Implement FileBufRead for SequentialFileReader

fs/src/buffered_reader.rs

@@ -401,10 +401,12 @@ pub fn large_file_buf_reader(
         assert!(agave_io_uring::io_uring_supported());
         use crate::io_uring::sequential_file_reader::SequentialFileReaderBuilder;
 
-        SequentialFileReaderBuilder::new()
+        let mut reader = SequentialFileReaderBuilder::new()
             .shared_sqpoll(io_setup.shared_sqpoll_fd())
             .use_registered_buffers(io_setup.use_registered_io_uring_buffers)
-            .build(path, buf_size)
+            .build(buf_size)?;
+        reader.set_path(path)?;
+        Ok(reader)
     }
     #[cfg(not(target_os = "linux"))]
     {

fs/src/io_setup.rs

@@ -82,8 +82,9 @@ mod tests {
             .build(1 << 20, move |file_info| {
                 let mut reader = SequentialFileReaderBuilder::new()
                     .shared_sqpoll(io_setup.shared_sqpoll_fd())
-                    .build(file_info.path, 1 << 20)
+                    .build(1 << 20)
                     .unwrap();
+                reader.set_path(file_info.path).unwrap();
                 reader
                     .read_to_end(read_bytes_ref.write().unwrap().as_mut())
                     .unwrap();

fs/src/io_uring/memory.rs

@@ -222,6 +222,10 @@ impl IoBufferChunk {
         self.size
     }
 
+    pub fn as_ptr(&self) -> *const u8 {
+        self.ptr
+    }
+
     /// Safety: while just returning without dereferencing a pointer is safe, this is marked unsafe
     /// so that the callers are encouraged to reason about the lifetime of the buffer.
     pub unsafe fn as_mut_ptr(&self) -> *mut u8 {
@@ -233,16 +237,6 @@ impl IoBufferChunk {
         self.registered_io_buf_index
     }
 
-    /// Return a clone of `self` reduced to specified `size`
-    pub fn into_shrinked(self, size: IoSize) -> Self {
-        assert!(size <= self.size);
-        Self {
-            ptr: self.ptr,
-            size,
-            registered_io_buf_index: self.registered_io_buf_index,
-        }
-    }
-
     /// Register provided buffer as fixed buffer in `io_uring`.
     pub unsafe fn register<S, E: RingOp<S>>(
         buffer: &mut [u8],
@@ -258,9 +252,3 @@ impl IoBufferChunk {
         unsafe { ring.register_buffers(&iovecs) }
     }
 }
-
-impl AsRef<[u8]> for IoBufferChunk {
-    fn as_ref(&self) -> &[u8] {
-        unsafe { slice::from_raw_parts(self.ptr, self.size as usize) }
-    }
-}