mirror of https://github.com/torvalds/linux.git
69 lines
2.3 KiB
Rust
69 lines
2.3 KiB
Rust
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
// Copyright (C) 2024 Google LLC.
|
|
|
|
//! Kernel IO callbacks.
|
|
//!
|
|
//! C headers: [`include/linux/fs.h`](srctree/include/linux/fs.h)
|
|
|
|
use core::marker::PhantomData;
|
|
use core::ptr::NonNull;
|
|
use kernel::types::ForeignOwnable;
|
|
|
|
/// Wrapper for the kernel's `struct kiocb`.
|
|
///
|
|
/// Currently this abstractions is incomplete and is essentially just a tuple containing a
|
|
/// reference to a file and a file position.
|
|
///
|
|
/// The type `T` represents the filesystem or driver specific data associated with the file.
|
|
///
|
|
/// # Invariants
|
|
///
|
|
/// `inner` points at a valid `struct kiocb` whose file has the type `T` as its private data.
|
|
pub struct Kiocb<'a, T> {
|
|
inner: NonNull<bindings::kiocb>,
|
|
_phantom: PhantomData<&'a T>,
|
|
}
|
|
|
|
impl<'a, T: ForeignOwnable> Kiocb<'a, T> {
|
|
/// Create a `Kiocb` from a raw pointer.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// The pointer must reference a valid `struct kiocb` for the duration of `'a`. The private
|
|
/// data of the file must be `T`.
|
|
pub unsafe fn from_raw(kiocb: *mut bindings::kiocb) -> Self {
|
|
Self {
|
|
// SAFETY: If a pointer is valid it is not null.
|
|
inner: unsafe { NonNull::new_unchecked(kiocb) },
|
|
_phantom: PhantomData,
|
|
}
|
|
}
|
|
|
|
/// Access the underlying `struct kiocb` directly.
|
|
pub fn as_raw(&self) -> *mut bindings::kiocb {
|
|
self.inner.as_ptr()
|
|
}
|
|
|
|
/// Get the filesystem or driver specific data associated with the file.
|
|
pub fn file(&self) -> <T as ForeignOwnable>::Borrowed<'a> {
|
|
// SAFETY: We have shared access to this kiocb and hence the underlying file, so we can
|
|
// read the file's private data.
|
|
let private = unsafe { (*(*self.as_raw()).ki_filp).private_data };
|
|
// SAFETY: The kiocb has shared access to the private data.
|
|
unsafe { <T as ForeignOwnable>::borrow(private) }
|
|
}
|
|
|
|
/// Gets the current value of `ki_pos`.
|
|
pub fn ki_pos(&self) -> i64 {
|
|
// SAFETY: We have shared access to the kiocb, so we can read its `ki_pos` field.
|
|
unsafe { (*self.as_raw()).ki_pos }
|
|
}
|
|
|
|
/// Gets a mutable reference to the `ki_pos` field.
|
|
pub fn ki_pos_mut(&mut self) -> &mut i64 {
|
|
// SAFETY: We have exclusive access to the kiocb, so we can write to `ki_pos`.
|
|
unsafe { &mut (*self.as_raw()).ki_pos }
|
|
}
|
|
}
|