Expose layout `fn`s in `KnownLayout`

[kupiakos]

Until solutions like #2490 are present for DST construction (and even after), it'd be extremely convenient to get the correct Layout for a given DST with specific tail slice length, considering all of the challenges present in doing that calculation correctly.

So, I propose these operations be exposed on KnownLayout for users:

• Get the Layout for a given usize trailing slice len (where PointerMetadata=usize).
• Extract the pointer metadata.
• Construct a raw pointer with the given pointer metadata.

Consider this utility type

#[derive(Debug, Eq, IntoBytes, Immutable, PartialEq)]
#[repr(C)]
pub struct TpmRequestMessage<T: TpmvRequest + ?Sized> {
    /// The request header
    header: TpmRequestHeader,

    /// Contains fields specific to the type of request being sent
    pub request: T,
}
pub trait TpmvRequest: IntoBytes + Immutable + Unaligned {
    const TAG: U16<BE>;
    const COMMAND_CODE: U16<BE>;
    const ORDINAL: U32<BE>;
    type TpmvResponse: FromBytes + ?Sized + Unaligned;
}

How does one create a constructor for Box<TpmRequestMessage<T>> given a &T or a length of trailing slice in T? It requires manual calculation and being sure about the properties of the TpmvRequest (here bounded by Unaligned). If I have just a &T there's some math, but it still requires transmuteing and assuming layout of raw pointers (SAFETY docs excluded):

impl<T: TpmvRequest + KnownLayout<PointerMetadata = usize> + 'static + ?Sized>
    TpmRequestMessage<T>
{
    pub fn new_box(request: &T) -> Box<Self> {
        let (layout, offset) =
            Layout::new::<TpmRequestHeader>().extend(Layout::for_value(request)).unwrap();
        let p = unsafe { std::alloc::alloc(layout) };
        if p.is_null() {
            std::alloc::handle_alloc_error(layout)
        }
        // There is no less disgusting way to access this `usize`:
        // Rust can't know that `T` has the correct metadata for an `as` cast.
        let request_raw: *const [u8] = transmute(request);
        let trailing_len = request_raw.len();

        unsafe {
            *p.cast() = TpmRequestHeader::for_request::<T>();
            // The `'static` bound limits bad cases like copying `Option<&T>` which can be
            // IntoBytes and TryFromBytes, but `try_from_bytes` would reject converting Some.
            // It might be better to check if you can `TryFromBytes` `request.as_bytes()`?
            p.offset(offset).copy_from_nonoverlapping(
                std::ptr::from_ref(request).cast(),
                std::mem::size_of_val(request),
            );
        }

        let out_slice = std::ptr::slice_from_raw_parts_mut(p, trailing_len);
        unsafe {
            let out_ptr: *mut Self = transmute(out_slice);
            Box::from_raw(out_ptr)
        }
    }
}

But if I just want to construct a zeroed Box<TpmRequestMessage<T>> I'm very out of luck on stable (use FromZeroes::new_box_zeroed_with_elems) - I need to essentially reimplement the DST calculation done by KnownLayout. This results in the temptation to ignore #[doc(hidden)].

[kupiakos]

The safest and stablest approach I've been able to take is using the TryFromBytes machinery to construct the pointers, but it still requires that the user already know a valid size to use:

impl<T: TpmvRequest + FromZeros + KnownLayout<PointerMetadata = usize> + ?Sized>
    TpmRequestMessage<T>
{
    /// Constructs a `TpmRequestMessage` with zeroed `request` bytes and a correct header.
    ///
    /// `request_size` does not include the header.
    ///
    /// # Panics
    /// Panics if `size` is not a correct data size for `T` or if the total size exceed `isize::MAX`.
    pub fn new_zeroed(request_size: usize) -> Box<Self> {
        let total_size = size_of::<TpmRequestHeader>().checked_add(request_size).unwrap();
        assert!(total_size < isize::MAX as usize);
        let mut box_bytes: Box<[u8]> = Box::from(vec![0; total_size]);
        box_bytes[..size_of::<TpmRequestHeader>()]
            .copy_from_slice(TpmRequestHeader::for_request::<T>().as_bytes());
        match <Self as TryFromBytes>::try_mut_from_bytes(Box::leak(box_bytes)) {
            // zerocopy determines the correct trailing slice len
            Ok(x) => unsafe { Box::from_raw(x) },
            Err(e) => {
                let _ = unsafe { Box::<[u8]>::from_raw(e.into_src()) };
                panic!("request_size is not valid for the request type");
            }
        }
    }
}

I can use FromZeros::new_box_zeroed_with_elems iff I have the correct trailing slice len.