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