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#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
12#[repr(C)]
13pub struct VolumeSetLimitRequest {
14    pub bytes: u64,
15}
16
17impl fidl::Persistable for VolumeSetLimitRequest {}
18
19#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
20#[repr(C)]
21pub struct VolumeGetLimitResponse {
22    pub bytes: u64,
23}
24
25impl fidl::Persistable for VolumeGetLimitResponse {}
26
27#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
28pub struct VolumesRemoveRequest {
29    pub name: String,
30}
31
32impl fidl::Persistable for VolumesRemoveRequest {}
33
34#[derive(Clone, Debug, PartialEq)]
35pub struct VolumesGetInfoResponse {
36    pub info: Option<Box<fidl_fuchsia_storage_block__common::VolumeManagerInfo>>,
37}
38
39impl fidl::Persistable for VolumesGetInfoResponse {}
40
41/// Options for how to format filesystems.
42#[derive(Clone, Debug, Default, PartialEq)]
43pub struct FormatOptions {
44    /// Enable verbose logging.
45    pub verbose: Option<bool>,
46    /// If true, use the deprecated padded merkle tree blobfs format.
47    pub deprecated_padded_blobfs_format: Option<bool>,
48    /// The initial number of inodes to allocate space for. If zero, a default is used. Only
49    /// supported for blobfs.
50    pub num_inodes: Option<u64>,
51    /// The number of fvm slices to preallocate for data when the filesystem is created.
52    pub fvm_data_slices: Option<u32>,
53    /// The number of sectors-per-cluster (for FAT filesystems).
54    pub sectors_per_cluster: Option<u16>,
55    /// The slice size for FVM (in bytes).
56    pub fvm_slice_size: Option<u64>,
57    #[doc(hidden)]
58    pub __source_breaking: fidl::marker::SourceBreaking,
59}
60
61impl fidl::Persistable for FormatOptions {}
62
63/// Options for starting a filesystem.
64#[derive(Clone, Debug, Default, PartialEq)]
65pub struct StartOptions {
66    /// Start the filesystem in read-only mode.
67    pub read_only: Option<bool>,
68    /// Enable verbose logging.
69    pub verbose: Option<bool>,
70    /// If true, run fsck after every transaction. This is for testing purposes only - it's very
71    /// slow to run a filesystem like this.
72    pub fsck_after_every_transaction: Option<bool>,
73    /// Use profiling for the first N seconds after filesystem start. Records the access patterns
74    /// of objects for N seconds and if the profile already exists, prefetch data and hold the vmos
75    /// in cache for N seconds. Functionally this means that the first launch with this option
76    /// records the profile and all other launches with this option will replay that profile.
77    pub startup_profiling_seconds: Option<u32>,
78    /// If true, configures the filesystem to use the hardware's inline encryption engine when
79    /// writing encrypted data. This allows the filesystem to store user-encrypted data without
80    /// being able to read or write the plaintext contents, which enhances security and privacy.
81    /// Requires the block device to support inline encryption and for `barriers_enabled` to be
82    /// true.
83    /// TODO(https://fxbug.dev/393196849): For now, this flag only prevents the filesystem from
84    /// computing checksums. Update this comment when the filesystem actually uses inline
85    /// encryption.
86    pub inline_crypto_enabled: Option<bool>,
87    /// Configures the filesystem to use barriers instead of checksums to ensure consistency. If
88    /// set, barriers will be used to enforce proper ordering of data and metadata writes, which
89    /// is otherwise provided by computing and verifying data checksums.  Requires filesystem
90    /// support; at the time of writing, only Fxfs uses this argument.
91    /// Must be set to true if `inline_crypto_enabled` is true.
92    pub barriers_enabled: Option<bool>,
93    /// Only valid for GPT.
94    /// Configures the GPT to merge the `super` and `userdata` partitions into an overlay partition
95    /// `fxfs` when possible.  The partitions must be physically contiguous.  See
96    /// fuchsia.storage.partitions.OverlayPartition for more details.
97    pub merge_super_and_userdata: Option<bool>,
98    #[doc(hidden)]
99    pub __source_breaking: fidl::marker::SourceBreaking,
100}
101
102impl fidl::Persistable for StartOptions {}
103
104#[derive(Clone, Debug, Default, PartialEq)]
105pub struct VolumeInfo {
106    pub guid: Option<[u8; 16]>,
107    #[doc(hidden)]
108    pub __source_breaking: fidl::marker::SourceBreaking,
109}
110
111impl fidl::Persistable for VolumeInfo {}
112
113pub mod startup_ordinals {
114    pub const START: u64 = 0x317aa9458d3190c8;
115    pub const FORMAT: u64 = 0x3124676dd91933de;
116    pub const CHECK: u64 = 0x81e85b3190e7db3;
117}
118
119pub mod volume_ordinals {
120    pub const MOUNT: u64 = 0x3470ab56d455af0;
121    pub const CHECK: u64 = 0x5b638348f5e0418c;
122    pub const SET_LIMIT: u64 = 0x19286d83eb3cd137;
123    pub const GET_LIMIT: u64 = 0xb14e4950939f16;
124    pub const GET_INFO: u64 = 0x481018250e109f53;
125}
126
127pub mod volumes_ordinals {
128    pub const CREATE: u64 = 0x11a55097834b38e8;
129    pub const REMOVE: u64 = 0x70983b9344dc2292;
130    pub const GET_INFO: u64 = 0x50d2962df9a0746e;
131}
132
133mod internal {
134    use super::*;
135
136    impl fidl::encoding::ValueTypeMarker for VolumeSetLimitRequest {
137        type Borrowed<'a> = &'a Self;
138        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
139            value
140        }
141    }
142
143    unsafe impl fidl::encoding::TypeMarker for VolumeSetLimitRequest {
144        type Owned = Self;
145
146        #[inline(always)]
147        fn inline_align(_context: fidl::encoding::Context) -> usize {
148            8
149        }
150
151        #[inline(always)]
152        fn inline_size(_context: fidl::encoding::Context) -> usize {
153            8
154        }
155        #[inline(always)]
156        fn encode_is_copy() -> bool {
157            true
158        }
159
160        #[inline(always)]
161        fn decode_is_copy() -> bool {
162            true
163        }
164    }
165
166    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumeSetLimitRequest, D>
167        for &VolumeSetLimitRequest
168    {
169        #[inline]
170        unsafe fn encode(
171            self,
172            encoder: &mut fidl::encoding::Encoder<'_, D>,
173            offset: usize,
174            _depth: fidl::encoding::Depth,
175        ) -> fidl::Result<()> {
176            encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
177            unsafe {
178                // Copy the object into the buffer.
179                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
180                (buf_ptr as *mut VolumeSetLimitRequest)
181                    .write_unaligned((self as *const VolumeSetLimitRequest).read());
182                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
183                // done second because the memcpy will write garbage to these bytes.
184            }
185            Ok(())
186        }
187    }
188    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
189        fidl::encoding::Encode<VolumeSetLimitRequest, D> for (T0,)
190    {
191        #[inline]
192        unsafe fn encode(
193            self,
194            encoder: &mut fidl::encoding::Encoder<'_, D>,
195            offset: usize,
196            depth: fidl::encoding::Depth,
197        ) -> fidl::Result<()> {
198            encoder.debug_check_bounds::<VolumeSetLimitRequest>(offset);
199            // Zero out padding regions. There's no need to apply masks
200            // because the unmasked parts will be overwritten by fields.
201            // Write the fields.
202            self.0.encode(encoder, offset + 0, depth)?;
203            Ok(())
204        }
205    }
206
207    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumeSetLimitRequest {
208        #[inline(always)]
209        fn new_empty() -> Self {
210            Self { bytes: fidl::new_empty!(u64, D) }
211        }
212
213        #[inline]
214        unsafe fn decode(
215            &mut self,
216            decoder: &mut fidl::encoding::Decoder<'_, D>,
217            offset: usize,
218            _depth: fidl::encoding::Depth,
219        ) -> fidl::Result<()> {
220            decoder.debug_check_bounds::<Self>(offset);
221            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
222            // Verify that padding bytes are zero.
223            // Copy from the buffer into the object.
224            unsafe {
225                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
226            }
227            Ok(())
228        }
229    }
230
231    impl fidl::encoding::ValueTypeMarker for VolumeGetLimitResponse {
232        type Borrowed<'a> = &'a Self;
233        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
234            value
235        }
236    }
237
238    unsafe impl fidl::encoding::TypeMarker for VolumeGetLimitResponse {
239        type Owned = Self;
240
241        #[inline(always)]
242        fn inline_align(_context: fidl::encoding::Context) -> usize {
243            8
244        }
245
246        #[inline(always)]
247        fn inline_size(_context: fidl::encoding::Context) -> usize {
248            8
249        }
250        #[inline(always)]
251        fn encode_is_copy() -> bool {
252            true
253        }
254
255        #[inline(always)]
256        fn decode_is_copy() -> bool {
257            true
258        }
259    }
260
261    unsafe impl<D: fidl::encoding::ResourceDialect>
262        fidl::encoding::Encode<VolumeGetLimitResponse, D> for &VolumeGetLimitResponse
263    {
264        #[inline]
265        unsafe fn encode(
266            self,
267            encoder: &mut fidl::encoding::Encoder<'_, D>,
268            offset: usize,
269            _depth: fidl::encoding::Depth,
270        ) -> fidl::Result<()> {
271            encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
272            unsafe {
273                // Copy the object into the buffer.
274                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
275                (buf_ptr as *mut VolumeGetLimitResponse)
276                    .write_unaligned((self as *const VolumeGetLimitResponse).read());
277                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
278                // done second because the memcpy will write garbage to these bytes.
279            }
280            Ok(())
281        }
282    }
283    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
284        fidl::encoding::Encode<VolumeGetLimitResponse, D> for (T0,)
285    {
286        #[inline]
287        unsafe fn encode(
288            self,
289            encoder: &mut fidl::encoding::Encoder<'_, D>,
290            offset: usize,
291            depth: fidl::encoding::Depth,
292        ) -> fidl::Result<()> {
293            encoder.debug_check_bounds::<VolumeGetLimitResponse>(offset);
294            // Zero out padding regions. There's no need to apply masks
295            // because the unmasked parts will be overwritten by fields.
296            // Write the fields.
297            self.0.encode(encoder, offset + 0, depth)?;
298            Ok(())
299        }
300    }
301
302    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
303        for VolumeGetLimitResponse
304    {
305        #[inline(always)]
306        fn new_empty() -> Self {
307            Self { bytes: fidl::new_empty!(u64, D) }
308        }
309
310        #[inline]
311        unsafe fn decode(
312            &mut self,
313            decoder: &mut fidl::encoding::Decoder<'_, D>,
314            offset: usize,
315            _depth: fidl::encoding::Depth,
316        ) -> fidl::Result<()> {
317            decoder.debug_check_bounds::<Self>(offset);
318            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
319            // Verify that padding bytes are zero.
320            // Copy from the buffer into the object.
321            unsafe {
322                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
323            }
324            Ok(())
325        }
326    }
327
328    impl fidl::encoding::ValueTypeMarker for VolumesRemoveRequest {
329        type Borrowed<'a> = &'a Self;
330        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
331            value
332        }
333    }
334
335    unsafe impl fidl::encoding::TypeMarker for VolumesRemoveRequest {
336        type Owned = Self;
337
338        #[inline(always)]
339        fn inline_align(_context: fidl::encoding::Context) -> usize {
340            8
341        }
342
343        #[inline(always)]
344        fn inline_size(_context: fidl::encoding::Context) -> usize {
345            16
346        }
347    }
348
349    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumesRemoveRequest, D>
350        for &VolumesRemoveRequest
351    {
352        #[inline]
353        unsafe fn encode(
354            self,
355            encoder: &mut fidl::encoding::Encoder<'_, D>,
356            offset: usize,
357            _depth: fidl::encoding::Depth,
358        ) -> fidl::Result<()> {
359            encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
360            // Delegate to tuple encoding.
361            fidl::encoding::Encode::<VolumesRemoveRequest, D>::encode(
362                (<fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
363                    &self.name,
364                ),),
365                encoder,
366                offset,
367                _depth,
368            )
369        }
370    }
371    unsafe impl<
372        D: fidl::encoding::ResourceDialect,
373        T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
374    > fidl::encoding::Encode<VolumesRemoveRequest, D> for (T0,)
375    {
376        #[inline]
377        unsafe fn encode(
378            self,
379            encoder: &mut fidl::encoding::Encoder<'_, D>,
380            offset: usize,
381            depth: fidl::encoding::Depth,
382        ) -> fidl::Result<()> {
383            encoder.debug_check_bounds::<VolumesRemoveRequest>(offset);
384            // Zero out padding regions. There's no need to apply masks
385            // because the unmasked parts will be overwritten by fields.
386            // Write the fields.
387            self.0.encode(encoder, offset + 0, depth)?;
388            Ok(())
389        }
390    }
391
392    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumesRemoveRequest {
393        #[inline(always)]
394        fn new_empty() -> Self {
395            Self { name: fidl::new_empty!(fidl::encoding::BoundedString<255>, D) }
396        }
397
398        #[inline]
399        unsafe fn decode(
400            &mut self,
401            decoder: &mut fidl::encoding::Decoder<'_, D>,
402            offset: usize,
403            _depth: fidl::encoding::Depth,
404        ) -> fidl::Result<()> {
405            decoder.debug_check_bounds::<Self>(offset);
406            // Verify that padding bytes are zero.
407            fidl::decode!(
408                fidl::encoding::BoundedString<255>,
409                D,
410                &mut self.name,
411                decoder,
412                offset + 0,
413                _depth
414            )?;
415            Ok(())
416        }
417    }
418
419    impl fidl::encoding::ValueTypeMarker for VolumesGetInfoResponse {
420        type Borrowed<'a> = &'a Self;
421        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
422            value
423        }
424    }
425
426    unsafe impl fidl::encoding::TypeMarker for VolumesGetInfoResponse {
427        type Owned = Self;
428
429        #[inline(always)]
430        fn inline_align(_context: fidl::encoding::Context) -> usize {
431            8
432        }
433
434        #[inline(always)]
435        fn inline_size(_context: fidl::encoding::Context) -> usize {
436            8
437        }
438    }
439
440    unsafe impl<D: fidl::encoding::ResourceDialect>
441        fidl::encoding::Encode<VolumesGetInfoResponse, D> for &VolumesGetInfoResponse
442    {
443        #[inline]
444        unsafe fn encode(
445            self,
446            encoder: &mut fidl::encoding::Encoder<'_, D>,
447            offset: usize,
448            _depth: fidl::encoding::Depth,
449        ) -> fidl::Result<()> {
450            encoder.debug_check_bounds::<VolumesGetInfoResponse>(offset);
451            // Delegate to tuple encoding.
452            fidl::encoding::Encode::<VolumesGetInfoResponse, D>::encode(
453                (
454                    <fidl::encoding::Boxed<fidl_fuchsia_storage_block__common::VolumeManagerInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.info),
455                ),
456                encoder, offset, _depth
457            )
458        }
459    }
460    unsafe impl<
461        D: fidl::encoding::ResourceDialect,
462        T0: fidl::encoding::Encode<
463                fidl::encoding::Boxed<fidl_fuchsia_storage_block__common::VolumeManagerInfo>,
464                D,
465            >,
466    > fidl::encoding::Encode<VolumesGetInfoResponse, D> for (T0,)
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::<VolumesGetInfoResponse>(offset);
476            // Zero out padding regions. There's no need to apply masks
477            // because the unmasked parts will be overwritten by fields.
478            // Write the fields.
479            self.0.encode(encoder, offset + 0, depth)?;
480            Ok(())
481        }
482    }
483
484    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
485        for VolumesGetInfoResponse
486    {
487        #[inline(always)]
488        fn new_empty() -> Self {
489            Self {
490                info: fidl::new_empty!(
491                    fidl::encoding::Boxed<fidl_fuchsia_storage_block__common::VolumeManagerInfo>,
492                    D
493                ),
494            }
495        }
496
497        #[inline]
498        unsafe fn decode(
499            &mut self,
500            decoder: &mut fidl::encoding::Decoder<'_, D>,
501            offset: usize,
502            _depth: fidl::encoding::Depth,
503        ) -> fidl::Result<()> {
504            decoder.debug_check_bounds::<Self>(offset);
505            // Verify that padding bytes are zero.
506            fidl::decode!(
507                fidl::encoding::Boxed<fidl_fuchsia_storage_block__common::VolumeManagerInfo>,
508                D,
509                &mut self.info,
510                decoder,
511                offset + 0,
512                _depth
513            )?;
514            Ok(())
515        }
516    }
517
518    impl FormatOptions {
519        #[inline(always)]
520        fn max_ordinal_present(&self) -> u64 {
521            if let Some(_) = self.fvm_slice_size {
522                return 6;
523            }
524            if let Some(_) = self.sectors_per_cluster {
525                return 5;
526            }
527            if let Some(_) = self.fvm_data_slices {
528                return 4;
529            }
530            if let Some(_) = self.num_inodes {
531                return 3;
532            }
533            if let Some(_) = self.deprecated_padded_blobfs_format {
534                return 2;
535            }
536            if let Some(_) = self.verbose {
537                return 1;
538            }
539            0
540        }
541    }
542
543    impl fidl::encoding::ValueTypeMarker for FormatOptions {
544        type Borrowed<'a> = &'a Self;
545        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
546            value
547        }
548    }
549
550    unsafe impl fidl::encoding::TypeMarker for FormatOptions {
551        type Owned = Self;
552
553        #[inline(always)]
554        fn inline_align(_context: fidl::encoding::Context) -> usize {
555            8
556        }
557
558        #[inline(always)]
559        fn inline_size(_context: fidl::encoding::Context) -> usize {
560            16
561        }
562    }
563
564    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FormatOptions, D>
565        for &FormatOptions
566    {
567        unsafe fn encode(
568            self,
569            encoder: &mut fidl::encoding::Encoder<'_, D>,
570            offset: usize,
571            mut depth: fidl::encoding::Depth,
572        ) -> fidl::Result<()> {
573            encoder.debug_check_bounds::<FormatOptions>(offset);
574            // Vector header
575            let max_ordinal: u64 = self.max_ordinal_present();
576            encoder.write_num(max_ordinal, offset);
577            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
578            // Calling encoder.out_of_line_offset(0) is not allowed.
579            if max_ordinal == 0 {
580                return Ok(());
581            }
582            depth.increment()?;
583            let envelope_size = 8;
584            let bytes_len = max_ordinal as usize * envelope_size;
585            #[allow(unused_variables)]
586            let offset = encoder.out_of_line_offset(bytes_len);
587            let mut _prev_end_offset: usize = 0;
588            if 1 > max_ordinal {
589                return Ok(());
590            }
591
592            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
593            // are envelope_size bytes.
594            let cur_offset: usize = (1 - 1) * envelope_size;
595
596            // Zero reserved fields.
597            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
598
599            // Safety:
600            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
601            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
602            //   envelope_size bytes, there is always sufficient room.
603            fidl::encoding::encode_in_envelope_optional::<bool, D>(
604                self.verbose.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
605                encoder,
606                offset + cur_offset,
607                depth,
608            )?;
609
610            _prev_end_offset = cur_offset + envelope_size;
611            if 2 > max_ordinal {
612                return Ok(());
613            }
614
615            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
616            // are envelope_size bytes.
617            let cur_offset: usize = (2 - 1) * envelope_size;
618
619            // Zero reserved fields.
620            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
621
622            // Safety:
623            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
624            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
625            //   envelope_size bytes, there is always sufficient room.
626            fidl::encoding::encode_in_envelope_optional::<bool, D>(
627                self.deprecated_padded_blobfs_format
628                    .as_ref()
629                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
630                encoder,
631                offset + cur_offset,
632                depth,
633            )?;
634
635            _prev_end_offset = cur_offset + envelope_size;
636            if 3 > max_ordinal {
637                return Ok(());
638            }
639
640            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
641            // are envelope_size bytes.
642            let cur_offset: usize = (3 - 1) * envelope_size;
643
644            // Zero reserved fields.
645            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
646
647            // Safety:
648            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
649            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
650            //   envelope_size bytes, there is always sufficient room.
651            fidl::encoding::encode_in_envelope_optional::<u64, D>(
652                self.num_inodes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
653                encoder,
654                offset + cur_offset,
655                depth,
656            )?;
657
658            _prev_end_offset = cur_offset + envelope_size;
659            if 4 > max_ordinal {
660                return Ok(());
661            }
662
663            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
664            // are envelope_size bytes.
665            let cur_offset: usize = (4 - 1) * envelope_size;
666
667            // Zero reserved fields.
668            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
669
670            // Safety:
671            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
672            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
673            //   envelope_size bytes, there is always sufficient room.
674            fidl::encoding::encode_in_envelope_optional::<u32, D>(
675                self.fvm_data_slices.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
676                encoder,
677                offset + cur_offset,
678                depth,
679            )?;
680
681            _prev_end_offset = cur_offset + envelope_size;
682            if 5 > max_ordinal {
683                return Ok(());
684            }
685
686            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
687            // are envelope_size bytes.
688            let cur_offset: usize = (5 - 1) * envelope_size;
689
690            // Zero reserved fields.
691            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
692
693            // Safety:
694            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
695            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
696            //   envelope_size bytes, there is always sufficient room.
697            fidl::encoding::encode_in_envelope_optional::<u16, D>(
698                self.sectors_per_cluster
699                    .as_ref()
700                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
701                encoder,
702                offset + cur_offset,
703                depth,
704            )?;
705
706            _prev_end_offset = cur_offset + envelope_size;
707            if 6 > max_ordinal {
708                return Ok(());
709            }
710
711            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
712            // are envelope_size bytes.
713            let cur_offset: usize = (6 - 1) * envelope_size;
714
715            // Zero reserved fields.
716            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
717
718            // Safety:
719            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
720            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
721            //   envelope_size bytes, there is always sufficient room.
722            fidl::encoding::encode_in_envelope_optional::<u64, D>(
723                self.fvm_slice_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
724                encoder,
725                offset + cur_offset,
726                depth,
727            )?;
728
729            _prev_end_offset = cur_offset + envelope_size;
730
731            Ok(())
732        }
733    }
734
735    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FormatOptions {
736        #[inline(always)]
737        fn new_empty() -> Self {
738            Self::default()
739        }
740
741        unsafe fn decode(
742            &mut self,
743            decoder: &mut fidl::encoding::Decoder<'_, D>,
744            offset: usize,
745            mut depth: fidl::encoding::Depth,
746        ) -> fidl::Result<()> {
747            decoder.debug_check_bounds::<Self>(offset);
748            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
749                None => return Err(fidl::Error::NotNullable),
750                Some(len) => len,
751            };
752            // Calling decoder.out_of_line_offset(0) is not allowed.
753            if len == 0 {
754                return Ok(());
755            };
756            depth.increment()?;
757            let envelope_size = 8;
758            let bytes_len = len * envelope_size;
759            let offset = decoder.out_of_line_offset(bytes_len)?;
760            // Decode the envelope for each type.
761            let mut _next_ordinal_to_read = 0;
762            let mut next_offset = offset;
763            let end_offset = offset + bytes_len;
764            _next_ordinal_to_read += 1;
765            if next_offset >= end_offset {
766                return Ok(());
767            }
768
769            // Decode unknown envelopes for gaps in ordinals.
770            while _next_ordinal_to_read < 1 {
771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
772                _next_ordinal_to_read += 1;
773                next_offset += envelope_size;
774            }
775
776            let next_out_of_line = decoder.next_out_of_line();
777            let handles_before = decoder.remaining_handles();
778            if let Some((inlined, num_bytes, num_handles)) =
779                fidl::encoding::decode_envelope_header(decoder, next_offset)?
780            {
781                let member_inline_size =
782                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
783                if inlined != (member_inline_size <= 4) {
784                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
785                }
786                let inner_offset;
787                let mut inner_depth = depth.clone();
788                if inlined {
789                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
790                    inner_offset = next_offset;
791                } else {
792                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
793                    inner_depth.increment()?;
794                }
795                let val_ref = self.verbose.get_or_insert_with(|| fidl::new_empty!(bool, D));
796                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
797                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
798                {
799                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
800                }
801                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
802                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
803                }
804            }
805
806            next_offset += envelope_size;
807            _next_ordinal_to_read += 1;
808            if next_offset >= end_offset {
809                return Ok(());
810            }
811
812            // Decode unknown envelopes for gaps in ordinals.
813            while _next_ordinal_to_read < 2 {
814                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
815                _next_ordinal_to_read += 1;
816                next_offset += envelope_size;
817            }
818
819            let next_out_of_line = decoder.next_out_of_line();
820            let handles_before = decoder.remaining_handles();
821            if let Some((inlined, num_bytes, num_handles)) =
822                fidl::encoding::decode_envelope_header(decoder, next_offset)?
823            {
824                let member_inline_size =
825                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
826                if inlined != (member_inline_size <= 4) {
827                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
828                }
829                let inner_offset;
830                let mut inner_depth = depth.clone();
831                if inlined {
832                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
833                    inner_offset = next_offset;
834                } else {
835                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
836                    inner_depth.increment()?;
837                }
838                let val_ref = self
839                    .deprecated_padded_blobfs_format
840                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
841                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
842                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
843                {
844                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
845                }
846                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
847                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
848                }
849            }
850
851            next_offset += envelope_size;
852            _next_ordinal_to_read += 1;
853            if next_offset >= end_offset {
854                return Ok(());
855            }
856
857            // Decode unknown envelopes for gaps in ordinals.
858            while _next_ordinal_to_read < 3 {
859                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
860                _next_ordinal_to_read += 1;
861                next_offset += envelope_size;
862            }
863
864            let next_out_of_line = decoder.next_out_of_line();
865            let handles_before = decoder.remaining_handles();
866            if let Some((inlined, num_bytes, num_handles)) =
867                fidl::encoding::decode_envelope_header(decoder, next_offset)?
868            {
869                let member_inline_size =
870                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
871                if inlined != (member_inline_size <= 4) {
872                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
873                }
874                let inner_offset;
875                let mut inner_depth = depth.clone();
876                if inlined {
877                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
878                    inner_offset = next_offset;
879                } else {
880                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
881                    inner_depth.increment()?;
882                }
883                let val_ref = self.num_inodes.get_or_insert_with(|| fidl::new_empty!(u64, D));
884                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
885                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
886                {
887                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
888                }
889                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
890                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
891                }
892            }
893
894            next_offset += envelope_size;
895            _next_ordinal_to_read += 1;
896            if next_offset >= end_offset {
897                return Ok(());
898            }
899
900            // Decode unknown envelopes for gaps in ordinals.
901            while _next_ordinal_to_read < 4 {
902                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
903                _next_ordinal_to_read += 1;
904                next_offset += envelope_size;
905            }
906
907            let next_out_of_line = decoder.next_out_of_line();
908            let handles_before = decoder.remaining_handles();
909            if let Some((inlined, num_bytes, num_handles)) =
910                fidl::encoding::decode_envelope_header(decoder, next_offset)?
911            {
912                let member_inline_size =
913                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
914                if inlined != (member_inline_size <= 4) {
915                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
916                }
917                let inner_offset;
918                let mut inner_depth = depth.clone();
919                if inlined {
920                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
921                    inner_offset = next_offset;
922                } else {
923                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
924                    inner_depth.increment()?;
925                }
926                let val_ref = self.fvm_data_slices.get_or_insert_with(|| fidl::new_empty!(u32, D));
927                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
928                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
929                {
930                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
931                }
932                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
933                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
934                }
935            }
936
937            next_offset += envelope_size;
938            _next_ordinal_to_read += 1;
939            if next_offset >= end_offset {
940                return Ok(());
941            }
942
943            // Decode unknown envelopes for gaps in ordinals.
944            while _next_ordinal_to_read < 5 {
945                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
946                _next_ordinal_to_read += 1;
947                next_offset += envelope_size;
948            }
949
950            let next_out_of_line = decoder.next_out_of_line();
951            let handles_before = decoder.remaining_handles();
952            if let Some((inlined, num_bytes, num_handles)) =
953                fidl::encoding::decode_envelope_header(decoder, next_offset)?
954            {
955                let member_inline_size =
956                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
957                if inlined != (member_inline_size <= 4) {
958                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
959                }
960                let inner_offset;
961                let mut inner_depth = depth.clone();
962                if inlined {
963                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
964                    inner_offset = next_offset;
965                } else {
966                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
967                    inner_depth.increment()?;
968                }
969                let val_ref =
970                    self.sectors_per_cluster.get_or_insert_with(|| fidl::new_empty!(u16, D));
971                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
972                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
973                {
974                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
975                }
976                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
977                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
978                }
979            }
980
981            next_offset += envelope_size;
982            _next_ordinal_to_read += 1;
983            if next_offset >= end_offset {
984                return Ok(());
985            }
986
987            // Decode unknown envelopes for gaps in ordinals.
988            while _next_ordinal_to_read < 6 {
989                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
990                _next_ordinal_to_read += 1;
991                next_offset += envelope_size;
992            }
993
994            let next_out_of_line = decoder.next_out_of_line();
995            let handles_before = decoder.remaining_handles();
996            if let Some((inlined, num_bytes, num_handles)) =
997                fidl::encoding::decode_envelope_header(decoder, next_offset)?
998            {
999                let member_inline_size =
1000                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1001                if inlined != (member_inline_size <= 4) {
1002                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1003                }
1004                let inner_offset;
1005                let mut inner_depth = depth.clone();
1006                if inlined {
1007                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1008                    inner_offset = next_offset;
1009                } else {
1010                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1011                    inner_depth.increment()?;
1012                }
1013                let val_ref = self.fvm_slice_size.get_or_insert_with(|| fidl::new_empty!(u64, D));
1014                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1015                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1016                {
1017                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1018                }
1019                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1020                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1021                }
1022            }
1023
1024            next_offset += envelope_size;
1025
1026            // Decode the remaining unknown envelopes.
1027            while next_offset < end_offset {
1028                _next_ordinal_to_read += 1;
1029                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1030                next_offset += envelope_size;
1031            }
1032
1033            Ok(())
1034        }
1035    }
1036
1037    impl StartOptions {
1038        #[inline(always)]
1039        fn max_ordinal_present(&self) -> u64 {
1040            if let Some(_) = self.merge_super_and_userdata {
1041                return 10;
1042            }
1043            if let Some(_) = self.barriers_enabled {
1044                return 9;
1045            }
1046            if let Some(_) = self.inline_crypto_enabled {
1047                return 8;
1048            }
1049            if let Some(_) = self.startup_profiling_seconds {
1050                return 7;
1051            }
1052            if let Some(_) = self.fsck_after_every_transaction {
1053                return 3;
1054            }
1055            if let Some(_) = self.verbose {
1056                return 2;
1057            }
1058            if let Some(_) = self.read_only {
1059                return 1;
1060            }
1061            0
1062        }
1063    }
1064
1065    impl fidl::encoding::ValueTypeMarker for StartOptions {
1066        type Borrowed<'a> = &'a Self;
1067        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1068            value
1069        }
1070    }
1071
1072    unsafe impl fidl::encoding::TypeMarker for StartOptions {
1073        type Owned = Self;
1074
1075        #[inline(always)]
1076        fn inline_align(_context: fidl::encoding::Context) -> usize {
1077            8
1078        }
1079
1080        #[inline(always)]
1081        fn inline_size(_context: fidl::encoding::Context) -> usize {
1082            16
1083        }
1084    }
1085
1086    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StartOptions, D>
1087        for &StartOptions
1088    {
1089        unsafe fn encode(
1090            self,
1091            encoder: &mut fidl::encoding::Encoder<'_, D>,
1092            offset: usize,
1093            mut depth: fidl::encoding::Depth,
1094        ) -> fidl::Result<()> {
1095            encoder.debug_check_bounds::<StartOptions>(offset);
1096            // Vector header
1097            let max_ordinal: u64 = self.max_ordinal_present();
1098            encoder.write_num(max_ordinal, offset);
1099            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1100            // Calling encoder.out_of_line_offset(0) is not allowed.
1101            if max_ordinal == 0 {
1102                return Ok(());
1103            }
1104            depth.increment()?;
1105            let envelope_size = 8;
1106            let bytes_len = max_ordinal as usize * envelope_size;
1107            #[allow(unused_variables)]
1108            let offset = encoder.out_of_line_offset(bytes_len);
1109            let mut _prev_end_offset: usize = 0;
1110            if 1 > max_ordinal {
1111                return Ok(());
1112            }
1113
1114            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1115            // are envelope_size bytes.
1116            let cur_offset: usize = (1 - 1) * envelope_size;
1117
1118            // Zero reserved fields.
1119            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1120
1121            // Safety:
1122            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1123            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1124            //   envelope_size bytes, there is always sufficient room.
1125            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1126                self.read_only.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1127                encoder,
1128                offset + cur_offset,
1129                depth,
1130            )?;
1131
1132            _prev_end_offset = cur_offset + envelope_size;
1133            if 2 > max_ordinal {
1134                return Ok(());
1135            }
1136
1137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1138            // are envelope_size bytes.
1139            let cur_offset: usize = (2 - 1) * envelope_size;
1140
1141            // Zero reserved fields.
1142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1143
1144            // Safety:
1145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1147            //   envelope_size bytes, there is always sufficient room.
1148            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1149                self.verbose.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1150                encoder,
1151                offset + cur_offset,
1152                depth,
1153            )?;
1154
1155            _prev_end_offset = cur_offset + envelope_size;
1156            if 3 > max_ordinal {
1157                return Ok(());
1158            }
1159
1160            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1161            // are envelope_size bytes.
1162            let cur_offset: usize = (3 - 1) * envelope_size;
1163
1164            // Zero reserved fields.
1165            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1166
1167            // Safety:
1168            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1169            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1170            //   envelope_size bytes, there is always sufficient room.
1171            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1172                self.fsck_after_every_transaction
1173                    .as_ref()
1174                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1175                encoder,
1176                offset + cur_offset,
1177                depth,
1178            )?;
1179
1180            _prev_end_offset = cur_offset + envelope_size;
1181            if 7 > max_ordinal {
1182                return Ok(());
1183            }
1184
1185            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1186            // are envelope_size bytes.
1187            let cur_offset: usize = (7 - 1) * envelope_size;
1188
1189            // Zero reserved fields.
1190            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1191
1192            // Safety:
1193            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1194            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1195            //   envelope_size bytes, there is always sufficient room.
1196            fidl::encoding::encode_in_envelope_optional::<u32, D>(
1197                self.startup_profiling_seconds
1198                    .as_ref()
1199                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
1200                encoder,
1201                offset + cur_offset,
1202                depth,
1203            )?;
1204
1205            _prev_end_offset = cur_offset + envelope_size;
1206            if 8 > max_ordinal {
1207                return Ok(());
1208            }
1209
1210            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1211            // are envelope_size bytes.
1212            let cur_offset: usize = (8 - 1) * envelope_size;
1213
1214            // Zero reserved fields.
1215            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1216
1217            // Safety:
1218            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1219            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1220            //   envelope_size bytes, there is always sufficient room.
1221            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1222                self.inline_crypto_enabled
1223                    .as_ref()
1224                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1225                encoder,
1226                offset + cur_offset,
1227                depth,
1228            )?;
1229
1230            _prev_end_offset = cur_offset + envelope_size;
1231            if 9 > max_ordinal {
1232                return Ok(());
1233            }
1234
1235            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1236            // are envelope_size bytes.
1237            let cur_offset: usize = (9 - 1) * envelope_size;
1238
1239            // Zero reserved fields.
1240            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1241
1242            // Safety:
1243            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1244            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1245            //   envelope_size bytes, there is always sufficient room.
1246            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1247                self.barriers_enabled
1248                    .as_ref()
1249                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1250                encoder,
1251                offset + cur_offset,
1252                depth,
1253            )?;
1254
1255            _prev_end_offset = cur_offset + envelope_size;
1256            if 10 > max_ordinal {
1257                return Ok(());
1258            }
1259
1260            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1261            // are envelope_size bytes.
1262            let cur_offset: usize = (10 - 1) * envelope_size;
1263
1264            // Zero reserved fields.
1265            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1266
1267            // Safety:
1268            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1269            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1270            //   envelope_size bytes, there is always sufficient room.
1271            fidl::encoding::encode_in_envelope_optional::<bool, D>(
1272                self.merge_super_and_userdata
1273                    .as_ref()
1274                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
1275                encoder,
1276                offset + cur_offset,
1277                depth,
1278            )?;
1279
1280            _prev_end_offset = cur_offset + envelope_size;
1281
1282            Ok(())
1283        }
1284    }
1285
1286    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StartOptions {
1287        #[inline(always)]
1288        fn new_empty() -> Self {
1289            Self::default()
1290        }
1291
1292        unsafe fn decode(
1293            &mut self,
1294            decoder: &mut fidl::encoding::Decoder<'_, D>,
1295            offset: usize,
1296            mut depth: fidl::encoding::Depth,
1297        ) -> fidl::Result<()> {
1298            decoder.debug_check_bounds::<Self>(offset);
1299            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1300                None => return Err(fidl::Error::NotNullable),
1301                Some(len) => len,
1302            };
1303            // Calling decoder.out_of_line_offset(0) is not allowed.
1304            if len == 0 {
1305                return Ok(());
1306            };
1307            depth.increment()?;
1308            let envelope_size = 8;
1309            let bytes_len = len * envelope_size;
1310            let offset = decoder.out_of_line_offset(bytes_len)?;
1311            // Decode the envelope for each type.
1312            let mut _next_ordinal_to_read = 0;
1313            let mut next_offset = offset;
1314            let end_offset = offset + bytes_len;
1315            _next_ordinal_to_read += 1;
1316            if next_offset >= end_offset {
1317                return Ok(());
1318            }
1319
1320            // Decode unknown envelopes for gaps in ordinals.
1321            while _next_ordinal_to_read < 1 {
1322                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1323                _next_ordinal_to_read += 1;
1324                next_offset += envelope_size;
1325            }
1326
1327            let next_out_of_line = decoder.next_out_of_line();
1328            let handles_before = decoder.remaining_handles();
1329            if let Some((inlined, num_bytes, num_handles)) =
1330                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1331            {
1332                let member_inline_size =
1333                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1334                if inlined != (member_inline_size <= 4) {
1335                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1336                }
1337                let inner_offset;
1338                let mut inner_depth = depth.clone();
1339                if inlined {
1340                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1341                    inner_offset = next_offset;
1342                } else {
1343                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1344                    inner_depth.increment()?;
1345                }
1346                let val_ref = self.read_only.get_or_insert_with(|| fidl::new_empty!(bool, D));
1347                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1348                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1349                {
1350                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1351                }
1352                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1353                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1354                }
1355            }
1356
1357            next_offset += envelope_size;
1358            _next_ordinal_to_read += 1;
1359            if next_offset >= end_offset {
1360                return Ok(());
1361            }
1362
1363            // Decode unknown envelopes for gaps in ordinals.
1364            while _next_ordinal_to_read < 2 {
1365                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1366                _next_ordinal_to_read += 1;
1367                next_offset += envelope_size;
1368            }
1369
1370            let next_out_of_line = decoder.next_out_of_line();
1371            let handles_before = decoder.remaining_handles();
1372            if let Some((inlined, num_bytes, num_handles)) =
1373                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1374            {
1375                let member_inline_size =
1376                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1377                if inlined != (member_inline_size <= 4) {
1378                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1379                }
1380                let inner_offset;
1381                let mut inner_depth = depth.clone();
1382                if inlined {
1383                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1384                    inner_offset = next_offset;
1385                } else {
1386                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1387                    inner_depth.increment()?;
1388                }
1389                let val_ref = self.verbose.get_or_insert_with(|| fidl::new_empty!(bool, D));
1390                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1391                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1392                {
1393                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1394                }
1395                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1396                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1397                }
1398            }
1399
1400            next_offset += envelope_size;
1401            _next_ordinal_to_read += 1;
1402            if next_offset >= end_offset {
1403                return Ok(());
1404            }
1405
1406            // Decode unknown envelopes for gaps in ordinals.
1407            while _next_ordinal_to_read < 3 {
1408                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1409                _next_ordinal_to_read += 1;
1410                next_offset += envelope_size;
1411            }
1412
1413            let next_out_of_line = decoder.next_out_of_line();
1414            let handles_before = decoder.remaining_handles();
1415            if let Some((inlined, num_bytes, num_handles)) =
1416                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1417            {
1418                let member_inline_size =
1419                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1420                if inlined != (member_inline_size <= 4) {
1421                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1422                }
1423                let inner_offset;
1424                let mut inner_depth = depth.clone();
1425                if inlined {
1426                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1427                    inner_offset = next_offset;
1428                } else {
1429                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1430                    inner_depth.increment()?;
1431                }
1432                let val_ref = self
1433                    .fsck_after_every_transaction
1434                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
1435                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1436                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1437                {
1438                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1439                }
1440                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1441                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1442                }
1443            }
1444
1445            next_offset += envelope_size;
1446            _next_ordinal_to_read += 1;
1447            if next_offset >= end_offset {
1448                return Ok(());
1449            }
1450
1451            // Decode unknown envelopes for gaps in ordinals.
1452            while _next_ordinal_to_read < 7 {
1453                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1454                _next_ordinal_to_read += 1;
1455                next_offset += envelope_size;
1456            }
1457
1458            let next_out_of_line = decoder.next_out_of_line();
1459            let handles_before = decoder.remaining_handles();
1460            if let Some((inlined, num_bytes, num_handles)) =
1461                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1462            {
1463                let member_inline_size =
1464                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1465                if inlined != (member_inline_size <= 4) {
1466                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1467                }
1468                let inner_offset;
1469                let mut inner_depth = depth.clone();
1470                if inlined {
1471                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1472                    inner_offset = next_offset;
1473                } else {
1474                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1475                    inner_depth.increment()?;
1476                }
1477                let val_ref =
1478                    self.startup_profiling_seconds.get_or_insert_with(|| fidl::new_empty!(u32, D));
1479                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
1480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1481                {
1482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1483                }
1484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1486                }
1487            }
1488
1489            next_offset += envelope_size;
1490            _next_ordinal_to_read += 1;
1491            if next_offset >= end_offset {
1492                return Ok(());
1493            }
1494
1495            // Decode unknown envelopes for gaps in ordinals.
1496            while _next_ordinal_to_read < 8 {
1497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1498                _next_ordinal_to_read += 1;
1499                next_offset += envelope_size;
1500            }
1501
1502            let next_out_of_line = decoder.next_out_of_line();
1503            let handles_before = decoder.remaining_handles();
1504            if let Some((inlined, num_bytes, num_handles)) =
1505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1506            {
1507                let member_inline_size =
1508                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1509                if inlined != (member_inline_size <= 4) {
1510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1511                }
1512                let inner_offset;
1513                let mut inner_depth = depth.clone();
1514                if inlined {
1515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1516                    inner_offset = next_offset;
1517                } else {
1518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1519                    inner_depth.increment()?;
1520                }
1521                let val_ref =
1522                    self.inline_crypto_enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
1523                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1524                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1525                {
1526                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1527                }
1528                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1529                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1530                }
1531            }
1532
1533            next_offset += envelope_size;
1534            _next_ordinal_to_read += 1;
1535            if next_offset >= end_offset {
1536                return Ok(());
1537            }
1538
1539            // Decode unknown envelopes for gaps in ordinals.
1540            while _next_ordinal_to_read < 9 {
1541                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1542                _next_ordinal_to_read += 1;
1543                next_offset += envelope_size;
1544            }
1545
1546            let next_out_of_line = decoder.next_out_of_line();
1547            let handles_before = decoder.remaining_handles();
1548            if let Some((inlined, num_bytes, num_handles)) =
1549                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1550            {
1551                let member_inline_size =
1552                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1553                if inlined != (member_inline_size <= 4) {
1554                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1555                }
1556                let inner_offset;
1557                let mut inner_depth = depth.clone();
1558                if inlined {
1559                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1560                    inner_offset = next_offset;
1561                } else {
1562                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1563                    inner_depth.increment()?;
1564                }
1565                let val_ref =
1566                    self.barriers_enabled.get_or_insert_with(|| fidl::new_empty!(bool, D));
1567                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1568                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1569                {
1570                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1571                }
1572                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1573                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1574                }
1575            }
1576
1577            next_offset += envelope_size;
1578            _next_ordinal_to_read += 1;
1579            if next_offset >= end_offset {
1580                return Ok(());
1581            }
1582
1583            // Decode unknown envelopes for gaps in ordinals.
1584            while _next_ordinal_to_read < 10 {
1585                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1586                _next_ordinal_to_read += 1;
1587                next_offset += envelope_size;
1588            }
1589
1590            let next_out_of_line = decoder.next_out_of_line();
1591            let handles_before = decoder.remaining_handles();
1592            if let Some((inlined, num_bytes, num_handles)) =
1593                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1594            {
1595                let member_inline_size =
1596                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1597                if inlined != (member_inline_size <= 4) {
1598                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1599                }
1600                let inner_offset;
1601                let mut inner_depth = depth.clone();
1602                if inlined {
1603                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1604                    inner_offset = next_offset;
1605                } else {
1606                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1607                    inner_depth.increment()?;
1608                }
1609                let val_ref =
1610                    self.merge_super_and_userdata.get_or_insert_with(|| fidl::new_empty!(bool, D));
1611                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
1612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1613                {
1614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1615                }
1616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1618                }
1619            }
1620
1621            next_offset += envelope_size;
1622
1623            // Decode the remaining unknown envelopes.
1624            while next_offset < end_offset {
1625                _next_ordinal_to_read += 1;
1626                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1627                next_offset += envelope_size;
1628            }
1629
1630            Ok(())
1631        }
1632    }
1633
1634    impl VolumeInfo {
1635        #[inline(always)]
1636        fn max_ordinal_present(&self) -> u64 {
1637            if let Some(_) = self.guid {
1638                return 1;
1639            }
1640            0
1641        }
1642    }
1643
1644    impl fidl::encoding::ValueTypeMarker for VolumeInfo {
1645        type Borrowed<'a> = &'a Self;
1646        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1647            value
1648        }
1649    }
1650
1651    unsafe impl fidl::encoding::TypeMarker for VolumeInfo {
1652        type Owned = Self;
1653
1654        #[inline(always)]
1655        fn inline_align(_context: fidl::encoding::Context) -> usize {
1656            8
1657        }
1658
1659        #[inline(always)]
1660        fn inline_size(_context: fidl::encoding::Context) -> usize {
1661            16
1662        }
1663    }
1664
1665    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VolumeInfo, D>
1666        for &VolumeInfo
1667    {
1668        unsafe fn encode(
1669            self,
1670            encoder: &mut fidl::encoding::Encoder<'_, D>,
1671            offset: usize,
1672            mut depth: fidl::encoding::Depth,
1673        ) -> fidl::Result<()> {
1674            encoder.debug_check_bounds::<VolumeInfo>(offset);
1675            // Vector header
1676            let max_ordinal: u64 = self.max_ordinal_present();
1677            encoder.write_num(max_ordinal, offset);
1678            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1679            // Calling encoder.out_of_line_offset(0) is not allowed.
1680            if max_ordinal == 0 {
1681                return Ok(());
1682            }
1683            depth.increment()?;
1684            let envelope_size = 8;
1685            let bytes_len = max_ordinal as usize * envelope_size;
1686            #[allow(unused_variables)]
1687            let offset = encoder.out_of_line_offset(bytes_len);
1688            let mut _prev_end_offset: usize = 0;
1689            if 1 > max_ordinal {
1690                return Ok(());
1691            }
1692
1693            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1694            // are envelope_size bytes.
1695            let cur_offset: usize = (1 - 1) * envelope_size;
1696
1697            // Zero reserved fields.
1698            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1699
1700            // Safety:
1701            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1702            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1703            //   envelope_size bytes, there is always sufficient room.
1704            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
1705                self.guid.as_ref().map(
1706                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
1707                ),
1708                encoder,
1709                offset + cur_offset,
1710                depth,
1711            )?;
1712
1713            _prev_end_offset = cur_offset + envelope_size;
1714
1715            Ok(())
1716        }
1717    }
1718
1719    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VolumeInfo {
1720        #[inline(always)]
1721        fn new_empty() -> Self {
1722            Self::default()
1723        }
1724
1725        unsafe fn decode(
1726            &mut self,
1727            decoder: &mut fidl::encoding::Decoder<'_, D>,
1728            offset: usize,
1729            mut depth: fidl::encoding::Depth,
1730        ) -> fidl::Result<()> {
1731            decoder.debug_check_bounds::<Self>(offset);
1732            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1733                None => return Err(fidl::Error::NotNullable),
1734                Some(len) => len,
1735            };
1736            // Calling decoder.out_of_line_offset(0) is not allowed.
1737            if len == 0 {
1738                return Ok(());
1739            };
1740            depth.increment()?;
1741            let envelope_size = 8;
1742            let bytes_len = len * envelope_size;
1743            let offset = decoder.out_of_line_offset(bytes_len)?;
1744            // Decode the envelope for each type.
1745            let mut _next_ordinal_to_read = 0;
1746            let mut next_offset = offset;
1747            let end_offset = offset + bytes_len;
1748            _next_ordinal_to_read += 1;
1749            if next_offset >= end_offset {
1750                return Ok(());
1751            }
1752
1753            // Decode unknown envelopes for gaps in ordinals.
1754            while _next_ordinal_to_read < 1 {
1755                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1756                _next_ordinal_to_read += 1;
1757                next_offset += envelope_size;
1758            }
1759
1760            let next_out_of_line = decoder.next_out_of_line();
1761            let handles_before = decoder.remaining_handles();
1762            if let Some((inlined, num_bytes, num_handles)) =
1763                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1764            {
1765                let member_inline_size =
1766                    <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
1767                        decoder.context,
1768                    );
1769                if inlined != (member_inline_size <= 4) {
1770                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1771                }
1772                let inner_offset;
1773                let mut inner_depth = depth.clone();
1774                if inlined {
1775                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1776                    inner_offset = next_offset;
1777                } else {
1778                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1779                    inner_depth.increment()?;
1780                }
1781                let val_ref = self
1782                    .guid
1783                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
1784                fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
1785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1786                {
1787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1788                }
1789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1791                }
1792            }
1793
1794            next_offset += envelope_size;
1795
1796            // Decode the remaining unknown envelopes.
1797            while next_offset < end_offset {
1798                _next_ordinal_to_read += 1;
1799                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1800                next_offset += envelope_size;
1801            }
1802
1803            Ok(())
1804        }
1805    }
1806}
fidl_fuchsia_fs_startup__common/fidl_fuchsia_fs_startup__common.rs

fidl_fuchsia_fs_startup__common/
fidl_fuchsia_fs_startup__common.rs
