libfuse_fs/passthrough/
newlogfs.rs

1use super::Inode;
2use bytes::Bytes;
3use rfuse3::notify::Notify;
4use rfuse3::raw::reply::*;
5use rfuse3::raw::{Filesystem, Request, reply::ReplyInit};
6use rfuse3::{Result, SetAttr};
7use std::any::type_name_of_val;
8use std::ffi::OsStr;
9use std::sync::atomic::{AtomicU64, Ordering};
10use tracing::debug;
11// LoggingFileSystem . provide log info for a filesystem trait.
12pub struct LoggingFileSystem<FS: Filesystem> {
13    inner: FS,
14    fsname: String,
15    next_log_id: AtomicU64,
16}
17
18impl<FS: Filesystem> LoggingFileSystem<FS> {
19    pub fn new(fs: FS) -> Self {
20        let fsname = type_name_of_val(&fs);
21        Self {
22            inner: fs,
23            fsname: String::from(fsname),
24            next_log_id: AtomicU64::new(1),
25        }
26    }
27}
28impl<FS: Filesystem> LoggingFileSystem<FS> {
29    fn log_start(&self, req: &Request, id: u64, method: &str, args: &[(&str, String)]) {
30        let args_str = args
31            .iter()
32            .map(|(k, v)| format!("{k}={v}"))
33            .collect::<Vec<_>>()
34            .join(", ");
35        debug!("ID: {id} | [{method}] REQ {req:?} - Call_arg: {args_str}");
36    }
37
38    fn log_result(&self, id: u64, method: &str, result: &Result<impl std::fmt::Debug>) {
39        match result {
40            Ok(res) => debug!("ID: {id} | [{method}] - Success: {res:?}"),
41            Err(e) => debug!("ID: {id} | [{method}] - Error: {e:?}"),
42        }
43    }
44}
45
46impl<FS: rfuse3::raw::Filesystem + std::marker::Sync> Filesystem for LoggingFileSystem<FS> {
47    async fn init(&self, req: Request) -> Result<ReplyInit> {
48        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
49        let method = "init";
50        self.log_start(&req, id, method, &[]);
51        let result = self.inner.init(req).await;
52        self.log_result(id, method, &result);
53        result
54    }
55
56    async fn destroy(&self, req: Request) {
57        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
58        let method = "destroy";
59        self.log_start(&req, id, method, &[]);
60        self.inner.destroy(req).await;
61        debug!("ID: {} [{}] {} - Completed", id, self.fsname, method);
62    }
63
64    async fn lookup(&self, req: Request, parent: Inode, name: &OsStr) -> Result<ReplyEntry> {
65        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
66        let method = "lookup";
67        let args = vec![
68            ("parent", parent.to_string()),
69            ("name", name.to_string_lossy().into_owned()),
70        ];
71        self.log_start(&req, id, method, &args);
72        let result = self.inner.lookup(req, parent, name).await;
73        self.log_result(id, method, &result);
74        result
75    }
76
77    async fn forget(&self, req: Request, inode: Inode, nlookup: u64) {
78        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
79        let method = "forget";
80        let args = vec![
81            ("inode", inode.to_string()),
82            ("nlookup", nlookup.to_string()),
83        ];
84        self.log_start(&req, id, method, &args);
85        self.inner.forget(req, inode, nlookup).await;
86        debug!("ID: {} [{}] {} - Completed", id, self.fsname, method);
87    }
88
89    async fn getattr(
90        &self,
91        req: Request,
92        inode: Inode,
93        fh: Option<u64>,
94        flags: u32,
95    ) -> Result<ReplyAttr> {
96        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
97        let method = "getattr";
98        let args = vec![
99            ("inode", inode.to_string()),
100            ("fh", fh.map(|v| v.to_string()).unwrap_or_default()),
101            ("flags", flags.to_string()),
102        ];
103        self.log_start(&req, id, method, &args);
104        let result = self.inner.getattr(req, inode, fh, flags).await;
105        self.log_result(id, method, &result);
106        result
107    }
108
109    async fn setattr(
110        &self,
111        req: Request,
112        inode: Inode,
113        fh: Option<u64>,
114        set_attr: SetAttr,
115    ) -> Result<ReplyAttr> {
116        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
117        let method = "setattr";
118        let args = vec![
119            ("inode", inode.to_string()),
120            ("fh", fh.map(|v| v.to_string()).unwrap_or_default()),
121            ("set_attr", format!("{set_attr:?}")),
122        ];
123        self.log_start(&req, id, method, &args);
124        let result = self.inner.setattr(req, inode, fh, set_attr).await;
125        self.log_result(id, method, &result);
126        result
127    }
128
129    async fn readdirplus<'a>(
130        &'a self,
131        req: Request,
132        parent: Inode,
133        fh: u64,
134        offset: u64,
135        lock_owner: u64,
136    ) -> Result<
137        ReplyDirectoryPlus<
138            impl futures_util::stream::Stream<Item = Result<DirectoryEntryPlus>> + Send + 'a,
139        >,
140    > {
141        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
142        let method = "readdirplus";
143        let args = vec![
144            ("parent", parent.to_string()),
145            ("fh", fh.to_string()),
146            ("offset", offset.to_string()),
147            ("lock_owner", lock_owner.to_string()),
148        ];
149        self.log_start(&req, id, method, &args);
150        let result = self
151            .inner
152            .readdirplus(req, parent, fh, offset, lock_owner)
153            .await;
154        self.log_result(id, method, &Ok(""));
155        result
156    }
157
158    async fn opendir(&self, req: Request, inode: Inode, flags: u32) -> Result<ReplyOpen> {
159        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
160        let method = "opendir";
161        let args = vec![("inode", inode.to_string()), ("flags", flags.to_string())];
162        self.log_start(&req, id, method, &args);
163        let result = self.inner.opendir(req, inode, flags).await;
164        if let Ok(ref reply) = result {
165            debug!(
166                "ID: {} [{}] {} - Obtained fh: {}",
167                id, self.fsname, method, reply.fh
168            );
169        }
170        self.log_result(id, method, &result);
171        result
172    }
173
174    async fn readdir<'a>(
175        &'a self,
176        req: Request,
177        parent: Inode,
178        fh: u64,
179        offset: i64,
180    ) -> Result<
181        ReplyDirectory<
182            impl futures_util::stream::Stream<Item = Result<DirectoryEntry>> + Send + 'a,
183        >,
184    > {
185        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
186        let method = "readdir";
187        let args = vec![
188            ("parent", parent.to_string()),
189            ("fh", fh.to_string()),
190            ("offset", offset.to_string()),
191        ];
192        self.log_start(&req, id, method, &args);
193        let result = self.inner.readdir(req, parent, fh, offset).await;
194        self.log_result(id, method, &Ok(""));
195        result
196    }
197
198    async fn read(
199        &self,
200        req: Request,
201        inode: Inode,
202        fh: u64,
203        offset: u64,
204        size: u32,
205    ) -> Result<ReplyData> {
206        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
207        let method = "read";
208        let args = vec![
209            ("inode", inode.to_string()),
210            ("fh", fh.to_string()),
211            ("offset", offset.to_string()),
212            ("size", size.to_string()),
213        ];
214        self.log_start(&req, id, method, &args);
215        let result = self.inner.read(req, inode, fh, offset, size).await;
216        if let Ok(ref data) = result {
217            debug!(
218                "ID: {} [{}] {} - Read {} bytes",
219                id,
220                self.fsname,
221                method,
222                data.data.len()
223            );
224        }
225
226        // self.log_result(id, method, &result);
227        result
228    }
229
230    async fn write(
231        &self,
232        req: Request,
233        inode: Inode,
234        fh: u64,
235        offset: u64,
236        data: &[u8],
237        write_flags: u32,
238        flags: u32,
239    ) -> Result<ReplyWrite> {
240        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
241        let method = "write";
242        let args = vec![
243            ("inode", inode.to_string()),
244            ("fh", fh.to_string()),
245            ("offset", offset.to_string()),
246            ("data_len", data.len().to_string()),
247            ("write_flags", write_flags.to_string()),
248            ("flags", flags.to_string()),
249        ];
250        self.log_start(&req, id, method, &args);
251        let result = self
252            .inner
253            .write(req, inode, fh, offset, data, write_flags, flags)
254            .await;
255        if let Ok(ref reply) = result {
256            debug!(
257                "ID: {} [{}] {} - Wrote {} bytes",
258                id, self.fsname, method, reply.written
259            );
260        }
261        self.log_result(id, method, &result);
262        result
263    }
264
265    async fn fsync(&self, req: Request, inode: Inode, fh: u64, datasync: bool) -> Result<()> {
266        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
267        let method = "fsync";
268        let args = vec![
269            ("inode", inode.to_string()),
270            ("fh", fh.to_string()),
271            ("datasync", datasync.to_string()),
272        ];
273        self.log_start(&req, id, method, &args);
274        let result = self.inner.fsync(req, inode, fh, datasync).await;
275        self.log_result(id, method, &result);
276        result
277    }
278
279    async fn setxattr(
280        &self,
281        req: Request,
282        inode: Inode,
283        name: &OsStr,
284        value: &[u8],
285        flags: u32,
286        position: u32,
287    ) -> Result<()> {
288        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
289        let method = "setxattr";
290        let args = vec![
291            ("inode", inode.to_string()),
292            ("name", name.to_string_lossy().into_owned()),
293            ("value_len", value.len().to_string()),
294            ("flags", flags.to_string()),
295            ("position", position.to_string()),
296        ];
297        self.log_start(&req, id, method, &args);
298        let result = self
299            .inner
300            .setxattr(req, inode, name, value, flags, position)
301            .await;
302        self.log_result(id, method, &result);
303        result
304    }
305
306    async fn rename2(
307        &self,
308        req: Request,
309        parent: Inode,
310        name: &OsStr,
311        new_parent: Inode,
312        new_name: &OsStr,
313        flags: u32,
314    ) -> Result<()> {
315        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
316        let method = "rename2";
317        let args = vec![
318            ("parent", parent.to_string()),
319            ("name", name.to_string_lossy().into_owned()),
320            ("new_parent", new_parent.to_string()),
321            ("new_name", new_name.to_string_lossy().into_owned()),
322            ("flags", flags.to_string()),
323        ];
324        self.log_start(&req, id, method, &args);
325        let result = self
326            .inner
327            .rename2(req, parent, name, new_parent, new_name, flags)
328            .await;
329        self.log_result(id, method, &result);
330        result
331    }
332
333    async fn unlink(&self, req: Request, parent: Inode, name: &OsStr) -> Result<()> {
334        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
335        let method = "unlink";
336        let args = vec![
337            ("parent", parent.to_string()),
338            ("name", name.to_string_lossy().into_owned()),
339        ];
340        self.log_start(&req, id, method, &args);
341        let re = self.inner.unlink(req, parent, name).await;
342        self.log_result(id, method, &re);
343        re
344    }
345
346    async fn mkdir(
347        &self,
348        req: Request,
349        parent: rfuse3::Inode,
350        name: &OsStr,
351        mode: u32,
352        umask: u32,
353    ) -> Result<ReplyEntry> {
354        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
355        let method = "mkdir";
356        let args = vec![
357            ("parent", parent.to_string()),
358            ("name", name.to_string_lossy().into_owned()),
359            ("mode", mode.to_string()),
360            ("umask", umask.to_string()),
361        ];
362        self.log_start(&req, id, method, &args);
363        let result = self.inner.mkdir(req, parent, name, mode, umask).await;
364        self.log_result(id, method, &result);
365        result
366    }
367
368    async fn access(&self, req: Request, inode: rfuse3::Inode, mask: u32) -> Result<()> {
369        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
370        let method = "access";
371        let args = vec![("inode", inode.to_string()), ("mask", mask.to_string())];
372        self.log_start(&req, id, method, &args);
373        let result = self.inner.access(req, inode, mask).await;
374        self.log_result(id, method, &result);
375        result
376    }
377
378    async fn getxattr(
379        &self,
380        req: Request,
381        inode: rfuse3::Inode,
382        name: &OsStr,
383        size: u32,
384    ) -> Result<ReplyXAttr> {
385        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
386        let method = "getxattr";
387        let args = vec![
388            ("inode", inode.to_string()),
389            ("name", name.to_string_lossy().into_owned()),
390            ("size", size.to_string()),
391        ];
392        self.log_start(&req, id, method, &args);
393        let result = self.inner.getxattr(req, inode, name, size).await;
394        self.log_result(id, method, &result);
395        result
396    }
397
398    async fn create(
399        &self,
400        req: Request,
401        parent: rfuse3::Inode,
402        name: &OsStr,
403        mode: u32,
404        flags: u32,
405    ) -> Result<ReplyCreated> {
406        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
407        let method = "create";
408        let args = vec![
409            ("parent", parent.to_string()),
410            ("name", name.to_string_lossy().into_owned()),
411            ("mode", mode.to_string()),
412            ("flags", flags.to_string()),
413        ];
414        self.log_start(&req, id, method, &args);
415        let result = self.inner.create(req, parent, name, mode, flags).await;
416        self.log_result(id, method, &result);
417        result
418    }
419
420    async fn lseek(
421        &self,
422        req: Request,
423        inode: rfuse3::Inode,
424        fh: u64,
425        offset: u64,
426        whence: u32,
427    ) -> Result<ReplyLSeek> {
428        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
429        let method = "lseek";
430        let args = vec![
431            ("inode", inode.to_string()),
432            ("fh", fh.to_string()),
433            ("offset", offset.to_string()),
434            ("whence", whence.to_string()),
435        ];
436        self.log_start(&req, id, method, &args);
437        let result = self.inner.lseek(req, inode, fh, offset, whence).await;
438        self.log_result(id, method, &result);
439        result
440    }
441
442    async fn mknod(
443        &self,
444        req: Request,
445        parent: rfuse3::Inode,
446        name: &OsStr,
447        mode: u32,
448        rdev: u32,
449    ) -> Result<ReplyEntry> {
450        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
451        let method = "mknod";
452        let args = vec![
453            ("parent", parent.to_string()),
454            ("name", name.to_string_lossy().into_owned()),
455            ("mode", mode.to_string()),
456            ("rdev", rdev.to_string()),
457        ];
458        self.log_start(&req, id, method, &args);
459        let result = self.inner.mknod(req, parent, name, mode, rdev).await;
460        self.log_result(id, method, &result);
461        result
462    }
463
464    async fn rename(
465        &self,
466        req: Request,
467        parent: rfuse3::Inode,
468        name: &OsStr,
469        new_parent: rfuse3::Inode,
470        new_name: &OsStr,
471    ) -> Result<()> {
472        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
473        let method = "rename";
474        let args = vec![
475            ("parent", parent.to_string()),
476            ("name", name.to_string_lossy().into_owned()),
477            ("new_parent", new_parent.to_string()),
478            ("new_name", new_name.to_string_lossy().into_owned()),
479        ];
480        self.log_start(&req, id, method, &args);
481        let result = self
482            .inner
483            .rename(req, parent, name, new_parent, new_name)
484            .await;
485        self.log_result(id, method, &result);
486        result
487    }
488    async fn listxattr(&self, req: Request, inode: rfuse3::Inode, size: u32) -> Result<ReplyXAttr> {
489        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
490        let method = "listxattr";
491        let args = vec![("inode", inode.to_string()), ("size", size.to_string())];
492        self.log_start(&req, id, method, &args);
493        let result = self.inner.listxattr(req, inode, size).await;
494        self.log_result(id, method, &result);
495        result
496    }
497
498    async fn open(&self, req: Request, inode: rfuse3::Inode, flags: u32) -> Result<ReplyOpen> {
499        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
500        let method = "open";
501        let args = vec![("inode", inode.to_string()), ("flags", flags.to_string())];
502        self.log_start(&req, id, method, &args);
503        let result = self.inner.open(req, inode, flags).await;
504        if let Ok(ref reply) = result {
505            debug!(
506                "ID: {} [{}] {} - Obtained fh: {}",
507                id, self.fsname, method, reply.fh
508            );
509        }
510        self.log_result(id, method, &result);
511        result
512    }
513
514    async fn rmdir(&self, req: Request, parent: rfuse3::Inode, name: &OsStr) -> Result<()> {
515        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
516        let method = "rmdir";
517        let args = vec![
518            ("parent", parent.to_string()),
519            ("name", name.to_string_lossy().into_owned()),
520        ];
521        self.log_start(&req, id, method, &args);
522        let result = self.inner.rmdir(req, parent, name).await;
523        self.log_result(id, method, &result);
524        result
525    }
526
527    async fn statfs(&self, req: Request, inode: rfuse3::Inode) -> Result<ReplyStatFs> {
528        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
529        let method = "statfs";
530        let args = vec![("inode", inode.to_string())];
531        self.log_start(&req, id, method, &args);
532        let result = self.inner.statfs(req, inode).await;
533        self.log_result(id, method, &result);
534        result
535    }
536
537    async fn link(
538        &self,
539        req: Request,
540        inode: rfuse3::Inode,
541        new_parent: rfuse3::Inode,
542        new_name: &OsStr,
543    ) -> Result<ReplyEntry> {
544        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
545        let method = "link";
546        let args = vec![
547            ("inode", inode.to_string()),
548            ("new_parent", new_parent.to_string()),
549            ("new_name", new_name.to_string_lossy().into_owned()),
550        ];
551        self.log_start(&req, id, method, &args);
552        let result = self.inner.link(req, inode, new_parent, new_name).await;
553        self.log_result(id, method, &result);
554        result
555    }
556
557    async fn symlink(
558        &self,
559        req: Request,
560        parent: rfuse3::Inode,
561        name: &OsStr,
562        link: &OsStr,
563    ) -> Result<ReplyEntry> {
564        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
565        let method = "symlink";
566        let args = vec![
567            ("parent", parent.to_string()),
568            ("name", name.to_string_lossy().into_owned()),
569            ("link", link.to_string_lossy().into_owned()),
570        ];
571        self.log_start(&req, id, method, &args);
572        let result = self.inner.symlink(req, parent, name, link).await;
573        self.log_result(id, method, &result);
574        result
575    }
576
577    async fn batch_forget(&self, req: Request, inodes: &[(Inode, u64)]) {
578        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
579        let method = "batch_forget";
580        let args = vec![(
581            "inodes",
582            inodes
583                .iter()
584                .map(|inode| inode.0.to_string())
585                .collect::<Vec<_>>()
586                .join(", "),
587        )];
588        self.log_start(&req, id, method, &args);
589        self.inner.batch_forget(req, inodes).await;
590        self.log_result(id, method, &Ok(""));
591    }
592
593    async fn bmap(
594        &self,
595        req: Request,
596        inode: rfuse3::Inode,
597        blocksize: u32,
598        idx: u64,
599    ) -> Result<ReplyBmap> {
600        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
601        let method = "bmap";
602        let args = vec![
603            ("inode", inode.to_string()),
604            ("blocksize", blocksize.to_string()),
605            ("idx", idx.to_string()),
606        ];
607        self.log_start(&req, id, method, &args);
608        let result = self.inner.bmap(req, inode, blocksize, idx).await;
609        self.log_result(id, method, &result);
610        result
611    }
612
613    async fn copy_file_range(
614        &self,
615        req: Request,
616        inode: rfuse3::Inode,
617        fh_in: u64,
618        off_in: u64,
619        inode_out: rfuse3::Inode,
620        fh_out: u64,
621        off_out: u64,
622        length: u64,
623        flags: u64,
624    ) -> Result<ReplyCopyFileRange> {
625        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
626        let method = "copy_file_range";
627        let args = vec![
628            ("inode", inode.to_string()),
629            ("fh_in", fh_in.to_string()),
630            ("off_in", off_in.to_string()),
631            ("inode_out", inode_out.to_string()),
632            ("fh_out", fh_out.to_string()),
633            ("off_out", off_out.to_string()),
634            ("length", length.to_string()),
635            ("flags", flags.to_string()),
636        ];
637        self.log_start(&req, id, method, &args);
638        let result = self
639            .inner
640            .copy_file_range(
641                req, inode, fh_in, off_in, inode_out, fh_out, off_out, length, flags,
642            )
643            .await;
644        self.log_result(id, method, &result);
645        result
646    }
647
648    async fn fallocate(
649        &self,
650        req: Request,
651        inode: rfuse3::Inode,
652        fh: u64,
653        offset: u64,
654        length: u64,
655        mode: u32,
656    ) -> Result<()> {
657        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
658        let method = "fallocate";
659        let args = vec![
660            ("inode", inode.to_string()),
661            ("fh", fh.to_string()),
662            ("offset", offset.to_string()),
663            ("length", length.to_string()),
664            ("mode", mode.to_string()),
665        ];
666        self.log_start(&req, id, method, &args);
667        let result = self
668            .inner
669            .fallocate(req, inode, fh, offset, length, mode)
670            .await;
671        self.log_result(id, method, &result);
672        result
673    }
674
675    async fn flush(
676        &self,
677        req: Request,
678        inode: rfuse3::Inode,
679        fh: u64,
680        lock_owner: u64,
681    ) -> Result<()> {
682        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
683        let method = "flush";
684        let args = vec![
685            ("inode", inode.to_string()),
686            ("fh", fh.to_string()),
687            ("lock_owner", lock_owner.to_string()),
688        ];
689        self.log_start(&req, id, method, &args);
690        let result = self.inner.flush(req, inode, fh, lock_owner).await;
691        self.log_result(id, method, &result);
692        result
693    }
694
695    async fn fsyncdir(
696        &self,
697        req: Request,
698        inode: rfuse3::Inode,
699        fh: u64,
700        datasync: bool,
701    ) -> Result<()> {
702        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
703        let method = "fsyncdir";
704        let args = vec![
705            ("inode", inode.to_string()),
706            ("fh", fh.to_string()),
707            ("datasync", datasync.to_string()),
708        ];
709        self.log_start(&req, id, method, &args);
710        let result = self.inner.fsyncdir(req, inode, fh, datasync).await;
711        self.log_result(id, method, &result);
712        result
713    }
714
715    // async  fn interrupt(&self, req: Request, unique: u64) -> Result<()> {
716    //     let uuid = Uuid::new_v4();
717    //     let method = "interrupt";
718    //     let args = vec![
719    //         ("unique", unique.to_string())
720    //     ];
721    //     self.log_start(&req,&uuid, method, &args);
722    //     let result = self.inner.interrupt(req, unique).await;
723    //     self.log_result(&uuid, method, &result);
724    //     result
725    // }
726
727    async fn notify_reply(
728        &self,
729        req: Request,
730        inode: rfuse3::Inode,
731        offset: u64,
732        data: Bytes,
733    ) -> Result<()> {
734        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
735        let method = "notify_reply";
736        let args = vec![("inode", inode.to_string()), ("offset", offset.to_string())];
737        self.log_start(&req, id, method, &args);
738        let result = self.inner.notify_reply(req, inode, offset, data).await;
739        self.log_result(id, method, &result);
740        result
741    }
742
743    async fn poll(
744        &self,
745        req: Request,
746        inode: rfuse3::Inode,
747        fh: u64,
748        kh: Option<u64>,
749        flags: u32,
750        events: u32,
751        notify: &Notify,
752    ) -> Result<ReplyPoll> {
753        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
754        let method = "poll";
755        let args = vec![
756            ("inode", inode.to_string()),
757            ("fh", fh.to_string()),
758            ("flags", flags.to_string()),
759            ("events", events.to_string()),
760        ];
761        self.log_start(&req, id, method, &args);
762        let result = self
763            .inner
764            .poll(req, inode, fh, kh, flags, events, notify)
765            .await;
766        self.log_result(id, method, &result);
767        result
768    }
769
770    async fn readlink(&self, req: Request, inode: rfuse3::Inode) -> Result<ReplyData> {
771        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
772        let method = "readlink";
773        let args = vec![("inode", inode.to_string())];
774        self.log_start(&req, id, method, &args);
775        let result = self.inner.readlink(req, inode).await;
776        self.log_result(id, method, &result);
777        result
778    }
779
780    async fn release(
781        &self,
782        req: Request,
783        inode: rfuse3::Inode,
784        fh: u64,
785        flags: u32,
786        lock_owner: u64,
787        flush: bool,
788    ) -> Result<()> {
789        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
790        let method = "release";
791        let args = vec![
792            ("inode", inode.to_string()),
793            ("fh", fh.to_string()),
794            ("flags", flags.to_string()),
795            ("lock_owner", lock_owner.to_string()),
796            ("flush", flush.to_string()),
797        ];
798        self.log_start(&req, id, method, &args);
799        let result = self
800            .inner
801            .release(req, inode, fh, flags, lock_owner, flush)
802            .await;
803        self.log_result(id, method, &result);
804        result
805    }
806
807    async fn releasedir(
808        &self,
809        req: Request,
810        inode: rfuse3::Inode,
811        fh: u64,
812        flags: u32,
813    ) -> Result<()> {
814        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
815        let method = "releasedir";
816        let args = vec![
817            ("inode", inode.to_string()),
818            ("fh", fh.to_string()),
819            ("flags", flags.to_string()),
820        ];
821        self.log_start(&req, id, method, &args);
822        let result = self.inner.releasedir(req, inode, fh, flags).await;
823        self.log_result(id, method, &result);
824        result
825    }
826
827    async fn removexattr(&self, req: Request, inode: rfuse3::Inode, name: &OsStr) -> Result<()> {
828        let id = self.next_log_id.fetch_add(1, Ordering::Relaxed);
829        let method = "removexattr";
830        let args = vec![
831            ("inode", inode.to_string()),
832            ("name", name.to_string_lossy().to_string()),
833        ];
834        self.log_start(&req, id, method, &args);
835        let result = self.inner.removexattr(req, inode, name).await;
836        self.log_result(id, method, &result);
837        result
838    }
839}
libfuse_fs/passthrough/newlogfs.rs

libfuse_fs/passthrough/
newlogfs.rs
