diff --git a/src/platform/redox/mod.rs b/src/platform/redox/mod.rs index 238687a2d3..c4a5a27989 100644 --- a/src/platform/redox/mod.rs +++ b/src/platform/redox/mod.rs @@ -136,7 +136,7 @@ impl Pal for Sys { let perms = (if stat.st_uid == uid { stat.st_mode >> (3 * 2) } else if stat.st_gid == gid { - stat.st_mode >> (3 * 1) + stat.st_mode >> 3 } else { stat.st_mode }) & 0o7; @@ -169,7 +169,7 @@ impl Pal for Sys { unsafe { BRK_CUR = allocated; - BRK_END = (allocated as *mut u8).add(BRK_MAX_SIZE) as *mut c_void + BRK_END = allocated.cast::().add(BRK_MAX_SIZE).cast::() }; } @@ -187,7 +187,7 @@ impl Pal for Sys { } fn chdir(path: CStr) -> Result<()> { - let path = RedoxStr::new_c(path.to_cstr()).ok_or_else(|| Errno(EINVAL))?; + let path = RedoxStr::new_c(path.to_cstr()).ok_or(Errno(EINVAL))?; path::chdir(path)?; Ok(()) } @@ -208,11 +208,11 @@ impl Pal for Sys { CLOCK_MONOTONIC => "/scheme/time/4/getres", _ => return Err(Errno(EINVAL)), }; - let timerfd = FdGuard::open(&path, syscall::O_RDONLY)?; + let timerfd = FdGuard::open(path, syscall::O_RDONLY)?; let mut redox_res = timespec::default(); let buffer = unsafe { slice::from_raw_parts_mut( - &mut redox_res as *mut _ as *mut u8, + (&raw mut redox_res).cast::(), mem::size_of::(), ) }; @@ -347,7 +347,7 @@ impl Pal for Sys { let start = start as u64 | if is_ofd { 1 << 63 } else { 0 }; let len = len as u64; - match flock.l_type as i32 { + match i32::from(flock.l_type) { F_UNLCK => { let meta = StdFsCallMeta::new(StdFsCallKind::Unlock, start, len); syscall::std_fs_call(fd as usize, &mut [], &meta)?; @@ -358,7 +358,7 @@ impl Pal for Sys { let meta = StdFsCallMeta::new( StdFsCallKind::Lock, start, - len | if flock.l_type as i32 == F_WRLCK { + len | if i32::from(flock.l_type) == F_WRLCK { 1 << 63 } else { 0 @@ -394,7 +394,7 @@ impl Pal for Sys { } let mut len = len as u64; - if flock.l_type as i32 == F_WRLCK { + if i32::from(flock.l_type) == F_WRLCK { len |= 1 << 63; } @@ -510,7 +510,7 @@ impl Pal for Sys { #[inline] unsafe fn futex_wait(addr: *mut u32, val: u32, deadline: Option<×pec>) -> Result<()> { - let deadline = deadline.map(|d| syscall::TimeSpec::from(d)); + let deadline = deadline.map(syscall::TimeSpec::from); (unsafe { redox_rt::sys::sys_futex_wait(addr, val, deadline.as_ref()) })?; Ok(()) } @@ -559,7 +559,7 @@ impl Pal for Sys { // NOTE: fn is unsafe, but this just means we can assume more things. impl is safe unsafe fn dent_reclen_offset(this_dent: &[u8], offset: usize) -> Option<(u16, u64)> { let mut header = DirentHeader::default(); - header.copy_from_slice(&this_dent.get(..size_of::())?); + header.copy_from_slice(this_dent.get(..size_of::())?); // If scheme does not send a NUL byte, this shouldn't be able to cause UB for the caller. if this_dent.get(usize::from(header.record_len) - 1) != Some(&b'\0') { @@ -613,7 +613,7 @@ impl Pal for Sys { } if found { - if !list.is_empty() && (count as usize) < list.len() { + if !list.is_empty() && count < list.len() { list.index(count).write(grp.gr_gid); } count += 1; @@ -622,7 +622,7 @@ impl Pal for Sys { grp::endgrent(); } - if !list.is_empty() && (count as usize) > list.len() { + if !list.is_empty() && count > list.len() { return Err(Errno(EINVAL)); } @@ -646,9 +646,9 @@ impl Pal for Sys { } fn getpriority(which: c_int, who: id_t) -> Result { - match redox_rt::sys::posix_getpriority(which, who as u32) { + match redox_rt::sys::posix_getpriority(which, who) { Ok(kernel_prio) => { - let posix_prio = (kernel_prio as i32 * -1) + 40 as i32; + let posix_prio = -(kernel_prio as i32) + 40_i32; Ok(posix_prio) } Err(e) => Err(Errno(e.errno)), @@ -773,7 +773,7 @@ impl Pal for Sys { if (flags & !(AT_SYMLINK_FOLLOW)) != 0 { return Err(Errno(EINVAL)); } - let newpath = RedoxStr::new_c(newpath.to_cstr()).ok_or_else(|| Errno(EINVAL))?; + let newpath = RedoxStr::new_c(newpath.to_cstr()).ok_or(Errno(EINVAL))?; // By default, we don't follow the symlink if there is one. // We only follow it if AT_SYMLINK_FOLLOW is passed in flags. @@ -939,7 +939,7 @@ impl Pal for Sys { redox_rmtp = unsafe { (&*rmtp).into() }; } match redox_rt::sys::posix_nanosleep(&redox_rqtp, &mut redox_rmtp) { - Ok(_) => Ok(()), + Ok(()) => Ok(()), Err(Error { errno: EINTR }) => { unsafe { if !rmtp.is_null() { @@ -987,7 +987,7 @@ impl Pal for Sys { let total_offset = offset.checked_add(length).ok_or(Errno(EFBIG))?; let mut stat: stat = unsafe { mem::zeroed() }; - unsafe { libredox::fstat(fd as usize, &mut stat)? }; + unsafe { libredox::fstat(fd as usize, &raw mut stat)? }; let st_size = stat.st_size as u64; // The difference between total_offset and the file size is the number of bytes to // allocate. So, if it's negative then the file is already large enough and we don't @@ -1076,7 +1076,7 @@ impl Pal for Sys { let redox_path = str::from_utf8(&buf[..count]) .ok() - .and_then(|x| redox_path::RedoxPath::from_absolute(x)) + .and_then(redox_path::RedoxPath::from_absolute) .ok_or(Errno(EINVAL))?; let (scheme, reference) = redox_path.as_parts().ok_or(Errno(EINVAL))?; @@ -1163,8 +1163,8 @@ impl Pal for Sys { let clamped_prio = prio.clamp(-20, 19); let kernel_prio = (20 + clamped_prio) as u32; - match redox_rt::sys::posix_setpriority(which, who as u32, kernel_prio) { - Ok(_) => Ok(()), + match redox_rt::sys::posix_setpriority(which, who, kernel_prio) { + Ok(()) => Ok(()), Err(e) => Err(Errno(e.errno)), } } @@ -1237,7 +1237,7 @@ impl Pal for Sys { } } - args[0] = &program.to_bytes(); + args[0] = program.to_bytes(); let new_file_table = child.thr_fd.dup_into_upper(b"filetable-binary")?; @@ -1544,7 +1544,7 @@ impl Pal for Sys { CLOCK_MONOTONIC => "/scheme/time/4", _ => return Err(Errno(EINVAL)), }; - let timerfd = FdGuard::open_into_upper(&path, syscall::O_RDWR)?; + let timerfd = FdGuard::open_into_upper(path, syscall::O_RDWR)?; let eventfd = FdGuard::new(Error::demux(unsafe { event::redox_event_queue_create_v1(0) })?) @@ -1565,7 +1565,7 @@ impl Pal for Sys { let mut memory_pointer: *mut timer_internal_t = ptr::null_mut(); unsafe { let result = posix_memalign( - (&mut memory_pointer as *mut *mut timer_internal_t).cast(), + (&raw mut memory_pointer).cast(), align_of::(), size_of::(), ); @@ -1616,11 +1616,11 @@ impl Pal for Sys { let timer_st = unsafe { timer_internal_t::from_raw(timerid) }; let mut now = timespec::default(); Self::clock_gettime(timer_st.clockid, Out::from_mut(&mut now))?; - if timer_st.evp.sigev_notify == SIGEV_NONE { - if timespec::subtract(&timer_st.next_wake_time.it_value, &now).is_none() { - // error here means the timer is disarmed - let _ = timer_update_wake_time(timer_st); - } + if timer_st.evp.sigev_notify == SIGEV_NONE + && timespec::subtract(&timer_st.next_wake_time.it_value, &now).is_none() + { + // error here means the timer is disarmed + let _ = timer_update_wake_time(timer_st); } let remaining = &timer_st.next_wake_time.it_value; value.write(if remaining.is_zero() { @@ -1685,10 +1685,10 @@ impl Pal for Sys { let mut tid = pthread_t::default(); let result = unsafe { pthread_create( - &mut tid as *mut _, + &raw mut tid, ptr::null(), timer_routine, - timerid as *mut c_void, + timerid.cast::(), ) }; if result != 0 { @@ -1742,21 +1742,19 @@ impl Pal for Sys { } match gethostname(nodename.as_slice_mut().cast_slice_to::()) { - Ok(_) => (), + Ok(()) => (), Err(_) => return Err(Errno(EIO)), } let file_path = c"/scheme/sys/uname".into(); - let mut file = match File::open(file_path, fcntl::O_RDONLY | fcntl::O_CLOEXEC) { - Ok(ok) => ok, - Err(_) => return Err(Errno(EIO)), + let Ok(mut file) = File::open(file_path, fcntl::O_RDONLY | fcntl::O_CLOEXEC) else { + return Err(Errno(EIO)); }; let mut lines = BufReader::new(&mut file).lines(); let mut read_line = |mut dst: Out<[u8]>| { - let mut line = match lines.next() { - Some(Ok(l)) => l, - None | Some(Err(_)) => return Err(Errno(EIO)), + let Some(Ok(mut line)) = lines.next() else { + return Err(Errno(EIO)); }; line.push('\0'); let line_slice: &[u8] = line.as_bytes(); @@ -1900,7 +1898,7 @@ impl Sys { len: off_t, ) -> Result<(off_t, off_t)> { // let file_off = Self::lseek(fd, 0, SEEK_SET)?; - match whence as i32 { + match i32::from(whence) { SEEK_SET => { let (start, len) = if len < 0 { (start + len, -len) diff --git a/src/platform/redox/socket.rs b/src/platform/redox/socket.rs index 0a3c25e2d6..27a9ae5195 100644 --- a/src/platform/redox/socket.rs +++ b/src/platform/redox/socket.rs @@ -42,16 +42,16 @@ unsafe fn bind_or_connect( return Err(Errno(EINVAL)); } - let path = match unsafe { (*address).sa_family } as c_int { + let path = match c_int::from(unsafe { (*address).sa_family }) { AF_INET => { if (address_len as usize) != mem::size_of::() { return Err(Errno(EINVAL)); } - let data = unsafe { &*(address as *const sockaddr_in) }; + let data = unsafe { &*address.cast::() }; let addr = unsafe { slice::from_raw_parts( - &data.sin_addr.s_addr as *const _ as *const u8, + (&raw const data.sin_addr.s_addr).cast::(), mem::size_of_val(&data.sin_addr.s_addr), ) }; @@ -101,12 +101,12 @@ pub unsafe fn bind_or_connect_into( } unsafe fn inner_af_unix(buf: &[u8], address: *mut sockaddr, address_len: *mut socklen_t) { - let data = unsafe { &mut *(address as *mut sockaddr_un) }; + let data = unsafe { &mut *address.cast::() }; data.sun_family = AF_UNIX as c_ushort; let path = unsafe { - slice::from_raw_parts_mut(&mut data.sun_path as *mut _ as *mut u8, data.sun_path.len()) + slice::from_raw_parts_mut((&raw mut data.sun_path).cast::(), data.sun_path.len()) }; let len = cmp::min(path.len(), buf.len()); @@ -142,11 +142,11 @@ unsafe fn inner_af_inet( // Make address be followed by a NUL-byte colon[0] = b'\0'; - log::trace!("address: {:?}, port: {:?}", str::from_utf8(&raw_addr), port); + log::trace!("address: {:?}, port: {:?}", str::from_utf8(raw_addr), port); let mut addr = in_addr::default(); assert_eq!( - unsafe { inet_aton(raw_addr.as_ptr() as *mut c_char, &mut addr) }, + unsafe { inet_aton(raw_addr.as_ptr() as *mut c_char, &raw mut addr) }, 1, "inet_aton might be broken, failed to parse netstack address" ); @@ -161,7 +161,7 @@ unsafe fn inner_af_inet( let len = cmp::min(unsafe { *address_len } as usize, mem::size_of_val(&ret)); unsafe { - ptr::copy_nonoverlapping(&ret as *const _ as *const u8, address as *mut u8, len); + ptr::copy_nonoverlapping((&raw const ret).cast::(), address.cast::(), len); *address_len = len as socklen_t; } } @@ -282,11 +282,11 @@ unsafe fn serialize_ancillary_data_to_stream( let fds_usize: Vec = c_fds.iter().map(|&fd| fd as usize).collect(); let fds_slice = unsafe { slice::from_raw_parts( - fds_usize.as_ptr() as *const u8, + fds_usize.as_ptr().cast::(), fds_usize.len() * mem::size_of::(), ) }; - redox_rt::sys::sys_call_wo(socket as usize, &fds_slice, CallFlags::FD, &[])?; + redox_rt::sys::sys_call_wo(socket as usize, fds_slice, CallFlags::FD, &[])?; } // Serialize to ancillary_data_stream. @@ -300,7 +300,7 @@ unsafe fn serialize_ancillary_data_to_stream( (SOL_SOCKET, SCM_CREDENTIALS) => { // Our intermediate format: data_len is 0, no data payload let data_for_stream_len = 0usize; - msg_stream.extend_from_slice(&(data_for_stream_len as usize).to_le_bytes()); + msg_stream.extend_from_slice(&data_for_stream_len.to_le_bytes()); } _ => { return Err(Errno(EOPNOTSUPP)); @@ -330,8 +330,8 @@ unsafe fn deserialize_name_from_stream( (unsafe { inner_get_name_inner( false, - mhdr.msg_name as *mut sockaddr, - &mut mhdr.msg_namelen, + mhdr.msg_name.cast::(), + &raw mut mhdr.msg_namelen, name_buffer, ) })?; @@ -380,7 +380,7 @@ unsafe fn deserialize_payload_from_stream( let bytes_to_write = cmp::min(iov.iov_len, source_bytes_remaining); if bytes_to_write > 0 { let dest_slice: &mut [u8] = - unsafe { slice::from_raw_parts_mut(iov.iov_base as *mut u8, iov.iov_len) }; + unsafe { slice::from_raw_parts_mut(iov.iov_base.cast::(), iov.iov_len) }; let source_sub_slice = &payload_data_from_stream [source_bytes_consumed..source_bytes_consumed + bytes_to_write]; @@ -448,13 +448,13 @@ unsafe fn deserialize_ancillary_data_from_stream( if cmsg_data_len_in_stream != mem::size_of::() { return Err(Errno(EINVAL)); } - let fd_count = read_num::(&cmsg_data_from_stream)?; + let fd_count = read_num::(cmsg_data_from_stream)?; let mut fds_usize = vec![0usize; fd_count]; let fds_bytes = unsafe { slice::from_raw_parts_mut( - fds_usize.as_mut_ptr() as *mut u8, + fds_usize.as_mut_ptr().cast::(), fds_usize.len() * mem::size_of::(), ) }; @@ -478,7 +478,7 @@ unsafe fn deserialize_ancillary_data_from_stream( return Err(Errno(EINVAL)); } - let pid = read_num::(&cmsg_data_from_stream)?; + let pid = read_num::(cmsg_data_from_stream)?; let uid_offset = mem::size_of::(); let uid = read_num::(&cmsg_data_from_stream[uid_offset..])?; let gid_offset = uid_offset + mem::size_of::(); @@ -486,10 +486,7 @@ unsafe fn deserialize_ancillary_data_from_stream( let cred = ucred { pid, uid, gid }; temp_posix_cmsg_data_buf.extend_from_slice(unsafe { - slice::from_raw_parts( - &cred as *const ucred as *const u8, - mem::size_of::(), - ) + slice::from_raw_parts((&raw const cred).cast::(), mem::size_of::()) }); temp_posix_cmsg_data_buf.len() } @@ -513,7 +510,7 @@ unsafe fn deserialize_ancillary_data_from_stream( unsafe { ptr::copy_nonoverlapping( temp_posix_cmsg_data_buf.as_ptr(), - data_ptr_in_user_cmsg as *mut u8, + data_ptr_in_user_cmsg.cast::(), actual_posix_cmsg_data_len, ) }; @@ -539,22 +536,23 @@ impl PalSocket for Sys { address_len: *mut socklen_t, ) -> Result { let stream = redox_rt::sys::dup(socket as usize, b"listen")?; - if address != ptr::null_mut() && address_len != ptr::null_mut() { - if let Err(err) = unsafe { Self::getpeername(stream as c_int, address, address_len) } { - let _ = redox_rt::sys::close(stream); - return Err(err); - } + if !address.is_null() + && !address_len.is_null() + && let Err(err) = unsafe { Self::getpeername(stream as c_int, address, address_len) } + { + let _ = redox_rt::sys::close(stream); + return Err(err); } Ok(stream as c_int) } unsafe fn bind(socket: c_int, address: *const sockaddr, address_len: socklen_t) -> Result<()> { - match unsafe { (*address).sa_family } as c_int { + match c_int::from(unsafe { (*address).sa_family }) { AF_INET => { (unsafe { bind_or_connect_into(SocketCall::Bind, socket, address, address_len) })?; } AF_UNIX => { - let data = unsafe { &*(address as *const sockaddr_un) }; + let data = unsafe { &*address.cast::() }; // NOTE: It's UB to access data in given address that exceeds // the given address length. @@ -569,11 +567,12 @@ impl PalSocket for Sys { // The maximum length of the address maxlen, // The first NUL byte, if any + // TODO triggers clippy::borrow_as_ptr, applying suggestion fails to compile unsafe { strnlen(&data.sun_path as *const _, maxlen as size_t) }, ); let addr = - unsafe { slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len) }; + unsafe { slice::from_raw_parts((&raw const data.sun_path).cast::(), len) }; let path = str::from_utf8(addr).map_err(|_| Errno(EINVAL))?; log::trace!("bind(): path: {:?}", path); @@ -635,12 +634,12 @@ impl PalSocket for Sys { address: *const sockaddr, address_len: socklen_t, ) -> Result { - match unsafe { (*address).sa_family } as c_int { + match c_int::from(unsafe { (*address).sa_family }) { AF_INET => unsafe { bind_or_connect_into(SocketCall::Connect, socket, address, address_len) }, AF_UNIX => { - let data = unsafe { &*(address as *const sockaddr_un) }; + let data = unsafe { &*address.cast::() }; // NOTE: It's UB to access data in given address that exceeds // the given address length. @@ -655,11 +654,12 @@ impl PalSocket for Sys { // The maximum length of the address maxlen, // The first NUL byte, if any + // TODO triggers clippy::borrow_as_ptr, applying suggestion fails to compile unsafe { strnlen(&data.sun_path as *const _, maxlen as size_t) }, ); let addr = - unsafe { slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len) }; + unsafe { slice::from_raw_parts((&raw const data.sun_path).cast::(), len) }; let path = str::from_utf8(addr).map_err(|_| Errno(EINVAL))?; log::trace!("bind(): path: {:?}", path); @@ -743,11 +743,12 @@ impl PalSocket for Sys { return Err(Errno(EINVAL)); } - Ok(unsafe { &mut *(option_value as *mut c_int) }) + Ok(unsafe { &mut *option_value.cast::() }) }; - match level { - SOL_SOCKET => match option_name { + // TODO convert back to match when we support more levels + if level == SOL_SOCKET { + match option_name { SO_DOMAIN => { let option = option_c_int()?; *option = socket_domain_type(socket)?.0; @@ -770,7 +771,7 @@ impl PalSocket for Sys { _ => { let metadata = [SocketCall::GetSockOpt as u64, option_name as u64]; let payload = - unsafe { slice::from_raw_parts_mut(option_value as *mut u8, option_len) }; + unsafe { slice::from_raw_parts_mut(option_value.cast::(), option_len) }; let call_flags = CallFlags::empty(); unsafe { *option_len_ptr = redox_rt::sys::sys_call_ro( @@ -782,8 +783,7 @@ impl PalSocket for Sys { } return Ok(()); } - }, - _ => (), + } } todo_skip!( @@ -813,7 +813,7 @@ impl PalSocket for Sys { ) -> Result { if address.is_null() && flags == 0 { Self::read(socket, unsafe { - slice::from_raw_parts_mut(buf as *mut u8, len) + slice::from_raw_parts_mut(buf.cast::(), len) }) } else { // Convert to recvmsg @@ -822,23 +822,23 @@ impl PalSocket for Sys { iov_len: len, }; let mut msg = msghdr { - msg_name: address as *mut c_void, + msg_name: address.cast::(), msg_namelen: if !address_len.is_null() { unsafe { *address_len } } else { 0 }, - msg_iov: &mut iov, + msg_iov: &raw mut iov, msg_iovlen: 1, msg_control: ptr::null_mut(), msg_controllen: 0, msg_flags: 0, }; - let count = unsafe { Self::recvmsg(socket, &mut msg, flags) }?; + let count = unsafe { Self::recvmsg(socket, &raw mut msg, flags) }?; if !address_len.is_null() { unsafe { *address_len = msg.msg_namelen }; } - return Ok(count); + Ok(count) } } @@ -846,11 +846,11 @@ impl PalSocket for Sys { if msg.is_null() { return Err(Errno(EINVAL)); } - let mut mhdr = unsafe { &mut *msg }; + let mhdr = unsafe { &mut *msg }; let iovs_slice: &[iovec] = if mhdr.msg_iov.is_null() || mhdr.msg_iovlen == 0 { &[] } else { - unsafe { slice::from_raw_parts(mhdr.msg_iov, mhdr.msg_iovlen as usize) } + unsafe { slice::from_raw_parts(mhdr.msg_iov, mhdr.msg_iovlen) } }; let whole_iov_size: usize = iovs_slice.iter().map(|iov| iov.iov_len).sum(); @@ -867,7 +867,7 @@ impl PalSocket for Sys { + mem::size_of::() // payload_len + whole_iov_size // payload_data_buffer + mem::size_of::() // control_len - + mhdr.msg_controllen as usize // ancillary_stream_buffer + + mhdr.msg_controllen // ancillary_stream_buffer }; msg_stream .try_reserve_exact(expected_stream_size) @@ -883,7 +883,7 @@ impl PalSocket for Sys { .copy_from_slice(&(whole_iov_size).to_le_bytes()); cursor += mem::size_of::(); msg_stream[cursor..cursor + mem::size_of::()] - .copy_from_slice(&(mhdr.msg_controllen as usize).to_le_bytes()); + .copy_from_slice(&mhdr.msg_controllen.to_le_bytes()); // Read the message stream. let metadata = [SocketCall::RecvMsg as u64, flags as u64]; @@ -897,12 +897,12 @@ impl PalSocket for Sys { mhdr.msg_flags = 0; // Read sender name. - (unsafe { deserialize_name_from_stream(&mut mhdr, &msg_stream, &mut cursor) })?; + (unsafe { deserialize_name_from_stream(mhdr, &msg_stream, &mut cursor) })?; // Read payload data. let actual_payload_bytes_written_to_iov = unsafe { deserialize_payload_from_stream( - &mut mhdr, + mhdr, &msg_stream, iovs_slice, whole_iov_size, @@ -921,7 +921,7 @@ impl PalSocket for Sys { socket, &msg_stream, &mut cursor, - cmsg_space_provided_by_user as usize, + cmsg_space_provided_by_user, flags, ) })?; @@ -943,7 +943,7 @@ impl PalSocket for Sys { let iovs_slice: &[iovec] = if mhdr.msg_iov.is_null() || mhdr.msg_iovlen == 0 { &[] } else { - unsafe { slice::from_raw_parts(mhdr.msg_iov, mhdr.msg_iovlen as usize) } + unsafe { slice::from_raw_parts(mhdr.msg_iov, mhdr.msg_iovlen) } }; let mut msg_stream: Vec = Vec::new(); @@ -952,7 +952,7 @@ impl PalSocket for Sys { .try_reserve_exact( mem::size_of::() // payload_len + whole_iov_size // payload_data_buffer - + mhdr.msg_controllen as usize, // ancillary_stream_buffer + + mhdr.msg_controllen, // ancillary_stream_buffer ) .map_err(|_| Errno(ENOMEM))?; @@ -960,7 +960,7 @@ impl PalSocket for Sys { let mut actual_payload_bytes_serialized = 0; if !mhdr.msg_iov.is_null() && mhdr.msg_iovlen > 0 { actual_payload_bytes_serialized = unsafe { - serialize_payload_to_stream(&mut msg_stream, &iovs_slice, whole_iov_size) + serialize_payload_to_stream(&mut msg_stream, iovs_slice, whole_iov_size) }?; } // Process Control Messages from msghdr and serialize them. @@ -995,30 +995,30 @@ impl PalSocket for Sys { if flags != 0 { // Convert to sendmsg let mut iov = iovec { - iov_base: buf as *mut c_void, + iov_base: buf.cast_mut(), iov_len: len, }; let msg = msghdr { msg_name: dest_addr as *mut c_void, msg_namelen: dest_len, - msg_iov: &mut iov, + msg_iov: &raw mut iov, msg_iovlen: 1, msg_control: ptr::null_mut(), msg_controllen: 0, msg_flags: 0, }; - return unsafe { Self::sendmsg(socket, &msg, flags) }; + return unsafe { Self::sendmsg(socket, &raw const msg, flags) }; } - if dest_addr == ptr::null() || dest_len == 0 { + if dest_addr.is_null() || dest_len == 0 { Self::write(socket, unsafe { - slice::from_raw_parts(buf as *const u8, len) + slice::from_raw_parts(buf.cast::(), len) }) } else { let fd = FdGuard::new(unsafe { bind_or_connect(SocketCall::Connect, socket, dest_addr, dest_len) }?); Self::write(fd.as_c_fd().unwrap(), unsafe { - slice::from_raw_parts(buf as *const u8, len) + slice::from_raw_parts(buf.cast::(), len) }) } } @@ -1039,7 +1039,7 @@ impl PalSocket for Sys { return Err(Errno(EINVAL)); } - let timeval = unsafe { &*(option_value as *const timeval) }; + let timeval = unsafe { &*option_value.cast::() }; let fd = FdGuard::new(redox_rt::sys::dup(socket as usize, timeout_name)?); @@ -1048,7 +1048,7 @@ impl PalSocket for Sys { }; let timespec = syscall::TimeSpec { - tv_sec: timeval.tv_sec as i64, + tv_sec: timeval.tv_sec, tv_nsec, }; @@ -1056,8 +1056,9 @@ impl PalSocket for Sys { Ok(()) }; - match level { - SOL_SOCKET => match option_name { + // TODO convert back to match when we support more levels + if level == SOL_SOCKET { + match option_name { SO_RCVTIMEO => return set_timeout(b"read_timeout"), SO_SNDTIMEO => return set_timeout(b"write_timeout"), _ => { @@ -1074,8 +1075,7 @@ impl PalSocket for Sys { )?; return Ok(()); } - }, - _ => (), + } } todo_skip!( @@ -1183,7 +1183,7 @@ impl NumFromBytes for i32 { buffer .get(..mem::size_of::()) .and_then(|slice| slice.try_into().ok()) - .ok_or_else(|| Errno(EFAULT))?, + .ok_or(Errno(EFAULT))?, )) } } @@ -1193,7 +1193,7 @@ impl NumFromBytes for usize { buffer .get(..mem::size_of::()) .and_then(|slice| slice.try_into().ok()) - .ok_or_else(|| Errno(EFAULT))?, + .ok_or(Errno(EFAULT))?, )) } } diff --git a/src/platform/redox/timer.rs b/src/platform/redox/timer.rs index 585ab0aa42..af9d34166b 100644 --- a/src/platform/redox/timer.rs +++ b/src/platform/redox/timer.rs @@ -70,16 +70,15 @@ pub extern "C" fn timer_routine(arg: *mut c_void) -> *mut c_void { if let Some(fun) = timer_st.evp.sigev_notify_function { fun(timer_st.evp.sigev_value); } - } else if timer_st.evp.sigev_notify == SIGEV_SIGNAL { - if Sys::sigqueue( + } else if timer_st.evp.sigev_notify == SIGEV_SIGNAL + && Sys::sigqueue( timer_st.process_pid, timer_st.evp.sigev_signo as _, timer_st.evp.sigev_value, ) .is_err() - { - break; - } + { + break; } } @@ -107,7 +106,7 @@ fn timer_next_event(timer_st: &mut timer_internal_t) -> Result<()> { syscall::TimeSpec::from(&timer_st.next_wake_time.it_value) }; - let bytes_written = redox_rt::sys::posix_write(timer_st.timerfd, &*buf_to_write)?; + let bytes_written = redox_rt::sys::posix_write(timer_st.timerfd, &buf_to_write)?; if bytes_written < size_of::() { return Err(Errno(EIO)); }