Skip to contentSkip to conversation

rust: fs: add a new type for file::Offset

PATCH In review Danilo Krummrich 3 participants 8 messages Nov 5, 2025

Subsystems (4)
lore
Share & tools
lore

Danilo Krummrich

author maintainer
#0 lore raw

PATCH 1/3 rust: fs: add a new type for file::Offset

Replace the existing file::Offset type alias with a new type.

Compared to a type alias, a new type allows for more fine grained control over the operations that (semantically) make sense for a specific type.

---
 rust/kernel/debugfs/file_ops.rs |   4 +-
 rust/kernel/fs/file.rs          | 159 +++++++++++++++++++++++++++++++-
 rust/kernel/uaccess.rs          |   4 +-
 3 files changed, 159 insertions(+), 8 deletions(-)
rust/kernel/debugfs/file_ops.rs +2 -2
index 6c8928902a0b..8e45c15d3c90 100644
@@ -261,7 +261,7 @@ extern "C" fn blob_read<T: BinaryWriter>(
     // SAFETY:
     // - `ppos` is a valid `file::Offset` pointer.
     // - We have exclusive access to `ppos`.
-    let pos: &mut file::Offset = unsafe { &mut *ppos };
+    let pos = unsafe { file::Offset::from_raw(ppos) };
 
     let mut writer = UserSlice::new(UserPtr::from_ptr(buf.cast()), count).writer();
 
@@ -316,7 +316,7 @@ extern "C" fn blob_write<T: BinaryReader>(
     // SAFETY:
     // - `ppos` is a valid `file::Offset` pointer.
     // - We have exclusive access to `ppos`.
-    let pos: &mut file::Offset = unsafe { &mut *ppos };
+    let pos = unsafe { file::Offset::from_raw(ppos) };
 
     let mut reader = UserSlice::new(UserPtr::from_ptr(buf.cast_mut().cast()), count).reader();
 
rust/kernel/fs/file.rs +155 -4

167 lines not on this page · raw message

rust/kernel/uaccess.rs +2 -2
index f989539a31b4..7bfc212e78d1 100644
@@ -325,7 +325,7 @@ pub fn read_slice_file(&mut self, out: &mut [u8], offset: &mut file::Offset) ->
         let read = self.read_slice_partial(out, offset_index)?;
 
         // OVERFLOW: `offset + read <= data.len() <= isize::MAX <= Offset::MAX`
-        *offset += read as i64;
+        *offset += read as isize;
 
         Ok(read)
     }
@@ -518,7 +518,7 @@ pub fn write_slice_file(&mut self, data: &[u8], offset: &mut file::Offset) -> Re
         let written = self.write_slice_partial(data, offset_index)?;
 
         // OVERFLOW: `offset + written <= data.len() <= isize::MAX <= Offset::MAX`
-        *offset += written as i64;
+        *offset += written as isize;
 
         Ok(written)
     }

base-commit: f656279afde16afee3ac163b90584ddceacb4e61

Signature · 1 line
2.51.2
author maintainer
#1 lore raw

PATCH 2/3 rust fs: kiocb: take advantage from file::Offset

Make use of file::Offset, now that we have a dedicated type for it.

---
 rust/kernel/fs/kiocb.rs          |  9 ++++++---
 samples/rust/rust_misc_device.rs | 10 +++++++---
 2 files changed, 13 insertions(+), 6 deletions(-)
rust/kernel/fs/kiocb.rs +6 -3
index 84c936cd69b0..3159b9ac2bf6 100644
@@ -8,7 +8,10 @@
 
 use core::marker::PhantomData;
 use core::ptr::NonNull;
-use kernel::types::ForeignOwnable;
+use kernel::{
+    fs::file,
+    types::ForeignOwnable, //
+};
 
 /// Wrapper for the kernel's `struct kiocb`.
 ///
@@ -61,8 +64,8 @@ pub fn ki_pos(&self) -> i64 {
     }
 
     /// Gets a mutable reference to the `ki_pos` field.
-    pub fn ki_pos_mut(&mut self) -> &mut i64 {
+    pub fn ki_pos_mut(&mut self) -> &mut file::Offset {
         // SAFETY: We have exclusive access to the kiocb, so we can write to `ki_pos`.
-        unsafe { &mut (*self.as_raw()).ki_pos }
+        unsafe { file::Offset::from_raw(&raw mut (*self.as_raw()).ki_pos) }
     }
 }
samples/rust/rust_misc_device.rs +7 -3
index d69bc33dbd99..6a9f59ccf71d 100644
@@ -100,7 +100,11 @@
 use kernel::{
     c_str,
     device::Device,
-    fs::{File, Kiocb},
+    fs::{
+        file,
+        File,
+        Kiocb, //
+    },
     ioctl::{_IO, _IOC_SIZE, _IOR, _IOW},
     iov::{IovIterDest, IovIterSource},
     miscdevice::{MiscDevice, MiscDeviceOptions, MiscDeviceRegistration},
@@ -183,7 +187,7 @@ fn read_iter(mut kiocb: Kiocb<'_, Self::Ptr>, iov: &mut IovIterDest<'_>) -> Resu
 
         let inner = me.inner.lock();
         // Read the buffer contents, taking the file position into account.
-        let read = iov.simple_read_from_buffer(kiocb.ki_pos_mut(), &inner.buffer)?;
+        let read = iov.simple_read_from_buffer(&mut kiocb.ki_pos_mut().0, &inner.buffer)?;
 
         Ok(read)
     }
@@ -199,7 +203,7 @@ fn write_iter(mut kiocb: Kiocb<'_, Self::Ptr>, iov: &mut IovIterSource<'_>) -> R
         let len = iov.copy_from_iter_vec(&mut inner.buffer, GFP_KERNEL)?;
 
         // Set position to zero so that future `read` calls will see the new contents.
-        *kiocb.ki_pos_mut() = 0;
+        *kiocb.ki_pos_mut() = file::Offset::from(0);
 
         Ok(len)
     }
Signature · 1 line
2.51.2
author maintainer
#3 lore raw

PATCH 3/3 rust: iov: take advantage from file::Offset

In reply to Danilo Krummrich

Make use of file::Offset, now that we have a dedicated type for it.

---
 rust/kernel/iov.rs               | 13 +++++++++----
 samples/rust/rust_misc_device.rs |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)
rust/kernel/iov.rs +9 -4
index 43bae8923c46..a3b1233441b6 100644
@@ -10,6 +10,7 @@
 use crate::{
     alloc::{Allocator, Flags},
     bindings,
+    fs::file,
     prelude::*,
     types::Opaque,
 };
@@ -292,8 +293,12 @@ pub fn copy_to_iter(&mut self, input: &[u8]) -> usize {
     /// that the file will appear to contain `contents` even if takes multiple reads to read the
     /// entire file.
     #[inline]
-    pub fn simple_read_from_buffer(&mut self, ppos: &mut i64, contents: &[u8]) -> Result<usize> {
-        if *ppos < 0 {
+    pub fn simple_read_from_buffer(
+        &mut self,
+        ppos: &mut file::Offset,
+        contents: &[u8],
+    ) -> Result<usize> {
+        if ppos.is_negative() {
             return Err(EINVAL);
         }
         let Ok(pos) = usize::try_from(*ppos) else {
@@ -306,8 +311,8 @@ pub fn simple_read_from_buffer(&mut self, ppos: &mut i64, contents: &[u8]) -> Re
         // BOUNDS: We just checked that `pos < contents.len()` above.
         let num_written = self.copy_to_iter(&contents[pos..]);
 
-        // OVERFLOW: `pos+num_written <= contents.len() <= isize::MAX <= i64::MAX`.
-        *ppos = (pos + num_written) as i64;
+        // OVERFLOW: `pos+num_written <= contents.len() <= isize::MAX <= file::Offset::MAX`.
+        *ppos += num_written as isize;
 
         Ok(num_written)
     }
samples/rust/rust_misc_device.rs +1 -1
index 6a9f59ccf71d..edbcc761b4a2 100644
@@ -187,7 +187,7 @@ fn read_iter(mut kiocb: Kiocb<'_, Self::Ptr>, iov: &mut IovIterDest<'_>) -> Resu
 
         let inner = me.inner.lock();
         // Read the buffer contents, taking the file position into account.
-        let read = iov.simple_read_from_buffer(&mut kiocb.ki_pos_mut().0, &inner.buffer)?;
+        let read = iov.simple_read_from_buffer(kiocb.ki_pos_mut(), &inner.buffer)?;
 
         Ok(read)
     }
Signature · 1 line
2.51.2
#5 lore raw
In reply to Danilo Krummrich
Quoted 14 lines · Danilo Krummrich

Replace the existing file::Offset type alias with a new type.

Compared to a type alias, a new type allows for more fine grained control over the operations that (semantically) make sense for a specific type.

Quoted 1 line

---

What's the base for this?
If it's stuff that belongs to fs/ I'd prefer if it always uses a stable -rc* version as base where possible.

author maintainer
#6 lore raw
Quoted 17 lines · Christian Brauner
Quoted 14 lines · Danilo Krummrich

Replace the existing file::Offset type alias with a new type.

Compared to a type alias, a new type allows for more fine grained control over the operations that (semantically) make sense for a specific type.

Quoted 1 line

---

Quoted 3 lines

What's the base for this?
If it's stuff that belongs to fs/ I'd prefer if it always uses a stable -rc* version as base where possible.

Please see [1]; the base is [2] from the driver-core tree.

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://git.kernel.org/pub/scm/linux/kernel/git/driver-core/driver-core.git/tree/?id=1bf5b90cd2f984e5d6ff6fd30d5d85f9f579b6f0

author maintainer
#7 lore raw
Quoted 18 lines · Danilo Krummrich
Quoted 17 lines · Christian Brauner
Quoted 15 lines · Danilo Krummrich

Replace the existing file::Offset type alias with a new type.

Compared to a type alias, a new type allows for more fine grained control over the operations that (semantically) make sense for a specific type.

---

Quoted 5 lines
Quoted 3 lines

What's the base for this?
If it's stuff that belongs to fs/ I'd prefer if it always uses a stable -rc* version as base where possible.

Please see [1]; the base is [2] from the driver-core tree.

For more context, when I picked up the debugfs patch series from [1] I picked up the patch that only introduced the file::Offset type alias for loff_t as a dependency and sent this series as a follow-up.

Hence, I can either take this one through the driver-core tree as well, or, if you prefer we can also wait for a cycle, so you can pick it up through the FS tree.

Quoted 2 lines

[1] https://lore.kernel.org/lkml/[email protected]/
[2] https://git.kernel.org/pub/scm/linux/kernel/git/driver-core/driver-core.git/tree/?id=1bf5b90cd2f984e5d6ff6fd30d5d85f9f579b6f0