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