diff options
Diffstat (limited to 'src/sys')
-rw-r--r-- | src/sys/ptrace/linux.rs | 7 | ||||
-rw-r--r-- | src/sys/quota.rs | 9 | ||||
-rw-r--r-- | src/sys/select.rs | 11 | ||||
-rw-r--r-- | src/sys/signal.rs | 109 | ||||
-rw-r--r-- | src/sys/signalfd.rs | 13 | ||||
-rw-r--r-- | src/sys/socket/addr.rs | 4 | ||||
-rw-r--r-- | src/sys/socket/mod.rs | 60 | ||||
-rw-r--r-- | src/sys/stat.rs | 24 | ||||
-rw-r--r-- | src/sys/statfs.rs | 12 | ||||
-rw-r--r-- | src/sys/statvfs.rs | 14 | ||||
-rw-r--r-- | src/sys/sysinfo.rs | 7 | ||||
-rw-r--r-- | src/sys/termios.rs | 6 | ||||
-rw-r--r-- | src/sys/utsname.rs | 8 |
13 files changed, 153 insertions, 131 deletions
diff --git a/src/sys/ptrace/linux.rs b/src/sys/ptrace/linux.rs index df15e665..b2b984c3 100644 --- a/src/sys/ptrace/linux.rs +++ b/src/sys/ptrace/linux.rs @@ -221,16 +221,15 @@ pub fn setregs(pid: Pid, regs: user_regs_struct) -> Result<()> { /// and therefore use the data field to return values. This function handles these /// requests. fn ptrace_get_data<T>(request: Request, pid: Pid) -> Result<T> { - // Creates an uninitialized pointer to store result in - let data: T = unsafe { mem::uninitialized() }; + let mut data = mem::MaybeUninit::uninit(); let res = unsafe { libc::ptrace(request as RequestType, libc::pid_t::from(pid), ptr::null_mut::<T>(), - &data as *const _ as *const c_void) + data.as_mut_ptr() as *const _ as *const c_void) }; Errno::result(res)?; - Ok(data) + Ok(unsafe{ data.assume_init() }) } unsafe fn ptrace_other(request: Request, pid: Pid, addr: AddressType, data: *mut c_void) -> Result<c_long> { diff --git a/src/sys/quota.rs b/src/sys/quota.rs index 8946fca2..b056c84d 100644 --- a/src/sys/quota.rs +++ b/src/sys/quota.rs @@ -94,8 +94,7 @@ libc_bitflags!( ); /// Wrapper type for `if_dqblk` -// FIXME: Change to repr(transparent) -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Dqblk(libc::dqblk); @@ -260,9 +259,9 @@ pub fn quotactl_sync<P: ?Sized + NixPath>(which: QuotaType, special: Option<&P>) /// Get disk quota limits and current usage for the given user/group id. pub fn quotactl_get<P: ?Sized + NixPath>(which: QuotaType, special: &P, id: c_int) -> Result<Dqblk> { - let mut dqblk = unsafe { mem::uninitialized() }; - quotactl(QuotaCmd(QuotaSubCmd::Q_GETQUOTA, which), Some(special), id, &mut dqblk as *mut _ as *mut c_char)?; - dqblk + let mut dqblk = mem::MaybeUninit::uninit(); + quotactl(QuotaCmd(QuotaSubCmd::Q_GETQUOTA, which), Some(special), id, dqblk.as_mut_ptr() as *mut c_char)?; + Ok(unsafe{ Dqblk(dqblk.assume_init())}) } /// Configure quota values for the specified fields for a given user/group id. diff --git a/src/sys/select.rs b/src/sys/select.rs index 9d60ffaf..32569acc 100644 --- a/src/sys/select.rs +++ b/src/sys/select.rs @@ -9,16 +9,17 @@ use sys::time::{TimeSpec, TimeVal}; pub use libc::FD_SETSIZE; -// FIXME: Change to repr(transparent) once it's stable -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct FdSet(libc::fd_set); impl FdSet { pub fn new() -> FdSet { - let mut fdset = unsafe { mem::uninitialized() }; - unsafe { libc::FD_ZERO(&mut fdset) }; - FdSet(fdset) + let mut fdset = mem::MaybeUninit::uninit(); + unsafe { + libc::FD_ZERO(fdset.as_mut_ptr()); + FdSet(fdset.assume_init()) + } } pub fn insert(&mut self, fd: RawFd) { diff --git a/src/sys/signal.rs b/src/sys/signal.rs index 51df7b12..41a62e6a 100644 --- a/src/sys/signal.rs +++ b/src/sys/signal.rs @@ -335,17 +335,17 @@ pub struct SigSet { impl SigSet { pub fn all() -> SigSet { - let mut sigset: libc::sigset_t = unsafe { mem::uninitialized() }; - let _ = unsafe { libc::sigfillset(&mut sigset as *mut libc::sigset_t) }; + let mut sigset = mem::MaybeUninit::uninit(); + let _ = unsafe { libc::sigfillset(sigset.as_mut_ptr()) }; - SigSet { sigset } + unsafe{ SigSet { sigset: sigset.assume_init() } } } pub fn empty() -> SigSet { - let mut sigset: libc::sigset_t = unsafe { mem::uninitialized() }; - let _ = unsafe { libc::sigemptyset(&mut sigset as *mut libc::sigset_t) }; + let mut sigset = mem::MaybeUninit::uninit(); + let _ = unsafe { libc::sigemptyset(sigset.as_mut_ptr()) }; - SigSet { sigset } + unsafe{ SigSet { sigset: sigset.assume_init() } } } pub fn add(&mut self, signal: Signal) { @@ -380,9 +380,9 @@ impl SigSet { /// Gets the currently blocked (masked) set of signals for the calling thread. pub fn thread_get_mask() -> Result<SigSet> { - let mut oldmask: SigSet = unsafe { mem::uninitialized() }; - pthread_sigmask(SigmaskHow::SIG_SETMASK, None, Some(&mut oldmask))?; - Ok(oldmask) + let mut oldmask = mem::MaybeUninit::uninit(); + do_pthread_sigmask(SigmaskHow::SIG_SETMASK, None, Some(oldmask.as_mut_ptr()))?; + Ok(unsafe{ SigSet{sigset: oldmask.assume_init()}}) } /// Sets the set of signals as the signal mask for the calling thread. @@ -402,18 +402,20 @@ impl SigSet { /// Sets the set of signals as the signal mask, and returns the old mask. pub fn thread_swap_mask(&self, how: SigmaskHow) -> Result<SigSet> { - let mut oldmask: SigSet = unsafe { mem::uninitialized() }; - pthread_sigmask(how, Some(self), Some(&mut oldmask))?; - Ok(oldmask) + let mut oldmask = mem::MaybeUninit::uninit(); + do_pthread_sigmask(how, Some(self), Some(oldmask.as_mut_ptr()))?; + Ok(unsafe{ SigSet{sigset: oldmask.assume_init()}}) } /// Suspends execution of the calling thread until one of the signals in the /// signal mask becomes pending, and returns the accepted signal. pub fn wait(&self) -> Result<Signal> { - let mut signum: libc::c_int = unsafe { mem::uninitialized() }; - let res = unsafe { libc::sigwait(&self.sigset as *const libc::sigset_t, &mut signum) }; + let mut signum = mem::MaybeUninit::uninit(); + let res = unsafe { libc::sigwait(&self.sigset as *const libc::sigset_t, signum.as_mut_ptr()) }; - Errno::result(res).map(|_| Signal::from_c_int(signum).unwrap()) + Errno::result(res).map(|_| unsafe { + Signal::from_c_int(signum.assume_init()).unwrap() + }) } } @@ -451,20 +453,23 @@ impl SigAction { /// is the `SigAction` variant). `mask` specifies other signals to block during execution of /// the signal-catching function. pub fn new(handler: SigHandler, flags: SaFlags, mask: SigSet) -> SigAction { - let mut s = unsafe { mem::uninitialized::<libc::sigaction>() }; - s.sa_sigaction = match handler { - SigHandler::SigDfl => libc::SIG_DFL, - SigHandler::SigIgn => libc::SIG_IGN, - SigHandler::Handler(f) => f as *const extern fn(libc::c_int) as usize, - SigHandler::SigAction(f) => f as *const extern fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void) as usize, - }; - s.sa_flags = match handler { - SigHandler::SigAction(_) => (flags | SaFlags::SA_SIGINFO).bits(), - _ => (flags - SaFlags::SA_SIGINFO).bits(), - }; - s.sa_mask = mask.sigset; - - SigAction { sigaction: s } + let mut s = mem::MaybeUninit::<libc::sigaction>::uninit(); + unsafe { + let p = s.as_mut_ptr(); + (*p).sa_sigaction = match handler { + SigHandler::SigDfl => libc::SIG_DFL, + SigHandler::SigIgn => libc::SIG_IGN, + SigHandler::Handler(f) => f as *const extern fn(libc::c_int) as usize, + SigHandler::SigAction(f) => f as *const extern fn(libc::c_int, *mut libc::siginfo_t, *mut libc::c_void) as usize, + }; + (*p).sa_flags = match handler { + SigHandler::SigAction(_) => (flags | SaFlags::SA_SIGINFO).bits(), + _ => (flags - SaFlags::SA_SIGINFO).bits(), + }; + (*p).sa_mask = mask.sigset; + + SigAction { sigaction: s.assume_init() } + } } /// Returns the flags set on the action. @@ -501,12 +506,13 @@ impl SigAction { /// the body of the signal-catching function. Be certain to only make syscalls that are explicitly /// marked safe for signal handlers and only share global data using atomics. pub unsafe fn sigaction(signal: Signal, sigaction: &SigAction) -> Result<SigAction> { - let mut oldact = mem::uninitialized::<libc::sigaction>(); + let mut oldact = mem::MaybeUninit::<libc::sigaction>::uninit(); - let res = - libc::sigaction(signal as libc::c_int, &sigaction.sigaction as *const libc::sigaction, &mut oldact as *mut libc::sigaction); + let res = libc::sigaction(signal as libc::c_int, + &sigaction.sigaction as *const libc::sigaction, + oldact.as_mut_ptr()); - Errno::result(res).map(|_| SigAction { sigaction: oldact }) + Errno::result(res).map(|_| SigAction { sigaction: oldact.assume_init() }) } /// Signal management (see [signal(3p)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/signal.html)) @@ -582,6 +588,25 @@ pub unsafe fn signal(signal: Signal, handler: SigHandler) -> Result<SigHandler> }) } +fn do_pthread_sigmask(how: SigmaskHow, + set: Option<&SigSet>, + oldset: Option<*mut libc::sigset_t>) -> Result<()> { + if set.is_none() && oldset.is_none() { + return Ok(()) + } + + let res = unsafe { + // if set or oldset is None, pass in null pointers instead + libc::pthread_sigmask(how as libc::c_int, + set.map_or_else(ptr::null::<libc::sigset_t>, + |s| &s.sigset as *const libc::sigset_t), + oldset.unwrap_or(ptr::null_mut()) + ) + }; + + Errno::result(res).map(drop) +} + /// Manages the signal mask (set of blocked signals) for the calling thread. /// /// If the `set` parameter is `Some(..)`, then the signal mask will be updated with the signal set. @@ -599,21 +624,9 @@ pub unsafe fn signal(signal: Signal, handler: SigHandler) -> Result<SigHandler> /// or [`sigprocmask`](http://pubs.opengroup.org/onlinepubs/9699919799/functions/sigprocmask.html) man pages. pub fn pthread_sigmask(how: SigmaskHow, set: Option<&SigSet>, - oldset: Option<&mut SigSet>) -> Result<()> { - if set.is_none() && oldset.is_none() { - return Ok(()) - } - - let res = unsafe { - // if set or oldset is None, pass in null pointers instead - libc::pthread_sigmask(how as libc::c_int, - set.map_or_else(ptr::null::<libc::sigset_t>, - |s| &s.sigset as *const libc::sigset_t), - oldset.map_or_else(ptr::null_mut::<libc::sigset_t>, - |os| &mut os.sigset as *mut libc::sigset_t)) - }; - - Errno::result(res).map(drop) + oldset: Option<&mut SigSet>) -> Result<()> +{ + do_pthread_sigmask(how, set, oldset.map(|os| &mut os.sigset as *mut _ )) } /// Examine and change blocked signals. diff --git a/src/sys/signalfd.rs b/src/sys/signalfd.rs index 5425a27b..6482eeb3 100644 --- a/src/sys/signalfd.rs +++ b/src/sys/signalfd.rs @@ -98,10 +98,15 @@ impl SignalFd { } pub fn read_signal(&mut self) -> Result<Option<siginfo>> { - let mut buffer: [u8; SIGNALFD_SIGINFO_SIZE] = unsafe { mem::uninitialized() }; - - match unistd::read(self.0, &mut buffer) { - Ok(SIGNALFD_SIGINFO_SIZE) => Ok(Some(unsafe { mem::transmute(buffer) })), + let mut buffer = mem::MaybeUninit::<[u8; SIGNALFD_SIGINFO_SIZE]>::uninit(); + + let res = Errno::result(unsafe { + libc::read(self.0, + buffer.as_mut_ptr() as *mut libc::c_void, + SIGNALFD_SIGINFO_SIZE as libc::size_t) + }).map(|r| r as usize); + match res { + Ok(SIGNALFD_SIGINFO_SIZE) => Ok(Some(unsafe { mem::transmute(buffer.assume_init()) })), Ok(_) => unreachable!("partial read on signalfd"), Err(Error::Sys(Errno::EAGAIN)) => Ok(None), Err(error) => Err(error) diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs index cbec71f7..2ad453f7 100644 --- a/src/sys/socket/addr.rs +++ b/src/sys/socket/addr.rs @@ -475,9 +475,7 @@ impl Ipv6Addr { #[allow(clippy::many_single_char_names)] #[allow(clippy::too_many_arguments)] pub fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr { - let mut in6_addr_var: libc::in6_addr = unsafe{mem::uninitialized()}; - in6_addr_var.s6_addr = to_u8_array!(a,b,c,d,e,f,g,h); - Ipv6Addr(in6_addr_var) + Ipv6Addr(libc::in6_addr{s6_addr: to_u8_array!(a,b,c,d,e,f,g,h)}) } pub fn from_std(std: &net::Ipv6Addr) -> Ipv6Addr { diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 662d8803..beaa69ad 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -854,20 +854,21 @@ pub fn sendmsg(fd: RawFd, iov: &[IoVec<&[u8]>], cmsgs: &[ControlMessage], ptr::null_mut() }; - let mhdr = { + let mhdr = unsafe { // Musl's msghdr has private fields, so this is the only way to // initialize it. - let mut mhdr: msghdr = unsafe{mem::uninitialized()}; - mhdr.msg_name = name as *mut _; - mhdr.msg_namelen = namelen; + let mut mhdr = mem::MaybeUninit::<msghdr>::uninit(); + let p = mhdr.as_mut_ptr(); + (*p).msg_name = name as *mut _; + (*p).msg_namelen = namelen; // transmute iov into a mutable pointer. sendmsg doesn't really mutate // the buffer, but the standard says that it takes a mutable pointer - mhdr.msg_iov = iov.as_ptr() as *mut _; - mhdr.msg_iovlen = iov.len() as _; - mhdr.msg_control = cmsg_ptr; - mhdr.msg_controllen = capacity as _; - mhdr.msg_flags = 0; - mhdr + (*p).msg_iov = iov.as_ptr() as *mut _; + (*p).msg_iovlen = iov.len() as _; + (*p).msg_control = cmsg_ptr; + (*p).msg_controllen = capacity as _; + (*p).msg_flags = 0; + mhdr.assume_init() }; // Encode each cmsg. This must happen after initializing the header because @@ -898,7 +899,7 @@ pub fn recvmsg<'a>(fd: RawFd, iov: &[IoVec<&mut [u8]>], cmsg_buffer: Option<&'a mut dyn CmsgBuffer>, flags: MsgFlags) -> Result<RecvMsg<'a>> { - let mut address: sockaddr_storage = unsafe { mem::uninitialized() }; + let mut address = mem::MaybeUninit::uninit(); let (msg_control, msg_controllen) = match cmsg_buffer { Some(cmsgspace) => { let msg_buf = cmsgspace.as_bytes_mut(); @@ -906,18 +907,19 @@ pub fn recvmsg<'a>(fd: RawFd, iov: &[IoVec<&mut [u8]>], }, None => (ptr::null_mut(), 0), }; - let mut mhdr = { + let mut mhdr = unsafe { // Musl's msghdr has private fields, so this is the only way to // initialize it. - let mut mhdr: msghdr = unsafe{mem::uninitialized()}; - mhdr.msg_name = &mut address as *mut sockaddr_storage as *mut c_void; - mhdr.msg_namelen = mem::size_of::<sockaddr_storage>() as socklen_t; - mhdr.msg_iov = iov.as_ptr() as *mut iovec; - mhdr.msg_iovlen = iov.len() as _; - mhdr.msg_control = msg_control as *mut c_void; - mhdr.msg_controllen = msg_controllen as _; - mhdr.msg_flags = 0; - mhdr + let mut mhdr = mem::MaybeUninit::<msghdr>::uninit(); + let p = mhdr.as_mut_ptr(); + (*p).msg_name = address.as_mut_ptr() as *mut c_void; + (*p).msg_namelen = mem::size_of::<sockaddr_storage>() as socklen_t; + (*p).msg_iov = iov.as_ptr() as *mut iovec; + (*p).msg_iovlen = iov.len() as _; + (*p).msg_control = msg_control as *mut c_void; + (*p).msg_controllen = msg_controllen as _; + (*p).msg_flags = 0; + mhdr.assume_init() }; let ret = unsafe { libc::recvmsg(fd, &mut mhdr, flags.bits()) }; @@ -935,7 +937,9 @@ pub fn recvmsg<'a>(fd: RawFd, iov: &[IoVec<&mut [u8]>], }; let address = unsafe { - sockaddr_storage_to_addr(&address, mhdr.msg_namelen as usize).ok() + sockaddr_storage_to_addr(&address.assume_init(), + mhdr.msg_namelen as usize + ).ok() }; RecvMsg { bytes: r as usize, @@ -1190,18 +1194,18 @@ pub fn setsockopt<O: SetSockOpt>(fd: RawFd, opt: O, val: &O::Val) -> Result<()> /// [Further reading](http://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html) pub fn getpeername(fd: RawFd) -> Result<SockAddr> { unsafe { - let mut addr: sockaddr_storage = mem::uninitialized(); + let mut addr = mem::MaybeUninit::uninit(); let mut len = mem::size_of::<sockaddr_storage>() as socklen_t; let ret = libc::getpeername( fd, - &mut addr as *mut libc::sockaddr_storage as *mut libc::sockaddr, + addr.as_mut_ptr() as *mut libc::sockaddr, &mut len ); Errno::result(ret)?; - sockaddr_storage_to_addr(&addr, len as usize) + sockaddr_storage_to_addr(&addr.assume_init(), len as usize) } } @@ -1210,18 +1214,18 @@ pub fn getpeername(fd: RawFd) -> Result<SockAddr> { /// [Further reading](http://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html) pub fn getsockname(fd: RawFd) -> Result<SockAddr> { unsafe { - let mut addr: sockaddr_storage = mem::uninitialized(); + let mut addr = mem::MaybeUninit::uninit(); let mut len = mem::size_of::<sockaddr_storage>() as socklen_t; let ret = libc::getsockname( fd, - &mut addr as *mut libc::sockaddr_storage as *mut libc::sockaddr, + addr.as_mut_ptr() as *mut libc::sockaddr, &mut len ); Errno::result(ret)?; - sockaddr_storage_to_addr(&addr, len as usize) + sockaddr_storage_to_addr(&addr.assume_init(), len as usize) } } diff --git a/src/sys/stat.rs b/src/sys/stat.rs index 66c8c9dd..29582251 100644 --- a/src/sys/stat.rs +++ b/src/sys/stat.rs @@ -78,49 +78,49 @@ pub fn umask(mode: Mode) -> Mode { } pub fn stat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> { - let mut dst = unsafe { mem::uninitialized() }; + let mut dst = mem::MaybeUninit::uninit(); let res = path.with_nix_path(|cstr| { unsafe { - libc::stat(cstr.as_ptr(), &mut dst as *mut FileStat) + libc::stat(cstr.as_ptr(), dst.as_mut_ptr()) } })?; Errno::result(res)?; - Ok(dst) + Ok(unsafe{dst.assume_init()}) } pub fn lstat<P: ?Sized + NixPath>(path: &P) -> Result<FileStat> { - let mut dst = unsafe { mem::uninitialized() }; + let mut dst = mem::MaybeUninit::uninit(); let res = path.with_nix_path(|cstr| { unsafe { - libc::lstat(cstr.as_ptr(), &mut dst as *mut FileStat) + libc::lstat(cstr.as_ptr(), dst.as_mut_ptr()) } })?; Errno::result(res)?; - Ok(dst) + Ok(unsafe{dst.assume_init()}) } pub fn fstat(fd: RawFd) -> Result<FileStat> { - let mut dst = unsafe { mem::uninitialized() }; - let res = unsafe { libc::fstat(fd, &mut dst as *mut FileStat) }; + let mut dst = mem::MaybeUninit::uninit(); + let res = unsafe { libc::fstat(fd, dst.as_mut_ptr()) }; Errno::result(res)?; - Ok(dst) + Ok(unsafe{dst.assume_init()}) } pub fn fstatat<P: ?Sized + NixPath>(dirfd: RawFd, pathname: &P, f: AtFlags) -> Result<FileStat> { - let mut dst = unsafe { mem::uninitialized() }; + let mut dst = mem::MaybeUninit::uninit(); let res = pathname.with_nix_path(|cstr| { - unsafe { libc::fstatat(dirfd, cstr.as_ptr(), &mut dst as *mut FileStat, f.bits() as libc::c_int) } + unsafe { libc::fstatat(dirfd, cstr.as_ptr(), dst.as_mut_ptr(), f.bits() as libc::c_int) } })?; Errno::result(res)?; - Ok(dst) + Ok(unsafe{dst.assume_init()}) } /// Change the file permission bits of the file specified by a file descriptor. diff --git a/src/sys/statfs.rs b/src/sys/statfs.rs index d4596bf3..c71b5767 100644 --- a/src/sys/statfs.rs +++ b/src/sys/statfs.rs @@ -15,6 +15,7 @@ pub type fsid_t = libc::__fsid_t; pub type fsid_t = libc::fsid_t; #[derive(Clone, Copy)] +#[repr(transparent)] pub struct Statfs(libc::statfs); #[cfg(target_os = "freebsd")] @@ -434,16 +435,17 @@ impl Debug for Statfs { pub fn statfs<P: ?Sized + NixPath>(path: &P) -> Result<Statfs> { unsafe { - let mut stat: Statfs = mem::uninitialized(); - let res = path.with_nix_path(|path| libc::statfs(path.as_ptr(), &mut stat.0))?; - Errno::result(res).map(|_| stat) + let mut stat = mem::MaybeUninit::<libc::statfs>::uninit(); + let res = path.with_nix_path(|path| libc::statfs(path.as_ptr(), stat.as_mut_ptr()))?; + Errno::result(res).map(|_| Statfs(stat.assume_init())) } } pub fn fstatfs<T: AsRawFd>(fd: &T) -> Result<Statfs> { unsafe { - let mut stat: Statfs = mem::uninitialized(); - Errno::result(libc::fstatfs(fd.as_raw_fd(), &mut stat.0)).map(|_| stat) + let mut stat = mem::MaybeUninit::<libc::statfs>::uninit(); + Errno::result(libc::fstatfs(fd.as_raw_fd(), stat.as_mut_ptr())) + .map(|_| Statfs(stat.assume_init())) } } diff --git a/src/sys/statvfs.rs b/src/sys/statvfs.rs index e5980369..26147803 100644 --- a/src/sys/statvfs.rs +++ b/src/sys/statvfs.rs @@ -55,8 +55,7 @@ libc_bitflags!( /// Wrapper around the POSIX `statvfs` struct /// /// For more information see the [`statvfs(3)` man pages](http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html). -// FIXME: Replace with repr(transparent) -#[repr(C)] +#[repr(transparent)] #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Statvfs(libc::statvfs); @@ -124,12 +123,12 @@ impl Statvfs { pub fn statvfs<P: ?Sized + NixPath>(path: &P) -> Result<Statvfs> { unsafe { Errno::clear(); - let mut stat: Statvfs = mem::uninitialized(); + let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit(); let res = path.with_nix_path(|path| - libc::statvfs(path.as_ptr(), &mut stat.0) + libc::statvfs(path.as_ptr(), stat.as_mut_ptr()) )?; - Errno::result(res).map(|_| stat) + Errno::result(res).map(|_| Statvfs(stat.assume_init())) } } @@ -137,8 +136,9 @@ pub fn statvfs<P: ?Sized + NixPath>(path: &P) -> Result<Statvfs> { pub fn fstatvfs<T: AsRawFd>(fd: &T) -> Result<Statvfs> { unsafe { Errno::clear(); - let mut stat: Statvfs = mem::uninitialized(); - Errno::result(libc::fstatvfs(fd.as_raw_fd(), &mut stat.0)).map(|_| stat) + let mut stat = mem::MaybeUninit::<libc::statvfs>::uninit(); + Errno::result(libc::fstatvfs(fd.as_raw_fd(), stat.as_mut_ptr())) + .map(|_| Statvfs(stat.assume_init())) } } diff --git a/src/sys/sysinfo.rs b/src/sys/sysinfo.rs index 4c8e3898..9807b444 100644 --- a/src/sys/sysinfo.rs +++ b/src/sys/sysinfo.rs @@ -7,6 +7,7 @@ use errno::Errno; /// System info structure returned by `sysinfo`. #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)] +#[repr(transparent)] pub struct SysInfo(libc::sysinfo); impl SysInfo { @@ -66,7 +67,7 @@ impl SysInfo { /// /// [See `sysinfo(2)`](http://man7.org/linux/man-pages/man2/sysinfo.2.html). pub fn sysinfo() -> Result<SysInfo> { - let mut info: libc::sysinfo = unsafe { mem::uninitialized() }; - let res = unsafe { libc::sysinfo(&mut info) }; - Errno::result(res).map(|_| SysInfo(info)) + let mut info = mem::MaybeUninit::uninit(); + let res = unsafe { libc::sysinfo(info.as_mut_ptr()) }; + Errno::result(res).map(|_| unsafe{ SysInfo(info.assume_init()) }) } diff --git a/src/sys/termios.rs b/src/sys/termios.rs index c7cdf10b..978e6a9c 100644 --- a/src/sys/termios.rs +++ b/src/sys/termios.rs @@ -1045,13 +1045,13 @@ pub fn cfmakesane(termios: &mut Termios) { /// this structure *will not* reconfigure the port, instead the modifications should be done to /// the `Termios` structure and then the port should be reconfigured using `tcsetattr()`. pub fn tcgetattr(fd: RawFd) -> Result<Termios> { - let mut termios: libc::termios = unsafe { mem::uninitialized() }; + let mut termios = mem::MaybeUninit::uninit(); - let res = unsafe { libc::tcgetattr(fd, &mut termios) }; + let res = unsafe { libc::tcgetattr(fd, termios.as_mut_ptr()) }; Errno::result(res)?; - Ok(termios.into()) + unsafe { Ok(termios.assume_init().into()) } } /// Set the configuration for a terminal (see diff --git a/src/sys/utsname.rs b/src/sys/utsname.rs index ab09c7d2..bf1a814d 100644 --- a/src/sys/utsname.rs +++ b/src/sys/utsname.rs @@ -3,8 +3,8 @@ use libc::{self, c_char}; use std::ffi::CStr; use std::str::from_utf8_unchecked; -#[repr(C)] #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] +#[repr(transparent)] pub struct UtsName(libc::utsname); impl UtsName { @@ -31,9 +31,9 @@ impl UtsName { pub fn uname() -> UtsName { unsafe { - let mut ret: UtsName = mem::uninitialized(); - libc::uname(&mut ret.0); - ret + let mut ret = mem::MaybeUninit::uninit(); + libc::uname(ret.as_mut_ptr()); + UtsName(ret.assume_init()) } } |