Make VmReader's several methods accept &mut self

kernel/comps/mlsdisk/src/lib.rs

@@ -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()

kernel/comps/network/src/buffer.rs

@@ -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
+        let mut reader = self.segment.reader().unwrap();
-            .reader()
+        reader.skip(self.header_len).limit(self.packet_len);
-            .unwrap()
+        reader
-            .skip(self.header_len)
-            .limit(self.packet_len)
     }
 
     pub fn buf(&self) -> VmReader<'_, Infallible> {
         self.segment
             .sync(0..self.header_len + self.packet_len)
             .unwrap();
-        self.segment
+        let mut reader = self.segment.reader().unwrap();
-            .reader()
+        reader.limit(self.header_len + self.packet_len);
-            .unwrap()
+        reader
-            .limit(self.header_len + self.packet_len)
     }
 
     pub const fn buf_len(&self) -> usize {

kernel/comps/network/src/dma_pool.rs

@@ -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> {

kernel/comps/virtio/src/device/console/device.rs

@@ -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);

kernel/libs/aster-util/src/segment_slice.rs

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

kernel/src/process/process_vm/init_stack/mod.rs

@@ -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
+                let mut arg_reader = frame.reader().to_fallible();
-                    .reader()
+                arg_reader.skip(arg_offset).limit(MAX_ARG_LEN);
-                    .skip(arg_offset)
-                    .to_fallible()
-                    .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
+                let mut envp_reader = frame.reader().to_fallible();
-                    .reader()
+                envp_reader.skip(envp_offset).limit(MAX_ENV_LEN);
-                    .skip(envp_offset)
-                    .to_fallible()
-                    .limit(MAX_ENV_LEN);
                 envp_reader.read_cstring()?
             };
             envp.push(env);

kernel/src/util/ring_buffer.rs

@@ -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)?
         };
 

ostd/src/mm/dma/dma_stream.rs

@@ -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
+        let mut stream_reader = self.stream.as_ref().reader()?;
-            .stream
+        stream_reader.skip(self.offset).limit(self.len);
-            .as_ref()
-            .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
+        let mut stream_writer = self.stream.as_ref().writer()?;
-            .stream
+        stream_writer.skip(self.offset).limit(self.len);
-            .as_ref()
-            .writer()?
-            .skip(self.offset)
-            .limit(self.len);
         Ok(stream_writer)
     }
 }

ostd/src/mm/io.rs

@@ -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.