Struct SquashFs

pub struct SquashFs<R: Manager> {
    pub superblock: SuperBlock,
    pub inode_table: InodeTable,
    pub fragments_table: FragmentsTable,
    pub directory_tables: BTreeMap<u32, DirectoryTable>,
    pub handles: RwLock<BTreeMap<u64, ReadFlags>>,
    /* private fields */
}

Base structure representing a loaded SquashFS image.

Note that the tables (inode, directory…) are fully parsed on creation and kept in memory, rather than being accessed lazily.

This implements the fuser_async::Filesystem trait.

The type R is a deadpool pool manager for the underlying filesystem readers. See crate::pools.

Fields

superblock: SuperBlock

inode_table: InodeTable

fragments_table: FragmentsTable

directory_tables: BTreeMap<u32, DirectoryTable>

Table for each directory inode

handles: RwLock<BTreeMap<u64, ReadFlags>>

Implementations

impl<T: AsyncSeekBufRead, R: Manager<Type = T, Error = Error> + Send + Sync> SquashFs<R>

pub async fn read_file( &self, inode: u32, offset: usize, size: usize, flags: ReadFlags, compression: Compression, ) -> Result<Bytes, Error>

Read from a file from the archive

pub async fn read_file_impl( &self, file: &Box<dyn FileInode + Send + Sync>, __arg2: (impl AsyncSeekBufRead, u64), inode: u32, __arg4: (usize, usize), compression: Compression, ) -> Result<Bytes, Error>

impl<R: Manager> SquashFs<R>

pub fn ino_to_fuse(&self, ino: u32) -> u64

Remapping to ensure that the root inode is fuser::FUSE_ROOT_ID

impl<T, P> SquashFs<P>

where T: AsyncSeekBufRead, P: LocalReadersPool + Manager<Type = T, Error = Error> + Send + Sync,

pub async fn open(file: &Path, options: &Options) -> Result<Self, Error>

Open squashfs image from a local file

impl<R: Manager> SquashFs<R>

pub fn inodes(&self) -> impl Iterator<Item = u32> + '_

impl<T, R> SquashFs<R>

where T: AsyncSeekBufRead, R: Manager<Type = T, Error = Error> + Send + Sync,

pub async fn has_handles(&self) -> bool

pub async fn from_reader( options: &Options, manager_factory: impl ManagerFactory<R>, ) -> Result<Self, Error>

Open squashfs image from a reader factory, responsible for creating readers with the requested open flags.

Trait Implementations

impl<R: Manager> Debug for SquashFs<R>

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

Formats the value using the given formatter.

impl<T: AsyncSeekBufRead, R: Manager<Type = T, Error = Error> + Send + Sync> Filesystem for SquashFs<R>

type Error = Error

fn inodes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BTreeSet<u64>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the set of inodes from the filesystem.

fn open<'life0, 'async_trait>( &'life0 self, _ino: u64, flags: i32, ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open a file and get a handle. See also fuser::Filesystem::open.

fn release<'life0, 'async_trait>( &'life0 self, _ino: u64, fh: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Release a file handle. See also fuser::Filesystem::release.

fn lookup<'life0, 'life1, 'async_trait>( &'life0 self, parent: u64, name: &'life1 OsStr, ) -> Pin<Box<dyn Future<Output = Result<FileAttr, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Lookup an entry by name in a directory. See also fuser::Filesystem::lookup.

fn getattr<'life0, 'async_trait>( &'life0 self, ino_fuse: u64, ) -> Pin<Box<dyn Future<Output = Result<FileAttr, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get attributes on an entry. See also fuser::Filesystem::getattr.

fn setattr<'life0, 'async_trait>( &'life0 mut self, _ino: u64, _size: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<FileAttr, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set attributes. Currently only supports setting the size

fn readdir<'life0, 'async_trait>( &'life0 self, ino_fuse: u64, offset: u64, ) -> Pin<Box<dyn Future<Output = Result<Box<dyn Iterator<Item = DirEntry> + Send + Sync + '_>, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read a directory. To be called repeatedly by specifying a gradually increasing offset, until the returned iterator is empty. A minimum of two calls is required to be certain that the end has been reached. offset represents the index of the starting element. See also fuser::Filesystem::readdir.

fn read<'life0, 'async_trait>( &'life0 self, ino_fuse: u64, fh: u64, offset: i64, size: u32, ) -> Pin<Box<dyn Future<Output = Result<Bytes, Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read from a file. See also fuser::Filesystem::read.

fn write<'life0, 'async_trait>( &'life0 self, _ino: u64, _fh: u64, _data: Bytes, _offset: i64, ) -> Pin<Box<dyn Future<Output = Result<u32, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Write to file. See also fuser::Filesystem::write.

fn create<'life0, 'async_trait>( &'life0 mut self, _parent: u64, _name: OsString, _mode: u32, _umask: u32, _flags: i32, ) -> Pin<Box<dyn Future<Output = Result<(FileAttr, u64), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create and open a file. See also fuser::Filesystem::create.

fn mkdir<'life0, 'async_trait>( &'life0 mut self, _parent: u64, _name: OsString, ) -> Pin<Box<dyn Future<Output = Result<FileAttr, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a directory. See also fuser::Filesystem::mkdir.

fn destroy<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: Send + 'async_trait,

Close filesystem. See also fuser::Filesystem::destroy.