From 6e597b40aff28b96fa10ecad0c2792ccc7cabffd Mon Sep 17 00:00:00 2001 From: Ruihan Li Date: Tue, 29 Jul 2025 13:28:50 +0800 Subject: [PATCH] Remove unsafe code in `mm/test.rs` --- ostd/src/mm/test.rs | 79 ++++++++++++--------------------------------- 1 file changed, 20 insertions(+), 59 deletions(-) diff --git a/ostd/src/mm/test.rs b/ostd/src/mm/test.rs index a958eb763..ac5e77e37 100644 --- a/ostd/src/mm/test.rs +++ b/ostd/src/mm/test.rs @@ -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::()]; - 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::();