vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix many clippy lints

Browse Source
This commit is contained in:
Speedy_Lex
2026-04-25 21:00:46 +02:00
parent eebd41a187
commit eff610eac6
21 changed files with 131 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/header/grp/mod.rs
+8 -8
View File
@@ -96,11 +96,11 @@ pub struct group {
#[derive(Debug)]
enum Error {
EOF,
SyntaxError,
Syntax,
BufTooSmall,
Misc(io::Error),
FromUtf8Error(FromUtf8Error),
ParseIntError(ParseIntError),
FromUtf8(FromUtf8Error),
ParseInt(ParseIntError),
Other,
}
@@ -171,9 +171,9 @@ fn parse_grp(line: String, destbuf: Option<DestBuffer>) -> Result<OwnedGrp, Erro
let gr_name = buffer.next().ok_or(Error::EOF)?.to_vec();
let gr_passwd = buffer.next().ok_or(Error::EOF)?.to_vec();
let gr_gid = String::from_utf8(buffer.next().ok_or(Error::EOF)?.to_vec())
.map_err(Error::FromUtf8Error)?
.map_err(Error::FromUtf8)?
.parse::<gid_t>()
.map_err(Error::ParseIntError)?;
.map_err(Error::ParseInt)?;
// Place the gid at the beginning of the byte buffer to make getting it back out again later, much faster.
@@ -338,9 +338,9 @@ pub unsafe extern "C" fn getgrgid_r(
return match err {
Error::BufTooSmall => ERANGE,
Error::EOF
| Error::SyntaxError
| Error::FromUtf8Error(_)
| Error::ParseIntError(_)
| Error::Syntax
| Error::FromUtf8(_)
| Error::ParseInt(_)
| Error::Other => EINVAL,
Error::Misc(io_err) => match io_err.kind() {
io::ErrorKind::InvalidData | io::ErrorKind::UnexpectedEof => EINVAL,
src/header/netdb/mod.rs
+6 -14
View File
@@ -272,10 +272,8 @@ pub unsafe extern "C" fn gethostbyaddr(
}
//TODO actually get aliases
let mut _host_aliases: Vec<Vec<u8>> = Vec::new();
_host_aliases.push(vec![b'\0']);
let mut host_aliases: Vec<*mut c_char> = Vec::new();
host_aliases.push(ptr::null_mut());
let mut _host_aliases: Vec<Vec<u8>> = vec![vec![b'\0']];
let mut host_aliases: Vec<*mut c_char> = vec![ptr::null_mut()];
unsafe { HOST_ALIASES.unsafe_set(Some(_host_aliases)) };
match lookup_addr(addr.clone()).map(|host_names| host_names.into_iter().next()) {
@@ -402,11 +400,8 @@ pub unsafe extern "C" fn gethostbyname(name: *const c_char) -> *mut hostent {
unsafe { HOST_ADDR = Some(host_addr) };
//TODO actually get aliases
let mut _host_aliases: Vec<Vec<u8>> = Vec::new();
_host_aliases.push(vec![b'\0']);
let mut host_aliases: Vec<*mut c_char> = Vec::new();
host_aliases.push(ptr::null_mut());
host_aliases.push(ptr::null_mut());
let mut _host_aliases: Vec<Vec<u8>> = vec![vec![b'\0']];
let mut host_aliases: Vec<*mut c_char> = vec![ptr::null_mut(); 2];
unsafe { HOST_ALIASES.unsafe_set(Some(_host_aliases)) };
unsafe {
@@ -769,11 +764,8 @@ pub unsafe extern "C" fn getservent() -> *mut servent {
*serv_aliases.push(ptr::null_mut());
*
*/
let mut _serv_aliases: Vec<Vec<u8>> = Vec::new();
_serv_aliases.push(vec![b'\0']);
let mut serv_aliases: Vec<*mut i8> = Vec::new();
serv_aliases.push(ptr::null_mut());
serv_aliases.push(ptr::null_mut());
let mut _serv_aliases: Vec<Vec<u8>> = vec![vec![b'\0']];
let mut serv_aliases: Vec<*mut i8> = vec![ptr::null_mut(); 2];
unsafe { SERV_ALIASES.unsafe_set(Some(_serv_aliases)) };
unsafe { SERV_NAME.unsafe_set(Some(serv_name)) };
src/header/poll/mod.rs
+1
View File
@@ -95,6 +95,7 @@ pub unsafe fn poll_epoll(fds: &mut [pollfd], timeout: c_int, sigmask: *const sig
continue;
}
#[expect(clippy::needless_update)]
let mut event = epoll_event {
events: 0,
data: epoll_data { u64: i as u64 },
src/header/signal/mod.rs
-3
View File
@@ -357,7 +357,6 @@ pub extern "C" fn signal(
};
let mut old_sa = mem::MaybeUninit::uninit();
if unsafe { sigaction(sig, &raw const sa, old_sa.as_mut_ptr()) } < 0 {
mem::forget(old_sa);
return unsafe { mem::transmute(SIG_ERR) };
}
unsafe { old_sa.assume_init() }.sa_handler
@@ -467,7 +466,6 @@ pub unsafe extern "C" fn sigset(
if unsafe { sigaction(sig, ptr::null_mut(), old_sa.as_mut_ptr()) } < 0
|| unsafe { sigprocmask(SIG_BLOCK, &raw const set, &raw mut set) } < 0
{
mem::forget(old_sa);
return sig_err;
}
} else {
@@ -481,7 +479,6 @@ pub unsafe extern "C" fn sigset(
if unsafe { sigaction(sig, &raw const sa, old_sa.as_mut_ptr()) } < 0
|| unsafe { sigprocmask(SIG_UNBLOCK, &raw const set, &raw mut set) } < 0
{
mem::forget(old_sa);
return sig_err;
}
}
src/header/stdio/printf.rs
+3 -1
View File
@@ -193,7 +193,7 @@ impl VaArg {
let ap_impl = unsafe {
// The double deconstruct is intended
let ptr_to_struct = *(ap as *mut core::ffi::VaList as *mut *mut VaListImpl);
let ptr_to_struct = *(core::ptr::from_mut(ap).cast::<*mut VaListImpl>());
&mut *ptr_to_struct
};
@@ -487,6 +487,7 @@ fn float_exp(mut float: c_double) -> (c_double, isize) {
(float, exp)
}
#[expect(clippy::too_many_arguments)]
fn fmt_float_exp<W: Write>(
w: &mut W,
exp_fmt: char,
@@ -524,6 +525,7 @@ fn fmt_float_exp<W: Write>(
Ok(())
}
#[expect(clippy::too_many_arguments)]
fn fmt_float_normal<W: Write>(
w: &mut W,
trim: bool,
src/header/sys_syslog/logger.rs
+3 -13
View File
@@ -92,17 +92,7 @@ impl<L: LogSink> LogParams<L> {
.unwrap_or(true)
{
// Try reopening the log file once and retrying as musl does.
if !self
.open_logger()
.is_ok()
.then(|| {
self.writer
.as_mut()
.map(|w| w.writer().write_all(&buffer).is_ok())
.unwrap_or_default()
})
.unwrap_or_default()
&& self.opt.contains(Config::Console)
if !(self.open_logger().is_ok() && self.writer.as_mut().and_then(|w| w.writer().write_all(&buffer).ok()).is_some()) && self.opt.contains(Config::Console)
{
// TODO: Log error to /dev/console & Redox equivalent
}
@@ -139,10 +129,10 @@ impl<L: LogSink> LogParams<L> {
/// default.
pub fn set_identity(&mut self, ident: Option<&str>) {
self.ident = ident
.and_then(|ident| {
.map(|ident| {
let ident = ident.bytes().chain([0]).collect();
// SAFETY: Already validated
Some(unsafe { String::from_utf8_unchecked(ident) })
unsafe { String::from_utf8_unchecked(ident) }
})
.unwrap_or_else(|| {
unsafe { CStr::from_nullable_ptr(platform::program_invocation_short_name) }
src/header/time/mod.rs
+25 -36
View File
@@ -256,6 +256,7 @@ pub extern "C" fn clock() -> clock_t {
}
let ts = unsafe { ts.assume_init() };
#[expect(clippy::unnecessary_cast, reason="needed on i586")]
let clocks =
ts.tv_sec * CLOCKS_PER_SEC as i64 + (ts.tv_nsec / (1_000_000_000 / CLOCKS_PER_SEC)) as i64;
clock_t::try_from(clocks).unwrap_or(-1)
@@ -712,18 +713,12 @@ unsafe fn clear_timezone(guard: &mut MutexGuard<'_, (Option<CString>, Option<CSt
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let daylight_mut = unsafe { &mut *(&raw mut daylight) };
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let timezone_mut = unsafe { &mut *(&raw mut timezone) };
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let tzname_mut = unsafe { &mut *(&raw mut tzname) };
(*tzname_mut).0[0] = ptr::null_mut();
(*tzname_mut).0[1] = ptr::null_mut();
*timezone_mut = 0;
*daylight_mut = 0;
unsafe {
tzname.0[0] = ptr::null_mut();
tzname.0[1] = ptr::null_mut();
timezone = 0;
daylight = 0;
}
}
#[inline(always)]
@@ -848,34 +843,28 @@ unsafe fn set_timezone(
) {
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let daylight_mut = unsafe { &mut *(&raw mut daylight) };
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let timezone_mut = unsafe { &mut *(&raw mut timezone) };
// SAFETY: the caller is required to ensure access exclusively for the
// holder of `TIMEZONE_LOCK`.
let tzname_mut = unsafe { &mut *(&raw mut tzname) };
unsafe {
let ut_offset = std.offset();
let ut_offset = std.offset();
guard.0 = Some(CString::new(ut_offset.abbreviation().expect("Wrong timezone")).unwrap());
tzname.0[0] = guard.0.as_ref().unwrap().as_ptr().cast_mut();
guard.0 = Some(CString::new(ut_offset.abbreviation().expect("Wrong timezone")).unwrap());
tzname_mut.0[0] = guard.0.as_ref().unwrap().as_ptr().cast_mut();
match dst {
Some(dst) => {
guard.1 =
Some(CString::new(dst.offset().abbreviation().expect("Wrong timezone")).unwrap());
tzname_mut.0[1] = guard.1.as_ref().unwrap().as_ptr().cast_mut();
*daylight_mut = 1;
}
None => {
guard.1 = None;
tzname_mut.0[1] = guard.0.as_ref().unwrap().as_ptr().cast_mut();
*daylight_mut = 0;
match dst {
Some(dst) => {
guard.1 =
Some(CString::new(dst.offset().abbreviation().expect("Wrong timezone")).unwrap());
tzname.0[1] = guard.1.as_ref().unwrap().as_ptr().cast_mut();
daylight = 1;
}
None => {
guard.1 = None;
tzname.0[1] = guard.0.as_ref().unwrap().as_ptr().cast_mut();
daylight = 0;
}
}
timezone = -c_long::from(ut_offset.fix().local_minus_utc());
}
*timezone_mut = -c_long::from(ut_offset.fix().local_minus_utc());
}
#[inline(always)]
src/header/unistd/pathconf.rs
+7 -7
View File
@@ -39,12 +39,12 @@ pub const _PC_2_SYMLINKS: c_int = 20;
fn pc(name: c_int) -> c_long {
// Settings from musl, some adjusted
match name {
_PC_LINK_MAX => LINK_MAX.try_into().unwrap_or(-1),
_PC_MAX_CANON => MAX_CANON.try_into().unwrap_or(-1),
_PC_MAX_INPUT => MAX_INPUT.try_into().unwrap_or(-1),
_PC_LINK_MAX => LINK_MAX,
_PC_MAX_CANON => MAX_CANON,
_PC_MAX_INPUT => MAX_INPUT,
_PC_NAME_MAX => NAME_MAX.try_into().unwrap_or(-1),
_PC_PATH_MAX => PATH_MAX.try_into().unwrap_or(-1),
_PC_PIPE_BUF => PIPE_BUF.try_into().unwrap_or(-1),
_PC_PIPE_BUF => PIPE_BUF,
_PC_CHOWN_RESTRICTED => 1,
_PC_NO_TRUNC => 1,
_PC_VDISABLE => _POSIX_VDISABLE.into(),
@@ -52,13 +52,13 @@ fn pc(name: c_int) -> c_long {
_PC_ASYNC_IO => -1,
_PC_PRIO_IO => -1,
_PC_SOCK_MAXBUF => -1,
_PC_FILESIZEBITS => FILESIZEBITS.into(),
_PC_FILESIZEBITS => FILESIZEBITS,
_PC_REC_INCR_XFER_SIZE => -1,
_PC_REC_MAX_XFER_SIZE => -1,
_PC_REC_MIN_XFER_SIZE => 4096,
_PC_REC_XFER_ALIGN => 4096,
_PC_ALLOC_SIZE_MIN => POSIX_ALLOC_SIZE_MIN.try_into().unwrap_or(-1),
_PC_SYMLINK_MAX => SYMLINK_MAX.try_into().unwrap_or(-1),
_PC_ALLOC_SIZE_MIN => POSIX_ALLOC_SIZE_MIN,
_PC_SYMLINK_MAX => SYMLINK_MAX,
_PC_2_SYMLINKS => 1,
_ => {
platform::ERRNO.set(errno::EINVAL);
src/header/unistd/sysconf/linux.rs
+1 -1
View File
@@ -326,7 +326,7 @@ pub(super) fn sysconf_impl(name: c_int) -> c_long {
}
}
_SC_V6_LPBIG_OFFBIG => -1,
_SC_HOST_NAME_MAX => HOST_NAME_MAX.try_into().unwrap_or(-1),
_SC_HOST_NAME_MAX => HOST_NAME_MAX,
_SC_TRACE => -1,
_SC_TRACE_EVENT_FILTER => -1,
_SC_TRACE_INHERIT => -1,
src/header/wchar/mod.rs
+1 -1
View File
@@ -331,7 +331,7 @@ pub unsafe extern "C" fn vswscanf(
unsafe {
let format = WStr::from_ptr(format);
let s = WStr::from_ptr(s);
wscanf::scanf(s.into(), format.into(), __valist)
wscanf::scanf(s.into(), format, __valist)
}
}
src/io/buffered.rs
+3 -3
View File
@@ -826,7 +826,7 @@ mod tests {
self.pos = self.pos.wrapping_add(n as u64);
}
SeekFrom::End(n) => {
self.pos = u64::max_value().wrapping_add(n as u64);
self.pos = u64::MAX.wrapping_add(n as u64);
}
}
Ok(self.pos)
@@ -837,13 +837,13 @@ mod tests {
assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));
assert_eq!(
reader.seek(SeekFrom::End(-5)).ok(),
Some(u64::max_value() - 5)
Some(u64::MAX - 5)
);
assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
// the following seek will require two underlying seeks
let expected = 9223372036854775802;
assert_eq!(
reader.seek(SeekFrom::Current(i64::min_value())).ok(),
reader.seek(SeekFrom::Current(i64::MIN)).ok(),
Some(expected)
);
assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));
src/io/cursor.rs
+27 -27
View File
@@ -375,7 +375,7 @@ mod tests {
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
}
#[test]
@@ -386,7 +386,7 @@ mod tests {
assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
}
#[test]
@@ -409,9 +409,9 @@ mod tests {
#[test]
fn test_buf_writer() {
let mut buf = [0 as u8; 9];
let mut buf = [0u8; 9];
{
let mut writer = Cursor::new(&mut buf[..]);
let mut writer = Cursor::new(buf.as_mut_slice());
assert_eq!(writer.position(), 0);
assert_eq!(writer.write(&[0]).unwrap(), 1);
assert_eq!(writer.position(), 1);
@@ -430,9 +430,9 @@ mod tests {
#[test]
fn test_buf_writer_seek() {
let mut buf = [0 as u8; 8];
let mut buf = [0u8; 8];
{
let mut writer = Cursor::new(&mut buf[..]);
let mut writer = Cursor::new(buf.as_mut_slice());
assert_eq!(writer.position(), 0);
assert_eq!(writer.write(&[1]).unwrap(), 1);
assert_eq!(writer.position(), 1);
@@ -458,8 +458,8 @@ mod tests {
#[test]
fn test_buf_writer_error() {
let mut buf = [0 as u8; 2];
let mut writer = Cursor::new(&mut buf[..]);
let mut buf = [0u8; 2];
let mut writer = Cursor::new(buf.as_mut_slice());
assert_eq!(writer.write(&[0]).unwrap(), 1);
assert_eq!(writer.write(&[0, 0]).unwrap(), 1);
assert_eq!(writer.write(&[0, 0]).unwrap(), 0);
@@ -519,20 +519,20 @@ mod tests {
#[test]
fn test_slice_reader() {
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
let reader = &mut &in_buf[..];
let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
let reader = &mut in_buf.as_slice();
let mut buf = [];
assert_eq!(reader.read(&mut buf).unwrap(), 0);
let mut buf = [0];
assert_eq!(reader.read(&mut buf).unwrap(), 1);
assert_eq!(reader.len(), 7);
let b: &[_] = &[0];
assert_eq!(&buf[..], b);
assert_eq!(&buf, b);
let mut buf = [0; 4];
assert_eq!(reader.read(&mut buf).unwrap(), 4);
assert_eq!(reader.len(), 3);
let b: &[_] = &[1, 2, 3, 4];
assert_eq!(&buf[..], b);
assert_eq!(&buf, b);
assert_eq!(reader.read(&mut buf).unwrap(), 3);
let b: &[_] = &[5, 6, 7];
assert_eq!(&buf[..3], b);
@@ -541,8 +541,8 @@ mod tests {
#[test]
fn test_read_exact() {
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
let reader = &mut &in_buf[..];
let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
let reader = &mut in_buf.as_slice();
let mut buf = [];
assert!(reader.read_exact(&mut buf).is_ok());
let mut buf = [8];
@@ -559,8 +559,8 @@ mod tests {
#[test]
fn test_buf_reader() {
let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
let mut reader = Cursor::new(&in_buf[..]);
let in_buf = [0, 1, 2, 3, 4, 5, 6, 7];
let mut reader = Cursor::new(&in_buf);
let mut buf = [];
assert_eq!(reader.read(&mut buf).unwrap(), 0);
assert_eq!(reader.position(), 0);
@@ -583,7 +583,7 @@ mod tests {
#[test]
fn seek_past_end() {
let buf = [0xff];
let mut r = Cursor::new(&buf[..]);
let mut r = Cursor::new(&buf);
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
assert_eq!(r.read(&mut [0]).unwrap(), 0);
@@ -592,7 +592,7 @@ mod tests {
assert_eq!(r.read(&mut [0]).unwrap(), 0);
let mut buf = [0];
let mut r = Cursor::new(&mut buf[..]);
let mut r = Cursor::new(buf.as_mut_slice());
assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);
assert_eq!(r.write(&[3]).unwrap(), 0);
@@ -604,7 +604,7 @@ mod tests {
#[test]
fn seek_past_i64() {
let buf = [0xff];
let mut r = Cursor::new(&buf[..]);
let mut r = Cursor::new(&buf);
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
assert_eq!(
r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
@@ -627,7 +627,7 @@ mod tests {
assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);
let mut buf = [0];
let mut r = Cursor::new(&mut buf[..]);
let mut r = Cursor::new(&mut buf);
assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);
assert_eq!(
r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(),
@@ -653,14 +653,14 @@ mod tests {
#[test]
fn seek_before_0() {
let buf = [0xff];
let mut r = Cursor::new(&buf[..]);
let mut r = Cursor::new(&buf);
assert!(r.seek(SeekFrom::End(-2)).is_err());
let mut r = Cursor::new(vec![10]);
assert!(r.seek(SeekFrom::End(-2)).is_err());
let mut buf = [0];
let mut r = Cursor::new(&mut buf[..]);
let mut r = Cursor::new(&mut buf);
assert!(r.seek(SeekFrom::End(-2)).is_err());
let mut r = Cursor::new(vec![10].into_boxed_slice());
@@ -677,28 +677,28 @@ mod tests {
assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);
assert_eq!(writer.position(), 8);
let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);
assert_eq!(writer.position(), 0);
assert_eq!(writer.write(&[3, 4]).unwrap(), 2);
let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);
assert_eq!(writer.write(&[0, 1]).unwrap(), 2);
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);
assert_eq!(writer.write(&[1, 2]).unwrap(), 2);
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);
assert_eq!(writer.write(&[1]).unwrap(), 1);
let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];
assert_eq!(&writer.get_ref()[..], b);
assert_eq!(writer.get_ref().as_slice(), b);
}
#[test]
src/io/mod.rs
+28 -28
View File
@@ -546,7 +546,7 @@ pub trait Read {
/// let mut buffer = [0; 10];
///
/// // read up to 10 bytes
/// f.read(&mut buffer[..])?;
/// f.read(&mut buffer.as_slice())?;
/// Ok(())
/// }
/// ```
@@ -2032,12 +2032,12 @@ mod tests {
#[test]
#[cfg_attr(target_os = "emscripten", ignore)]
fn read_until() {
let mut buf = Cursor::new(&b"12"[..]);
let mut buf = Cursor::new(b"12".as_slice());
let mut v = Vec::new();
assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);
assert_eq!(v, b"12");
let mut buf = Cursor::new(&b"1233"[..]);
let mut buf = Cursor::new(b"1233".as_slice());
let mut v = Vec::new();
assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);
assert_eq!(v, b"123");
@@ -2051,12 +2051,12 @@ mod tests {
#[test]
fn split() {
let buf = Cursor::new(&b"12"[..]);
let buf = Cursor::new(b"12".as_slice());
let mut s = buf.split(b'3');
assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
assert!(s.next().is_none());
let buf = Cursor::new(&b"1233"[..]);
let buf = Cursor::new(b"1233".as_slice());
let mut s = buf.split(b'3');
assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);
assert_eq!(s.next().unwrap().unwrap(), vec![]);
@@ -2065,12 +2065,12 @@ mod tests {
#[test]
fn read_line() {
let mut buf = Cursor::new(&b"12"[..]);
let mut buf = Cursor::new(b"12".as_slice());
let mut v = String::new();
assert_eq!(buf.read_line(&mut v).unwrap(), 2);
assert_eq!(v, "12");
let mut buf = Cursor::new(&b"12\n\n"[..]);
let mut buf = Cursor::new(b"12\n\n".as_slice());
let mut v = String::new();
assert_eq!(buf.read_line(&mut v).unwrap(), 3);
assert_eq!(v, "12\n");
@@ -2084,12 +2084,12 @@ mod tests {
// #[test]
// fn lines() {
// let buf = Cursor::new(&b"12\r"[..]);
// let buf = Cursor::new(b"12\r".as_slice());
// let mut s = buf.lines();
// assert_eq!(s.next().unwrap().unwrap(), "12\r".to_string());
// assert!(s.next().is_none());
// let buf = Cursor::new(&b"12\r\n\n"[..]);
// let buf = Cursor::new(b"12\r\n\n".as_slice());
// let mut s = buf.lines();
// assert_eq!(s.next().unwrap().unwrap(), "12".to_string());
// assert_eq!(s.next().unwrap().unwrap(), "".to_string());
@@ -2098,12 +2098,12 @@ mod tests {
#[test]
fn read_to_end() {
let mut c = Cursor::new(&b""[..]);
let mut c = Cursor::new(b"".as_slice());
let mut v = Vec::new();
assert_eq!(c.read_to_end(&mut v).unwrap(), 0);
assert_eq!(v, []);
let mut c = Cursor::new(&b"1"[..]);
let mut c = Cursor::new(b"1".as_slice());
let mut v = Vec::new();
assert_eq!(c.read_to_end(&mut v).unwrap(), 1);
assert_eq!(v, b"1");
@@ -2119,17 +2119,17 @@ mod tests {
#[test]
fn read_to_string() {
let mut c = Cursor::new(&b""[..]);
let mut c = Cursor::new(b"".as_slice());
let mut v = String::new();
assert_eq!(c.read_to_string(&mut v).unwrap(), 0);
assert_eq!(v, "");
let mut c = Cursor::new(&b"1"[..]);
let mut c = Cursor::new(b"1".as_slice());
let mut v = String::new();
assert_eq!(c.read_to_string(&mut v).unwrap(), 1);
assert_eq!(v, "1");
let mut c = Cursor::new(&b"\xff"[..]);
let mut c = Cursor::new(b"\xff".as_slice());
let mut v = String::new();
assert!(c.read_to_string(&mut v).is_err());
}
@@ -2138,17 +2138,17 @@ mod tests {
fn read_exact() {
let mut buf = [0; 4];
let mut c = Cursor::new(&b""[..]);
let mut c = Cursor::new(b"".as_slice());
assert_eq!(
c.read_exact(&mut buf).unwrap_err().kind(),
io::ErrorKind::UnexpectedEof
);
let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
let mut c = Cursor::new(b"123".as_slice()).chain(Cursor::new(b"456789".as_slice()));
c.read_exact(&mut buf).unwrap();
assert_eq!(&buf, b"1234");
assert_eq!(buf, *b"1234");
c.read_exact(&mut buf).unwrap();
assert_eq!(&buf, b"5678");
assert_eq!(buf, *b"5678");
assert_eq!(
c.read_exact(&mut buf).unwrap_err().kind(),
io::ErrorKind::UnexpectedEof
@@ -2159,27 +2159,27 @@ mod tests {
fn read_exact_slice() {
let mut buf = [0; 4];
let mut c = &b""[..];
let mut c = b"".as_slice();
assert_eq!(
c.read_exact(&mut buf).unwrap_err().kind(),
io::ErrorKind::UnexpectedEof
);
let mut c = &b"123"[..];
let mut c = b"123".as_slice();
assert_eq!(
c.read_exact(&mut buf).unwrap_err().kind(),
io::ErrorKind::UnexpectedEof
);
// make sure the optimized (early returning) method is being used
assert_eq!(&buf, &[0; 4]);
assert_eq!(buf, [0; 4]);
let mut c = &b"1234"[..];
let mut c = b"1234".as_slice();
c.read_exact(&mut buf).unwrap();
assert_eq!(&buf, b"1234");
assert_eq!(buf, *b"1234");
let mut c = &b"56789"[..];
let mut c = b"56789".as_slice();
c.read_exact(&mut buf).unwrap();
assert_eq!(&buf, b"5678");
assert_eq!(buf, *b"5678");
assert_eq!(c, b"9");
}
@@ -2227,7 +2227,7 @@ mod tests {
}
assert_eq!(br1.fill_buf().unwrap().len(), 0);
assert_eq!(br2.fill_buf().unwrap().len(), 0);
assert_eq!(&cat[..], &exp[..])
assert_eq!(&cat, &exp)
}
#[test]
@@ -2240,7 +2240,7 @@ mod tests {
let chain2 = (&testdata[..4])
.chain(&testdata[4..8])
.chain(&testdata[8..]);
cmp_bufread(chain1, chain2, &testdata[..]);
cmp_bufread(chain1, chain2, testdata.as_slice());
}
#[test]
@@ -2248,7 +2248,7 @@ mod tests {
let a = b"A";
let b = b"B";
let mut s = String::new();
let mut chain = (&a[..]).chain(&b[..]);
let mut chain = a.chain(b.as_slice());
chain.read(&mut []).unwrap();
chain.read_to_string(&mut s).unwrap();
assert_eq!("AB", s);
src/ld_so/dso.rs
+1
View File
@@ -774,6 +774,7 @@ impl DSO {
let strtab_offset = strtab_offset.expect("mandatory DT_STRTAB not present");
let strtab_size = strtab_size.expect("mandatory DT_STRSZ not present");
#[expect(clippy::unnecessary_cast, reason="needed on i586")]
let dynstrtab = StringTable::new(
mmap,
strtab_offset as u64,
src/macros.rs
+1
View File
@@ -574,6 +574,7 @@ macro_rules! CheckVsLibcCrate {
const _: () = {
fn ensure_ty<A, B>(a: A, b: B) where (): $crate::macros::LibcTypeEquals::<A, B> {}
fn for_libc(a: $name, b: __libc_only_for_layout_checks::$name) {
#[allow(clippy::diverging_sub_expression)]
let a: $type = panic!("never called");
ensure_ty(a, b.$field);
}
src/platform/mod.rs
+1
View File
@@ -417,5 +417,6 @@ pub unsafe fn init_inner(auxvs: Box<[[usize; 2]]>) {
redox_rt::sys::swap_umask((umask as u32) & u32::from(MODE_PERM) & !(S_ISVTX as u32));
}
}
#[expect(clippy::boxed_local)]
#[cfg(not(target_os = "redox"))]
pub unsafe fn init(auxvs: Box<[[usize; 2]]>) {}
src/pthread/mod.rs
+1 -1
View File
@@ -234,7 +234,7 @@ unsafe extern "C" fn new_thread_shim(
unsafe { tcb.copy_masters() }.unwrap();
unsafe { (*tcb).pthread.os_tid.get().write(Sys::current_os_tid()) };
unsafe { tcb.pthread.os_tid.get().write(Sys::current_os_tid()) };
unsafe { (&*synchronization_mutex).manual_unlock() };
src/start.rs
+1
View File
@@ -57,6 +57,7 @@ unsafe fn copy_string_array(array: *const *const c_char, len: usize) -> Vec<*mut
let mut offset = 0;
let buf = unsafe { platform::alloc(size).cast::<c_char>() };
#[expect(clippy::needless_range_loop)]
for i in 0..len {
let dest_buf = unsafe { buf.add(offset) };
let item = unsafe { *array.add(i) };
src/sync/rwlock.rs
+4 -6
View File
@@ -74,9 +74,8 @@ impl InnerRwLock {
waiting_wr = expected & WAITING_WR;
if actual & COUNT_MASK > 0 {
match crate::sync::futex_wait(&self.state, expected, relative.as_ref()) {
super::FutexWaitResult::TimedOut => return Err(Errno(ETIMEDOUT)),
_ => {}
if crate::sync::futex_wait(&self.state, expected, relative.as_ref()) == super::FutexWaitResult::TimedOut {
return Err(Errno(ETIMEDOUT))
}
} else {
// We must avoid blocking indefinitely in our `futex_wait()`, in this case
@@ -94,9 +93,8 @@ impl InnerRwLock {
pub fn acquire_read_lock(&self, deadline: Option<(&timespec, clockid_t)>) -> Result<(), Errno> {
let relative = Self::translate_timeout(deadline)?;
while let Err(old) = self.try_acquire_read_lock() {
match crate::sync::futex_wait(&self.state, old, relative.as_ref()) {
super::FutexWaitResult::TimedOut => return Err(Errno(ETIMEDOUT)),
_ => {}
if crate::sync::futex_wait(&self.state, old, relative.as_ref()) == super::FutexWaitResult::TimedOut {
return Err(Errno(ETIMEDOUT))
}
}
src/sync/semaphore.rs
+4 -7
View File
@@ -35,17 +35,14 @@ impl Semaphore {
return 0;
}
match self.count.compare_exchange_weak(
if self.count.compare_exchange_weak(
value,
value - 1,
Ordering::SeqCst,
Ordering::SeqCst,
) {
Ok(_) => {
// Acquired
return value;
}
Err(_) => (),
).is_ok() {
// Acquired
return value;
}
// Try again (as long as value > 0)
}
tests/src/main.rs
+5 -8
View File
@@ -26,13 +26,10 @@ fn find_expected_dir() -> Option<PathBuf> {
}
}
if found_expected_dir.is_none() {
if let Ok(cwd) = env::current_dir() {
let check = cwd.join("expected");
if check.is_dir() {
if found_expected_dir.is_none()
&& let Ok(check) = env::current_dir().map(|cwd| cwd.join("expected"))
&& check.is_dir(){
found_expected_dir = Some(check);
}
}
}
found_expected_dir
@@ -85,10 +82,10 @@ fn expected(
if expected != generated {
println!("# {}: {}: expected #", bin, kind);
io::stdout().write(&expected).unwrap();
io::stdout().write_all(&expected).unwrap();
println!("# {}: {}: generated #", bin, kind);
io::stdout().write(generated).unwrap();
io::stdout().write_all(generated).unwrap();
return Err(format!(
"{} failed - retcode {}, {} mismatch",