Struct kernel::sync::spin::mutex::Mutex

pub struct Mutex<T: ?Sized> {
    lock: Lock,
    owner_cpu: AtomicI64,
    data: UnsafeCell<T>,
}

Fields

lock: Lock

owner_cpu: AtomicI64

data: UnsafeCell<T>

Implementations

impl<T> Mutex<T>

pub const fn new(data: T) -> Self

impl<T: ?Sized> Mutex<T>

pub fn lock(&self) -> MutexGuard<'_, T>

pub fn try_lock(&self) -> Option<MutexGuard<'_, T>>

pub fn run_with<'a, R>(&'a self, f: impl FnOnce(&'a T) -> R) -> R

A special method to allow accessing the variable inside the lock after locking it.

The difference between this and using Deref is that the lifetime of the returned reference is tied to main value of the lock.

pub fn run_with_mut<'a, R>(&'a self, f: impl FnOnce(&'a mut T) -> R) -> R

A special method to allow accessing the variable inside the lock after locking it.

The difference between this and using DerefMut is that the lifetime of the returned reference is tied to main value of the lock.

pub fn get_mut(&mut self) -> &mut T

We know statically that no one else is accessing the lock, so we can just return a reference to the data without acquiring the lock.

Trait Implementations

impl ClockDevice for Mutex<Hpet>

fn name(&self) -> &'static str

Returns the name of the device

fn get_time(&self) -> ClockTime

Returns the current time of the device with no relation to anything The system will use consecutive calls to determine the time

fn granularity(&self) -> u64

Returns the granularity of the device in nanoseconds, i.e. the smallest time unit it can measure Must be at least 1

fn require_calibration(&self) -> bool

Returns true if the device needs to be calibration i.e. it doesn’t count time correctly

fn rating(&self) -> u64

Returns the rating of the device, i.e. how good it is The higher the better

impl<T> Debug for Mutex<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FileSystem for Mutex<FatFilesystem>

fn open_root(&self) -> Result<DirectoryNode, FileSystemError>

Open the root directory of the filesystem

fn read_dir( &self, inode: &DirectoryNode, handler: &mut dyn FnMut(Node) -> DirTreverse ) -> Result<(), FileSystemError>

Read the directory entries in the inode, and call the handler for each entry The handler should return DirTreverse::Stop to stop the traversal

fn treverse_dir( &self, inode: &DirectoryNode, matcher: &str ) -> Result<Node, FileSystemError>

Traverse the directory in the inode and return the entry with the name matcher Most of the time, no need to implement this, as it is already implemented in the default using FileSystem::read_dir

fn create_node( &self, parent: &DirectoryNode, name: &str, attributes: FileAttributes ) -> Result<Node, FileSystemError>

Create a new entry in the parent directory with the name and attributes This could be a file or a directory, the attributes should specify the type

fn read_file( &self, inode: &FileNode, position: u64, buf: &mut [u8], access_helper: &mut AccessHelper ) -> Result<u64, FileSystemError>

Read the file in the inode at the position and put the data in buf The access_helper is used to store some extra metadata to help the filesystem manage the caches or any extra data it needs.

fn write_file( &self, inode: &mut FileNode, position: u64, buf: &[u8], access_helper: &mut AccessHelper ) -> Result<u64, FileSystemError>

Write the file in the inode at the position with the data in buf The access_helper is used to store some extra metadata to help the filesystem manage the caches or any extra data it needs.

fn flush_file( &self, inode: &mut FileNode, access_helper: &mut AccessHelper ) -> Result<(), FileSystemError>

Tells the filesystem to flush the content of this file to disk or to the backing store if it needs to

fn close_file( &self, inode: &FileNode, access_helper: AccessHelper ) -> Result<(), FileSystemError>

Close the file in the inode, this is called when the file is dropped The access_helper is used to store some extra metadata to help the filesystem manage the caches or any extra data it needs.

fn set_file_size( &self, inode: &mut FileNode, size: u64 ) -> Result<(), FileSystemError>

Set the size of the file in the inode to size, this is used to truncate the file or to extend it

fn unmount(self: Arc<Self>)

Unmount the filesystem, this is called before the filesystem is dropped The reason we use this is that we can’t force Drop to be implemented for Arc<dyn FileSystem>, so we have this instead

fn number_global_refs(&self) -> usize

The expected number of strong refs in Arc by default This is used to check if the filesystem is still in use before unmounting This is here because for some filesystems, it could be stored globally in some Mutex like /devices this reference should not be counted to know if its still in use

impl<T: ?Sized + Send> Send for Mutex<T>

impl<T: ?Sized + Send> Sync for Mutex<T>