fdomain_fuchsia_ebpf/
fdomain_fuchsia_ebpf.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 fdomain_client::fidl::{ControlHandle as _, FDomainFlexibleIntoResult as _, Responder as _};
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9pub use fidl_fuchsia_ebpf_common::*;
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13/// A handle of an eBPF program.
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProgramHandle {
16    pub handle: fdomain_client::EventPair,
17}
18
19impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for ProgramHandle {}
20
21/// A representation of eBPF map that can be shared between processes.
22#[derive(Debug, Default, PartialEq)]
23pub struct Map {
24    /// Map schema.
25    pub schema: Option<MapSchema>,
26    /// VMO used to store the map data. The layout of the data stored in the
27    /// VMO depends on the `schema` as defined in the `ebpf_api` create.
28    pub vmo: Option<fdomain_client::Vmo>,
29    #[doc(hidden)]
30    pub __source_breaking: fidl::marker::SourceBreaking,
31}
32
33impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for Map {}
34
35/// A verified eBPF program.
36#[derive(Debug, Default, PartialEq)]
37pub struct VerifiedProgram {
38    /// Program instructions.
39    pub code: Option<Vec<u64>>,
40    /// List of instructions accessing struct fields.
41    pub struct_access_instructions: Option<Vec<StructAccess>>,
42    /// List of the maps used by the program. `code` may reference these maps
43    /// by their index in this array.
44    pub maps: Option<Vec<Map>>,
45    #[doc(hidden)]
46    pub __source_breaking: fidl::marker::SourceBreaking,
47}
48
49impl fidl::Standalone<fdomain_client::fidl::FDomainResourceDialect> for VerifiedProgram {}
50
51mod internal {
52    use super::*;
53
54    impl fidl::encoding::ResourceTypeMarker for ProgramHandle {
55        type Borrowed<'a> = &'a mut Self;
56        fn take_or_borrow<'a>(
57            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
58        ) -> Self::Borrowed<'a> {
59            value
60        }
61    }
62
63    unsafe impl fidl::encoding::TypeMarker for ProgramHandle {
64        type Owned = Self;
65
66        #[inline(always)]
67        fn inline_align(_context: fidl::encoding::Context) -> usize {
68            4
69        }
70
71        #[inline(always)]
72        fn inline_size(_context: fidl::encoding::Context) -> usize {
73            4
74        }
75    }
76
77    unsafe impl fidl::encoding::Encode<ProgramHandle, fdomain_client::fidl::FDomainResourceDialect>
78        for &mut ProgramHandle
79    {
80        #[inline]
81        unsafe fn encode(
82            self,
83            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
84            offset: usize,
85            _depth: fidl::encoding::Depth,
86        ) -> fidl::Result<()> {
87            encoder.debug_check_bounds::<ProgramHandle>(offset);
88            // Delegate to tuple encoding.
89            fidl::encoding::Encode::<ProgramHandle, fdomain_client::fidl::FDomainResourceDialect>::encode(
90                (
91                    <fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 20482> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle),
92                ),
93                encoder, offset, _depth
94            )
95        }
96    }
97    unsafe impl<
98        T0: fidl::encoding::Encode<
99                fidl::encoding::HandleType<
100                    fdomain_client::EventPair,
101                    { fidl::ObjectType::EVENTPAIR.into_raw() },
102                    20482,
103                >,
104                fdomain_client::fidl::FDomainResourceDialect,
105            >,
106    > fidl::encoding::Encode<ProgramHandle, fdomain_client::fidl::FDomainResourceDialect> for (T0,)
107    {
108        #[inline]
109        unsafe fn encode(
110            self,
111            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
112            offset: usize,
113            depth: fidl::encoding::Depth,
114        ) -> fidl::Result<()> {
115            encoder.debug_check_bounds::<ProgramHandle>(offset);
116            // Zero out padding regions. There's no need to apply masks
117            // because the unmasked parts will be overwritten by fields.
118            // Write the fields.
119            self.0.encode(encoder, offset + 0, depth)?;
120            Ok(())
121        }
122    }
123
124    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for ProgramHandle {
125        #[inline(always)]
126        fn new_empty() -> Self {
127            Self {
128                handle: fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 20482>, fdomain_client::fidl::FDomainResourceDialect),
129            }
130        }
131
132        #[inline]
133        unsafe fn decode(
134            &mut self,
135            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
136            offset: usize,
137            _depth: fidl::encoding::Depth,
138        ) -> fidl::Result<()> {
139            decoder.debug_check_bounds::<Self>(offset);
140            // Verify that padding bytes are zero.
141            fidl::decode!(fidl::encoding::HandleType<fdomain_client::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 20482>, fdomain_client::fidl::FDomainResourceDialect, &mut self.handle, decoder, offset + 0, _depth)?;
142            Ok(())
143        }
144    }
145
146    impl Map {
147        #[inline(always)]
148        fn max_ordinal_present(&self) -> u64 {
149            if let Some(_) = self.vmo {
150                return 2;
151            }
152            if let Some(_) = self.schema {
153                return 1;
154            }
155            0
156        }
157    }
158
159    impl fidl::encoding::ResourceTypeMarker for Map {
160        type Borrowed<'a> = &'a mut Self;
161        fn take_or_borrow<'a>(
162            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
163        ) -> Self::Borrowed<'a> {
164            value
165        }
166    }
167
168    unsafe impl fidl::encoding::TypeMarker for Map {
169        type Owned = Self;
170
171        #[inline(always)]
172        fn inline_align(_context: fidl::encoding::Context) -> usize {
173            8
174        }
175
176        #[inline(always)]
177        fn inline_size(_context: fidl::encoding::Context) -> usize {
178            16
179        }
180    }
181
182    unsafe impl fidl::encoding::Encode<Map, fdomain_client::fidl::FDomainResourceDialect> for &mut Map {
183        unsafe fn encode(
184            self,
185            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
186            offset: usize,
187            mut depth: fidl::encoding::Depth,
188        ) -> fidl::Result<()> {
189            encoder.debug_check_bounds::<Map>(offset);
190            // Vector header
191            let max_ordinal: u64 = self.max_ordinal_present();
192            encoder.write_num(max_ordinal, offset);
193            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
194            // Calling encoder.out_of_line_offset(0) is not allowed.
195            if max_ordinal == 0 {
196                return Ok(());
197            }
198            depth.increment()?;
199            let envelope_size = 8;
200            let bytes_len = max_ordinal as usize * envelope_size;
201            #[allow(unused_variables)]
202            let offset = encoder.out_of_line_offset(bytes_len);
203            let mut _prev_end_offset: usize = 0;
204            if 1 > max_ordinal {
205                return Ok(());
206            }
207
208            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
209            // are envelope_size bytes.
210            let cur_offset: usize = (1 - 1) * envelope_size;
211
212            // Zero reserved fields.
213            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
214
215            // Safety:
216            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
217            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
218            //   envelope_size bytes, there is always sufficient room.
219            fidl::encoding::encode_in_envelope_optional::<
220                MapSchema,
221                fdomain_client::fidl::FDomainResourceDialect,
222            >(
223                self.schema.as_ref().map(<MapSchema as fidl::encoding::ValueTypeMarker>::borrow),
224                encoder,
225                offset + cur_offset,
226                depth,
227            )?;
228
229            _prev_end_offset = cur_offset + envelope_size;
230            if 2 > max_ordinal {
231                return Ok(());
232            }
233
234            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
235            // are envelope_size bytes.
236            let cur_offset: usize = (2 - 1) * envelope_size;
237
238            // Zero reserved fields.
239            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
240
241            // Safety:
242            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
243            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
244            //   envelope_size bytes, there is always sufficient room.
245            fidl::encoding::encode_in_envelope_optional::<
246                fidl::encoding::HandleType<
247                    fdomain_client::Vmo,
248                    { fidl::ObjectType::VMO.into_raw() },
249                    20524,
250                >,
251                fdomain_client::fidl::FDomainResourceDialect,
252            >(
253                self.vmo.as_mut().map(
254                    <fidl::encoding::HandleType<
255                        fdomain_client::Vmo,
256                        { fidl::ObjectType::VMO.into_raw() },
257                        20524,
258                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
259                ),
260                encoder,
261                offset + cur_offset,
262                depth,
263            )?;
264
265            _prev_end_offset = cur_offset + envelope_size;
266
267            Ok(())
268        }
269    }
270
271    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect> for Map {
272        #[inline(always)]
273        fn new_empty() -> Self {
274            Self::default()
275        }
276
277        unsafe fn decode(
278            &mut self,
279            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
280            offset: usize,
281            mut depth: fidl::encoding::Depth,
282        ) -> fidl::Result<()> {
283            decoder.debug_check_bounds::<Self>(offset);
284            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
285                None => return Err(fidl::Error::NotNullable),
286                Some(len) => len,
287            };
288            // Calling decoder.out_of_line_offset(0) is not allowed.
289            if len == 0 {
290                return Ok(());
291            };
292            depth.increment()?;
293            let envelope_size = 8;
294            let bytes_len = len * envelope_size;
295            let offset = decoder.out_of_line_offset(bytes_len)?;
296            // Decode the envelope for each type.
297            let mut _next_ordinal_to_read = 0;
298            let mut next_offset = offset;
299            let end_offset = offset + bytes_len;
300            _next_ordinal_to_read += 1;
301            if next_offset >= end_offset {
302                return Ok(());
303            }
304
305            // Decode unknown envelopes for gaps in ordinals.
306            while _next_ordinal_to_read < 1 {
307                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
308                _next_ordinal_to_read += 1;
309                next_offset += envelope_size;
310            }
311
312            let next_out_of_line = decoder.next_out_of_line();
313            let handles_before = decoder.remaining_handles();
314            if let Some((inlined, num_bytes, num_handles)) =
315                fidl::encoding::decode_envelope_header(decoder, next_offset)?
316            {
317                let member_inline_size =
318                    <MapSchema as fidl::encoding::TypeMarker>::inline_size(decoder.context);
319                if inlined != (member_inline_size <= 4) {
320                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
321                }
322                let inner_offset;
323                let mut inner_depth = depth.clone();
324                if inlined {
325                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
326                    inner_offset = next_offset;
327                } else {
328                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
329                    inner_depth.increment()?;
330                }
331                let val_ref = self.schema.get_or_insert_with(|| {
332                    fidl::new_empty!(MapSchema, fdomain_client::fidl::FDomainResourceDialect)
333                });
334                fidl::decode!(
335                    MapSchema,
336                    fdomain_client::fidl::FDomainResourceDialect,
337                    val_ref,
338                    decoder,
339                    inner_offset,
340                    inner_depth
341                )?;
342                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
343                {
344                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
345                }
346                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
347                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
348                }
349            }
350
351            next_offset += envelope_size;
352            _next_ordinal_to_read += 1;
353            if next_offset >= end_offset {
354                return Ok(());
355            }
356
357            // Decode unknown envelopes for gaps in ordinals.
358            while _next_ordinal_to_read < 2 {
359                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
360                _next_ordinal_to_read += 1;
361                next_offset += envelope_size;
362            }
363
364            let next_out_of_line = decoder.next_out_of_line();
365            let handles_before = decoder.remaining_handles();
366            if let Some((inlined, num_bytes, num_handles)) =
367                fidl::encoding::decode_envelope_header(decoder, next_offset)?
368            {
369                let member_inline_size = <fidl::encoding::HandleType<
370                    fdomain_client::Vmo,
371                    { fidl::ObjectType::VMO.into_raw() },
372                    20524,
373                > as fidl::encoding::TypeMarker>::inline_size(
374                    decoder.context
375                );
376                if inlined != (member_inline_size <= 4) {
377                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
378                }
379                let inner_offset;
380                let mut inner_depth = depth.clone();
381                if inlined {
382                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
383                    inner_offset = next_offset;
384                } else {
385                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
386                    inner_depth.increment()?;
387                }
388                let val_ref =
389                self.vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 20524>, fdomain_client::fidl::FDomainResourceDialect));
390                fidl::decode!(fidl::encoding::HandleType<fdomain_client::Vmo, { fidl::ObjectType::VMO.into_raw() }, 20524>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
391                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
392                {
393                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
394                }
395                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
396                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
397                }
398            }
399
400            next_offset += envelope_size;
401
402            // Decode the remaining unknown envelopes.
403            while next_offset < end_offset {
404                _next_ordinal_to_read += 1;
405                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
406                next_offset += envelope_size;
407            }
408
409            Ok(())
410        }
411    }
412
413    impl VerifiedProgram {
414        #[inline(always)]
415        fn max_ordinal_present(&self) -> u64 {
416            if let Some(_) = self.maps {
417                return 3;
418            }
419            if let Some(_) = self.struct_access_instructions {
420                return 2;
421            }
422            if let Some(_) = self.code {
423                return 1;
424            }
425            0
426        }
427    }
428
429    impl fidl::encoding::ResourceTypeMarker for VerifiedProgram {
430        type Borrowed<'a> = &'a mut Self;
431        fn take_or_borrow<'a>(
432            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
433        ) -> Self::Borrowed<'a> {
434            value
435        }
436    }
437
438    unsafe impl fidl::encoding::TypeMarker for VerifiedProgram {
439        type Owned = Self;
440
441        #[inline(always)]
442        fn inline_align(_context: fidl::encoding::Context) -> usize {
443            8
444        }
445
446        #[inline(always)]
447        fn inline_size(_context: fidl::encoding::Context) -> usize {
448            16
449        }
450    }
451
452    unsafe impl
453        fidl::encoding::Encode<VerifiedProgram, fdomain_client::fidl::FDomainResourceDialect>
454        for &mut VerifiedProgram
455    {
456        unsafe fn encode(
457            self,
458            encoder: &mut fidl::encoding::Encoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
459            offset: usize,
460            mut depth: fidl::encoding::Depth,
461        ) -> fidl::Result<()> {
462            encoder.debug_check_bounds::<VerifiedProgram>(offset);
463            // Vector header
464            let max_ordinal: u64 = self.max_ordinal_present();
465            encoder.write_num(max_ordinal, offset);
466            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
467            // Calling encoder.out_of_line_offset(0) is not allowed.
468            if max_ordinal == 0 {
469                return Ok(());
470            }
471            depth.increment()?;
472            let envelope_size = 8;
473            let bytes_len = max_ordinal as usize * envelope_size;
474            #[allow(unused_variables)]
475            let offset = encoder.out_of_line_offset(bytes_len);
476            let mut _prev_end_offset: usize = 0;
477            if 1 > max_ordinal {
478                return Ok(());
479            }
480
481            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
482            // are envelope_size bytes.
483            let cur_offset: usize = (1 - 1) * envelope_size;
484
485            // Zero reserved fields.
486            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
487
488            // Safety:
489            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
490            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
491            //   envelope_size bytes, there is always sufficient room.
492            fidl::encoding::encode_in_envelope_optional::<
493                fidl::encoding::Vector<u64, 4096>,
494                fdomain_client::fidl::FDomainResourceDialect,
495            >(
496                self.code.as_ref().map(
497                    <fidl::encoding::Vector<u64, 4096> as fidl::encoding::ValueTypeMarker>::borrow,
498                ),
499                encoder,
500                offset + cur_offset,
501                depth,
502            )?;
503
504            _prev_end_offset = cur_offset + envelope_size;
505            if 2 > max_ordinal {
506                return Ok(());
507            }
508
509            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
510            // are envelope_size bytes.
511            let cur_offset: usize = (2 - 1) * envelope_size;
512
513            // Zero reserved fields.
514            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
515
516            // Safety:
517            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
518            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
519            //   envelope_size bytes, there is always sufficient room.
520            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<StructAccess, 4096>, fdomain_client::fidl::FDomainResourceDialect>(
521            self.struct_access_instructions.as_ref().map(<fidl::encoding::Vector<StructAccess, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
522            encoder, offset + cur_offset, depth
523        )?;
524
525            _prev_end_offset = cur_offset + envelope_size;
526            if 3 > max_ordinal {
527                return Ok(());
528            }
529
530            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
531            // are envelope_size bytes.
532            let cur_offset: usize = (3 - 1) * envelope_size;
533
534            // Zero reserved fields.
535            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
536
537            // Safety:
538            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
539            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
540            //   envelope_size bytes, there is always sufficient room.
541            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Map, 4096>, fdomain_client::fidl::FDomainResourceDialect>(
542            self.maps.as_mut().map(<fidl::encoding::Vector<Map, 4096> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
543            encoder, offset + cur_offset, depth
544        )?;
545
546            _prev_end_offset = cur_offset + envelope_size;
547
548            Ok(())
549        }
550    }
551
552    impl fidl::encoding::Decode<Self, fdomain_client::fidl::FDomainResourceDialect>
553        for VerifiedProgram
554    {
555        #[inline(always)]
556        fn new_empty() -> Self {
557            Self::default()
558        }
559
560        unsafe fn decode(
561            &mut self,
562            decoder: &mut fidl::encoding::Decoder<'_, fdomain_client::fidl::FDomainResourceDialect>,
563            offset: usize,
564            mut depth: fidl::encoding::Depth,
565        ) -> fidl::Result<()> {
566            decoder.debug_check_bounds::<Self>(offset);
567            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
568                None => return Err(fidl::Error::NotNullable),
569                Some(len) => len,
570            };
571            // Calling decoder.out_of_line_offset(0) is not allowed.
572            if len == 0 {
573                return Ok(());
574            };
575            depth.increment()?;
576            let envelope_size = 8;
577            let bytes_len = len * envelope_size;
578            let offset = decoder.out_of_line_offset(bytes_len)?;
579            // Decode the envelope for each type.
580            let mut _next_ordinal_to_read = 0;
581            let mut next_offset = offset;
582            let end_offset = offset + bytes_len;
583            _next_ordinal_to_read += 1;
584            if next_offset >= end_offset {
585                return Ok(());
586            }
587
588            // Decode unknown envelopes for gaps in ordinals.
589            while _next_ordinal_to_read < 1 {
590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591                _next_ordinal_to_read += 1;
592                next_offset += envelope_size;
593            }
594
595            let next_out_of_line = decoder.next_out_of_line();
596            let handles_before = decoder.remaining_handles();
597            if let Some((inlined, num_bytes, num_handles)) =
598                fidl::encoding::decode_envelope_header(decoder, next_offset)?
599            {
600                let member_inline_size =
601                    <fidl::encoding::Vector<u64, 4096> as fidl::encoding::TypeMarker>::inline_size(
602                        decoder.context,
603                    );
604                if inlined != (member_inline_size <= 4) {
605                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
606                }
607                let inner_offset;
608                let mut inner_depth = depth.clone();
609                if inlined {
610                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
611                    inner_offset = next_offset;
612                } else {
613                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
614                    inner_depth.increment()?;
615                }
616                let val_ref =
617                self.code.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u64, 4096>, fdomain_client::fidl::FDomainResourceDialect));
618                fidl::decode!(fidl::encoding::Vector<u64, 4096>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
619                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
620                {
621                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
622                }
623                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
624                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
625                }
626            }
627
628            next_offset += envelope_size;
629            _next_ordinal_to_read += 1;
630            if next_offset >= end_offset {
631                return Ok(());
632            }
633
634            // Decode unknown envelopes for gaps in ordinals.
635            while _next_ordinal_to_read < 2 {
636                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
637                _next_ordinal_to_read += 1;
638                next_offset += envelope_size;
639            }
640
641            let next_out_of_line = decoder.next_out_of_line();
642            let handles_before = decoder.remaining_handles();
643            if let Some((inlined, num_bytes, num_handles)) =
644                fidl::encoding::decode_envelope_header(decoder, next_offset)?
645            {
646                let member_inline_size = <fidl::encoding::Vector<StructAccess, 4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
647                if inlined != (member_inline_size <= 4) {
648                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
649                }
650                let inner_offset;
651                let mut inner_depth = depth.clone();
652                if inlined {
653                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
654                    inner_offset = next_offset;
655                } else {
656                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
657                    inner_depth.increment()?;
658                }
659                let val_ref =
660                self.struct_access_instructions.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<StructAccess, 4096>, fdomain_client::fidl::FDomainResourceDialect));
661                fidl::decode!(fidl::encoding::Vector<StructAccess, 4096>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
662                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
663                {
664                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
665                }
666                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
667                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
668                }
669            }
670
671            next_offset += envelope_size;
672            _next_ordinal_to_read += 1;
673            if next_offset >= end_offset {
674                return Ok(());
675            }
676
677            // Decode unknown envelopes for gaps in ordinals.
678            while _next_ordinal_to_read < 3 {
679                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
680                _next_ordinal_to_read += 1;
681                next_offset += envelope_size;
682            }
683
684            let next_out_of_line = decoder.next_out_of_line();
685            let handles_before = decoder.remaining_handles();
686            if let Some((inlined, num_bytes, num_handles)) =
687                fidl::encoding::decode_envelope_header(decoder, next_offset)?
688            {
689                let member_inline_size =
690                    <fidl::encoding::Vector<Map, 4096> as fidl::encoding::TypeMarker>::inline_size(
691                        decoder.context,
692                    );
693                if inlined != (member_inline_size <= 4) {
694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
695                }
696                let inner_offset;
697                let mut inner_depth = depth.clone();
698                if inlined {
699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
700                    inner_offset = next_offset;
701                } else {
702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
703                    inner_depth.increment()?;
704                }
705                let val_ref =
706                self.maps.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Map, 4096>, fdomain_client::fidl::FDomainResourceDialect));
707                fidl::decode!(fidl::encoding::Vector<Map, 4096>, fdomain_client::fidl::FDomainResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
708                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
709                {
710                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
711                }
712                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
713                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
714                }
715            }
716
717            next_offset += envelope_size;
718
719            // Decode the remaining unknown envelopes.
720            while next_offset < end_offset {
721                _next_ordinal_to_read += 1;
722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
723                next_offset += envelope_size;
724            }
725
726            Ok(())
727        }
728    }
729}
fdomain_fuchsia_ebpf/fdomain_fuchsia_ebpf.rs

fdomain_fuchsia_ebpf/
fdomain_fuchsia_ebpf.rs
