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

Use unsafe blocks in some more unsafe functions

Browse Source 
Building with redoxer showed some more places
that have to use unsafe blocks
This commit is contained in:
sourceturner
2026-01-21 00:06:51 +01:00
parent 55aba2825e
commit 582e6eba69
11 changed files with 299 additions and 254 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/header/string/mod.rs
+3 -3
View File
@@ -304,7 +304,7 @@ pub unsafe extern "C" fn strcoll_l(s1: *const c_char, s2: *const c_char, _loc: l
/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcoll.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strcoll(s1: *const c_char, s2: *const c_char) -> c_int {
strcoll_l(s1, s2, THREAD_LOCALE as locale_t)
unsafe { strcoll_l(s1, s2, THREAD_LOCALE as locale_t) }
}
/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strcpy.html>.
@@ -379,7 +379,7 @@ pub unsafe extern "C" fn strerror_l(errnum: c_int, _loc: locale_t) -> *mut c_cha
/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strerror.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strerror(errnum: c_int) -> *mut c_char {
strerror_l(errnum, THREAD_LOCALE as locale_t)
unsafe { strerror_l(errnum, THREAD_LOCALE as locale_t) }
}
/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strerror_r.html>.
@@ -669,5 +669,5 @@ pub unsafe extern "C" fn strxfrm_l(
/// See <https://pubs.opengroup.org/onlinepubs/9799919799/functions/strxfrm.html>.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn strxfrm(s1: *mut c_char, s2: *const c_char, n: size_t) -> size_t {
strxfrm_l(s1, s2, n, THREAD_LOCALE as locale_t)
unsafe { strxfrm_l(s1, s2, n, THREAD_LOCALE as locale_t) }
}
src/header/sys_ioctl/redox/drm.rs
+31 -27
View File
@@ -41,7 +41,7 @@ fn plane_id(i: u32) -> u32 {
}
unsafe fn copy_array<T: Copy>(src: &[T], dst_ptr: *mut T, dst_len: usize) -> usize {
let dst = slice::from_raw_parts_mut(dst_ptr, dst_len);
let dst = unsafe { slice::from_raw_parts_mut(dst_ptr, dst_len) };
dst.copy_from_slice(&src[..src.len().min(dst_len)]);
src.len()
}
@@ -61,22 +61,22 @@ impl Dev {
mut buf: IoctlBuffer,
func: u64,
) -> Result<c_int> {
let mut data = buf.read::<T>()?;
let mut wire = data.write();
let mut data = unsafe { buf.read::<T>() }?;
let mut wire = unsafe { data.write() };
let res = redox_rt::sys::sys_call(
self.fd as usize,
&mut wire,
syscall::CallFlags::empty(),
&[func],
)?;
data.read_from(&wire);
buf.write(data)?;
unsafe { data.read_from(&wire) };
(unsafe { buf.write(data) })?;
Ok(res as c_int)
}
unsafe fn write_ioctl<T: IoctlData>(&self, mut buf: IoctlBuffer, func: u64) -> Result<c_int> {
let mut data = buf.read::<T>()?;
let mut wire = data.write();
let mut data = unsafe { buf.read::<T>() }?;
let mut wire = unsafe { data.write() };
let res = redox_rt::sys::sys_call(
self.fd as usize,
&mut wire,
@@ -90,26 +90,30 @@ impl Dev {
pub(super) unsafe fn ioctl(fd: c_int, func: u8, buf: IoctlBuffer) -> Result<c_int> {
let dev = Dev::new(fd)?;
match func {
0x00 => dev.read_write_ioctl::<drm_version>(buf, VERSION),
0x0C => dev.read_write_ioctl::<drm_get_cap>(buf, GET_CAP),
0x0D => dev.write_ioctl::<drm_set_client_cap>(buf, SET_CLIENT_CAP),
0xA0 => dev.read_write_ioctl::<drm_mode_card_res>(buf, MODE_CARD_RES),
0xA1 => dev.read_write_ioctl::<drm_mode_crtc>(buf, MODE_GET_CRTC),
0xA6 => dev.read_write_ioctl::<drm_mode_get_encoder>(buf, MODE_GET_ENCODER),
0xA7 => dev.read_write_ioctl::<drm_mode_get_connector>(buf, MODE_GET_CONNECTOR),
0xAA => dev.read_write_ioctl::<drm_mode_get_property>(buf, MODE_GET_PROPERTY),
0xAB => dev.read_write_ioctl::<drm_mode_connector_set_property>(buf, MODE_SET_PROPERTY),
0xAC => dev.read_write_ioctl::<drm_mode_get_blob>(buf, MODE_GET_PROP_BLOB),
0xAD => dev.read_write_ioctl::<drm_mode_fb_cmd>(buf, MODE_GET_FB),
0xAE => dev.read_write_ioctl::<drm_mode_fb_cmd>(buf, MODE_ADD_FB),
0xAF => dev.read_write_ioctl::<standin_for_uint>(buf, MODE_RM_FB),
0xB2 => dev.read_write_ioctl::<drm_mode_create_dumb>(buf, MODE_CREATE_DUMB),
0xB3 => dev.read_write_ioctl::<drm_mode_map_dumb>(buf, MODE_MAP_DUMB),
0xB4 => dev.read_write_ioctl::<drm_mode_destroy_dumb>(buf, MODE_DESTROY_DUMB),
0xB5 => dev.read_write_ioctl::<drm_mode_get_plane_res>(buf, MODE_GET_PLANE_RES),
0xB6 => dev.read_write_ioctl::<drm_mode_get_plane>(buf, MODE_GET_PLANE),
0xB9 => dev.read_write_ioctl::<drm_mode_obj_get_properties>(buf, MODE_OBJ_GET_PROPERTIES),
0xCE => dev.read_write_ioctl::<drm_mode_fb_cmd2>(buf, MODE_GET_FB2),
0x00 => unsafe { dev.read_write_ioctl::<drm_version>(buf, VERSION) },
0x0C => unsafe { dev.read_write_ioctl::<drm_get_cap>(buf, GET_CAP) },
0x0D => unsafe { dev.write_ioctl::<drm_set_client_cap>(buf, SET_CLIENT_CAP) },
0xA0 => unsafe { dev.read_write_ioctl::<drm_mode_card_res>(buf, MODE_CARD_RES) },
0xA1 => unsafe { dev.read_write_ioctl::<drm_mode_crtc>(buf, MODE_GET_CRTC) },
0xA6 => unsafe { dev.read_write_ioctl::<drm_mode_get_encoder>(buf, MODE_GET_ENCODER) },
0xA7 => unsafe { dev.read_write_ioctl::<drm_mode_get_connector>(buf, MODE_GET_CONNECTOR) },
0xAA => unsafe { dev.read_write_ioctl::<drm_mode_get_property>(buf, MODE_GET_PROPERTY) },
0xAB => unsafe {
dev.read_write_ioctl::<drm_mode_connector_set_property>(buf, MODE_SET_PROPERTY)
},
0xAC => unsafe { dev.read_write_ioctl::<drm_mode_get_blob>(buf, MODE_GET_PROP_BLOB) },
0xAD => unsafe { dev.read_write_ioctl::<drm_mode_fb_cmd>(buf, MODE_GET_FB) },
0xAE => unsafe { dev.read_write_ioctl::<drm_mode_fb_cmd>(buf, MODE_ADD_FB) },
0xAF => unsafe { dev.read_write_ioctl::<standin_for_uint>(buf, MODE_RM_FB) },
0xB2 => unsafe { dev.read_write_ioctl::<drm_mode_create_dumb>(buf, MODE_CREATE_DUMB) },
0xB3 => unsafe { dev.read_write_ioctl::<drm_mode_map_dumb>(buf, MODE_MAP_DUMB) },
0xB4 => unsafe { dev.read_write_ioctl::<drm_mode_destroy_dumb>(buf, MODE_DESTROY_DUMB) },
0xB5 => unsafe { dev.read_write_ioctl::<drm_mode_get_plane_res>(buf, MODE_GET_PLANE_RES) },
0xB6 => unsafe { dev.read_write_ioctl::<drm_mode_get_plane>(buf, MODE_GET_PLANE) },
0xB9 => unsafe {
dev.read_write_ioctl::<drm_mode_obj_get_properties>(buf, MODE_OBJ_GET_PROPERTIES)
},
0xCE => unsafe { dev.read_write_ioctl::<drm_mode_fb_cmd2>(buf, MODE_GET_FB2) },
_ => {
eprintln!("unimplemented DRM ioctl({}, 0x{:02x}, {:?})", fd, func, buf);
Err(Errno(EINVAL))
src/header/sys_ioctl/redox/mod.rs
+9 -9
View File
@@ -111,7 +111,7 @@ unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c
match request {
FIONBIO => {
let mut flags = Sys::fcntl(fd, fcntl::F_GETFL, 0)?;
flags = if *(out as *mut c_int) == 0 {
flags = if unsafe { *(out as *mut c_int) } == 0 {
flags & !fcntl::O_NONBLOCK
} else {
flags | fcntl::O_NONBLOCK
@@ -119,12 +119,12 @@ unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c
Sys::fcntl(fd, fcntl::F_SETFL, flags as c_ulonglong)?;
}
TCGETS => {
let termios = &mut *(out as *mut termios::termios);
let termios = unsafe { &mut *(out as *mut termios::termios) };
dup_read(fd, "termios", termios)?;
}
// TODO: give these different behaviors
TCSETS | TCSETSW | TCSETSF => {
let termios = &*(out as *const termios::termios);
let termios = unsafe { &*(out as *const termios::termios) };
dup_write(fd, "termios", termios)?;
}
TCFLSH => {
@@ -135,19 +135,19 @@ unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c
eprintln!("TODO: ioctl TIOCSCTTY");
}
TIOCGPGRP => {
let pgrp = &mut *(out as *mut pid_t);
let pgrp = unsafe { &mut *(out as *mut pid_t) };
dup_read(fd, "pgrp", pgrp)?;
}
TIOCSPGRP => {
let pgrp = &*(out as *const pid_t);
let pgrp = unsafe { &*(out as *const pid_t) };
dup_write(fd, "pgrp", pgrp)?;
}
TIOCGWINSZ => {
let winsize = &mut *(out as *mut winsize);
let winsize = unsafe { &mut *(out as *mut winsize) };
dup_read(fd, "winsize", winsize)?;
}
TIOCSWINSZ => {
let winsize = &*(out as *const winsize);
let winsize = unsafe { &*(out as *const winsize) };
dup_write(fd, "winsize", winsize)?;
}
TIOCGPTLCK => {
@@ -179,7 +179,7 @@ unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c
0b11 => IoctlBuffer::ReadWrite(out, size),
_ => IoctlBuffer::None,
};
return drm::ioctl(fd, func, buf);
return unsafe { drm::ioctl(fd, func, buf) };
}
_ => {
return Err(Errno(EINVAL));
@@ -192,5 +192,5 @@ unsafe fn ioctl_inner(fd: c_int, request: c_ulong, out: *mut c_void) -> Result<c
#[unsafe(no_mangle)]
pub unsafe extern "C" fn ioctl(fd: c_int, request: c_ulong, out: *mut c_void) -> c_int {
ioctl_inner(fd, request, out).or_minus_one_errno()
unsafe { ioctl_inner(fd, request, out) }.or_minus_one_errno()
}
src/platform/redox/epoll.rs
+1 -1
View File
@@ -144,7 +144,7 @@ impl PalEpoll for Sys {
callback()
} else {
// Allowset is inverse of sigset mask
let allowset = !*sigset;
let allowset = !unsafe { *sigset };
redox_rt::signal::callback_or_signal_async(allowset, callback)
}?;
src/platform/redox/event.rs
+7 -5
View File
@@ -40,11 +40,13 @@ pub unsafe extern "C" fn redox_event_queue_get_events_v1(
size_of::<syscall::Event>(),
"EOF not yet defined for event queue reads"
);
buf.write(event::raw::RawEventV1 {
fd: event.id,
flags: event::raw::EventFlags::from(event.flags).bits(),
user_data: event.data,
});
unsafe {
buf.write(event::raw::RawEventV1 {
fd: event.id,
flags: event::raw::EventFlags::from(event.flags).bits(),
user_data: event.data,
})
};
Ok(1)
})())
src/platform/redox/extra.rs
+3 -4
View File
@@ -10,10 +10,9 @@ pub use redox_rt::proc::FdGuard;
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_fpath(fd: c_int, buf: *mut c_void, count: size_t) -> ssize_t {
syscall::fpath(
fd as usize,
slice::from_raw_parts_mut(buf as *mut u8, count),
)
syscall::fpath(fd as usize, unsafe {
slice::from_raw_parts_mut(buf as *mut u8, count)
})
.map_err(Errno::from)
.map(|l| l as ssize_t)
.or_minus_one_errno()
src/platform/redox/libredox.rs
+68 -60
View File
@@ -40,7 +40,7 @@ pub unsafe fn fstat(fd: usize, buf: *mut crate::header::sys_stat::stat) -> sysca
let mut redox_buf: syscall::Stat = Default::default();
syscall::fstat(fd, &mut redox_buf)?;
if let Some(buf) = buf.as_mut() {
if let Some(buf) = unsafe { buf.as_mut() } {
buf.st_dev = redox_buf.st_dev as dev_t;
buf.st_ino = redox_buf.st_ino as ino_t;
buf.st_nlink = redox_buf.st_nlink as nlink_t;
@@ -75,18 +75,20 @@ pub unsafe fn fstatvfs(
syscall::fstatvfs(fd, &mut kbuf)?;
if !buf.is_null() {
(*buf).f_bsize = kbuf.f_bsize as c_ulong;
(*buf).f_frsize = kbuf.f_bsize as c_ulong;
(*buf).f_blocks = kbuf.f_blocks as c_ulong;
(*buf).f_bfree = kbuf.f_bfree as c_ulong;
(*buf).f_bavail = kbuf.f_bavail as c_ulong;
//TODO
(*buf).f_files = 0;
(*buf).f_ffree = 0;
(*buf).f_favail = 0;
(*buf).f_fsid = 0;
(*buf).f_flag = 0;
(*buf).f_namemax = 0;
unsafe {
(*buf).f_bsize = kbuf.f_bsize as c_ulong;
(*buf).f_frsize = kbuf.f_bsize as c_ulong;
(*buf).f_blocks = kbuf.f_blocks as c_ulong;
(*buf).f_bfree = kbuf.f_bfree as c_ulong;
(*buf).f_bavail = kbuf.f_bavail as c_ulong;
//TODO
(*buf).f_files = 0;
(*buf).f_ffree = 0;
(*buf).f_favail = 0;
(*buf).f_fsid = 0;
(*buf).f_flag = 0;
(*buf).f_namemax = 0;
}
}
Ok(())
}
@@ -104,10 +106,7 @@ pub unsafe fn futimens(fd: usize, times: *const timespec) -> syscall::Result<()>
},
]
} else {
times
.cast::<[timespec; 2]>()
.read()
.map(|ts| syscall::TimeSpec::from(&ts))
unsafe { times.cast::<[timespec; 2]>().read() }.map(|ts| syscall::TimeSpec::from(&ts))
};
syscall::futimens(fd as usize, &times)?;
Ok(())
@@ -130,7 +129,7 @@ pub unsafe extern "C" fn redox_open_v1(
mode: u16,
) -> RawResult {
Error::mux(open(
str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)),
unsafe { str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)) },
flags as c_int,
mode as mode_t,
))
@@ -144,14 +143,16 @@ pub unsafe extern "C" fn redox_openat_v1(
) -> RawResult {
Error::mux(syscall::openat(
fd,
str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)),
unsafe { str::from_utf8_unchecked(slice::from_raw_parts(path_base, path_len)) },
flags as usize,
0, //TODO: openat fcntl_flags
))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_dup_v1(fd: usize, buf: *const u8, len: usize) -> RawResult {
Error::mux(syscall::dup(fd, core::slice::from_raw_parts(buf, len)))
Error::mux(syscall::dup(fd, unsafe {
core::slice::from_raw_parts(buf, len)
}))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_dup2_v1(
@@ -160,15 +161,15 @@ pub unsafe extern "C" fn redox_dup2_v1(
buf: *const u8,
len: usize,
) -> RawResult {
Error::mux(syscall::dup2(
old_fd,
new_fd,
core::slice::from_raw_parts(buf, len),
))
Error::mux(syscall::dup2(old_fd, new_fd, unsafe {
core::slice::from_raw_parts(buf, len)
}))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_read_v1(fd: usize, dst_base: *mut u8, dst_len: usize) -> RawResult {
Error::mux(posix_read(fd, slice::from_raw_parts_mut(dst_base, dst_len)))
Error::mux(posix_read(fd, unsafe {
slice::from_raw_parts_mut(dst_base, dst_len)
}))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_write_v1(
@@ -176,7 +177,9 @@ pub unsafe extern "C" fn redox_write_v1(
src_base: *const u8,
src_len: usize,
) -> RawResult {
Error::mux(posix_write(fd, slice::from_raw_parts(src_base, src_len)))
Error::mux(posix_write(fd, unsafe {
slice::from_raw_parts(src_base, src_len)
}))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_fsync_v1(fd: usize) -> RawResult {
@@ -197,28 +200,27 @@ pub unsafe extern "C" fn redox_fchown_v1(fd: usize, new_uid: u32, new_gid: u32)
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_fpath_v1(fd: usize, dst_base: *mut u8, dst_len: usize) -> RawResult {
Error::mux(syscall::fpath(
fd,
core::slice::from_raw_parts_mut(dst_base, dst_len),
))
Error::mux(syscall::fpath(fd, unsafe {
core::slice::from_raw_parts_mut(dst_base, dst_len)
}))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_fstat_v1(
fd: usize,
stat: *mut crate::header::sys_stat::stat,
) -> RawResult {
Error::mux(fstat(fd, stat).map(|()| 0))
Error::mux(unsafe { fstat(fd, stat) }.map(|()| 0))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_fstatvfs_v1(
fd: usize,
stat: *mut crate::header::sys_statvfs::statvfs,
) -> RawResult {
Error::mux(fstatvfs(fd, stat).map(|()| 0))
Error::mux(unsafe { fstatvfs(fd, stat) }.map(|()| 0))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_futimens_v1(fd: usize, times: *const timespec) -> RawResult {
Error::mux(futimens(fd, times).map(|()| 0))
Error::mux(unsafe { futimens(fd, times) }.map(|()| 0))
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_close_v1(fd: usize) -> RawResult {
@@ -271,7 +273,7 @@ pub unsafe extern "C" fn redox_waitpid_v1(pid: usize, status: *mut i32, options:
&mut sts,
WaitFlags::from_bits_truncate(options as usize),
));
status.write(sts as i32);
unsafe { status.write(sts as i32) };
res
}
@@ -289,9 +291,11 @@ pub unsafe extern "C" fn redox_sigaction_v1(
old: *mut sigaction,
) -> RawResult {
Error::mux(
Sys::sigaction(signal as c_int, new.as_ref(), old.as_mut())
.map(|()| 0)
.map_err(Into::into),
Sys::sigaction(signal as c_int, unsafe { new.as_ref() }, unsafe {
old.as_mut()
})
.map(|()| 0)
.map_err(Into::into),
)
}
@@ -302,9 +306,11 @@ pub unsafe extern "C" fn redox_sigprocmask_v1(
old: *mut u64,
) -> RawResult {
Error::mux(
Sys::sigprocmask(how as c_int, new.as_ref(), old.as_mut())
.map(|()| 0)
.map_err(Into::into),
Sys::sigprocmask(how as c_int, unsafe { new.as_ref() }, unsafe {
old.as_mut()
})
.map(|()| 0)
.map_err(Into::into),
)
}
#[unsafe(no_mangle)]
@@ -316,26 +322,28 @@ pub unsafe extern "C" fn redox_mmap_v1(
fd: usize,
offset: u64,
) -> RawResult {
Error::mux(syscall::fmap(
fd,
&syscall::Map {
address: addr as usize,
offset: offset as usize,
size: unaligned_len,
flags: syscall::MapFlags::from_bits_truncate(
((prot << 16) | (flags & 0xffff)) as usize,
),
},
))
Error::mux(unsafe {
syscall::fmap(
fd,
&syscall::Map {
address: addr as usize,
offset: offset as usize,
size: unaligned_len,
flags: syscall::MapFlags::from_bits_truncate(
((prot << 16) | (flags & 0xffff)) as usize,
),
},
)
})
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_munmap_v1(addr: *mut (), unaligned_len: usize) -> RawResult {
Error::mux(syscall::funmap(addr as usize, unaligned_len))
Error::mux(unsafe { syscall::funmap(addr as usize, unaligned_len) })
}
#[unsafe(no_mangle)]
pub unsafe extern "C" fn redox_clock_gettime_v1(clock: usize, ts: *mut timespec) -> RawResult {
Error::mux(clock_gettime(clock, Out::nonnull(ts)).map(|()| 0))
Error::mux(clock_gettime(clock, unsafe { Out::nonnull(ts) }).map(|()| 0))
}
#[unsafe(no_mangle)]
@@ -344,7 +352,7 @@ pub unsafe extern "C" fn redox_strerror_v1(
buflen: *mut usize,
error: u32,
) -> RawResult {
let dst = core::slice::from_raw_parts_mut(buf, buflen.read());
let dst = unsafe { core::slice::from_raw_parts_mut(buf, buflen.read()) };
Error::mux((|| {
// TODO: Merge syscall::error::STR_ERROR into crate::header::error::?
@@ -356,7 +364,7 @@ pub unsafe extern "C" fn redox_strerror_v1(
// This API ensures that the returned buffer is proper UTF-8. Thus, it returns both the
// copied length and the actual length.
buflen.write(src.len());
unsafe { buflen.write(src.len()) };
let raw_len = core::cmp::min(dst.len(), src.len());
let len = match core::str::from_utf8(&src.as_bytes()[..raw_len]) {
@@ -380,7 +388,7 @@ pub unsafe extern "C" fn redox_mkns_v1(
return Err(Error::new(EINVAL));
}
// Kernel does the UTF-8 validation.
syscall::mkns(core::slice::from_raw_parts(names.cast(), num_names))
syscall::mkns(unsafe { core::slice::from_raw_parts(names.cast(), num_names) })
})())
}
@@ -406,9 +414,9 @@ pub unsafe extern "C" fn redox_sys_call_v0(
) -> RawResult {
Error::mux(redox_rt::sys::sys_call(
fd,
slice::from_raw_parts_mut(payload, payload_len),
unsafe { slice::from_raw_parts_mut(payload, payload_len) },
syscall::CallFlags::from_bits_retain(flags),
slice::from_raw_parts(metadata, metadata_len),
unsafe { slice::from_raw_parts(metadata, metadata_len) },
))
}
@@ -421,7 +429,7 @@ pub unsafe extern "C" fn redox_get_socket_token_v0(
let metadata = [SocketCall::GetToken as u64];
Error::mux(redox_rt::sys::sys_call(
fd,
slice::from_raw_parts_mut(payload, payload_len),
unsafe { slice::from_raw_parts_mut(payload, payload_len) },
syscall::CallFlags::empty(),
&metadata,
))
src/platform/redox/mod.rs
+36 -30
View File
@@ -140,29 +140,33 @@ impl Pal for Sys {
unsafe fn brk(addr: *mut c_void) -> Result<*mut c_void> {
// On first invocation, allocate a buffer for brk
if BRK_CUR.is_null() {
if unsafe { BRK_CUR }.is_null() {
// 4 megabytes of RAM ought to be enough for anybody
const BRK_MAX_SIZE: usize = 4 * 1024 * 1024;
let allocated = Self::mmap(
ptr::null_mut(),
BRK_MAX_SIZE,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS,
0,
0,
)?;
let allocated = unsafe {
Self::mmap(
ptr::null_mut(),
BRK_MAX_SIZE,
PROT_READ | PROT_WRITE,
MAP_ANONYMOUS,
0,
0,
)
}?;
BRK_CUR = allocated;
BRK_END = (allocated as *mut u8).add(BRK_MAX_SIZE) as *mut c_void;
unsafe {
BRK_CUR = allocated;
BRK_END = (allocated as *mut u8).add(BRK_MAX_SIZE) as *mut c_void
};
}
if addr.is_null() {
// Lookup what previous brk() invocations have set the address to
Ok(BRK_CUR)
} else if BRK_CUR <= addr && addr < BRK_END {
Ok(unsafe { BRK_CUR })
} else if unsafe { BRK_CUR } <= addr && addr < unsafe { BRK_END } {
// It's inside buffer, return
BRK_CUR = addr;
unsafe { BRK_CUR = addr };
Ok(addr)
} else {
// It was outside of valid range
@@ -258,7 +262,7 @@ impl Pal for Sys {
self::exec::execve(
Executable::InFd {
file: File::new(fildes),
arg0: CStr::from_ptr(argv.read()).to_bytes(),
arg0: unsafe { CStr::from_ptr(argv.read()) }.to_bytes(),
},
self::exec::ArgEnv::C { argv, envp },
None,
@@ -395,22 +399,22 @@ impl Pal for Sys {
tv_sec: d.tv_sec,
tv_nsec: d.tv_nsec as i32,
});
redox_rt::sys::sys_futex_wait(addr, val, deadline.as_ref())?;
(unsafe { redox_rt::sys::sys_futex_wait(addr, val, deadline.as_ref()) })?;
Ok(())
}
#[inline]
unsafe fn futex_wake(addr: *mut u32, num: u32) -> Result<u32> {
Ok(redox_rt::sys::sys_futex_wake(addr, num)?)
Ok(unsafe { redox_rt::sys::sys_futex_wake(addr, num) }?)
}
unsafe fn futimens(fd: c_int, times: *const timespec) -> Result<()> {
libredox::futimens(fd as usize, times)?;
(unsafe { libredox::futimens(fd as usize, times) })?;
Ok(())
}
unsafe fn utimens(path: CStr, times: *const timespec) -> Result<()> {
let file = File::open(path, fcntl::O_PATH | fcntl::O_CLOEXEC)?;
Self::futimens(*file, times)
unsafe { Self::futimens(*file, times) }
}
fn getcwd(buf: Out<[u8]>) -> Result<()> {
@@ -791,9 +795,9 @@ impl Pal for Sys {
};
Ok(if flags & MAP_ANONYMOUS == MAP_ANONYMOUS {
syscall::fmap(!0, &map)?
(unsafe { syscall::fmap(!0, &map) })?
} else {
syscall::fmap(fildes as usize, &map)?
(unsafe { syscall::fmap(fildes as usize, &map) })?
} as *mut c_void)
}
@@ -811,12 +815,14 @@ impl Pal for Sys {
let Some(len) = round_up_to_page_size(len) else {
return Err(Errno(ENOMEM));
};
syscall::mprotect(
addr as usize,
len,
syscall::MapFlags::from_bits((prot as usize) << 16)
.expect("mprotect: invalid bit pattern"),
)?;
(unsafe {
syscall::mprotect(
addr as usize,
len,
syscall::MapFlags::from_bits((prot as usize) << 16)
.expect("mprotect: invalid bit pattern"),
)
})?;
Ok(())
}
@@ -853,7 +859,7 @@ impl Pal for Sys {
let Some(len) = round_up_to_page_size(len) else {
return Err(Errno(ENOMEM));
};
syscall::funmap(addr as usize, len)?;
(unsafe { syscall::funmap(addr as usize, len) })?;
Ok(())
}
@@ -969,7 +975,7 @@ impl Pal for Sys {
os_specific: &mut OsSpecific,
) -> Result<crate::pthread::OsTid> {
let _guard = CLONE_LOCK.read();
let res = clone::rlct_clone_impl(stack, os_specific);
let res = unsafe { clone::rlct_clone_impl(stack, os_specific) };
res.map(|thread_fd| crate::pthread::OsTid { thread_fd })
.map_err(|error| Errno(error.errno))
@@ -1504,6 +1510,6 @@ impl Pal for Sys {
}
unsafe fn exit_thread(stack_base: *mut (), stack_size: usize) -> ! {
redox_rt::thread::exit_this_thread(stack_base, stack_size)
unsafe { redox_rt::thread::exit_this_thread(stack_base, stack_size) }
}
}
src/platform/redox/ptrace.rs
+1 -1
View File
@@ -276,7 +276,7 @@ impl PalPtrace for Sys {
addr: *mut c_void,
data: *mut c_void,
) -> Result<c_int, Errno> {
inner_ptrace(request, pid, addr, data)
unsafe { inner_ptrace(request, pid, addr, data) }
.map_err(|err| Errno(err.raw_os_error().unwrap_or(EIO)))
}
}
src/platform/redox/signal.rs
+1 -1
View File
@@ -200,7 +200,7 @@ impl PalSignal for Sys {
.transpose()?;
let mut old = old_c.as_ref().map(|_| Sigaltstack::default());
redox_rt::signal::sigaltstack(new.as_ref(), old.as_mut())?;
(unsafe { redox_rt::signal::sigaltstack(new.as_ref(), old.as_mut()) })?;
if let (Some(old_c_stack), Some(old)) = (old_c, old) {
let c_stack = PosixStackt::from(old);
src/platform/redox/socket.rs
+139 -113
View File
@@ -41,17 +41,19 @@ unsafe fn bind_or_connect(
return Err(Errno(EINVAL));
}
let path = match (*address).sa_family as c_int {
let path = match unsafe { (*address).sa_family } as c_int {
AF_INET => {
if (address_len as usize) != mem::size_of::<sockaddr_in>() {
return Err(Errno(EINVAL));
}
let data = &*(address as *const sockaddr_in);
let addr = slice::from_raw_parts(
&data.sin_addr.s_addr as *const _ as *const u8,
mem::size_of_val(&data.sin_addr.s_addr),
);
let data = unsafe { &*(address as *const sockaddr_in) };
let addr = unsafe {
slice::from_raw_parts(
&data.sin_addr.s_addr as *const _ as *const u8,
mem::size_of_val(&data.sin_addr.s_addr),
)
};
let port = in_port_t::from_be(data.sin_port);
match op {
@@ -81,18 +83,19 @@ pub unsafe fn bind_or_connect_into(
address_len: socklen_t,
) -> Result<c_int, Errno> {
// Duplicate the socket, and then duplicate the copy back to the original fd
let fd = FdGuard::new(bind_or_connect(op, socket, address, address_len)?);
let fd = FdGuard::new(unsafe { bind_or_connect(op, socket, address, address_len) }?);
syscall::dup2(fd.as_raw_fd(), socket as usize, &[])?;
Ok(0)
}
unsafe fn inner_af_unix(buf: &[u8], address: *mut sockaddr, address_len: *mut socklen_t) {
let data = &mut *(address as *mut sockaddr_un);
let data = unsafe { &mut *(address as *mut sockaddr_un) };
data.sun_family = AF_UNIX as c_ushort;
let path =
slice::from_raw_parts_mut(&mut data.sun_path as *mut _ as *mut u8, data.sun_path.len());
let path = unsafe {
slice::from_raw_parts_mut(&mut data.sun_path as *mut _ as *mut u8, data.sun_path.len())
};
let len = cmp::min(path.len(), buf.len());
path[..len].copy_from_slice(&buf[..len]);
@@ -100,7 +103,7 @@ unsafe fn inner_af_unix(buf: &[u8], address: *mut sockaddr, address_len: *mut so
path[len] = 0;
}
*address_len = len as socklen_t;
unsafe { *address_len = len as socklen_t };
}
unsafe fn inner_af_inet(
@@ -131,7 +134,7 @@ unsafe fn inner_af_inet(
let mut addr = in_addr::default();
assert_eq!(
inet_aton(raw_addr.as_ptr() as *mut c_char, &mut addr),
unsafe { inet_aton(raw_addr.as_ptr() as *mut c_char, &mut addr) },
1,
"inet_aton might be broken, failed to parse netstack address"
);
@@ -143,10 +146,12 @@ unsafe fn inner_af_inet(
..sockaddr_in::default()
};
let len = cmp::min(*address_len as usize, mem::size_of_val(&ret));
let len = cmp::min(unsafe { *address_len } as usize, mem::size_of_val(&ret));
ptr::copy_nonoverlapping(&ret as *const _ as *const u8, address as *mut u8, len);
*address_len = len as socklen_t;
unsafe {
ptr::copy_nonoverlapping(&ret as *const _ as *const u8, address as *mut u8, len);
*address_len = len as socklen_t;
}
}
unsafe fn inner_get_name_inner(
@@ -156,17 +161,17 @@ unsafe fn inner_get_name_inner(
buf: &[u8],
) -> Result<()> {
if buf.starts_with(b"tcp:") || buf.starts_with(b"udp:") {
inner_af_inet(local, &buf[4..], address, address_len);
unsafe { inner_af_inet(local, &buf[4..], address, address_len) };
} else if buf.starts_with(b"/scheme/tcp/") || buf.starts_with(b"/scheme/udp/") {
inner_af_inet(local, &buf[12..], address, address_len);
unsafe { inner_af_inet(local, &buf[12..], address, address_len) };
} else if buf.starts_with(b"chan:") {
inner_af_unix(&buf[5..], address, address_len);
unsafe { inner_af_unix(&buf[5..], address, address_len) };
} else if buf.starts_with(b"/scheme/chan/") {
inner_af_unix(&buf[13..], address, address_len);
unsafe { inner_af_unix(&buf[13..], address, address_len) };
} else if buf.starts_with(b"/scheme/uds_stream/") {
inner_af_unix(&buf[19..], address, address_len);
unsafe { inner_af_unix(&buf[19..], address, address_len) };
} else if buf.starts_with(b"/scheme/uds_dgram/") {
inner_af_unix(&buf[18..], address, address_len);
unsafe { inner_af_unix(&buf[18..], address, address_len) };
} else {
// Socket doesn't belong to any scheme
trace!(
@@ -239,12 +244,12 @@ unsafe fn serialize_ancillary_data_to_stream(
return Err(Errno(EINVAL));
}
let mut cmsg: *mut cmsghdr = CMSG_FIRSTHDR(msg);
let mut cmsg: *mut cmsghdr = unsafe { CMSG_FIRSTHDR(msg) };
let mut cmsg_count = 0;
while !cmsg.is_null() {
cmsg_count += 1;
let current_cmsg = &*cmsg;
let min_cmsg_len = CMSG_ALIGN(mem::size_of::<cmsghdr>());
let current_cmsg = unsafe { &*cmsg };
let min_cmsg_len = unsafe { CMSG_ALIGN(mem::size_of::<cmsghdr>()) };
if current_cmsg.cmsg_len < min_cmsg_len {
return Err(Errno(EINVAL));
}
@@ -263,8 +268,8 @@ unsafe fn serialize_ancillary_data_to_stream(
// Call syscall::sendfd for each fd.
if fd_count > 0 {
let fds_ptr = CMSG_DATA(cmsg) as *const c_int;
let fds_slice = slice::from_raw_parts(fds_ptr, fd_count);
let fds_ptr = unsafe { CMSG_DATA(cmsg) } as *const c_int;
let fds_slice = unsafe { slice::from_raw_parts(fds_ptr, fd_count) };
for &fd in fds_slice.iter() {
let fd_to_send = FdGuard::new(syscall::dup(fd as usize, b"")?);
syscall::sendfd(socket as usize, fd_to_send.as_raw_fd(), 0, 0)?;
@@ -288,7 +293,7 @@ unsafe fn serialize_ancillary_data_to_stream(
return Err(Errno(EOPNOTSUPP));
}
}
cmsg = CMSG_NXTHDR(msg, cmsg);
cmsg = unsafe { CMSG_NXTHDR(msg, cmsg) };
}
Ok(())
}
@@ -309,12 +314,14 @@ unsafe fn deserialize_name_from_stream(
}
if !mhdr.msg_name.is_null() && mhdr.msg_namelen > 0 {
let name_buffer = &msg_stream[*cursor..*cursor + name_len];
inner_get_name_inner(
false,
mhdr.msg_name as *mut sockaddr,
&mut mhdr.msg_namelen,
name_buffer,
)?;
(unsafe {
inner_get_name_inner(
false,
mhdr.msg_name as *mut sockaddr,
&mut mhdr.msg_namelen,
name_buffer,
)
})?;
}
*cursor += name_len;
} else {
@@ -387,7 +394,7 @@ unsafe fn deserialize_ancillary_data_from_stream(
) -> Result<()> {
let mut current_cmsg_ptr_in_user_buf = if !mhdr.msg_control.is_null() && cmsg_space_provided > 0
{
CMSG_FIRSTHDR(mhdr)
unsafe { CMSG_FIRSTHDR(mhdr) }
} else {
ptr::null_mut()
};
@@ -464,27 +471,31 @@ unsafe fn deserialize_ancillary_data_from_stream(
}
}
let space_needed_for_posix_cmsg = CMSG_SPACE(actual_posix_cmsg_data_len as u32) as usize;
let space_needed_for_posix_cmsg =
unsafe { CMSG_SPACE(actual_posix_cmsg_data_len as u32) } as usize;
if !current_cmsg_ptr_in_user_buf.is_null()
&& remaining_user_cmsg_buf_len >= space_needed_for_posix_cmsg
{
let cmsg_ref = &mut *current_cmsg_ptr_in_user_buf;
cmsg_ref.cmsg_len = CMSG_LEN(actual_posix_cmsg_data_len as u32) as usize;
let cmsg_ref = unsafe { &mut *current_cmsg_ptr_in_user_buf };
cmsg_ref.cmsg_len = unsafe { CMSG_LEN(actual_posix_cmsg_data_len as u32) } as usize;
cmsg_ref.cmsg_level = cmsg_level;
cmsg_ref.cmsg_type = cmsg_type;
let data_ptr_in_user_cmsg = CMSG_DATA(cmsg_ref);
ptr::copy_nonoverlapping(
temp_posix_cmsg_data_buf.as_ptr(),
data_ptr_in_user_cmsg as *mut u8,
actual_posix_cmsg_data_len,
);
let data_ptr_in_user_cmsg = unsafe { CMSG_DATA(cmsg_ref) };
unsafe {
ptr::copy_nonoverlapping(
temp_posix_cmsg_data_buf.as_ptr(),
data_ptr_in_user_cmsg as *mut u8,
actual_posix_cmsg_data_len,
)
};
let aligned_len_written = CMSG_ALIGN(cmsg_ref.cmsg_len);
let aligned_len_written = unsafe { CMSG_ALIGN(cmsg_ref.cmsg_len) };
total_csmg_bytes_written_to_user_buf += aligned_len_written;
remaining_user_cmsg_buf_len -= aligned_len_written;
current_cmsg_ptr_in_user_buf = CMSG_NXTHDR(mhdr, current_cmsg_ptr_in_user_buf);
current_cmsg_ptr_in_user_buf =
unsafe { CMSG_NXTHDR(mhdr, current_cmsg_ptr_in_user_buf) };
} else {
mhdr.msg_flags |= MSG_CTRUNC;
break;
@@ -502,7 +513,7 @@ impl PalSocket for Sys {
) -> Result<c_int> {
let stream = syscall::dup(socket as usize, b"listen")?;
if address != ptr::null_mut() && address_len != ptr::null_mut() {
if let Err(err) = Self::getpeername(stream as c_int, address, address_len) {
if let Err(err) = unsafe { Self::getpeername(stream as c_int, address, address_len) } {
let _ = syscall::close(stream);
return Err(err);
}
@@ -511,12 +522,12 @@ impl PalSocket for Sys {
}
unsafe fn bind(socket: c_int, address: *const sockaddr, address_len: socklen_t) -> Result<()> {
match (*address).sa_family as c_int {
match unsafe { (*address).sa_family } as c_int {
AF_INET => {
bind_or_connect_into(SocketCall::Bind, socket, address, address_len)?;
(unsafe { bind_or_connect_into(SocketCall::Bind, socket, address, address_len) })?;
}
AF_UNIX => {
let data = &*(address as *const sockaddr_un);
let data = unsafe { &*(address as *const sockaddr_un) };
// NOTE: It's UB to access data in given address that exceeds
// the given address length.
@@ -531,10 +542,11 @@ impl PalSocket for Sys {
// The maximum length of the address
maxlen,
// The first NUL byte, if any
strnlen(&data.sun_path as *const _, maxlen as size_t),
unsafe { strnlen(&data.sun_path as *const _, maxlen as size_t) },
);
let addr = slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len);
let addr =
unsafe { slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len) };
let path = format!("{}", str::from_utf8(addr).unwrap());
trace!("path: {:?}", path);
@@ -542,7 +554,7 @@ impl PalSocket for Sys {
redox_rt::sys::sys_call(
socket as usize,
fd_path.as_bytes_mut(),
unsafe { fd_path.as_bytes_mut() },
CallFlags::empty(),
&[SocketCall::Bind as u64],
)?;
@@ -586,10 +598,12 @@ impl PalSocket for Sys {
address: *const sockaddr,
address_len: socklen_t,
) -> Result<c_int> {
match (*address).sa_family as c_int {
AF_INET => bind_or_connect_into(SocketCall::Connect, socket, address, address_len),
match unsafe { (*address).sa_family } as c_int {
AF_INET => unsafe {
bind_or_connect_into(SocketCall::Connect, socket, address, address_len)
},
AF_UNIX => {
let data = &*(address as *const sockaddr_un);
let data = unsafe { &*(address as *const sockaddr_un) };
// NOTE: It's UB to access data in given address that exceeds
// the given address length.
@@ -604,10 +618,11 @@ impl PalSocket for Sys {
// The maximum length of the address
maxlen,
// The first NUL byte, if any
strnlen(&data.sun_path as *const _, maxlen as size_t),
unsafe { strnlen(&data.sun_path as *const _, maxlen as size_t) },
);
let addr = slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len);
let addr =
unsafe { slice::from_raw_parts(&data.sun_path as *const _ as *const u8, len) };
let mut path = format!("{}", str::from_utf8(addr).unwrap());
trace!("path: {:?}", path);
@@ -652,7 +667,7 @@ impl PalSocket for Sys {
&[SocketCall::GetPeerName as u64],
)?;
inner_get_name_inner(false, address, address_len, &buf[..len])
unsafe { inner_get_name_inner(false, address, address_len, &buf[..len]) }
}
unsafe fn getsockname(
@@ -663,7 +678,7 @@ impl PalSocket for Sys {
let mut buf = [0; 256];
let len = syscall::fpath(socket as usize, &mut buf)?;
inner_get_name_inner(true, address, address_len, &buf[..len])
unsafe { inner_get_name_inner(true, address, address_len, &buf[..len]) }
}
unsafe fn getsockopt(
@@ -676,7 +691,7 @@ impl PalSocket for Sys {
if option_len_ptr.is_null() {
return Err(Errno(EFAULT));
}
let option_len = (*option_len_ptr) as usize;
let option_len = (unsafe { *option_len_ptr }) as usize;
let option_c_int = || -> Result<&mut c_int> {
if option_value.is_null() {
@@ -695,32 +710,35 @@ impl PalSocket for Sys {
SO_DOMAIN => {
let option = option_c_int()?;
*option = socket_domain_type(socket)?.0;
*option_len_ptr = mem::size_of::<c_int>() as socklen_t;
unsafe { *option_len_ptr = mem::size_of::<c_int>() as socklen_t };
return Ok(());
}
SO_ERROR => {
let option = option_c_int()?;
//TODO: Socket nonblock connection error
*option = 0;
*option_len_ptr = mem::size_of::<c_int>() as socklen_t;
unsafe { *option_len_ptr = mem::size_of::<c_int>() as socklen_t };
return Ok(());
}
SO_TYPE => {
let option = option_c_int()?;
*option = socket_domain_type(socket)?.1;
*option_len_ptr = mem::size_of::<c_int>() as socklen_t;
unsafe { *option_len_ptr = mem::size_of::<c_int>() as socklen_t };
return Ok(());
}
_ => {
let metadata = [SocketCall::GetSockOpt as u64, option_name as u64];
let payload = slice::from_raw_parts_mut(option_value as *mut u8, option_len);
let payload =
unsafe { slice::from_raw_parts_mut(option_value as *mut u8, option_len) };
let call_flags = CallFlags::empty();
*option_len_ptr = redox_rt::sys::sys_call(
socket as usize,
payload,
CallFlags::empty(),
&metadata,
)? as socklen_t;
unsafe {
*option_len_ptr = redox_rt::sys::sys_call(
socket as usize,
payload,
CallFlags::empty(),
&metadata,
)? as socklen_t;
}
return Ok(());
}
},
@@ -756,7 +774,7 @@ impl PalSocket for Sys {
let mut msg = msghdr {
msg_name: address as *mut c_void,
msg_namelen: if !address_len.is_null() {
*address_len
unsafe { *address_len }
} else {
0
},
@@ -766,26 +784,30 @@ impl PalSocket for Sys {
msg_controllen: 0,
msg_flags: 0,
};
let count = Self::recvmsg(socket, &mut msg, flags)?;
let count = unsafe { Self::recvmsg(socket, &mut msg, flags) }?;
if !address_len.is_null() {
*address_len = msg.msg_namelen;
unsafe { *address_len = msg.msg_namelen };
}
return Ok(count);
}
if address.is_null() || address_len.is_null() {
Self::read(socket, slice::from_raw_parts_mut(buf as *mut u8, len))
Self::read(socket, unsafe {
slice::from_raw_parts_mut(buf as *mut u8, len)
})
} else {
// TODO: in UDS dgram getpeername on listener always return ENOTCONN,
// it probably the expected error on usual getpeername call, but not here.
if let Err(e) = Self::getpeername(socket, address, address_len) {
if let Err(e) = unsafe { Self::getpeername(socket, address, address_len) } {
if e.0 != ENOTCONN {
return Err(e);
}
let data = &mut *(address as *mut sockaddr);
let data = unsafe { &mut *(address as *mut sockaddr) };
data.sa_family = AF_UNSPEC as u16;
*address_len = 0;
unsafe { *address_len = 0 };
}
Self::read(socket, slice::from_raw_parts_mut(buf as *mut u8, len))
Self::read(socket, unsafe {
slice::from_raw_parts_mut(buf as *mut u8, len)
})
}
}
@@ -793,7 +815,7 @@ impl PalSocket for Sys {
if msg.is_null() {
return Err(Errno(EINVAL));
}
let mut mhdr = &mut *msg;
let mut mhdr = unsafe { &mut *msg };
let iovs_slice: &[iovec] = if mhdr.msg_iov.is_null() || mhdr.msg_iovlen == 0 {
&[]
} else {
@@ -843,29 +865,33 @@ impl PalSocket for Sys {
mhdr.msg_flags = 0;
// Read sender name.
deserialize_name_from_stream(&mut mhdr, &msg_stream, &mut cursor)?;
(unsafe { deserialize_name_from_stream(&mut mhdr, &msg_stream, &mut cursor) })?;
// Read payload data.
let actual_payload_bytes_written_to_iov = deserialize_payload_from_stream(
&mut mhdr,
&msg_stream,
iovs_slice,
whole_iov_size,
&mut cursor,
0u8,
)?;
let actual_payload_bytes_written_to_iov = unsafe {
deserialize_payload_from_stream(
&mut mhdr,
&msg_stream,
iovs_slice,
whole_iov_size,
&mut cursor,
0u8,
)
}?;
// Reconstruct the ancillary data in the user-provided buffer.
let has_cmsg_buffer = !mhdr.msg_control.is_null() && cmsg_space_provided_by_user > 0;
let has_ancillary_data = cursor < msg_stream.len();
if has_cmsg_buffer && has_ancillary_data {
deserialize_ancillary_data_from_stream(
mhdr,
socket,
&msg_stream,
&mut cursor,
cmsg_space_provided_by_user as usize,
)?;
(unsafe {
deserialize_ancillary_data_from_stream(
mhdr,
socket,
&msg_stream,
&mut cursor,
cmsg_space_provided_by_user as usize,
)
})?;
} else {
mhdr.msg_controllen = 0; // No ancillary data
}
@@ -876,7 +902,7 @@ impl PalSocket for Sys {
if msg.is_null() {
return Err(Errno(EINVAL));
}
let mhdr = &*msg;
let mhdr = unsafe { &*msg };
// Reserve space for the message stream.
// [payload_len(usize)][payload_data_buffer]
@@ -900,12 +926,13 @@ impl PalSocket for Sys {
// Write the message to the msg_stream.
let mut actual_payload_bytes_serialized = 0;
if !mhdr.msg_iov.is_null() && mhdr.msg_iovlen > 0 {
actual_payload_bytes_serialized =
serialize_payload_to_stream(&mut msg_stream, &iovs_slice, whole_iov_size)?;
actual_payload_bytes_serialized = unsafe {
serialize_payload_to_stream(&mut msg_stream, &iovs_slice, whole_iov_size)
}?;
}
// Process Control Messages from msghdr and serialize them.
if mhdr.msg_controllen > 0 {
serialize_ancillary_data_to_stream(msg, mhdr, socket, &mut msg_stream)?;
(unsafe { serialize_ancillary_data_to_stream(msg, mhdr, socket, &mut msg_stream) })?;
}
// Send the message stream.
@@ -944,21 +971,19 @@ impl PalSocket for Sys {
msg_controllen: 0,
msg_flags: 0,
};
return Self::sendmsg(socket, &msg, flags);
return unsafe { Self::sendmsg(socket, &msg, flags) };
}
if dest_addr == ptr::null() || dest_len == 0 {
Self::write(socket, slice::from_raw_parts(buf as *const u8, len))
Self::write(socket, unsafe {
slice::from_raw_parts(buf as *const u8, len)
})
} else {
let fd = FdGuard::new(bind_or_connect(
SocketCall::Connect,
socket,
dest_addr,
dest_len,
)?);
Self::write(
fd.as_c_fd().unwrap(),
slice::from_raw_parts(buf as *const u8, len),
)
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)
})
}
}
@@ -1001,8 +1026,9 @@ impl PalSocket for Sys {
SO_SNDTIMEO => return set_timeout(b"write_timeout"),
_ => {
let metadata = [SocketCall::SetSockOpt as u64, option_name as u64];
let payload =
slice::from_raw_parts_mut(option_value as *mut u8, option_len as usize);
let payload = unsafe {
slice::from_raw_parts_mut(option_value as *mut u8, option_len as usize)
};
let call_flags = CallFlags::empty();
redox_rt::sys::sys_call(
socket as usize,