From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from lindbergh.monkeyblade.net (lindbergh.monkeyblade.net [23.128.96.19]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 01D2B11C83 for ; Mon, 28 Aug 2023 10:49:31 +0000 (UTC) Received: from mail-ej1-x64a.google.com (mail-ej1-x64a.google.com [IPv6:2a00:1450:4864:20::64a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 79D2C12F for ; Mon, 28 Aug 2023 03:49:12 -0700 (PDT) Received: by mail-ej1-x64a.google.com with SMTP id a640c23a62f3a-99388334de6so231547866b.0 for ; Mon, 28 Aug 2023 03:49:12 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20221208; t=1693219745; x=1693824545; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=pDP42zhivXOqcs6bhwO68yvQPwPyC5hRmGTeBYgZbjo=; b=SYVXPWup/0Ks6nXMQH+6J2EtHyABPdkhXEFLtjkJc4WrjinWO3O4DLXXavo+jfZHDN INnhDkT1UT/hU3EysH7zORu7nGbRfewp9BHn5X0SoJ4vQ/W+zinqE3wNMlbhkuWFMn0b m/zV2DZSBJZSz70HSvf+NXM6XPHwK3T+dB99fvAUDzXov74YWnJHIZ8cSFuXCZXy38Jw 7M1tfbDiZ+NPI0Uv0TARka+LjGcmAWDDDMJQPjFyrTL9L9AF3T/W5l1r76gQe187Yvuk y9rCKcTjhKuozR8oPg+A8Vd+gEfQm3FALggEScLhA0kYD2ySB395Wh+AVgvYYPaaBqrJ rexw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1693219745; x=1693824545; 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=pDP42zhivXOqcs6bhwO68yvQPwPyC5hRmGTeBYgZbjo=; b=RE5U5aDPNYf3Xt/BRqaWvaK0U7pOsD8OikgsRQGXoHPU+Zw4mirPuBrz/ZT9lLpNmq QMpW2MncWvrPZJEFHxiTTpJRXy827KDN5NLvbtjrZmFBlYcmLVGBK4EClp/oSkNyy4VZ qGPKH3GaMtZ0UPrVQ00ILSxdfzCbL5c4P+XLFxOSaRMso4pp0TMXHCEPONZdFiAylAuN yVpB7vUDFoR3+TC88QOFkV46jStF9XAExHXiWVIX1Ol0Npq/Ic0nCcHry53ssQrC0iKJ VLJDsUuO6wkfXt3LS02nPh4JEmjir/+YWSnnstb/Iy8rvHrcbVxtq7PVIyuRKrwynFU3 IVcg== X-Gm-Message-State: AOJu0YwHkyQ9Dj3p01OX9+039pkANT+XoOxtF8Z2tHYUAMV6jplJvzX/ +iWrOwAkm+2PwlpP6+GFHA1fbKlMgU+TalGasHkPx2PsgXbRm99tjlTQAOLm0q81v2EMYZwlLWT b4H1CDmb86NKadTAcwy/CtccDFXd4i4HSeILbuyFW85yqMJI9zYoyJHBr8sFHn9edqaS1WfUzxy srDXpd X-Google-Smtp-Source: AGHT+IEdOjPh0Uew8IdWm/tyy/0oO+3TUd+SIs77H1knmFnd3hNZemCnPFGJq1OlHiFl5RLAX9VYSyKw8p7K1Ew= X-Received: from aliceryhl.c.googlers.com ([fda3:e722:ac3:cc00:31:98fb:c0a8:6c8]) (user=aliceryhl job=sendgmr) by 2002:a17:907:3546:b0:9a1:c474:8e5f with SMTP id aa6-20020a170907354600b009a1c4748e5fmr352725ejc.8.1693219744499; Mon, 28 Aug 2023 03:49:04 -0700 (PDT) Date: Mon, 28 Aug 2023 10:48:01 +0000 In-Reply-To: <20230828104807.1581592-1-aliceryhl@google.com> Precedence: bulk X-Mailing-List: rust-for-linux@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20230828104807.1581592-1-aliceryhl@google.com> X-Mailer: git-send-email 2.42.0.rc1.204.g551eb34607-goog Message-ID: <20230828104807.1581592-2-aliceryhl@google.com> Subject: [PATCH v4 1/7] rust: sync: add `Arc::{from_raw, into_raw}` From: Alice Ryhl To: rust-for-linux@vger.kernel.org, Tejun Heo , Miguel Ojeda Cc: Lai Jiangshan , Wedson Almeida Filho , Alex Gaynor , Boqun Feng , Gary Guo , "=?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?=" , Benno Lossin , Alice Ryhl , linux-kernel@vger.kernel.org, patches@lists.linux.dev, Wedson Almeida Filho , Martin Rodriguez Reboredo , Andreas Hindborg Content-Type: text/plain; charset="UTF-8" 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_BLOCKED,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 From: Wedson Almeida Filho These methods can be used to turn an `Arc` into a raw pointer and back, in a way that preserves the metadata for fat pointers. This is done using the unstable ptr_metadata feature [1]. However, it could also be done using the unstable pointer_byte_offsets feature [2], which is likely to have a shorter path to stabilization than ptr_metadata. Link: https://github.com/rust-lang/rust/issues/81513 [1] Link: https://github.com/rust-lang/rust/issues/96283 [2] Signed-off-by: Wedson Almeida Filho Co-developed-by: Alice Ryhl Signed-off-by: Alice Ryhl Reviewed-by: Gary Guo Reviewed-by: Martin Rodriguez Reboredo Reviewed-by: Benno Lossin Reviewed-by: Andreas Hindborg --- v3 -> v4: * Update doc comment for `Arc::from_raw`. * Add Reviewed-by for Martin, Benno, and Andreas. rust/kernel/lib.rs | 1 + rust/kernel/sync/arc.rs | 46 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 45 insertions(+), 2 deletions(-) diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index d59041ff5ff2..abeef423d3a8 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -16,6 +16,7 @@ #![feature(coerce_unsized)] #![feature(dispatch_from_dyn)] #![feature(new_uninit)] +#![feature(ptr_metadata)] #![feature(receiver_trait)] #![feature(unsize)] diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs index 172f563976a9..cae2ff44920b 100644 --- a/rust/kernel/sync/arc.rs +++ b/rust/kernel/sync/arc.rs @@ -24,13 +24,13 @@ }; use alloc::boxed::Box; use core::{ - alloc::AllocError, + alloc::{AllocError, Layout}, fmt, marker::{PhantomData, Unsize}, mem::{ManuallyDrop, MaybeUninit}, ops::{Deref, DerefMut}, pin::Pin, - ptr::NonNull, + ptr::{NonNull, Pointee}, }; use macros::pin_data; @@ -212,6 +212,48 @@ unsafe fn from_inner(inner: NonNull>) -> Self { } } + /// Convert the [`Arc`] into a raw pointer. + /// + /// The raw pointer has ownership of the refcount that this Arc object owned. + pub fn into_raw(self) -> *const T { + let ptr = self.ptr.as_ptr(); + core::mem::forget(self); + // SAFETY: The pointer is valid. + unsafe { core::ptr::addr_of!((*ptr).data) } + } + + /// Recreates an [`Arc`] instance previously deconstructed via [`Arc::into_raw`]. + /// + /// # Safety + /// + /// `ptr` must have been returned by a previous call to [`Arc::into_raw`]. Additionally, it + /// must not be called more than once for each previous call to [`Arc::into_raw`]. + pub unsafe fn from_raw(ptr: *const T) -> Self { + let refcount_layout = Layout::new::(); + // SAFETY: The caller guarantees that the pointer is valid. + let val_layout = Layout::for_value(unsafe { &*ptr }); + // SAFETY: We're computing the layout of a real struct that existed when compiling this + // binary, so its layout is not so large that it can trigger arithmetic overflow. + let val_offset = unsafe { refcount_layout.extend(val_layout).unwrap_unchecked().1 }; + + let metadata: ::Metadata = core::ptr::metadata(ptr); + // SAFETY: The metadata of `T` and `ArcInner` is the same because `ArcInner` is a struct + // with `T` as its last field. + // + // This is documented at: + // . + let metadata: as Pointee>::Metadata = + unsafe { core::mem::transmute_copy(&metadata) }; + // SAFETY: The pointer is in-bounds of an allocation both before and after offsetting the + // pointer, since it originates from a previous call to `Arc::into_raw` and is still valid. + let ptr = unsafe { (ptr as *mut u8).sub(val_offset) as *mut () }; + let ptr = core::ptr::from_raw_parts_mut(ptr, metadata); + + // SAFETY: By the safety requirements we know that `ptr` came from `Arc::into_raw`, so the + // reference count held then will be owned by the new `Arc` object. + unsafe { Self::from_inner(NonNull::new_unchecked(ptr)) } + } + /// Returns an [`ArcBorrow`] from the given [`Arc`]. /// /// This is useful when the argument of a function call is an [`ArcBorrow`] (e.g., in a method -- 2.42.0.rc1.204.g551eb34607-goog