From patchwork Thu Sep 14 15:26:11 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Suren Baghdasaryan X-Patchwork-Id: 13385625 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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id A3FC4EEAA51 for ; Thu, 14 Sep 2023 15:26:30 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id EB0CE6B02BE; Thu, 14 Sep 2023 11:26:29 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id E61066B02C0; Thu, 14 Sep 2023 11:26:29 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id D01716B02C1; Thu, 14 Sep 2023 11:26:29 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0014.hostedemail.com [216.40.44.14]) by kanga.kvack.org (Postfix) with ESMTP id C01DD6B02BE for ; Thu, 14 Sep 2023 11:26:29 -0400 (EDT) Received: from smtpin23.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay01.hostedemail.com (Postfix) with ESMTP id A2FA51CA086 for ; Thu, 14 Sep 2023 15:26:29 +0000 (UTC) X-FDA: 81235579698.23.2AC5451 Received: from mail-yb1-f202.google.com (mail-yb1-f202.google.com [209.85.219.202]) by imf05.hostedemail.com (Postfix) with ESMTP id D9DF2100009 for ; Thu, 14 Sep 2023 15:26:27 +0000 (UTC) Authentication-Results: imf05.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=ICTR85Sk; spf=pass (imf05.hostedemail.com: domain of 3IiYDZQYKCKkbdaNWKPXXPUN.LXVURWdg-VVTeJLT.XaP@flex--surenb.bounces.google.com designates 209.85.219.202 as permitted sender) smtp.mailfrom=3IiYDZQYKCKkbdaNWKPXXPUN.LXVURWdg-VVTeJLT.XaP@flex--surenb.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1694705187; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=szuJNW0JYA8v41wMmDUwFhK5OZ9EO2QBXA4Fv3dKB/g=; b=ve8NJTZ0D7RgWma7H3+YNFD+hKsRZPubY8p2E9lIWqGmt80f/SscvXPjXe0E8hgPCOQ0HX nOiGr7/hxMbIsZ+J1OLI9LgeRqaBw1xjXuu+irFRm5c5VwhJBR2tGgrjLzA8MsXzIHhC7M x8sWKftf0oUOImpuBHZ3uVEjtIhsbGI= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1694705187; a=rsa-sha256; cv=none; b=WdTVt/piVM3rwr2S0xYiFlIBqxw4My7ZaUIeiuD9NBE+zs/r6+NHb7mlEUTYOcC2yaoaat arRnSu8gMuQ+6CnP552WW6/g7BAFSfFBTzHoyqQ0B8OynR5eRxZMdyVs+stzRihmpPGH+q PZpjNrjnjkmPnQMYREiZ6iHfXBBhZ50= ARC-Authentication-Results: i=1; imf05.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=ICTR85Sk; spf=pass (imf05.hostedemail.com: domain of 3IiYDZQYKCKkbdaNWKPXXPUN.LXVURWdg-VVTeJLT.XaP@flex--surenb.bounces.google.com designates 209.85.219.202 as permitted sender) smtp.mailfrom=3IiYDZQYKCKkbdaNWKPXXPUN.LXVURWdg-VVTeJLT.XaP@flex--surenb.bounces.google.com; dmarc=pass (policy=reject) header.from=google.com Received: by mail-yb1-f202.google.com with SMTP id 3f1490d57ef6-d814105dc2cso1379600276.2 for ; Thu, 14 Sep 2023 08:26:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1694705187; x=1695309987; darn=kvack.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=szuJNW0JYA8v41wMmDUwFhK5OZ9EO2QBXA4Fv3dKB/g=; b=ICTR85SkrmxbNJixf1+DDkArkQ4fnbX4N9bXsz86zwJRq6AP/CGobQbXVoLIwDUraS Pli9MFYF36d0FVBOUpYNRZOaOQ5kE3KUhvehwz8hYryeMW22S/7apqmSyTTJtMwRQzI8 hoNGDTlYA6fTdVWPf91cbBaFiCyyraSx0yZKwzhINNnJuFWacZn6IJzveo5WeG+/hyOG t5yTdHRRm52JxdgDHoCGC2Hab1n1T+Nj2MJr5zwS2FHAC3FIh0J2BeC5YGfCIkUkJfst AgXCy/kuONOQEd50ot5hjG2dDLjuIxalyJQHva3xOWkYU3Ojgkj8wetDRhmT6NewWt45 wBng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1694705187; x=1695309987; 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=szuJNW0JYA8v41wMmDUwFhK5OZ9EO2QBXA4Fv3dKB/g=; b=amrpRVZyo67llWwtCPXbYxLPcj4bBqS0cNoP4T9tYX2Il/8OwFeWMkv68N1xt3uakA b3aR1WodF1rcMWHyGikthl3uxqKe8oSsljNc7fqTKMAKHWCtlsGD7pQDUYM6YoKMvWB2 trXDpzb2f+/wN2N1KF8jr0Xapdx7vLrtjnlJQj20eHyhrSGn4L5aycRs6MNg5s/Jx8EZ K1wb7lxy5U5ZHoMA4s52ojiQILDy8lu+dI6GN0Rct65XNP5z5/jI8Xm5DhhY86c5rwem ybMk56NUawa55tgryYbNCwZVr4pp3zMc0mC6N35H2hYG08xkhQB3Tx5LjdnpoDBS3nPS ahxQ== X-Gm-Message-State: AOJu0YxPLYbcC5JYpEjhW/imtEBfxH9kt81C/MCJ9S12krTc97596oeM vNnX93UGdzRB57SHwfMY5kxYaIydiBQ= X-Google-Smtp-Source: AGHT+IEd5v61XzoVq0A62rwjSzBLodEWtJ0EzGsQ7diWTmRZrqfRIFz5ezY13wh1THs9a+DnBIwa+z8BazU= X-Received: from surenb-desktop.mtv.corp.google.com ([2620:15c:211:201:405c:ba64:810f:5fee]) (user=surenb job=sendgmr) by 2002:a25:b45:0:b0:d40:932e:f7b1 with SMTP id 66-20020a250b45000000b00d40932ef7b1mr128068ybl.7.1694705186976; Thu, 14 Sep 2023 08:26:26 -0700 (PDT) Date: Thu, 14 Sep 2023 08:26:11 -0700 In-Reply-To: <20230914152620.2743033-1-surenb@google.com> Mime-Version: 1.0 References: <20230914152620.2743033-1-surenb@google.com> X-Mailer: git-send-email 2.42.0.283.g2d96d420d3-goog Message-ID: <20230914152620.2743033-2-surenb@google.com> Subject: [PATCH 1/3] userfaultfd: UFFDIO_REMAP: rmap preparation From: Suren Baghdasaryan To: akpm@linux-foundation.org Cc: viro@zeniv.linux.org.uk, brauner@kernel.org, shuah@kernel.org, aarcange@redhat.com, lokeshgidra@google.com, peterx@redhat.com, david@redhat.com, hughd@google.com, mhocko@suse.com, axelrasmussen@google.com, rppt@kernel.org, willy@infradead.org, Liam.Howlett@oracle.com, jannh@google.com, zhangpeng362@huawei.com, bgeffon@google.com, kaleshsingh@google.com, ngeoffray@google.com, jdduke@google.com, surenb@google.com, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, kernel-team@android.com X-Stat-Signature: 1j9fsy7744g4hdd1ppfotoem5fk1bb1w X-Rspamd-Server: rspam10 X-Rspamd-Queue-Id: D9DF2100009 X-Rspam-User: X-HE-Tag: 1694705187-597234 X-HE-Meta: U2FsdGVkX18nCJ7V1X74M4J2+Z9jKUL/f6+8AnsC2r314fZ1olfv15KxaP5JFukdBiiDXe2OFZF7VwBmk3xgzF4P1JfiaWwAwGpmKH+O+tXTD+sLYclF+FeJhZUc5wol/YtWMcFp7RmnI1B+2lVoHatqpChn5VM4w87crdeLUSQSx2a8ZMwuv7fG9C9mA+UmFgFaTbIG5aplZ3e3mJk6ttEg1w1yA7vGMXoQUlTuIasNNPW+koXTNq/vYpWSMALO/fEVqK9P7dUQ3/HkmLh4RQKLOmpD7a02YeWvC66yxZFRo4qnq166xUCpsTP09fU5YMe0E2TA+ZAmviVtRy1jMx3TRSrfaVcKtmLdthap/S0DaJvV36JR6AkPK5V5IT5edgDHekXWXUW47i1YAgFcce86mLr58/7TXg5ucfGFKzzBDTtozPgshfWILH6jwaxhWR3bh8xfXF7m7dhhB3emKcZQ3IFz8wJTUWy1jYVO17FuCOr9QPsZ8qabA0wfqJe3ZqHepbx68AOSHwiXTXtIdSZpKAwv1IJCm3aNNDoZHSw0xftY/C4+PgnLPPTgIj0vs8il/ofM9nQSdM8zUpFaFZIGNvuTloac+ppDltk/MknRtq82Up7zlJdZck8k+ORJfXrKPtLRT5sD0f2eNl4iCXxRKaKl92pcKdiiUbgWmpFDoAziU20/LU4p0pv8X09pXaDYtvsNJDCX7wnZDuKj5c8cNIvBj/fq34q5W0qfZDSaamoUvXzRadfoQ/SBHuj1420szbswjWsQ8+KM2QJ/ZVnQkxy51ACmyVMQekhzQWp0CBVr+SrNQE6IRT/sIt5lYWGZBY8V8OsAQozeaNOhBAFSgy41zyKNLOvsYywGl6tkY0O1updQlKsx0IKOzQ8bBB8lDyXCY1CLYeOVC8lvLFJ/kpQhkuNT4oC9j3YZg1A194Cg3z2KRDVnzHc91J3sS1E5rvbxAvt1BjkWh1X w6z+6HZg ergm9D09aa01m+1mgyH7ZIP2w04UxhmHmqLRX+cspnC+iBmpBODAUPyLUO1pPSO5sTNFqvROWrBOh1moYe3hC/rDIJN/in+PCZfbXeNiSGGLX7JO1Cl093gpEG9hyEFk+S7dYYDYQGoR9FPpDv2+JSeiC1fobkn+nmXGe+Th7+S7mGuqKsnV+T0EmbmcsuRgSI0WEp1FZXHN/cVlM1Gh0JoEi1i0aqJEG3cPJimwEhX59/9dqZRlcLZ9WOTguRQiT+0Cw4zJYjVARn567SYb6wxVCOSbyVlZQbxw9JxZbTXrVTUCE6zBx1LeTbHVpgs3ub0NJ4dUKOmtj4UiY/CHqTUGTxxQsws0fArI0PV8PCLamXjS5J04EoRaDpGRrzkBjaT+F/byLVbK56BhTFhGRs2zMynOPpcFVpv3QFygbsdKe5RYDcUDKxg/wgAm8GFfQLQhevs3q+vJc/4mTxer025IhVnFrHL/s8SSHBu+aaCysJq83QD226WoucYlELYGLVi0MsbmiEwdXhH+7XCtiyBWbsm2tWeUDM0M1Op/TT4Vi9vMiRA3/JGu7+BC/SZmq2+oygx9aEerYUd+kkP5bPJKi3Cg7GvW/Ke82CHbihwTD2RQymIgB58fIqJ/bSlEwWmaL8YZ5DRx7RDWJ0yZfiql7hAsAie6OImuxXEWBGtGJAEk= X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: From: Andrea Arcangeli As far as the rmap code is concerned, UFFDIO_REMAP only alters the page->mapping and page->index. It does it while holding the page lock. However folio_referenced() is doing rmap walks without taking the folio lock first, so folio_lock_anon_vma_read() must be updated to re-check that the folio->mapping didn't change after we obtained the anon_vma read lock. UFFDIO_REMAP takes the anon_vma lock for writing before altering the folio->mapping, so if the folio->mapping is still the same after obtaining the anon_vma read lock (without the folio lock), the rmap walks can go ahead safely (and UFFDIO_REMAP will wait the rmap walk to complete before proceeding). UFFDIO_REMAP serializes against itself with the folio lock. All other places taking the anon_vma lock while holding the mmap_lock for writing, don't need to check if the folio->mapping has changed after taking the anon_vma lock, regardless of the folio lock, because UFFDIO_REMAP holds the mmap_lock for reading. There's one constraint enforced to allow this simplification: the source pages passed to UFFDIO_REMAP must be mapped only in one vma, but this constraint is an acceptable tradeoff for UFFDIO_REMAP users. The source addresses passed to UFFDIO_REMAP can be set as VM_DONTCOPY with MADV_DONTFORK to avoid any risk of the mapcount of the pages increasing if some thread of the process forks() before UFFDIO_REMAP run. Signed-off-by: Andrea Arcangeli Signed-off-by: Suren Baghdasaryan --- mm/rmap.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/mm/rmap.c b/mm/rmap.c index ec7f8e6c9e48..c1ebbd23fa61 100644 --- a/mm/rmap.c +++ b/mm/rmap.c @@ -542,6 +542,7 @@ struct anon_vma *folio_lock_anon_vma_read(struct folio *folio, struct anon_vma *root_anon_vma; unsigned long anon_mapping; +repeat: rcu_read_lock(); anon_mapping = (unsigned long)READ_ONCE(folio->mapping); if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON) @@ -586,6 +587,18 @@ struct anon_vma *folio_lock_anon_vma_read(struct folio *folio, rcu_read_unlock(); anon_vma_lock_read(anon_vma); + /* + * Check if UFFDIO_REMAP changed the anon_vma. This is needed + * because we don't assume the folio was locked. + */ + if (unlikely((unsigned long) READ_ONCE(folio->mapping) != + anon_mapping)) { + anon_vma_unlock_read(anon_vma); + put_anon_vma(anon_vma); + anon_vma = NULL; + goto repeat; + } + if (atomic_dec_and_test(&anon_vma->refcount)) { /* * Oops, we held the last refcount, release the lock From patchwork Thu Sep 14 15:26:12 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Suren Baghdasaryan X-Patchwork-Id: 13385627 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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id F1439EEAA57 for ; Thu, 14 Sep 2023 15:26:32 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 848586B02C1; Thu, 14 Sep 2023 11:26:32 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 7F75E6B02C2; Thu, 14 Sep 2023 11:26:32 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 5FCB36B02C3; Thu, 14 Sep 2023 11:26:32 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0010.hostedemail.com [216.40.44.10]) by kanga.kvack.org (Postfix) with ESMTP id 4B4A26B02C1 for ; Thu, 14 Sep 2023 11:26:32 -0400 (EDT) Received: from smtpin23.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 23201140CE4 for ; Thu, 14 Sep 2023 15:26:32 +0000 (UTC) X-FDA: 81235579824.23.74723E1 Received: from mail-yb1-f201.google.com (mail-yb1-f201.google.com [209.85.219.201]) by imf07.hostedemail.com (Postfix) with ESMTP id 1FC9240009 for ; Thu, 14 Sep 2023 15:26:29 +0000 (UTC) Authentication-Results: imf07.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=0GWV4hwQ; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf07.hostedemail.com: domain of 3JSYDZQYKCKwegdQZNSaaSXQ.OaYXUZgj-YYWhMOW.adS@flex--surenb.bounces.google.com designates 209.85.219.201 as permitted sender) smtp.mailfrom=3JSYDZQYKCKwegdQZNSaaSXQ.OaYXUZgj-YYWhMOW.adS@flex--surenb.bounces.google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1694705190; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=vKvQQhsOnQPOzJh/frUZToIv42f95olTu0FEXWLe57U=; b=c+6oPrvjnBYaO4DYilxrtdi9TTz1TzdJ9onySUL2PYXxS86yp74CXexrHep5EX4qgnxd/Q hW6vok3O0ZYqDobtKCwcpORowbOw9Trw0Y4bDZjTWqTyvzBxAPFh/HaDyrUtabizuWY+5j BemYEJaaON+4//TqVsHMUcYryOITGdo= ARC-Authentication-Results: i=1; imf07.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=0GWV4hwQ; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf07.hostedemail.com: domain of 3JSYDZQYKCKwegdQZNSaaSXQ.OaYXUZgj-YYWhMOW.adS@flex--surenb.bounces.google.com designates 209.85.219.201 as permitted sender) smtp.mailfrom=3JSYDZQYKCKwegdQZNSaaSXQ.OaYXUZgj-YYWhMOW.adS@flex--surenb.bounces.google.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1694705190; a=rsa-sha256; cv=none; b=8oH8Q2IUyyoWnJBlgS9UR5vKIMYvOERyYAw8Y5wCnIKonISXV3VnnbOw7ClK1rywQ/s1VF /LPQ71v4JgyBPsbUE2A9uTZr0LliG3We7o6wTcM5yEBBY0bi6ed0wV9HqxALSYw90ZA9UM 7lJrOe1tN6CGLsR510sI8KdW2PaqR/8= Received: by mail-yb1-f201.google.com with SMTP id 3f1490d57ef6-d814634fe4bso1399012276.1 for ; Thu, 14 Sep 2023 08:26:29 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1694705189; x=1695309989; darn=kvack.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=vKvQQhsOnQPOzJh/frUZToIv42f95olTu0FEXWLe57U=; b=0GWV4hwQv6m2wlKkC1qT5mvyu7C3SE01tbAvxZdZFV85cJo3Qg5rp6QSHi2/udQ4jL cpXgX6OpmmMyOj+0OVIPZf8aDWi7ZN0dMuVRTwMqtta4WoFZdS6MzHehvQMsg3KEdtHb H6H42yKE83PTV55Q58ICvACQzTma11CO53fO81o4J7PmbLmSvncf//XUTHm6Gs5XC1kV xidYUvFfO7vK8tur7UwBmMFnbjUqpTFSZytm9yIEFuLow/iCGgPRb6S5SUnG4zNoye1O 1vDFkRUuZplJfagn90flEDbSUu4iM418VFVADJ4tlQ2zZS3n8zGjuvLLtIDqtZ1gJ5bR fYgw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1694705189; x=1695309989; 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=vKvQQhsOnQPOzJh/frUZToIv42f95olTu0FEXWLe57U=; b=infZUt3nfIox36FfyQPQ8qnrVFFmq6PMxbEsfvqV+J9lO/0VfIc0jeCYmtVP/V5Poh nUMCfAI/iNItYj8or6Qs+X5il1Fyj05ki0Hs6o5uwpUtkbt8H1b/Xf/+xF1WgcLYXIc2 HoDHruMVmvfsB/AEuFJ6zYuUe4IDZ58JONoPWGx+yxi5Sn4vb7i/WbeE/D9KtsNamuxd Fsbm1HiUU8eScEde+1wz7ExHJWH7pipzU0VxNQxoUIlv7bIMyWeQuGYFuhPqV6kDmCCK brUw2qrq29X3lUtpYYmk4062/frX//RQpPT1GNyTrVE/z3BfPdf1oFCujGH/KTU8UuzS bxWw== X-Gm-Message-State: AOJu0YwSH13MpjHmWGjFwnVc1qUw7OziqwUpVvPhvZj//E7cEmJL57bQ tZTUlK6wL9bODW5vbFgo2uz3QfZW+co= X-Google-Smtp-Source: AGHT+IErdl3j36auryaEBKVPOGsZPU+Tafg4HOMgPdqMXZU76tdGjcbI+FRFD2o1NozLAqa0MWiVrErJLoU= X-Received: from surenb-desktop.mtv.corp.google.com ([2620:15c:211:201:405c:ba64:810f:5fee]) (user=surenb job=sendgmr) by 2002:a25:aa83:0:b0:d77:984e:c770 with SMTP id t3-20020a25aa83000000b00d77984ec770mr131612ybi.5.1694705189263; Thu, 14 Sep 2023 08:26:29 -0700 (PDT) Date: Thu, 14 Sep 2023 08:26:12 -0700 In-Reply-To: <20230914152620.2743033-1-surenb@google.com> Mime-Version: 1.0 References: <20230914152620.2743033-1-surenb@google.com> X-Mailer: git-send-email 2.42.0.283.g2d96d420d3-goog Message-ID: <20230914152620.2743033-3-surenb@google.com> Subject: [PATCH 2/3] userfaultfd: UFFDIO_REMAP uABI From: Suren Baghdasaryan To: akpm@linux-foundation.org Cc: viro@zeniv.linux.org.uk, brauner@kernel.org, shuah@kernel.org, aarcange@redhat.com, lokeshgidra@google.com, peterx@redhat.com, david@redhat.com, hughd@google.com, mhocko@suse.com, axelrasmussen@google.com, rppt@kernel.org, willy@infradead.org, Liam.Howlett@oracle.com, jannh@google.com, zhangpeng362@huawei.com, bgeffon@google.com, kaleshsingh@google.com, ngeoffray@google.com, jdduke@google.com, surenb@google.com, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, kernel-team@android.com X-Rspamd-Queue-Id: 1FC9240009 X-Rspam-User: X-Rspamd-Server: rspam02 X-Stat-Signature: nddqpboo8k3fddthetpakkeecefwry37 X-HE-Tag: 1694705189-178257 X-HE-Meta: U2FsdGVkX1/+WM9Zfn9Jsi5iBblIpXtuB4RMruc/hRcjxrrVbBIZuzBm46Sn3LhZGjMjCiusdIoBPYq6R+R6NF4Dzf59uBLvu9+iBsmvdSzy9RC105dKbzKlkVxYJf9TjjuggDO+sNKYAX6BYR3qMGNoNPTx0fyreTtmwTt4rRYbbDh76TqAuJys7Fvok0ZqXrKYnrrFtj2a4BW2NPO6WBvdBalY3M+Hnra1Ko/qk2PP3d/fb6G2q7ZVvyIyKiYCAvT5s/gy2Fbw/QfQNA6i8/hQ/n9fdJ3Cgx67mAMRww2IGy5+1VIjAoQN23zuNsN99j0HuOvrke4yoeV4pM3AfPJjIqEXsKAq+vqBOcB6SsQa4qwoc2NMCxXx9HNvhcolPJzwqMPLxvD3iSEzD9YH39d2Nf0p6aY8ZqwacBCSpmu1zAsN0Uq5MMz3P2kVJ2NnpNAhHFIPxzGOMunoMSYVgjmTMVVtGmR7nmhFBl0SRqz4w085aF9E2Z1w5Ab0uYukLO805Xh/oBf2K8Ro6KPMm6+ybd3IJt/sm59edWwxfGu11lcNCer/tHvx39wfN92EwnUkIgHv2vgaF7A4sdZvhCu+LPiR69orfsUos9aNKQZanWO1lm/dZakXTQVrh3vSnXK5Bf0k/n/THJoayHujZ+sxaBWey1sOt9PuyaS+KIkAXsFK1UwvAJ4ARs0LAAd+qo9ICS1cAC7I438AwEi6oeimMT6ZL0x3+gp7D63BS52pLkGkdMX4Q1wr+TyyixXLMdIkp4ec7aFraBOWYTRwmdy1xI6karoILXFU7hiro0nJCkcvjKCV/TsDtnOwbxKy/B2f0wmH2xgicExfhU5RpDNF2kA3a9zHsG9BzcdRs0SrS5+McThvC+/19wS0WfAjD0/qC0cOywr9dZq81/5eMbyi91dFH8GDJzJFLW5JnyN0TSWWW4xYdZ1+f6e/SP40pg+19jvgh8T5MfYnSgW vS0J369Z nDTL64Q+HgyE4OqN5UfFlA7f3yIzY3ETRFUcrudyVhhyI+22fUyliFbL5ck9MHn7iTqh81M9VBRPMEdp/vSgRCHvTZq/LysNHhYAxHAoa47UsxeDnCitJAJMNMzVdnrXyR7LYtxtaFR/IMvsnk0iH31Q+52K+bxdyqZH3PnpS2UqwhMpnf4mzKs5905EJO35lyQyth9VeytEFPvWmTocFHdOqeL4+ehGWYEh/DqnxbGgXJLlnLeUFepTfFvTDzZCmOmQmchFmBx+1IBX91RhVFlQH4sgbWjYUGZZHS6r8M+AtO5AM0JnV2NTQUygsBtCPr+LsCovM5XIJVWpdi1DA/YwiwAKfXt/I+9unS4k1ojxTIAI5XHru2SqavPiEFZ6ut67bN2GPH4M7y8u2ZWL8fJ9PdXOJD/q4O64CBlXoavNw176hjrOdIqINnKDlKqfZlo25b/LqbhJRCASjQu6Ym/gLJnfhsnN1laiVh9Gzh0q6+PKozgTnzHI2pxAJ24Rztqr3dSyqyJ5mCnKf6GPg7JdqDSASGGN3ijvwigGi2damR3QTVhPqxoyCyWUMW1fUNP322Nh2hGzhFuoeRgoZ19hw/VxbX0Bt+qmfbN3PIrqP8E9hhaYwucvLPutduo9t5MiRJLE8G9ouUbm7S4kJBBELK4La2t8B/aMsX6vFgZodk2kHewx/G2MZoQ== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: From: Andrea Arcangeli This implements the uABI of UFFDIO_REMAP. Notably one mode bitflag is also forwarded (and in turn known) by the lowlevel remap_pages method. Signed-off-by: Andrea Arcangeli Signed-off-by: Suren Baghdasaryan --- fs/userfaultfd.c | 49 +++ include/linux/rmap.h | 5 + include/linux/userfaultfd_k.h | 17 + include/uapi/linux/userfaultfd.h | 22 ++ mm/huge_memory.c | 118 +++++++ mm/khugepaged.c | 3 + mm/userfaultfd.c | 586 +++++++++++++++++++++++++++++++ 7 files changed, 800 insertions(+) diff --git a/fs/userfaultfd.c b/fs/userfaultfd.c index 56eaae9dac1a..7bf64e7541c1 100644 --- a/fs/userfaultfd.c +++ b/fs/userfaultfd.c @@ -2027,6 +2027,52 @@ static inline unsigned int uffd_ctx_features(__u64 user_features) return (unsigned int)user_features | UFFD_FEATURE_INITIALIZED; } +static int userfaultfd_remap(struct userfaultfd_ctx *ctx, + unsigned long arg) +{ + __s64 ret; + struct uffdio_remap uffdio_remap; + struct uffdio_remap __user *user_uffdio_remap; + struct userfaultfd_wake_range range; + + user_uffdio_remap = (struct uffdio_remap __user *) arg; + + ret = -EFAULT; + if (copy_from_user(&uffdio_remap, user_uffdio_remap, + /* don't copy "remap" last field */ + sizeof(uffdio_remap)-sizeof(__s64))) + goto out; + + ret = validate_range(ctx->mm, uffdio_remap.dst, uffdio_remap.len); + if (ret) + goto out; + ret = validate_range(current->mm, uffdio_remap.src, uffdio_remap.len); + if (ret) + goto out; + ret = -EINVAL; + if (uffdio_remap.mode & ~(UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES| + UFFDIO_REMAP_MODE_DONTWAKE)) + goto out; + + ret = remap_pages(ctx->mm, current->mm, + uffdio_remap.dst, uffdio_remap.src, + uffdio_remap.len, uffdio_remap.mode); + if (unlikely(put_user(ret, &user_uffdio_remap->remap))) + return -EFAULT; + if (ret < 0) + goto out; + /* len == 0 would wake all */ + BUG_ON(!ret); + range.len = ret; + if (!(uffdio_remap.mode & UFFDIO_REMAP_MODE_DONTWAKE)) { + range.start = uffdio_remap.dst; + wake_userfault(ctx, &range); + } + ret = range.len == uffdio_remap.len ? 0 : -EAGAIN; +out: + return ret; +} + /* * userland asks for a certain API version and we return which bits * and ioctl commands are implemented in this kernel for such API @@ -2113,6 +2159,9 @@ static long userfaultfd_ioctl(struct file *file, unsigned cmd, case UFFDIO_ZEROPAGE: ret = userfaultfd_zeropage(ctx, arg); break; + case UFFDIO_REMAP: + ret = userfaultfd_remap(ctx, arg); + break; case UFFDIO_WRITEPROTECT: ret = userfaultfd_writeprotect(ctx, arg); break; diff --git a/include/linux/rmap.h b/include/linux/rmap.h index 51cc21ebb568..614c4b439907 100644 --- a/include/linux/rmap.h +++ b/include/linux/rmap.h @@ -121,6 +121,11 @@ static inline void anon_vma_lock_write(struct anon_vma *anon_vma) down_write(&anon_vma->root->rwsem); } +static inline int anon_vma_trylock_write(struct anon_vma *anon_vma) +{ + return down_write_trylock(&anon_vma->root->rwsem); +} + static inline void anon_vma_unlock_write(struct anon_vma *anon_vma) { up_write(&anon_vma->root->rwsem); diff --git a/include/linux/userfaultfd_k.h b/include/linux/userfaultfd_k.h index ac8c6854097c..2bc807dc390b 100644 --- a/include/linux/userfaultfd_k.h +++ b/include/linux/userfaultfd_k.h @@ -93,6 +93,23 @@ extern int mwriteprotect_range(struct mm_struct *dst_mm, extern long uffd_wp_range(struct vm_area_struct *vma, unsigned long start, unsigned long len, bool enable_wp); +/* remap_pages */ +extern void double_pt_lock(spinlock_t *ptl1, spinlock_t *ptl2); +extern void double_pt_unlock(spinlock_t *ptl1, spinlock_t *ptl2); +extern ssize_t remap_pages(struct mm_struct *dst_mm, + struct mm_struct *src_mm, + unsigned long dst_start, + unsigned long src_start, + unsigned long len, __u64 flags); +extern int remap_pages_huge_pmd(struct mm_struct *dst_mm, + struct mm_struct *src_mm, + pmd_t *dst_pmd, pmd_t *src_pmd, + pmd_t dst_pmdval, + struct vm_area_struct *dst_vma, + struct vm_area_struct *src_vma, + unsigned long dst_addr, + unsigned long src_addr); + /* mm helpers */ static inline bool is_mergeable_vm_userfaultfd_ctx(struct vm_area_struct *vma, struct vm_userfaultfd_ctx vm_ctx) diff --git a/include/uapi/linux/userfaultfd.h b/include/uapi/linux/userfaultfd.h index 62151706c5a3..22d1c43e39f9 100644 --- a/include/uapi/linux/userfaultfd.h +++ b/include/uapi/linux/userfaultfd.h @@ -49,6 +49,7 @@ ((__u64)1 << _UFFDIO_WAKE | \ (__u64)1 << _UFFDIO_COPY | \ (__u64)1 << _UFFDIO_ZEROPAGE | \ + (__u64)1 << _UFFDIO_REMAP | \ (__u64)1 << _UFFDIO_WRITEPROTECT | \ (__u64)1 << _UFFDIO_CONTINUE | \ (__u64)1 << _UFFDIO_POISON) @@ -72,6 +73,7 @@ #define _UFFDIO_WAKE (0x02) #define _UFFDIO_COPY (0x03) #define _UFFDIO_ZEROPAGE (0x04) +#define _UFFDIO_REMAP (0x05) #define _UFFDIO_WRITEPROTECT (0x06) #define _UFFDIO_CONTINUE (0x07) #define _UFFDIO_POISON (0x08) @@ -91,6 +93,8 @@ struct uffdio_copy) #define UFFDIO_ZEROPAGE _IOWR(UFFDIO, _UFFDIO_ZEROPAGE, \ struct uffdio_zeropage) +#define UFFDIO_REMAP _IOWR(UFFDIO, _UFFDIO_REMAP, \ + struct uffdio_remap) #define UFFDIO_WRITEPROTECT _IOWR(UFFDIO, _UFFDIO_WRITEPROTECT, \ struct uffdio_writeprotect) #define UFFDIO_CONTINUE _IOWR(UFFDIO, _UFFDIO_CONTINUE, \ @@ -340,6 +344,24 @@ struct uffdio_poison { __s64 updated; }; +struct uffdio_remap { + __u64 dst; + __u64 src; + __u64 len; + /* + * Especially if used to atomically remove memory from the + * address space the wake on the dst range is not needed. + */ +#define UFFDIO_REMAP_MODE_DONTWAKE ((__u64)1<<0) +#define UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES ((__u64)1<<1) + __u64 mode; + /* + * "remap" is written by the ioctl and must be at the end: the + * copy_from_user will not read the last 8 bytes. + */ + __s64 remap; +}; + /* * Flags for the userfaultfd(2) system call itself. */ diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 064fbd90822b..c7a9880a1f6a 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -1932,6 +1932,124 @@ int change_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, return ret; } +#ifdef CONFIG_USERFAULTFD +/* + * The PT lock for src_pmd and the mmap_lock for reading are held by + * the caller, but it must return after releasing the + * page_table_lock. We're guaranteed the src_pmd is a pmd_trans_huge + * until the PT lock of the src_pmd is released. Just move the page + * from src_pmd to dst_pmd if possible. Return zero if succeeded in + * moving the page, -EAGAIN if it needs to be repeated by the caller, + * or other errors in case of failure. + */ +int remap_pages_huge_pmd(struct mm_struct *dst_mm, + struct mm_struct *src_mm, + pmd_t *dst_pmd, pmd_t *src_pmd, + pmd_t dst_pmdval, + struct vm_area_struct *dst_vma, + struct vm_area_struct *src_vma, + unsigned long dst_addr, + unsigned long src_addr) +{ + pmd_t _dst_pmd, src_pmdval; + struct page *src_page; + struct anon_vma *src_anon_vma, *dst_anon_vma; + spinlock_t *src_ptl, *dst_ptl; + pgtable_t pgtable; + struct mmu_notifier_range range; + + src_pmdval = *src_pmd; + src_ptl = pmd_lockptr(src_mm, src_pmd); + + BUG_ON(!pmd_trans_huge(src_pmdval)); + BUG_ON(!pmd_none(dst_pmdval)); + BUG_ON(!spin_is_locked(src_ptl)); + mmap_assert_locked(src_mm); + mmap_assert_locked(dst_mm); + BUG_ON(src_addr & ~HPAGE_PMD_MASK); + BUG_ON(dst_addr & ~HPAGE_PMD_MASK); + + src_page = pmd_page(src_pmdval); + BUG_ON(!PageHead(src_page)); + BUG_ON(!PageAnon(src_page)); + if (unlikely(page_mapcount(src_page) != 1)) { + spin_unlock(src_ptl); + return -EBUSY; + } + + get_page(src_page); + spin_unlock(src_ptl); + + mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, src_mm, src_addr, + src_addr + HPAGE_PMD_SIZE); + mmu_notifier_invalidate_range_start(&range); + + /* block all concurrent rmap walks */ + lock_page(src_page); + + /* + * split_huge_page walks the anon_vma chain without the page + * lock. Serialize against it with the anon_vma lock, the page + * lock is not enough. + */ + src_anon_vma = folio_get_anon_vma(page_folio(src_page)); + if (!src_anon_vma) { + unlock_page(src_page); + put_page(src_page); + mmu_notifier_invalidate_range_end(&range); + return -EAGAIN; + } + anon_vma_lock_write(src_anon_vma); + + dst_ptl = pmd_lockptr(dst_mm, dst_pmd); + double_pt_lock(src_ptl, dst_ptl); + if (unlikely(!pmd_same(*src_pmd, src_pmdval) || + !pmd_same(*dst_pmd, dst_pmdval) || + page_mapcount(src_page) != 1)) { + double_pt_unlock(src_ptl, dst_ptl); + anon_vma_unlock_write(src_anon_vma); + put_anon_vma(src_anon_vma); + unlock_page(src_page); + put_page(src_page); + mmu_notifier_invalidate_range_end(&range); + return -EAGAIN; + } + + BUG_ON(!PageHead(src_page)); + BUG_ON(!PageAnon(src_page)); + /* the PT lock is enough to keep the page pinned now */ + put_page(src_page); + + dst_anon_vma = (void *) dst_vma->anon_vma + PAGE_MAPPING_ANON; + WRITE_ONCE(src_page->mapping, (struct address_space *) dst_anon_vma); + WRITE_ONCE(src_page->index, linear_page_index(dst_vma, dst_addr)); + + if (!pmd_same(pmdp_huge_clear_flush(src_vma, src_addr, src_pmd), + src_pmdval)) + BUG_ON(1); + _dst_pmd = mk_huge_pmd(src_page, dst_vma->vm_page_prot); + _dst_pmd = maybe_pmd_mkwrite(pmd_mkdirty(_dst_pmd), dst_vma); + set_pmd_at(dst_mm, dst_addr, dst_pmd, _dst_pmd); + + pgtable = pgtable_trans_huge_withdraw(src_mm, src_pmd); + pgtable_trans_huge_deposit(dst_mm, dst_pmd, pgtable); + if (dst_mm != src_mm) { + add_mm_counter(dst_mm, MM_ANONPAGES, HPAGE_PMD_NR); + add_mm_counter(src_mm, MM_ANONPAGES, -HPAGE_PMD_NR); + } + double_pt_unlock(src_ptl, dst_ptl); + + anon_vma_unlock_write(src_anon_vma); + put_anon_vma(src_anon_vma); + + /* unblock rmap walks */ + unlock_page(src_page); + + mmu_notifier_invalidate_range_end(&range); + return 0; +} +#endif /* CONFIG_USERFAULTFD */ + /* * Returns page table lock pointer if a given pmd maps a thp, NULL otherwise. * diff --git a/mm/khugepaged.c b/mm/khugepaged.c index 88433cc25d8a..af23248b3551 100644 --- a/mm/khugepaged.c +++ b/mm/khugepaged.c @@ -1135,6 +1135,9 @@ static int collapse_huge_page(struct mm_struct *mm, unsigned long address, * Prevent all access to pagetables with the exception of * gup_fast later handled by the ptep_clear_flush and the VM * handled by the anon_vma lock + PG_lock. + * + * UFFDIO_REMAP is prevented to race as well thanks to the + * mmap_lock. */ mmap_write_lock(mm); result = hugepage_vma_revalidate(mm, address, true, &vma, cc); diff --git a/mm/userfaultfd.c b/mm/userfaultfd.c index 96d9eae5c7cc..0cca60dfa8f8 100644 --- a/mm/userfaultfd.c +++ b/mm/userfaultfd.c @@ -842,3 +842,589 @@ int mwriteprotect_range(struct mm_struct *dst_mm, unsigned long start, mmap_read_unlock(dst_mm); return err; } + + +void double_pt_lock(spinlock_t *ptl1, + spinlock_t *ptl2) + __acquires(ptl1) + __acquires(ptl2) +{ + spinlock_t *ptl_tmp; + + if (ptl1 > ptl2) { + /* exchange ptl1 and ptl2 */ + ptl_tmp = ptl1; + ptl1 = ptl2; + ptl2 = ptl_tmp; + } + /* lock in virtual address order to avoid lock inversion */ + spin_lock(ptl1); + if (ptl1 != ptl2) + spin_lock_nested(ptl2, SINGLE_DEPTH_NESTING); + else + __acquire(ptl2); +} + +void double_pt_unlock(spinlock_t *ptl1, + spinlock_t *ptl2) + __releases(ptl1) + __releases(ptl2) +{ + spin_unlock(ptl1); + if (ptl1 != ptl2) + spin_unlock(ptl2); + else + __release(ptl2); +} + +/* + * The mmap_lock for reading is held by the caller. Just move the page + * from src_pmd to dst_pmd if possible, and return true if succeeded + * in moving the page. + */ +static int remap_pages_pte(struct mm_struct *dst_mm, + struct mm_struct *src_mm, + pmd_t *dst_pmd, + pmd_t *src_pmd, + struct vm_area_struct *dst_vma, + struct vm_area_struct *src_vma, + unsigned long dst_addr, + unsigned long src_addr, + __u64 mode) +{ + swp_entry_t entry; + pte_t orig_src_pte, orig_dst_pte; + spinlock_t *src_ptl, *dst_ptl; + pte_t *src_pte = NULL; + pte_t *dst_pte = NULL; + + struct folio *src_folio = NULL; + struct anon_vma *src_anon_vma = NULL; + struct anon_vma *dst_anon_vma; + struct mmu_notifier_range range; + int err = 0; + +retry: + dst_pte = pte_offset_map_nolock(dst_mm, dst_pmd, dst_addr, &dst_ptl); + + /* If an huge pmd materialized from under us fail */ + if (unlikely(!dst_pte)) { + err = -EFAULT; + goto out; + } + + src_pte = pte_offset_map_nolock(src_mm, src_pmd, src_addr, &src_ptl); + + /* + * We held the mmap_lock for reading so MADV_DONTNEED + * can zap transparent huge pages under us, or the + * transparent huge page fault can establish new + * transparent huge pages under us. + */ + if (unlikely(!src_pte)) { + err = -EFAULT; + goto out; + } + + BUG_ON(pmd_none(*dst_pmd)); + BUG_ON(pmd_none(*src_pmd)); + BUG_ON(pmd_trans_huge(*dst_pmd)); + BUG_ON(pmd_trans_huge(*src_pmd)); + + spin_lock(dst_ptl); + orig_dst_pte = *dst_pte; + spin_unlock(dst_ptl); + if (!pte_none(orig_dst_pte)) { + err = -EEXIST; + goto out; + } + + spin_lock(src_ptl); + orig_src_pte = *src_pte; + spin_unlock(src_ptl); + if (pte_none(orig_src_pte)) { + if (!(mode & UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES)) + err = -ENOENT; + else /* nothing to do to remap a hole */ + err = 0; + goto out; + } + + if (pte_present(orig_src_pte)) { + if (!src_folio) { + struct folio *folio; + + /* + * Pin the page while holding the lock to be sure the + * page isn't freed under us + */ + spin_lock(src_ptl); + if (!pte_same(orig_src_pte, *src_pte)) { + spin_unlock(src_ptl); + err = -EAGAIN; + goto out; + } + + folio = vm_normal_folio(src_vma, src_addr, orig_src_pte); + if (!folio || !folio_test_anon(folio) || + folio_estimated_sharers(folio) != 1) { + spin_unlock(src_ptl); + err = -EBUSY; + goto out; + } + + src_folio = folio; + folio_get(src_folio); + spin_unlock(src_ptl); + + /* try to block all concurrent rmap walks */ + if (!folio_trylock(src_folio)) { + pte_unmap(&orig_src_pte); + pte_unmap(&orig_dst_pte); + src_pte = dst_pte = NULL; + folio_lock(src_folio); + goto retry; + } + } + + if (!src_anon_vma) { + /* + * folio_referenced walks the anon_vma chain + * without the folio lock. Serialize against it with + * the anon_vma lock, the folio lock is not enough. + */ + src_anon_vma = folio_get_anon_vma(src_folio); + if (!src_anon_vma) { + /* page was unmapped from under us */ + err = -EAGAIN; + goto out; + } + if (!anon_vma_trylock_write(src_anon_vma)) { + pte_unmap(&orig_src_pte); + pte_unmap(&orig_dst_pte); + src_pte = dst_pte = NULL; + anon_vma_lock_write(src_anon_vma); + goto retry; + } + } + + mmu_notifier_range_init(&range, MMU_NOTIFY_CLEAR, 0, src_mm, + src_addr, src_addr + PAGE_SIZE); + mmu_notifier_invalidate_range_start_nonblock(&range); + + double_pt_lock(dst_ptl, src_ptl); + + if (!pte_same(*src_pte, orig_src_pte) || + !pte_same(*dst_pte, orig_dst_pte) || + folio_estimated_sharers(src_folio) != 1) { + double_pt_unlock(dst_ptl, src_ptl); + err = -EAGAIN; + goto out; + } + + BUG_ON(!folio_test_anon(src_folio)); + /* the PT lock is enough to keep the page pinned now */ + folio_put(src_folio); + + dst_anon_vma = (void *) dst_vma->anon_vma + PAGE_MAPPING_ANON; + WRITE_ONCE(src_folio->mapping, + (struct address_space *) dst_anon_vma); + WRITE_ONCE(src_folio->index, linear_page_index(dst_vma, + dst_addr)); + + if (!pte_same(ptep_clear_flush(src_vma, src_addr, src_pte), + orig_src_pte)) + BUG_ON(1); + + orig_dst_pte = mk_pte(&src_folio->page, dst_vma->vm_page_prot); + orig_dst_pte = maybe_mkwrite(pte_mkdirty(orig_dst_pte), + dst_vma); + + set_pte_at(dst_mm, dst_addr, dst_pte, orig_dst_pte); + + if (dst_mm != src_mm) { + inc_mm_counter(dst_mm, MM_ANONPAGES); + dec_mm_counter(src_mm, MM_ANONPAGES); + } + + double_pt_unlock(dst_ptl, src_ptl); + + anon_vma_unlock_write(src_anon_vma); + mmu_notifier_invalidate_range_end(&range); + put_anon_vma(src_anon_vma); + src_anon_vma = NULL; + + /* unblock rmap walks */ + folio_unlock(src_folio); + src_folio = NULL; + + } else { + struct swap_info_struct *si; + int swap_count; + + entry = pte_to_swp_entry(orig_src_pte); + if (non_swap_entry(entry)) { + if (is_migration_entry(entry)) { + pte_unmap(&orig_src_pte); + pte_unmap(&orig_dst_pte); + src_pte = dst_pte = NULL; + migration_entry_wait(src_mm, src_pmd, + src_addr); + err = -EAGAIN; + } else + err = -EFAULT; + goto out; + } + + /* + * COUNT_CONTINUE to be returned is fine here, no need + * of follow all swap continuation to check against + * number 1. + */ + si = get_swap_device(entry); + if (!si) { + err = -EBUSY; + goto out; + } + + swap_count = swap_swapcount(si, entry); + put_swap_device(si); + if (swap_count != 1) { + err = -EBUSY; + goto out; + } + + double_pt_lock(dst_ptl, src_ptl); + + if (!pte_same(*src_pte, orig_src_pte) || + !pte_same(*dst_pte, orig_dst_pte) || + swp_swapcount(entry) != 1) { + double_pt_unlock(dst_ptl, src_ptl); + err = -EAGAIN; + goto out; + } + + if (pte_val(ptep_get_and_clear(src_mm, src_addr, src_pte)) != + pte_val(orig_src_pte)) + BUG_ON(1); + set_pte_at(dst_mm, dst_addr, dst_pte, orig_src_pte); + + if (dst_mm != src_mm) { + inc_mm_counter(dst_mm, MM_ANONPAGES); + dec_mm_counter(src_mm, MM_ANONPAGES); + } + + double_pt_unlock(dst_ptl, src_ptl); + } + +out: + if (src_anon_vma) { + anon_vma_unlock_write(src_anon_vma); + put_anon_vma(src_anon_vma); + } + if (src_folio) { + folio_unlock(src_folio); + folio_put(src_folio); + } + if (dst_pte) + pte_unmap(dst_pte); + if (src_pte) + pte_unmap(src_pte); + + return err; +} + +/** + * remap_pages - remap arbitrary anonymous pages of an existing vma + * @dst_start: start of the destination virtual memory range + * @src_start: start of the source virtual memory range + * @len: length of the virtual memory range + * + * remap_pages() remaps arbitrary anonymous pages atomically in zero + * copy. It only works on non shared anonymous pages because those can + * be relocated without generating non linear anon_vmas in the rmap + * code. + * + * It provides a zero copy mechanism to handle userspace page faults. + * The source vma pages should have mapcount == 1, which can be + * enforced by using madvise(MADV_DONTFORK) on src vma. + * + * The thread receiving the page during the userland page fault + * will receive the faulting page in the source vma through the network, + * storage or any other I/O device (MADV_DONTFORK in the source vma + * avoids remap_pages() to fail with -EBUSY if the process forks before + * remap_pages() is called), then it will call remap_pages() to map the + * page in the faulting address in the destination vma. + * + * This userfaultfd command works purely via pagetables, so it's the + * most efficient way to move physical non shared anonymous pages + * across different virtual addresses. Unlike mremap()/mmap()/munmap() + * it does not create any new vmas. The mapping in the destination + * address is atomic. + * + * It only works if the vma protection bits are identical from the + * source and destination vma. + * + * It can remap non shared anonymous pages within the same vma too. + * + * If the source virtual memory range has any unmapped holes, or if + * the destination virtual memory range is not a whole unmapped hole, + * remap_pages() will fail respectively with -ENOENT or -EEXIST. This + * provides a very strict behavior to avoid any chance of memory + * corruption going unnoticed if there are userland race conditions. + * Only one thread should resolve the userland page fault at any given + * time for any given faulting address. This means that if two threads + * try to both call remap_pages() on the same destination address at the + * same time, the second thread will get an explicit error from this + * command. + * + * The command retval will return "len" is successful. The command + * however can be interrupted by fatal signals or errors. If + * interrupted it will return the number of bytes successfully + * remapped before the interruption if any, or the negative error if + * none. It will never return zero. Either it will return an error or + * an amount of bytes successfully moved. If the retval reports a + * "short" remap, the remap_pages() command should be repeated by + * userland with src+retval, dst+reval, len-retval if it wants to know + * about the error that interrupted it. + * + * The UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES flag can be specified to + * prevent -ENOENT errors to materialize if there are holes in the + * source virtual range that is being remapped. The holes will be + * accounted as successfully remapped in the retval of the + * command. This is mostly useful to remap hugepage naturally aligned + * virtual regions without knowing if there are transparent hugepage + * in the regions or not, but preventing the risk of having to split + * the hugepmd during the remap. + * + * If there's any rmap walk that is taking the anon_vma locks without + * first obtaining the folio lock (for example split_huge_page and + * folio_referenced), they will have to verify if the folio->mapping + * has changed after taking the anon_vma lock. If it changed they + * should release the lock and retry obtaining a new anon_vma, because + * it means the anon_vma was changed by remap_pages() before the lock + * could be obtained. This is the only additional complexity added to + * the rmap code to provide this anonymous page remapping functionality. + */ +ssize_t remap_pages(struct mm_struct *dst_mm, struct mm_struct *src_mm, + unsigned long dst_start, unsigned long src_start, + unsigned long len, __u64 mode) +{ + struct vm_area_struct *src_vma, *dst_vma; + long err = -EINVAL; + pmd_t *src_pmd, *dst_pmd; + unsigned long src_addr, dst_addr; + int thp_aligned = -1; + ssize_t moved = 0; + + /* + * Sanitize the command parameters: + */ + BUG_ON(src_start & ~PAGE_MASK); + BUG_ON(dst_start & ~PAGE_MASK); + BUG_ON(len & ~PAGE_MASK); + + /* Does the address range wrap, or is the span zero-sized? */ + BUG_ON(src_start + len <= src_start); + BUG_ON(dst_start + len <= dst_start); + + /* + * Because these are read sempahores there's no risk of lock + * inversion. + */ + mmap_read_lock(dst_mm); + if (dst_mm != src_mm) + mmap_read_lock(src_mm); + + /* + * Make sure the vma is not shared, that the src and dst remap + * ranges are both valid and fully within a single existing + * vma. + */ + src_vma = find_vma(src_mm, src_start); + if (!src_vma || (src_vma->vm_flags & VM_SHARED)) + goto out; + if (src_start < src_vma->vm_start || + src_start + len > src_vma->vm_end) + goto out; + + dst_vma = find_vma(dst_mm, dst_start); + if (!dst_vma || (dst_vma->vm_flags & VM_SHARED)) + goto out; + if (dst_start < dst_vma->vm_start || + dst_start + len > dst_vma->vm_end) + goto out; + + if (pgprot_val(src_vma->vm_page_prot) != + pgprot_val(dst_vma->vm_page_prot)) + goto out; + + /* only allow remapping if both are mlocked or both aren't */ + if ((src_vma->vm_flags & VM_LOCKED) ^ (dst_vma->vm_flags & VM_LOCKED)) + goto out; + + /* + * Be strict and only allow remap_pages if either the src or + * dst range is registered in the userfaultfd to prevent + * userland errors going unnoticed. As far as the VM + * consistency is concerned, it would be perfectly safe to + * remove this check, but there's no useful usage for + * remap_pages ouside of userfaultfd registered ranges. This + * is after all why it is an ioctl belonging to the + * userfaultfd and not a syscall. + * + * Allow both vmas to be registered in the userfaultfd, just + * in case somebody finds a way to make such a case useful. + * Normally only one of the two vmas would be registered in + * the userfaultfd. + */ + if (!dst_vma->vm_userfaultfd_ctx.ctx && + !src_vma->vm_userfaultfd_ctx.ctx) + goto out; + + /* + * FIXME: only allow remapping across anonymous vmas, + * tmpfs should be added. + */ + if (src_vma->vm_ops || dst_vma->vm_ops) + goto out; + + /* + * Ensure the dst_vma has a anon_vma or this page + * would get a NULL anon_vma when moved in the + * dst_vma. + */ + err = -ENOMEM; + if (unlikely(anon_vma_prepare(dst_vma))) + goto out; + + for (src_addr = src_start, dst_addr = dst_start; + src_addr < src_start + len;) { + spinlock_t *ptl; + pmd_t dst_pmdval; + + BUG_ON(dst_addr >= dst_start + len); + src_pmd = mm_find_pmd(src_mm, src_addr); + if (unlikely(!src_pmd)) { + if (!(mode & UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES)) { + err = -ENOENT; + break; + } + src_pmd = mm_alloc_pmd(src_mm, src_addr); + if (unlikely(!src_pmd)) { + err = -ENOMEM; + break; + } + } + dst_pmd = mm_alloc_pmd(dst_mm, dst_addr); + if (unlikely(!dst_pmd)) { + err = -ENOMEM; + break; + } + + dst_pmdval = pmdp_get_lockless(dst_pmd); + /* + * If the dst_pmd is mapped as THP don't + * override it and just be strict. + */ + if (unlikely(pmd_trans_huge(dst_pmdval))) { + err = -EEXIST; + break; + } + ptl = pmd_trans_huge_lock(src_pmd, src_vma); + if (ptl) { + /* + * Check if we can move the pmd without + * splitting it. First check the address + * alignment to be the same in src/dst. These + * checks don't actually need the PT lock but + * it's good to do it here to optimize this + * block away at build time if + * CONFIG_TRANSPARENT_HUGEPAGE is not set. + */ + if (thp_aligned == -1) + thp_aligned = ((src_addr & ~HPAGE_PMD_MASK) == + (dst_addr & ~HPAGE_PMD_MASK)); + if (!thp_aligned || (src_addr & ~HPAGE_PMD_MASK) || + !pmd_none(dst_pmdval) || + src_start + len - src_addr < HPAGE_PMD_SIZE) { + spin_unlock(ptl); + /* Fall through */ + split_huge_pmd(src_vma, src_pmd, src_addr); + } else { + err = remap_pages_huge_pmd(dst_mm, + src_mm, + dst_pmd, + src_pmd, + dst_pmdval, + dst_vma, + src_vma, + dst_addr, + src_addr); + cond_resched(); + + if (!err) { + dst_addr += HPAGE_PMD_SIZE; + src_addr += HPAGE_PMD_SIZE; + moved += HPAGE_PMD_SIZE; + } + + if ((!err || err == -EAGAIN) && + fatal_signal_pending(current)) + err = -EINTR; + + if (err && err != -EAGAIN) + break; + + continue; + } + } + + if (pmd_none(*src_pmd)) { + if (!(mode & UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES)) { + err = -ENOENT; + break; + } + if (unlikely(__pte_alloc(src_mm, src_pmd))) { + err = -ENOMEM; + break; + } + } + + if (unlikely(pmd_none(dst_pmdval)) && + unlikely(__pte_alloc(dst_mm, dst_pmd))) { + err = -ENOMEM; + break; + } + + err = remap_pages_pte(dst_mm, src_mm, + dst_pmd, src_pmd, + dst_vma, src_vma, + dst_addr, src_addr, + mode); + + cond_resched(); + + if (!err) { + dst_addr += PAGE_SIZE; + src_addr += PAGE_SIZE; + moved += PAGE_SIZE; + } + + if ((!err || err == -EAGAIN) && + fatal_signal_pending(current)) + err = -EINTR; + + if (err && err != -EAGAIN) + break; + } + +out: + mmap_read_unlock(dst_mm); + if (dst_mm != src_mm) + mmap_read_unlock(src_mm); + BUG_ON(moved < 0); + BUG_ON(err > 0); + BUG_ON(!moved && !err); + return moved ? moved : err; +} From patchwork Thu Sep 14 15:26:13 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Suren Baghdasaryan X-Patchwork-Id: 13385626 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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 304A4EEAA4E for ; Thu, 14 Sep 2023 15:26:35 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 9597D6B02C3; Thu, 14 Sep 2023 11:26:34 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 90A306B02C4; Thu, 14 Sep 2023 11:26:34 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 783A46B02C5; Thu, 14 Sep 2023 11:26:34 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0012.hostedemail.com [216.40.44.12]) by kanga.kvack.org (Postfix) with ESMTP id 6411C6B02C3 for ; Thu, 14 Sep 2023 11:26:34 -0400 (EDT) Received: from smtpin27.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay09.hostedemail.com (Postfix) with ESMTP id 3220A80545 for ; Thu, 14 Sep 2023 15:26:34 +0000 (UTC) X-FDA: 81235579908.27.31421BA Received: from mail-yw1-f201.google.com (mail-yw1-f201.google.com [209.85.128.201]) by imf22.hostedemail.com (Postfix) with ESMTP id 684B8C0009 for ; Thu, 14 Sep 2023 15:26:32 +0000 (UTC) Authentication-Results: imf22.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=TBCVFZth; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf22.hostedemail.com: domain of 3JyYDZQYKCK4gifSbPUccUZS.QcaZWbil-aaYjOQY.cfU@flex--surenb.bounces.google.com designates 209.85.128.201 as permitted sender) smtp.mailfrom=3JyYDZQYKCK4gifSbPUccUZS.QcaZWbil-aaYjOQY.cfU@flex--surenb.bounces.google.com ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1694705192; a=rsa-sha256; cv=none; b=XLVvRY2tO1rOLUGLWrOggKlorlAs6OXvBfg8bPryK3cw5peLqPZwfHazojI3SFQBERnNU4 KII61VeEYAFJYzlvJvVTy7KzGS0IaENn9MUimEnXrd2rxF1cZ50VfLdDb6GCw8uUvSILwi wTCYqPecBAvDv+4sSrjRedeN86o6GG4= ARC-Authentication-Results: i=1; imf22.hostedemail.com; dkim=pass header.d=google.com header.s=20230601 header.b=TBCVFZth; dmarc=pass (policy=reject) header.from=google.com; spf=pass (imf22.hostedemail.com: domain of 3JyYDZQYKCK4gifSbPUccUZS.QcaZWbil-aaYjOQY.cfU@flex--surenb.bounces.google.com designates 209.85.128.201 as permitted sender) smtp.mailfrom=3JyYDZQYKCK4gifSbPUccUZS.QcaZWbil-aaYjOQY.cfU@flex--surenb.bounces.google.com ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1694705192; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=Mu1OGPWARKH9oRMfZEcpV5n3maR0zmAnXssCvh8qI9k=; b=vAlzPCkdnII2MtKd+USBrNLzX3V6dVME1cZHYO/VYnwLuR8wSDKaslB5olYzFglEukccFG OeE+0k8AwpGE8AkZ1yVBR9jwwm3XZphqEmVrW+mODjWYygt3xO/I0LEjhyg9S7gsTG2zyW ozTbkcULEiQtP3zGUS7nWXxosmmF5GM= Received: by mail-yw1-f201.google.com with SMTP id 00721157ae682-5925fb6087bso14678317b3.2 for ; Thu, 14 Sep 2023 08:26:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1694705191; x=1695309991; darn=kvack.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=Mu1OGPWARKH9oRMfZEcpV5n3maR0zmAnXssCvh8qI9k=; b=TBCVFZth4e3YerU/bBVBoy+YksK6dAz8ciWNo1Iz2CussJzcIPAaSSy6e0erEeSxT/ KHACziaw1XYnAjWXCcBTw1/xDjAMqOkZu9sWiku3ZYuqoHqRsaAjRMiNiN6Unr5Ymxtx hbefGOosvNUnHBX47ACgwRWv71N2GgBZYW220k+Ji1FV5gtftr8MFnwvzy8wUQ/DNPkk 9v1UtnG+z/wXBKOwM7u/QreBbKy1++c6+e+G3KWYsqBpWNaz1WmH9y3EM6iCwprxIEVa sxROPw2rvqe3cm47KSSccTGtl4/3mBI68+cETW6E+T6hxA80I6bDpj2vyQncfOYx1yhQ d2LQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1694705191; x=1695309991; 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=Mu1OGPWARKH9oRMfZEcpV5n3maR0zmAnXssCvh8qI9k=; b=VTRPJGYuNAjDHyT6M67de2rhnUlgHU5k2iCIGjHzMjW/txOnzKdHYCgRO/qPd8rQR5 f1oi03yl5QOkdcakGj8blmio9S0pmCvnG8lJInGc3vMm6/ELLPu4Dd49BV+mO0Z9PplV fY8FRcB7ZcJoAKbYutLROxGXK7Yy10LyCTyNJ2mjaI2IfuMPOWrRXt1HB4MVzqHgWfpI l55KEdAAAmSrHZfKwP4GwnLkNIWQ7LsE8+2ctwzMJcqrEYVlpVYQpKjyCdzzjebvVum3 F6g7wv+3jTFyrpPMC1LsPIEDhxKOkhtR5w8u3aWvWhZ+xI6Bm5M7gWDY5DQhp5WvQcZG xPrg== X-Gm-Message-State: AOJu0Ywiirmt+aCMhTAS3y/buAlEJx/jKOFTqimK55jvnl6B/uMmdOwa Sf+3r2TIzA7bguUAmAvS/Nad4OSzEY0= X-Google-Smtp-Source: AGHT+IFBVegGxf80f6tK8JTRTL2eDdZPWBJrMSOMFpp88sQURTGOGeLIWNKbAvxE88xxjjHdcadvLmZLUmU= X-Received: from surenb-desktop.mtv.corp.google.com ([2620:15c:211:201:405c:ba64:810f:5fee]) (user=surenb job=sendgmr) by 2002:a81:c94b:0:b0:59b:ba8a:97d0 with SMTP id c11-20020a81c94b000000b0059bba8a97d0mr154662ywl.3.1694705191508; Thu, 14 Sep 2023 08:26:31 -0700 (PDT) Date: Thu, 14 Sep 2023 08:26:13 -0700 In-Reply-To: <20230914152620.2743033-1-surenb@google.com> Mime-Version: 1.0 References: <20230914152620.2743033-1-surenb@google.com> X-Mailer: git-send-email 2.42.0.283.g2d96d420d3-goog Message-ID: <20230914152620.2743033-4-surenb@google.com> Subject: [PATCH 3/3] selftests/mm: add UFFDIO_REMAP ioctl test From: Suren Baghdasaryan To: akpm@linux-foundation.org Cc: viro@zeniv.linux.org.uk, brauner@kernel.org, shuah@kernel.org, aarcange@redhat.com, lokeshgidra@google.com, peterx@redhat.com, david@redhat.com, hughd@google.com, mhocko@suse.com, axelrasmussen@google.com, rppt@kernel.org, willy@infradead.org, Liam.Howlett@oracle.com, jannh@google.com, zhangpeng362@huawei.com, bgeffon@google.com, kaleshsingh@google.com, ngeoffray@google.com, jdduke@google.com, surenb@google.com, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, kernel-team@android.com X-Rspam-User: X-Rspamd-Server: rspam06 X-Rspamd-Queue-Id: 684B8C0009 X-Stat-Signature: tqku77wa7h1h5m7bp6nwfa8393p7no6n X-HE-Tag: 1694705192-941150 X-HE-Meta: U2FsdGVkX195F6wZb0KUxS67xH7NtnygyEb7xc+IkvPEari+NAngij8I4PIm9E6MFnO3YL8mYRaU0RCZFYazUBJ701ThyZL8esVmsgaP3CkWPn1l6HtOAgMs2hcyAe2br4nINOxomo3LHKIemz8uG2ilVc1kYjPhQcKTxeQ+LNiEYF3AUKblhLRboumS3kUycAFBYlwRukINHeaN0KXD82fcdpKPEsZtkvjHbYRWaoQqKrqQxn1fUD/ccQG46eOF+xhFd5Kr95lRvlijG9YrGVSgOwK+nVdF15nNIDmjbQKUSk0esIvYQAEmyewIV1Tur800tU6/8SViBKQ3HxQqVeQn/mMr6bBRnIaib6W/T/OhqSVaIbzDjqhhDxeIydcPGfUAuz76OStK/a6mvg26D2NhsxFAYlvh4s7Ed6/ugE1rJIUTGP7ZrvgXduDlDUwcvkj6nt5DqaWtSQP5jhtrdhCExNzUtgprd/OY1ON/uBatDdV/iYrL4qoz6kIwd77iKGuk3oT9kSs9W9lg3qqWQHxDOkb16IgK3bXObXPB4kDAODzptmB/2LxOIQbd4iixJbVsop8+MqL4a9nhCKOd+PZ+wOfW+OwSkM9yv5nGp2LC7lRQE9HmdZHlA2iNf7t54TalMXsTntl7D+h/e6oYL/SDkbXaCHRldDdl4oFRfP3ViZy5b5cAtFnaF6rC87/9V4a360QE4647hjm8OhqN6/JynLMe7m8PAbmTxy0iLbJbNAMntv+HZUaLce3bymH4CxJcqaZWroWiL8+xjRAoo8/tKiSvWLH2z6fznwLm81B5Up2gSWl4/+UKnYQgSSg+MKUpICVx0gQ72weZR/fKihUWGbsZ8y9h9t1lbA9aXDaxGAXeX1rW/gaDQgwF1ymAKLS80HKeM4rIIMXWOZVm1GPGKR82MAsNm7hB7h74nEfllVol+R9f7czmnqa5/jxXGCzf3VZAFFHVqOery4U qNz+Ti47 f1n2gKZHC5f9jHMMyxOTfr/Bo/GA5I8umxZvMySdMsrZMIuqFM3o6yUSW0IUfrguMIIOCnDJuAOZQXsDaBv1vbClcFr3BxzH425G/kOewsHsOv++tvuRBTOfdw2ISA54dXSYmdYi053YPV/lE43p+wdkHqYxjdI42p6QrKyL/cAUX3ZnI++WSHWb7L4/t5VZOKwW/O1TLgCy6034EvWZqJbLzoUq8y2swojlhy2fyuON60Pz1VCRysBlGTO30oaxIPikh8jS2RHSRIGrZSLq8jTnyCz/6JzAdNrHj6wFMqikuM66HgBT708RLNVVBjaE4s6mV8HsWuVMNVT7vzQkoGTGDYPMUK6shuqVwTcgHRime2Rm60ieaytSujYKIA9C47GoVJ1PxlZnNSjGbir653pc3JvjXeuUKtgjvtBcG5PplffF3JK31dJQt7jLQMSSDVMPYClwj7uD//q3wAIsb2oc83AGDBZpC9BjbKyxxpREJOoRjtHlFLnMXXVZWIfbxAyA+TKyBQhQPJqCaMkD/kjCm5m9FSuj5SGGT8hFx0zl/fFTidsqjd3vAuXb+FpVgIdaPbJp/Icow7NIeAX5D1FB3Rt3j7nGQhtjeMbNJ+AyQ4TP+Jlxmnv2DnBJW3O4LYhiYWhaklAQ1blfJZzWaEBThcg== X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Add a test for new UFFDIO_REMAP ioctl which uses uffd to remaps source into destination buffer while checking the contents of both after remapping. After the operation the content of the destination buffer should match the original source buffer's content while the source buffer should be zeroed. Signed-off-by: Suren Baghdasaryan --- tools/testing/selftests/mm/uffd-common.c | 34 ++++++++++- tools/testing/selftests/mm/uffd-common.h | 1 + tools/testing/selftests/mm/uffd-unit-tests.c | 62 ++++++++++++++++++++ 3 files changed, 95 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/mm/uffd-common.c b/tools/testing/selftests/mm/uffd-common.c index 02b89860e193..fb449abc46e2 100644 --- a/tools/testing/selftests/mm/uffd-common.c +++ b/tools/testing/selftests/mm/uffd-common.c @@ -484,8 +484,14 @@ void uffd_handle_page_fault(struct uffd_msg *msg, struct uffd_args *args) offset = (char *)(unsigned long)msg->arg.pagefault.address - area_dst; offset &= ~(page_size-1); - if (copy_page(uffd, offset, args->apply_wp)) - args->missing_faults++; + /* UFFD_REMAP is supported for anon non-shared mappings. */ + if (uffd_test_ops == &anon_uffd_test_ops && !map_shared) { + if (remap_page(uffd, offset)) + args->missing_faults++; + } else { + if (copy_page(uffd, offset, args->apply_wp)) + args->missing_faults++; + } } } @@ -620,6 +626,30 @@ int copy_page(int ufd, unsigned long offset, bool wp) return __copy_page(ufd, offset, false, wp); } +int remap_page(int ufd, unsigned long offset) +{ + struct uffdio_remap uffdio_remap; + + if (offset >= nr_pages * page_size) + err("unexpected offset %lu\n", offset); + uffdio_remap.dst = (unsigned long) area_dst + offset; + uffdio_remap.src = (unsigned long) area_src + offset; + uffdio_remap.len = page_size; + uffdio_remap.mode = UFFDIO_REMAP_MODE_ALLOW_SRC_HOLES; + uffdio_remap.remap = 0; + if (ioctl(ufd, UFFDIO_REMAP, &uffdio_remap)) { + /* real retval in uffdio_remap.remap */ + if (uffdio_remap.remap != -EEXIST) + err("UFFDIO_REMAP error: %"PRId64, + (int64_t)uffdio_remap.remap); + wake_range(ufd, uffdio_remap.dst, page_size); + } else if (uffdio_remap.remap != page_size) { + err("UFFDIO_REMAP error: %"PRId64, (int64_t)uffdio_remap.remap); + } else + return 1; + return 0; +} + int uffd_open_dev(unsigned int flags) { int fd, uffd; diff --git a/tools/testing/selftests/mm/uffd-common.h b/tools/testing/selftests/mm/uffd-common.h index 7c4fa964c3b0..2bbb15d1920c 100644 --- a/tools/testing/selftests/mm/uffd-common.h +++ b/tools/testing/selftests/mm/uffd-common.h @@ -111,6 +111,7 @@ void wp_range(int ufd, __u64 start, __u64 len, bool wp); void uffd_handle_page_fault(struct uffd_msg *msg, struct uffd_args *args); int __copy_page(int ufd, unsigned long offset, bool retry, bool wp); int copy_page(int ufd, unsigned long offset, bool wp); +int remap_page(int ufd, unsigned long offset); void *uffd_poll_thread(void *arg); int uffd_open_dev(unsigned int flags); diff --git a/tools/testing/selftests/mm/uffd-unit-tests.c b/tools/testing/selftests/mm/uffd-unit-tests.c index 2709a34a39c5..a33819639187 100644 --- a/tools/testing/selftests/mm/uffd-unit-tests.c +++ b/tools/testing/selftests/mm/uffd-unit-tests.c @@ -824,6 +824,10 @@ static void uffd_events_test_common(bool wp) char c; struct uffd_args args = { 0 }; + /* Prevent source pages from being mapped more than once */ + if (madvise(area_src, nr_pages * page_size, MADV_DONTFORK)) + err("madvise(MADV_DONTFORK) failed"); + fcntl(uffd, F_SETFL, uffd_flags | O_NONBLOCK); if (uffd_register(uffd, area_dst, nr_pages * page_size, true, wp, false)) @@ -1062,6 +1066,58 @@ static void uffd_poison_test(uffd_test_args_t *targs) uffd_test_pass(); } +static void uffd_remap_test(uffd_test_args_t *targs) +{ + unsigned long nr; + pthread_t uffd_mon; + char c; + unsigned long long count; + struct uffd_args args = { 0 }; + + if (uffd_register(uffd, area_dst, nr_pages * page_size, + true, false, false)) + err("register failure"); + + if (pthread_create(&uffd_mon, NULL, uffd_poll_thread, &args)) + err("uffd_poll_thread create"); + + /* + * Read each of the pages back using the UFFD-registered mapping. We + * expect that the first time we touch a page, it will result in a missing + * fault. uffd_poll_thread will resolve the fault by remapping source + * page to destination. + */ + for (nr = 0; nr < nr_pages; nr++) { + /* Check area_src content */ + count = *area_count(area_src, nr); + if (count != count_verify[nr]) + err("nr %lu source memory invalid %llu %llu\n", + nr, count, count_verify[nr]); + + /* Faulting into area_dst should remap the page */ + count = *area_count(area_dst, nr); + if (count != count_verify[nr]) + err("nr %lu memory corruption %llu %llu\n", + nr, count, count_verify[nr]); + + /* Re-check area_src content which should be empty */ + count = *area_count(area_src, nr); + if (count != 0) + err("nr %lu remap failed %llu %llu\n", + nr, count, count_verify[nr]); + } + + if (write(pipefd[1], &c, sizeof(c)) != sizeof(c)) + err("pipe write"); + if (pthread_join(uffd_mon, NULL)) + err("join() failed"); + + if (args.missing_faults != nr_pages || args.minor_faults != 0) + uffd_test_fail("stats check error"); + else + uffd_test_pass(); +} + /* * Test the returned uffdio_register.ioctls with different register modes. * Note that _UFFDIO_ZEROPAGE is tested separately in the zeropage test. @@ -1139,6 +1195,12 @@ uffd_test_case_t uffd_tests[] = { .mem_targets = MEM_ALL, .uffd_feature_required = 0, }, + { + .name = "remap", + .uffd_fn = uffd_remap_test, + .mem_targets = MEM_ANON, + .uffd_feature_required = 0, + }, { .name = "wp-fork", .uffd_fn = uffd_wp_fork_test,