Skip to main content

INodeEntry

simply_fuse::basic

Struct INodeEntry 

Source 
pub struct INodeEntry<F> { /* private fields */ }

Implementations§

Source§

impl<F> INodeEntry<F>

Source

pub fn kind(&self) -> &INodeKind<F>

Source

pub fn kind_mut(&mut self) -> &mut INodeKind<F>

Examples found in repository?
examples/memfs.rs (line 186)
183    fn setattr(&mut self, ino: INode, attrs: SetFileAttributes) -> Result<FileAttributes> {
184        let entry = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;
185
186        match entry.kind_mut() {
187            INodeKind::Directory(dir) => dir.apply_attrs(attrs),
188            INodeKind::File(file) => file.attrs.apply_attrs(attrs),
189        };
190
191        Ok(entry.getattrs())
192    }
Source

pub fn file_type(&self) -> FileType

Examples found in repository?
examples/memfs.rs (line 144)
112    fn readdir(&mut self, dir_ino: INode, offset: u64) -> Result<Vec<DirEntry>> {
113        let dir_main = self.inodes.get(dir_ino).ok_or(FSError::NoEntry)?;
114        let dir = dir_main.as_dir().ok_or(FSError::NotDirectory)?;
115
116        let dots = [
117            DirEntry::builder()
118                .name(".".into())
119                .inode(dir_ino)
120                .typ(FileType::Directory)
121                .offset(1)
122                .build(),
123            DirEntry::builder()
124                .name("..".into())
125                .inode(dir_main.parent().unwrap_or(ROOT_INODE))
126                .typ(FileType::Directory)
127                .offset(2)
128                .build(),
129        ];
130
131        Ok(dots
132            .into_iter()
133            .chain(
134                dir.children()
135                    .enumerate()
136                    .map(
137                        |(off, v)| (off + 3, v), // add 3 to skip 0 and the two dots
138                    )
139                    .map(|(offset, (name, inode))| {
140                        DirEntry::builder()
141                            .name(name.clone())
142                            .offset(offset as u64)
143                            .inode(inode)
144                            .typ(self.inodes.get(inode).unwrap().file_type())
145                            .build()
146                    }),
147            )
148            .skip(offset as usize)
149            .collect())
150    }
Source

pub fn parent(&self) -> Option<INode>

Examples found in repository?
examples/memfs.rs (line 125)
112    fn readdir(&mut self, dir_ino: INode, offset: u64) -> Result<Vec<DirEntry>> {
113        let dir_main = self.inodes.get(dir_ino).ok_or(FSError::NoEntry)?;
114        let dir = dir_main.as_dir().ok_or(FSError::NotDirectory)?;
115
116        let dots = [
117            DirEntry::builder()
118                .name(".".into())
119                .inode(dir_ino)
120                .typ(FileType::Directory)
121                .offset(1)
122                .build(),
123            DirEntry::builder()
124                .name("..".into())
125                .inode(dir_main.parent().unwrap_or(ROOT_INODE))
126                .typ(FileType::Directory)
127                .offset(2)
128                .build(),
129        ];
130
131        Ok(dots
132            .into_iter()
133            .chain(
134                dir.children()
135                    .enumerate()
136                    .map(
137                        |(off, v)| (off + 3, v), // add 3 to skip 0 and the two dots
138                    )
139                    .map(|(offset, (name, inode))| {
140                        DirEntry::builder()
141                            .name(name.clone())
142                            .offset(offset as u64)
143                            .inode(inode)
144                            .typ(self.inodes.get(inode).unwrap().file_type())
145                            .build()
146                    }),
147            )
148            .skip(offset as usize)
149            .collect())
150    }
Source

pub fn as_dir(&self) -> Option<&Directory>

Examples found in repository?
examples/memfs.rs (line 92)
87    fn lookup(&mut self, parent: INode, name: &OsStr) -> Result<Lookup> {
88        let parent = self
89            .inodes
90            .get(parent)
91            .ok_or(FSError::NoEntry)
92            .and_then(|x| x.as_dir().ok_or(FSError::NotDirectory))?;
93
94        let (child_ino, child) = parent
95            .get(name)
96            // get the inode entry and then map it into (inode, &entry)
97            .and_then(|ino| self.inodes.get(*ino).map(|x| (*ino, x)))
98            .ok_or(FSError::NoEntry)?;
99
100        Ok(Lookup::builder()
101            .attributes(child.getattrs())
102            .inode(child_ino)
103            .build())
104    }
105
106    fn getattr(&mut self, inode: INode) -> Result<FileAttributes> {
107        let entry = self.inodes.get(inode).ok_or(FSError::NoEntry)?;
108
109        Ok(entry.getattrs())
110    }
111
112    fn readdir(&mut self, dir_ino: INode, offset: u64) -> Result<Vec<DirEntry>> {
113        let dir_main = self.inodes.get(dir_ino).ok_or(FSError::NoEntry)?;
114        let dir = dir_main.as_dir().ok_or(FSError::NotDirectory)?;
115
116        let dots = [
117            DirEntry::builder()
118                .name(".".into())
119                .inode(dir_ino)
120                .typ(FileType::Directory)
121                .offset(1)
122                .build(),
123            DirEntry::builder()
124                .name("..".into())
125                .inode(dir_main.parent().unwrap_or(ROOT_INODE))
126                .typ(FileType::Directory)
127                .offset(2)
128                .build(),
129        ];
130
131        Ok(dots
132            .into_iter()
133            .chain(
134                dir.children()
135                    .enumerate()
136                    .map(
137                        |(off, v)| (off + 3, v), // add 3 to skip 0 and the two dots
138                    )
139                    .map(|(offset, (name, inode))| {
140                        DirEntry::builder()
141                            .name(name.clone())
142                            .offset(offset as u64)
143                            .inode(inode)
144                            .typ(self.inodes.get(inode).unwrap().file_type())
145                            .build()
146                    }),
147            )
148            .skip(offset as usize)
149            .collect())
150    }
Source

pub fn as_dir_mut(&mut self) -> Option<&mut Directory>

Source

pub fn as_file(&self) -> Option<&F>

Examples found in repository?
examples/memfs.rs (line 154)
152    fn read(&mut self, ino: INode, offset: u64, size: u32) -> Result<&[u8]> {
153        let file = self.inodes.get(ino).ok_or(FSError::NoEntry)?;
154        let file = file.as_file().ok_or(FSError::NotFile)?;
155
156        let offset = offset as usize;
157        let size = size as usize;
158
159        let content = file.data.get(offset..).unwrap_or(&[]);
160        let content = &content[..std::cmp::min(file.size(), size)];
161
162        Ok(content)
163    }
Source

pub fn as_file_mut(&mut self) -> Option<&mut F>

Examples found in repository?
examples/memfs.rs (line 167)
165    fn write<T: BufRead>(&mut self, ino: INode, offset: u64, size: u32, mut buf: T) -> Result<u32> {
166        let file = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;
167        let file = file.as_file_mut().ok_or(FSError::NotFile)?;
168
169        let offset = offset as usize;
170        let size = size as usize;
171
172        file.data
173            .resize(std::cmp::max(file.size(), offset + size), 0);
174
175        buf.read_exact(&mut file.data[offset..offset + size])
176            .unwrap();
177
178        file.attrs.set_size((offset + size) as u64);
179
180        Ok(size as u32)
181    }
Source

pub fn children(&self) -> Option<&DirChildren>

Source§

impl<T: Attributable> INodeEntry<T>

Source

pub fn getattrs(&self) -> FileAttributes

Examples found in repository?
examples/memfs.rs (line 101)
87    fn lookup(&mut self, parent: INode, name: &OsStr) -> Result<Lookup> {
88        let parent = self
89            .inodes
90            .get(parent)
91            .ok_or(FSError::NoEntry)
92            .and_then(|x| x.as_dir().ok_or(FSError::NotDirectory))?;
93
94        let (child_ino, child) = parent
95            .get(name)
96            // get the inode entry and then map it into (inode, &entry)
97            .and_then(|ino| self.inodes.get(*ino).map(|x| (*ino, x)))
98            .ok_or(FSError::NoEntry)?;
99
100        Ok(Lookup::builder()
101            .attributes(child.getattrs())
102            .inode(child_ino)
103            .build())
104    }
105
106    fn getattr(&mut self, inode: INode) -> Result<FileAttributes> {
107        let entry = self.inodes.get(inode).ok_or(FSError::NoEntry)?;
108
109        Ok(entry.getattrs())
110    }
111
112    fn readdir(&mut self, dir_ino: INode, offset: u64) -> Result<Vec<DirEntry>> {
113        let dir_main = self.inodes.get(dir_ino).ok_or(FSError::NoEntry)?;
114        let dir = dir_main.as_dir().ok_or(FSError::NotDirectory)?;
115
116        let dots = [
117            DirEntry::builder()
118                .name(".".into())
119                .inode(dir_ino)
120                .typ(FileType::Directory)
121                .offset(1)
122                .build(),
123            DirEntry::builder()
124                .name("..".into())
125                .inode(dir_main.parent().unwrap_or(ROOT_INODE))
126                .typ(FileType::Directory)
127                .offset(2)
128                .build(),
129        ];
130
131        Ok(dots
132            .into_iter()
133            .chain(
134                dir.children()
135                    .enumerate()
136                    .map(
137                        |(off, v)| (off + 3, v), // add 3 to skip 0 and the two dots
138                    )
139                    .map(|(offset, (name, inode))| {
140                        DirEntry::builder()
141                            .name(name.clone())
142                            .offset(offset as u64)
143                            .inode(inode)
144                            .typ(self.inodes.get(inode).unwrap().file_type())
145                            .build()
146                    }),
147            )
148            .skip(offset as usize)
149            .collect())
150    }
151
152    fn read(&mut self, ino: INode, offset: u64, size: u32) -> Result<&[u8]> {
153        let file = self.inodes.get(ino).ok_or(FSError::NoEntry)?;
154        let file = file.as_file().ok_or(FSError::NotFile)?;
155
156        let offset = offset as usize;
157        let size = size as usize;
158
159        let content = file.data.get(offset..).unwrap_or(&[]);
160        let content = &content[..std::cmp::min(file.size(), size)];
161
162        Ok(content)
163    }
164
165    fn write<T: BufRead>(&mut self, ino: INode, offset: u64, size: u32, mut buf: T) -> Result<u32> {
166        let file = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;
167        let file = file.as_file_mut().ok_or(FSError::NotFile)?;
168
169        let offset = offset as usize;
170        let size = size as usize;
171
172        file.data
173            .resize(std::cmp::max(file.size(), offset + size), 0);
174
175        buf.read_exact(&mut file.data[offset..offset + size])
176            .unwrap();
177
178        file.attrs.set_size((offset + size) as u64);
179
180        Ok(size as u32)
181    }
182
183    fn setattr(&mut self, ino: INode, attrs: SetFileAttributes) -> Result<FileAttributes> {
184        let entry = self.inodes.get_mut(ino).ok_or(FSError::NoEntry)?;
185
186        match entry.kind_mut() {
187            INodeKind::Directory(dir) => dir.apply_attrs(attrs),
188            INodeKind::File(file) => file.attrs.apply_attrs(attrs),
189        };
190
191        Ok(entry.getattrs())
192    }

Trait Implementations§

Source§

impl<F: Debug> Debug for INodeEntry<F>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<F> IntoINodeEntry<F> for INodeEntry<F>

Source§

fn with_parent(self, parent: INode) -> INodeEntry<F>

Auto Trait Implementations§

§

impl<F> Freeze for INodeEntry<F>
where F: Freeze,

§

impl<F> RefUnwindSafe for INodeEntry<F>
where F: RefUnwindSafe,

§

impl<F> Send for INodeEntry<F>
where F: Send,

§

impl<F> Sync for INodeEntry<F>
where F: Sync,

§

impl<F> Unpin for INodeEntry<F>
where F: Unpin,

§

impl<F> UnsafeUnpin for INodeEntry<F>
where F: UnsafeUnpin,

§

impl<F> UnwindSafe for INodeEntry<F>
where F: UnwindSafe,

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> WithSubscriber for T

Source§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more