rust: file: handle fd table teardown in file descriptor APIs
PATCH 1/1 rust: file: handle fd table teardown in file descriptor APIs
Several Rust file descriptor APIs rely on current->files being available. However, exit_files() clears it while execution may still continue on the same task.
This affects LocalFile::fget() and the FileDescriptorReservation operations that call get_unused_fd_flags(), fd_install(), and put_unused_fd(). FileDescriptorReservation cannot cross task boundaries, but remaining on the same task does not guarantee that current->files is still available when these operations are performed.
Guard the affected operations against a missing current->files. LocalFile::fget() returns EBADF and FileDescriptorReservation::get_unused_fd_flags() returns EMFILE. For the infallible fd_install() and drop paths, warn once and avoid calling the corresponding C helper when the fd table is already gone.
This prevents NULL dereferences through these safe Rust APIs after exit_files().
--- rust/kernel/fs/file.rs | 69 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 60 insertions(+), 9 deletions(-)
rust/kernel/fs/file.rs +60 -9
@@ -260,7 +260,17 @@ impl LocalFile {/// [`assume_no_fdget_pos`]: LocalFile::assume_no_fdget_pos #[inline] pub fn fget (fd:u32 ) ->Result <ARef <LocalFile >,BadFdError > { -// SAFETY: FFI call, there are no requirements on `fd`. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +return Err (BadFdError ); + } + +// SAFETY: There are no requirements on `fd`. We checked above that the +// current task still has a file descriptor table, which `fget` accesses. let ptr = ptr::NonNull ::new (unsafe { bindings::fget (fd) }).ok_or (BadFdError )?;// SAFETY: `bindings::fget` created a refcount, and we pass ownership of it to the `ARef`.
@@ -403,7 +413,18 @@ impl FileDescriptorReservation {/// Creates a new file descriptor reservation. #[inline] pub fn get_unused_fd_flags (flags:u32 ) ->Result <Self > { -// SAFETY: FFI call, there are no safety requirements on `flags`. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +return Err (EMFILE ); + } + +// SAFETY: There are no safety requirements on `flags`. We checked above +// that the current task still has a file descriptor table, which +// `get_unused_fd_flags` accesses. let fd:i32 =unsafe { bindings::get_unused_fd_flags (flags) };to_result (fd)?;
@@ -421,13 +442,30 @@ pub fn reserved_fd(&self) -> u32 {/// Commits the reservation. /// -/// The previously reserved file descriptor is bound to `file`. This method consumes the -/// [`FileDescriptorReservation`], so it will not be usable after this call. +/// The previously reserved file descriptor is bound to `file`. If the current task no longer +/// has a file descriptor table, the reservation is abandoned instead. This method consumes the +/// [`FileDescriptorReservation`] in either case. #[inline] pub fn fd_install (self, file:ARef <File >) { -// SAFETY: `self.fd` was previously returned by `get_unused_fd_flags`. We have not yet used -// the fd, so it is still valid, and `current` still refers to the same task, as this type -// cannot be moved across task boundaries. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +crate ::pr_warn_once!( +"FileDescriptorReservation::fd_install called with current->files == NULL\n" + ); + +// `put_unused_fd` also requires `current->files` to be valid, so do not run +// the reservation's destructor after the current task has lost its fd table. + core::mem::forget (self); +return ; + } + +// SAFETY: `self.fd` was previously returned by `get_unused_fd_flags` and has not yet been +// used. This type cannot be moved across task boundaries, so `current` still refers to the +// same task, and we checked above that it still has an fd table. // // Furthermore, the file pointer is guaranteed to own a refcount by its type invariants, // and we take ownership of that refcount by not running the destructor below.
@@ -446,9 +484,22 @@ pub fn fd_install(self, file: ARef<File>) {impl Drop for FileDescriptorReservation {#[inline] fn drop (&mut self) { +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +crate ::pr_warn_once!( +"FileDescriptorReservation dropped with current->files == NULL\n" + ); +return ; + } +// SAFETY: By the type invariants of this type, `self.fd` was previously returned by -// `get_unused_fd_flags`. We have not yet used the fd, so it is still valid, and `current` -// still refers to the same task, as this type cannot be moved across task boundaries. +// `get_unused_fd_flags` and has not yet been used. This type cannot be moved across task +// boundaries, so `current` still refers to the same task, and we checked above that it +// still has an fd table. unsafe { bindings::put_unused_fd (self.fd) }; } }
Signature · 1 line
2.47.3
Gary Guo
reviewerQuoted 11 lines · Georgios Androutsopoulos
Several Rust file descriptor APIs rely on
current->filesbeing available. However,exit_files()clears it while execution may still continue on the same task.This affects
LocalFile::fget()and theFileDescriptorReservationoperations that callget_unused_fd_flags(),fd_install(), andput_unused_fd().FileDescriptorReservationcannot cross task boundaries, but remaining on the same task does not guarantee thatcurrent->filesis still available when these operations are performed.
Quoted 8 lines
Guard the affected operations against a missing
current->files.LocalFile::fget()returnsEBADFandFileDescriptorReservation::get_unused_fd_flags()returnsEMFILE. For the infalliblefd_install()and drop paths, warn once and avoid calling the corresponding C helper when the fd table is already gone.This prevents NULL dereferences through these safe Rust APIs after
exit_files().
I suppose we could add these checks to C side instead, although perhaps one may say "its bad caller code and not worth checking"?
So having these checks on Rust side is okay to me.
Quoted 16 lines
Fixes 851849824bb5 ("rust: file: add Rust abstraction for `struct file`")Fixes 5da9857b127e ("rust: file: add `FileDescriptorReservation`")Signed-off-by Georgios Androutsopoulos <[email protected]>--- rust/kernel/fs/file.rs | 69 ++++++++++++++++++++++++++++++++++++------ 1 file changed, 60 insertions(+), 9 deletions(-)rust/kernel/fs/file.rs +0
-0@@ -260,7 +260,17 @@ impl LocalFile {/// [`assume_no_fdget_pos`]: LocalFile::assume_no_fdget_pos #[inline]
rust/kernel/fs/file.rs impl LocalFile { · line 270
Quoted 10 lines
rust/kernel/fs/file.rs +8
-1pub fn fget (fd:u32 ) ->Result <ARef <LocalFile >,BadFdError > { -// SAFETY: FFI call, there are no requirements on `fd`. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +return Err (BadFdError ); + }
I think we want to add unlikely() on them (which is being added by
https://lore.kernel.org/rust-for-linux/[email protected]/).
Quoted 39 lines
rust/kernel/fs/file.rs +18
-5+ +// SAFETY: There are no requirements on `fd`. We checked above that the +// current task still has a file descriptor table, which `fget` accesses. let ptr = ptr::NonNull ::new (unsafe { bindings::fget (fd) }).ok_or (BadFdError )?;// SAFETY: `bindings::fget` created a refcount, and we pass ownership of it to the `ARef`. @@ -403,7 +413,18 @@ impl FileDescriptorReservation {/// Creates a new file descriptor reservation. #[inline] pub fn get_unused_fd_flags (flags:u32 ) ->Result <Self > { -// SAFETY: FFI call, there are no safety requirements on `flags`. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +return Err (EMFILE ); + } + +// SAFETY: There are no safety requirements on `flags`. We checked above +// that the current task still has a file descriptor table, which +// `get_unused_fd_flags` accesses. let fd:i32 =unsafe { bindings::get_unused_fd_flags (flags) };to_result (fd)?;@@ -421,13 +442,30 @@ pub fn reserved_fd(&self) -> u32 {/// Commits the reservation. /// -/// The previously reserved file descriptor is bound to `file`. This method consumes the -/// [`FileDescriptorReservation`], so it will not be usable after this call. +/// The previously reserved file descriptor is bound to `file`. If the current task no longer +/// has a file descriptor table, the reservation is abandoned instead. This method consumes the +/// [`FileDescriptorReservation`] in either case. #[inline] pub fn fd_install (self, file:ARef <File >) { -// SAFETY: `self.fd` was previously returned by `get_unused_fd_flags`. We have not yet used -// the fd, so it is still valid, and `current` still refers to the same task, as this type
rust/kernel/fs/file.rs pub fn reserved_fd(&self) -> u32 { · line 458
Quoted 10 lines
rust/kernel/fs/file.rs +9
-1-// cannot be moved across task boundaries. +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +crate ::pr_warn_once!( +"FileDescriptorReservation::fd_install called with current->files == NULL\n" + );
I wonder if we should upgrade this to WARN_ONCE. As code being executed when exiting are cleanup code, for this code path to be hit, it would mean that some code is installing FD descriptor while being dropped -- which is likely a bug.
Putting a "BTW, some Rust code is installing a FD when process is exiting" in dmesg is not going to be useful to understand what's going on. We'd want a full backtrace.
On the other hand, dropping a FileDescriptorReservation is a more realistic, so we perhaps might even want to declare it being okay (see below).
Quoted 16 lines
rust/kernel/fs/file.rs +10
-0+ +// `put_unused_fd` also requires `current->files` to be valid, so do not run +// the reservation's destructor after the current task has lost its fd table. + core::mem::forget (self); +return ; + } + +// SAFETY: `self.fd` was previously returned by `get_unused_fd_flags` and has not yet been +// used. This type cannot be moved across task boundaries, so `current` still refers to the +// same task, and we checked above that it still has an fd table. // // Furthermore, the file pointer is guaranteed to own a refcount by its type invariants, // and we take ownership of that refcount by not running the destructor below. @@ -446,9 +484,22 @@ pub fn fd_install(self, file: ARef<File>) {impl Drop for FileDescriptorReservation {#[inline]
rust/kernel/fs/file.rs pub fn fd_install(self, file: ARef<File>) { · line 495
Quoted 10 lines
rust/kernel/fs/file.rs +9
-0fn drop (&mut self) { +let current =crate ::current!(); + +// SAFETY: `current` points to the currently executing task, so it is +// valid to read its `files` pointer. The pointer may be null during +// task teardown. +if unsafe { (*current.as_ptr ()).files.is_null () } { +crate ::pr_warn_once!( +"FileDescriptorReservation dropped with current->files == NULL\n" + );
I think we can remove this warning. Skipping put_unused_fd isn't actually leaking anything as the files_struct is cleaned up.
Best,
Gary
Quoted 12 lines
rust/kernel/fs/file.rs +6
-2+return ; + } +// SAFETY: By the type invariants of this type, `self.fd` was previously returned by -// `get_unused_fd_flags`. We have not yet used the fd, so it is still valid, and `current` -// still refers to the same task, as this type cannot be moved across task boundaries. +// `get_unused_fd_flags` and has not yet been used. This type cannot be moved across task +// boundaries, so `current` still refers to the same task, and we checked above that it +// still has an fd table. unsafe { bindings::put_unused_fd (self.fd) }; } }
Quoted 2 lines · Gary Guo
I think we want to add
unlikely()on them (which is being added by
https://lore.kernel.org/rust-for-linux/[email protected]/).
I checked current linux-next and rust-next, but this does not seem to have landed yet. Should I leave these as regular checks for now and add a TODO: to use unlikely() once it is available?
Quoted 7 lines
I wonder if we should upgrade this to
WARN_ONCE. As code being executed when exiting are cleanup code, for this code path to be hit, it would mean that some code is installing FD descriptor while being dropped -- which is likely a bug.Putting a "BTW, some Rust code is installing a FD when process is exiting" in dmesg is not going to be useful to understand what's going on. We'd want a full backtrace.
WARN_ONCE does not seem to be available on the Rust side yet either. warn_on!() is available on the current base and would give us the backtrace. Would you prefer using that here for now?
Quoted 2 lines
I think we can remove this warning. Skipping
put_unused_fdisn't actually leaking anything as thefiles_structis cleaned up.
Agreed. I'll treat dropping the reservation after fd table teardown as normal cleanup, skip put_unused_fd(), and document that this can happen.
Best,
George
Gary Guo
reviewerQuoted 7 lines · Georgios Androutsopoulos
Quoted 2 lines · Gary Guo
I think we want to add
unlikely()on them (which is being added by
https://lore.kernel.org/rust-for-linux/[email protected]/).I checked current
linux-nextandrust-next, but this does not seem to have landed yet. Should I leave these as regular checks for now and add aTODO:to useunlikely()once it is available?
Regular checks are fine, no need for TODO either. Just bring this up to nudge Miguel to pick the patch :)
Quoted 5 lines
Quoted 5 lines
I wonder if we should upgrade this to
WARN_ONCE. As code being executed when exiting are cleanup code, for this code path to be hit, it would mean that some code is installing FD descriptor while being dropped -- which is likely a bug.
Quoted 7 lines
Quoted 3 lines
Putting a "BTW, some Rust code is installing a FD when process is exiting" in dmesg is not going to be useful to understand what's going on. We'd want a full backtrace.
WARN_ONCEdoes not seem to be available on the Rust side yet either.warn_on!()is available on the current base and would give us the backtrace. Would you prefer using that here for now?
I would prefer warn_on!().
Best,
Gary
Quoted 9 lines
Quoted 3 lines
I think we can remove this warning. Skipping
put_unused_fdisn't actually leaking anything as thefiles_structis cleaned up.Agreed. I'll treat dropping the reservation after fd table teardown as normal cleanup, skip
put_unused_fd(), and document that this can happen.Best,
George
Miguel Ojeda
maintainerQuoted 3 lines · On Tue, 22 Sep 2026 20:55:16 +0100 Gary Guo <[email protected]> wrote:
Regular checks are fine, no need for TODO either. Just bring this up to nudge Miguel to pick the patch :)
v3 up and ready to be picked:
https://lore.kernel.org/rust-for-linux/[email protected]/
:)
Cheers,
Miguel
Christian Brauner
maintainerQuoted 18 lines · Gary Guo
Quoted 17 lines · Georgios Androutsopoulos
Several Rust file descriptor APIs rely on
current->filesbeing available. However,exit_files()clears it while execution may still continue on the same task.This affects
LocalFile::fget()and theFileDescriptorReservationoperations that callget_unused_fd_flags(),fd_install(), andput_unused_fd().FileDescriptorReservationcannot cross task boundaries, but remaining on the same task does not guarantee thatcurrent->filesis still available when these operations are performed.Guard the affected operations against a missing
current->files.LocalFile::fget()returnsEBADFandFileDescriptorReservation::get_unused_fd_flags()returnsEMFILE. For the infalliblefd_install()and drop paths, warn once and avoid calling the corresponding C helper when the fd table is already gone.
Quoted 5 lines
Quoted 2 lines
This prevents NULL dereferences through these safe Rust APIs after
exit_files().I suppose we could add these checks to C side instead, although perhaps one may say "its bad caller code and not worth checking"?
It is a bug to call fd_install() or anything like that post exit_files(). Whatever code is doing that needs to get fixed.
Similarly it is a bug to call fd_install() on kernel thread which do not have files at all. So whoever you're doing this for is breaching core api assumptions big time and I would like a detailed explanation otherwise I see no reason to merge this.