polyfuse_kernel/
lib.rs

1//! FUSE application binary interface for `polyfuse`.
2//!
3//! The binding is compatible with ABI 7.31 (in libfuse 3.10.1).
4
5#![allow(nonstandard_style, clippy::identity_op)]
6
7use std::convert::TryFrom;
8use std::error;
9use std::fmt;
10use zerocopy::AsBytes;
11use zerocopy::FromBytes;
12
13/// The major version number of FUSE protocol.
14pub const FUSE_KERNEL_VERSION: u32 = 7;
15
16/// The minor version number of FUSE protocol.
17pub const FUSE_KERNEL_MINOR_VERSION: u32 = 31;
18
19/// The minimum length of read buffer.
20pub const FUSE_MIN_READ_BUFFER: u32 = 8192;
21
22/// Maximum of in_iovecs + out_iovecs
23pub const FUSE_IOCTL_MAX_IOV: u32 = 256;
24
25// Bitmasks for fuse_setattr_in.valid
26pub const FATTR_MODE: u32 = 1 << 0;
27pub const FATTR_UID: u32 = 1 << 1;
28pub const FATTR_GID: u32 = 1 << 2;
29pub const FATTR_SIZE: u32 = 1 << 3;
30pub const FATTR_ATIME: u32 = 1 << 4;
31pub const FATTR_MTIME: u32 = 1 << 5;
32pub const FATTR_FH: u32 = 1 << 6;
33pub const FATTR_ATIME_NOW: u32 = 1 << 7;
34pub const FATTR_MTIME_NOW: u32 = 1 << 8;
35pub const FATTR_LOCKOWNER: u32 = 1 << 9;
36pub const FATTR_CTIME: u32 = 1 << 10;
37
38// Flags returned by the OPEN request.
39pub const FOPEN_DIRECT_IO: u32 = 1 << 0;
40pub const FOPEN_KEEP_CACHE: u32 = 1 << 1;
41pub const FOPEN_NONSEEKABLE: u32 = 1 << 2;
42pub const FOPEN_CACHE_DIR: u32 = 1 << 3;
43pub const FOPEN_STREAM: u32 = 1 << 4;
44
45// INIT request/reply flags.
46pub const FUSE_ASYNC_READ: u32 = 1;
47pub const FUSE_POSIX_LOCKS: u32 = 1 << 1;
48pub const FUSE_FILE_OPS: u32 = 1 << 2;
49pub const FUSE_ATOMIC_O_TRUNC: u32 = 1 << 3;
50pub const FUSE_EXPORT_SUPPORT: u32 = 1 << 4;
51pub const FUSE_BIG_WRITES: u32 = 1 << 5;
52pub const FUSE_DONT_MASK: u32 = 1 << 6;
53pub const FUSE_SPLICE_WRITE: u32 = 1 << 7;
54pub const FUSE_SPLICE_MOVE: u32 = 1 << 8;
55pub const FUSE_SPLICE_READ: u32 = 1 << 9;
56pub const FUSE_FLOCK_LOCKS: u32 = 1 << 10;
57pub const FUSE_HAS_IOCTL_DIR: u32 = 1 << 11;
58pub const FUSE_AUTO_INVAL_DATA: u32 = 1 << 12;
59pub const FUSE_DO_READDIRPLUS: u32 = 1 << 13;
60pub const FUSE_READDIRPLUS_AUTO: u32 = 1 << 14;
61pub const FUSE_ASYNC_DIO: u32 = 1 << 15;
62pub const FUSE_WRITEBACK_CACHE: u32 = 1 << 16;
63pub const FUSE_NO_OPEN_SUPPORT: u32 = 1 << 17;
64pub const FUSE_PARALLEL_DIROPS: u32 = 1 << 18;
65pub const FUSE_HANDLE_KILLPRIV: u32 = 1 << 19;
66pub const FUSE_POSIX_ACL: u32 = 1 << 20;
67pub const FUSE_ABORT_ERROR: u32 = 1 << 21;
68pub const FUSE_MAX_PAGES: u32 = 1 << 22;
69pub const FUSE_CACHE_SYMLINKS: u32 = 1 << 23;
70pub const FUSE_NO_OPENDIR_SUPPORT: u32 = 1 << 24;
71pub const FUSE_EXPLICIT_INVAL_DATA: u32 = 1 << 25;
72
73// CUSE INIT request/reply flags.
74pub const CUSE_UNRESTRICTED_IOCTL: u32 = 1 << 0;
75
76// Release flags.
77pub const FUSE_RELEASE_FLUSH: u32 = 1 << 0;
78pub const FUSE_RELEASE_FLOCK_UNLOCK: u32 = 1 << 1;
79
80// Getattr flags.
81pub const FUSE_GETATTR_FH: u32 = 1;
82
83// Lock flags.
84pub const FUSE_LK_FLOCK: u32 = 1 << 0;
85
86// WRITE flags.
87pub const FUSE_WRITE_CACHE: u32 = 1 << 0;
88pub const FUSE_WRITE_LOCKOWNER: u32 = 1 << 1;
89pub const FUSE_WRITE_KILL_PRIV: u32 = 1 << 2;
90
91// Read flags.
92pub const FUSE_READ_LOCKOWNER: u32 = 1 << 1;
93
94// Ioctl flags.
95pub const FUSE_IOCTL_COMPAT: u32 = 1 << 0;
96pub const FUSE_IOCTL_UNRESTRICTED: u32 = 1 << 1;
97pub const FUSE_IOCTL_RETRY: u32 = 1 << 2;
98pub const FUSE_IOCTL_32BIT: u32 = 1 << 3;
99pub const FUSE_IOCTL_DIR: u32 = 1 << 4;
100pub const FUSE_IOCTL_COMPAT_X32: u32 = 1 << 5;
101
102// Poll flags.
103pub const FUSE_POLL_SCHEDULE_NOTIFY: u32 = 1 << 0;
104
105// Fsync flags.
106pub const FUSE_FSYNC_FDATASYNC: u32 = 1 << 0;
107
108// misc
109pub const FUSE_COMPAT_ENTRY_OUT_SIZE: usize = 120;
110pub const FUSE_COMPAT_ATTR_OUT_SIZE: usize = 96;
111pub const FUSE_COMPAT_MKNOD_IN_SIZE: usize = 8;
112pub const FUSE_COMPAT_WRITE_IN_SIZE: usize = 24;
113pub const FUSE_COMPAT_STATFS_SIZE: usize = 48;
114pub const FUSE_COMPAT_INIT_OUT_SIZE: usize = 8;
115pub const FUSE_COMPAT_22_INIT_OUT_SIZE: usize = 24;
116pub const CUSE_INIT_INFO_MAX: u32 = 4096;
117
118#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
119#[repr(C)]
120pub struct fuse_attr {
121    pub ino: u64,
122    pub size: u64,
123    pub blocks: u64,
124    pub atime: u64,
125    pub mtime: u64,
126    pub ctime: u64,
127    pub atimensec: u32,
128    pub mtimensec: u32,
129    pub ctimensec: u32,
130    pub mode: u32,
131    pub nlink: u32,
132    pub uid: u32,
133    pub gid: u32,
134    pub rdev: u32,
135    pub blksize: u32,
136    pub padding: u32,
137}
138
139#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
140#[repr(C)]
141pub struct fuse_dirent {
142    pub ino: u64,
143    pub off: u64,
144    pub namelen: u32,
145    pub typ: u32,
146    pub name: [u8; 0],
147}
148
149#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
150#[repr(C)]
151pub struct fuse_direntplus {
152    pub entry_out: fuse_entry_out,
153    pub dirent: fuse_dirent,
154}
155
156#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
157#[repr(C)]
158pub struct fuse_kstatfs {
159    pub blocks: u64,
160    pub bfree: u64,
161    pub bavail: u64,
162    pub files: u64,
163    pub ffree: u64,
164    pub bsize: u32,
165    pub namelen: u32,
166    pub frsize: u32,
167    pub padding: u32,
168    pub spare: [u32; 6usize],
169}
170
171#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
172#[repr(C)]
173pub struct fuse_file_lock {
174    pub start: u64,
175    pub end: u64,
176    pub typ: u32,
177    pub pid: u32,
178}
179
180macro_rules! define_opcode {
181    ($(
182        $(#[$m:meta])*
183        $VARIANT:ident = $val:expr,
184    )*) => {
185        $(
186            #[doc(hidden)]
187            pub const $VARIANT: u32 = $val;
188        )*
189
190        #[derive(Clone, Copy, Hash, PartialEq)]
191        #[repr(u32)]
192        pub enum fuse_opcode {
193            $(
194                $(#[$m])*
195                $VARIANT = self::$VARIANT,
196            )*
197        }
198
199        impl TryFrom<u32> for fuse_opcode {
200            type Error = UnknownOpcode;
201
202            fn try_from(opcode: u32) -> Result<Self, Self::Error> {
203                match opcode {
204                    $(
205                        $val => Ok(Self::$VARIANT),
206                    )*
207                    opcode => Err(UnknownOpcode(opcode)),
208                }
209            }
210        }
211    };
212}
213
214define_opcode! {
215    FUSE_LOOKUP = 1,
216    FUSE_FORGET = 2,
217    FUSE_GETATTR = 3,
218    FUSE_SETATTR = 4,
219    FUSE_READLINK = 5,
220    FUSE_SYMLINK = 6,
221    // _ = 7,
222    FUSE_MKNOD = 8,
223    FUSE_MKDIR = 9,
224    FUSE_UNLINK = 10,
225    FUSE_RMDIR = 11,
226    FUSE_RENAME = 12,
227    FUSE_LINK = 13,
228    FUSE_OPEN = 14,
229    FUSE_READ = 15,
230    FUSE_WRITE = 16,
231    FUSE_STATFS = 17,
232    FUSE_RELEASE = 18,
233    // _ = 19,
234    FUSE_FSYNC = 20,
235    FUSE_SETXATTR = 21,
236    FUSE_GETXATTR = 22,
237    FUSE_LISTXATTR = 23,
238    FUSE_REMOVEXATTR = 24,
239    FUSE_FLUSH = 25,
240    FUSE_INIT = 26,
241    FUSE_OPENDIR = 27,
242    FUSE_READDIR = 28,
243    FUSE_RELEASEDIR = 29,
244    FUSE_FSYNCDIR = 30,
245    FUSE_GETLK = 31,
246    FUSE_SETLK = 32,
247    FUSE_SETLKW = 33,
248    FUSE_ACCESS = 34,
249    FUSE_CREATE = 35,
250    FUSE_INTERRUPT = 36,
251    FUSE_BMAP = 37,
252    FUSE_DESTROY = 38,
253    FUSE_IOCTL = 39,
254    FUSE_POLL = 40,
255    FUSE_NOTIFY_REPLY = 41,
256    FUSE_BATCH_FORGET = 42,
257    FUSE_FALLOCATE = 43,
258    FUSE_READDIRPLUS = 44,
259    FUSE_RENAME2 = 45,
260    FUSE_LSEEK = 46,
261    FUSE_COPY_FILE_RANGE = 47,
262
263    CUSE_INIT = 4096,
264}
265
266#[doc(hidden)]
267#[derive(Debug)]
268pub struct UnknownOpcode(u32);
269
270impl fmt::Display for UnknownOpcode {
271    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
272        write!(f, "unknown opcode: {}", self.0)
273    }
274}
275
276impl error::Error for UnknownOpcode {}
277
278#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
279#[repr(C)]
280pub struct fuse_in_header {
281    pub len: u32,
282    pub opcode: u32,
283    pub unique: u64,
284    pub nodeid: u64,
285    pub uid: u32,
286    pub gid: u32,
287    pub pid: u32,
288    pub padding: u32,
289}
290
291#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
292#[repr(C)]
293pub struct fuse_init_in {
294    pub major: u32,
295    pub minor: u32,
296    pub max_readahead: u32,
297    pub flags: u32,
298}
299
300#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
301#[repr(C)]
302pub struct fuse_forget_in {
303    pub nlookup: u64,
304}
305
306#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
307#[repr(C)]
308pub struct fuse_getattr_in {
309    pub getattr_flags: u32,
310    pub dummy: u32,
311    pub fh: u64,
312}
313
314#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
315#[repr(C)]
316pub struct fuse_setattr_in {
317    pub valid: u32,
318    pub padding: u32,
319    pub fh: u64,
320    pub size: u64,
321    pub lock_owner: u64,
322    pub atime: u64,
323    pub mtime: u64,
324    pub ctime: u64,
325    pub atimensec: u32,
326    pub mtimensec: u32,
327    pub ctimensec: u32,
328    pub mode: u32,
329    pub unused4: u32,
330    pub uid: u32,
331    pub gid: u32,
332    pub unused5: u32,
333}
334
335#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
336#[repr(C)]
337pub struct fuse_mknod_in {
338    pub mode: u32,
339    pub rdev: u32,
340    pub umask: u32,
341    pub padding: u32,
342}
343
344#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
345#[repr(C)]
346pub struct fuse_mkdir_in {
347    pub mode: u32,
348    pub umask: u32,
349}
350
351#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
352#[repr(C)]
353pub struct fuse_rename_in {
354    pub newdir: u64,
355}
356
357#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
358#[repr(C)]
359pub struct fuse_link_in {
360    pub oldnodeid: u64,
361}
362
363#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
364#[repr(C)]
365pub struct fuse_open_in {
366    pub flags: u32,
367    pub unused: u32,
368}
369
370#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
371#[repr(C)]
372pub struct fuse_read_in {
373    pub fh: u64,
374    pub offset: u64,
375    pub size: u32,
376    pub read_flags: u32,
377    pub lock_owner: u64,
378    pub flags: u32,
379    pub padding: u32,
380}
381
382#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
383#[repr(C)]
384pub struct fuse_write_in {
385    pub fh: u64,
386    pub offset: u64,
387    pub size: u32,
388    pub write_flags: u32,
389    pub lock_owner: u64,
390    pub flags: u32,
391    pub padding: u32,
392}
393
394#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
395#[repr(C)]
396pub struct fuse_flush_in {
397    pub fh: u64,
398    pub unused: u32,
399    pub padding: u32,
400    pub lock_owner: u64,
401}
402
403#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
404#[repr(C)]
405pub struct fuse_release_in {
406    pub fh: u64,
407    pub flags: u32,
408    pub release_flags: u32,
409    pub lock_owner: u64,
410}
411
412#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
413#[repr(C)]
414pub struct fuse_fsync_in {
415    pub fh: u64,
416    pub fsync_flags: u32,
417    pub padding: u32,
418}
419
420#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
421#[repr(C)]
422pub struct fuse_getxattr_in {
423    pub size: u32,
424    pub padding: u32,
425}
426
427#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
428#[repr(C)]
429pub struct fuse_setxattr_in {
430    pub size: u32,
431    pub flags: u32,
432}
433
434#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
435#[repr(C)]
436pub struct fuse_lk_in {
437    pub fh: u64,
438    pub owner: u64,
439    pub lk: fuse_file_lock,
440    pub lk_flags: u32,
441    pub padding: u32,
442}
443
444#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
445#[repr(C)]
446pub struct fuse_access_in {
447    pub mask: u32,
448    pub padding: u32,
449}
450
451#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
452#[repr(C)]
453pub struct fuse_create_in {
454    pub flags: u32,
455    pub mode: u32,
456    pub umask: u32,
457    pub padding: u32,
458}
459
460#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
461#[repr(C)]
462pub struct fuse_bmap_in {
463    pub block: u64,
464    pub blocksize: u32,
465    pub padding: u32,
466}
467
468#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
469#[repr(C)]
470pub struct fuse_out_header {
471    pub len: u32,
472    pub error: i32,
473    pub unique: u64,
474}
475
476#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
477#[repr(C)]
478pub struct fuse_attr_out {
479    pub attr_valid: u64,
480    pub attr_valid_nsec: u32,
481    pub dummy: u32,
482    pub attr: fuse_attr,
483}
484
485#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
486#[repr(C)]
487pub struct fuse_entry_out {
488    pub nodeid: u64,
489    pub generation: u64,
490    pub entry_valid: u64,
491    pub attr_valid: u64,
492    pub entry_valid_nsec: u32,
493    pub attr_valid_nsec: u32,
494    pub attr: fuse_attr,
495}
496
497#[derive(Clone, Copy, FromBytes, AsBytes)]
498#[repr(C)]
499pub struct fuse_init_out {
500    pub major: u32,
501    pub minor: u32,
502    pub max_readahead: u32,
503    pub flags: u32,
504    pub max_background: u16,
505    pub congestion_threshold: u16,
506    pub max_write: u32,
507    pub time_gran: u32,
508    pub max_pages: u16,
509    pub padding: u16,
510    pub unused: [u32; 8],
511}
512
513impl Default for fuse_init_out {
514    fn default() -> Self {
515        Self {
516            major: FUSE_KERNEL_VERSION,
517            minor: FUSE_KERNEL_MINOR_VERSION,
518            max_readahead: 0,
519            flags: 0,
520            max_background: 0,
521            congestion_threshold: 0,
522            max_write: 0,
523            time_gran: 0,
524            max_pages: 0,
525            padding: 0,
526            unused: [0; 8],
527        }
528    }
529}
530
531#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
532#[repr(C)]
533pub struct fuse_getxattr_out {
534    pub size: u32,
535    pub padding: u32,
536}
537
538#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
539#[repr(C)]
540pub struct fuse_open_out {
541    pub fh: u64,
542    pub open_flags: u32,
543    pub padding: u32,
544}
545
546#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
547#[repr(C)]
548pub struct fuse_write_out {
549    pub size: u32,
550    pub padding: u32,
551}
552
553#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
554#[repr(C)]
555pub struct fuse_statfs_out {
556    pub st: fuse_kstatfs,
557}
558
559#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
560#[repr(C)]
561pub struct fuse_lk_out {
562    pub lk: fuse_file_lock,
563}
564
565#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
566#[repr(C)]
567pub struct fuse_bmap_out {
568    pub block: u64,
569}
570
571#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
572#[repr(C)]
573pub struct fuse_ioctl_in {
574    pub fh: u64,
575    pub flags: u32,
576    pub cmd: u32,
577    pub arg: u64,
578    pub in_size: u32,
579    pub out_size: u32,
580}
581
582#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
583#[repr(C)]
584pub struct fuse_ioctl_out {
585    pub result: i32,
586    pub flags: u32,
587    pub in_iovs: u32,
588    pub out_iovs: u32,
589}
590
591#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
592#[repr(C)]
593pub struct fuse_ioctl_iovec {
594    pub base: u64,
595    pub len: u64,
596}
597
598#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
599#[repr(C)]
600pub struct fuse_poll_in {
601    pub fh: u64,
602    pub kh: u64,
603    pub flags: u32,
604    pub events: u32,
605}
606
607#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
608#[repr(C)]
609pub struct fuse_poll_out {
610    pub revents: u32,
611    pub padding: u32,
612}
613
614#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
615#[repr(C)]
616pub struct fuse_interrupt_in {
617    pub unique: u64,
618}
619
620#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
621#[repr(C)]
622pub struct fuse_fallocate_in {
623    pub fh: u64,
624    pub offset: u64,
625    pub length: u64,
626    pub mode: u32,
627    pub padding: u32,
628}
629
630#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
631#[repr(C)]
632pub struct fuse_batch_forget_in {
633    pub count: u32,
634    pub dummy: u32,
635}
636
637#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
638#[repr(C)]
639pub struct fuse_forget_one {
640    pub nodeid: u64,
641    pub nlookup: u64,
642}
643
644#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
645#[repr(C)]
646pub struct fuse_rename2_in {
647    pub newdir: u64,
648    pub flags: u32,
649    pub padding: u32,
650}
651
652#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
653#[repr(C)]
654pub struct fuse_lseek_in {
655    pub fh: u64,
656    pub offset: u64,
657    pub whence: u32,
658    pub padding: u32,
659}
660
661#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
662#[repr(C)]
663pub struct fuse_lseek_out {
664    pub offset: u64,
665}
666
667#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
668#[repr(C)]
669pub struct fuse_copy_file_range_in {
670    pub fh_in: u64,
671    pub off_in: u64,
672    pub nodeid_out: u64,
673    pub fh_out: u64,
674    pub off_out: u64,
675    pub len: u64,
676    pub flags: u64,
677}
678
679macro_rules! define_notify_code {
680    ($(
681        $(#[$m:meta])*
682        $VARIANT:ident = $val:expr,
683    )*) => {
684        $(
685            #[doc(hidden)]
686            pub const $VARIANT: u32 = $val;
687        )*
688
689        #[derive(Clone, Copy, PartialEq, Hash)]
690        #[repr(u32)]
691        pub enum fuse_notify_code {
692            $(
693                $(#[$m])*
694                $VARIANT = self::$VARIANT,
695            )*
696        }
697    };
698}
699
700define_notify_code! {
701    FUSE_NOTIFY_POLL = 1,
702    FUSE_NOTIFY_INVAL_INODE = 2,
703    FUSE_NOTIFY_INVAL_ENTRY = 3,
704    FUSE_NOTIFY_STORE = 4,
705    FUSE_NOTIFY_RETRIEVE = 5,
706    FUSE_NOTIFY_DELETE = 6,
707}
708
709#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
710#[repr(C)]
711pub struct fuse_notify_poll_wakeup_out {
712    pub kh: u64,
713}
714
715#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
716#[repr(C)]
717pub struct fuse_notify_inval_inode_out {
718    pub ino: u64,
719    pub off: i64,
720    pub len: i64,
721}
722
723#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
724#[repr(C)]
725pub struct fuse_notify_inval_entry_out {
726    pub parent: u64,
727    pub namelen: u32,
728    pub padding: u32,
729}
730
731#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
732#[repr(C)]
733pub struct fuse_notify_delete_out {
734    pub parent: u64,
735    pub child: u64,
736    pub namelen: u32,
737    pub padding: u32,
738}
739
740#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
741#[repr(C)]
742pub struct fuse_notify_store_out {
743    pub nodeid: u64,
744    pub offset: u64,
745    pub size: u32,
746    pub padding: u32,
747}
748
749#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
750#[repr(C)]
751pub struct fuse_notify_retrieve_out {
752    pub notify_unique: u64,
753    pub nodeid: u64,
754    pub offset: u64,
755    pub size: u32,
756    pub padding: u32,
757}
758
759#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
760#[repr(C)]
761pub struct fuse_notify_retrieve_in {
762    pub dummy1: u64,
763    pub offset: u64,
764    pub size: u32,
765    pub dummy2: u32,
766    pub dummy3: u64,
767    pub dummy4: u64,
768}
769
770#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
771#[repr(C)]
772pub struct cuse_init_in {
773    pub major: u32,
774    pub minor: u32,
775    pub unused: u32,
776    pub flags: u32,
777}
778
779#[derive(Clone, Copy, Default, FromBytes, AsBytes)]
780#[repr(C)]
781pub struct cuse_init_out {
782    pub major: u32,
783    pub minor: u32,
784    pub unused: u32,
785    pub flags: u32,
786    pub max_read: u32,
787    pub max_write: u32,
788    pub dev_major: u32,
789    pub dev_minor: u32,
790    pub spare: [u32; 10],
791}
polyfuse_kernel/lib.rs

polyfuse_kernel/
lib.rs
