From mboxrd@z Thu Jan 1 00:00:00 1970 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 75AF1E69183 for ; Fri, 22 Nov 2024 17:28:02 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 9A3A76B0082; Fri, 22 Nov 2024 12:28:01 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 9532F6B0083; Fri, 22 Nov 2024 12:28:01 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 7A6F26B0085; Fri, 22 Nov 2024 12:28:01 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0016.hostedemail.com [216.40.44.16]) by kanga.kvack.org (Postfix) with ESMTP id 565976B0082 for ; Fri, 22 Nov 2024 12:28:01 -0500 (EST) Received: from smtpin01.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id ED0CD14199D for ; Fri, 22 Nov 2024 17:28:00 +0000 (UTC) X-FDA: 82814411148.01.13BB7AC Received: from mx0a-00069f02.pphosted.com (mx0a-00069f02.pphosted.com [205.220.165.32]) by imf01.hostedemail.com (Postfix) with ESMTP id 6725A4000E for ; Fri, 22 Nov 2024 17:27:15 +0000 (UTC) Authentication-Results: imf01.hostedemail.com; dkim=pass header.d=oracle.com header.s=corp-2023-11-20 header.b=hEncJetn; dkim=pass header.d=oracle.onmicrosoft.com header.s=selector2-oracle-onmicrosoft-com header.b=EUrPrX3D; arc=pass ("microsoft.com:s=arcselector10001:i=1"); dmarc=pass (policy=reject) header.from=oracle.com; spf=pass (imf01.hostedemail.com: domain of lorenzo.stoakes@oracle.com designates 205.220.165.32 as permitted sender) smtp.mailfrom=lorenzo.stoakes@oracle.com ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1732296290; 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=OSUoKqsbKjNnMedwWkR49gLpXbX3BCySCt2w9Hvi7wc=; b=ayxdp9d19w22rq8ouJ10UyDrM/TjGX8gc6dKeg3mnTogCcSJ9vkhmWRPkR8K/XL4yZBjhH qcB7CiFSWN1zo4xj/G/xKEqhBHgAgFv2EHKkCaVpHEpAjzKGeUpjMXpat8Z8mnoxOfb8jE sLzlepck+FxwjiHURpB2zvBkiPx9FIU= ARC-Authentication-Results: i=2; imf01.hostedemail.com; dkim=pass header.d=oracle.com header.s=corp-2023-11-20 header.b=hEncJetn; dkim=pass header.d=oracle.onmicrosoft.com header.s=selector2-oracle-onmicrosoft-com header.b=EUrPrX3D; arc=pass ("microsoft.com:s=arcselector10001:i=1"); dmarc=pass (policy=reject) header.from=oracle.com; spf=pass (imf01.hostedemail.com: domain of lorenzo.stoakes@oracle.com designates 205.220.165.32 as permitted sender) smtp.mailfrom=lorenzo.stoakes@oracle.com ARC-Seal: i=2; s=arc-20220608; d=hostedemail.com; t=1732296290; a=rsa-sha256; cv=pass; b=YdSsy6MGDVQw48Jq/yDXJHBk8Jcb6BKWWFadzu7yrXAEBEwKgcaC0AYWtqKhC1dx+SEKrw WZj37V1bXyHEy7s41Y1b7FmZT1yKJoWGOBOeOOsAca6ECoVV30JIphU6hlk7+jIAkBBPi6 K6hmUEaGiR8uT/SdChymjFqjbxrPL6Y= Received: from pps.filterd (m0333521.ppops.net [127.0.0.1]) by mx0b-00069f02.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 4AMGBbMh016291; Fri, 22 Nov 2024 17:27:44 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.com; h=cc :content-type:date:from:in-reply-to:message-id:mime-version :references:subject:to; s=corp-2023-11-20; bh=OSUoKqsbKjNnMedwWk R49gLpXbX3BCySCt2w9Hvi7wc=; b=hEncJetn7PoJsm6bpSdReqQnO4zMIucZT1 EaISqdjL9Op1xheHwL/Dns7CCYImMdVu4/GjRvCMTmHj2EgPmlt8BECHsqI/6ESq cbh3g56JUwBde1PCDdp8O9ndaCff26MPSnKuIxhZx9kQTEL4TC1nU6ZaYZuupw3y JbqYUwpCco9XzTMbE9TQw0Qz0JMKVuHvS6qaOm8DU+OKCvWqrq30jz4G6HLN2WN3 Mz/ueMj/ETYp7j/MFGRsrd6tidx1yc7ULUwp2tx/04lBPYjBZITrlr3UDNG+iT/W cS9IoUFwElY4ixqY0EQYTZw1pnkd1DJ0uXm3sq6YVzJ/7RE2Lx+g== Received: from phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (phxpaimrmta02.appoci.oracle.com [147.154.114.232]) by mx0b-00069f02.pphosted.com (PPS) with ESMTPS id 42xjaacpf0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 22 Nov 2024 17:27:43 +0000 (GMT) Received: from pps.filterd (phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com [127.0.0.1]) by phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (8.18.1.2/8.18.1.2) with ESMTP id 4AMHFBxv037310; Fri, 22 Nov 2024 17:27:43 GMT Received: from nam10-dm6-obe.outbound.protection.outlook.com (mail-dm6nam10lp2043.outbound.protection.outlook.com [104.47.58.43]) by phxpaimrmta02.imrmtpd1.prodappphxaev1.oraclevcn.com (PPS) with ESMTPS id 42xhudmegm-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Fri, 22 Nov 2024 17:27:42 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector10001; d=microsoft.com; cv=none; b=wMe4A+nzl+MmJR9vOgAOOy17YQMnTbrWHqfOKzCXi+gnL06XyufQxnz9thTwQohxi+r7fdG2ExH8yJ7jqYls7bFTUY3qS0mQUAFujuXp/AwtMSAcBvzYxd1qaXgGQbINWBfnrqBOv1pR/BgnQTqB/8ahX3HgSxuLVnLxAaNbjTCFkgSGn4N2FgVScJcnNXCWUGsASjcnkwem1vdMCFVSKVNB9TLZjEI8xDvyign9Frd62hIQgWnX3AB8aArMD6dt3JpTvjrnPNpzwkhd73gTMPLAAA+G7QhgK1WN+q8cljn3RWDWvOWlKrhKfw+FHUe0H8/yqgfKWSHeqjE+V4ZTCQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector10001; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=OSUoKqsbKjNnMedwWkR49gLpXbX3BCySCt2w9Hvi7wc=; b=VFCPcVfhElKsij0kynaft1zgrfhYKBhKW59Y3c0QSo1IgTi6QDYw3N2rgpKwbNVYCE7ucTqFUj5Hlt9+NYROpZz0+E78cv6z0AT8IIEZqS2F84YfLC7coG4AY9q1mXLXkSzOl9Vzv+2IAO4e3+2mWc60MojiSvvFLZRCcdJjlzdlExnC/xe+1AvB8TxABqzIM9sZeZiGEltq6HKny6GorD8ucBRLThw6+nu0uww+GIWkMsOUwq5deJ/FSIOq45ZAkM1apUO9guuAIbSA3kl4j5WEl5K8hHmozUSV1iXuVVc2FcxWFD8lFLbJi5F+olD4yw949O0yrD/iT/Q3QPK5bA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=oracle.com; dmarc=pass action=none header.from=oracle.com; dkim=pass header.d=oracle.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=oracle.onmicrosoft.com; s=selector2-oracle-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=OSUoKqsbKjNnMedwWkR49gLpXbX3BCySCt2w9Hvi7wc=; b=EUrPrX3DApIX8wC5pCgZEV0mIvgbRhUMLMrJ2Y51wlEvHFuv64LIZvgG4ipDyjEbrsmiCWEHt8i2OILYxDrvU2+hr7w78ipvb+EN1+quPfsYCYxhdkWTR6VsSbosIGtCR842+qs1mvbVR/xDBFX6NekFrHDdt7hZ1hopYOheEJ0= Received: from BYAPR10MB3366.namprd10.prod.outlook.com (2603:10b6:a03:14f::25) by BLAPR10MB5139.namprd10.prod.outlook.com (2603:10b6:208:307::20) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.8158.27; Fri, 22 Nov 2024 17:27:39 +0000 Received: from BYAPR10MB3366.namprd10.prod.outlook.com ([fe80::baf2:dff1:d471:1c9]) by BYAPR10MB3366.namprd10.prod.outlook.com ([fe80::baf2:dff1:d471:1c9%7]) with mapi id 15.20.8158.023; Fri, 22 Nov 2024 17:27:39 +0000 Date: Fri, 22 Nov 2024 17:27:36 +0000 From: Lorenzo Stoakes To: Alice Ryhl Cc: Miguel Ojeda , Matthew Wilcox , Vlastimil Babka , John Hubbard , "Liam R. Howlett" , Andrew Morton , Greg Kroah-Hartman , Arnd Bergmann , Christian Brauner , Jann Horn , Suren Baghdasaryan , Alex Gaynor , Boqun Feng , Gary Guo , =?utf-8?B?QmrDtnJu?= Roy Baron , Benno Lossin , linux-kernel@vger.kernel.org, linux-mm@kvack.org, rust-for-linux@vger.kernel.org, Andreas Hindborg Subject: Re: [PATCH v9 1/8] mm: rust: add abstraction for struct mm_struct Message-ID: <9f26e6d4-77db-4dd2-a934-c83008cf1bdd@lucifer.local> References: <20241122-vma-v9-0-7127bfcdd54e@google.com> <20241122-vma-v9-1-7127bfcdd54e@google.com> Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <20241122-vma-v9-1-7127bfcdd54e@google.com> X-ClientProxiedBy: LO4P123CA0482.GBRP123.PROD.OUTLOOK.COM (2603:10a6:600:1a8::19) To BYAPR10MB3366.namprd10.prod.outlook.com (2603:10b6:a03:14f::25) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-TrafficTypeDiagnostic: BYAPR10MB3366:EE_|BLAPR10MB5139:EE_ X-MS-Office365-Filtering-Correlation-Id: 1f094cc5-e94c-4dbe-0354-08dd0b1af6c0 X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0;ARA:13230040|366016|7416014|1800799024|376014|7053199007; X-Microsoft-Antispam-Message-Info: =?us-ascii?Q?5AvEWP2c6TV08vLh67+OzQXzjjBqElwR87xk78aEIR6aHb8HIlkAXWPJHgaV?= =?us-ascii?Q?LB+0rEtSJFQTm61uS9OzJTDZSJwrw8J8soOtLqQaYl2CpGMNFd7ijhCqekIa?= =?us-ascii?Q?RvV8WYhp6qbpy782zSxvlkAhIVyH2k5oyhxqFNjna/NT9nrO2giKnoEQLAFn?= =?us-ascii?Q?KOLYeCMCLc58yGN40iKfBrlgKabQdcUfAIq5p5AehdwA5fu7IWQRySyxE2O4?= =?us-ascii?Q?tLKYI5uxRi6whVfzgE5BHQrVYfOtWFQ7BQ++k5LsMx2BxskWlAKIaiKX9PB5?= =?us-ascii?Q?s93qI78NahME/Ud9rp0/qPtnmmIOAWiRGL7Fgx69/8hcz4Uf3/oiGPTWZeRo?= =?us-ascii?Q?OlEvwXO85rw5WDgqet8Fk8jAh2A3C3Wz15ifWKzWpEYSXQdtTcIF5nkvinDX?= =?us-ascii?Q?1PrDs3ddqyXTJEESMKwVKOhcOSaS7HP4YiFixaoQP1xkR+aNdN9m67v9B5Xc?= =?us-ascii?Q?H2Whhaf2gAFvCl+jcfAVTwl18YXYaYafXm/sYuPJjZ0E1RDdocg3DzEnUhwJ?= =?us-ascii?Q?yXDJygancgvHnpMgQpvlT+LoRmDt0m3TTXP2yMQZrJTZK/o7dfDTzexuVJxS?= =?us-ascii?Q?hd1xAOObCLPGZ/SsCCUKBrk4rmrEfquYhUQFuUIiDFs/myRoHnTf0MdKRSNu?= =?us-ascii?Q?AuRi+0uPu+2fXbu5PNbzXgnMRV1solfXRaKYwpKQk90CGPChV3eshmH/IRQ7?= =?us-ascii?Q?uDJo4wOYzGnUBTichKnOymBYgY7MF65R2rKWCZ9AiCg38iz7fxVPaec3Uj3/?= =?us-ascii?Q?7ScJltyEKYob7hdtHeSJlhUd3v5C553j9Y0sjsAcI/yQ84rhDhA9vi4i3o6B?= =?us-ascii?Q?zz3KHH2Nodq8A6SSF5TtJgaJoEYniIUTw0TWKC76KcaLRRIIC+13vN7uKF7H?= =?us-ascii?Q?O0HkzV+4Iwdsl+Briqw7Kh9I0R47T5W+q1+cjcKkF33uAIdJcYp1iP8Y6tI8?= =?us-ascii?Q?agMgi4WIAMbdTrZtsK1Nip4JKlJnM1wPJ4esi5nLwgGIfCUoP+Xfpesz4Y1t?= =?us-ascii?Q?AMIBlcIHX+ZqZoDl4t1L30e/I5hfnNfwroZWVicpIL0mBRnO2oUOdCCWHTis?= =?us-ascii?Q?WYWuHmSUDGVrMTPyRb2MvrCSghPq/krgdoVYhlSZJ5+GEyWOHF08brlaZCwr?= =?us-ascii?Q?t0ZPXr9rOPBT9gmo8g7m3WYnRxBMEruj4UybiJfK7wA79X4G2K9+fKjZO/Rw?= =?us-ascii?Q?8dJEvoebKCtcl/+rI9tOgHkZVZPU1BKRLnrb+7eGNpD9PUsNueEzRZRDXAbF?= =?us-ascii?Q?Mvpo8NK5sf4j5TUzwuuUKIvF2sH7KLAHyaCeLEbcYYzhpe/btTLxTioWTFrB?= =?us-ascii?Q?cE4=3D?= X-Forefront-Antispam-Report: CIP:255.255.255.255;CTRY:;LANG:en;SCL:1;SRV:;IPV:NLI;SFV:NSPM;H:BYAPR10MB3366.namprd10.prod.outlook.com;PTR:;CAT:NONE;SFS:(13230040)(366016)(7416014)(1800799024)(376014)(7053199007);DIR:OUT;SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?us-ascii?Q?rMynlYZ/44dPSLrkljJPQ36h700X8JZB332/hSkhVYaM4sx20ylk3epWJRM/?= =?us-ascii?Q?+8wUL7s0ubzeab2E+8sJtCRXKQWg871DQCMn202JW9wHYagLsBaAn9oHRE5A?= =?us-ascii?Q?NResI1o/iybYwjsTJy3bj5xhLOTxF3Q9YiTNstIh/CZpeAA9+xSV/LVWVVSx?= =?us-ascii?Q?ndxeZPH7xuGPEHW1hJrzf/RupiKug6TUH92CORdIEonVFnYbxxVCMPBEOGx+?= =?us-ascii?Q?sUgDsB4F/XoDJ4ebTLBlPQzauVRjTej0/2/32yBy+BL4YSF3n7Nxtwz9nVWH?= =?us-ascii?Q?PSHhL7QlpQcjAu6CQIVQSZKXa9DuIlbzp1PzLHHD1Kh5sI3jPqK9OnuANpK/?= =?us-ascii?Q?xKkjyC6SbDmjI7HJcbZSp+syjtHyeDKrRmGUei8yGTWSs0k0Vq7Qdq7E+upu?= =?us-ascii?Q?bvUidxwFNkEuEA3UlSdvlKO/ps5YjSdQMdjcMOVOGMRRRhDe4v8rg87ilhIh?= =?us-ascii?Q?sQfAQm3eFfmCFkNBv6QuNNDEBjS77WemxeLgNTfwxzW8cj8SABjmXzPbvWWB?= =?us-ascii?Q?HhqnKDHv0nYwjfhtLpeCT4sxoxZ8Bb22yVaqv0lRtuj6fl42ThuwaidPAj7M?= =?us-ascii?Q?+AvN0R2xKOQR/ZSQ76uhbmOm+m1zfu9Dr4gAarQAciLES5xtir2NUOFBxPvd?= =?us-ascii?Q?THMMMWsjaV1pp2HwCsitLkVNfgb0Qr4xVywYreCxvzkneaiO6p7cExdey8wc?= =?us-ascii?Q?d0InAA+V1xRBrzVhEtFAYhdH8uWtFXKLWzS2rGkDLVg+Bgg+/k4usGIXvdMX?= =?us-ascii?Q?QQgn8Kf4enL0wOK9XYJ2RdsOX+LaVKuA2hdzPUEkKlx6alQcgLAodDQ2bxSI?= =?us-ascii?Q?dvbcsV1/hHMCWI2nJe/OtK+BFL8EmyWCpDx5SDbZzq/diTF7xjrPdPnpr02i?= =?us-ascii?Q?Q25OXQiWfk+tk8/p56s3L2XOHAFOS+m5QuxNZhEg6Ni3bk7eWVdM8ilTxxsT?= =?us-ascii?Q?VGKdB+ATvlM572dRYE1P6i4vK8yxTRdF3H5p/42eYeVJ8CxwbpU0yp/ZLvCm?= =?us-ascii?Q?z+jk92GylteLScTD72VqofB13HMv+D4pVu8ekCzqj/mNOR2mTK6t5eVJtzG/?= =?us-ascii?Q?R3XFhjvp8lA7yubzcuohPuc2t3W4qQTxFMtAey4dvOaal32TWiWIBjQFtp53?= =?us-ascii?Q?uh72X0o0ehuYLf0pwvTYsDtqwoWbKg9PJRmA7NtvK+COMth2h+M/TrdS5riG?= =?us-ascii?Q?Trkkf69euQ/7cMI9RHDtnXzLGuzKTi1NbyjQdhfjqR/aW6VIkWbT2fl+gcEl?= =?us-ascii?Q?9Re6PYXWkU6NHDFvlvIw7QbX3lKEfsMzWCfb+BlWx7KWdUO73bTVUWdlCRbj?= =?us-ascii?Q?+antrMozQ9Cn0Qw9tQ+tkcMH/uJqBe/gBhaK7XgN6NIcrFOquhImAVDgHftw?= =?us-ascii?Q?nZvx+tt4yAbpr8ZGHUJ1Hj/89PDX12GUi+BF5uksRbcEQF60190uzTTdW+4L?= =?us-ascii?Q?4mRq9CmEiKVrxP9+6hr6rXlRZdMjGcuH81aBi/BwcmhtqxBN+3vjPYIyreEE?= =?us-ascii?Q?SnMgVGm72XMHxY96cN6G7PU7wBJILi+rwwtRf1G5yuADy+8PFT0ZhO0cL9hs?= =?us-ascii?Q?G42UCbWATG/5OpXlRm0frBp320NeCZMgWDcU+wdP+ccen4fg/mOaxEt1TWpx?= =?us-ascii?Q?dw=3D=3D?= X-MS-Exchange-AntiSpam-ExternalHop-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-ExternalHop-MessageData-0: nST411oTiIpNvA/xCADJfGZ2z/v0q57Sdzs08wjTbVX6BZ9fKdQHO2PiPTppvIS+OGtdoI0zDaMj05XGkQKHkv+vJp4TQCWKu8aQsbTCp7X5ZWKdQoKoG4/+kl98NjfVjvwSSEJoDNzOZfaT0V/v+TcEzwD3TpWQ7s3K3FLnwOtUuKqM8SFn80v1t+4OSlHRVmqPyBBpJbwysPBtGCGxankQxCQZFsDnRFYD6+m6X9MXuLt+YX8PVHflKpuqcx059CZv3oP2wsGNk951kJjXjznR6+VBOYZ/buaKskPo5AR36E2rPwy/5BWEXvVO07T7uwnCNQeUh7wWjAONmun2yLkCXCosVLgBkKJ8hK/6KG5GH+hUYSn087k6WnSWSgjlLbb59ZrAGPZcQN8pKVHmAUTd/kjlkHJ58+AuMKHv5ugxc7I+OGjaHLAEhSLFL0OKlLQl54TJ1Vg7+1dwF/6VEZv34hiR+NYMqUd5A0IilfakIcqlPNTIRClZarx66na5l0gcU1GHtAJ6OiMJBgt744FrykQMHmW7m+uunHjJeDGsbTSHI2zSqgixlFwvTAmQerD5H/lIv//8Y8RRCwI2mRf+7wqobcZ6ybIpwdAksyY= X-OriginatorOrg: oracle.com X-MS-Exchange-CrossTenant-Network-Message-Id: 1f094cc5-e94c-4dbe-0354-08dd0b1af6c0 X-MS-Exchange-CrossTenant-AuthSource: BYAPR10MB3366.namprd10.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 22 Nov 2024 17:27:39.5798 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 4e2c6054-71cb-48f1-bd6c-3a9705aca71b X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: wFVJ4Cjjg+xa/Xn78gasACe0YUa/0VBZwQzFziqETQdpiKYwooooYGcs8+qHwG2O5DTnwnVnxZQmWJ/HKAwy4cHaoFUWDbsIIrp/Yc7tSIE= X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLAPR10MB5139 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1057,Hydra:6.0.680,FMLib:17.12.62.30 definitions=2024-11-22_09,2024-11-21_01,2024-09-30_01 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 bulkscore=0 spamscore=0 adultscore=0 suspectscore=0 mlxlogscore=999 phishscore=0 malwarescore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.12.0-2409260000 definitions=main-2411220146 X-Proofpoint-ORIG-GUID: PXX1dTwjTU4aWmSyOj9sKX1_0jqUXjno X-Proofpoint-GUID: PXX1dTwjTU4aWmSyOj9sKX1_0jqUXjno X-Rspamd-Server: rspam04 X-Rspamd-Queue-Id: 6725A4000E X-Stat-Signature: 7ah1o8wwgu1fjy3ad1ho5jzmgmqonpfx X-Rspam-User: X-HE-Tag: 1732296435-169136 X-HE-Meta: U2FsdGVkX197f/gY/OaqKdF2dZ3S8GswYCo7SwJTapJlZOPdiou9pCZt49KuYeCUZGnpTduh1B+IuDjqgSVCarzf7J1gIa+I4tiLEzgaLqzen45cTCT8sbd+UH+One4AP5CwVoZfGNht65qr9BFoIPmm0BQjUDxtT666NKrZZAwk/wofmyqLMW94yy896rhqC86g5PKgv6EUFza6Ot42xD6A/w2mOtA74RJs1rIO0xkWogzSr1KtsqCCCR7xJjjs424j6ivjWj3jhmoOgwVvRwolYe10SYD7VwHq7hBFyxLXFWcGvQrFgof4mv4xMQa4rrmfe0nX+G9SOr8+KCk9xgRdduemfOY0SUZhyPsZVt6lsGuWcoIrwV2CKlMrUcwsMj7OciT5tdnCkfst+G/Ho4/ms01ioqDaAsoOsSR9+yY2HScLIP+5PJBTbbI/Nu1MjsiyBLNFDZd69xhZSmqG+CuE2ajAAL3Tgg9bDhNMdTXvImpyBka3tRkRDBw7C4QjFrNWSHHSfz9XS+pZYTWMj8pjQuOc6M/o+6kX+wnJFG0BoL0SLB0InYfvqSNC7d3AFaMr8wV6J9sUxkSrgL/TD63vMMHC6cFm8p8LvEZRIZGSoLJ+Z+uLcpm6niOilWQIWy5kju7i2nepM+Z7DyQWDx46LJmJP2MesAghej3oELmBlGB4fpjdixsMe2aWCaagzUs+4UsZrCt1861KYdLof9v7X3kE5rL7+FIIGFoRH5pJfZG948Vu7xiYWEQrDoxLnxVJb7Nnc7mmuqtlflfw9lwUU5Voe7zOA6QZ+H/xC+V3k2y2UimbC/Sc0A7YkLxT5R8ixavHTMB5jdnfr0aTcVX79DlIvS6k5rKZYKAAzB/d2Uu2mPQRrWp1KizZ1wuIKWGpi4mYezbnUd3UuvTLlqg5ywxNCwuggqT/41JiHuDlfnggGqGKjvESWH22ZhYHpjQ3oynG4FT9nU1YYvI cNtJ7F2j m162XLAqbV9zVoyFEkPgOupqhg1c0xZU1SCObm8l1HgYT4sdizjIpnGlcvTWUQBNUe3qksW/3v2S6mbYQ0s0BYcU8qOvNaS/RxZDfhZURC7IIz42zn1NVZFlJgvahj2GGK6mhe0KR8PieBSmIpda01g4HW1t+956CgbID1KAp+g+OmHtZuV0c/WyslYUyYEagjzViCPRouqpg8YejNcScBP5BohuPpBpWCEjJ8BKv/6QpnSd8oW8fDhpqUo/ZpM9SjlTNeSVeK2Hpfa8fod4xxPDLQ/g9iLH4eo0zJjwcD+xqkIQnv7NMvgYRqbBFEJc0GyDIYKHUoYuDUMrO9xJPiDEIa+PASLRHZovMS0DR8LgGEb4GbMVitkeWSB7l6zSjihlihxFCdEeiyIYNXxGO+pUNSvPMy3LqltPInv+ZPdCbphu8FMdrkuyS71Dw69crjAqg8iHQe+hl4UHLVtTrhjQooe7GF4cHQWgNUqysSL73xTQAdG2wm50pinpx1cfpymidy7Unnle3TNf3Jw+YxXcJllVFmL0NIFy0qnXpbCiterHgb6Gr0VczRKOjbPvq6uHhfXJXBfAq4ZWng0TwoNmkonhtbZVvg+f54sdBtASC0mVF4yjEfF7BPctRxVYjDvhAPjkh0Zl4dwf+bB9mJlZGWFIkPueQ7Zf4PRilUzmWDPRpmHT0unDTSPWulSJ1cfm30gLsiBvWvrU= 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: List-Subscribe: List-Unsubscribe: On Fri, Nov 22, 2024 at 03:40:26PM +0000, Alice Ryhl wrote: > These abstractions allow you to reference a `struct mm_struct` using > both mmgrab and mmget refcounts. This is done using two Rust types: > > * Mm - represents an mm_struct where you don't know anything about the > value of mm_users. > * MmWithUser - represents an mm_struct where you know at compile time > that mm_users is non-zero. > > This allows us to encode in the type system whether a method requires > that mm_users is non-zero or not. For instance, you can always call > `mmget_not_zero` but you can only call `mmap_read_lock` when mm_users is > non-zero. > > It's possible to access current->mm without a refcount increment, but > that is added in a later patch of this series. > > Signed-off-by: Alice Ryhl I see you address the current thing in a later commit, so as the rest of the patch looked fine previously (with help from your kind explanations on the rust side :), so: Acked-by: Lorenzo Stoakes (for mm bits) > --- > rust/helpers/helpers.c | 1 + > rust/helpers/mm.c | 39 +++++++++ > rust/kernel/lib.rs | 1 + > rust/kernel/mm.rs | 219 +++++++++++++++++++++++++++++++++++++++++++++++++ > 4 files changed, 260 insertions(+) > > diff --git a/rust/helpers/helpers.c b/rust/helpers/helpers.c > index 6d90afd38c40..2ee3af594633 100644 > --- a/rust/helpers/helpers.c > +++ b/rust/helpers/helpers.c > @@ -15,6 +15,7 @@ > #include "err.c" > #include "fs.c" > #include "kunit.c" > +#include "mm.c" > #include "mutex.c" > #include "page.c" > #include "rbtree.c" > diff --git a/rust/helpers/mm.c b/rust/helpers/mm.c > new file mode 100644 > index 000000000000..7201747a5d31 > --- /dev/null > +++ b/rust/helpers/mm.c > @@ -0,0 +1,39 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +#include > +#include > + > +void rust_helper_mmgrab(struct mm_struct *mm) > +{ > + mmgrab(mm); > +} > + > +void rust_helper_mmdrop(struct mm_struct *mm) > +{ > + mmdrop(mm); > +} > + > +void rust_helper_mmget(struct mm_struct *mm) > +{ > + mmget(mm); > +} > + > +bool rust_helper_mmget_not_zero(struct mm_struct *mm) > +{ > + return mmget_not_zero(mm); > +} > + > +void rust_helper_mmap_read_lock(struct mm_struct *mm) > +{ > + mmap_read_lock(mm); > +} > + > +bool rust_helper_mmap_read_trylock(struct mm_struct *mm) > +{ > + return mmap_read_trylock(mm); > +} > + > +void rust_helper_mmap_read_unlock(struct mm_struct *mm) > +{ > + mmap_read_unlock(mm); > +} > diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs > index bf98caa6d6a5..104e619f5dbd 100644 > --- a/rust/kernel/lib.rs > +++ b/rust/kernel/lib.rs > @@ -45,6 +45,7 @@ > pub mod kunit; > pub mod list; > pub mod miscdevice; > +pub mod mm; > #[cfg(CONFIG_NET)] > pub mod net; > pub mod page; > diff --git a/rust/kernel/mm.rs b/rust/kernel/mm.rs > new file mode 100644 > index 000000000000..84cba581edaa > --- /dev/null > +++ b/rust/kernel/mm.rs > @@ -0,0 +1,219 @@ > +// SPDX-License-Identifier: GPL-2.0 > + > +// Copyright (C) 2024 Google LLC. > + > +//! Memory management. > +//! > +//! C header: [`include/linux/mm.h`](srctree/include/linux/mm.h) > + > +use crate::{ > + bindings, > + types::{ARef, AlwaysRefCounted, NotThreadSafe, Opaque}, > +}; > +use core::{ops::Deref, ptr::NonNull}; > + > +/// A wrapper for the kernel's `struct mm_struct`. > +/// > +/// Since `mm_users` may be zero, the associated address space may not exist anymore. You can use > +/// [`mmget_not_zero`] to be able to access the address space. > +/// > +/// The `ARef` smart pointer holds an `mmgrab` refcount. Its destructor may sleep. > +/// > +/// # Invariants > +/// > +/// Values of this type are always refcounted using `mmgrab`. > +/// > +/// [`mmget_not_zero`]: Mm::mmget_not_zero > +#[repr(transparent)] > +pub struct Mm { > + mm: Opaque, > +} > + > +// SAFETY: It is safe to call `mmdrop` on another thread than where `mmgrab` was called. > +unsafe impl Send for Mm {} > +// SAFETY: All methods on `Mm` can be called in parallel from several threads. > +unsafe impl Sync for Mm {} > + > +// SAFETY: By the type invariants, this type is always refcounted. > +unsafe impl AlwaysRefCounted for Mm { > + #[inline] > + fn inc_ref(&self) { > + // SAFETY: The pointer is valid since self is a reference. > + unsafe { bindings::mmgrab(self.as_raw()) }; > + } > + > + #[inline] > + unsafe fn dec_ref(obj: NonNull) { > + // SAFETY: The caller is giving up their refcount. > + unsafe { bindings::mmdrop(obj.cast().as_ptr()) }; > + } > +} > + > +/// A wrapper for the kernel's `struct mm_struct`. > +/// > +/// This type is like [`Mm`], but with non-zero `mm_users`. It can only be used when `mm_users` can > +/// be proven to be non-zero at compile-time, usually because the relevant code holds an `mmget` > +/// refcount. It can be used to access the associated address space. > +/// > +/// The `ARef` smart pointer holds an `mmget` refcount. Its destructor may sleep. > +/// > +/// # Invariants > +/// > +/// Values of this type are always refcounted using `mmget`. The value of `mm_users` is non-zero. > +#[repr(transparent)] > +pub struct MmWithUser { > + mm: Mm, > +} > + > +// SAFETY: It is safe to call `mmput` on another thread than where `mmget` was called. > +unsafe impl Send for MmWithUser {} > +// SAFETY: All methods on `MmWithUser` can be called in parallel from several threads. > +unsafe impl Sync for MmWithUser {} > + > +// SAFETY: By the type invariants, this type is always refcounted. > +unsafe impl AlwaysRefCounted for MmWithUser { > + #[inline] > + fn inc_ref(&self) { > + // SAFETY: The pointer is valid since self is a reference. > + unsafe { bindings::mmget(self.as_raw()) }; > + } > + > + #[inline] > + unsafe fn dec_ref(obj: NonNull) { > + // SAFETY: The caller is giving up their refcount. > + unsafe { bindings::mmput(obj.cast().as_ptr()) }; > + } > +} > + > +// Make all `Mm` methods available on `MmWithUser`. > +impl Deref for MmWithUser { > + type Target = Mm; > + > + #[inline] > + fn deref(&self) -> &Mm { > + &self.mm > + } > +} > + > +// These methods are safe to call even if `mm_users` is zero. > +impl Mm { > + /// Call `mmgrab` on `current.mm`. > + #[inline] > + pub fn mmgrab_current() -> Option> { > + // SAFETY: It's safe to get the `mm` field from current. > + let mm = unsafe { > + let current = bindings::get_current(); > + (*current).mm > + }; > + > + if mm.is_null() { > + return None; > + } > + > + // SAFETY: The value of `current->mm` is guaranteed to be null or a valid `mm_struct`. We > + // just checked that it's not null. Furthermore, the returned `&Mm` is valid only for the > + // duration of this function, and `current->mm` will stay valid for that long. > + let mm = unsafe { Mm::from_raw(mm) }; > + > + // This increments the refcount using `mmgrab`. > + Some(ARef::from(mm)) > + } > + > + /// Returns a raw pointer to the inner `mm_struct`. > + #[inline] > + pub fn as_raw(&self) -> *mut bindings::mm_struct { > + self.mm.get() > + } > + > + /// Obtain a reference from a raw pointer. > + /// > + /// # Safety > + /// > + /// The caller must ensure that `ptr` points at an `mm_struct`, and that it is not deallocated > + /// during the lifetime 'a. > + #[inline] > + pub unsafe fn from_raw<'a>(ptr: *const bindings::mm_struct) -> &'a Mm { > + // SAFETY: Caller promises that the pointer is valid for 'a. Layouts are compatible due to > + // repr(transparent). > + unsafe { &*ptr.cast() } > + } > + > + /// Calls `mmget_not_zero` and returns a handle if it succeeds. > + #[inline] > + pub fn mmget_not_zero(&self) -> Option> { > + // SAFETY: The pointer is valid since self is a reference. > + let success = unsafe { bindings::mmget_not_zero(self.as_raw()) }; > + > + if success { > + // SAFETY: We just created an `mmget` refcount. > + Some(unsafe { ARef::from_raw(NonNull::new_unchecked(self.as_raw().cast())) }) > + } else { > + None > + } > + } > +} > + > +// These methods require `mm_users` to be non-zero. > +impl MmWithUser { > + /// Obtain a reference from a raw pointer. > + /// > + /// # Safety > + /// > + /// The caller must ensure that `ptr` points at an `mm_struct`, and that `mm_users` remains > + /// non-zero for the duration of the lifetime 'a. > + #[inline] > + pub unsafe fn from_raw<'a>(ptr: *const bindings::mm_struct) -> &'a MmWithUser { > + // SAFETY: Caller promises that the pointer is valid for 'a. The layout is compatible due > + // to repr(transparent). > + unsafe { &*ptr.cast() } > + } > + > + /// Lock the mmap read lock. > + #[inline] > + pub fn mmap_read_lock(&self) -> MmapReadGuard<'_> { > + // SAFETY: The pointer is valid since self is a reference. > + unsafe { bindings::mmap_read_lock(self.as_raw()) }; > + > + // INVARIANT: We just acquired the read lock. > + MmapReadGuard { > + mm: self, > + _nts: NotThreadSafe, > + } > + } > + > + /// Try to lock the mmap read lock. > + #[inline] > + pub fn mmap_read_trylock(&self) -> Option> { > + // SAFETY: The pointer is valid since self is a reference. > + let success = unsafe { bindings::mmap_read_trylock(self.as_raw()) }; > + > + if success { > + // INVARIANT: We just acquired the read lock. > + Some(MmapReadGuard { > + mm: self, > + _nts: NotThreadSafe, > + }) > + } else { > + None > + } > + } > +} > + > +/// A guard for the mmap read lock. > +/// > +/// # Invariants > +/// > +/// This `MmapReadGuard` guard owns the mmap read lock. > +pub struct MmapReadGuard<'a> { > + mm: &'a MmWithUser, > + // `mmap_read_lock` and `mmap_read_unlock` must be called on the same thread > + _nts: NotThreadSafe, > +} > + > +impl Drop for MmapReadGuard<'_> { > + #[inline] > + fn drop(&mut self) { > + // SAFETY: We hold the read lock by the type invariants. > + unsafe { bindings::mmap_read_unlock(self.mm.as_raw()) }; > + } > +} > > -- > 2.47.0.371.ga323438b13-goog >