qiurui
/
asterinas
mirror of https://github.com/asterinas/asterinas.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove unsafe code in `mm/test.rs`

This commit is contained in:
Ruihan Li 2025-07-29 13:28:50 +08:00 committed by Tate, Hongliang Tian
parent f2ead0b3ed
commit 6e597b40af
1 changed files with 20 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
ostd/src/mm/test.rs
View File

@ -33,10 +33,7 @@ mod io {
#[ktest]
fn read_write_u32_infallible() {
let mut buffer = [0u8; 8];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
// Write two u32 values
let val1: u32 = 0xDEADBEEF;
@ -49,9 +46,7 @@ mod io {
assert_eq!(&buffer[4..], &val2.to_le_bytes()[..]);
// Read back the values
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
let read_val1: u32 = reader_infallible.read_val().unwrap();
let read_val2: u32 = reader_infallible.read_val().unwrap();
@ -65,19 +60,14 @@ mod io {
fn read_write_slice_infallible() {
let data = [1u8, 2, 3, 4, 5];
let mut buffer = vec![0u8; data.len()];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
writer_infallible.write(&mut VmReader::from(&data[..]));
assert_eq!(buffer, data);
// Read back the bytes
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
let mut read_buffer = [0u8; 5];
reader_infallible.read(&mut VmWriter::from(&mut read_buffer[..]));
@ -89,10 +79,7 @@ mod io {
#[ktest]
fn read_write_struct_infallible() {
let mut buffer = [0u8; size_of::<TestPodStruct>()];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
let test_struct = TestPodStruct {
a: 0x12345678,
@ -101,9 +88,7 @@ mod io {
writer_infallible.write_val(&test_struct).unwrap();
// Read back the struct
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
let read_struct: TestPodStruct = reader_infallible.read_val().unwrap();
@ -115,9 +100,7 @@ mod io {
#[should_panic]
fn read_beyond_buffer_infallible() {
let buffer = [1u8, 2, 3];
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
// Attempt to read a u32 which requires 4 bytes, but buffer has only 3
let _val: u32 = reader_infallible.read_val().unwrap();
@ -128,9 +111,7 @@ mod io {
#[should_panic]
fn write_beyond_buffer_infallible() {
let mut buffer = [0u8; 3];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
// Attempt to write a u32 which requires 4 bytes, but buffer has only 3
let val: u32 = 0xDEADBEEF;
@ -141,26 +122,22 @@ mod io {
#[ktest]
fn fill_infallible() {
let mut buffer = vec![0u8; 8];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
// Fill with 0xFF
let filled = writer_infallible.fill(0xFFu8);
assert_eq!(filled, 8);
assert_eq!(buffer, vec![0xFF; 8]);
// Ensure the cursor is at the end
assert_eq!(writer_infallible.avail(), 0);
assert_eq!(buffer, vec![0xFF; 8]);
}
/// Tests the `skip` method for reading in Infallible mode.
#[ktest]
fn skip_read_infallible() {
let data = [10u8, 20, 30, 40, 50];
let reader = VmReader::from(&data[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), reader.remain()) };
let mut reader_infallible = VmReader::from(&data[..]);
// Skip first two bytes
let reader_infallible = reader_infallible.skip(2);
@ -176,9 +153,7 @@ mod io {
#[ktest]
fn skip_write_infallible() {
let mut buffer = [0u8; 5];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), writer.avail()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
// Skip first two bytes
let writer_infallible = writer_infallible.skip(2);
@ -231,17 +206,13 @@ mod io {
fn read_write_slice_vmio_infallible() {
let data = [100u8, 101, 102, 103, 104];
let mut buffer = [0u8; 5];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
writer_infallible.write(&mut VmReader::from(&data[..]));
assert_eq!(buffer, data);
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
let mut read_data = [0u8; 5];
reader_infallible.read(&mut VmWriter::from(&mut read_data[..]));
@ -253,17 +224,13 @@ mod io {
#[ktest]
fn read_write_once_infallible() {
let mut buffer = [0u8; 8];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
let val: u64 = 0x1122334455667788;
writer_infallible.write_once(&val).unwrap();
// Reads back the value
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
let read_val: u64 = reader_infallible.read_once().unwrap();
assert_eq!(val, read_val);
@ -273,9 +240,7 @@ mod io {
#[ktest]
fn write_val_infallible() {
let mut buffer = [0u8; 12];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
let values = [1u32, 2, 3];
for val in values.iter() {
@ -428,18 +393,14 @@ mod io {
#[ktest]
fn invalid_read_write_infallible() {
let mut buffer = [0u8; 3];
let writer = VmWriter::from(&mut buffer[..]);
let mut writer_infallible =
unsafe { VmWriter::from_kernel_space(writer.cursor(), buffer.len()) };
let mut writer_infallible = VmWriter::from(&mut buffer[..]);
// Attempts to write a u32 which requires 4 bytes, but buffer has only 3
let val: u32 = 0xDEADBEEF;
let result = writer_infallible.write_val(&val);
assert_eq!(result, Err(Error::InvalidArgs));
let reader = VmReader::from(&buffer[..]);
let mut reader_infallible =
unsafe { VmReader::from_kernel_space(reader.cursor(), buffer.len()) };
let mut reader_infallible = VmReader::from(&buffer[..]);
// Attempts to read a u32 which requires 4 bytes, but buffer has only 3
let result = reader_infallible.read_val::<u32>();