fuser/
lib.rs

1//! FUSE userspace library implementation
2//!
3//! This is an improved rewrite of the FUSE userspace library (lowlevel interface) to fully take
4//! advantage of Rust's architecture. The only thing we rely on in the real libfuse are mount
5//! and unmount calls which are needed to establish a fd to talk to the kernel driver.
6
7#![warn(missing_docs, missing_debug_implementations, rust_2018_idioms)]
8
9use libc::{ENOSYS, EPERM, c_int};
10use log::warn;
11use mnt::mount_options::parse_options_from_args;
12#[cfg(feature = "serializable")]
13use serde::{Deserialize, Serialize};
14use std::ffi::OsStr;
15use std::io;
16use std::path::Path;
17#[cfg(feature = "abi-7-23")]
18use std::time::Duration;
19use std::time::SystemTime;
20use std::{convert::AsRef, io::ErrorKind};
21
22pub use crate::ll::fuse_abi::FUSE_ROOT_ID;
23use crate::ll::fuse_abi::consts::*;
24pub use crate::ll::{TimeOrNow, fuse_abi::consts};
25use crate::mnt::mount_options::check_option_conflicts;
26use crate::session::MAX_WRITE_SIZE;
27pub use ll::fuse_abi::fuse_forget_one;
28pub use mnt::{Mount, mount_options::MountOption};
29pub use notify::{Notifier, PollHandle};
30#[cfg(feature = "abi-7-40")]
31pub use passthrough::BackingId;
32pub use reply::ReplyPoll;
33#[cfg(target_os = "macos")]
34pub use reply::ReplyXTimes;
35pub use reply::ReplyXattr;
36pub use reply::{Reply, ReplyAttr, ReplyData, ReplyEmpty, ReplyEntry, ReplyOpen};
37pub use reply::{
38    ReplyBmap, ReplyCreate, ReplyDirectory, ReplyDirectoryPlus, ReplyIoctl, ReplyLock, ReplyLseek,
39    ReplyStatfs, ReplyWrite,
40};
41pub use request::Request;
42pub use session::{BackgroundSession, Session, SessionACL, SessionUnmounter};
43#[cfg(feature = "abi-7-28")]
44use std::cmp::max;
45use std::cmp::min;
46
47mod channel;
48mod ll;
49mod mnt;
50mod notify;
51#[cfg(feature = "abi-7-40")]
52mod passthrough;
53mod reply;
54mod request;
55mod session;
56
57/// We generally support async reads
58#[cfg(not(target_os = "macos"))]
59const INIT_FLAGS: u64 = FUSE_ASYNC_READ | FUSE_BIG_WRITES;
60// TODO: Add FUSE_EXPORT_SUPPORT
61
62/// On macOS, we additionally support case insensitiveness, volume renames and xtimes
63/// TODO: we should eventually let the filesystem implementation decide which flags to set
64#[cfg(target_os = "macos")]
65const INIT_FLAGS: u64 = FUSE_ASYNC_READ | FUSE_CASE_INSENSITIVE | FUSE_VOL_RENAME | FUSE_XTIMES;
66// TODO: Add FUSE_EXPORT_SUPPORT and FUSE_BIG_WRITES (requires ABI 7.10)
67
68const fn default_init_flags(#[allow(unused_variables)] capabilities: u64) -> u64 {
69    #[cfg(not(feature = "abi-7-28"))]
70    {
71        INIT_FLAGS
72    }
73
74    #[cfg(feature = "abi-7-28")]
75    {
76        let mut flags = INIT_FLAGS;
77        if capabilities & FUSE_MAX_PAGES != 0 {
78            flags |= FUSE_MAX_PAGES;
79        }
80        flags
81    }
82}
83
84/// File types
85#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
86#[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))]
87pub enum FileType {
88    /// Named pipe (S_IFIFO)
89    NamedPipe,
90    /// Character device (S_IFCHR)
91    CharDevice,
92    /// Block device (S_IFBLK)
93    BlockDevice,
94    /// Directory (S_IFDIR)
95    Directory,
96    /// Regular file (S_IFREG)
97    RegularFile,
98    /// Symbolic link (S_IFLNK)
99    Symlink,
100    /// Unix domain socket (S_IFSOCK)
101    Socket,
102}
103
104/// File attributes
105#[derive(Clone, Copy, Debug, Eq, PartialEq)]
106#[cfg_attr(feature = "serializable", derive(Serialize, Deserialize))]
107pub struct FileAttr {
108    /// Inode number
109    pub ino: u64,
110    /// Size in bytes
111    pub size: u64,
112    /// Size in blocks
113    pub blocks: u64,
114    /// Time of last access
115    pub atime: SystemTime,
116    /// Time of last modification
117    pub mtime: SystemTime,
118    /// Time of last change
119    pub ctime: SystemTime,
120    /// Time of creation (macOS only)
121    pub crtime: SystemTime,
122    /// Kind of file (directory, file, pipe, etc)
123    pub kind: FileType,
124    /// Permissions
125    pub perm: u16,
126    /// Number of hard links
127    pub nlink: u32,
128    /// User id
129    pub uid: u32,
130    /// Group id
131    pub gid: u32,
132    /// Rdev
133    pub rdev: u32,
134    /// Block size
135    pub blksize: u32,
136    /// Flags (macOS only, see chflags(2))
137    pub flags: u32,
138}
139
140/// Configuration of the fuse kernel module connection
141#[derive(Debug)]
142pub struct KernelConfig {
143    capabilities: u64,
144    requested: u64,
145    max_readahead: u32,
146    max_max_readahead: u32,
147    max_background: u16,
148    congestion_threshold: Option<u16>,
149    max_write: u32,
150    #[cfg(feature = "abi-7-23")]
151    time_gran: Duration,
152    #[cfg(feature = "abi-7-40")]
153    max_stack_depth: u32,
154}
155
156impl KernelConfig {
157    fn new(capabilities: u64, max_readahead: u32) -> Self {
158        Self {
159            capabilities,
160            requested: default_init_flags(capabilities),
161            max_readahead,
162            max_max_readahead: max_readahead,
163            max_background: 16,
164            congestion_threshold: None,
165            // use a max write size that fits into the session's buffer
166            max_write: MAX_WRITE_SIZE as u32,
167            // 1ns means nano-second granularity.
168            #[cfg(feature = "abi-7-23")]
169            time_gran: Duration::new(0, 1),
170            #[cfg(feature = "abi-7-40")]
171            max_stack_depth: 0,
172        }
173    }
174
175    /// Set the maximum stacking depth of the filesystem
176    ///
177    /// This has to be at least 1 to support passthrough to backing files.  Setting this to 0 (the
178    /// default) effectively disables support for passthrough.
179    ///
180    /// With max_stack_depth > 1, the backing files can be on a stacked fs (e.g. overlayfs)
181    /// themselves and with max_stack_depth == 1, this FUSE filesystem can be stacked as the
182    /// underlying fs of a stacked fs (e.g. overlayfs).
183    ///
184    /// The kernel currently has a hard maximum value of 2.  Anything higher won't work.
185    ///
186    /// On success, returns the previous value.  On error, returns the nearest value which will succeed.
187    #[cfg(feature = "abi-7-40")]
188    pub fn set_max_stack_depth(&mut self, value: u32) -> Result<u32, u32> {
189        // https://lore.kernel.org/linux-fsdevel/CAOYeF9V_n93OEF_uf0Gwtd=+da0ReX8N2aaT6RfEJ9DPvs8O2w@mail.gmail.com/
190        const FILESYSTEM_MAX_STACK_DEPTH: u32 = 2;
191
192        if value > FILESYSTEM_MAX_STACK_DEPTH {
193            return Err(FILESYSTEM_MAX_STACK_DEPTH);
194        }
195
196        let previous = self.max_stack_depth;
197        self.max_stack_depth = value;
198        Ok(previous)
199    }
200
201    /// Set the timestamp granularity
202    ///
203    /// Must be a power of 10 nanoseconds. i.e. 1s, 0.1s, 0.01s, 1ms, 0.1ms...etc
204    ///
205    /// On success returns the previous value. On error returns the nearest value which will succeed
206    #[cfg(feature = "abi-7-23")]
207    pub fn set_time_granularity(&mut self, value: Duration) -> Result<Duration, Duration> {
208        if value.as_nanos() == 0 {
209            return Err(Duration::new(0, 1));
210        }
211        if value.as_secs() > 1 || (value.as_secs() == 1 && value.subsec_nanos() > 0) {
212            return Err(Duration::new(1, 0));
213        }
214        let mut power_of_10 = 1;
215        while power_of_10 < value.as_nanos() {
216            if value.as_nanos() < power_of_10 * 10 {
217                // value must not be a power of ten, since power_of_10 < value < power_of_10 * 10
218                return Err(Duration::new(0, power_of_10 as u32));
219            }
220            power_of_10 *= 10;
221        }
222        let previous = self.time_gran;
223        self.time_gran = value;
224        Ok(previous)
225    }
226
227    /// Set the maximum write size for a single request
228    ///
229    /// On success returns the previous value. On error returns the nearest value which will succeed
230    pub fn set_max_write(&mut self, value: u32) -> Result<u32, u32> {
231        if value == 0 {
232            return Err(1);
233        }
234        if value > MAX_WRITE_SIZE as u32 {
235            return Err(MAX_WRITE_SIZE as u32);
236        }
237        let previous = self.max_write;
238        self.max_write = value;
239        Ok(previous)
240    }
241
242    /// Set the maximum readahead size
243    ///
244    /// On success returns the previous value. On error returns the nearest value which will succeed
245    pub fn set_max_readahead(&mut self, value: u32) -> Result<u32, u32> {
246        if value == 0 {
247            return Err(1);
248        }
249        if value > self.max_max_readahead {
250            return Err(self.max_max_readahead);
251        }
252        let previous = self.max_readahead;
253        self.max_readahead = value;
254        Ok(previous)
255    }
256
257    /// Add a set of capabilities.
258    ///
259    /// On success returns Ok, else return bits of capabilities not supported when capabilities you provided are not all supported by kernel.
260    pub fn add_capabilities(&mut self, capabilities_to_add: u64) -> Result<(), u64> {
261        if capabilities_to_add & self.capabilities != capabilities_to_add {
262            return Err(capabilities_to_add - (capabilities_to_add & self.capabilities));
263        }
264        self.requested |= capabilities_to_add;
265        Ok(())
266    }
267
268    /// Set the maximum number of pending background requests. Such as readahead requests.
269    ///
270    /// On success returns the previous value. On error returns the nearest value which will succeed
271    pub fn set_max_background(&mut self, value: u16) -> Result<u16, u16> {
272        if value == 0 {
273            return Err(1);
274        }
275        let previous = self.max_background;
276        self.max_background = value;
277        Ok(previous)
278    }
279
280    /// Set the threshold of background requests at which the kernel will consider the filesystem
281    /// request queue congested. (it may then switch to sleeping instead of spin-waiting, for example)
282    ///
283    /// On success returns the previous value. On error returns the nearest value which will succeed
284    pub fn set_congestion_threshold(&mut self, value: u16) -> Result<u16, u16> {
285        if value == 0 {
286            return Err(1);
287        }
288        let previous = self.congestion_threshold();
289        self.congestion_threshold = Some(value);
290        Ok(previous)
291    }
292
293    fn congestion_threshold(&self) -> u16 {
294        match self.congestion_threshold {
295            // Default to a threshold of 3/4 of the max background threads
296            None => (self.max_background as u32 * 3 / 4) as u16,
297            Some(value) => min(value, self.max_background),
298        }
299    }
300
301    #[cfg(feature = "abi-7-28")]
302    fn max_pages(&self) -> u16 {
303        ((max(self.max_write, self.max_readahead) - 1) / page_size::get() as u32) as u16 + 1
304    }
305}
306
307/// Filesystem trait.
308///
309/// This trait must be implemented to provide a userspace filesystem via FUSE.
310/// These methods correspond to fuse_lowlevel_ops in libfuse. Reasonable default
311/// implementations are provided here to get a mountable filesystem that does
312/// nothing.
313#[allow(clippy::too_many_arguments)]
314pub trait Filesystem {
315    /// Initialize filesystem.
316    /// Called before any other filesystem method.
317    /// The kernel module connection can be configured using the KernelConfig object
318    fn init(&self, _req: &Request<'_>, _config: &mut KernelConfig) -> Result<(), c_int> {
319        Ok(())
320    }
321
322    /// Clean up filesystem.
323    /// Called on filesystem exit.
324    fn destroy(&self) {}
325
326    /// Look up a directory entry by name and get its attributes.
327    fn lookup(&self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: ReplyEntry) {
328        warn!("[Not Implemented] lookup(parent: {parent:#x?}, name {name:?})");
329        reply.error(ENOSYS);
330    }
331
332    /// Forget about an inode.
333    /// The nlookup parameter indicates the number of lookups previously performed on
334    /// this inode. If the filesystem implements inode lifetimes, it is recommended that
335    /// inodes acquire a single reference on each lookup, and lose nlookup references on
336    /// each forget. The filesystem may ignore forget calls, if the inodes don't need to
337    /// have a limited lifetime. On unmount it is not guaranteed, that all referenced
338    /// inodes will receive a forget message.
339    fn forget(&self, _req: &Request<'_>, _ino: u64, _nlookup: u64) {}
340
341    /// Like forget, but take multiple forget requests at once for performance. The default
342    /// implementation will fallback to forget.
343    fn batch_forget(&self, req: &Request<'_>, nodes: &[fuse_forget_one]) {
344        for node in nodes {
345            self.forget(req, node.nodeid, node.nlookup);
346        }
347    }
348
349    /// Get file attributes.
350    fn getattr(&self, _req: &Request<'_>, ino: u64, fh: Option<u64>, reply: ReplyAttr) {
351        warn!("[Not Implemented] getattr(ino: {ino:#x?}, fh: {fh:#x?})");
352        reply.error(ENOSYS);
353    }
354
355    /// Set file attributes.
356    fn setattr(
357        &self,
358        _req: &Request<'_>,
359        ino: u64,
360        mode: Option<u32>,
361        uid: Option<u32>,
362        gid: Option<u32>,
363        size: Option<u64>,
364        _atime: Option<TimeOrNow>,
365        _mtime: Option<TimeOrNow>,
366        _ctime: Option<SystemTime>,
367        fh: Option<u64>,
368        _crtime: Option<SystemTime>,
369        _chgtime: Option<SystemTime>,
370        _bkuptime: Option<SystemTime>,
371        flags: Option<u32>,
372        reply: ReplyAttr,
373    ) {
374        warn!(
375            "[Not Implemented] setattr(ino: {ino:#x?}, mode: {mode:?}, uid: {uid:?}, \
376            gid: {gid:?}, size: {size:?}, fh: {fh:?}, flags: {flags:?})"
377        );
378        reply.error(ENOSYS);
379    }
380
381    /// Read symbolic link.
382    fn readlink(&self, _req: &Request<'_>, ino: u64, reply: ReplyData) {
383        warn!("[Not Implemented] readlink(ino: {ino:#x?})");
384        reply.error(ENOSYS);
385    }
386
387    /// Create file node.
388    /// Create a regular file, character device, block device, fifo or socket node.
389    fn mknod(
390        &self,
391        _req: &Request<'_>,
392        parent: u64,
393        name: &OsStr,
394        mode: u32,
395        umask: u32,
396        rdev: u32,
397        reply: ReplyEntry,
398    ) {
399        warn!(
400            "[Not Implemented] mknod(parent: {parent:#x?}, name: {name:?}, \
401            mode: {mode}, umask: {umask:#x?}, rdev: {rdev})"
402        );
403        reply.error(ENOSYS);
404    }
405
406    /// Create a directory.
407    fn mkdir(
408        &self,
409        _req: &Request<'_>,
410        parent: u64,
411        name: &OsStr,
412        mode: u32,
413        umask: u32,
414        reply: ReplyEntry,
415    ) {
416        warn!(
417            "[Not Implemented] mkdir(parent: {parent:#x?}, name: {name:?}, mode: {mode}, umask: {umask:#x?})"
418        );
419        reply.error(ENOSYS);
420    }
421
422    /// Remove a file.
423    fn unlink(&self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: ReplyEmpty) {
424        warn!("[Not Implemented] unlink(parent: {parent:#x?}, name: {name:?})",);
425        reply.error(ENOSYS);
426    }
427
428    /// Remove a directory.
429    fn rmdir(&self, _req: &Request<'_>, parent: u64, name: &OsStr, reply: ReplyEmpty) {
430        warn!("[Not Implemented] rmdir(parent: {parent:#x?}, name: {name:?})",);
431        reply.error(ENOSYS);
432    }
433
434    /// Create a symbolic link.
435    fn symlink(
436        &self,
437        _req: &Request<'_>,
438        parent: u64,
439        link_name: &OsStr,
440        target: &Path,
441        reply: ReplyEntry,
442    ) {
443        warn!(
444            "[Not Implemented] symlink(parent: {parent:#x?}, link_name: {link_name:?}, target: {target:?})",
445        );
446        reply.error(EPERM);
447    }
448
449    /// Rename a file.
450    fn rename(
451        &self,
452        _req: &Request<'_>,
453        parent: u64,
454        name: &OsStr,
455        newparent: u64,
456        newname: &OsStr,
457        flags: u32,
458        reply: ReplyEmpty,
459    ) {
460        warn!(
461            "[Not Implemented] rename(parent: {parent:#x?}, name: {name:?}, \
462            newparent: {newparent:#x?}, newname: {newname:?}, flags: {flags})",
463        );
464        reply.error(ENOSYS);
465    }
466
467    /// Create a hard link.
468    fn link(
469        &self,
470        _req: &Request<'_>,
471        ino: u64,
472        newparent: u64,
473        newname: &OsStr,
474        reply: ReplyEntry,
475    ) {
476        warn!(
477            "[Not Implemented] link(ino: {ino:#x?}, newparent: {newparent:#x?}, newname: {newname:?})"
478        );
479        reply.error(EPERM);
480    }
481
482    /// Open a file.
483    /// Open flags (with the exception of O_CREAT, O_EXCL, O_NOCTTY and O_TRUNC) are
484    /// available in flags. Filesystem may store an arbitrary file handle (pointer, index,
485    /// etc) in fh, and use this in other all other file operations (read, write, flush,
486    /// release, fsync). Filesystem may also implement stateless file I/O and not store
487    /// anything in fh. There are also some flags (direct_io, keep_cache) which the
488    /// filesystem may set, to change the way the file is opened. See fuse_file_info
489    /// structure in <fuse_common.h> for more details.
490    fn open(&self, _req: &Request<'_>, _ino: u64, _flags: i32, reply: ReplyOpen) {
491        reply.opened(0, 0);
492    }
493
494    /// Read data.
495    /// Read should send exactly the number of bytes requested except on EOF or error,
496    /// otherwise the rest of the data will be substituted with zeroes. An exception to
497    /// this is when the file has been opened in 'direct_io' mode, in which case the
498    /// return value of the read system call will reflect the return value of this
499    /// operation. fh will contain the value set by the open method, or will be undefined
500    /// if the open method didn't set any value.
501    ///
502    /// flags: these are the file flags, such as O_SYNC. Only supported with ABI >= 7.9
503    /// lock_owner: only supported with ABI >= 7.9
504    fn read(
505        &self,
506        _req: &Request<'_>,
507        ino: u64,
508        fh: u64,
509        offset: i64,
510        size: u32,
511        flags: i32,
512        lock_owner: Option<u64>,
513        reply: ReplyData,
514    ) {
515        warn!(
516            "[Not Implemented] read(ino: {ino:#x?}, fh: {fh}, offset: {offset}, \
517            size: {size}, flags: {flags:#x?}, lock_owner: {lock_owner:?})"
518        );
519        reply.error(ENOSYS);
520    }
521
522    /// Write data.
523    /// Write should return exactly the number of bytes requested except on error. An
524    /// exception to this is when the file has been opened in 'direct_io' mode, in
525    /// which case the return value of the write system call will reflect the return
526    /// value of this operation. fh will contain the value set by the open method, or
527    /// will be undefined if the open method didn't set any value.
528    ///
529    /// write_flags: will contain FUSE_WRITE_CACHE, if this write is from the page cache. If set,
530    /// the pid, uid, gid, and fh may not match the value that would have been sent if write cachin
531    /// is disabled
532    /// flags: these are the file flags, such as O_SYNC. Only supported with ABI >= 7.9
533    /// lock_owner: only supported with ABI >= 7.9
534    fn write(
535        &self,
536        _req: &Request<'_>,
537        ino: u64,
538        fh: u64,
539        offset: i64,
540        data: &[u8],
541        write_flags: u32,
542        flags: i32,
543        lock_owner: Option<u64>,
544        reply: ReplyWrite,
545    ) {
546        warn!(
547            "[Not Implemented] write(ino: {ino:#x?}, fh: {fh}, offset: {offset}, \
548            data.len(): {}, write_flags: {write_flags:#x?}, flags: {flags:#x?}, \
549            lock_owner: {lock_owner:?})",
550            data.len()
551        );
552        reply.error(ENOSYS);
553    }
554
555    /// Flush method.
556    /// This is called on each close() of the opened file. Since file descriptors can
557    /// be duplicated (dup, dup2, fork), for one open call there may be many flush
558    /// calls. Filesystems shouldn't assume that flush will always be called after some
559    /// writes, or that if will be called at all. fh will contain the value set by the
560    /// open method, or will be undefined if the open method didn't set any value.
561    /// NOTE: the name of the method is misleading, since (unlike fsync) the filesystem
562    /// is not forced to flush pending writes. One reason to flush data, is if the
563    /// filesystem wants to return write errors. If the filesystem supports file locking
564    /// operations (setlk, getlk) it should remove all locks belonging to 'lock_owner'.
565    fn flush(&self, _req: &Request<'_>, ino: u64, fh: u64, lock_owner: u64, reply: ReplyEmpty) {
566        warn!("[Not Implemented] flush(ino: {ino:#x?}, fh: {fh}, lock_owner: {lock_owner:?})");
567        reply.error(ENOSYS);
568    }
569
570    /// Release an open file.
571    /// Release is called when there are no more references to an open file: all file
572    /// descriptors are closed and all memory mappings are unmapped. For every open
573    /// call there will be exactly one release call. The filesystem may reply with an
574    /// error, but error values are not returned to close() or munmap() which triggered
575    /// the release. fh will contain the value set by the open method, or will be undefined
576    /// if the open method didn't set any value. flags will contain the same flags as for
577    /// open.
578    fn release(
579        &self,
580        _req: &Request<'_>,
581        _ino: u64,
582        _fh: u64,
583        _flags: i32,
584        _lock_owner: Option<u64>,
585        _flush: bool,
586        reply: ReplyEmpty,
587    ) {
588        reply.ok();
589    }
590
591    /// Synchronize file contents.
592    /// If the datasync parameter is non-zero, then only the user data should be flushed,
593    /// not the meta data.
594    fn fsync(&self, _req: &Request<'_>, ino: u64, fh: u64, datasync: bool, reply: ReplyEmpty) {
595        warn!("[Not Implemented] fsync(ino: {ino:#x?}, fh: {fh}, datasync: {datasync})");
596        reply.error(ENOSYS);
597    }
598
599    /// Open a directory.
600    /// Filesystem may store an arbitrary file handle (pointer, index, etc) in fh, and
601    /// use this in other all other directory stream operations (readdir, releasedir,
602    /// fsyncdir). Filesystem may also implement stateless directory I/O and not store
603    /// anything in fh, though that makes it impossible to implement standard conforming
604    /// directory stream operations in case the contents of the directory can change
605    /// between opendir and releasedir.
606    fn opendir(&self, _req: &Request<'_>, _ino: u64, _flags: i32, reply: ReplyOpen) {
607        reply.opened(0, 0);
608    }
609
610    /// Read directory.
611    /// Send a buffer filled using buffer.fill(), with size not exceeding the
612    /// requested size. Send an empty buffer on end of stream. fh will contain the
613    /// value set by the opendir method, or will be undefined if the opendir method
614    /// didn't set any value.
615    fn readdir(&self, _req: &Request<'_>, ino: u64, fh: u64, offset: i64, reply: ReplyDirectory) {
616        warn!("[Not Implemented] readdir(ino: {ino:#x?}, fh: {fh}, offset: {offset})");
617        reply.error(ENOSYS);
618    }
619
620    /// Read directory.
621    /// Send a buffer filled using buffer.fill(), with size not exceeding the
622    /// requested size. Send an empty buffer on end of stream. fh will contain the
623    /// value set by the opendir method, or will be undefined if the opendir method
624    /// didn't set any value.
625    fn readdirplus(
626        &self,
627        _req: &Request<'_>,
628        ino: u64,
629        fh: u64,
630        offset: i64,
631        reply: ReplyDirectoryPlus,
632    ) {
633        warn!("[Not Implemented] readdirplus(ino: {ino:#x?}, fh: {fh}, offset: {offset})");
634        reply.error(ENOSYS);
635    }
636
637    /// Release an open directory.
638    /// For every opendir call there will be exactly one releasedir call. fh will
639    /// contain the value set by the opendir method, or will be undefined if the
640    /// opendir method didn't set any value.
641    fn releasedir(&self, _req: &Request<'_>, _ino: u64, _fh: u64, _flags: i32, reply: ReplyEmpty) {
642        reply.ok();
643    }
644
645    /// Synchronize directory contents.
646    /// If the datasync parameter is set, then only the directory contents should
647    /// be flushed, not the meta data. fh will contain the value set by the opendir
648    /// method, or will be undefined if the opendir method didn't set any value.
649    fn fsyncdir(&self, _req: &Request<'_>, ino: u64, fh: u64, datasync: bool, reply: ReplyEmpty) {
650        warn!("[Not Implemented] fsyncdir(ino: {ino:#x?}, fh: {fh}, datasync: {datasync})");
651        reply.error(ENOSYS);
652    }
653
654    /// Get file system statistics.
655    fn statfs(&self, _req: &Request<'_>, _ino: u64, reply: ReplyStatfs) {
656        reply.statfs(0, 0, 0, 0, 0, 512, 255, 0);
657    }
658
659    /// Set an extended attribute.
660    fn setxattr(
661        &self,
662        _req: &Request<'_>,
663        ino: u64,
664        name: &OsStr,
665        _value: &[u8],
666        flags: i32,
667        position: u32,
668        reply: ReplyEmpty,
669    ) {
670        warn!(
671            "[Not Implemented] setxattr(ino: {ino:#x?}, name: {name:?}, \
672            flags: {flags:#x?}, position: {position})"
673        );
674        reply.error(ENOSYS);
675    }
676
677    /// Get an extended attribute.
678    /// If `size` is 0, the size of the value should be sent with `reply.size()`.
679    /// If `size` is not 0, and the value fits, send it with `reply.data()`, or
680    /// `reply.error(ERANGE)` if it doesn't.
681    fn getxattr(&self, _req: &Request<'_>, ino: u64, name: &OsStr, size: u32, reply: ReplyXattr) {
682        warn!("[Not Implemented] getxattr(ino: {ino:#x?}, name: {name:?}, size: {size})");
683        reply.error(ENOSYS);
684    }
685
686    /// List extended attribute names.
687    /// If `size` is 0, the size of the value should be sent with `reply.size()`.
688    /// If `size` is not 0, and the value fits, send it with `reply.data()`, or
689    /// `reply.error(ERANGE)` if it doesn't.
690    fn listxattr(&self, _req: &Request<'_>, ino: u64, size: u32, reply: ReplyXattr) {
691        warn!("[Not Implemented] listxattr(ino: {ino:#x?}, size: {size})");
692        reply.error(ENOSYS);
693    }
694
695    /// Remove an extended attribute.
696    fn removexattr(&self, _req: &Request<'_>, ino: u64, name: &OsStr, reply: ReplyEmpty) {
697        warn!("[Not Implemented] removexattr(ino: {ino:#x?}, name: {name:?})");
698        reply.error(ENOSYS);
699    }
700
701    /// Check file access permissions.
702    /// This will be called for the access() system call. If the 'default_permissions'
703    /// mount option is given, this method is not called. This method is not called
704    /// under Linux kernel versions 2.4.x
705    fn access(&self, _req: &Request<'_>, ino: u64, mask: i32, reply: ReplyEmpty) {
706        warn!("[Not Implemented] access(ino: {ino:#x?}, mask: {mask})");
707        reply.error(ENOSYS);
708    }
709
710    /// Create and open a file.
711    /// If the file does not exist, first create it with the specified mode, and then
712    /// open it. You can use any open flags in the flags parameter except O_NOCTTY.
713    /// The filesystem can store any type of file handle (such as a pointer or index)
714    /// in fh, which can then be used across all subsequent file operations including
715    /// read, write, flush, release, and fsync. Additionally, the filesystem may set
716    /// certain flags like direct_io and keep_cache to change the way the file is
717    /// opened. See fuse_file_info structure in <fuse_common.h> for more details. If
718    /// this method is not implemented or under Linux kernel versions earlier than
719    /// 2.6.15, the mknod() and open() methods will be called instead.
720    fn create(
721        &self,
722        _req: &Request<'_>,
723        parent: u64,
724        name: &OsStr,
725        mode: u32,
726        umask: u32,
727        flags: i32,
728        reply: ReplyCreate,
729    ) {
730        warn!(
731            "[Not Implemented] create(parent: {parent:#x?}, name: {name:?}, mode: {mode}, \
732            umask: {umask:#x?}, flags: {flags:#x?})"
733        );
734        reply.error(ENOSYS);
735    }
736
737    /// Test for a POSIX file lock.
738    fn getlk(
739        &self,
740        _req: &Request<'_>,
741        ino: u64,
742        fh: u64,
743        lock_owner: u64,
744        start: u64,
745        end: u64,
746        typ: i32,
747        pid: u32,
748        reply: ReplyLock,
749    ) {
750        warn!(
751            "[Not Implemented] getlk(ino: {ino:#x?}, fh: {fh}, lock_owner: {lock_owner}, \
752            start: {start}, end: {end}, typ: {typ}, pid: {pid})"
753        );
754        reply.error(ENOSYS);
755    }
756
757    /// Acquire, modify or release a POSIX file lock.
758    /// For POSIX threads (NPTL) there's a 1-1 relation between pid and owner, but
759    /// otherwise this is not always the case.  For checking lock ownership,
760    /// 'fi->owner' must be used. The l_pid field in 'struct flock' should only be
761    /// used to fill in this field in getlk(). Note: if the locking methods are not
762    /// implemented, the kernel will still allow file locking to work locally.
763    /// Hence these are only interesting for network filesystems and similar.
764    fn setlk(
765        &self,
766        _req: &Request<'_>,
767        ino: u64,
768        fh: u64,
769        lock_owner: u64,
770        start: u64,
771        end: u64,
772        typ: i32,
773        pid: u32,
774        sleep: bool,
775        reply: ReplyEmpty,
776    ) {
777        warn!(
778            "[Not Implemented] setlk(ino: {ino:#x?}, fh: {fh}, lock_owner: {lock_owner}, \
779            start: {start}, end: {end}, typ: {typ}, pid: {pid}, sleep: {sleep})"
780        );
781        reply.error(ENOSYS);
782    }
783
784    /// Map block index within file to block index within device.
785    /// Note: This makes sense only for block device backed filesystems mounted
786    /// with the 'blkdev' option
787    fn bmap(&self, _req: &Request<'_>, ino: u64, blocksize: u32, idx: u64, reply: ReplyBmap) {
788        warn!("[Not Implemented] bmap(ino: {ino:#x?}, blocksize: {blocksize}, idx: {idx})",);
789        reply.error(ENOSYS);
790    }
791
792    /// control device
793    fn ioctl(
794        &self,
795        _req: &Request<'_>,
796        ino: u64,
797        fh: u64,
798        flags: u32,
799        cmd: u32,
800        in_data: &[u8],
801        out_size: u32,
802        reply: ReplyIoctl,
803    ) {
804        warn!(
805            "[Not Implemented] ioctl(ino: {ino:#x?}, fh: {fh}, flags: {flags}, \
806            cmd: {cmd}, in_data.len(): {}, out_size: {out_size})",
807            in_data.len()
808        );
809        reply.error(ENOSYS);
810    }
811
812    /// Poll for events
813    fn poll(
814        &self,
815        _req: &Request<'_>,
816        ino: u64,
817        fh: u64,
818        ph: PollHandle,
819        events: u32,
820        flags: u32,
821        reply: ReplyPoll,
822    ) {
823        warn!(
824            "[Not Implemented] poll(ino: {ino:#x?}, fh: {fh}, \
825            ph: {ph:?}, events: {events}, flags: {flags})"
826        );
827        reply.error(ENOSYS);
828    }
829
830    /// Preallocate or deallocate space to a file
831    fn fallocate(
832        &self,
833        _req: &Request<'_>,
834        ino: u64,
835        fh: u64,
836        offset: i64,
837        length: i64,
838        mode: i32,
839        reply: ReplyEmpty,
840    ) {
841        warn!(
842            "[Not Implemented] fallocate(ino: {ino:#x?}, fh: {fh}, \
843            offset: {offset}, length: {length}, mode: {mode})"
844        );
845        reply.error(ENOSYS);
846    }
847
848    /// Reposition read/write file offset
849    fn lseek(
850        &self,
851        _req: &Request<'_>,
852        ino: u64,
853        fh: u64,
854        offset: i64,
855        whence: i32,
856        reply: ReplyLseek,
857    ) {
858        warn!(
859            "[Not Implemented] lseek(ino: {ino:#x?}, fh: {fh}, \
860            offset: {offset}, whence: {whence})"
861        );
862        reply.error(ENOSYS);
863    }
864
865    /// Copy the specified range from the source inode to the destination inode
866    fn copy_file_range(
867        &self,
868        _req: &Request<'_>,
869        ino_in: u64,
870        fh_in: u64,
871        offset_in: i64,
872        ino_out: u64,
873        fh_out: u64,
874        offset_out: i64,
875        len: u64,
876        flags: u32,
877        reply: ReplyWrite,
878    ) {
879        warn!(
880            "[Not Implemented] copy_file_range(ino_in: {ino_in:#x?}, fh_in: {fh_in}, \
881            offset_in: {offset_in}, ino_out: {ino_out:#x?}, fh_out: {fh_out}, \
882            offset_out: {offset_out}, len: {len}, flags: {flags})"
883        );
884        reply.error(ENOSYS);
885    }
886
887    /// macOS only: Rename the volume. Set fuse_init_out.flags during init to
888    /// FUSE_VOL_RENAME to enable
889    #[cfg(target_os = "macos")]
890    fn setvolname(&self, _req: &Request<'_>, name: &OsStr, reply: ReplyEmpty) {
891        warn!("[Not Implemented] setvolname(name: {name:?})");
892        reply.error(ENOSYS);
893    }
894
895    /// macOS only (undocumented)
896    #[cfg(target_os = "macos")]
897    fn exchange(
898        &self,
899        _req: &Request<'_>,
900        parent: u64,
901        name: &OsStr,
902        newparent: u64,
903        newname: &OsStr,
904        options: u64,
905        reply: ReplyEmpty,
906    ) {
907        warn!(
908            "[Not Implemented] exchange(parent: {parent:#x?}, name: {name:?}, \
909            newparent: {newparent:#x?}, newname: {newname:?}, options: {options})"
910        );
911        reply.error(ENOSYS);
912    }
913
914    /// macOS only: Query extended times (bkuptime and crtime). Set fuse_init_out.flags
915    /// during init to FUSE_XTIMES to enable
916    #[cfg(target_os = "macos")]
917    fn getxtimes(&self, _req: &Request<'_>, ino: u64, reply: ReplyXTimes) {
918        warn!("[Not Implemented] getxtimes(ino: {ino:#x?})");
919        reply.error(ENOSYS);
920    }
921}
922
923/// Mount the given filesystem to the given mountpoint. This function will
924/// not return until the filesystem is unmounted.
925///
926/// Note that you need to lead each option with a separate `"-o"` string.
927#[deprecated(note = "use mount2() instead")]
928pub fn mount<FS: Filesystem, P: AsRef<Path>>(
929    filesystem: FS,
930    mountpoint: P,
931    options: &[&OsStr],
932) -> io::Result<()> {
933    let options = parse_options_from_args(options)?;
934    mount2(filesystem, mountpoint, options.as_ref())
935}
936
937/// Mount the given filesystem to the given mountpoint. This function will
938/// not return until the filesystem is unmounted.
939///
940/// NOTE: This will eventually replace mount(), once the API is stable
941pub fn mount2<FS: Filesystem, P: AsRef<Path>>(
942    filesystem: FS,
943    mountpoint: P,
944    options: &[MountOption],
945) -> io::Result<()> {
946    check_option_conflicts(options)?;
947    Session::new(filesystem, mountpoint.as_ref(), options).and_then(|se| se.run())
948}
949
950/// Mount the given filesystem to the given mountpoint. This function spawns
951/// a background thread to handle filesystem operations while being mounted
952/// and therefore returns immediately. The returned handle should be stored
953/// to reference the mounted filesystem. If it's dropped, the filesystem will
954/// be unmounted.
955#[deprecated(note = "use spawn_mount2() instead")]
956pub fn spawn_mount<'a, FS: Filesystem + Send + 'static + 'a, P: AsRef<Path>>(
957    filesystem: FS,
958    mountpoint: P,
959    options: &[&OsStr],
960) -> io::Result<BackgroundSession> {
961    let options: Option<Vec<_>> = options
962        .iter()
963        .map(|x| Some(MountOption::from_str(x.to_str()?)))
964        .collect();
965    let options = options.ok_or(ErrorKind::InvalidData)?;
966    Session::new(filesystem, mountpoint.as_ref(), options.as_ref()).and_then(|se| se.spawn())
967}
968
969/// Mount the given filesystem to the given mountpoint. This function spawns
970/// a background thread to handle filesystem operations while being mounted
971/// and therefore returns immediately. The returned handle should be stored
972/// to reference the mounted filesystem. If it's dropped, the filesystem will
973/// be unmounted.
974///
975/// NOTE: This is the corresponding function to mount2.
976pub fn spawn_mount2<'a, FS: Filesystem + Send + 'static + 'a, P: AsRef<Path>>(
977    filesystem: FS,
978    mountpoint: P,
979    options: &[MountOption],
980) -> io::Result<BackgroundSession> {
981    check_option_conflicts(options)?;
982    Session::new(filesystem, mountpoint.as_ref(), options).and_then(|se| se.spawn())
983}
fuser/lib.rs

fuser/
lib.rs
