Replace mem::zeroed with mem::MaybeUninit::uninit for large struct in unix

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>

library/std/src/sys/net/connection/socket.rs

@@ -557,10 +557,13 @@ impl TcpListener {
     }
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
-        let mut storage: c::sockaddr_storage = unsafe { mem::zeroed() };
+        // The `accept` function will fill in the storage with the address,
+        // so we don't need to zero it here.
+        // reference: https://linux.die.net/man/2/accept4
+        let mut storage: mem::MaybeUninit<c::sockaddr_storage> = mem::MaybeUninit::uninit();
         let mut len = mem::size_of_val(&storage) as c::socklen_t;
-        let sock = self.inner.accept((&raw mut storage) as *mut _, &mut len)?;
+        let sock = self.inner.accept(storage.as_mut_ptr() as *mut _, &mut len)?;
-        let addr = unsafe { socket_addr_from_c(&storage, len as usize)? };
+        let addr = unsafe { socket_addr_from_c(storage.as_ptr(), len as usize)? };
         Ok((TcpStream { inner: sock }, addr))
     }
 

library/std/src/sys/net/connection/socket/unix.rs

@@ -322,7 +322,10 @@ impl Socket {
         buf: &mut [u8],
         flags: c_int,
     ) -> io::Result<(usize, SocketAddr)> {
-        let mut storage: libc::sockaddr_storage = unsafe { mem::zeroed() };
+        // The `recvfrom` function will fill in the storage with the address,
+        // so we don't need to zero it here.
+        // reference: https://linux.die.net/man/2/recvfrom
+        let mut storage: mem::MaybeUninit<libc::sockaddr_storage> = mem::MaybeUninit::uninit();
         let mut addrlen = mem::size_of_val(&storage) as libc::socklen_t;
 
         let n = cvt(unsafe {
@@ -335,7 +338,7 @@ impl Socket {
                 &mut addrlen,
             )
         })?;
-        Ok((n as usize, unsafe { socket_addr_from_c(&storage, addrlen as usize)? }))
+        Ok((n as usize, unsafe { socket_addr_from_c(storage.as_ptr(), addrlen as usize)? }))
     }
 
     pub fn recv_from(&self, buf: &mut [u8]) -> io::Result<(usize, SocketAddr)> {

library/std/src/sys/pal/unix/stack_overflow.rs

@@ -319,9 +319,14 @@ mod imp {
     ))]
     unsafe fn get_stack_start() -> Option<*mut libc::c_void> {
         let mut ret = None;
-        let mut attr: libc::pthread_attr_t = crate::mem::zeroed();
+        let attr: mem::MaybeUninit<libc::pthread_attr_t> = if cfg!(target_os = "freebsd") {
-        #[cfg(target_os = "freebsd")]
+            let mut attr = mem::MaybeUninit::uninit();
-        assert_eq!(libc::pthread_attr_init(&mut attr), 0);
+            assert_eq!(libc::pthread_attr_init((&raw mut attr) as *mut _), 0);
+            attr
+        } else {
+            mem::MaybeUninit::zeroed()
+        };
+        let mut attr = unsafe { attr.assume_init() };
         #[cfg(target_os = "freebsd")]
         let e = libc::pthread_attr_get_np(libc::pthread_self(), &mut attr);
         #[cfg(not(target_os = "freebsd"))]
@@ -509,9 +514,15 @@ mod imp {
     // FIXME: I am probably not unsafe.
     unsafe fn current_guard() -> Option<Range<usize>> {
         let mut ret = None;
-        let mut attr: libc::pthread_attr_t = crate::mem::zeroed();
+        let attr: mem::MaybeUninit<libc::pthread_attr_t> = if cfg!(target_os = "freebsd") {
-        #[cfg(target_os = "freebsd")]
+            let mut attr = mem::MaybeUninit::uninit();
-        assert_eq!(libc::pthread_attr_init(&mut attr), 0);
+            assert_eq!(libc::pthread_attr_init((&raw mut attr) as *mut _), 0);
+            attr
+        } else {
+            mem::MaybeUninit::zeroed()
+        };
+
+        let mut attr = unsafe { attr.assume_init() };
         #[cfg(target_os = "freebsd")]
         let e = libc::pthread_attr_get_np(libc::pthread_self(), &mut attr);
         #[cfg(not(target_os = "freebsd"))]

library/std/src/sys/pal/unix/thread.rs

@@ -49,8 +49,9 @@ impl Thread {
     pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
         let p = Box::into_raw(Box::new(p));
         let mut native: libc::pthread_t = mem::zeroed();
-        let mut attr: libc::pthread_attr_t = mem::zeroed();
+        let mut attr: mem::MaybeUninit<libc::pthread_attr_t> = mem::MaybeUninit::uninit();
-        assert_eq!(libc::pthread_attr_init(&mut attr), 0);
+        assert_eq!(libc::pthread_attr_init((&raw mut attr) as *mut _), 0);
+        let mut attr: libc::pthread_attr_t = unsafe { attr.assume_init() };
 
         #[cfg(target_os = "espidf")]
         if stack > 0 {