Add syscall tracing to FuseFS

[rslota]

No description provided.

[rslota]

Reviews in this chain:
└#1 Add syscall tracing to FuseFS

[rslota]

#	head	base	diff	date	summary
0	657659bb	3bdbda5c	diff	Feb 19 12:01 PM	3 files changed, 285 insertions(+), 22 deletions(-)
1	0af1c438	3bdbda5c	diff	Feb 19 17:09 PM	1 file changed, 28 insertions(+), 62 deletions(-)

[erszcz]

32 bits for size seems a bit conservative... 4GiB is not that uncommon for file sizes nowadays, though probably would be a problem due to other reasons in the sandbox agent

[rslota]

I don't think it's possible to have single syscall with bigger size. I think FUSE is typed for u32 🤔 At least it is in this codebase

[erszcz]

We could probably get away without these extra allocations - after all, these strings have to exist somewhere already and we just want to "print" them.

---

The SyscallArgs variants currently allocate String for every trace event, but the data is already available as borrowed &str:

• path comes from self.path_for_inode(ino) → Option<&str> borrowed from the inode_to_node HashMap
• name comes from name.to_string_lossy() → Cow<'_, str> (zero-copy for valid UTF-8)

Since trace() serializes and sends immediately, the borrows just need to live through that call. Adding a lifetime to the types eliminates all heap allocations:

#[derive(Debug, Serialize)]
pub enum SyscallArgs<'a> {
    Lookup {
        parent: u64,
        name: &'a str,
        #[serde(skip_serializing_if = "Option::is_none")]
        parent_path: Option<&'a str>,
    },
    Getattr {
        ino: u64,
        fh: Option<u64>,
        #[serde(skip_serializing_if = "Option::is_none")]
        path: Option<&'a str>,
    },
    // ... same for all variants
}

#[derive(Debug, Serialize)]
pub struct SyscallEvent<'a> {
    pub syscall: &'static str,
    pub timestamp_ns: u128,
    #[serde(flatten)]
    pub args: SyscallArgs<'a>,
}

Then the convenience methods just pass the borrows through with no .to_string():

pub fn lookup(&self, parent: u64, name: &str, parent_path: Option<&str>) {
    self.trace("lookup", SyscallArgs::Lookup { parent, name, parent_path });
}

Zero heap allocations per trace event. The only allocation is the output JSON buffer in serde_json::to_vec, which is unavoidable.

[rslota]

Thanks, i've been living under a rock and never actually seen rust to this day, so a bit of learning like that helps ;)

[erszcz]

My pleasure 🎩😁