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

fidl_fuchsia_starnix_runner__common/
fidl_fuchsia_starnix_runner__common.rs
