Samuka007/asterinas
1
0
Fork 0
mirror of https://github.com/asterinas/asterinas.git synced 2025-06-19 04:26:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make VmReader's several methods accept &mut self

Browse Source
This commit is contained in:
jiangjianfeng
2025-03-24 03:35:28 +00:00
committed by Qingsong Chen
parent 9872adaa71
commit 0e1c660225
9 changed files with 58 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/comps/mlsdisk/src/lib.rs
View File

@ -167,7 +167,7 @@ mod test {
BioType::Read => segment
.inner_segment()
.writer()
.write(&mut self.blocks.reader().skip(current_offset)),
.write(self.blocks.reader().skip(current_offset)),
BioType::Write => self
.blocks
.writer()

19
kernel/comps/network/src/buffer.rs
View File

@ -56,7 +56,9 @@ impl TxBuffer {
}
pub fn writer(&self) -> VmWriter<'_, Infallible> {
self.dma_stream.writer().unwrap().limit(self.nbytes)
let mut writer = self.dma_stream.writer().unwrap();
writer.limit(self.nbytes);
writer
}
fn sync(&self) {
@ -110,21 +112,18 @@ impl RxBuffer {
self.segment
.sync(self.header_len..self.header_len + self.packet_len)
.unwrap();
self.segment
.reader()
.unwrap()
.skip(self.header_len)
.limit(self.packet_len)
let mut reader = self.segment.reader().unwrap();
reader.skip(self.header_len).limit(self.packet_len);
reader
}
pub fn buf(&self) -> VmReader<'_, Infallible> {
self.segment
.sync(0..self.header_len + self.packet_len)
.unwrap();
self.segment
.reader()
.unwrap()
.limit(self.header_len + self.packet_len)
let mut reader = self.segment.reader().unwrap();
reader.limit(self.header_len + self.packet_len);
reader
}
pub const fn buf_len(&self) -> usize {

8
kernel/comps/network/src/dma_pool.rs
View File

@ -236,12 +236,16 @@ impl DmaSegment {
pub fn reader(&self) -> Result<VmReader<'_, Infallible>, ostd::Error> {
let offset = self.start_addr - self.dma_stream.daddr();
Ok(self.dma_stream.reader()?.skip(offset).limit(self.size))
let mut reader = self.dma_stream.reader()?;
reader.skip(offset).limit(self.size);
Ok(reader)
}
pub fn writer(&self) -> Result<VmWriter<'_, Infallible>, ostd::Error> {
let offset = self.start_addr - self.dma_stream.daddr();
Ok(self.dma_stream.writer()?.skip(offset).limit(self.size))
let mut writer = self.dma_stream.writer()?;
writer.skip(offset).limit(self.size);
Ok(writer)
}
pub fn sync(&self, byte_range: Range<usize>) -> Result<(), ostd::Error> {

3
kernel/comps/virtio/src/device/console/device.rs
View File

@ -151,7 +151,8 @@ impl ConsoleDevice {
let callbacks = self.callbacks.read();
for callback in callbacks.iter() {
let reader = self.receive_buffer.reader().unwrap().limit(len as usize);
let mut reader = self.receive_buffer.reader().unwrap();
reader.limit(len as usize);
callback(reader);
}
drop(callbacks);

14
kernel/libs/aster-util/src/segment_slice.rs
View File

@ -71,18 +71,20 @@ impl SegmentSlice {
/// Gets a reader for the slice.
pub fn reader(&self) -> VmReader<'_, Infallible> {
self.inner
.reader()
let mut reader = self.inner.reader();
reader
.skip(self.start_paddr() - self.inner.start_paddr())
.limit(self.nbytes())
.limit(self.nbytes());
reader
}
/// Gets a writer for the slice.
pub fn writer(&self) -> VmWriter<'_, Infallible> {
self.inner
.writer()
let mut writer = self.inner.writer();
writer
.skip(self.start_paddr() - self.inner.start_paddr())
.limit(self.nbytes())
.limit(self.nbytes());
writer
}
fn start_frame_index(&self) -> usize {

20
kernel/src/process/process_vm/init_stack/mod.rs
View File

@ -415,18 +415,16 @@ impl InitStackReader<'_> {
return_errno_with_message!(Errno::EACCES, "Page not accessible");
};
let mut arg_ptr_reader = frame.reader().skip(read_offset - page_base_addr);
let mut arg_ptr_reader = frame.reader();
arg_ptr_reader.skip(read_offset - page_base_addr);
for _ in 0..argc {
let arg = {
let arg_ptr = arg_ptr_reader.read_val::<Vaddr>()?;
let arg_offset = arg_ptr
.checked_sub(page_base_addr)
.ok_or_else(|| Error::with_message(Errno::EINVAL, "arg_ptr is corrupted"))?;
let mut arg_reader = frame
.reader()
.skip(arg_offset)
.to_fallible()
.limit(MAX_ARG_LEN);
let mut arg_reader = frame.reader().to_fallible();
arg_reader.skip(arg_offset).limit(MAX_ARG_LEN);
arg_reader.read_cstring()?
};
argv.push(arg);
@ -457,7 +455,8 @@ impl InitStackReader<'_> {
return_errno_with_message!(Errno::EACCES, "Page not accessible");
};
let mut envp_ptr_reader = frame.reader().skip(read_offset - page_base_addr);
let mut envp_ptr_reader = frame.reader();
envp_ptr_reader.skip(read_offset - page_base_addr);
for _ in 0..MAX_ENVP_NUMBER {
let env = {
let envp_ptr = envp_ptr_reader.read_val::<Vaddr>()?;
@ -469,11 +468,8 @@ impl InitStackReader<'_> {
let envp_offset = envp_ptr
.checked_sub(page_base_addr)
.ok_or_else(|| Error::with_message(Errno::EINVAL, "envp is corrupted"))?;
let mut envp_reader = frame
.reader()
.skip(envp_offset)
.to_fallible()
.limit(MAX_ENV_LEN);
let mut envp_reader = frame.reader().to_fallible();
envp_reader.skip(envp_offset).limit(MAX_ENV_LEN);
envp_reader.read_cstring()?
};
envp.push(env);

24
kernel/src/util/ring_buffer.rs
View File

@ -262,7 +262,8 @@ impl<T: Pod, R: Deref<Target = RingBuffer<T>>> Producer<T, R> {
debug_assert!(tail < rb.capacity);
let segment_offset = tail * Self::T_SIZE;
let mut writer = rb.segment.writer().skip(segment_offset);
let mut writer = rb.segment.writer();
writer.skip(segment_offset);
writer.write_val(&item).unwrap();
rb.advance_tail(tail, 1);
@ -317,14 +318,17 @@ impl<R: Deref<Target = RingBuffer<u8>>> Producer<u8, R> {
let tail = rb.tail();
let write_len = if tail + write_len > rb.capacity {
// Write into two separate parts
let mut writer = rb.segment.writer().skip(tail).limit(rb.capacity - tail);
let mut writer = rb.segment.writer();
writer.skip(tail).limit(rb.capacity - tail);
let mut len = reader.read(&mut writer)?;
let mut writer = rb.segment.writer().limit(write_len - (rb.capacity - tail));
let mut writer = rb.segment.writer();
writer.limit(write_len - (rb.capacity - tail));
len += reader.read(&mut writer)?;
len
} else {
let mut writer = rb.segment.writer().skip(tail).limit(write_len);
let mut writer = rb.segment.writer();
writer.skip(tail).limit(write_len);
reader.read(&mut writer)?
};
@ -359,7 +363,8 @@ impl<T: Pod, R: Deref<Target = RingBuffer<T>>> Consumer<T, R> {
debug_assert!(head < rb.capacity);
let segment_offset = head * Self::T_SIZE;
let mut reader = rb.segment.reader().skip(segment_offset);
let mut reader = rb.segment.reader();
reader.skip(segment_offset);
let item = reader.read_val::<T>().unwrap();
rb.advance_head(head, 1);
@ -413,14 +418,17 @@ impl<R: Deref<Target = RingBuffer<u8>>> Consumer<u8, R> {
let head = rb.head();
let read_len = if head + read_len > rb.capacity {
// Read from two separate parts
let mut reader = rb.segment.reader().skip(head).limit(rb.capacity - head);
let mut reader = rb.segment.reader();
reader.skip(head).limit(rb.capacity - head);
let mut len = writer.write(&mut reader)?;
let mut reader = rb.segment.reader().limit(read_len - (rb.capacity - head));
let mut reader = rb.segment.reader();
reader.limit(read_len - (rb.capacity - head));
len += writer.write(&mut reader)?;
len
} else {
let mut reader = rb.segment.reader().skip(head).limit(read_len);
let mut reader = rb.segment.reader();
reader.skip(head).limit(read_len);
writer.write(&mut reader)?
};

16
ostd/src/mm/dma/dma_stream.rs
View File

@ -305,23 +305,15 @@ impl<Dma: AsRef<DmaStream>> DmaStreamSlice<Dma> {
/// Returns a reader to read data from it.
pub fn reader(&self) -> Result<VmReader<Infallible>, Error> {
let stream_reader = self
.stream
.as_ref()
.reader()?
.skip(self.offset)
.limit(self.len);
let mut stream_reader = self.stream.as_ref().reader()?;
stream_reader.skip(self.offset).limit(self.len);
Ok(stream_reader)
}
/// Returns a writer to write data into it.
pub fn writer(&self) -> Result<VmWriter<Infallible>, Error> {
let stream_writer = self
.stream
.as_ref()
.writer()?
.skip(self.offset)
.limit(self.len);
let mut stream_writer = self.stream.as_ref().writer()?;
stream_writer.skip(self.offset).limit(self.len);
Ok(stream_writer)
}
}

8
ostd/src/mm/io.rs
View File

@ -629,7 +629,7 @@ impl<Fallibility> VmReader<'_, Fallibility> {
/// Limits the length of remaining data.
///
/// This method ensures the post condition of `self.remain() <= max_remain`.
pub const fn limit(mut self, max_remain: usize) -> Self {
pub const fn limit(&mut self, max_remain: usize) -> &mut Self {
if max_remain < self.remain() {
// SAFETY: the new end is less than the old end.
unsafe { self.end = self.cursor.add(max_remain) };
@ -643,7 +643,7 @@ impl<Fallibility> VmReader<'_, Fallibility> {
/// # Panics
///
/// If `nbytes` is greater than `self.remain()`, then the method panics.
pub fn skip(mut self, nbytes: usize) -> Self {
pub fn skip(&mut self, nbytes: usize) -> &mut Self {
assert!(nbytes <= self.remain());
// SAFETY: the new cursor is less than or equal to the end.
@ -893,7 +893,7 @@ impl<Fallibility> VmWriter<'_, Fallibility> {
/// Limits the length of available space.
///
/// This method ensures the post condition of `self.avail() <= max_avail`.
pub const fn limit(mut self, max_avail: usize) -> Self {
pub const fn limit(&mut self, max_avail: usize) -> &mut Self {
if max_avail < self.avail() {
// SAFETY: the new end is less than the old end.
unsafe { self.end = self.cursor.add(max_avail) };
@ -907,7 +907,7 @@ impl<Fallibility> VmWriter<'_, Fallibility> {
/// # Panics
///
/// If `nbytes` is greater than `self.avail()`, then the method panics.
pub fn skip(mut self, nbytes: usize) -> Self {
pub fn skip(&mut self, nbytes: usize) -> &mut Self {
assert!(nbytes <= self.avail());
// SAFETY: the new cursor is less than or equal to the end.