Loading...
Note: File does not exist in v5.9.
1// SPDX-License-Identifier: GPL-2.0
2
3//! A reference-counted pointer.
4//!
5//! This module implements a way for users to create reference-counted objects and pointers to
6//! them. Such a pointer automatically increments and decrements the count, and drops the
7//! underlying object when it reaches zero. It is also safe to use concurrently from multiple
8//! threads.
9//!
10//! It is different from the standard library's [`Arc`] in a few ways:
11//! 1. It is backed by the kernel's `refcount_t` type.
12//! 2. It does not support weak references, which allows it to be half the size.
13//! 3. It saturates the reference count instead of aborting when it goes over a threshold.
14//! 4. It does not provide a `get_mut` method, so the ref counted object is pinned.
15//! 5. The object in [`Arc`] is pinned implicitly.
16//!
17//! [`Arc`]: https://doc.rust-lang.org/std/sync/struct.Arc.html
18
19use crate::{
20 alloc::{AllocError, Flags, KBox},
21 bindings,
22 init::{self, InPlaceInit, Init, PinInit},
23 try_init,
24 types::{ForeignOwnable, Opaque},
25};
26use core::{
27 alloc::Layout,
28 fmt,
29 marker::{PhantomData, Unsize},
30 mem::{ManuallyDrop, MaybeUninit},
31 ops::{Deref, DerefMut},
32 pin::Pin,
33 ptr::NonNull,
34};
35use macros::pin_data;
36
37mod std_vendor;
38
39/// A reference-counted pointer to an instance of `T`.
40///
41/// The reference count is incremented when new instances of [`Arc`] are created, and decremented
42/// when they are dropped. When the count reaches zero, the underlying `T` is also dropped.
43///
44/// # Invariants
45///
46/// The reference count on an instance of [`Arc`] is always non-zero.
47/// The object pointed to by [`Arc`] is always pinned.
48///
49/// # Examples
50///
51/// ```
52/// use kernel::sync::Arc;
53///
54/// struct Example {
55/// a: u32,
56/// b: u32,
57/// }
58///
59/// // Create a refcounted instance of `Example`.
60/// let obj = Arc::new(Example { a: 10, b: 20 }, GFP_KERNEL)?;
61///
62/// // Get a new pointer to `obj` and increment the refcount.
63/// let cloned = obj.clone();
64///
65/// // Assert that both `obj` and `cloned` point to the same underlying object.
66/// assert!(core::ptr::eq(&*obj, &*cloned));
67///
68/// // Destroy `obj` and decrement its refcount.
69/// drop(obj);
70///
71/// // Check that the values are still accessible through `cloned`.
72/// assert_eq!(cloned.a, 10);
73/// assert_eq!(cloned.b, 20);
74///
75/// // The refcount drops to zero when `cloned` goes out of scope, and the memory is freed.
76/// # Ok::<(), Error>(())
77/// ```
78///
79/// Using `Arc<T>` as the type of `self`:
80///
81/// ```
82/// use kernel::sync::Arc;
83///
84/// struct Example {
85/// a: u32,
86/// b: u32,
87/// }
88///
89/// impl Example {
90/// fn take_over(self: Arc<Self>) {
91/// // ...
92/// }
93///
94/// fn use_reference(self: &Arc<Self>) {
95/// // ...
96/// }
97/// }
98///
99/// let obj = Arc::new(Example { a: 10, b: 20 }, GFP_KERNEL)?;
100/// obj.use_reference();
101/// obj.take_over();
102/// # Ok::<(), Error>(())
103/// ```
104///
105/// Coercion from `Arc<Example>` to `Arc<dyn MyTrait>`:
106///
107/// ```
108/// use kernel::sync::{Arc, ArcBorrow};
109///
110/// trait MyTrait {
111/// // Trait has a function whose `self` type is `Arc<Self>`.
112/// fn example1(self: Arc<Self>) {}
113///
114/// // Trait has a function whose `self` type is `ArcBorrow<'_, Self>`.
115/// fn example2(self: ArcBorrow<'_, Self>) {}
116/// }
117///
118/// struct Example;
119/// impl MyTrait for Example {}
120///
121/// // `obj` has type `Arc<Example>`.
122/// let obj: Arc<Example> = Arc::new(Example, GFP_KERNEL)?;
123///
124/// // `coerced` has type `Arc<dyn MyTrait>`.
125/// let coerced: Arc<dyn MyTrait> = obj;
126/// # Ok::<(), Error>(())
127/// ```
128pub struct Arc<T: ?Sized> {
129 ptr: NonNull<ArcInner<T>>,
130 _p: PhantomData<ArcInner<T>>,
131}
132
133#[pin_data]
134#[repr(C)]
135struct ArcInner<T: ?Sized> {
136 refcount: Opaque<bindings::refcount_t>,
137 data: T,
138}
139
140impl<T: ?Sized> ArcInner<T> {
141 /// Converts a pointer to the contents of an [`Arc`] into a pointer to the [`ArcInner`].
142 ///
143 /// # Safety
144 ///
145 /// `ptr` must have been returned by a previous call to [`Arc::into_raw`], and the `Arc` must
146 /// not yet have been destroyed.
147 unsafe fn container_of(ptr: *const T) -> NonNull<ArcInner<T>> {
148 let refcount_layout = Layout::new::<bindings::refcount_t>();
149 // SAFETY: The caller guarantees that the pointer is valid.
150 let val_layout = Layout::for_value(unsafe { &*ptr });
151 // SAFETY: We're computing the layout of a real struct that existed when compiling this
152 // binary, so its layout is not so large that it can trigger arithmetic overflow.
153 let val_offset = unsafe { refcount_layout.extend(val_layout).unwrap_unchecked().1 };
154
155 // Pointer casts leave the metadata unchanged. This is okay because the metadata of `T` and
156 // `ArcInner<T>` is the same since `ArcInner` is a struct with `T` as its last field.
157 //
158 // This is documented at:
159 // <https://doc.rust-lang.org/std/ptr/trait.Pointee.html>.
160 let ptr = ptr as *const ArcInner<T>;
161
162 // SAFETY: The pointer is in-bounds of an allocation both before and after offsetting the
163 // pointer, since it originates from a previous call to `Arc::into_raw` on an `Arc` that is
164 // still valid.
165 let ptr = unsafe { ptr.byte_sub(val_offset) };
166
167 // SAFETY: The pointer can't be null since you can't have an `ArcInner<T>` value at the null
168 // address.
169 unsafe { NonNull::new_unchecked(ptr.cast_mut()) }
170 }
171}
172
173// This is to allow coercion from `Arc<T>` to `Arc<U>` if `T` can be converted to the
174// dynamically-sized type (DST) `U`.
175impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::CoerceUnsized<Arc<U>> for Arc<T> {}
176
177// This is to allow `Arc<U>` to be dispatched on when `Arc<T>` can be coerced into `Arc<U>`.
178impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::DispatchFromDyn<Arc<U>> for Arc<T> {}
179
180// SAFETY: It is safe to send `Arc<T>` to another thread when the underlying `T` is `Sync` because
181// it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally, it needs
182// `T` to be `Send` because any thread that has an `Arc<T>` may ultimately access `T` using a
183// mutable reference when the reference count reaches zero and `T` is dropped.
184unsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}
185
186// SAFETY: It is safe to send `&Arc<T>` to another thread when the underlying `T` is `Sync`
187// because it effectively means sharing `&T` (which is safe because `T` is `Sync`); additionally,
188// it needs `T` to be `Send` because any thread that has a `&Arc<T>` may clone it and get an
189// `Arc<T>` on that thread, so the thread may ultimately access `T` using a mutable reference when
190// the reference count reaches zero and `T` is dropped.
191unsafe impl<T: ?Sized + Sync + Send> Sync for Arc<T> {}
192
193impl<T> Arc<T> {
194 /// Constructs a new reference counted instance of `T`.
195 pub fn new(contents: T, flags: Flags) -> Result<Self, AllocError> {
196 // INVARIANT: The refcount is initialised to a non-zero value.
197 let value = ArcInner {
198 // SAFETY: There are no safety requirements for this FFI call.
199 refcount: Opaque::new(unsafe { bindings::REFCOUNT_INIT(1) }),
200 data: contents,
201 };
202
203 let inner = KBox::new(value, flags)?;
204
205 // SAFETY: We just created `inner` with a reference count of 1, which is owned by the new
206 // `Arc` object.
207 Ok(unsafe { Self::from_inner(KBox::leak(inner).into()) })
208 }
209}
210
211impl<T: ?Sized> Arc<T> {
212 /// Constructs a new [`Arc`] from an existing [`ArcInner`].
213 ///
214 /// # Safety
215 ///
216 /// The caller must ensure that `inner` points to a valid location and has a non-zero reference
217 /// count, one of which will be owned by the new [`Arc`] instance.
218 unsafe fn from_inner(inner: NonNull<ArcInner<T>>) -> Self {
219 // INVARIANT: By the safety requirements, the invariants hold.
220 Arc {
221 ptr: inner,
222 _p: PhantomData,
223 }
224 }
225
226 /// Convert the [`Arc`] into a raw pointer.
227 ///
228 /// The raw pointer has ownership of the refcount that this Arc object owned.
229 pub fn into_raw(self) -> *const T {
230 let ptr = self.ptr.as_ptr();
231 core::mem::forget(self);
232 // SAFETY: The pointer is valid.
233 unsafe { core::ptr::addr_of!((*ptr).data) }
234 }
235
236 /// Recreates an [`Arc`] instance previously deconstructed via [`Arc::into_raw`].
237 ///
238 /// # Safety
239 ///
240 /// `ptr` must have been returned by a previous call to [`Arc::into_raw`]. Additionally, it
241 /// must not be called more than once for each previous call to [`Arc::into_raw`].
242 pub unsafe fn from_raw(ptr: *const T) -> Self {
243 // SAFETY: The caller promises that this pointer originates from a call to `into_raw` on an
244 // `Arc` that is still valid.
245 let ptr = unsafe { ArcInner::container_of(ptr) };
246
247 // SAFETY: By the safety requirements we know that `ptr` came from `Arc::into_raw`, so the
248 // reference count held then will be owned by the new `Arc` object.
249 unsafe { Self::from_inner(ptr) }
250 }
251
252 /// Returns an [`ArcBorrow`] from the given [`Arc`].
253 ///
254 /// This is useful when the argument of a function call is an [`ArcBorrow`] (e.g., in a method
255 /// receiver), but we have an [`Arc`] instead. Getting an [`ArcBorrow`] is free when optimised.
256 #[inline]
257 pub fn as_arc_borrow(&self) -> ArcBorrow<'_, T> {
258 // SAFETY: The constraint that the lifetime of the shared reference must outlive that of
259 // the returned `ArcBorrow` ensures that the object remains alive and that no mutable
260 // reference can be created.
261 unsafe { ArcBorrow::new(self.ptr) }
262 }
263
264 /// Compare whether two [`Arc`] pointers reference the same underlying object.
265 pub fn ptr_eq(this: &Self, other: &Self) -> bool {
266 core::ptr::eq(this.ptr.as_ptr(), other.ptr.as_ptr())
267 }
268
269 /// Converts this [`Arc`] into a [`UniqueArc`], or destroys it if it is not unique.
270 ///
271 /// When this destroys the `Arc`, it does so while properly avoiding races. This means that
272 /// this method will never call the destructor of the value.
273 ///
274 /// # Examples
275 ///
276 /// ```
277 /// use kernel::sync::{Arc, UniqueArc};
278 ///
279 /// let arc = Arc::new(42, GFP_KERNEL)?;
280 /// let unique_arc = arc.into_unique_or_drop();
281 ///
282 /// // The above conversion should succeed since refcount of `arc` is 1.
283 /// assert!(unique_arc.is_some());
284 ///
285 /// assert_eq!(*(unique_arc.unwrap()), 42);
286 ///
287 /// # Ok::<(), Error>(())
288 /// ```
289 ///
290 /// ```
291 /// use kernel::sync::{Arc, UniqueArc};
292 ///
293 /// let arc = Arc::new(42, GFP_KERNEL)?;
294 /// let another = arc.clone();
295 ///
296 /// let unique_arc = arc.into_unique_or_drop();
297 ///
298 /// // The above conversion should fail since refcount of `arc` is >1.
299 /// assert!(unique_arc.is_none());
300 ///
301 /// # Ok::<(), Error>(())
302 /// ```
303 pub fn into_unique_or_drop(self) -> Option<Pin<UniqueArc<T>>> {
304 // We will manually manage the refcount in this method, so we disable the destructor.
305 let me = ManuallyDrop::new(self);
306 // SAFETY: We own a refcount, so the pointer is still valid.
307 let refcount = unsafe { me.ptr.as_ref() }.refcount.get();
308
309 // If the refcount reaches a non-zero value, then we have destroyed this `Arc` and will
310 // return without further touching the `Arc`. If the refcount reaches zero, then there are
311 // no other arcs, and we can create a `UniqueArc`.
312 //
313 // SAFETY: We own a refcount, so the pointer is not dangling.
314 let is_zero = unsafe { bindings::refcount_dec_and_test(refcount) };
315 if is_zero {
316 // SAFETY: We have exclusive access to the arc, so we can perform unsynchronized
317 // accesses to the refcount.
318 unsafe { core::ptr::write(refcount, bindings::REFCOUNT_INIT(1)) };
319
320 // INVARIANT: We own the only refcount to this arc, so we may create a `UniqueArc`. We
321 // must pin the `UniqueArc` because the values was previously in an `Arc`, and they pin
322 // their values.
323 Some(Pin::from(UniqueArc {
324 inner: ManuallyDrop::into_inner(me),
325 }))
326 } else {
327 None
328 }
329 }
330}
331
332impl<T: 'static> ForeignOwnable for Arc<T> {
333 type Borrowed<'a> = ArcBorrow<'a, T>;
334
335 fn into_foreign(self) -> *const crate::ffi::c_void {
336 ManuallyDrop::new(self).ptr.as_ptr() as _
337 }
338
339 unsafe fn borrow<'a>(ptr: *const crate::ffi::c_void) -> ArcBorrow<'a, T> {
340 // By the safety requirement of this function, we know that `ptr` came from
341 // a previous call to `Arc::into_foreign`.
342 let inner = NonNull::new(ptr as *mut ArcInner<T>).unwrap();
343
344 // SAFETY: The safety requirements of `from_foreign` ensure that the object remains alive
345 // for the lifetime of the returned value.
346 unsafe { ArcBorrow::new(inner) }
347 }
348
349 unsafe fn from_foreign(ptr: *const crate::ffi::c_void) -> Self {
350 // SAFETY: By the safety requirement of this function, we know that `ptr` came from
351 // a previous call to `Arc::into_foreign`, which guarantees that `ptr` is valid and
352 // holds a reference count increment that is transferrable to us.
353 unsafe { Self::from_inner(NonNull::new(ptr as _).unwrap()) }
354 }
355}
356
357impl<T: ?Sized> Deref for Arc<T> {
358 type Target = T;
359
360 fn deref(&self) -> &Self::Target {
361 // SAFETY: By the type invariant, there is necessarily a reference to the object, so it is
362 // safe to dereference it.
363 unsafe { &self.ptr.as_ref().data }
364 }
365}
366
367impl<T: ?Sized> AsRef<T> for Arc<T> {
368 fn as_ref(&self) -> &T {
369 self.deref()
370 }
371}
372
373impl<T: ?Sized> Clone for Arc<T> {
374 fn clone(&self) -> Self {
375 // INVARIANT: C `refcount_inc` saturates the refcount, so it cannot overflow to zero.
376 // SAFETY: By the type invariant, there is necessarily a reference to the object, so it is
377 // safe to increment the refcount.
378 unsafe { bindings::refcount_inc(self.ptr.as_ref().refcount.get()) };
379
380 // SAFETY: We just incremented the refcount. This increment is now owned by the new `Arc`.
381 unsafe { Self::from_inner(self.ptr) }
382 }
383}
384
385impl<T: ?Sized> Drop for Arc<T> {
386 fn drop(&mut self) {
387 // SAFETY: By the type invariant, there is necessarily a reference to the object. We cannot
388 // touch `refcount` after it's decremented to a non-zero value because another thread/CPU
389 // may concurrently decrement it to zero and free it. It is ok to have a raw pointer to
390 // freed/invalid memory as long as it is never dereferenced.
391 let refcount = unsafe { self.ptr.as_ref() }.refcount.get();
392
393 // INVARIANT: If the refcount reaches zero, there are no other instances of `Arc`, and
394 // this instance is being dropped, so the broken invariant is not observable.
395 // SAFETY: Also by the type invariant, we are allowed to decrement the refcount.
396 let is_zero = unsafe { bindings::refcount_dec_and_test(refcount) };
397 if is_zero {
398 // The count reached zero, we must free the memory.
399 //
400 // SAFETY: The pointer was initialised from the result of `KBox::leak`.
401 unsafe { drop(KBox::from_raw(self.ptr.as_ptr())) };
402 }
403 }
404}
405
406impl<T: ?Sized> From<UniqueArc<T>> for Arc<T> {
407 fn from(item: UniqueArc<T>) -> Self {
408 item.inner
409 }
410}
411
412impl<T: ?Sized> From<Pin<UniqueArc<T>>> for Arc<T> {
413 fn from(item: Pin<UniqueArc<T>>) -> Self {
414 // SAFETY: The type invariants of `Arc` guarantee that the data is pinned.
415 unsafe { Pin::into_inner_unchecked(item).inner }
416 }
417}
418
419/// A borrowed reference to an [`Arc`] instance.
420///
421/// For cases when one doesn't ever need to increment the refcount on the allocation, it is simpler
422/// to use just `&T`, which we can trivially get from an [`Arc<T>`] instance.
423///
424/// However, when one may need to increment the refcount, it is preferable to use an `ArcBorrow<T>`
425/// over `&Arc<T>` because the latter results in a double-indirection: a pointer (shared reference)
426/// to a pointer ([`Arc<T>`]) to the object (`T`). An [`ArcBorrow`] eliminates this double
427/// indirection while still allowing one to increment the refcount and getting an [`Arc<T>`] when/if
428/// needed.
429///
430/// # Invariants
431///
432/// There are no mutable references to the underlying [`Arc`], and it remains valid for the
433/// lifetime of the [`ArcBorrow`] instance.
434///
435/// # Example
436///
437/// ```
438/// use kernel::sync::{Arc, ArcBorrow};
439///
440/// struct Example;
441///
442/// fn do_something(e: ArcBorrow<'_, Example>) -> Arc<Example> {
443/// e.into()
444/// }
445///
446/// let obj = Arc::new(Example, GFP_KERNEL)?;
447/// let cloned = do_something(obj.as_arc_borrow());
448///
449/// // Assert that both `obj` and `cloned` point to the same underlying object.
450/// assert!(core::ptr::eq(&*obj, &*cloned));
451/// # Ok::<(), Error>(())
452/// ```
453///
454/// Using `ArcBorrow<T>` as the type of `self`:
455///
456/// ```
457/// use kernel::sync::{Arc, ArcBorrow};
458///
459/// struct Example {
460/// a: u32,
461/// b: u32,
462/// }
463///
464/// impl Example {
465/// fn use_reference(self: ArcBorrow<'_, Self>) {
466/// // ...
467/// }
468/// }
469///
470/// let obj = Arc::new(Example { a: 10, b: 20 }, GFP_KERNEL)?;
471/// obj.as_arc_borrow().use_reference();
472/// # Ok::<(), Error>(())
473/// ```
474pub struct ArcBorrow<'a, T: ?Sized + 'a> {
475 inner: NonNull<ArcInner<T>>,
476 _p: PhantomData<&'a ()>,
477}
478
479// This is to allow `ArcBorrow<U>` to be dispatched on when `ArcBorrow<T>` can be coerced into
480// `ArcBorrow<U>`.
481impl<T: ?Sized + Unsize<U>, U: ?Sized> core::ops::DispatchFromDyn<ArcBorrow<'_, U>>
482 for ArcBorrow<'_, T>
483{
484}
485
486impl<T: ?Sized> Clone for ArcBorrow<'_, T> {
487 fn clone(&self) -> Self {
488 *self
489 }
490}
491
492impl<T: ?Sized> Copy for ArcBorrow<'_, T> {}
493
494impl<T: ?Sized> ArcBorrow<'_, T> {
495 /// Creates a new [`ArcBorrow`] instance.
496 ///
497 /// # Safety
498 ///
499 /// Callers must ensure the following for the lifetime of the returned [`ArcBorrow`] instance:
500 /// 1. That `inner` remains valid;
501 /// 2. That no mutable references to `inner` are created.
502 unsafe fn new(inner: NonNull<ArcInner<T>>) -> Self {
503 // INVARIANT: The safety requirements guarantee the invariants.
504 Self {
505 inner,
506 _p: PhantomData,
507 }
508 }
509
510 /// Creates an [`ArcBorrow`] to an [`Arc`] that has previously been deconstructed with
511 /// [`Arc::into_raw`].
512 ///
513 /// # Safety
514 ///
515 /// * The provided pointer must originate from a call to [`Arc::into_raw`].
516 /// * For the duration of the lifetime annotated on this `ArcBorrow`, the reference count must
517 /// not hit zero.
518 /// * For the duration of the lifetime annotated on this `ArcBorrow`, there must not be a
519 /// [`UniqueArc`] reference to this value.
520 pub unsafe fn from_raw(ptr: *const T) -> Self {
521 // SAFETY: The caller promises that this pointer originates from a call to `into_raw` on an
522 // `Arc` that is still valid.
523 let ptr = unsafe { ArcInner::container_of(ptr) };
524
525 // SAFETY: The caller promises that the value remains valid since the reference count must
526 // not hit zero, and no mutable reference will be created since that would involve a
527 // `UniqueArc`.
528 unsafe { Self::new(ptr) }
529 }
530}
531
532impl<T: ?Sized> From<ArcBorrow<'_, T>> for Arc<T> {
533 fn from(b: ArcBorrow<'_, T>) -> Self {
534 // SAFETY: The existence of `b` guarantees that the refcount is non-zero. `ManuallyDrop`
535 // guarantees that `drop` isn't called, so it's ok that the temporary `Arc` doesn't own the
536 // increment.
537 ManuallyDrop::new(unsafe { Arc::from_inner(b.inner) })
538 .deref()
539 .clone()
540 }
541}
542
543impl<T: ?Sized> Deref for ArcBorrow<'_, T> {
544 type Target = T;
545
546 fn deref(&self) -> &Self::Target {
547 // SAFETY: By the type invariant, the underlying object is still alive with no mutable
548 // references to it, so it is safe to create a shared reference.
549 unsafe { &self.inner.as_ref().data }
550 }
551}
552
553/// A refcounted object that is known to have a refcount of 1.
554///
555/// It is mutable and can be converted to an [`Arc`] so that it can be shared.
556///
557/// # Invariants
558///
559/// `inner` always has a reference count of 1.
560///
561/// # Examples
562///
563/// In the following example, we make changes to the inner object before turning it into an
564/// `Arc<Test>` object (after which point, it cannot be mutated directly). Note that `x.into()`
565/// cannot fail.
566///
567/// ```
568/// use kernel::sync::{Arc, UniqueArc};
569///
570/// struct Example {
571/// a: u32,
572/// b: u32,
573/// }
574///
575/// fn test() -> Result<Arc<Example>> {
576/// let mut x = UniqueArc::new(Example { a: 10, b: 20 }, GFP_KERNEL)?;
577/// x.a += 1;
578/// x.b += 1;
579/// Ok(x.into())
580/// }
581///
582/// # test().unwrap();
583/// ```
584///
585/// In the following example we first allocate memory for a refcounted `Example` but we don't
586/// initialise it on allocation. We do initialise it later with a call to [`UniqueArc::write`],
587/// followed by a conversion to `Arc<Example>`. This is particularly useful when allocation happens
588/// in one context (e.g., sleepable) and initialisation in another (e.g., atomic):
589///
590/// ```
591/// use kernel::sync::{Arc, UniqueArc};
592///
593/// struct Example {
594/// a: u32,
595/// b: u32,
596/// }
597///
598/// fn test() -> Result<Arc<Example>> {
599/// let x = UniqueArc::new_uninit(GFP_KERNEL)?;
600/// Ok(x.write(Example { a: 10, b: 20 }).into())
601/// }
602///
603/// # test().unwrap();
604/// ```
605///
606/// In the last example below, the caller gets a pinned instance of `Example` while converting to
607/// `Arc<Example>`; this is useful in scenarios where one needs a pinned reference during
608/// initialisation, for example, when initialising fields that are wrapped in locks.
609///
610/// ```
611/// use kernel::sync::{Arc, UniqueArc};
612///
613/// struct Example {
614/// a: u32,
615/// b: u32,
616/// }
617///
618/// fn test() -> Result<Arc<Example>> {
619/// let mut pinned = Pin::from(UniqueArc::new(Example { a: 10, b: 20 }, GFP_KERNEL)?);
620/// // We can modify `pinned` because it is `Unpin`.
621/// pinned.as_mut().a += 1;
622/// Ok(pinned.into())
623/// }
624///
625/// # test().unwrap();
626/// ```
627pub struct UniqueArc<T: ?Sized> {
628 inner: Arc<T>,
629}
630
631impl<T> UniqueArc<T> {
632 /// Tries to allocate a new [`UniqueArc`] instance.
633 pub fn new(value: T, flags: Flags) -> Result<Self, AllocError> {
634 Ok(Self {
635 // INVARIANT: The newly-created object has a refcount of 1.
636 inner: Arc::new(value, flags)?,
637 })
638 }
639
640 /// Tries to allocate a new [`UniqueArc`] instance whose contents are not initialised yet.
641 pub fn new_uninit(flags: Flags) -> Result<UniqueArc<MaybeUninit<T>>, AllocError> {
642 // INVARIANT: The refcount is initialised to a non-zero value.
643 let inner = KBox::try_init::<AllocError>(
644 try_init!(ArcInner {
645 // SAFETY: There are no safety requirements for this FFI call.
646 refcount: Opaque::new(unsafe { bindings::REFCOUNT_INIT(1) }),
647 data <- init::uninit::<T, AllocError>(),
648 }? AllocError),
649 flags,
650 )?;
651 Ok(UniqueArc {
652 // INVARIANT: The newly-created object has a refcount of 1.
653 // SAFETY: The pointer from the `KBox` is valid.
654 inner: unsafe { Arc::from_inner(KBox::leak(inner).into()) },
655 })
656 }
657}
658
659impl<T> UniqueArc<MaybeUninit<T>> {
660 /// Converts a `UniqueArc<MaybeUninit<T>>` into a `UniqueArc<T>` by writing a value into it.
661 pub fn write(mut self, value: T) -> UniqueArc<T> {
662 self.deref_mut().write(value);
663 // SAFETY: We just wrote the value to be initialized.
664 unsafe { self.assume_init() }
665 }
666
667 /// Unsafely assume that `self` is initialized.
668 ///
669 /// # Safety
670 ///
671 /// The caller guarantees that the value behind this pointer has been initialized. It is
672 /// *immediate* UB to call this when the value is not initialized.
673 pub unsafe fn assume_init(self) -> UniqueArc<T> {
674 let inner = ManuallyDrop::new(self).inner.ptr;
675 UniqueArc {
676 // SAFETY: The new `Arc` is taking over `ptr` from `self.inner` (which won't be
677 // dropped). The types are compatible because `MaybeUninit<T>` is compatible with `T`.
678 inner: unsafe { Arc::from_inner(inner.cast()) },
679 }
680 }
681
682 /// Initialize `self` using the given initializer.
683 pub fn init_with<E>(mut self, init: impl Init<T, E>) -> core::result::Result<UniqueArc<T>, E> {
684 // SAFETY: The supplied pointer is valid for initialization.
685 match unsafe { init.__init(self.as_mut_ptr()) } {
686 // SAFETY: Initialization completed successfully.
687 Ok(()) => Ok(unsafe { self.assume_init() }),
688 Err(err) => Err(err),
689 }
690 }
691
692 /// Pin-initialize `self` using the given pin-initializer.
693 pub fn pin_init_with<E>(
694 mut self,
695 init: impl PinInit<T, E>,
696 ) -> core::result::Result<Pin<UniqueArc<T>>, E> {
697 // SAFETY: The supplied pointer is valid for initialization and we will later pin the value
698 // to ensure it does not move.
699 match unsafe { init.__pinned_init(self.as_mut_ptr()) } {
700 // SAFETY: Initialization completed successfully.
701 Ok(()) => Ok(unsafe { self.assume_init() }.into()),
702 Err(err) => Err(err),
703 }
704 }
705}
706
707impl<T: ?Sized> From<UniqueArc<T>> for Pin<UniqueArc<T>> {
708 fn from(obj: UniqueArc<T>) -> Self {
709 // SAFETY: It is not possible to move/replace `T` inside a `Pin<UniqueArc<T>>` (unless `T`
710 // is `Unpin`), so it is ok to convert it to `Pin<UniqueArc<T>>`.
711 unsafe { Pin::new_unchecked(obj) }
712 }
713}
714
715impl<T: ?Sized> Deref for UniqueArc<T> {
716 type Target = T;
717
718 fn deref(&self) -> &Self::Target {
719 self.inner.deref()
720 }
721}
722
723impl<T: ?Sized> DerefMut for UniqueArc<T> {
724 fn deref_mut(&mut self) -> &mut Self::Target {
725 // SAFETY: By the `Arc` type invariant, there is necessarily a reference to the object, so
726 // it is safe to dereference it. Additionally, we know there is only one reference when
727 // it's inside a `UniqueArc`, so it is safe to get a mutable reference.
728 unsafe { &mut self.inner.ptr.as_mut().data }
729 }
730}
731
732impl<T: fmt::Display + ?Sized> fmt::Display for UniqueArc<T> {
733 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
734 fmt::Display::fmt(self.deref(), f)
735 }
736}
737
738impl<T: fmt::Display + ?Sized> fmt::Display for Arc<T> {
739 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
740 fmt::Display::fmt(self.deref(), f)
741 }
742}
743
744impl<T: fmt::Debug + ?Sized> fmt::Debug for UniqueArc<T> {
745 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
746 fmt::Debug::fmt(self.deref(), f)
747 }
748}
749
750impl<T: fmt::Debug + ?Sized> fmt::Debug for Arc<T> {
751 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
752 fmt::Debug::fmt(self.deref(), f)
753 }
754}