What is let dst = unsafe { &mut *(dst as *mut _ as *mut [MaybeUninit<u8>]) }; doing?

[Urhengulas]

I came across following code:

tokio/tokio/src/io/util/read_buf.rs

Lines 53 to 57 in d786553

	let dst = me.buf.bytes_mut();
	let dst = unsafe { &mut *(dst as *mut _ as *mut [MaybeUninit<u8>]) };
	let mut buf = ReadBuf::uninit(dst);
	let ptr = buf.filled().as_ptr();
	ready!(Pin::new(me.reader).poll_read(cx, &mut buf)?);

Can someone please briefly explain what this is doing? I feel especially threatened by line 54...

Thought: If it helps, I think the type of dst is &mut bytes::buf::UninitSlice.

[Darksonn]

The &mut UninitSlice type is a special kind of u8 slice that allows the memory behind it to be uninitialized, but doesn't allow you to de-initialize any memory behind the slice if that memory was already initialized. The unsafe block casts it to an &mut [MaybeUninit<u8>], which is a different kind of slice. The &mut [MaybeUninit<u8>] type also allows the memory behind it to be uninitialized, but allows you to de-initialize memory behind it.

The unsafe block is a promise that we don't de-initialize any memory in the slice that was already initialized. This is correct to do in this case because the ReadBuf type has the following guarantee on unfilled_mut, so the implementer of poll_read can't violate the restriction, as they can only access the slice through the ReadBuf.

The caller must not de-initialize portions of the buffer that have already been initialized. This includes any bytes in the region marked as uninitialized by ReadBuf.

[Urhengulas]

It probably will take me some time to fully understand what you wrote, but Thank you!

[hawkw]

You may find the documentation for UninitSlice helpful.

Essentially, UninitSlice is a wrapper around &mut [MaybeUninit<u8>] that provides safe APIs for writing bytes to the potentially uninitialized slice. Writing to uninitialized memory is safe; but reading from uninitialized memory is not; the UninitSlice interface exposes safe methods for writing but doesn't allow any way to read memory that may be uninitialized. However, the ReadBuf::uninit constructor, which constructs a ReadBuf from an uninitialized slice, doesn't know about the UninitSlice type in bytes. So, it is necessary to cast to the pointer to [MaybeUninit<u8>]. Pointer casts can only be performed for raw pointers, so it's necessary to turn the &mut reference into an *mut, perform the cast, and then re-borrow the cast raw pointer.

[Urhengulas]

Thank you too!