projects/linux·blob master · refs

160 lines · 5.2 KiB

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2
3#[cfg(all(feature = "alloc", not(feature = "std")))]
4use alloc::{boxed::Box, sync::Arc};
5#[cfg(feature = "alloc")]
6use core::alloc::AllocError;
7use core::{mem::MaybeUninit, pin::Pin};
8#[cfg(feature = "std")]
9use std::sync::Arc;
10
11#[cfg(not(feature = "alloc"))]
12type AllocError = core::convert::Infallible;
13
14use crate::{
15 init_from_closure, pin_init_from_closure, InPlaceWrite, Init, PinInit, ZeroableOption,
16};
17
18pub extern crate alloc;
19
20// SAFETY: All zeros is equivalent to `None` (option layout optimization guarantee:
21// <https://doc.rust-lang.org/stable/std/option/index.html#representation>).
22unsafe impl<T> ZeroableOption for Box<T> {}
23
24/// Smart pointer that can initialize memory in-place.
25pub trait InPlaceInit<T>: Sized {
26 /// Use the given pin-initializer to pin-initialize a `T` inside of a new smart pointer of this
27 /// type.
28 ///
29 /// If `T: !Unpin` it will not be able to move afterwards.
30 fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
31 where
32 E: From<AllocError>;
33
34 /// Use the given pin-initializer to pin-initialize a `T` inside of a new smart pointer of this
35 /// type.
36 ///
37 /// If `T: !Unpin` it will not be able to move afterwards.
38 #[inline]
39 fn pin_init(init: impl PinInit<T>) -> Result<Pin<Self>, AllocError> {
40 // SAFETY: We delegate to `init` and only change the error type.
41 let init = unsafe {
42 pin_init_from_closure(|slot| match init.__init(slot) {
43 Ok(()) => Ok(()),
44 Err(i) => match i {},
45 })
46 };
47 Self::try_pin_init(init)
48 }
49
50 /// Use the given initializer to in-place initialize a `T`.
51 fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
52 where
53 E: From<AllocError>;
54
55 /// Use the given initializer to in-place initialize a `T`.
56 #[inline]
57 fn init(init: impl Init<T>) -> Result<Self, AllocError> {
58 // SAFETY: We delegate to `init` and only change the error type.
59 let init = unsafe {
60 init_from_closure(|slot| match init.__init(slot) {
61 Ok(()) => Ok(()),
62 Err(i) => match i {},
63 })
64 };
65 Self::try_init(init)
66 }
67}
68
69#[cfg(feature = "alloc")]
70macro_rules! try_new_uninit {
71 ($type:ident) => {
72 $type::try_new_uninit()?
73 };
74}
75#[cfg(all(feature = "std", not(feature = "alloc")))]
76macro_rules! try_new_uninit {
77 ($type:ident) => {
78 $type::new_uninit()
79 };
80}
81
82impl<T> InPlaceInit<T> for Box<T> {
83 #[inline]
84 fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
85 where
86 E: From<AllocError>,
87 {
88 try_new_uninit!(Box).write_pin_init(init)
89 }
90
91 #[inline]
92 fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
93 where
94 E: From<AllocError>,
95 {
96 try_new_uninit!(Box).write_init(init)
97 }
98}
99
100impl<T> InPlaceInit<T> for Arc<T> {
101 #[inline]
102 fn try_pin_init<E>(init: impl PinInit<T, E>) -> Result<Pin<Self>, E>
103 where
104 E: From<AllocError>,
105 {
106 let mut this = try_new_uninit!(Arc);
107 let Some(slot) = Arc::get_mut(&mut this) else {
108 // SAFETY: the Arc has just been created and has no external references
109 unsafe { core::hint::unreachable_unchecked() }
110 };
111 let slot = slot.as_mut_ptr();
112 // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
113 // slot is valid and will not be moved, because we pin it later.
114 unsafe { init.__init(slot)? };
115 // SAFETY: All fields have been initialized and this is the only `Arc` to that data.
116 Ok(unsafe { Pin::new_unchecked(this.assume_init()) })
117 }
118
119 #[inline]
120 fn try_init<E>(init: impl Init<T, E>) -> Result<Self, E>
121 where
122 E: From<AllocError>,
123 {
124 let mut this = try_new_uninit!(Arc);
125 let Some(slot) = Arc::get_mut(&mut this) else {
126 // SAFETY: the Arc has just been created and has no external references
127 unsafe { core::hint::unreachable_unchecked() }
128 };
129 let slot = slot.as_mut_ptr();
130 // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
131 // slot is valid.
132 unsafe { init.__init(slot)? };
133 // SAFETY: All fields have been initialized.
134 Ok(unsafe { this.assume_init() })
135 }
136}
137
138impl<T> InPlaceWrite<T> for Box<MaybeUninit<T>> {
139 type Initialized = Box<T>;
140
141 #[inline]
142 fn write_init<E>(mut self, init: impl Init<T, E>) -> Result<Self::Initialized, E> {
143 let slot = self.as_mut_ptr();
144 // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
145 // slot is valid.
146 unsafe { init.__init(slot)? };
147 // SAFETY: All fields have been initialized.
148 Ok(unsafe { self.assume_init() })
149 }
150
151 #[inline]
152 fn write_pin_init<E>(mut self, init: impl PinInit<T, E>) -> Result<Pin<Self::Initialized>, E> {
153 let slot = self.as_mut_ptr();
154 // SAFETY: When init errors/panics, slot will get deallocated but not dropped,
155 // slot is valid and will not be moved, because we pin it later.
156 unsafe { init.__init(slot)? };
157 // SAFETY: All fields have been initialized.
158 Ok(unsafe { self.assume_init() }.into())
159 }
160}