nfs4/
lib.rs

1// Copyright 2023 Remi Bernotavicius
2
3use bitflags::bitflags;
4use bitflags_serde_shim::impl_serde_for_bitflags;
5use derive_more::{From, TryInto};
6use enum_as_inner::EnumAsInner;
7pub use enum_map::{EnumMap, EnumSet, ToId};
8use num_enum::{IntoPrimitive, TryFromPrimitive};
9use serde::{
10    de::Deserializer,
11    ser::{SerializeStruct as _, Serializer},
12    Deserialize, Serialize,
13};
14use std::fmt;
15use sun_rpc::{AuthFlavor, AuthSysParameters};
16use xdr_extras::{DeserializeWithDiscriminant, SerializeWithDiscriminant};
17
18mod enum_map;
19
20pub type FileAttributes = EnumMap<FileAttributeId, FileAttribute>;
21
22#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
23pub struct CompoundArgs {
24    pub tag: String,
25    pub minor_version: u32,
26    pub arg_array: Vec<ArgOp>,
27}
28
29#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
30pub struct CompoundRes {
31    pub status: StatusResult<()>,
32    pub tag: String,
33    pub res_array: Vec<ResOp>,
34}
35
36bitflags! {
37    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
38    pub struct Access: u32 {
39        const READ      = 0x00000001;
40        const LOOKUP    = 0x00000002;
41        const MODIFY    = 0x00000004;
42        const EXTEND    = 0x00000008;
43        const DELETE    = 0x00000010;
44        const EXECUTE   = 0x00000020;
45    }
46}
47
48impl_serde_for_bitflags!(Access);
49
50#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
51pub struct AccessArgs {
52    pub access: Access,
53}
54
55#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
56pub struct StateId {
57    pub sequence_id: u32,
58    #[serde(with = "xdr_extras::array_as_struct")]
59    pub other: [u8; 12],
60}
61
62impl StateId {
63    pub fn anonymous() -> Self {
64        Self {
65            sequence_id: 0,
66            other: [0; 12],
67        }
68    }
69}
70
71#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
72pub struct SequenceId(pub u32);
73
74impl SequenceId {
75    pub fn incr(&mut self) {
76        self.0 += 1;
77    }
78}
79
80#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
81pub struct CloseArgs {
82    pub sequence_id: SequenceId,
83    pub open_stateid: StateId,
84}
85
86#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
87pub struct CommitArgs {
88    pub offset: u64,
89    pub count: u32,
90}
91
92#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
93pub struct DeviceData {
94    pub major: u32,
95    pub minor: u32,
96}
97
98#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
99pub struct RetentionGet {
100    pub duration: u64,
101    pub begin_time: Option<Time>,
102}
103
104#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
105pub struct RetentionSet {
106    pub enable: bool,
107    pub duration: Option<u64>,
108}
109
110#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
111#[repr(u32)]
112pub enum SetTime {
113    SetToClientTime(Time) = 0,
114    SetToServerTime = 1,
115}
116
117#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
118#[repr(u32)]
119pub enum FileType {
120    Regular = 1,
121    Directory = 2,
122    Block = 3,
123    Character = 4,
124    Link = 5,
125    Socket = 6,
126    Fifo = 7,
127    AttrDir = 8,
128}
129
130#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
131#[repr(u32)]
132pub enum CreateType {
133    Directory = 2,
134    Block = 3,
135    Character(DeviceData) = 4,
136    Link(String) = 5,
137    Socket = 6,
138    Fifo = 7,
139}
140
141#[derive(
142    SerializeWithDiscriminant,
143    DeserializeWithDiscriminant,
144    PartialEq,
145    Eq,
146    Copy,
147    Clone,
148    PartialOrd,
149    Ord,
150    Debug,
151    TryFromPrimitive,
152    IntoPrimitive,
153)]
154#[repr(u32)]
155pub enum FileAttributeId {
156    SupportedAttrs = 0,
157    Type = 1,
158    FhExpireType = 2,
159    Change = 3,
160    Size = 4,
161    LinkSupport = 5,
162    SymlinkSupport = 6,
163    NamedAttr = 7,
164    FsId = 8,
165    UniqueHandles = 9,
166    LeaseTime = 10,
167    ReadDirAttrError = 11,
168    Acl = 12,
169    AclSupport = 13,
170    Archive = 14,
171    CanSetTime = 15,
172    CaseInsensitive = 16,
173    CasePreserving = 17,
174    ChownRestricted = 18,
175    FileHandle = 19,
176    FileId = 20,
177    FilesAvail = 21,
178    FilesFree = 22,
179    FilesTotal = 23,
180    FsLocations = 24,
181    Homogeneous = 26,
182    MaxFileSize = 27,
183    MaxLink = 28,
184    MaxName = 29,
185    MaxRead = 30,
186    MaxWrite = 31,
187    MimeType = 32,
188    Mode = 33,
189    NoTrunc = 34,
190    NumLinks = 35,
191    Owner = 36,
192    OwnerGroup = 37,
193    QuotaAvailHard = 38,
194    QuotaAvailSoft = 39,
195    QuotaUsed = 40,
196    RawDev = 41,
197    SpaceAvail = 42,
198    SpaceFree = 43,
199    SpaceTotal = 44,
200    SpaceUsed = 45,
201    System = 46,
202    TimeAccess = 47,
203    TimeAccessSet = 48,
204    TimeBackup = 49,
205    TimeCreate = 50,
206    TimeDelta = 51,
207    TimeMetadata = 52,
208    TimeModify = 53,
209    TimeModifySet = 54,
210    MountedOnFileid = 55,
211    DirNotifDelay = 56,
212    DirentNotifDelay = 57,
213    Dacl = 58,
214    Sacl = 59,
215    ChangePolicy = 60,
216    FsStatus = 61,
217    FsLayoutType = 62,
218    LayoutHint = 63,
219    LayoutType = 64,
220    LayoutBlksize = 65,
221    LayoutAlignment = 66,
222    FsLocationsInfo = 67,
223    MdsThreshold = 68,
224    RetentionGet = 69,
225    RetentionSet = 70,
226    RetentevtGet = 71,
227    RetentevtSet = 72,
228    RetentionHold = 73,
229    ModeSetMasked = 74,
230    SupportedAttrsExclusiveCreate = 75,
231    FsCharsetCap = 76,
232}
233
234#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
235pub struct FsId {
236    pub major: u64,
237    pub minor: u64,
238}
239
240#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
241pub struct FileHandle(#[serde(with = "serde_bytes")] pub Vec<u8>);
242
243#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
244pub struct Identity(pub String);
245
246#[derive(
247    SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Copy, Clone, Debug,
248)]
249#[repr(u32)]
250pub enum AceType {
251    AccessAllowed = 0,
252    AccessDenied = 1,
253    SystemAudit = 2,
254    SystemAlarm = 3,
255}
256
257bitflags! {
258    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
259    pub struct AceFlags: u32 {
260        const FILE_INHERIT_ACE             = 0x00000001;
261        const DIRECTORY_INHERIT_ACE        = 0x00000002;
262        const NO_PROPAGATE_INHERIT_ACE     = 0x00000004;
263        const INHERIT_ONLY_ACE             = 0x00000008;
264        const SUCCESSFUL_ACCESS_ACE_FLAG   = 0x00000010;
265        const FAILED_ACCESS_ACE_FLAG       = 0x00000020;
266        const IDENTIFIER_GROUP             = 0x00000040;
267        const INHERITED_ACE                = 0x00000080;
268    }
269}
270
271impl_serde_for_bitflags!(AceFlags);
272
273bitflags! {
274    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
275    pub struct AceMask: u32 {
276        const READ_DATA            = 0x00000001;
277        const LIST_DIRECTORY       = 0x00000001;
278        const WRITE_DATA           = 0x00000002;
279        const ADD_FILE             = 0x00000002;
280        const APPEND_DATA          = 0x00000004;
281        const ADD_SUBDIRECTORY     = 0x00000004;
282        const READ_NAMED_ATTRS     = 0x00000008;
283        const WRITE_NAMED_ATTRS    = 0x00000010;
284        const EXECUTE              = 0x00000020;
285        const DELETE_CHILD         = 0x00000040;
286        const READ_ATTRIBUTES      = 0x00000080;
287        const WRITE_ATTRIBUTES     = 0x00000100;
288        const WRITE_RETENTION      = 0x00000200;
289        const WRITE_RETENTION_HOLD = 0x00000400;
290
291        const DELETE               = 0x00010000;
292        const READ_ACL             = 0x00020000;
293        const WRITE_ACL            = 0x00040000;
294        const WRITE_OWNER          = 0x00080000;
295        const SYNCHRONIZE          = 0x00100000;
296    }
297}
298
299impl_serde_for_bitflags!(AceMask);
300
301#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
302pub struct Ace {
303    pub type_: AceType,
304    pub flags: AceFlags,
305    pub access_mask: AceMask,
306    pub who: Identity,
307}
308
309#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
310pub struct Acl {
311    pub aces: Vec<Ace>,
312}
313
314bitflags! {
315    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
316    pub struct AclFlags: u32 {
317        const AUTO_INHERIT         = 0x00000001;
318        const PROTECTED            = 0x00000002;
319        const DEFAULTED            = 0x00000004;
320    }
321}
322
323impl_serde_for_bitflags!(AclFlags);
324
325#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
326pub struct AclWithFlags {
327    pub flags: AclFlags,
328}
329
330#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
331pub struct ChangePolicy(u32);
332
333#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
334pub struct Time {
335    pub seconds: i64,
336    pub nseconds: u32,
337}
338
339#[derive(
340    SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Copy, Clone, Debug,
341)]
342#[repr(u32)]
343pub enum LayoutType {
344    NfsV41Files = 1,
345    Osd2Objects = 2,
346    BlockVolume = 3,
347}
348
349#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
350pub struct LockDenied {
351    pub offset: u64,
352    pub length: u64,
353    pub lock_type: LockType,
354    pub owner: StateOwner,
355}
356
357#[derive(
358    SerializeWithDiscriminant,
359    DeserializeWithDiscriminant,
360    PartialEq,
361    Eq,
362    Clone,
363    Debug,
364    TryFromPrimitive,
365)]
366#[repr(u32)]
367pub enum StatusError {
368    Perm = 1,
369    NoEnt = 2,
370    Io = 5,
371    NxIo = 6,
372    Access = 13,
373    Exist = 17,
374    XDev = 18,
375    NotDir = 20,
376    Isdir = 21,
377    Inval = 22,
378    FBig = 27,
379    NoSpc = 28,
380    RoFs = 30,
381    MLink = 31,
382    NameTooLong = 63,
383    NotEmpty = 66,
384    DQuot = 69,
385    Stale = 70,
386    BadHandle = 10001,
387    BadCookie = 10003,
388    NotSupported = 10004,
389    TooSmall = 10005,
390    ServerFault = 10006,
391    BadType = 10007,
392    Delay = 10008,
393    Same = 10009,
394    Denied = 10010,
395    Expired = 10011,
396    Locked = 10012,
397    Grace = 10013,
398    FhExpired = 10014,
399    ShareDenied = 10015,
400    WrongSec = 10016,
401    ClidInUse = 10017,
402    Moved = 10019,
403    NoFileHandle = 10020,
404    MinorVersMismatch = 10021,
405    StaleClientId = 10022,
406    StaleStateId = 10023,
407    OldStateId = 10024,
408    BadStateId = 10025,
409    BadSeqId = 10026,
410    NotSame = 10027,
411    LockRange = 10028,
412    Symlink = 10029,
413    RestoreFh = 10030,
414    LeaseMoved = 10031,
415    AttrNotSupported = 10032,
416    NoGrace = 10033,
417    ReclaimBad = 10034,
418    ReclaimConflict = 10035,
419    BadXdr = 10036,
420    LocksHeld = 10037,
421    OpenMode = 10038,
422    BadOwner = 10039,
423    BadChar = 10040,
424    BadName = 10041,
425    BadRange = 10042,
426    LockNotSupported = 10043,
427    OpIllegal = 10044,
428    Deadlock = 10045,
429    FileOpen = 10046,
430    AdminRevoked = 10047,
431    CbPathDown = 10048,
432    BadIoMode = 10049,
433    BadLayout = 10050,
434    BadSessionDigest = 10051,
435    BadSession = 10052,
436    BadSlot = 10053,
437    CompleteAlready = 10054,
438    ConnNotBoundToSession = 10055,
439    DelegAlreadyWanted = 10056,
440    BackChanBusy = 10057,
441    LayoutTryLater = 10058,
442    LayoutUnavailable = 10059,
443    NoMatchingLayout = 10060,
444    RecallConflict = 10061,
445    UnknownLayoutType = 10062,
446    SeqMisordered = 10063,
447    SequencePos = 10064,
448    ReqTooBig = 10065,
449    RepTooBig = 10066,
450    RepTooBigToCache = 10067,
451    RetryUncachedRep = 10068,
452    UnsafeCompound = 10069,
453    TooManyOps = 10070,
454    OpNotInSession = 10071,
455    HashAlgUnsupported = 10072,
456    ClientIdBusy = 10074,
457    PnfsIoHole = 10075,
458    SeqFalseRetry = 10076,
459    BadHighSlot = 10077,
460    DeadSession = 10078,
461    EncrAlgUnsupported = 10079,
462    PnfsNoLayout = 10080,
463    NotOnlyOp = 10081,
464    WrongCred = 10082,
465    WrongType = 10083,
466    DirDelegUnavail = 10084,
467    RejectDeleg = 10085,
468    ReturnConflict = 10086,
469    DelegRevoked = 10087,
470}
471
472#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
473pub struct Component(String);
474
475#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
476pub struct PathName(Vec<Component>);
477
478#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
479pub struct FsLocation {
480    pub server: Vec<String>,
481    pub root_path: PathName,
482}
483
484#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
485pub struct FsLocations {
486    pub fs_root: PathName,
487    pub locations: Vec<FsLocation>,
488}
489
490bitflags! {
491    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
492    pub struct FsLocationsInfoFlags: u32 {
493        const VAR_SUB = 0x00000001;
494    }
495}
496
497impl_serde_for_bitflags!(FsLocationsInfoFlags);
498
499#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
500pub struct FsLocationsServer {
501    pub currency: i32,
502    #[serde(with = "serde_bytes")]
503    pub info: Vec<u8>,
504    pub server: String,
505}
506
507#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
508pub struct FsLocationsItem {
509    pub entries: Vec<FsLocationsServer>,
510    pub root_path: PathName,
511}
512
513#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
514pub struct FsLocationsInfo {
515    pub flags: FsLocationsInfoFlags,
516    pub valid_for: i32,
517    pub fs_root: PathName,
518    pub items: Vec<FsLocationsItem>,
519}
520
521#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
522#[repr(u32)]
523pub enum FsStatusType {
524    Fixed = 1,
525    Updated = 2,
526    Versioned = 3,
527    Writable = 4,
528    Referral = 5,
529}
530
531#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
532pub struct FsStatus {
533    pub absent: bool,
534    pub type_: FsStatusType,
535    pub source: String,
536    pub current: String,
537    pub age: i32,
538    pub version: Time,
539}
540
541#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
542pub struct LayoutHint {
543    pub type_: LayoutType,
544    #[serde(with = "serde_bytes")]
545    pub body: Vec<u8>,
546}
547
548#[derive(
549    SerializeWithDiscriminant,
550    DeserializeWithDiscriminant,
551    PartialEq,
552    Eq,
553    Copy,
554    Clone,
555    PartialOrd,
556    Ord,
557    Debug,
558    TryFromPrimitive,
559    IntoPrimitive,
560)]
561#[repr(u32)]
562pub enum ThresholdAttributeId {
563    ReadSize = 0,
564    WriteSize = 1,
565    ReadIoSize = 2,
566    WriteIoSize = 3,
567}
568
569#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
570#[repr(u32)]
571pub enum ThresholdAttribute {
572    ReadSize(u32) = ThresholdAttributeId::ReadSize as u32,
573    WriteSize(u32) = ThresholdAttributeId::WriteSize as u32,
574    ReadIoSize(u32) = ThresholdAttributeId::ReadIoSize as u32,
575    WriteIoSize(u32) = ThresholdAttributeId::WriteIoSize as u32,
576}
577
578#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
579pub struct ThresholdItem {
580    pub layout_type: LayoutType,
581    pub hintset: EnumMap<ThresholdAttributeId, ThresholdAttribute>,
582}
583
584#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
585pub struct MdsThreshold {
586    hints: Vec<ThresholdItem>,
587}
588
589struct OctalFmt<T>(T);
590
591impl<T> fmt::Debug for OctalFmt<T>
592where
593    T: fmt::Octal,
594{
595    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
596        fmt::Octal::fmt(&self.0, f)
597    }
598}
599
600#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone)]
601pub struct Mode(pub u32);
602
603impl fmt::Debug for Mode {
604    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
605        f.debug_tuple("Mode").field(&OctalFmt(self.0)).finish()
606    }
607}
608
609#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone)]
610pub struct ModeMasked(pub u32);
611
612impl fmt::Debug for ModeMasked {
613    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
614        f.debug_tuple("Mode").field(&OctalFmt(self.0)).finish()
615    }
616}
617
618#[derive(PartialEq, Eq, Clone, Debug)]
619pub enum StatusResult<T> {
620    Ok(T),
621    Err(StatusError),
622}
623
624#[derive(PartialEq, Eq, Clone, Debug)]
625pub struct LockStatusError {
626    pub error: StatusError,
627    pub denied: Option<LockDenied>,
628}
629
630#[derive(PartialEq, Eq, Clone, Debug)]
631pub enum LockStatusResult<T> {
632    Ok(T),
633    Err(LockStatusError),
634}
635
636impl<T> Serialize for StatusResult<T>
637where
638    T: Serialize,
639{
640    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
641    where
642        S: Serializer,
643    {
644        match self {
645            Self::Ok(v) => {
646                let mut state = serializer.serialize_struct("StatusResult", 2)?;
647                state.serialize_field("discriminant", &0u32)?;
648                state.serialize_field("ok", v)?;
649                state.end()
650            }
651            Self::Err(e) => e.serialize(serializer),
652        }
653    }
654}
655
656impl<'de, T> Deserialize<'de> for StatusResult<T>
657where
658    T: Deserialize<'de>,
659{
660    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
661    where
662        D: Deserializer<'de>,
663    {
664        struct Visitor<T>(std::marker::PhantomData<T>);
665
666        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
667        where
668            T: Deserialize<'de>,
669        {
670            type Value = StatusResult<T>;
671
672            fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> std::fmt::Result {
673                formatter.write_str("StatusResult")
674            }
675
676            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
677            where
678                A: serde::de::SeqAccess<'de>,
679            {
680                let disc: u32 = seq
681                    .next_element()?
682                    .ok_or(serde::de::Error::custom("expected discriminant"))?;
683                if disc == 0 {
684                    Ok(StatusResult::Ok(
685                        seq.next_element()?
686                            .ok_or(serde::de::Error::custom("expected value"))?,
687                    ))
688                } else {
689                    let err_id: StatusError = disc.try_into().map_err(|_| {
690                        serde::de::Error::custom(format!(
691                            "unexpected value {disc:?} for StatusError"
692                        ))
693                    })?;
694                    Ok(StatusResult::Err(err_id))
695                }
696            }
697        }
698
699        deserializer.deserialize_struct(
700            "StatusResult",
701            &["disc", "value"],
702            Visitor(std::marker::PhantomData),
703        )
704    }
705}
706
707impl<T> Serialize for LockStatusResult<T>
708where
709    T: Serialize,
710{
711    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
712    where
713        S: Serializer,
714    {
715        match self {
716            Self::Ok(v) => {
717                let mut state = serializer.serialize_struct("LockStatusResult", 2)?;
718                state.serialize_field("discriminant", &0u32)?;
719                state.serialize_field("ok", v)?;
720                state.end()
721            }
722            Self::Err(LockStatusError { error, denied }) => {
723                let mut state = serializer.serialize_struct("LockStatusResult", 2)?;
724                state.serialize_field("error", error)?;
725                if error == &StatusError::Denied {
726                    state.serialize_field("denied", denied.as_ref().unwrap())?;
727                }
728                state.end()
729            }
730        }
731    }
732}
733
734impl<'de, T> Deserialize<'de> for LockStatusResult<T>
735where
736    T: Deserialize<'de>,
737{
738    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
739    where
740        D: Deserializer<'de>,
741    {
742        struct Visitor<T>(std::marker::PhantomData<T>);
743
744        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
745        where
746            T: Deserialize<'de>,
747        {
748            type Value = LockStatusResult<T>;
749
750            fn expecting(&self, formatter: &mut ::std::fmt::Formatter) -> std::fmt::Result {
751                formatter.write_str("LockStatusResult")
752            }
753
754            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
755            where
756                A: serde::de::SeqAccess<'de>,
757            {
758                let disc: u32 = seq
759                    .next_element()?
760                    .ok_or(serde::de::Error::custom("expected discriminant"))?;
761                if disc == 0 {
762                    Ok(LockStatusResult::Ok(
763                        seq.next_element()?
764                            .ok_or(serde::de::Error::custom("expected value"))?,
765                    ))
766                } else {
767                    let error: StatusError = disc.try_into().map_err(|_| {
768                        serde::de::Error::custom(format!(
769                            "unexpected value {disc:?} for StatusError"
770                        ))
771                    })?;
772                    let denied = (error == StatusError::Denied)
773                        .then(|| {
774                            seq.next_element()?
775                                .ok_or(serde::de::Error::custom("expected denied"))
776                        })
777                        .transpose()?;
778
779                    Ok(LockStatusResult::Err(LockStatusError { error, denied }))
780                }
781            }
782        }
783
784        deserializer.deserialize_struct(
785            "LockStatusResult",
786            &["disc", "value", "denied"],
787            Visitor(std::marker::PhantomData),
788        )
789    }
790}
791
792#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
793pub struct Lease(pub u32);
794
795#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
796pub struct Change(pub u64);
797
798#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
799pub struct FileId(pub u64);
800
801#[derive(
802    SerializeWithDiscriminant,
803    DeserializeWithDiscriminant,
804    EnumAsInner,
805    PartialEq,
806    Eq,
807    Clone,
808    Debug,
809    TryInto,
810)]
811#[try_into(owned, ref)]
812#[repr(u32)]
813pub enum FileAttribute {
814    SupportedAttrs(EnumSet<FileAttributeId>) = FileAttributeId::SupportedAttrs as u32,
815    Type(FileType) = FileAttributeId::Type as u32,
816    FhExpireType(u32) = FileAttributeId::FhExpireType as u32,
817    Change(Change) = FileAttributeId::Change as u32,
818    Size(u64) = FileAttributeId::Size as u32,
819    LinkSupport(bool) = FileAttributeId::LinkSupport as u32,
820    SymlinkSupport(bool) = FileAttributeId::SymlinkSupport as u32,
821    NamedAttr(bool) = FileAttributeId::NamedAttr as u32,
822    FsId(FsId) = FileAttributeId::FsId as u32,
823    UniqueHandles(bool) = FileAttributeId::UniqueHandles as u32,
824    LeaseTime(Lease) = FileAttributeId::LeaseTime as u32,
825    ReadDirAttrError(StatusResult<()>) = FileAttributeId::ReadDirAttrError as u32,
826    Acl(Acl) = FileAttributeId::Acl as u32,
827    AclSupport(u32) = FileAttributeId::AclSupport as u32,
828    Archive(bool) = FileAttributeId::Archive as u32,
829    CanSetTime(bool) = FileAttributeId::CanSetTime as u32,
830    CaseInsensitive(bool) = FileAttributeId::CaseInsensitive as u32,
831    CasePreserving(bool) = FileAttributeId::CasePreserving as u32,
832    ChownRestricted(bool) = FileAttributeId::ChownRestricted as u32,
833    FileHandle(FileHandle) = FileAttributeId::FileHandle as u32,
834    FileId(FileId) = FileAttributeId::FileId as u32,
835    FilesAvail(u64) = FileAttributeId::FilesAvail as u32,
836    FilesFree(u64) = FileAttributeId::FilesFree as u32,
837    FilesTotal(u64) = FileAttributeId::FilesTotal as u32,
838    FsLocations(FsLocations) = FileAttributeId::FsLocations as u32,
839    Homogeneous(bool) = FileAttributeId::Homogeneous as u32,
840    MaxFileSize(u64) = FileAttributeId::MaxFileSize as u32,
841    MaxLink(u32) = FileAttributeId::MaxLink as u32,
842    MaxName(u32) = FileAttributeId::MaxName as u32,
843    MaxRead(u64) = FileAttributeId::MaxRead as u32,
844    MaxWrite(u64) = FileAttributeId::MaxWrite as u32,
845    MimeType(String) = FileAttributeId::MimeType as u32,
846    Mode(Mode) = FileAttributeId::Mode as u32,
847    NoTrunc(bool) = FileAttributeId::NoTrunc as u32,
848    NumLinks(u32) = FileAttributeId::NumLinks as u32,
849    Owner(String) = FileAttributeId::Owner as u32,
850    OwnerGroup(String) = FileAttributeId::OwnerGroup as u32,
851    QuotaAvailHard(u64) = FileAttributeId::QuotaAvailHard as u32,
852    QuotaAvailSoft(u64) = FileAttributeId::QuotaAvailSoft as u32,
853    QuotaUsed(u64) = FileAttributeId::QuotaUsed as u32,
854    RawDev(DeviceData) = FileAttributeId::RawDev as u32,
855    SpaceAvail(u64) = FileAttributeId::SpaceAvail as u32,
856    SpaceFree(u64) = FileAttributeId::SpaceFree as u32,
857    SpaceTotal(u64) = FileAttributeId::SpaceTotal as u32,
858    SpaceUsed(u64) = FileAttributeId::SpaceUsed as u32,
859    System(bool) = FileAttributeId::System as u32,
860    TimeAccess(Time) = FileAttributeId::TimeAccess as u32,
861    TimeAccessSet(SetTime) = FileAttributeId::TimeAccessSet as u32,
862    TimeBackup(Time) = FileAttributeId::TimeBackup as u32,
863    TimeCreate(Time) = FileAttributeId::TimeCreate as u32,
864    TimeDelta(Time) = FileAttributeId::TimeDelta as u32,
865    TimeMetadata(Time) = FileAttributeId::TimeMetadata as u32,
866    TimeModify(Time) = FileAttributeId::TimeModify as u32,
867    TimeModifySet(SetTime) = FileAttributeId::TimeModifySet as u32,
868    MountedOnFileid(FileId) = FileAttributeId::MountedOnFileid as u32,
869    DirNotifDelay(Time) = FileAttributeId::DirNotifDelay as u32,
870    DirentNotifDelay(Time) = FileAttributeId::DirentNotifDelay as u32,
871    Dacl(AclWithFlags) = FileAttributeId::Dacl as u32,
872    Sacl(AclWithFlags) = FileAttributeId::Sacl as u32,
873    ChangePolicy(ChangePolicy) = FileAttributeId::ChangePolicy as u32,
874    FsStatus(FsStatus) = FileAttributeId::FsStatus as u32,
875    FsLayoutType(Vec<LayoutType>) = FileAttributeId::FsLayoutType as u32,
876    LayoutHint(LayoutHint) = FileAttributeId::LayoutHint as u32,
877    LayoutType(Vec<LayoutType>) = FileAttributeId::LayoutType as u32,
878    LayoutBlksize(u32) = FileAttributeId::LayoutBlksize as u32,
879    LayoutAlignment(u32) = FileAttributeId::LayoutAlignment as u32,
880    FsLocationsInfo(FsLocationsInfo) = FileAttributeId::FsLocationsInfo as u32,
881    MdsThreshold(MdsThreshold) = FileAttributeId::MdsThreshold as u32,
882    RetentionGet(RetentionGet) = FileAttributeId::RetentionGet as u32,
883    RetentionSet(RetentionSet) = FileAttributeId::RetentionSet as u32,
884    RetentevtGet(RetentionGet) = FileAttributeId::RetentevtGet as u32,
885    RetentevtSet(RetentionSet) = FileAttributeId::RetentevtSet as u32,
886    RetentionHold(u64) = FileAttributeId::RetentionHold as u32,
887    ModeSetMasked(ModeMasked) = FileAttributeId::ModeSetMasked as u32,
888    SupportedAttrsExclusiveCreate(EnumSet<FileAttributeId>) =
889        FileAttributeId::SupportedAttrsExclusiveCreate as u32,
890    FsCharsetCap(u32) = FileAttributeId::FsCharsetCap as u32,
891}
892
893impl ToId<FileAttributeId> for FileAttribute {
894    fn to_id(&self) -> FileAttributeId {
895        match self {
896            Self::SupportedAttrs(..) => FileAttributeId::SupportedAttrs,
897            Self::Type(..) => FileAttributeId::Type,
898            Self::FhExpireType(..) => FileAttributeId::FhExpireType,
899            Self::Change(..) => FileAttributeId::Change,
900            Self::Size(..) => FileAttributeId::Size,
901            Self::LinkSupport(..) => FileAttributeId::LinkSupport,
902            Self::SymlinkSupport(..) => FileAttributeId::SymlinkSupport,
903            Self::NamedAttr(..) => FileAttributeId::NamedAttr,
904            Self::FsId(..) => FileAttributeId::FsId,
905            Self::UniqueHandles(..) => FileAttributeId::UniqueHandles,
906            Self::LeaseTime(..) => FileAttributeId::LeaseTime,
907            Self::ReadDirAttrError(..) => FileAttributeId::ReadDirAttrError,
908            Self::Acl(..) => FileAttributeId::Acl,
909            Self::AclSupport(..) => FileAttributeId::AclSupport,
910            Self::Archive(..) => FileAttributeId::Archive,
911            Self::CanSetTime(..) => FileAttributeId::CanSetTime,
912            Self::CaseInsensitive(..) => FileAttributeId::CaseInsensitive,
913            Self::CasePreserving(..) => FileAttributeId::CasePreserving,
914            Self::ChownRestricted(..) => FileAttributeId::ChownRestricted,
915            Self::FileHandle(..) => FileAttributeId::FileHandle,
916            Self::FileId(..) => FileAttributeId::FileId,
917            Self::FilesAvail(..) => FileAttributeId::FilesAvail,
918            Self::FilesFree(..) => FileAttributeId::FilesFree,
919            Self::FilesTotal(..) => FileAttributeId::FilesTotal,
920            Self::FsLocations(..) => FileAttributeId::FsLocations,
921            Self::Homogeneous(..) => FileAttributeId::Homogeneous,
922            Self::MaxFileSize(..) => FileAttributeId::MaxFileSize,
923            Self::MaxLink(..) => FileAttributeId::MaxLink,
924            Self::MaxName(..) => FileAttributeId::MaxName,
925            Self::MaxRead(..) => FileAttributeId::MaxRead,
926            Self::MaxWrite(..) => FileAttributeId::MaxWrite,
927            Self::MimeType(..) => FileAttributeId::MimeType,
928            Self::Mode(..) => FileAttributeId::Mode,
929            Self::NoTrunc(..) => FileAttributeId::NoTrunc,
930            Self::NumLinks(..) => FileAttributeId::NumLinks,
931            Self::Owner(..) => FileAttributeId::Owner,
932            Self::OwnerGroup(..) => FileAttributeId::OwnerGroup,
933            Self::QuotaAvailHard(..) => FileAttributeId::QuotaAvailHard,
934            Self::QuotaAvailSoft(..) => FileAttributeId::QuotaAvailSoft,
935            Self::QuotaUsed(..) => FileAttributeId::QuotaUsed,
936            Self::RawDev(..) => FileAttributeId::RawDev,
937            Self::SpaceAvail(..) => FileAttributeId::SpaceAvail,
938            Self::SpaceFree(..) => FileAttributeId::SpaceFree,
939            Self::SpaceTotal(..) => FileAttributeId::SpaceTotal,
940            Self::SpaceUsed(..) => FileAttributeId::SpaceUsed,
941            Self::System(..) => FileAttributeId::System,
942            Self::TimeAccess(..) => FileAttributeId::TimeAccess,
943            Self::TimeAccessSet(..) => FileAttributeId::TimeAccessSet,
944            Self::TimeBackup(..) => FileAttributeId::TimeBackup,
945            Self::TimeCreate(..) => FileAttributeId::TimeCreate,
946            Self::TimeDelta(..) => FileAttributeId::TimeDelta,
947            Self::TimeMetadata(..) => FileAttributeId::TimeMetadata,
948            Self::TimeModify(..) => FileAttributeId::TimeModify,
949            Self::TimeModifySet(..) => FileAttributeId::TimeModifySet,
950            Self::MountedOnFileid(..) => FileAttributeId::MountedOnFileid,
951            Self::DirNotifDelay(..) => FileAttributeId::DirNotifDelay,
952            Self::DirentNotifDelay(..) => FileAttributeId::DirentNotifDelay,
953            Self::Dacl(..) => FileAttributeId::Dacl,
954            Self::Sacl(..) => FileAttributeId::Sacl,
955            Self::ChangePolicy(..) => FileAttributeId::ChangePolicy,
956            Self::FsStatus(..) => FileAttributeId::FsStatus,
957            Self::FsLayoutType(..) => FileAttributeId::FsLayoutType,
958            Self::LayoutHint(..) => FileAttributeId::LayoutHint,
959            Self::LayoutType(..) => FileAttributeId::LayoutType,
960            Self::LayoutBlksize(..) => FileAttributeId::LayoutBlksize,
961            Self::LayoutAlignment(..) => FileAttributeId::LayoutAlignment,
962            Self::FsLocationsInfo(..) => FileAttributeId::FsLocationsInfo,
963            Self::MdsThreshold(..) => FileAttributeId::MdsThreshold,
964            Self::RetentionGet(..) => FileAttributeId::RetentionGet,
965            Self::RetentionSet(..) => FileAttributeId::RetentionSet,
966            Self::RetentevtGet(..) => FileAttributeId::RetentevtGet,
967            Self::RetentevtSet(..) => FileAttributeId::RetentevtSet,
968            Self::RetentionHold(..) => FileAttributeId::RetentionHold,
969            Self::ModeSetMasked(..) => FileAttributeId::ModeSetMasked,
970            Self::SupportedAttrsExclusiveCreate(..) => {
971                FileAttributeId::SupportedAttrsExclusiveCreate
972            }
973            Self::FsCharsetCap(..) => FileAttributeId::FsCharsetCap,
974        }
975    }
976}
977
978#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
979pub struct CreateArgs {
980    pub object_type: CreateType,
981    pub object_name: String,
982    pub create_attrs: FileAttributes,
983}
984
985#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
986pub struct ClientId(pub u64);
987
988#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
989pub struct DelegPurgeArgs {
990    pub client_id: ClientId,
991}
992
993#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
994pub struct DelegReturnArgs {
995    pub state_id: StateId,
996}
997
998#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
999pub struct GetAttrArgs {
1000    pub attr_request: EnumSet<FileAttributeId>,
1001}
1002
1003#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1004pub struct LinkArgs {
1005    pub new_name: String,
1006}
1007
1008#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1009#[repr(u32)]
1010pub enum LockType {
1011    Read = 1,
1012    Write = 2,
1013    BlockingRead = 3,
1014    BlockingWrite = 4,
1015}
1016
1017#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1018pub struct OpenToLockOwner {
1019    open_sequence_id: SequenceId,
1020    open_state_id: StateId,
1021    lock_sequence_id: SequenceId,
1022    lock_owner: StateOwner,
1023}
1024
1025#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1026pub struct ExistingLockOwner {
1027    lock_state_id: StateId,
1028    lock_sequence_id: SequenceId,
1029}
1030
1031#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1032#[repr(u8)]
1033pub enum Locker {
1034    NewLockOwner(OpenToLockOwner) = 1,
1035    ExistingLockOwner(ExistingLockOwner) = 0,
1036}
1037
1038#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1039pub struct LockArgs {
1040    pub lock_type: LockType,
1041    pub reclaim: bool,
1042    pub offset: u64,
1043    pub length: u64,
1044    pub locker: Locker,
1045}
1046
1047#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1048pub struct StateOwner {
1049    pub client_id: ClientId,
1050    #[serde(with = "serde_bytes")]
1051    pub opaque: Vec<u8>,
1052}
1053
1054#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1055pub struct LockTArgs {
1056    pub lock_type: LockType,
1057    pub offset: u64,
1058    pub length: u64,
1059    pub owner: StateOwner,
1060}
1061
1062#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1063pub struct LockUArgs {
1064    pub lock_type: LockType,
1065    pub sequence_id: SequenceId,
1066    pub lock_state_id: StateId,
1067    pub offset: u64,
1068    pub length: u64,
1069}
1070
1071#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1072pub struct LookUpArgs {
1073    pub object_name: String,
1074}
1075
1076#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1077pub struct NVerifyArgs {
1078    pub object_attributes: FileAttributes,
1079}
1080
1081bitflags! {
1082    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
1083    pub struct ShareAccess: u32 {
1084        const READ                               = 0x00000001;
1085        const WRITE                              = 0x00000002;
1086        const BOTH                               = 0x00000003;
1087        const WANT_DELEG_MASK                    = 0xFF00;
1088        const WANT_NO_PREFERENCE                 = 0x0000;
1089        const WANT_READ_DELEG                    = 0x0100;
1090        const WANT_WRITE_DELEG                   = 0x0200;
1091        const WANT_ANY_DELEG                     = 0x0300;
1092        const WANT_NO_DELEG                      = 0x0400;
1093        const WANT_CANCEL                        = 0x0500;
1094        const WANT_SIGNAL_DELEG_WHEN_RESRC_AVAIL = 0x10000;
1095        const WANT_PUSH_DELEG_WHEN_UNCONTENDED   = 0x20000;
1096    }
1097}
1098
1099impl_serde_for_bitflags!(ShareAccess);
1100
1101bitflags! {
1102    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
1103    pub struct ShareDeny: u32 {
1104        const NONE     = 0x00000000;
1105        const READ     = 0x00000001;
1106        const WRITE    = 0x00000002;
1107        const BOTH     = 0x00000003;
1108    }
1109}
1110
1111impl_serde_for_bitflags!(ShareDeny);
1112
1113#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1114#[repr(u32)]
1115pub enum OpenFlag {
1116    OpenNoCreate = 0,
1117    OpenCreate(CreateHow) = 1,
1118}
1119
1120#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1121#[repr(u32)]
1122pub enum OpenDelegationType {
1123    None = 0,
1124    Read = 1,
1125    Write = 2,
1126    NoneExt = 3,
1127}
1128
1129#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1130#[repr(u32)]
1131pub enum CreateHow {
1132    Unchecked = 0,
1133    Guarded {
1134        create_attrs: FileAttributes,
1135    } = 1,
1136    Exclusive {
1137        create_verifier: Verifier,
1138    } = 2,
1139    ExclusiveBoth {
1140        create_verifier: Verifier,
1141        create_attrs: FileAttributes,
1142    } = 3,
1143}
1144
1145#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1146#[repr(u32)]
1147pub enum OpenClaim {
1148    Null {
1149        file: String,
1150    } = 0,
1151    Previous {
1152        delegate_type: OpenDelegationType,
1153    } = 1,
1154    DelegateCurrent {
1155        delegate_current_info: OpenClaimDelegateCurrent,
1156    } = 2,
1157    DelegatePrevious {
1158        file_delegate_previous: String,
1159    } = 3,
1160    Fh = 4,
1161    DelegateCurrentFh {
1162        oc_delegate_state_id: StateId,
1163    } = 5,
1164    PreviousFh = 6,
1165}
1166
1167#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1168pub struct OpenClaimDelegateCurrent {
1169    pub delegate_stateid: StateId,
1170    pub file: String,
1171}
1172
1173#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1174pub struct OpenArgs {
1175    pub sequence_id: SequenceId,
1176    pub share_access: ShareAccess,
1177    pub share_deny: ShareDeny,
1178    pub owner: StateOwner,
1179    pub open_how: OpenFlag,
1180    pub claim: OpenClaim,
1181}
1182
1183#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1184pub struct OpenAttrArgs {
1185    pub create_dir: bool,
1186}
1187
1188#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1189pub struct OpenDowngradeArgs {
1190    pub open_state_id: StateId,
1191    pub sequence_id: SequenceId,
1192    pub share_access: ShareAccess,
1193    pub share_deny: ShareDeny,
1194}
1195
1196#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1197pub struct PutFhArgs {
1198    pub object: FileHandle,
1199}
1200
1201#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1202pub struct ReadArgs {
1203    pub state_id: StateId,
1204    pub offset: u64,
1205    pub count: u32,
1206}
1207
1208#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1209pub struct Cookie(pub u64);
1210
1211#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1212pub struct Verifier(pub u64);
1213
1214#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1215pub struct ReadDirArgs {
1216    pub cookie: Cookie,
1217    pub cookie_verifier: Verifier,
1218    pub directory_count: u32,
1219    pub max_count: u32,
1220    pub attr_request: EnumSet<FileAttributeId>,
1221}
1222
1223#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1224pub struct RemoveArgs {
1225    pub target: String,
1226}
1227
1228#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1229pub struct RenameArgs {
1230    pub old_name: String,
1231    pub new_name: String,
1232}
1233
1234#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1235pub struct SecInfoArgs {
1236    pub name: String,
1237}
1238
1239#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1240pub struct SetAttrArgs {
1241    pub state_id: StateId,
1242    pub object_attributes: FileAttributes,
1243}
1244
1245#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1246pub struct VerifyArgs {
1247    pub object_attributes: FileAttributes,
1248}
1249
1250#[derive(
1251    SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Copy, Clone, Debug,
1252)]
1253#[repr(u32)]
1254pub enum StableHow {
1255    Unstable = 0,
1256    DataSync = 1,
1257    FileSync = 2,
1258}
1259
1260#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1261pub struct WriteArgs {
1262    pub state_id: StateId,
1263    pub offset: u64,
1264    pub stable: StableHow,
1265    #[serde(with = "serde_bytes")]
1266    pub data: Vec<u8>,
1267}
1268
1269#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1270#[repr(u32)]
1271pub enum RpcGssService {
1272    None = 1,
1273    Integrity = 2,
1274    Privacy = 3,
1275}
1276
1277#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1278pub struct GssHandle(#[serde(with = "serde_bytes")] pub Vec<u8>);
1279
1280#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1281pub struct GssCallbackHandles {
1282    service: RpcGssService,
1283    handle_from_server: GssHandle,
1284    handle_from_client: GssHandle,
1285}
1286
1287#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1288#[repr(u32)]
1289pub enum CallbackSecurityParameters {
1290    None = AuthFlavor::None as u32,
1291    Sys(AuthSysParameters) = AuthFlavor::Sys as u32,
1292    RpcSecGss(GssCallbackHandles) = AuthFlavor::RpcSecGss as u32,
1293}
1294
1295#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1296#[repr(u32)]
1297pub enum ChannelDirectionFromServer {
1298    Fore = 1,
1299    Back = 2,
1300    Both = 3,
1301}
1302
1303#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1304pub struct BackchannelCtlArgs {
1305    pub cp_program: u32,
1306    pub security_parameters: Vec<CallbackSecurityParameters>,
1307}
1308
1309#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1310pub struct SessionId(#[serde(with = "xdr_extras::array_as_struct")] pub [u8; 16]);
1311
1312#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1313pub struct BindConnToSessionArgs {
1314    pub session_id: SessionId,
1315    pub direction: ChannelDirectionFromServer,
1316    pub use_connection_in_rdma_mode: bool,
1317}
1318
1319#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1320pub struct ClientOwner {
1321    pub verifier: Verifier,
1322    #[serde(with = "serde_bytes")]
1323    pub owner_id: Vec<u8>,
1324}
1325
1326bitflags! {
1327    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
1328    pub struct ExchangeIdFlags: u32 {
1329        const SUPP_MOVED_REFER    = 0x00000001;
1330        const SUPP_MOVED_MIGR     = 0x00000002;
1331        const BIND_PRINC_STATEID  = 0x00000100;
1332        const USE_NON_PNFS        = 0x00010000;
1333        const USE_PNFS_MDS        = 0x00020000;
1334        const USE_PNFS_DS         = 0x00040000;
1335        const MASK_PNFS           = 0x00070000;
1336        const UPD_CONFIRMED_REC_A = 0x40000000;
1337        const CONFIRMED_R         = 0x80000000;
1338    }
1339}
1340
1341impl_serde_for_bitflags!(ExchangeIdFlags);
1342
1343#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1344pub struct StateProtectOps {
1345    pub must_enforce: EnumSet<OperationId>,
1346    pub must_allow: EnumSet<OperationId>,
1347}
1348
1349#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1350pub struct SsvProtInfo {
1351    pub ops: StateProtectOps,
1352    pub hash_algorithm: u32,
1353    pub encryption_algorithm: u32,
1354    pub ssv_length: u32,
1355    pub window: u32,
1356    pub handles: Vec<GssHandle>,
1357}
1358
1359#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1360pub struct SecOid(#[serde(with = "serde_bytes")] pub Vec<u8>);
1361
1362#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1363pub struct SsvStateProtectParams {
1364    pub ops: StateProtectOps,
1365    pub hash_algorithms: Vec<SecOid>,
1366    pub encryption_algorithms: Vec<SecOid>,
1367    pub window: u32,
1368    pub num_gss_handles: u32,
1369}
1370
1371#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1372#[repr(u32)]
1373pub enum StateProtect {
1374    None = 0,
1375    MachCred(StateProtectOps) = 1,
1376    Ssv(SsvStateProtectParams) = 2,
1377}
1378
1379#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1380pub struct ImplId {
1381    pub domain: String,
1382    pub name: String,
1383    pub date: Time,
1384}
1385
1386#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1387pub struct ExchangeIdArgs {
1388    pub client_owner: ClientOwner,
1389    pub flags: ExchangeIdFlags,
1390    pub state_protect: StateProtect,
1391    pub client_impl_id: Option<ImplId>,
1392}
1393
1394#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1395pub struct ChannelAttrs {
1396    pub header_pad_size: u32,
1397    pub max_request_size: u32,
1398    pub max_response_size: u32,
1399    pub max_response_size_cached: u32,
1400    pub max_operations: u32,
1401    pub max_requests: u32,
1402    pub rdma_ird: Option<u32>,
1403}
1404
1405bitflags! {
1406    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
1407    pub struct CreateSessionFlags: u32 {
1408        const PERSIST              = 0x00000001;
1409        const CONN_BACK_CHAN       = 0x00000002;
1410        const CONN_RDMA            = 0x00000004;
1411    }
1412}
1413
1414impl_serde_for_bitflags!(CreateSessionFlags);
1415
1416#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1417pub struct CreateSessionArgs {
1418    pub client_id: ClientId,
1419    pub sequence_id: SequenceId,
1420    pub flags: CreateSessionFlags,
1421    pub fore_channel_attrs: ChannelAttrs,
1422    pub back_channel_attrs: ChannelAttrs,
1423    pub program: u32,
1424    pub security_parameters: Vec<CallbackSecurityParameters>,
1425}
1426
1427#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1428pub struct DestroySessionArgs {
1429    pub session_id: SessionId,
1430}
1431
1432#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1433pub struct FreeStateidArgs {
1434    pub state_id: StateId,
1435}
1436
1437#[derive(
1438    SerializeWithDiscriminant,
1439    DeserializeWithDiscriminant,
1440    PartialEq,
1441    Eq,
1442    Copy,
1443    Clone,
1444    PartialOrd,
1445    Ord,
1446    Debug,
1447    TryFromPrimitive,
1448    IntoPrimitive,
1449)]
1450#[repr(u32)]
1451pub enum NotifyType {
1452    ChangeChildAttrs = 0,
1453    ChangeDirAttrs = 1,
1454    RemoveEntry = 2,
1455    AddEntry = 3,
1456    RenameEntry = 4,
1457    ChangeCookieVerifier = 5,
1458}
1459
1460#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1461pub struct GetDirDelegationArgs {
1462    pub signal_delegation_available: bool,
1463    pub notification_types: EnumSet<NotifyType>,
1464    pub child_attr_delay: Time,
1465    pub dir_attr_delay: Time,
1466    pub child_attributes: EnumSet<FileAttributeId>,
1467    pub dir_attributes: EnumSet<FileAttributeId>,
1468}
1469
1470#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1471pub struct DeviceId(#[serde(with = "xdr_extras::array_as_struct")] pub [u8; 16]);
1472
1473#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1474pub struct Util(pub u32);
1475
1476#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1477pub struct GetDeviceInfoArgs {
1478    pub device_id: DeviceId,
1479    pub util: Util,
1480    pub first_stripe_index: u32,
1481    pub pattern_offset: u64,
1482    pub fh_list: Vec<FileHandle>,
1483}
1484
1485#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1486pub struct GetDeviceListArgs {
1487    pub layout_type: LayoutType,
1488    pub max_devices: u32,
1489    pub cookie: Cookie,
1490    pub cookie_verifier: Verifier,
1491}
1492
1493#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1494pub struct LayoutUpdate {
1495    pub type_: LayoutType,
1496    #[serde(with = "serde_bytes")]
1497    pub body: Vec<u8>,
1498}
1499
1500#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1501pub struct LayoutCommitArgs {
1502    pub offset: u64,
1503    pub length: u64,
1504    pub reclaim: bool,
1505    pub state_id: StateId,
1506    pub last_write_offset: Option<u64>,
1507    pub time_modify: Option<Time>,
1508    pub layout_update: LayoutUpdate,
1509}
1510
1511#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1512#[repr(u32)]
1513pub enum LayoutIoMode {
1514    Read = 1,
1515    ReadWrite = 2,
1516    Any = 3,
1517}
1518
1519#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1520pub struct LayoutGetArgs {
1521    pub signal_layout_available: bool,
1522    pub layout_type: LayoutType,
1523    pub io_mode: LayoutIoMode,
1524    pub offset: u64,
1525    pub length: u64,
1526    pub min_length: u64,
1527    pub state_id: StateId,
1528    pub max_count: u32,
1529}
1530
1531#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1532#[repr(u32)]
1533pub enum LayoutReturnType {
1534    File = 1,
1535    FsId = 2,
1536    All = 3,
1537}
1538
1539#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1540pub struct LayoutReturnFile {
1541    pub offset: u64,
1542    pub length: u64,
1543    pub state_id: StateId,
1544    #[serde(with = "serde_bytes")]
1545    pub body: Vec<u8>,
1546}
1547
1548#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1549#[repr(u32)]
1550pub enum LayoutReturn {
1551    File(LayoutReturnFile) = LayoutReturnType::File as u32,
1552    FsId = LayoutReturnType::FsId as u32,
1553    All = LayoutReturnType::All as u32,
1554}
1555
1556#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1557pub struct LayoutReturnArgs {
1558    pub reclaim: bool,
1559    pub layout_type: LayoutType,
1560    pub io_mode: LayoutIoMode,
1561    pub layout_return: LayoutReturn,
1562}
1563
1564#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1565#[repr(u32)]
1566pub enum SecInfoStyle {
1567    CurrentFh = 0,
1568    Parent = 1,
1569}
1570
1571#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1572pub struct SecInfoNoNameArgs {
1573    pub style: SecInfoStyle,
1574}
1575
1576#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1577pub struct SlotId(pub u32);
1578
1579#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1580pub struct SequenceArgs {
1581    pub session_id: SessionId,
1582    pub sequence_id: SequenceId,
1583    pub slot_id: SlotId,
1584    pub highest_slot_id: SlotId,
1585    pub cache_this: bool,
1586}
1587
1588#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1589pub struct SetSsvArgs {
1590    #[serde(with = "serde_bytes")]
1591    pub ssv: Vec<u8>,
1592    #[serde(with = "serde_bytes")]
1593    pub digest: Vec<u8>,
1594}
1595
1596#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1597pub struct TestStateIdArgs {
1598    pub state_ids: Vec<StateId>,
1599}
1600
1601#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1602#[repr(u32)]
1603pub enum DelegationClaim {
1604    Null = 0,
1605    Previous { delegate_type: OpenDelegationType } = 1,
1606    DelegationCurrent = 2,
1607    DelegationPrevious = 3,
1608    Fh = 4,
1609    DelegationCurrentFh = 5,
1610    DelefationPreviousFh = 6,
1611}
1612
1613#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1614pub struct WantDelegationArgs {
1615    pub want: ShareAccess,
1616    pub claim: DelegationClaim,
1617}
1618
1619#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1620pub struct DestroyClientIdArgs {
1621    pub client_id: ClientId,
1622}
1623
1624#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1625pub struct ReclaimCompleteArgs {
1626    pub one_fs: bool,
1627}
1628
1629#[derive(
1630    SerializeWithDiscriminant,
1631    DeserializeWithDiscriminant,
1632    PartialEq,
1633    Eq,
1634    Copy,
1635    Clone,
1636    Debug,
1637    PartialOrd,
1638    Ord,
1639    TryFromPrimitive,
1640    IntoPrimitive,
1641)]
1642#[repr(u32)]
1643pub enum OperationId {
1644    Access = 3,
1645    Close = 4,
1646    Commit = 5,
1647    Create = 6,
1648    DelegPurge = 7,
1649    DelegReturn = 8,
1650    GetAttr = 9,
1651    GetFh = 10,
1652    Link = 11,
1653    Lock = 12,
1654    LockT = 13,
1655    LockU = 14,
1656    LookUp = 15,
1657    LookUpP = 16,
1658    NVerify = 17,
1659    Open = 18,
1660    OpenAttr = 19,
1661    OpenDowngrade = 21,
1662    PutFh = 22,
1663    PutPubFh = 23,
1664    PutRootFh = 24,
1665    Read = 25,
1666    ReadDir = 26,
1667    ReadLink = 27,
1668    Remove = 28,
1669    Rename = 29,
1670    RestoreFh = 31,
1671    SaveFh = 32,
1672    SecInfo = 33,
1673    SetAttr = 34,
1674    Verify = 37,
1675    Write = 38,
1676    BackchannelCtl = 40,
1677    BindConnToSession = 41,
1678    ExchangeId = 42,
1679    CreateSession = 43,
1680    DestroySession = 44,
1681    FreeStateid = 45,
1682    GetDirDelegation = 46,
1683    GetDeviceInfo = 47,
1684    GetDeviceList = 48,
1685    LayoutCommit = 49,
1686    LayoutGet = 50,
1687    LayoutReturn = 51,
1688    SecInfoNoName = 52,
1689    Sequence = 53,
1690    SetSsv = 54,
1691    TestStateId = 55,
1692    WantDelegation = 56,
1693    DestroyClientId = 57,
1694    ReclaimComplete = 58,
1695}
1696
1697#[derive(
1698    SerializeWithDiscriminant, DeserializeWithDiscriminant, From, PartialEq, Eq, Clone, Debug,
1699)]
1700#[repr(u32)]
1701pub enum ArgOp {
1702    Access(AccessArgs) = OperationId::Access as u32,
1703    Close(CloseArgs) = OperationId::Close as u32,
1704    Commit(CommitArgs) = OperationId::Commit as u32,
1705    Create(CreateArgs) = OperationId::Create as u32,
1706    DelegPurge(DelegPurgeArgs) = OperationId::DelegPurge as u32,
1707    DelegReturn(DelegReturnArgs) = OperationId::DelegReturn as u32,
1708    GetAttr(GetAttrArgs) = OperationId::GetAttr as u32,
1709    GetFh = OperationId::GetFh as u32,
1710    Link(LinkArgs) = OperationId::Link as u32,
1711    Lock(LockArgs) = OperationId::Lock as u32,
1712    LockT(LockTArgs) = OperationId::LockT as u32,
1713    LockU(LockUArgs) = OperationId::LockU as u32,
1714    LookUp(LookUpArgs) = OperationId::LookUp as u32,
1715    LookUpP = OperationId::LookUpP as u32,
1716    NVerify(NVerifyArgs) = OperationId::NVerify as u32,
1717    Open(OpenArgs) = OperationId::Open as u32,
1718    OpenAttr(OpenAttrArgs) = OperationId::OpenAttr as u32,
1719    OpenDowngrade(OpenDowngradeArgs) = OperationId::OpenDowngrade as u32,
1720    PutFh(PutFhArgs) = OperationId::PutFh as u32,
1721    PutPubFh = OperationId::PutPubFh as u32,
1722    PutRootFh = OperationId::PutRootFh as u32,
1723    Read(ReadArgs) = OperationId::Read as u32,
1724    ReadDir(ReadDirArgs) = OperationId::ReadDir as u32,
1725    ReadLink = OperationId::ReadLink as u32,
1726    Remove(RemoveArgs) = OperationId::Remove as u32,
1727    Rename(RenameArgs) = OperationId::Rename as u32,
1728    RestoreFh = OperationId::RestoreFh as u32,
1729    SaveFh = OperationId::SaveFh as u32,
1730    SecInfo(SecInfoArgs) = OperationId::SecInfo as u32,
1731    SetAttr(SetAttrArgs) = OperationId::SetAttr as u32,
1732    Verify(VerifyArgs) = OperationId::Verify as u32,
1733    Write(WriteArgs) = OperationId::Write as u32,
1734    BackchannelCtl(BackchannelCtlArgs) = OperationId::BackchannelCtl as u32,
1735    BindConnToSession(BindConnToSessionArgs) = OperationId::BindConnToSession as u32,
1736    ExchangeId(ExchangeIdArgs) = OperationId::ExchangeId as u32,
1737    CreateSession(CreateSessionArgs) = OperationId::CreateSession as u32,
1738    DestroySession(DestroySessionArgs) = OperationId::DestroySession as u32,
1739    FreeStateid(FreeStateidArgs) = OperationId::FreeStateid as u32,
1740    GetDirDelegation(GetDirDelegationArgs) = OperationId::GetDirDelegation as u32,
1741    GetDeviceInfo(GetDeviceInfoArgs) = OperationId::GetDeviceInfo as u32,
1742    GetDeviceList(GetDeviceListArgs) = OperationId::GetDeviceList as u32,
1743    LayoutCommit(LayoutCommitArgs) = OperationId::LayoutCommit as u32,
1744    LayoutGet(LayoutGetArgs) = OperationId::LayoutGet as u32,
1745    LayoutReturn(LayoutReturnArgs) = OperationId::LayoutReturn as u32,
1746    SecInfoNoName(SecInfoNoNameArgs) = OperationId::SecInfoNoName as u32,
1747    Sequence(SequenceArgs) = OperationId::Sequence as u32,
1748    SetSsv(SetSsvArgs) = OperationId::SetSsv as u32,
1749    TestStateId(TestStateIdArgs) = OperationId::TestStateId as u32,
1750    WantDelegation(WantDelegationArgs) = OperationId::WantDelegation as u32,
1751    DestroyClientId(DestroyClientIdArgs) = OperationId::DestroyClientId as u32,
1752    ReclaimComplete(ReclaimCompleteArgs) = OperationId::ReclaimComplete as u32,
1753}
1754
1755#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1756pub struct DirectoryEntry {
1757    pub cookie: Cookie,
1758    pub name: String,
1759    pub attrs: FileAttributes,
1760}
1761
1762#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1763pub struct DirectoryList {
1764    #[serde(with = "xdr_extras::list")]
1765    pub entries: Vec<DirectoryEntry>,
1766    pub eof: bool,
1767}
1768
1769#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1770pub struct AccessRes {
1771    pub supported: Access,
1772    pub access: Access,
1773}
1774
1775#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1776pub struct CloseRes {
1777    pub open_state_id: StateId,
1778}
1779
1780#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1781pub struct CommitRes {
1782    pub write_verifier: Verifier,
1783}
1784
1785#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1786pub struct ChangeId(u64);
1787
1788#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1789pub struct ChangeInfo {
1790    pub atomic: bool,
1791    pub before: ChangeId,
1792    pub after: ChangeId,
1793}
1794
1795#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1796pub struct CreateRes {
1797    pub change_info: ChangeInfo,
1798    pub attribute_set: EnumSet<FileAttributeId>,
1799}
1800
1801#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1802pub struct GetAttrRes {
1803    pub object_attributes: FileAttributes,
1804}
1805
1806#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1807pub struct GetFhRes {
1808    pub object: FileHandle,
1809}
1810
1811#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1812pub struct LinkRes {
1813    pub change_info: ChangeInfo,
1814}
1815
1816#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1817pub struct LockRes {
1818    pub lock_state_id: StateId,
1819}
1820
1821#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1822pub struct LockURes {
1823    pub lock_state_id: StateId,
1824}
1825
1826bitflags! {
1827    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
1828    pub struct OpenResult: u32 {
1829        const CONFIRM      = 0x00000002;
1830        const LOCKTYPE_POSIX = 0x00000004;
1831        const PRESERVE_UNLINKED = 0x00000008;
1832        const MAY_NOTIFY_LOCK = 0x00000020;
1833    }
1834}
1835
1836impl_serde_for_bitflags!(OpenResult);
1837
1838#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1839pub struct OpenReadDelegation {
1840    pub state_id: StateId,
1841    pub recall: bool,
1842    pub permissions: Ace,
1843}
1844
1845#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1846pub struct ModifiedLimit {
1847    pub num_blocks: u32,
1848    pub bytes_per_block: u32,
1849}
1850
1851#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1852#[repr(u32)]
1853pub enum SpaceLimit {
1854    Size { file_size: u64 } = 1,
1855    Blocks { modified_blocks: ModifiedLimit } = 2,
1856}
1857
1858#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1859pub struct OpenWriteDelegation {
1860    pub state_id: StateId,
1861    pub recall: bool,
1862    pub space_limit: SpaceLimit,
1863    pub permissions: Ace,
1864}
1865
1866#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1867#[repr(u32)]
1868pub enum OpenNoneDelegation {
1869    NotWanted = 0,
1870    Contention { server_will_push_delegation: bool } = 1,
1871    Resource { server_will_signal_available: bool } = 2,
1872    NotSupportedFileType = 3,
1873    WriteDelegationNotSupportedFileType = 4,
1874    NotSupportedUpgrade = 5,
1875    NotSupportedDowngrade = 6,
1876    Cancelled = 7,
1877    IsDir = 8,
1878}
1879
1880#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1881#[repr(u32)]
1882pub enum OpenDelegation {
1883    None = OpenDelegationType::None as u32,
1884    Read { read: OpenReadDelegation } = OpenDelegationType::Read as u32,
1885    Write { write: OpenWriteDelegation } = OpenDelegationType::Write as u32,
1886    NoneExt { why_none: OpenNoneDelegation } = OpenDelegationType::NoneExt as u32,
1887}
1888
1889#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1890pub struct OpenRes {
1891    pub state_id: StateId,
1892    pub change_info: ChangeInfo,
1893    pub result_flags: OpenResult,
1894    pub attribute_set: EnumSet<FileAttributeId>,
1895    pub delegation: OpenDelegation,
1896}
1897
1898#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1899pub struct OpenDowngradeRes {
1900    pub open_state_id: StateId,
1901}
1902
1903#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1904pub struct ReadRes {
1905    pub eof: bool,
1906    #[serde(with = "serde_bytes")]
1907    pub data: Vec<u8>,
1908}
1909
1910#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1911pub struct ReadDirRes {
1912    pub cookie_verifier: Verifier,
1913    pub reply: DirectoryList,
1914}
1915
1916#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1917pub struct ReadLinkRes {
1918    pub link: String,
1919}
1920
1921#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1922pub struct RemoveRes {
1923    pub change_info: ChangeInfo,
1924}
1925
1926#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1927pub struct RenameRes {
1928    pub source_change_info: ChangeInfo,
1929    pub target_change_info: ChangeInfo,
1930}
1931
1932#[derive(Serialize, Deserialize, PartialEq, Eq, Copy, Clone, Debug)]
1933pub struct Qop(u32);
1934
1935#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1936pub struct RpcSecGssInfo {
1937    pub oid: SecOid,
1938    pub qop: Qop,
1939    pub service: RpcGssService,
1940}
1941
1942#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
1943#[repr(u32)]
1944pub enum SecurityInfo {
1945    None = AuthFlavor::None as u32,
1946    Sys = AuthFlavor::Sys as u32,
1947    RpcSecGss { flavor_info: RpcSecGssInfo } = AuthFlavor::RpcSecGss as u32,
1948}
1949
1950#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1951pub struct SecInfoRes {
1952    pub body: Vec<SecurityInfo>,
1953}
1954
1955#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1956pub struct SetAttrRes {
1957    pub attr_set: EnumSet<FileAttributeId>,
1958}
1959
1960#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1961pub struct SetAttrStatusResult {
1962    pub status: StatusResult<()>,
1963    pub res: SetAttrRes,
1964}
1965
1966#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1967pub struct WriteRes {
1968    pub count: u32,
1969    pub committed: StableHow,
1970    pub write_veritifer: Verifier,
1971}
1972
1973#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1974pub struct BindConnToSessionRes {
1975    pub session_id: SessionId,
1976    pub direction: ChannelDirectionFromServer,
1977    pub use_connection_in_rdma_mode: bool,
1978}
1979
1980#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1981pub struct ServerOwner {
1982    pub minor_id: u64,
1983    #[serde(with = "serde_bytes")]
1984    pub major_id: Vec<u8>,
1985}
1986
1987#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1988pub struct ServerScope(#[serde(with = "serde_bytes")] pub Vec<u8>);
1989
1990#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
1991pub struct ExchangeIdRes {
1992    pub client_id: ClientId,
1993    pub sequence_id: SequenceId,
1994    pub flags: ExchangeIdFlags,
1995    pub state_protect: StateProtect,
1996    pub server_owner: ServerOwner,
1997    pub server_scope: ServerScope,
1998    pub server_impl_id: Option<ImplId>,
1999}
2000
2001#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2002pub struct CreateSessionRes {
2003    pub session_id: SessionId,
2004    pub sequence_id: SequenceId,
2005    pub flags: CreateSessionFlags,
2006    pub fore_channel_attrs: ChannelAttrs,
2007    pub back_channel_attrs: ChannelAttrs,
2008}
2009
2010#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2011pub struct GetDirDelegationRes {
2012    pub cookie_verifier: Verifier,
2013    pub state_id: StateId,
2014    pub notification: EnumSet<FileAttributeId>,
2015    pub child_attributes: EnumSet<FileAttributeId>,
2016    pub dir_attributes: EnumSet<FileAttributeId>,
2017}
2018
2019#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2020pub struct DeviceAddr {
2021    pub layout_type: LayoutType,
2022    #[serde(with = "serde_bytes")]
2023    pub body: Vec<u8>,
2024}
2025
2026#[derive(
2027    SerializeWithDiscriminant,
2028    DeserializeWithDiscriminant,
2029    PartialEq,
2030    Eq,
2031    Copy,
2032    Clone,
2033    Debug,
2034    PartialOrd,
2035    Ord,
2036    TryFromPrimitive,
2037    IntoPrimitive,
2038)]
2039#[repr(u32)]
2040pub enum NotifyDeviceIdType {
2041    Change = 1,
2042    Delete = 2,
2043}
2044
2045#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2046pub struct GetDeviceInfoRes {
2047    pub device_addr: DeviceAddr,
2048    pub notification: EnumSet<NotifyDeviceIdType>,
2049}
2050
2051#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2052pub struct GetDeviceListRes {
2053    pub cookie: Cookie,
2054    pub cookie_verifier: Verifier,
2055    pub device_id_list: Vec<DeviceId>,
2056    pub eof: bool,
2057}
2058
2059#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2060pub struct LayoutCommitRes {
2061    pub new_size: Option<u64>,
2062}
2063
2064#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2065pub struct LayoutContent {
2066    pub type_: LayoutType,
2067    #[serde(with = "serde_bytes")]
2068    pub body: Vec<u8>,
2069}
2070
2071#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2072pub struct Layout {
2073    pub offset: u64,
2074    pub length: u64,
2075    pub io_mode: LayoutIoMode,
2076    pub content: LayoutContent,
2077}
2078
2079#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2080pub struct LayoutGetRes {
2081    pub return_on_close: bool,
2082    pub state_id: StateId,
2083    pub layout: Vec<Layout>,
2084}
2085
2086#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2087pub struct LayoutReturnRes {
2088    pub state_id: Option<StateId>,
2089}
2090
2091bitflags! {
2092    #[derive(PartialEq, Eq, Copy, Clone, Debug)]
2093    pub struct SequenceStatusFlags: u32 {
2094        const CB_PATH_DOWN                  = 0x00000001;
2095        const CB_GSS_CONTEXTS_EXPIRING      = 0x00000002;
2096        const CB_GSS_CONTEXTS_EXPIRED       = 0x00000004;
2097        const EXPIRED_ALL_STATE_REVOKED     = 0x00000008;
2098        const EXPIRED_SOME_STATE_REVOKED    = 0x00000010;
2099        const ADMIN_STATE_REVOKED           = 0x00000020;
2100        const RECALLABLE_STATE_REVOKED      = 0x00000040;
2101        const LEASE_MOVED                   = 0x00000080;
2102        const RESTART_RECLAIM_NEEDED        = 0x00000100;
2103        const CB_PATH_DOWN_SESSION          = 0x00000200;
2104        const BACKCHANNEL_FAULT             = 0x00000400;
2105        const DEVID_CHANGED                 = 0x00000800;
2106        const DEVID_DELETED                 = 0x00001000;
2107    }
2108}
2109
2110impl_serde_for_bitflags!(SequenceStatusFlags);
2111
2112#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2113pub struct SequenceRes {
2114    pub session_id: SessionId,
2115    pub sequence_id: SequenceId,
2116    pub slot_id: SlotId,
2117    pub highest_slot_id: SlotId,
2118    pub target_highest_slot_id: SlotId,
2119    pub status_flags: SequenceStatusFlags,
2120}
2121
2122#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2123pub struct SetSsvRes {
2124    #[serde(with = "serde_bytes")]
2125    pub digest: Vec<u8>,
2126}
2127
2128#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2129pub struct TestStateIdRes {
2130    pub status_codes: Vec<StatusResult<()>>,
2131}
2132
2133#[derive(Serialize, Deserialize, PartialEq, Eq, Clone, Debug)]
2134pub struct WantDelegationRes {
2135    pub delegation: OpenDelegation,
2136}
2137
2138pub type SecInfoNoNameRes = SecInfoRes;
2139
2140#[derive(SerializeWithDiscriminant, DeserializeWithDiscriminant, PartialEq, Eq, Clone, Debug)]
2141#[repr(u32)]
2142pub enum ResOp {
2143    Access(StatusResult<AccessRes>) = OperationId::Access as u32,
2144    Close(StatusResult<CloseRes>) = OperationId::Close as u32,
2145    Commit(StatusResult<CommitRes>) = OperationId::Commit as u32,
2146    Create(StatusResult<CreateRes>) = OperationId::Create as u32,
2147    DelegPurge(StatusResult<()>) = OperationId::DelegPurge as u32,
2148    DelegReturn(StatusResult<()>) = OperationId::DelegReturn as u32,
2149    GetAttr(StatusResult<GetAttrRes>) = OperationId::GetAttr as u32,
2150    GetFh(StatusResult<GetFhRes>) = OperationId::GetFh as u32,
2151    Link(LockStatusResult<LinkRes>) = OperationId::Link as u32,
2152    Lock(LockStatusResult<LockRes>) = OperationId::Lock as u32,
2153    LockT(StatusResult<()>) = OperationId::LockT as u32,
2154    LockU(StatusResult<LockURes>) = OperationId::LockU as u32,
2155    LookUp(StatusResult<()>) = OperationId::LookUp as u32,
2156    LookUpP(StatusResult<()>) = OperationId::LookUpP as u32,
2157    NVerify(StatusResult<()>) = OperationId::NVerify as u32,
2158    Open(StatusResult<OpenRes>) = OperationId::Open as u32,
2159    OpenAttr(StatusResult<()>) = OperationId::OpenAttr as u32,
2160    OpenDowngrade(StatusResult<OpenDowngradeRes>) = OperationId::OpenDowngrade as u32,
2161    PutFh(StatusResult<()>) = OperationId::PutFh as u32,
2162    PutPubFh(StatusResult<()>) = OperationId::PutPubFh as u32,
2163    PutRootFh(StatusResult<()>) = OperationId::PutRootFh as u32,
2164    Read(StatusResult<ReadRes>) = OperationId::Read as u32,
2165    ReadDir(StatusResult<ReadDirRes>) = OperationId::ReadDir as u32,
2166    ReadLink(StatusResult<ReadLinkRes>) = OperationId::ReadLink as u32,
2167    Remove(StatusResult<RemoveRes>) = OperationId::Remove as u32,
2168    Rename(StatusResult<RenameRes>) = OperationId::Rename as u32,
2169    RestoreFh(StatusResult<()>) = OperationId::RestoreFh as u32,
2170    SaveFh(StatusResult<()>) = OperationId::SaveFh as u32,
2171    SecInfo(StatusResult<SecInfoRes>) = OperationId::SecInfo as u32,
2172    SetAttr(SetAttrStatusResult) = OperationId::SetAttr as u32,
2173    Verify(StatusResult<()>) = OperationId::Verify as u32,
2174    Write(StatusResult<WriteRes>) = OperationId::Write as u32,
2175    BackchannelCtl(StatusResult<()>) = OperationId::BackchannelCtl as u32,
2176    BindConnToSession(StatusResult<BindConnToSessionRes>) = OperationId::BindConnToSession as u32,
2177    ExchangeId(StatusResult<ExchangeIdRes>) = OperationId::ExchangeId as u32,
2178    CreateSession(StatusResult<CreateSessionRes>) = OperationId::CreateSession as u32,
2179    DestroySession(StatusResult<()>) = OperationId::DestroySession as u32,
2180    FreeStateid(StatusResult<()>) = OperationId::FreeStateid as u32,
2181    GetDirDelegation(StatusResult<GetDirDelegationRes>) = OperationId::GetDirDelegation as u32,
2182    GetDeviceInfo(StatusResult<GetDeviceInfoRes>) = OperationId::GetDeviceInfo as u32,
2183    GetDeviceList(StatusResult<GetDeviceListRes>) = OperationId::GetDeviceList as u32,
2184    LayoutCommit(StatusResult<LayoutCommitRes>) = OperationId::LayoutCommit as u32,
2185    LayoutGet(StatusResult<LayoutGetRes>) = OperationId::LayoutGet as u32,
2186    LayoutReturn(StatusResult<LayoutReturnRes>) = OperationId::LayoutReturn as u32,
2187    SecInfoNoName(StatusResult<SecInfoRes>) = OperationId::SecInfoNoName as u32,
2188    Sequence(StatusResult<SequenceRes>) = OperationId::Sequence as u32,
2189    SetSsv(StatusResult<SetSsvRes>) = OperationId::SetSsv as u32,
2190    TestStateId(StatusResult<TestStateIdRes>) = OperationId::TestStateId as u32,
2191    WantDelegation(StatusResult<WantDelegationRes>) = OperationId::WantDelegation as u32,
2192    DestroyClientId(StatusResult<()>) = OperationId::DestroyClientId as u32,
2193    ReclaimComplete(StatusResult<()>) = OperationId::ReclaimComplete as u32,
2194}
nfs4/lib.rs

nfs4/
lib.rs
