fidl_fuchsia_starnix_runner__common/
fidl_fuchsia_starnix_runner__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
11pub const PROXY_NAME_LEN: u32 = 1024;
12
13#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
14pub enum SuspendError {
15    WakeLocksExist,
16    SuspendFailure,
17    #[doc(hidden)]
18    __SourceBreaking {
19        unknown_ordinal: u32,
20    },
21}
22
23/// Pattern that matches an unknown `SuspendError` member.
24#[macro_export]
25macro_rules! SuspendErrorUnknown {
26    () => {
27        _
28    };
29}
30
31impl SuspendError {
32    #[inline]
33    pub fn from_primitive(prim: u32) -> Option<Self> {
34        match prim {
35            1 => Some(Self::WakeLocksExist),
36            2 => Some(Self::SuspendFailure),
37            _ => None,
38        }
39    }
40
41    #[inline]
42    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
43        match prim {
44            1 => Self::WakeLocksExist,
45            2 => Self::SuspendFailure,
46            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
47        }
48    }
49
50    #[inline]
51    pub fn unknown() -> Self {
52        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
53    }
54
55    #[inline]
56    pub const fn into_primitive(self) -> u32 {
57        match self {
58            Self::WakeLocksExist => 1,
59            Self::SuspendFailure => 2,
60            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
61        }
62    }
63
64    #[inline]
65    pub fn is_unknown(&self) -> bool {
66        match self {
67            Self::__SourceBreaking { unknown_ordinal: _ } => true,
68            _ => false,
69        }
70    }
71}
72
73#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
74#[repr(C)]
75pub struct PagerExtent {
76    pub logical_start: u32,
77    pub logical_end: u32,
78    pub physical_block: u64,
79}
80
81impl fidl::Persistable for PagerExtent {}
82
83#[derive(Clone, Debug, Default, PartialEq)]
84pub struct ManagerSuspendContainerResponse {
85    /// The amount of time spent in the suspend state.
86    ///
87    /// It is used for tracking suspend stats in the Starnix kernel.
88    pub suspend_time: Option<i64>,
89    /// The name of the event that woke the container.
90    pub resume_reason: Option<String>,
91    #[doc(hidden)]
92    pub __source_breaking: fidl::marker::SourceBreaking,
93}
94
95impl fidl::Persistable for ManagerSuspendContainerResponse {}
96
97#[derive(Clone, Debug, Default, PartialEq)]
98pub struct PagerRegisterFileRequest {
99    /// The name of the file vmo.
100    pub name: Option<String>,
101    /// The inode name to use for the file.
102    pub inode_num: Option<u32>,
103    /// The size of the file.
104    pub size: Option<u64>,
105    /// The extents associated with the file, required to be sorted.
106    pub extents: Option<Vec<PagerExtent>>,
107    #[doc(hidden)]
108    pub __source_breaking: fidl::marker::SourceBreaking,
109}
110
111impl fidl::Persistable for PagerRegisterFileRequest {}
112
113pub mod manager_ordinals {
114    pub const SUSPEND_CONTAINER: u64 = 0x928527927c9f2a7;
115    pub const PROXY_WAKE_CHANNEL: u64 = 0x46a374ab73b23714;
116    pub const REGISTER_WAKE_WATCHER: u64 = 0x456d74519eb65b41;
117    pub const CREATE_PAGER: u64 = 0x49d14958b736198b;
118}
119
120pub mod pager_ordinals {
121    pub const REGISTER_FILE: u64 = 0x4f85a2ce6cae4aed;
122}
123
124mod internal {
125    use super::*;
126    unsafe impl fidl::encoding::TypeMarker for SuspendError {
127        type Owned = Self;
128
129        #[inline(always)]
130        fn inline_align(_context: fidl::encoding::Context) -> usize {
131            std::mem::align_of::<u32>()
132        }
133
134        #[inline(always)]
135        fn inline_size(_context: fidl::encoding::Context) -> usize {
136            std::mem::size_of::<u32>()
137        }
138
139        #[inline(always)]
140        fn encode_is_copy() -> bool {
141            false
142        }
143
144        #[inline(always)]
145        fn decode_is_copy() -> bool {
146            false
147        }
148    }
149
150    impl fidl::encoding::ValueTypeMarker for SuspendError {
151        type Borrowed<'a> = Self;
152        #[inline(always)]
153        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
154            *value
155        }
156    }
157
158    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SuspendError {
159        #[inline]
160        unsafe fn encode(
161            self,
162            encoder: &mut fidl::encoding::Encoder<'_, D>,
163            offset: usize,
164            _depth: fidl::encoding::Depth,
165        ) -> fidl::Result<()> {
166            encoder.debug_check_bounds::<Self>(offset);
167            encoder.write_num(self.into_primitive(), offset);
168            Ok(())
169        }
170    }
171
172    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SuspendError {
173        #[inline(always)]
174        fn new_empty() -> Self {
175            Self::unknown()
176        }
177
178        #[inline]
179        unsafe fn decode(
180            &mut self,
181            decoder: &mut fidl::encoding::Decoder<'_, D>,
182            offset: usize,
183            _depth: fidl::encoding::Depth,
184        ) -> fidl::Result<()> {
185            decoder.debug_check_bounds::<Self>(offset);
186            let prim = decoder.read_num::<u32>(offset);
187
188            *self = Self::from_primitive_allow_unknown(prim);
189            Ok(())
190        }
191    }
192
193    impl fidl::encoding::ValueTypeMarker for PagerExtent {
194        type Borrowed<'a> = &'a Self;
195        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
196            value
197        }
198    }
199
200    unsafe impl fidl::encoding::TypeMarker for PagerExtent {
201        type Owned = Self;
202
203        #[inline(always)]
204        fn inline_align(_context: fidl::encoding::Context) -> usize {
205            8
206        }
207
208        #[inline(always)]
209        fn inline_size(_context: fidl::encoding::Context) -> usize {
210            16
211        }
212        #[inline(always)]
213        fn encode_is_copy() -> bool {
214            true
215        }
216
217        #[inline(always)]
218        fn decode_is_copy() -> bool {
219            true
220        }
221    }
222
223    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PagerExtent, D>
224        for &PagerExtent
225    {
226        #[inline]
227        unsafe fn encode(
228            self,
229            encoder: &mut fidl::encoding::Encoder<'_, D>,
230            offset: usize,
231            _depth: fidl::encoding::Depth,
232        ) -> fidl::Result<()> {
233            encoder.debug_check_bounds::<PagerExtent>(offset);
234            unsafe {
235                // Copy the object into the buffer.
236                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
237                (buf_ptr as *mut PagerExtent).write_unaligned((self as *const PagerExtent).read());
238                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
239                // done second because the memcpy will write garbage to these bytes.
240            }
241            Ok(())
242        }
243    }
244    unsafe impl<
245            D: fidl::encoding::ResourceDialect,
246            T0: fidl::encoding::Encode<u32, D>,
247            T1: fidl::encoding::Encode<u32, D>,
248            T2: fidl::encoding::Encode<u64, D>,
249        > fidl::encoding::Encode<PagerExtent, D> for (T0, T1, T2)
250    {
251        #[inline]
252        unsafe fn encode(
253            self,
254            encoder: &mut fidl::encoding::Encoder<'_, D>,
255            offset: usize,
256            depth: fidl::encoding::Depth,
257        ) -> fidl::Result<()> {
258            encoder.debug_check_bounds::<PagerExtent>(offset);
259            // Zero out padding regions. There's no need to apply masks
260            // because the unmasked parts will be overwritten by fields.
261            // Write the fields.
262            self.0.encode(encoder, offset + 0, depth)?;
263            self.1.encode(encoder, offset + 4, depth)?;
264            self.2.encode(encoder, offset + 8, depth)?;
265            Ok(())
266        }
267    }
268
269    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PagerExtent {
270        #[inline(always)]
271        fn new_empty() -> Self {
272            Self {
273                logical_start: fidl::new_empty!(u32, D),
274                logical_end: fidl::new_empty!(u32, D),
275                physical_block: fidl::new_empty!(u64, D),
276            }
277        }
278
279        #[inline]
280        unsafe fn decode(
281            &mut self,
282            decoder: &mut fidl::encoding::Decoder<'_, D>,
283            offset: usize,
284            _depth: fidl::encoding::Depth,
285        ) -> fidl::Result<()> {
286            decoder.debug_check_bounds::<Self>(offset);
287            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
288            // Verify that padding bytes are zero.
289            // Copy from the buffer into the object.
290            unsafe {
291                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
292            }
293            Ok(())
294        }
295    }
296
297    impl ManagerSuspendContainerResponse {
298        #[inline(always)]
299        fn max_ordinal_present(&self) -> u64 {
300            if let Some(_) = self.resume_reason {
301                return 2;
302            }
303            if let Some(_) = self.suspend_time {
304                return 1;
305            }
306            0
307        }
308    }
309
310    impl fidl::encoding::ValueTypeMarker for ManagerSuspendContainerResponse {
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 ManagerSuspendContainerResponse {
318        type Owned = Self;
319
320        #[inline(always)]
321        fn inline_align(_context: fidl::encoding::Context) -> usize {
322            8
323        }
324
325        #[inline(always)]
326        fn inline_size(_context: fidl::encoding::Context) -> usize {
327            16
328        }
329    }
330
331    unsafe impl<D: fidl::encoding::ResourceDialect>
332        fidl::encoding::Encode<ManagerSuspendContainerResponse, D>
333        for &ManagerSuspendContainerResponse
334    {
335        unsafe fn encode(
336            self,
337            encoder: &mut fidl::encoding::Encoder<'_, D>,
338            offset: usize,
339            mut depth: fidl::encoding::Depth,
340        ) -> fidl::Result<()> {
341            encoder.debug_check_bounds::<ManagerSuspendContainerResponse>(offset);
342            // Vector header
343            let max_ordinal: u64 = self.max_ordinal_present();
344            encoder.write_num(max_ordinal, offset);
345            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
346            // Calling encoder.out_of_line_offset(0) is not allowed.
347            if max_ordinal == 0 {
348                return Ok(());
349            }
350            depth.increment()?;
351            let envelope_size = 8;
352            let bytes_len = max_ordinal as usize * envelope_size;
353            #[allow(unused_variables)]
354            let offset = encoder.out_of_line_offset(bytes_len);
355            let mut _prev_end_offset: usize = 0;
356            if 1 > max_ordinal {
357                return Ok(());
358            }
359
360            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
361            // are envelope_size bytes.
362            let cur_offset: usize = (1 - 1) * envelope_size;
363
364            // Zero reserved fields.
365            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
366
367            // Safety:
368            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
369            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
370            //   envelope_size bytes, there is always sufficient room.
371            fidl::encoding::encode_in_envelope_optional::<i64, D>(
372                self.suspend_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
373                encoder,
374                offset + cur_offset,
375                depth,
376            )?;
377
378            _prev_end_offset = cur_offset + envelope_size;
379            if 2 > max_ordinal {
380                return Ok(());
381            }
382
383            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
384            // are envelope_size bytes.
385            let cur_offset: usize = (2 - 1) * envelope_size;
386
387            // Zero reserved fields.
388            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
389
390            // Safety:
391            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
392            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
393            //   envelope_size bytes, there is always sufficient room.
394            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, D>(
395            self.resume_reason.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
396            encoder, offset + cur_offset, depth
397        )?;
398
399            _prev_end_offset = cur_offset + envelope_size;
400
401            Ok(())
402        }
403    }
404
405    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
406        for ManagerSuspendContainerResponse
407    {
408        #[inline(always)]
409        fn new_empty() -> Self {
410            Self::default()
411        }
412
413        unsafe fn decode(
414            &mut self,
415            decoder: &mut fidl::encoding::Decoder<'_, D>,
416            offset: usize,
417            mut depth: fidl::encoding::Depth,
418        ) -> fidl::Result<()> {
419            decoder.debug_check_bounds::<Self>(offset);
420            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
421                None => return Err(fidl::Error::NotNullable),
422                Some(len) => len,
423            };
424            // Calling decoder.out_of_line_offset(0) is not allowed.
425            if len == 0 {
426                return Ok(());
427            };
428            depth.increment()?;
429            let envelope_size = 8;
430            let bytes_len = len * envelope_size;
431            let offset = decoder.out_of_line_offset(bytes_len)?;
432            // Decode the envelope for each type.
433            let mut _next_ordinal_to_read = 0;
434            let mut next_offset = offset;
435            let end_offset = offset + bytes_len;
436            _next_ordinal_to_read += 1;
437            if next_offset >= end_offset {
438                return Ok(());
439            }
440
441            // Decode unknown envelopes for gaps in ordinals.
442            while _next_ordinal_to_read < 1 {
443                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
444                _next_ordinal_to_read += 1;
445                next_offset += envelope_size;
446            }
447
448            let next_out_of_line = decoder.next_out_of_line();
449            let handles_before = decoder.remaining_handles();
450            if let Some((inlined, num_bytes, num_handles)) =
451                fidl::encoding::decode_envelope_header(decoder, next_offset)?
452            {
453                let member_inline_size =
454                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
455                if inlined != (member_inline_size <= 4) {
456                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
457                }
458                let inner_offset;
459                let mut inner_depth = depth.clone();
460                if inlined {
461                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
462                    inner_offset = next_offset;
463                } else {
464                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
465                    inner_depth.increment()?;
466                }
467                let val_ref = self.suspend_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
468                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
469                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
470                {
471                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
472                }
473                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
474                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
475                }
476            }
477
478            next_offset += envelope_size;
479            _next_ordinal_to_read += 1;
480            if next_offset >= end_offset {
481                return Ok(());
482            }
483
484            // Decode unknown envelopes for gaps in ordinals.
485            while _next_ordinal_to_read < 2 {
486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
487                _next_ordinal_to_read += 1;
488                next_offset += envelope_size;
489            }
490
491            let next_out_of_line = decoder.next_out_of_line();
492            let handles_before = decoder.remaining_handles();
493            if let Some((inlined, num_bytes, num_handles)) =
494                fidl::encoding::decode_envelope_header(decoder, next_offset)?
495            {
496                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
497                if inlined != (member_inline_size <= 4) {
498                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
499                }
500                let inner_offset;
501                let mut inner_depth = depth.clone();
502                if inlined {
503                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
504                    inner_offset = next_offset;
505                } else {
506                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
507                    inner_depth.increment()?;
508                }
509                let val_ref = self.resume_reason.get_or_insert_with(|| {
510                    fidl::new_empty!(fidl::encoding::BoundedString<1024>, D)
511                });
512                fidl::decode!(
513                    fidl::encoding::BoundedString<1024>,
514                    D,
515                    val_ref,
516                    decoder,
517                    inner_offset,
518                    inner_depth
519                )?;
520                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
521                {
522                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
523                }
524                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
525                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
526                }
527            }
528
529            next_offset += envelope_size;
530
531            // Decode the remaining unknown envelopes.
532            while next_offset < end_offset {
533                _next_ordinal_to_read += 1;
534                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
535                next_offset += envelope_size;
536            }
537
538            Ok(())
539        }
540    }
541
542    impl PagerRegisterFileRequest {
543        #[inline(always)]
544        fn max_ordinal_present(&self) -> u64 {
545            if let Some(_) = self.extents {
546                return 4;
547            }
548            if let Some(_) = self.size {
549                return 3;
550            }
551            if let Some(_) = self.inode_num {
552                return 2;
553            }
554            if let Some(_) = self.name {
555                return 1;
556            }
557            0
558        }
559    }
560
561    impl fidl::encoding::ValueTypeMarker for PagerRegisterFileRequest {
562        type Borrowed<'a> = &'a Self;
563        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
564            value
565        }
566    }
567
568    unsafe impl fidl::encoding::TypeMarker for PagerRegisterFileRequest {
569        type Owned = Self;
570
571        #[inline(always)]
572        fn inline_align(_context: fidl::encoding::Context) -> usize {
573            8
574        }
575
576        #[inline(always)]
577        fn inline_size(_context: fidl::encoding::Context) -> usize {
578            16
579        }
580    }
581
582    unsafe impl<D: fidl::encoding::ResourceDialect>
583        fidl::encoding::Encode<PagerRegisterFileRequest, D> for &PagerRegisterFileRequest
584    {
585        unsafe fn encode(
586            self,
587            encoder: &mut fidl::encoding::Encoder<'_, D>,
588            offset: usize,
589            mut depth: fidl::encoding::Depth,
590        ) -> fidl::Result<()> {
591            encoder.debug_check_bounds::<PagerRegisterFileRequest>(offset);
592            // Vector header
593            let max_ordinal: u64 = self.max_ordinal_present();
594            encoder.write_num(max_ordinal, offset);
595            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
596            // Calling encoder.out_of_line_offset(0) is not allowed.
597            if max_ordinal == 0 {
598                return Ok(());
599            }
600            depth.increment()?;
601            let envelope_size = 8;
602            let bytes_len = max_ordinal as usize * envelope_size;
603            #[allow(unused_variables)]
604            let offset = encoder.out_of_line_offset(bytes_len);
605            let mut _prev_end_offset: usize = 0;
606            if 1 > max_ordinal {
607                return Ok(());
608            }
609
610            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
611            // are envelope_size bytes.
612            let cur_offset: usize = (1 - 1) * envelope_size;
613
614            // Zero reserved fields.
615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
616
617            // Safety:
618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
620            //   envelope_size bytes, there is always sufficient room.
621            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
622                self.name.as_ref().map(
623                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
624                ),
625                encoder,
626                offset + cur_offset,
627                depth,
628            )?;
629
630            _prev_end_offset = cur_offset + envelope_size;
631            if 2 > max_ordinal {
632                return Ok(());
633            }
634
635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
636            // are envelope_size bytes.
637            let cur_offset: usize = (2 - 1) * envelope_size;
638
639            // Zero reserved fields.
640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
641
642            // Safety:
643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
645            //   envelope_size bytes, there is always sufficient room.
646            fidl::encoding::encode_in_envelope_optional::<u32, D>(
647                self.inode_num.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
648                encoder,
649                offset + cur_offset,
650                depth,
651            )?;
652
653            _prev_end_offset = cur_offset + envelope_size;
654            if 3 > max_ordinal {
655                return Ok(());
656            }
657
658            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
659            // are envelope_size bytes.
660            let cur_offset: usize = (3 - 1) * envelope_size;
661
662            // Zero reserved fields.
663            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
664
665            // Safety:
666            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
667            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
668            //   envelope_size bytes, there is always sufficient room.
669            fidl::encoding::encode_in_envelope_optional::<u64, D>(
670                self.size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
671                encoder,
672                offset + cur_offset,
673                depth,
674            )?;
675
676            _prev_end_offset = cur_offset + envelope_size;
677            if 4 > max_ordinal {
678                return Ok(());
679            }
680
681            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
682            // are envelope_size bytes.
683            let cur_offset: usize = (4 - 1) * envelope_size;
684
685            // Zero reserved fields.
686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
687
688            // Safety:
689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
691            //   envelope_size bytes, there is always sufficient room.
692            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PagerExtent, 1024>, D>(
693            self.extents.as_ref().map(<fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
694            encoder, offset + cur_offset, depth
695        )?;
696
697            _prev_end_offset = cur_offset + envelope_size;
698
699            Ok(())
700        }
701    }
702
703    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
704        for PagerRegisterFileRequest
705    {
706        #[inline(always)]
707        fn new_empty() -> Self {
708            Self::default()
709        }
710
711        unsafe fn decode(
712            &mut self,
713            decoder: &mut fidl::encoding::Decoder<'_, D>,
714            offset: usize,
715            mut depth: fidl::encoding::Depth,
716        ) -> fidl::Result<()> {
717            decoder.debug_check_bounds::<Self>(offset);
718            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
719                None => return Err(fidl::Error::NotNullable),
720                Some(len) => len,
721            };
722            // Calling decoder.out_of_line_offset(0) is not allowed.
723            if len == 0 {
724                return Ok(());
725            };
726            depth.increment()?;
727            let envelope_size = 8;
728            let bytes_len = len * envelope_size;
729            let offset = decoder.out_of_line_offset(bytes_len)?;
730            // Decode the envelope for each type.
731            let mut _next_ordinal_to_read = 0;
732            let mut next_offset = offset;
733            let end_offset = offset + bytes_len;
734            _next_ordinal_to_read += 1;
735            if next_offset >= end_offset {
736                return Ok(());
737            }
738
739            // Decode unknown envelopes for gaps in ordinals.
740            while _next_ordinal_to_read < 1 {
741                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
742                _next_ordinal_to_read += 1;
743                next_offset += envelope_size;
744            }
745
746            let next_out_of_line = decoder.next_out_of_line();
747            let handles_before = decoder.remaining_handles();
748            if let Some((inlined, num_bytes, num_handles)) =
749                fidl::encoding::decode_envelope_header(decoder, next_offset)?
750            {
751                let member_inline_size =
752                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
753                        decoder.context,
754                    );
755                if inlined != (member_inline_size <= 4) {
756                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
757                }
758                let inner_offset;
759                let mut inner_depth = depth.clone();
760                if inlined {
761                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
762                    inner_offset = next_offset;
763                } else {
764                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
765                    inner_depth.increment()?;
766                }
767                let val_ref = self
768                    .name
769                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
770                fidl::decode!(
771                    fidl::encoding::UnboundedString,
772                    D,
773                    val_ref,
774                    decoder,
775                    inner_offset,
776                    inner_depth
777                )?;
778                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
779                {
780                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
781                }
782                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
783                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
784                }
785            }
786
787            next_offset += envelope_size;
788            _next_ordinal_to_read += 1;
789            if next_offset >= end_offset {
790                return Ok(());
791            }
792
793            // Decode unknown envelopes for gaps in ordinals.
794            while _next_ordinal_to_read < 2 {
795                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
796                _next_ordinal_to_read += 1;
797                next_offset += envelope_size;
798            }
799
800            let next_out_of_line = decoder.next_out_of_line();
801            let handles_before = decoder.remaining_handles();
802            if let Some((inlined, num_bytes, num_handles)) =
803                fidl::encoding::decode_envelope_header(decoder, next_offset)?
804            {
805                let member_inline_size =
806                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
807                if inlined != (member_inline_size <= 4) {
808                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
809                }
810                let inner_offset;
811                let mut inner_depth = depth.clone();
812                if inlined {
813                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
814                    inner_offset = next_offset;
815                } else {
816                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
817                    inner_depth.increment()?;
818                }
819                let val_ref = self.inode_num.get_or_insert_with(|| fidl::new_empty!(u32, D));
820                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
821                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
822                {
823                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
824                }
825                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
826                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
827                }
828            }
829
830            next_offset += envelope_size;
831            _next_ordinal_to_read += 1;
832            if next_offset >= end_offset {
833                return Ok(());
834            }
835
836            // Decode unknown envelopes for gaps in ordinals.
837            while _next_ordinal_to_read < 3 {
838                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
839                _next_ordinal_to_read += 1;
840                next_offset += envelope_size;
841            }
842
843            let next_out_of_line = decoder.next_out_of_line();
844            let handles_before = decoder.remaining_handles();
845            if let Some((inlined, num_bytes, num_handles)) =
846                fidl::encoding::decode_envelope_header(decoder, next_offset)?
847            {
848                let member_inline_size =
849                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
850                if inlined != (member_inline_size <= 4) {
851                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
852                }
853                let inner_offset;
854                let mut inner_depth = depth.clone();
855                if inlined {
856                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
857                    inner_offset = next_offset;
858                } else {
859                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
860                    inner_depth.increment()?;
861                }
862                let val_ref = self.size.get_or_insert_with(|| fidl::new_empty!(u64, D));
863                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
864                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
865                {
866                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
867                }
868                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
869                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
870                }
871            }
872
873            next_offset += envelope_size;
874            _next_ordinal_to_read += 1;
875            if next_offset >= end_offset {
876                return Ok(());
877            }
878
879            // Decode unknown envelopes for gaps in ordinals.
880            while _next_ordinal_to_read < 4 {
881                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
882                _next_ordinal_to_read += 1;
883                next_offset += envelope_size;
884            }
885
886            let next_out_of_line = decoder.next_out_of_line();
887            let handles_before = decoder.remaining_handles();
888            if let Some((inlined, num_bytes, num_handles)) =
889                fidl::encoding::decode_envelope_header(decoder, next_offset)?
890            {
891                let member_inline_size = <fidl::encoding::Vector<PagerExtent, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
892                if inlined != (member_inline_size <= 4) {
893                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
894                }
895                let inner_offset;
896                let mut inner_depth = depth.clone();
897                if inlined {
898                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
899                    inner_offset = next_offset;
900                } else {
901                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
902                    inner_depth.increment()?;
903                }
904                let val_ref = self.extents.get_or_insert_with(
905                    || fidl::new_empty!(fidl::encoding::Vector<PagerExtent, 1024>, D),
906                );
907                fidl::decode!(fidl::encoding::Vector<PagerExtent, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
908                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
909                {
910                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
911                }
912                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
913                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
914                }
915            }
916
917            next_offset += envelope_size;
918
919            // Decode the remaining unknown envelopes.
920            while next_offset < end_offset {
921                _next_ordinal_to_read += 1;
922                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
923                next_offset += envelope_size;
924            }
925
926            Ok(())
927        }
928    }
929}