fidl_fuchsia_fs_startup__common/
fidl_fuchsia_fs_startup__common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// Compression algorithm specifier.
12#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
13pub enum CompressionAlgorithm {
14    ZstdChunked,
15    Uncompressed,
16    #[doc(hidden)]
17    __SourceBreaking {
18        unknown_ordinal: u32,
19    },
20}
21
22/// Pattern that matches an unknown `CompressionAlgorithm` member.
23#[macro_export]
24macro_rules! CompressionAlgorithmUnknown {
25    () => {
26        _
27    };
28}
29
30impl CompressionAlgorithm {
31    #[inline]
32    pub fn from_primitive(prim: u32) -> Option<Self> {
33        match prim {
34            0 => Some(Self::ZstdChunked),
35            1 => Some(Self::Uncompressed),
36            _ => None,
37        }
38    }
39
40    #[inline]
41    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
42        match prim {
43            0 => Self::ZstdChunked,
44            1 => Self::Uncompressed,
45            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
46        }
47    }
48
49    #[inline]
50    pub fn unknown() -> Self {
51        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
52    }
53
54    #[inline]
55    pub const fn into_primitive(self) -> u32 {
56        match self {
57            Self::ZstdChunked => 0,
58            Self::Uncompressed => 1,
59            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
60        }
61    }
62
63    #[inline]
64    pub fn is_unknown(&self) -> bool {
65        match self {
66            Self::__SourceBreaking { unknown_ordinal: _ } => true,
67            _ => false,
68        }
69    }
70}
71
72/// An optional eviction policy override for pager-backed blobs for blobfs.
73#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
74pub enum EvictionPolicyOverride {
75    /// Don't override the default cache policy.
76    None,
77    /// Override the default cache policy for pager-backed blobs with kNeverEvict.
78    NeverEvict,
79    /// Override the default cache policy for pager-backed blobs with kEvictImmediately.
80    EvictImmediately,
81    #[doc(hidden)]
82    __SourceBreaking { unknown_ordinal: u32 },
83}
84
85/// Pattern that matches an unknown `EvictionPolicyOverride` member.
86#[macro_export]
87macro_rules! EvictionPolicyOverrideUnknown {
88    () => {
89        _
90    };
91}
92
93impl EvictionPolicyOverride {
94    #[inline]
95    pub fn from_primitive(prim: u32) -> Option<Self> {
96        match prim {
97            0 => Some(Self::None),
98            1 => Some(Self::NeverEvict),
99            2 => Some(Self::EvictImmediately),
100            _ => None,
101        }
102    }
103
104    #[inline]
105    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
106        match prim {
107            0 => Self::None,
108            1 => Self::NeverEvict,
109            2 => Self::EvictImmediately,
110            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
111        }
112    }
113
114    #[inline]
115    pub fn unknown() -> Self {
116        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
117    }
118
119    #[inline]
120    pub const fn into_primitive(self) -> u32 {
121        match self {
122            Self::None => 0,
123            Self::NeverEvict => 1,
124            Self::EvictImmediately => 2,
125            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
126        }
127    }
128
129    #[inline]
130    pub fn is_unknown(&self) -> bool {
131        match self {
132            Self::__SourceBreaking { unknown_ordinal: _ } => true,
133            _ => false,
134        }
135    }
136}
137
138#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
139#[repr(C)]
140pub struct VolumeSetLimitRequest {
141    pub bytes: u64,
142}
143
144impl fidl::Persistable for VolumeSetLimitRequest {}
145
146#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
147#[repr(C)]
148pub struct VolumeGetLimitResponse {
149    pub bytes: u64,
150}
151
152impl fidl::Persistable for VolumeGetLimitResponse {}
153
154#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
155pub struct VolumesRemoveRequest {
156    pub name: String,
157}
158
159impl fidl::Persistable for VolumesRemoveRequest {}
160
161/// Options for how to format filesystems.
162#[derive(Clone, Debug, Default, PartialEq)]
163pub struct FormatOptions {
164    /// Enable verbose logging.
165    pub verbose: Option<bool>,
166    /// If true, use the deprecated padded merkle tree blobfs format.
167    pub deprecated_padded_blobfs_format: Option<bool>,
168    /// The initial number of inodes to allocate space for. If zero, a default is used. Only
169    /// supported for blobfs.
170    pub num_inodes: Option<u64>,
171    /// The number of fvm slices to preallocate for data when the filesystem is created.
172    pub fvm_data_slices: Option<u32>,
173    /// The number of sectors-per-cluster (for FAT filesystems).
174    pub sectors_per_cluster: Option<u16>,
175    #[doc(hidden)]
176    pub __source_breaking: fidl::marker::SourceBreaking,
177}
178
179impl fidl::Persistable for FormatOptions {}
180
181pub mod startup_ordinals {
182    pub const START: u64 = 0x317aa9458d3190c8;
183    pub const FORMAT: u64 = 0x3124676dd91933de;
184    pub const CHECK: u64 = 0x81e85b3190e7db3;
185}
186
187pub mod volume_ordinals {
188    pub const MOUNT: u64 = 0x3470ab56d455af0;
189    pub const CHECK: u64 = 0x5b638348f5e0418c;
190    pub const SET_LIMIT: u64 = 0x19286d83eb3cd137;
191    pub const GET_LIMIT: u64 = 0xb14e4950939f16;
192}
193
194pub mod volumes_ordinals {
195    pub const CREATE: u64 = 0x11a55097834b38e8;
196    pub const REMOVE: u64 = 0x70983b9344dc2292;
197}
198
199mod internal {
200    use super::*;
201    unsafe impl fidl::encoding::TypeMarker for CompressionAlgorithm {
202        type Owned = Self;
203
204        #[inline(always)]
205        fn inline_align(_context: fidl::encoding::Context) -> usize {
206            std::mem::align_of::<u32>()
207        }
208
209        #[inline(always)]
210        fn inline_size(_context: fidl::encoding::Context) -> usize {
211            std::mem::size_of::<u32>()
212        }
213
214        #[inline(always)]
215        fn encode_is_copy() -> bool {
216            false
217        }
218
219        #[inline(always)]
220        fn decode_is_copy() -> bool {
221            false
222        }
223    }
224
225    impl fidl::encoding::ValueTypeMarker for CompressionAlgorithm {
226        type Borrowed<'a> = Self;
227        #[inline(always)]
228        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
229            *value
230        }
231    }
232
233    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
234        for CompressionAlgorithm
235    {
236        #[inline]
237        unsafe fn encode(
238            self,
239            encoder: &mut fidl::encoding::Encoder<'_, D>,
240            offset: usize,
241            _depth: fidl::encoding::Depth,
242        ) -> fidl::Result<()> {
243            encoder.debug_check_bounds::<Self>(offset);
244            encoder.write_num(self.into_primitive(), offset);
245            Ok(())
246        }
247    }
248
249    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CompressionAlgorithm {
250        #[inline(always)]
251        fn new_empty() -> Self {
252            Self::unknown()
253        }
254
255        #[inline]
256        unsafe fn decode(
257            &mut self,
258            decoder: &mut fidl::encoding::Decoder<'_, D>,
259            offset: usize,
260            _depth: fidl::encoding::Depth,
261        ) -> fidl::Result<()> {
262            decoder.debug_check_bounds::<Self>(offset);
263            let prim = decoder.read_num::<u32>(offset);
264
265            *self = Self::from_primitive_allow_unknown(prim);
266            Ok(())
267        }
268    }
269    unsafe impl fidl::encoding::TypeMarker for EvictionPolicyOverride {
270        type Owned = Self;
271
272        #[inline(always)]
273        fn inline_align(_context: fidl::encoding::Context) -> usize {
274            std::mem::align_of::<u32>()
275        }
276
277        #[inline(always)]
278        fn inline_size(_context: fidl::encoding::Context) -> usize {
279            std::mem::size_of::<u32>()
280        }
281
282        #[inline(always)]
283        fn encode_is_copy() -> bool {
284            false
285        }
286
287        #[inline(always)]
288        fn decode_is_copy() -> bool {
289            false
290        }
291    }
292
293    impl fidl::encoding::ValueTypeMarker for EvictionPolicyOverride {
294        type Borrowed<'a> = Self;
295        #[inline(always)]
296        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297            *value
298        }
299    }
300
301    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
302        for EvictionPolicyOverride
303    {
304        #[inline]
305        unsafe fn encode(
306            self,
307            encoder: &mut fidl::encoding::Encoder<'_, D>,
308            offset: usize,
309            _depth: fidl::encoding::Depth,
310        ) -> fidl::Result<()> {
311            encoder.debug_check_bounds::<Self>(offset);
312            encoder.write_num(self.into_primitive(), offset);
313            Ok(())
314        }
315    }
316
317    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
318        for EvictionPolicyOverride
319    {
320        #[inline(always)]
321        fn new_empty() -> Self {
322            Self::unknown()
323        }
324
325        #[inline]
326        unsafe fn decode(
327            &mut self,
328            decoder: &mut fidl::encoding::Decoder<'_, D>,
329            offset: usize,
330            _depth: fidl::encoding::Depth,
331        ) -> fidl::Result<()> {
332            decoder.debug_check_bounds::<Self>(offset);
333            let prim = decoder.read_num::<u32>(offset);
334
335            *self = Self::from_primitive_allow_unknown(prim);
336            Ok(())
337        }
338    }
339
340    impl fidl::encoding::ValueTypeMarker for VolumeSetLimitRequest {
341        type Borrowed<'a> = &'a Self;
342        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
343            value
344        }
345    }
346
347    unsafe impl fidl::encoding::TypeMarker for VolumeSetLimitRequest {
348        type Owned = Self;
349
350        #[inline(always)]
351        fn inline_align(_context: fidl::encoding::Context) -> usize {
352            8
353        }
354
355        #[inline(always)]
356        fn inline_size(_context: fidl::encoding::Context) -> usize {
357            8
358        }
359        #[inline(always)]
360        fn encode_is_copy() -> bool {
361            true
362        }
363
364        #[inline(always)]
365        fn decode_is_copy() -> bool {
366            true
367        }
368    }
369
370    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumeSetLimitRequest, D>
371        for &VolumeSetLimitRequest
372    {
373        #[inline]
374        unsafe fn encode(
375            self,
376            encoder: &mut fidl::encoding::Encoder<'_, D>,
377            offset: usize,
378            _depth: fidl::encoding::Depth,
379        ) -> fidl::Result<()> {
380            encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
381            unsafe {
382                // Copy the object into the buffer.
383                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
384                (buf_ptr as *mut VolumeSetLimitRequest)
385                    .write_unaligned((self as *const VolumeSetLimitRequest).read());
386                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
387                // done second because the memcpy will write garbage to these bytes.
388            }
389            Ok(())
390        }
391    }
392    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
393        fidl::encoding::Encode<VolumeSetLimitRequest, D> for (T0,)
394    {
395        #[inline]
396        unsafe fn encode(
397            self,
398            encoder: &mut fidl::encoding::Encoder<'_, D>,
399            offset: usize,
400            depth: fidl::encoding::Depth,
401        ) -> fidl::Result<()> {
402            encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
403            // Zero out padding regions. There's no need to apply masks
404            // because the unmasked parts will be overwritten by fields.
405            // Write the fields.
406            self.0.encode(encoder, offset + 0, depth)?;
407            Ok(())
408        }
409    }
410
411    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumeSetLimitRequest {
412        #[inline(always)]
413        fn new_empty() -> Self {
414            Self { bytes: fidl::new_empty!(u64, D) }
415        }
416
417        #[inline]
418        unsafe fn decode(
419            &mut self,
420            decoder: &mut fidl::encoding::Decoder<'_, D>,
421            offset: usize,
422            _depth: fidl::encoding::Depth,
423        ) -> fidl::Result<()> {
424            decoder.debug_check_bounds::<Self>(offset);
425            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
426            // Verify that padding bytes are zero.
427            // Copy from the buffer into the object.
428            unsafe {
429                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
430            }
431            Ok(())
432        }
433    }
434
435    impl fidl::encoding::ValueTypeMarker for VolumeGetLimitResponse {
436        type Borrowed<'a> = &'a Self;
437        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
438            value
439        }
440    }
441
442    unsafe impl fidl::encoding::TypeMarker for VolumeGetLimitResponse {
443        type Owned = Self;
444
445        #[inline(always)]
446        fn inline_align(_context: fidl::encoding::Context) -> usize {
447            8
448        }
449
450        #[inline(always)]
451        fn inline_size(_context: fidl::encoding::Context) -> usize {
452            8
453        }
454        #[inline(always)]
455        fn encode_is_copy() -> bool {
456            true
457        }
458
459        #[inline(always)]
460        fn decode_is_copy() -> bool {
461            true
462        }
463    }
464
465    unsafe impl<D: fidl::encoding::ResourceDialect>
466        fidl::encoding::Encode<VolumeGetLimitResponse, D> for &VolumeGetLimitResponse
467    {
468        #[inline]
469        unsafe fn encode(
470            self,
471            encoder: &mut fidl::encoding::Encoder<'_, D>,
472            offset: usize,
473            _depth: fidl::encoding::Depth,
474        ) -> fidl::Result<()> {
475            encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
476            unsafe {
477                // Copy the object into the buffer.
478                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
479                (buf_ptr as *mut VolumeGetLimitResponse)
480                    .write_unaligned((self as *const VolumeGetLimitResponse).read());
481                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
482                // done second because the memcpy will write garbage to these bytes.
483            }
484            Ok(())
485        }
486    }
487    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
488        fidl::encoding::Encode<VolumeGetLimitResponse, D> for (T0,)
489    {
490        #[inline]
491        unsafe fn encode(
492            self,
493            encoder: &mut fidl::encoding::Encoder<'_, D>,
494            offset: usize,
495            depth: fidl::encoding::Depth,
496        ) -> fidl::Result<()> {
497            encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
498            // Zero out padding regions. There's no need to apply masks
499            // because the unmasked parts will be overwritten by fields.
500            // Write the fields.
501            self.0.encode(encoder, offset + 0, depth)?;
502            Ok(())
503        }
504    }
505
506    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
507        for VolumeGetLimitResponse
508    {
509        #[inline(always)]
510        fn new_empty() -> Self {
511            Self { bytes: fidl::new_empty!(u64, D) }
512        }
513
514        #[inline]
515        unsafe fn decode(
516            &mut self,
517            decoder: &mut fidl::encoding::Decoder<'_, D>,
518            offset: usize,
519            _depth: fidl::encoding::Depth,
520        ) -> fidl::Result<()> {
521            decoder.debug_check_bounds::<Self>(offset);
522            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
523            // Verify that padding bytes are zero.
524            // Copy from the buffer into the object.
525            unsafe {
526                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
527            }
528            Ok(())
529        }
530    }
531
532    impl fidl::encoding::ValueTypeMarker for VolumesRemoveRequest {
533        type Borrowed<'a> = &'a Self;
534        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
535            value
536        }
537    }
538
539    unsafe impl fidl::encoding::TypeMarker for VolumesRemoveRequest {
540        type Owned = Self;
541
542        #[inline(always)]
543        fn inline_align(_context: fidl::encoding::Context) -> usize {
544            8
545        }
546
547        #[inline(always)]
548        fn inline_size(_context: fidl::encoding::Context) -> usize {
549            16
550        }
551    }
552
553    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumesRemoveRequest, D>
554        for &VolumesRemoveRequest
555    {
556        #[inline]
557        unsafe fn encode(
558            self,
559            encoder: &mut fidl::encoding::Encoder<'_, D>,
560            offset: usize,
561            _depth: fidl::encoding::Depth,
562        ) -> fidl::Result<()> {
563            encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
564            // Delegate to tuple encoding.
565            fidl::encoding::Encode::<VolumesRemoveRequest, D>::encode(
566                (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
567                    &self.name,
568                ),),
569                encoder,
570                offset,
571                _depth,
572            )
573        }
574    }
575    unsafe impl<
576            D: fidl::encoding::ResourceDialect,
577            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
578        > fidl::encoding::Encode<VolumesRemoveRequest, D> for (T0,)
579    {
580        #[inline]
581        unsafe fn encode(
582            self,
583            encoder: &mut fidl::encoding::Encoder<'_, D>,
584            offset: usize,
585            depth: fidl::encoding::Depth,
586        ) -> fidl::Result<()> {
587            encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
588            // Zero out padding regions. There's no need to apply masks
589            // because the unmasked parts will be overwritten by fields.
590            // Write the fields.
591            self.0.encode(encoder, offset + 0, depth)?;
592            Ok(())
593        }
594    }
595
596    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumesRemoveRequest {
597        #[inline(always)]
598        fn new_empty() -> Self {
599            Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
600        }
601
602        #[inline]
603        unsafe fn decode(
604            &mut self,
605            decoder: &mut fidl::encoding::Decoder<'_, D>,
606            offset: usize,
607            _depth: fidl::encoding::Depth,
608        ) -> fidl::Result<()> {
609            decoder.debug_check_bounds::<Self>(offset);
610            // Verify that padding bytes are zero.
611            fidl::decode!(
612                fidl::encoding::BoundedString<255>,
613                D,
614                &mut self.name,
615                decoder,
616                offset + 0,
617                _depth
618            )?;
619            Ok(())
620        }
621    }
622
623    impl FormatOptions {
624        #[inline(always)]
625        fn max_ordinal_present(&self) -> u64 {
626            if let Some(_) = self.sectors_per_cluster {
627                return 5;
628            }
629            if let Some(_) = self.fvm_data_slices {
630                return 4;
631            }
632            if let Some(_) = self.num_inodes {
633                return 3;
634            }
635            if let Some(_) = self.deprecated_padded_blobfs_format {
636                return 2;
637            }
638            if let Some(_) = self.verbose {
639                return 1;
640            }
641            0
642        }
643    }
644
645    impl fidl::encoding::ValueTypeMarker for FormatOptions {
646        type Borrowed<'a> = &'a Self;
647        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
648            value
649        }
650    }
651
652    unsafe impl fidl::encoding::TypeMarker for FormatOptions {
653        type Owned = Self;
654
655        #[inline(always)]
656        fn inline_align(_context: fidl::encoding::Context) -> usize {
657            8
658        }
659
660        #[inline(always)]
661        fn inline_size(_context: fidl::encoding::Context) -> usize {
662            16
663        }
664    }
665
666    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatOptions, D>
667        for &FormatOptions
668    {
669        unsafe fn encode(
670            self,
671            encoder: &mut fidl::encoding::Encoder<'_, D>,
672            offset: usize,
673            mut depth: fidl::encoding::Depth,
674        ) -> fidl::Result<()> {
675            encoder.debug_check_bounds::<FormatOptions>(offset);
676            // Vector header
677            let max_ordinal: u64 = self.max_ordinal_present();
678            encoder.write_num(max_ordinal, offset);
679            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
680            // Calling encoder.out_of_line_offset(0) is not allowed.
681            if max_ordinal == 0 {
682                return Ok(());
683            }
684            depth.increment()?;
685            let envelope_size = 8;
686            let bytes_len = max_ordinal as usize * envelope_size;
687            #[allow(unused_variables)]
688            let offset = encoder.out_of_line_offset(bytes_len);
689            let mut _prev_end_offset: usize = 0;
690            if 1 > max_ordinal {
691                return Ok(());
692            }
693
694            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
695            // are envelope_size bytes.
696            let cur_offset: usize = (1 - 1) * envelope_size;
697
698            // Zero reserved fields.
699            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
700
701            // Safety:
702            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
703            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
704            //   envelope_size bytes, there is always sufficient room.
705            fidl::encoding::encode_in_envelope_optional::<bool, D>(
706                self.verbose.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
707                encoder,
708                offset + cur_offset,
709                depth,
710            )?;
711
712            _prev_end_offset = cur_offset + envelope_size;
713            if 2 > max_ordinal {
714                return Ok(());
715            }
716
717            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
718            // are envelope_size bytes.
719            let cur_offset: usize = (2 - 1) * envelope_size;
720
721            // Zero reserved fields.
722            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
723
724            // Safety:
725            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
726            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
727            //   envelope_size bytes, there is always sufficient room.
728            fidl::encoding::encode_in_envelope_optional::<bool, D>(
729                self.deprecated_padded_blobfs_format
730                    .as_ref()
731                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
732                encoder,
733                offset + cur_offset,
734                depth,
735            )?;
736
737            _prev_end_offset = cur_offset + envelope_size;
738            if 3 > max_ordinal {
739                return Ok(());
740            }
741
742            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
743            // are envelope_size bytes.
744            let cur_offset: usize = (3 - 1) * envelope_size;
745
746            // Zero reserved fields.
747            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
748
749            // Safety:
750            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
751            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
752            //   envelope_size bytes, there is always sufficient room.
753            fidl::encoding::encode_in_envelope_optional::<u64, D>(
754                self.num_inodes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
755                encoder,
756                offset + cur_offset,
757                depth,
758            )?;
759
760            _prev_end_offset = cur_offset + envelope_size;
761            if 4 > max_ordinal {
762                return Ok(());
763            }
764
765            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
766            // are envelope_size bytes.
767            let cur_offset: usize = (4 - 1) * envelope_size;
768
769            // Zero reserved fields.
770            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
771
772            // Safety:
773            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
774            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
775            //   envelope_size bytes, there is always sufficient room.
776            fidl::encoding::encode_in_envelope_optional::<u32, D>(
777                self.fvm_data_slices.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
778                encoder,
779                offset + cur_offset,
780                depth,
781            )?;
782
783            _prev_end_offset = cur_offset + envelope_size;
784            if 5 > max_ordinal {
785                return Ok(());
786            }
787
788            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
789            // are envelope_size bytes.
790            let cur_offset: usize = (5 - 1) * envelope_size;
791
792            // Zero reserved fields.
793            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
794
795            // Safety:
796            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
797            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
798            //   envelope_size bytes, there is always sufficient room.
799            fidl::encoding::encode_in_envelope_optional::<u16, D>(
800                self.sectors_per_cluster
801                    .as_ref()
802                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
803                encoder,
804                offset + cur_offset,
805                depth,
806            )?;
807
808            _prev_end_offset = cur_offset + envelope_size;
809
810            Ok(())
811        }
812    }
813
814    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatOptions {
815        #[inline(always)]
816        fn new_empty() -> Self {
817            Self::default()
818        }
819
820        unsafe fn decode(
821            &mut self,
822            decoder: &mut fidl::encoding::Decoder<'_, D>,
823            offset: usize,
824            mut depth: fidl::encoding::Depth,
825        ) -> fidl::Result<()> {
826            decoder.debug_check_bounds::<Self>(offset);
827            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
828                None => return Err(fidl::Error::NotNullable),
829                Some(len) => len,
830            };
831            // Calling decoder.out_of_line_offset(0) is not allowed.
832            if len == 0 {
833                return Ok(());
834            };
835            depth.increment()?;
836            let envelope_size = 8;
837            let bytes_len = len * envelope_size;
838            let offset = decoder.out_of_line_offset(bytes_len)?;
839            // Decode the envelope for each type.
840            let mut _next_ordinal_to_read = 0;
841            let mut next_offset = offset;
842            let end_offset = offset + bytes_len;
843            _next_ordinal_to_read += 1;
844            if next_offset >= end_offset {
845                return Ok(());
846            }
847
848            // Decode unknown envelopes for gaps in ordinals.
849            while _next_ordinal_to_read < 1 {
850                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
851                _next_ordinal_to_read += 1;
852                next_offset += envelope_size;
853            }
854
855            let next_out_of_line = decoder.next_out_of_line();
856            let handles_before = decoder.remaining_handles();
857            if let Some((inlined, num_bytes, num_handles)) =
858                fidl::encoding::decode_envelope_header(decoder, next_offset)?
859            {
860                let member_inline_size =
861                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
862                if inlined != (member_inline_size <= 4) {
863                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
864                }
865                let inner_offset;
866                let mut inner_depth = depth.clone();
867                if inlined {
868                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
869                    inner_offset = next_offset;
870                } else {
871                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
872                    inner_depth.increment()?;
873                }
874                let val_ref = self.verbose.get_or_insert_with(|| fidl::new_empty!(bool, D));
875                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
876                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
877                {
878                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
879                }
880                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
881                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
882                }
883            }
884
885            next_offset += envelope_size;
886            _next_ordinal_to_read += 1;
887            if next_offset >= end_offset {
888                return Ok(());
889            }
890
891            // Decode unknown envelopes for gaps in ordinals.
892            while _next_ordinal_to_read < 2 {
893                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
894                _next_ordinal_to_read += 1;
895                next_offset += envelope_size;
896            }
897
898            let next_out_of_line = decoder.next_out_of_line();
899            let handles_before = decoder.remaining_handles();
900            if let Some((inlined, num_bytes, num_handles)) =
901                fidl::encoding::decode_envelope_header(decoder, next_offset)?
902            {
903                let member_inline_size =
904                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
905                if inlined != (member_inline_size <= 4) {
906                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
907                }
908                let inner_offset;
909                let mut inner_depth = depth.clone();
910                if inlined {
911                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
912                    inner_offset = next_offset;
913                } else {
914                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
915                    inner_depth.increment()?;
916                }
917                let val_ref = self
918                    .deprecated_padded_blobfs_format
919                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
920                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
921                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
922                {
923                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
924                }
925                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
926                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
927                }
928            }
929
930            next_offset += envelope_size;
931            _next_ordinal_to_read += 1;
932            if next_offset >= end_offset {
933                return Ok(());
934            }
935
936            // Decode unknown envelopes for gaps in ordinals.
937            while _next_ordinal_to_read < 3 {
938                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
939                _next_ordinal_to_read += 1;
940                next_offset += envelope_size;
941            }
942
943            let next_out_of_line = decoder.next_out_of_line();
944            let handles_before = decoder.remaining_handles();
945            if let Some((inlined, num_bytes, num_handles)) =
946                fidl::encoding::decode_envelope_header(decoder, next_offset)?
947            {
948                let member_inline_size =
949                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
950                if inlined != (member_inline_size <= 4) {
951                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
952                }
953                let inner_offset;
954                let mut inner_depth = depth.clone();
955                if inlined {
956                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
957                    inner_offset = next_offset;
958                } else {
959                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
960                    inner_depth.increment()?;
961                }
962                let val_ref = self.num_inodes.get_or_insert_with(|| fidl::new_empty!(u64, D));
963                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
964                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
965                {
966                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
967                }
968                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
969                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
970                }
971            }
972
973            next_offset += envelope_size;
974            _next_ordinal_to_read += 1;
975            if next_offset >= end_offset {
976                return Ok(());
977            }
978
979            // Decode unknown envelopes for gaps in ordinals.
980            while _next_ordinal_to_read < 4 {
981                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
982                _next_ordinal_to_read += 1;
983                next_offset += envelope_size;
984            }
985
986            let next_out_of_line = decoder.next_out_of_line();
987            let handles_before = decoder.remaining_handles();
988            if let Some((inlined, num_bytes, num_handles)) =
989                fidl::encoding::decode_envelope_header(decoder, next_offset)?
990            {
991                let member_inline_size =
992                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
993                if inlined != (member_inline_size <= 4) {
994                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
995                }
996                let inner_offset;
997                let mut inner_depth = depth.clone();
998                if inlined {
999                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1000                    inner_offset = next_offset;
1001                } else {
1002                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1003                    inner_depth.increment()?;
1004                }
1005                let val_ref = self.fvm_data_slices.get_or_insert_with(|| fidl::new_empty!(u32, D));
1006                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1007                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1008                {
1009                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1010                }
1011                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1012                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1013                }
1014            }
1015
1016            next_offset += envelope_size;
1017            _next_ordinal_to_read += 1;
1018            if next_offset >= end_offset {
1019                return Ok(());
1020            }
1021
1022            // Decode unknown envelopes for gaps in ordinals.
1023            while _next_ordinal_to_read < 5 {
1024                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1025                _next_ordinal_to_read += 1;
1026                next_offset += envelope_size;
1027            }
1028
1029            let next_out_of_line = decoder.next_out_of_line();
1030            let handles_before = decoder.remaining_handles();
1031            if let Some((inlined, num_bytes, num_handles)) =
1032                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1033            {
1034                let member_inline_size =
1035                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1036                if inlined != (member_inline_size <= 4) {
1037                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1038                }
1039                let inner_offset;
1040                let mut inner_depth = depth.clone();
1041                if inlined {
1042                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1043                    inner_offset = next_offset;
1044                } else {
1045                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1046                    inner_depth.increment()?;
1047                }
1048                let val_ref =
1049                    self.sectors_per_cluster.get_or_insert_with(|| fidl::new_empty!(u16, D));
1050                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
1051                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1052                {
1053                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1054                }
1055                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1056                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1057                }
1058            }
1059
1060            next_offset += envelope_size;
1061
1062            // Decode the remaining unknown envelopes.
1063            while next_offset < end_offset {
1064                _next_ordinal_to_read += 1;
1065                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1066                next_offset += envelope_size;
1067            }
1068
1069            Ok(())
1070        }
1071    }
1072}