Implement seek on FileOperations

Author: alex

build.rs

@@ -29,6 +29,7 @@ const INCLUDED_FUNCTIONS: &[&str] = &[
 const INCLUDED_VARS: &[&str] = &[
     "EINVAL",
     "ENOMEM",
+    "ESPIPE",
     "EFAULT",
     "__this_module",
     "FS_REQUIRES_DEV",
@@ -40,6 +41,9 @@ const INCLUDED_VARS: &[&str] = &[
     "KERN_INFO",
     "VERIFY_WRITE",
     "LINUX_VERSION_CODE",
+    "SEEK_SET",
+    "SEEK_CUR",
+    "SEEK_END",
 ];
 const OPAQUE_TYPES: &[&str] = &[
     // These need to be opaque because they're both packed and aligned, which rustc

src/chrdev.rs

@@ -96,6 +96,27 @@ impl Drop for Registration {
     }
 }
 
+pub struct File {
+    ptr: *const bindings::file,
+}
+
+impl File {
+    unsafe fn from_ptr(ptr: *const bindings::file) -> File {
+        File { ptr }
+    }
+
+    pub fn pos(&self) -> u64 {
+        unsafe { (*self.ptr).f_pos as u64 }
+    }
+}
+
+// Matches std::io::SeekFrom in the Rust stdlib
+pub enum SeekFrom {
+    Start(u64),
+    End(i64),
+    Current(i64),
+}
+
 pub struct FileOperationsVtable(bindings::file_operations);
 
 unsafe extern "C" fn open_callback<T: FileOperations>(
@@ -141,12 +162,34 @@ unsafe extern "C" fn release_callback<T: FileOperations>(
     0
 }
 
+unsafe extern "C" fn llseek_callback<T: FileOperations>(
+    file: *mut bindings::file,
+    offset: bindings::loff_t,
+    whence: c_types::c_int,
+) -> bindings::loff_t {
+    let off = match whence as u32 {
+        bindings::SEEK_SET => match offset.try_into() {
+            Ok(v) => SeekFrom::Start(v),
+            Err(_) => return Error::EINVAL.to_kernel_errno().into(),
+        },
+        bindings::SEEK_CUR => SeekFrom::Current(offset),
+        bindings::SEEK_END => SeekFrom::End(offset),
+        _ => return Error::EINVAL.to_kernel_errno().into(),
+    };
+    let f = &*((*file).private_data as *const T);
+    match f.seek(&File::from_ptr(file), off) {
+        Ok(off) => off as bindings::loff_t,
+        Err(e) => e.to_kernel_errno().into(),
+    }
+}
+
 impl FileOperationsVtable {
     pub const fn new<T: FileOperations>() -> FileOperationsVtable {
         FileOperationsVtable(bindings::file_operations {
             open: Some(open_callback::<T>),
             read: Some(read_callback::<T>),
             release: Some(release_callback::<T>),
+            llseek: Some(llseek_callback::<T>),
 
             check_flags: None,
             #[cfg(not(kernel_4_20_0_or_greater))]
@@ -167,7 +210,6 @@ impl FileOperationsVtable {
             iterate_shared: None,
             #[cfg(kernel_5_1_0_or_greater)]
             iopoll: None,
-            llseek: None,
             lock: None,
             mmap: None,
             #[cfg(kernel_4_15_0_or_greater)]
@@ -194,5 +236,10 @@ pub trait FileOperations: Sync + Sized {
     const VTABLE: FileOperationsVtable;
 
     fn open() -> KernelResult<Self>;
-    fn read(&self, buf: &mut UserSlicePtrWriter) -> KernelResult<()>;
+    fn read(&self, _buf: &mut UserSlicePtrWriter) -> KernelResult<()> {
+        Err(Error::EINVAL)
+    }
+    fn seek(&self, _file: &File, _offset: SeekFrom) -> KernelResult<u64> {
+        Err(Error::ESPIPE)
+    }
 }

src/error.rs

@@ -9,6 +9,7 @@ impl Error {
     pub const EINVAL: Self = Error(-(bindings::EINVAL as i32));
     pub const ENOMEM: Self = Error(-(bindings::ENOMEM as i32));
     pub const EFAULT: Self = Error(-(bindings::EFAULT as i32));
+    pub const ESPIPE: Self = Error(-(bindings::ESPIPE as i32));
 
     pub fn from_kernel_errno(errno: c_types::c_int) -> Error {
         Error(errno)

tests/chrdev/src/lib.rs

@@ -24,15 +24,35 @@ impl linux_kernel_module::chrdev::FileOperations for CycleFile {
     }
 }
 
+struct SeekFile;
+
+impl linux_kernel_module::chrdev::FileOperations for SeekFile {
+    const VTABLE: linux_kernel_module::chrdev::FileOperationsVtable =
+        linux_kernel_module::chrdev::FileOperationsVtable::new::<Self>();
+
+    fn open() -> linux_kernel_module::KernelResult<Self> {
+        return Ok(SeekFile);
+    }
+
+    fn seek(
+        &self,
+        _file: &linux_kernel_module::chrdev::File,
+        _offset: linux_kernel_module::chrdev::SeekFrom,
+    ) -> linux_kernel_module::KernelResult<u64> {
+        return Ok(1234);
+    }
+}
+
 struct ChrdevTestModule {
     _chrdev_registration: linux_kernel_module::chrdev::Registration,
 }
 
 impl linux_kernel_module::KernelModule for ChrdevTestModule {
     fn init() -> linux_kernel_module::KernelResult<Self> {
         let chrdev_registration =
-            linux_kernel_module::chrdev::builder(cstr!("chrdev-tests"), 0..1)?
+            linux_kernel_module::chrdev::builder(cstr!("chrdev-tests"), 0..2)?
                 .register_device::<CycleFile>()
+                .register_device::<SeekFile>()
                 .build()?;
         Ok(ChrdevTestModule {
             _chrdev_registration: chrdev_registration,

tests/chrdev/tests/tests.rs

@@ -54,6 +54,7 @@ fn mknod(path: &PathBuf, major: libc::dev_t, minor: libc::dev_t) -> UnlinkOnDrop
 }
 
 const READ_FILE_MINOR: libc::dev_t = 0;
+const SEEK_FILE_MINOR: libc::dev_t = 1;
 
 #[test]
 fn test_mknod() {
@@ -77,6 +78,22 @@ fn test_read() {
     });
 }
 
+#[test]
+fn test_read_unimplemented() {
+    with_kernel_module(|| {
+        let device_number = get_device_major_number();
+        let p = temporary_file_path();
+        let _u = mknod(&p, device_number, SEEK_FILE_MINOR);
+
+        let mut f = fs::File::open(&p).unwrap();
+        let mut data = [0; 12];
+        assert_eq!(
+            f.read_exact(&mut data).unwrap_err().raw_os_error().unwrap(),
+            libc::EINVAL
+        );
+    })
+}
+
 #[test]
 fn test_lseek_unimplemented() {
     with_kernel_module(|| {
@@ -108,3 +125,25 @@ fn test_lseek_unimplemented() {
         );
     });
 }
+
+#[test]
+fn test_lseek() {
+    with_kernel_module(|| {
+        let device_number = get_device_major_number();
+        let p = temporary_file_path();
+        let _u = mknod(&p, device_number, SEEK_FILE_MINOR);
+
+        let mut f = fs::File::open(&p).unwrap();
+        assert_eq!(f.seek(SeekFrom::Start(12)).unwrap(), 1234);
+        assert_eq!(f.seek(SeekFrom::End(-12)).unwrap(), 1234);
+        assert_eq!(f.seek(SeekFrom::Current(12)).unwrap(), 1234);
+
+        assert_eq!(
+            f.seek(SeekFrom::Start(u64::max_value()))
+                .unwrap_err()
+                .raw_os_error()
+                .unwrap(),
+            libc::EINVAL
+        );
+    });
+}