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
11pub const DEBUG_COMMAND_MAX: u32 = 1024;
13
14#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15#[repr(C)]
16pub struct CounterUpdateInspectVmoResponse {
17 pub status: i32,
18}
19
20impl fidl::Persistable for CounterUpdateInspectVmoResponse {}
21
22#[derive(Clone, Debug, PartialEq)]
23pub struct CpuStats {
24 pub actual_num_cpus: u64,
28 pub per_cpu_stats: Option<Vec<PerCpuStats>>,
29}
30
31impl fidl::Persistable for CpuStats {}
32
33#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
34pub struct DebugBrokerSendDebugCommandRequest {
35 pub command: String,
36}
37
38impl fidl::Persistable for DebugBrokerSendDebugCommandRequest {}
39
40#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
41#[repr(C)]
42pub struct DebugBrokerSendDebugCommandResponse {
43 pub status: i32,
44}
45
46impl fidl::Persistable for DebugBrokerSendDebugCommandResponse {}
47
48#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
49pub struct DebugBrokerSetTracingEnabledRequest {
50 pub enabled: bool,
51}
52
53impl fidl::Persistable for DebugBrokerSetTracingEnabledRequest {}
54
55#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
56#[repr(C)]
57pub struct DebugBrokerSetTracingEnabledResponse {
58 pub status: i32,
59}
60
61impl fidl::Persistable for DebugBrokerSetTracingEnabledResponse {}
62
63#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
64#[repr(C)]
65pub struct StatsGetCpuLoadRequest {
66 pub duration: i64,
67}
68
69impl fidl::Persistable for StatsGetCpuLoadRequest {}
70
71#[derive(Clone, Debug, PartialEq, PartialOrd)]
72pub struct StatsGetCpuLoadResponse {
73 pub per_cpu_load: Vec<f32>,
74}
75
76impl fidl::Persistable for StatsGetCpuLoadResponse {}
77
78#[derive(Clone, Debug, PartialEq)]
79pub struct StatsGetCpuStatsResponse {
80 pub stats: CpuStats,
81}
82
83impl fidl::Persistable for StatsGetCpuStatsResponse {}
84
85#[derive(Clone, Debug, PartialEq)]
86pub struct StatsGetMemoryStatsExtendedResponse {
87 pub stats: MemoryStatsExtended,
88}
89
90impl fidl::Persistable for StatsGetMemoryStatsExtendedResponse {}
91
92#[derive(Clone, Debug, PartialEq)]
93pub struct StatsGetMemoryStatsResponse {
94 pub stats: MemoryStats,
95}
96
97impl fidl::Persistable for StatsGetMemoryStatsResponse {}
98
99#[derive(Clone, Debug, Default, PartialEq)]
100pub struct MemoryStats {
101 pub total_bytes: Option<u64>,
102 pub free_bytes: Option<u64>,
103 pub wired_bytes: Option<u64>,
104 pub total_heap_bytes: Option<u64>,
105 pub free_heap_bytes: Option<u64>,
106 pub vmo_bytes: Option<u64>,
107 pub mmu_overhead_bytes: Option<u64>,
108 pub ipc_bytes: Option<u64>,
109 pub other_bytes: Option<u64>,
110 pub free_loaned_bytes: Option<u64>,
111 pub cache_bytes: Option<u64>,
112 pub slab_bytes: Option<u64>,
113 pub zram_bytes: Option<u64>,
114 pub vmo_reclaim_total_bytes: Option<u64>,
115 pub vmo_reclaim_newest_bytes: Option<u64>,
116 pub vmo_reclaim_oldest_bytes: Option<u64>,
117 pub vmo_reclaim_disabled_bytes: Option<u64>,
118 pub vmo_discardable_locked_bytes: Option<u64>,
119 pub vmo_discardable_unlocked_bytes: Option<u64>,
120 #[doc(hidden)]
121 pub __source_breaking: fidl::marker::SourceBreaking,
122}
123
124impl fidl::Persistable for MemoryStats {}
125
126#[derive(Clone, Debug, Default, PartialEq)]
127pub struct MemoryStatsCompression {
128 pub uncompressed_storage_bytes: Option<u64>,
129 pub compressed_storage_bytes: Option<u64>,
130 pub compressed_fragmentation_bytes: Option<u64>,
131 pub compression_time: Option<i64>,
132 pub decompression_time: Option<i64>,
133 pub total_page_compression_attempts: Option<u64>,
134 pub failed_page_compression_attempts: Option<u64>,
135 pub total_page_decompressions: Option<u64>,
136 pub compressed_page_evictions: Option<u64>,
137 pub eager_page_compressions: Option<u64>,
138 pub memory_pressure_page_compressions: Option<u64>,
139 pub critical_memory_page_compressions: Option<u64>,
140 pub pages_decompressed_unit_ns: Option<u64>,
141 pub pages_decompressed_within_log_time: Option<[u64; 8]>,
142 #[doc(hidden)]
143 pub __source_breaking: fidl::marker::SourceBreaking,
144}
145
146impl fidl::Persistable for MemoryStatsCompression {}
147
148#[derive(Clone, Debug, Default, PartialEq)]
149pub struct MemoryStatsExtended {
150 pub total_bytes: Option<u64>,
151 pub free_bytes: Option<u64>,
152 pub wired_bytes: Option<u64>,
153 pub total_heap_bytes: Option<u64>,
154 pub free_heap_bytes: Option<u64>,
155 pub vmo_bytes: Option<u64>,
156 pub vmo_pager_total_bytes: Option<u64>,
157 pub vmo_pager_newest_bytes: Option<u64>,
158 pub vmo_pager_oldest_bytes: Option<u64>,
159 pub vmo_discardable_locked_bytes: Option<u64>,
160 pub vmo_discardable_unlocked_bytes: Option<u64>,
161 pub mmu_overhead_bytes: Option<u64>,
162 pub ipc_bytes: Option<u64>,
163 pub other_bytes: Option<u64>,
164 #[doc(hidden)]
165 pub __source_breaking: fidl::marker::SourceBreaking,
166}
167
168impl fidl::Persistable for MemoryStatsExtended {}
169
170#[derive(Clone, Debug, Default, PartialEq)]
171pub struct PerCpuStats {
172 pub cpu_number: Option<u32>,
173 pub flags: Option<u32>,
174 pub idle_time: Option<i64>,
175 pub reschedules: Option<u64>,
176 pub context_switches: Option<u64>,
177 pub irq_preempts: Option<u64>,
178 pub yields: Option<u64>,
179 pub ints: Option<u64>,
180 pub timer_ints: Option<u64>,
181 pub timers: Option<u64>,
182 pub page_faults: Option<u64>,
183 pub exceptions: Option<u64>,
184 pub syscalls: Option<u64>,
185 pub reschedule_ipis: Option<u64>,
186 pub generic_ipis: Option<u64>,
187 #[doc(hidden)]
188 pub __source_breaking: fidl::marker::SourceBreaking,
189}
190
191impl fidl::Persistable for PerCpuStats {}
192
193pub mod counter_ordinals {
194 pub const GET_INSPECT_VMO: u64 = 0x6ea9b2e6b2791b81;
195 pub const UPDATE_INSPECT_VMO: u64 = 0x1d25eb7995a0539f;
196}
197
198pub mod cpu_resource_ordinals {
199 pub const GET: u64 = 0x41e1103acf4215e4;
200}
201
202pub mod debug_broker_ordinals {
203 pub const SEND_DEBUG_COMMAND: u64 = 0x1ee270f83b5d6ff6;
204 pub const SET_TRACING_ENABLED: u64 = 0x12e368d05329b30e;
205}
206
207pub mod debug_resource_ordinals {
208 pub const GET: u64 = 0x1d79d77ea12a6474;
209}
210
211pub mod debuglog_resource_ordinals {
212 pub const GET: u64 = 0x6e78c1ff74765225;
213}
214
215pub mod energy_info_resource_ordinals {
216 pub const GET: u64 = 0x5f5cc9f0745f61d0;
217}
218
219pub mod hypervisor_resource_ordinals {
220 pub const GET: u64 = 0x1c312131d3b824a2;
221}
222
223pub mod info_resource_ordinals {
224 pub const GET: u64 = 0x1de8edcb4abc2067;
225}
226
227pub mod iommu_resource_ordinals {
228 pub const GET: u64 = 0x5af309b619aa7c5b;
229}
230
231pub mod ioport_resource_ordinals {
232 pub const GET: u64 = 0x4db20876b537c52b;
233}
234
235pub mod irq_resource_ordinals {
236 pub const GET: u64 = 0x491be54504b041e9;
237}
238
239pub mod mexec_resource_ordinals {
240 pub const GET: u64 = 0xff93e6722900f54;
241}
242
243pub mod mmio_resource_ordinals {
244 pub const GET: u64 = 0x66747b9c5a6dfe7b;
245}
246
247pub mod msi_resource_ordinals {
248 pub const GET: u64 = 0x360a97e47e8c4f1f;
249}
250
251pub mod power_resource_ordinals {
252 pub const GET: u64 = 0x2b8df8ca24d1e866;
253}
254
255pub mod profile_resource_ordinals {
256 pub const GET: u64 = 0x3003a0c14de1fa86;
257}
258
259pub mod root_job_ordinals {
260 pub const GET: u64 = 0x73acb63f93d53eac;
261}
262
263pub mod root_job_for_inspect_ordinals {
264 pub const GET: u64 = 0x73acb63f93d53eac;
265}
266
267pub mod smc_resource_ordinals {
268 pub const GET: u64 = 0x392cbd495b84ede7;
269}
270
271pub mod stall_resource_ordinals {
272 pub const GET: u64 = 0x5edf4c8629a9781a;
273}
274
275pub mod stats_ordinals {
276 pub const GET_MEMORY_STATS: u64 = 0x686677932ae41074;
277 pub const GET_MEMORY_STATS_EXTENDED: u64 = 0x60faa0f8aa38c29f;
278 pub const GET_MEMORY_STATS_COMPRESSION: u64 = 0x544a09995befb531;
279 pub const GET_CPU_STATS: u64 = 0x470e2684ca1ca19e;
280 pub const GET_CPU_LOAD: u64 = 0x4c8f0f05e7034666;
281}
282
283pub mod tracing_resource_ordinals {
284 pub const GET: u64 = 0x299bc179aa54c6aa;
285}
286
287pub mod vmex_resource_ordinals {
288 pub const GET: u64 = 0x33db32deed650699;
289}
290
291mod internal {
292 use super::*;
293
294 impl fidl::encoding::ValueTypeMarker for CounterUpdateInspectVmoResponse {
295 type Borrowed<'a> = &'a Self;
296 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
297 value
298 }
299 }
300
301 unsafe impl fidl::encoding::TypeMarker for CounterUpdateInspectVmoResponse {
302 type Owned = Self;
303
304 #[inline(always)]
305 fn inline_align(_context: fidl::encoding::Context) -> usize {
306 4
307 }
308
309 #[inline(always)]
310 fn inline_size(_context: fidl::encoding::Context) -> usize {
311 4
312 }
313 #[inline(always)]
314 fn encode_is_copy() -> bool {
315 true
316 }
317
318 #[inline(always)]
319 fn decode_is_copy() -> bool {
320 true
321 }
322 }
323
324 unsafe impl<D: fidl::encoding::ResourceDialect>
325 fidl::encoding::Encode<CounterUpdateInspectVmoResponse, D>
326 for &CounterUpdateInspectVmoResponse
327 {
328 #[inline]
329 unsafe fn encode(
330 self,
331 encoder: &mut fidl::encoding::Encoder<'_, D>,
332 offset: usize,
333 _depth: fidl::encoding::Depth,
334 ) -> fidl::Result<()> {
335 encoder.debug_check_bounds::<CounterUpdateInspectVmoResponse>(offset);
336 unsafe {
337 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
339 (buf_ptr as *mut CounterUpdateInspectVmoResponse)
340 .write_unaligned((self as *const CounterUpdateInspectVmoResponse).read());
341 }
344 Ok(())
345 }
346 }
347 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
348 fidl::encoding::Encode<CounterUpdateInspectVmoResponse, D> for (T0,)
349 {
350 #[inline]
351 unsafe fn encode(
352 self,
353 encoder: &mut fidl::encoding::Encoder<'_, D>,
354 offset: usize,
355 depth: fidl::encoding::Depth,
356 ) -> fidl::Result<()> {
357 encoder.debug_check_bounds::<CounterUpdateInspectVmoResponse>(offset);
358 self.0.encode(encoder, offset + 0, depth)?;
362 Ok(())
363 }
364 }
365
366 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
367 for CounterUpdateInspectVmoResponse
368 {
369 #[inline(always)]
370 fn new_empty() -> Self {
371 Self { status: fidl::new_empty!(i32, D) }
372 }
373
374 #[inline]
375 unsafe fn decode(
376 &mut self,
377 decoder: &mut fidl::encoding::Decoder<'_, D>,
378 offset: usize,
379 _depth: fidl::encoding::Depth,
380 ) -> fidl::Result<()> {
381 decoder.debug_check_bounds::<Self>(offset);
382 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
383 unsafe {
386 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
387 }
388 Ok(())
389 }
390 }
391
392 impl fidl::encoding::ValueTypeMarker for CpuStats {
393 type Borrowed<'a> = &'a Self;
394 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
395 value
396 }
397 }
398
399 unsafe impl fidl::encoding::TypeMarker for CpuStats {
400 type Owned = Self;
401
402 #[inline(always)]
403 fn inline_align(_context: fidl::encoding::Context) -> usize {
404 8
405 }
406
407 #[inline(always)]
408 fn inline_size(_context: fidl::encoding::Context) -> usize {
409 24
410 }
411 }
412
413 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CpuStats, D> for &CpuStats {
414 #[inline]
415 unsafe fn encode(
416 self,
417 encoder: &mut fidl::encoding::Encoder<'_, D>,
418 offset: usize,
419 _depth: fidl::encoding::Depth,
420 ) -> fidl::Result<()> {
421 encoder.debug_check_bounds::<CpuStats>(offset);
422 fidl::encoding::Encode::<CpuStats, D>::encode(
424 (
425 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.actual_num_cpus),
426 <fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>> as fidl::encoding::ValueTypeMarker>::borrow(&self.per_cpu_stats),
427 ),
428 encoder, offset, _depth
429 )
430 }
431 }
432 unsafe impl<
433 D: fidl::encoding::ResourceDialect,
434 T0: fidl::encoding::Encode<u64, D>,
435 T1: fidl::encoding::Encode<
436 fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
437 D,
438 >,
439 > fidl::encoding::Encode<CpuStats, D> for (T0, T1)
440 {
441 #[inline]
442 unsafe fn encode(
443 self,
444 encoder: &mut fidl::encoding::Encoder<'_, D>,
445 offset: usize,
446 depth: fidl::encoding::Depth,
447 ) -> fidl::Result<()> {
448 encoder.debug_check_bounds::<CpuStats>(offset);
449 self.0.encode(encoder, offset + 0, depth)?;
453 self.1.encode(encoder, offset + 8, depth)?;
454 Ok(())
455 }
456 }
457
458 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CpuStats {
459 #[inline(always)]
460 fn new_empty() -> Self {
461 Self {
462 actual_num_cpus: fidl::new_empty!(u64, D),
463 per_cpu_stats: fidl::new_empty!(
464 fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
465 D
466 ),
467 }
468 }
469
470 #[inline]
471 unsafe fn decode(
472 &mut self,
473 decoder: &mut fidl::encoding::Decoder<'_, D>,
474 offset: usize,
475 _depth: fidl::encoding::Depth,
476 ) -> fidl::Result<()> {
477 decoder.debug_check_bounds::<Self>(offset);
478 fidl::decode!(u64, D, &mut self.actual_num_cpus, decoder, offset + 0, _depth)?;
480 fidl::decode!(
481 fidl::encoding::Optional<fidl::encoding::Vector<PerCpuStats, 512>>,
482 D,
483 &mut self.per_cpu_stats,
484 decoder,
485 offset + 8,
486 _depth
487 )?;
488 Ok(())
489 }
490 }
491
492 impl fidl::encoding::ValueTypeMarker for DebugBrokerSendDebugCommandRequest {
493 type Borrowed<'a> = &'a Self;
494 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
495 value
496 }
497 }
498
499 unsafe impl fidl::encoding::TypeMarker for DebugBrokerSendDebugCommandRequest {
500 type Owned = Self;
501
502 #[inline(always)]
503 fn inline_align(_context: fidl::encoding::Context) -> usize {
504 8
505 }
506
507 #[inline(always)]
508 fn inline_size(_context: fidl::encoding::Context) -> usize {
509 16
510 }
511 }
512
513 unsafe impl<D: fidl::encoding::ResourceDialect>
514 fidl::encoding::Encode<DebugBrokerSendDebugCommandRequest, D>
515 for &DebugBrokerSendDebugCommandRequest
516 {
517 #[inline]
518 unsafe fn encode(
519 self,
520 encoder: &mut fidl::encoding::Encoder<'_, D>,
521 offset: usize,
522 _depth: fidl::encoding::Depth,
523 ) -> fidl::Result<()> {
524 encoder.debug_check_bounds::<DebugBrokerSendDebugCommandRequest>(offset);
525 fidl::encoding::Encode::<DebugBrokerSendDebugCommandRequest, D>::encode(
527 (<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow(
528 &self.command,
529 ),),
530 encoder,
531 offset,
532 _depth,
533 )
534 }
535 }
536 unsafe impl<
537 D: fidl::encoding::ResourceDialect,
538 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<1024>, D>,
539 > fidl::encoding::Encode<DebugBrokerSendDebugCommandRequest, D> for (T0,)
540 {
541 #[inline]
542 unsafe fn encode(
543 self,
544 encoder: &mut fidl::encoding::Encoder<'_, D>,
545 offset: usize,
546 depth: fidl::encoding::Depth,
547 ) -> fidl::Result<()> {
548 encoder.debug_check_bounds::<DebugBrokerSendDebugCommandRequest>(offset);
549 self.0.encode(encoder, offset + 0, depth)?;
553 Ok(())
554 }
555 }
556
557 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
558 for DebugBrokerSendDebugCommandRequest
559 {
560 #[inline(always)]
561 fn new_empty() -> Self {
562 Self { command: fidl::new_empty!(fidl::encoding::BoundedString<1024>, D) }
563 }
564
565 #[inline]
566 unsafe fn decode(
567 &mut self,
568 decoder: &mut fidl::encoding::Decoder<'_, D>,
569 offset: usize,
570 _depth: fidl::encoding::Depth,
571 ) -> fidl::Result<()> {
572 decoder.debug_check_bounds::<Self>(offset);
573 fidl::decode!(
575 fidl::encoding::BoundedString<1024>,
576 D,
577 &mut self.command,
578 decoder,
579 offset + 0,
580 _depth
581 )?;
582 Ok(())
583 }
584 }
585
586 impl fidl::encoding::ValueTypeMarker for DebugBrokerSendDebugCommandResponse {
587 type Borrowed<'a> = &'a Self;
588 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
589 value
590 }
591 }
592
593 unsafe impl fidl::encoding::TypeMarker for DebugBrokerSendDebugCommandResponse {
594 type Owned = Self;
595
596 #[inline(always)]
597 fn inline_align(_context: fidl::encoding::Context) -> usize {
598 4
599 }
600
601 #[inline(always)]
602 fn inline_size(_context: fidl::encoding::Context) -> usize {
603 4
604 }
605 #[inline(always)]
606 fn encode_is_copy() -> bool {
607 true
608 }
609
610 #[inline(always)]
611 fn decode_is_copy() -> bool {
612 true
613 }
614 }
615
616 unsafe impl<D: fidl::encoding::ResourceDialect>
617 fidl::encoding::Encode<DebugBrokerSendDebugCommandResponse, D>
618 for &DebugBrokerSendDebugCommandResponse
619 {
620 #[inline]
621 unsafe fn encode(
622 self,
623 encoder: &mut fidl::encoding::Encoder<'_, D>,
624 offset: usize,
625 _depth: fidl::encoding::Depth,
626 ) -> fidl::Result<()> {
627 encoder.debug_check_bounds::<DebugBrokerSendDebugCommandResponse>(offset);
628 unsafe {
629 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
631 (buf_ptr as *mut DebugBrokerSendDebugCommandResponse)
632 .write_unaligned((self as *const DebugBrokerSendDebugCommandResponse).read());
633 }
636 Ok(())
637 }
638 }
639 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
640 fidl::encoding::Encode<DebugBrokerSendDebugCommandResponse, D> for (T0,)
641 {
642 #[inline]
643 unsafe fn encode(
644 self,
645 encoder: &mut fidl::encoding::Encoder<'_, D>,
646 offset: usize,
647 depth: fidl::encoding::Depth,
648 ) -> fidl::Result<()> {
649 encoder.debug_check_bounds::<DebugBrokerSendDebugCommandResponse>(offset);
650 self.0.encode(encoder, offset + 0, depth)?;
654 Ok(())
655 }
656 }
657
658 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
659 for DebugBrokerSendDebugCommandResponse
660 {
661 #[inline(always)]
662 fn new_empty() -> Self {
663 Self { status: fidl::new_empty!(i32, D) }
664 }
665
666 #[inline]
667 unsafe fn decode(
668 &mut self,
669 decoder: &mut fidl::encoding::Decoder<'_, D>,
670 offset: usize,
671 _depth: fidl::encoding::Depth,
672 ) -> fidl::Result<()> {
673 decoder.debug_check_bounds::<Self>(offset);
674 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
675 unsafe {
678 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
679 }
680 Ok(())
681 }
682 }
683
684 impl fidl::encoding::ValueTypeMarker for DebugBrokerSetTracingEnabledRequest {
685 type Borrowed<'a> = &'a Self;
686 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
687 value
688 }
689 }
690
691 unsafe impl fidl::encoding::TypeMarker for DebugBrokerSetTracingEnabledRequest {
692 type Owned = Self;
693
694 #[inline(always)]
695 fn inline_align(_context: fidl::encoding::Context) -> usize {
696 1
697 }
698
699 #[inline(always)]
700 fn inline_size(_context: fidl::encoding::Context) -> usize {
701 1
702 }
703 }
704
705 unsafe impl<D: fidl::encoding::ResourceDialect>
706 fidl::encoding::Encode<DebugBrokerSetTracingEnabledRequest, D>
707 for &DebugBrokerSetTracingEnabledRequest
708 {
709 #[inline]
710 unsafe fn encode(
711 self,
712 encoder: &mut fidl::encoding::Encoder<'_, D>,
713 offset: usize,
714 _depth: fidl::encoding::Depth,
715 ) -> fidl::Result<()> {
716 encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledRequest>(offset);
717 fidl::encoding::Encode::<DebugBrokerSetTracingEnabledRequest, D>::encode(
719 (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
720 encoder,
721 offset,
722 _depth,
723 )
724 }
725 }
726 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
727 fidl::encoding::Encode<DebugBrokerSetTracingEnabledRequest, D> for (T0,)
728 {
729 #[inline]
730 unsafe fn encode(
731 self,
732 encoder: &mut fidl::encoding::Encoder<'_, D>,
733 offset: usize,
734 depth: fidl::encoding::Depth,
735 ) -> fidl::Result<()> {
736 encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledRequest>(offset);
737 self.0.encode(encoder, offset + 0, depth)?;
741 Ok(())
742 }
743 }
744
745 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
746 for DebugBrokerSetTracingEnabledRequest
747 {
748 #[inline(always)]
749 fn new_empty() -> Self {
750 Self { enabled: fidl::new_empty!(bool, D) }
751 }
752
753 #[inline]
754 unsafe fn decode(
755 &mut self,
756 decoder: &mut fidl::encoding::Decoder<'_, D>,
757 offset: usize,
758 _depth: fidl::encoding::Depth,
759 ) -> fidl::Result<()> {
760 decoder.debug_check_bounds::<Self>(offset);
761 fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
763 Ok(())
764 }
765 }
766
767 impl fidl::encoding::ValueTypeMarker for DebugBrokerSetTracingEnabledResponse {
768 type Borrowed<'a> = &'a Self;
769 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
770 value
771 }
772 }
773
774 unsafe impl fidl::encoding::TypeMarker for DebugBrokerSetTracingEnabledResponse {
775 type Owned = Self;
776
777 #[inline(always)]
778 fn inline_align(_context: fidl::encoding::Context) -> usize {
779 4
780 }
781
782 #[inline(always)]
783 fn inline_size(_context: fidl::encoding::Context) -> usize {
784 4
785 }
786 #[inline(always)]
787 fn encode_is_copy() -> bool {
788 true
789 }
790
791 #[inline(always)]
792 fn decode_is_copy() -> bool {
793 true
794 }
795 }
796
797 unsafe impl<D: fidl::encoding::ResourceDialect>
798 fidl::encoding::Encode<DebugBrokerSetTracingEnabledResponse, D>
799 for &DebugBrokerSetTracingEnabledResponse
800 {
801 #[inline]
802 unsafe fn encode(
803 self,
804 encoder: &mut fidl::encoding::Encoder<'_, D>,
805 offset: usize,
806 _depth: fidl::encoding::Depth,
807 ) -> fidl::Result<()> {
808 encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledResponse>(offset);
809 unsafe {
810 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
812 (buf_ptr as *mut DebugBrokerSetTracingEnabledResponse)
813 .write_unaligned((self as *const DebugBrokerSetTracingEnabledResponse).read());
814 }
817 Ok(())
818 }
819 }
820 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
821 fidl::encoding::Encode<DebugBrokerSetTracingEnabledResponse, D> for (T0,)
822 {
823 #[inline]
824 unsafe fn encode(
825 self,
826 encoder: &mut fidl::encoding::Encoder<'_, D>,
827 offset: usize,
828 depth: fidl::encoding::Depth,
829 ) -> fidl::Result<()> {
830 encoder.debug_check_bounds::<DebugBrokerSetTracingEnabledResponse>(offset);
831 self.0.encode(encoder, offset + 0, depth)?;
835 Ok(())
836 }
837 }
838
839 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
840 for DebugBrokerSetTracingEnabledResponse
841 {
842 #[inline(always)]
843 fn new_empty() -> Self {
844 Self { status: fidl::new_empty!(i32, D) }
845 }
846
847 #[inline]
848 unsafe fn decode(
849 &mut self,
850 decoder: &mut fidl::encoding::Decoder<'_, D>,
851 offset: usize,
852 _depth: fidl::encoding::Depth,
853 ) -> fidl::Result<()> {
854 decoder.debug_check_bounds::<Self>(offset);
855 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
856 unsafe {
859 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
860 }
861 Ok(())
862 }
863 }
864
865 impl fidl::encoding::ValueTypeMarker for StatsGetCpuLoadRequest {
866 type Borrowed<'a> = &'a Self;
867 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
868 value
869 }
870 }
871
872 unsafe impl fidl::encoding::TypeMarker for StatsGetCpuLoadRequest {
873 type Owned = Self;
874
875 #[inline(always)]
876 fn inline_align(_context: fidl::encoding::Context) -> usize {
877 8
878 }
879
880 #[inline(always)]
881 fn inline_size(_context: fidl::encoding::Context) -> usize {
882 8
883 }
884 #[inline(always)]
885 fn encode_is_copy() -> bool {
886 true
887 }
888
889 #[inline(always)]
890 fn decode_is_copy() -> bool {
891 true
892 }
893 }
894
895 unsafe impl<D: fidl::encoding::ResourceDialect>
896 fidl::encoding::Encode<StatsGetCpuLoadRequest, D> for &StatsGetCpuLoadRequest
897 {
898 #[inline]
899 unsafe fn encode(
900 self,
901 encoder: &mut fidl::encoding::Encoder<'_, D>,
902 offset: usize,
903 _depth: fidl::encoding::Depth,
904 ) -> fidl::Result<()> {
905 encoder.debug_check_bounds::<StatsGetCpuLoadRequest>(offset);
906 unsafe {
907 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
909 (buf_ptr as *mut StatsGetCpuLoadRequest)
910 .write_unaligned((self as *const StatsGetCpuLoadRequest).read());
911 }
914 Ok(())
915 }
916 }
917 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
918 fidl::encoding::Encode<StatsGetCpuLoadRequest, D> for (T0,)
919 {
920 #[inline]
921 unsafe fn encode(
922 self,
923 encoder: &mut fidl::encoding::Encoder<'_, D>,
924 offset: usize,
925 depth: fidl::encoding::Depth,
926 ) -> fidl::Result<()> {
927 encoder.debug_check_bounds::<StatsGetCpuLoadRequest>(offset);
928 self.0.encode(encoder, offset + 0, depth)?;
932 Ok(())
933 }
934 }
935
936 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
937 for StatsGetCpuLoadRequest
938 {
939 #[inline(always)]
940 fn new_empty() -> Self {
941 Self { duration: fidl::new_empty!(i64, D) }
942 }
943
944 #[inline]
945 unsafe fn decode(
946 &mut self,
947 decoder: &mut fidl::encoding::Decoder<'_, D>,
948 offset: usize,
949 _depth: fidl::encoding::Depth,
950 ) -> fidl::Result<()> {
951 decoder.debug_check_bounds::<Self>(offset);
952 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
953 unsafe {
956 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
957 }
958 Ok(())
959 }
960 }
961
962 impl fidl::encoding::ValueTypeMarker for StatsGetCpuLoadResponse {
963 type Borrowed<'a> = &'a Self;
964 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
965 value
966 }
967 }
968
969 unsafe impl fidl::encoding::TypeMarker for StatsGetCpuLoadResponse {
970 type Owned = Self;
971
972 #[inline(always)]
973 fn inline_align(_context: fidl::encoding::Context) -> usize {
974 8
975 }
976
977 #[inline(always)]
978 fn inline_size(_context: fidl::encoding::Context) -> usize {
979 16
980 }
981 }
982
983 unsafe impl<D: fidl::encoding::ResourceDialect>
984 fidl::encoding::Encode<StatsGetCpuLoadResponse, D> for &StatsGetCpuLoadResponse
985 {
986 #[inline]
987 unsafe fn encode(
988 self,
989 encoder: &mut fidl::encoding::Encoder<'_, D>,
990 offset: usize,
991 _depth: fidl::encoding::Depth,
992 ) -> fidl::Result<()> {
993 encoder.debug_check_bounds::<StatsGetCpuLoadResponse>(offset);
994 fidl::encoding::Encode::<StatsGetCpuLoadResponse, D>::encode(
996 (<fidl::encoding::Vector<f32, 512> as fidl::encoding::ValueTypeMarker>::borrow(
997 &self.per_cpu_load,
998 ),),
999 encoder,
1000 offset,
1001 _depth,
1002 )
1003 }
1004 }
1005 unsafe impl<
1006 D: fidl::encoding::ResourceDialect,
1007 T0: fidl::encoding::Encode<fidl::encoding::Vector<f32, 512>, D>,
1008 > fidl::encoding::Encode<StatsGetCpuLoadResponse, D> for (T0,)
1009 {
1010 #[inline]
1011 unsafe fn encode(
1012 self,
1013 encoder: &mut fidl::encoding::Encoder<'_, D>,
1014 offset: usize,
1015 depth: fidl::encoding::Depth,
1016 ) -> fidl::Result<()> {
1017 encoder.debug_check_bounds::<StatsGetCpuLoadResponse>(offset);
1018 self.0.encode(encoder, offset + 0, depth)?;
1022 Ok(())
1023 }
1024 }
1025
1026 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1027 for StatsGetCpuLoadResponse
1028 {
1029 #[inline(always)]
1030 fn new_empty() -> Self {
1031 Self { per_cpu_load: fidl::new_empty!(fidl::encoding::Vector<f32, 512>, D) }
1032 }
1033
1034 #[inline]
1035 unsafe fn decode(
1036 &mut self,
1037 decoder: &mut fidl::encoding::Decoder<'_, D>,
1038 offset: usize,
1039 _depth: fidl::encoding::Depth,
1040 ) -> fidl::Result<()> {
1041 decoder.debug_check_bounds::<Self>(offset);
1042 fidl::decode!(fidl::encoding::Vector<f32, 512>, D, &mut self.per_cpu_load, decoder, offset + 0, _depth)?;
1044 Ok(())
1045 }
1046 }
1047
1048 impl fidl::encoding::ValueTypeMarker for StatsGetCpuStatsResponse {
1049 type Borrowed<'a> = &'a Self;
1050 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1051 value
1052 }
1053 }
1054
1055 unsafe impl fidl::encoding::TypeMarker for StatsGetCpuStatsResponse {
1056 type Owned = Self;
1057
1058 #[inline(always)]
1059 fn inline_align(_context: fidl::encoding::Context) -> usize {
1060 8
1061 }
1062
1063 #[inline(always)]
1064 fn inline_size(_context: fidl::encoding::Context) -> usize {
1065 24
1066 }
1067 }
1068
1069 unsafe impl<D: fidl::encoding::ResourceDialect>
1070 fidl::encoding::Encode<StatsGetCpuStatsResponse, D> for &StatsGetCpuStatsResponse
1071 {
1072 #[inline]
1073 unsafe fn encode(
1074 self,
1075 encoder: &mut fidl::encoding::Encoder<'_, D>,
1076 offset: usize,
1077 _depth: fidl::encoding::Depth,
1078 ) -> fidl::Result<()> {
1079 encoder.debug_check_bounds::<StatsGetCpuStatsResponse>(offset);
1080 fidl::encoding::Encode::<StatsGetCpuStatsResponse, D>::encode(
1082 (<CpuStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1083 encoder,
1084 offset,
1085 _depth,
1086 )
1087 }
1088 }
1089 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<CpuStats, D>>
1090 fidl::encoding::Encode<StatsGetCpuStatsResponse, D> for (T0,)
1091 {
1092 #[inline]
1093 unsafe fn encode(
1094 self,
1095 encoder: &mut fidl::encoding::Encoder<'_, D>,
1096 offset: usize,
1097 depth: fidl::encoding::Depth,
1098 ) -> fidl::Result<()> {
1099 encoder.debug_check_bounds::<StatsGetCpuStatsResponse>(offset);
1100 self.0.encode(encoder, offset + 0, depth)?;
1104 Ok(())
1105 }
1106 }
1107
1108 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1109 for StatsGetCpuStatsResponse
1110 {
1111 #[inline(always)]
1112 fn new_empty() -> Self {
1113 Self { stats: fidl::new_empty!(CpuStats, D) }
1114 }
1115
1116 #[inline]
1117 unsafe fn decode(
1118 &mut self,
1119 decoder: &mut fidl::encoding::Decoder<'_, D>,
1120 offset: usize,
1121 _depth: fidl::encoding::Depth,
1122 ) -> fidl::Result<()> {
1123 decoder.debug_check_bounds::<Self>(offset);
1124 fidl::decode!(CpuStats, D, &mut self.stats, decoder, offset + 0, _depth)?;
1126 Ok(())
1127 }
1128 }
1129
1130 impl fidl::encoding::ValueTypeMarker for StatsGetMemoryStatsExtendedResponse {
1131 type Borrowed<'a> = &'a Self;
1132 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1133 value
1134 }
1135 }
1136
1137 unsafe impl fidl::encoding::TypeMarker for StatsGetMemoryStatsExtendedResponse {
1138 type Owned = Self;
1139
1140 #[inline(always)]
1141 fn inline_align(_context: fidl::encoding::Context) -> usize {
1142 8
1143 }
1144
1145 #[inline(always)]
1146 fn inline_size(_context: fidl::encoding::Context) -> usize {
1147 16
1148 }
1149 }
1150
1151 unsafe impl<D: fidl::encoding::ResourceDialect>
1152 fidl::encoding::Encode<StatsGetMemoryStatsExtendedResponse, D>
1153 for &StatsGetMemoryStatsExtendedResponse
1154 {
1155 #[inline]
1156 unsafe fn encode(
1157 self,
1158 encoder: &mut fidl::encoding::Encoder<'_, D>,
1159 offset: usize,
1160 _depth: fidl::encoding::Depth,
1161 ) -> fidl::Result<()> {
1162 encoder.debug_check_bounds::<StatsGetMemoryStatsExtendedResponse>(offset);
1163 fidl::encoding::Encode::<StatsGetMemoryStatsExtendedResponse, D>::encode(
1165 (<MemoryStatsExtended as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1166 encoder,
1167 offset,
1168 _depth,
1169 )
1170 }
1171 }
1172 unsafe impl<
1173 D: fidl::encoding::ResourceDialect,
1174 T0: fidl::encoding::Encode<MemoryStatsExtended, D>,
1175 > fidl::encoding::Encode<StatsGetMemoryStatsExtendedResponse, D> for (T0,)
1176 {
1177 #[inline]
1178 unsafe fn encode(
1179 self,
1180 encoder: &mut fidl::encoding::Encoder<'_, D>,
1181 offset: usize,
1182 depth: fidl::encoding::Depth,
1183 ) -> fidl::Result<()> {
1184 encoder.debug_check_bounds::<StatsGetMemoryStatsExtendedResponse>(offset);
1185 self.0.encode(encoder, offset + 0, depth)?;
1189 Ok(())
1190 }
1191 }
1192
1193 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1194 for StatsGetMemoryStatsExtendedResponse
1195 {
1196 #[inline(always)]
1197 fn new_empty() -> Self {
1198 Self { stats: fidl::new_empty!(MemoryStatsExtended, D) }
1199 }
1200
1201 #[inline]
1202 unsafe fn decode(
1203 &mut self,
1204 decoder: &mut fidl::encoding::Decoder<'_, D>,
1205 offset: usize,
1206 _depth: fidl::encoding::Depth,
1207 ) -> fidl::Result<()> {
1208 decoder.debug_check_bounds::<Self>(offset);
1209 fidl::decode!(MemoryStatsExtended, D, &mut self.stats, decoder, offset + 0, _depth)?;
1211 Ok(())
1212 }
1213 }
1214
1215 impl fidl::encoding::ValueTypeMarker for StatsGetMemoryStatsResponse {
1216 type Borrowed<'a> = &'a Self;
1217 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1218 value
1219 }
1220 }
1221
1222 unsafe impl fidl::encoding::TypeMarker for StatsGetMemoryStatsResponse {
1223 type Owned = Self;
1224
1225 #[inline(always)]
1226 fn inline_align(_context: fidl::encoding::Context) -> usize {
1227 8
1228 }
1229
1230 #[inline(always)]
1231 fn inline_size(_context: fidl::encoding::Context) -> usize {
1232 16
1233 }
1234 }
1235
1236 unsafe impl<D: fidl::encoding::ResourceDialect>
1237 fidl::encoding::Encode<StatsGetMemoryStatsResponse, D> for &StatsGetMemoryStatsResponse
1238 {
1239 #[inline]
1240 unsafe fn encode(
1241 self,
1242 encoder: &mut fidl::encoding::Encoder<'_, D>,
1243 offset: usize,
1244 _depth: fidl::encoding::Depth,
1245 ) -> fidl::Result<()> {
1246 encoder.debug_check_bounds::<StatsGetMemoryStatsResponse>(offset);
1247 fidl::encoding::Encode::<StatsGetMemoryStatsResponse, D>::encode(
1249 (<MemoryStats as fidl::encoding::ValueTypeMarker>::borrow(&self.stats),),
1250 encoder,
1251 offset,
1252 _depth,
1253 )
1254 }
1255 }
1256 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MemoryStats, D>>
1257 fidl::encoding::Encode<StatsGetMemoryStatsResponse, D> for (T0,)
1258 {
1259 #[inline]
1260 unsafe fn encode(
1261 self,
1262 encoder: &mut fidl::encoding::Encoder<'_, D>,
1263 offset: usize,
1264 depth: fidl::encoding::Depth,
1265 ) -> fidl::Result<()> {
1266 encoder.debug_check_bounds::<StatsGetMemoryStatsResponse>(offset);
1267 self.0.encode(encoder, offset + 0, depth)?;
1271 Ok(())
1272 }
1273 }
1274
1275 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1276 for StatsGetMemoryStatsResponse
1277 {
1278 #[inline(always)]
1279 fn new_empty() -> Self {
1280 Self { stats: fidl::new_empty!(MemoryStats, D) }
1281 }
1282
1283 #[inline]
1284 unsafe fn decode(
1285 &mut self,
1286 decoder: &mut fidl::encoding::Decoder<'_, D>,
1287 offset: usize,
1288 _depth: fidl::encoding::Depth,
1289 ) -> fidl::Result<()> {
1290 decoder.debug_check_bounds::<Self>(offset);
1291 fidl::decode!(MemoryStats, D, &mut self.stats, decoder, offset + 0, _depth)?;
1293 Ok(())
1294 }
1295 }
1296
1297 impl MemoryStats {
1298 #[inline(always)]
1299 fn max_ordinal_present(&self) -> u64 {
1300 if let Some(_) = self.vmo_discardable_unlocked_bytes {
1301 return 19;
1302 }
1303 if let Some(_) = self.vmo_discardable_locked_bytes {
1304 return 18;
1305 }
1306 if let Some(_) = self.vmo_reclaim_disabled_bytes {
1307 return 17;
1308 }
1309 if let Some(_) = self.vmo_reclaim_oldest_bytes {
1310 return 16;
1311 }
1312 if let Some(_) = self.vmo_reclaim_newest_bytes {
1313 return 15;
1314 }
1315 if let Some(_) = self.vmo_reclaim_total_bytes {
1316 return 14;
1317 }
1318 if let Some(_) = self.zram_bytes {
1319 return 13;
1320 }
1321 if let Some(_) = self.slab_bytes {
1322 return 12;
1323 }
1324 if let Some(_) = self.cache_bytes {
1325 return 11;
1326 }
1327 if let Some(_) = self.free_loaned_bytes {
1328 return 10;
1329 }
1330 if let Some(_) = self.other_bytes {
1331 return 9;
1332 }
1333 if let Some(_) = self.ipc_bytes {
1334 return 8;
1335 }
1336 if let Some(_) = self.mmu_overhead_bytes {
1337 return 7;
1338 }
1339 if let Some(_) = self.vmo_bytes {
1340 return 6;
1341 }
1342 if let Some(_) = self.free_heap_bytes {
1343 return 5;
1344 }
1345 if let Some(_) = self.total_heap_bytes {
1346 return 4;
1347 }
1348 if let Some(_) = self.wired_bytes {
1349 return 3;
1350 }
1351 if let Some(_) = self.free_bytes {
1352 return 2;
1353 }
1354 if let Some(_) = self.total_bytes {
1355 return 1;
1356 }
1357 0
1358 }
1359 }
1360
1361 impl fidl::encoding::ValueTypeMarker for MemoryStats {
1362 type Borrowed<'a> = &'a Self;
1363 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1364 value
1365 }
1366 }
1367
1368 unsafe impl fidl::encoding::TypeMarker for MemoryStats {
1369 type Owned = Self;
1370
1371 #[inline(always)]
1372 fn inline_align(_context: fidl::encoding::Context) -> usize {
1373 8
1374 }
1375
1376 #[inline(always)]
1377 fn inline_size(_context: fidl::encoding::Context) -> usize {
1378 16
1379 }
1380 }
1381
1382 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MemoryStats, D>
1383 for &MemoryStats
1384 {
1385 unsafe fn encode(
1386 self,
1387 encoder: &mut fidl::encoding::Encoder<'_, D>,
1388 offset: usize,
1389 mut depth: fidl::encoding::Depth,
1390 ) -> fidl::Result<()> {
1391 encoder.debug_check_bounds::<MemoryStats>(offset);
1392 let max_ordinal: u64 = self.max_ordinal_present();
1394 encoder.write_num(max_ordinal, offset);
1395 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1396 if max_ordinal == 0 {
1398 return Ok(());
1399 }
1400 depth.increment()?;
1401 let envelope_size = 8;
1402 let bytes_len = max_ordinal as usize * envelope_size;
1403 #[allow(unused_variables)]
1404 let offset = encoder.out_of_line_offset(bytes_len);
1405 let mut _prev_end_offset: usize = 0;
1406 if 1 > max_ordinal {
1407 return Ok(());
1408 }
1409
1410 let cur_offset: usize = (1 - 1) * envelope_size;
1413
1414 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1416
1417 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1422 self.total_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1423 encoder,
1424 offset + cur_offset,
1425 depth,
1426 )?;
1427
1428 _prev_end_offset = cur_offset + envelope_size;
1429 if 2 > max_ordinal {
1430 return Ok(());
1431 }
1432
1433 let cur_offset: usize = (2 - 1) * envelope_size;
1436
1437 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1439
1440 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1445 self.free_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1446 encoder,
1447 offset + cur_offset,
1448 depth,
1449 )?;
1450
1451 _prev_end_offset = cur_offset + envelope_size;
1452 if 3 > max_ordinal {
1453 return Ok(());
1454 }
1455
1456 let cur_offset: usize = (3 - 1) * envelope_size;
1459
1460 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1462
1463 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1468 self.wired_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1469 encoder,
1470 offset + cur_offset,
1471 depth,
1472 )?;
1473
1474 _prev_end_offset = cur_offset + envelope_size;
1475 if 4 > max_ordinal {
1476 return Ok(());
1477 }
1478
1479 let cur_offset: usize = (4 - 1) * envelope_size;
1482
1483 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1485
1486 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1491 self.total_heap_bytes
1492 .as_ref()
1493 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1494 encoder,
1495 offset + cur_offset,
1496 depth,
1497 )?;
1498
1499 _prev_end_offset = cur_offset + envelope_size;
1500 if 5 > max_ordinal {
1501 return Ok(());
1502 }
1503
1504 let cur_offset: usize = (5 - 1) * envelope_size;
1507
1508 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1510
1511 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1516 self.free_heap_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1517 encoder,
1518 offset + cur_offset,
1519 depth,
1520 )?;
1521
1522 _prev_end_offset = cur_offset + envelope_size;
1523 if 6 > max_ordinal {
1524 return Ok(());
1525 }
1526
1527 let cur_offset: usize = (6 - 1) * envelope_size;
1530
1531 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1533
1534 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1539 self.vmo_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1540 encoder,
1541 offset + cur_offset,
1542 depth,
1543 )?;
1544
1545 _prev_end_offset = cur_offset + envelope_size;
1546 if 7 > max_ordinal {
1547 return Ok(());
1548 }
1549
1550 let cur_offset: usize = (7 - 1) * envelope_size;
1553
1554 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1556
1557 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1562 self.mmu_overhead_bytes
1563 .as_ref()
1564 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1565 encoder,
1566 offset + cur_offset,
1567 depth,
1568 )?;
1569
1570 _prev_end_offset = cur_offset + envelope_size;
1571 if 8 > max_ordinal {
1572 return Ok(());
1573 }
1574
1575 let cur_offset: usize = (8 - 1) * envelope_size;
1578
1579 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1581
1582 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1587 self.ipc_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1588 encoder,
1589 offset + cur_offset,
1590 depth,
1591 )?;
1592
1593 _prev_end_offset = cur_offset + envelope_size;
1594 if 9 > max_ordinal {
1595 return Ok(());
1596 }
1597
1598 let cur_offset: usize = (9 - 1) * envelope_size;
1601
1602 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1604
1605 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1610 self.other_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1611 encoder,
1612 offset + cur_offset,
1613 depth,
1614 )?;
1615
1616 _prev_end_offset = cur_offset + envelope_size;
1617 if 10 > max_ordinal {
1618 return Ok(());
1619 }
1620
1621 let cur_offset: usize = (10 - 1) * envelope_size;
1624
1625 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1627
1628 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1633 self.free_loaned_bytes
1634 .as_ref()
1635 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1636 encoder,
1637 offset + cur_offset,
1638 depth,
1639 )?;
1640
1641 _prev_end_offset = cur_offset + envelope_size;
1642 if 11 > max_ordinal {
1643 return Ok(());
1644 }
1645
1646 let cur_offset: usize = (11 - 1) * envelope_size;
1649
1650 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1652
1653 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1658 self.cache_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1659 encoder,
1660 offset + cur_offset,
1661 depth,
1662 )?;
1663
1664 _prev_end_offset = cur_offset + envelope_size;
1665 if 12 > max_ordinal {
1666 return Ok(());
1667 }
1668
1669 let cur_offset: usize = (12 - 1) * envelope_size;
1672
1673 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1675
1676 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1681 self.slab_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1682 encoder,
1683 offset + cur_offset,
1684 depth,
1685 )?;
1686
1687 _prev_end_offset = cur_offset + envelope_size;
1688 if 13 > max_ordinal {
1689 return Ok(());
1690 }
1691
1692 let cur_offset: usize = (13 - 1) * envelope_size;
1695
1696 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1698
1699 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1704 self.zram_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1705 encoder,
1706 offset + cur_offset,
1707 depth,
1708 )?;
1709
1710 _prev_end_offset = cur_offset + envelope_size;
1711 if 14 > max_ordinal {
1712 return Ok(());
1713 }
1714
1715 let cur_offset: usize = (14 - 1) * envelope_size;
1718
1719 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1721
1722 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1727 self.vmo_reclaim_total_bytes
1728 .as_ref()
1729 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1730 encoder,
1731 offset + cur_offset,
1732 depth,
1733 )?;
1734
1735 _prev_end_offset = cur_offset + envelope_size;
1736 if 15 > max_ordinal {
1737 return Ok(());
1738 }
1739
1740 let cur_offset: usize = (15 - 1) * envelope_size;
1743
1744 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1746
1747 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1752 self.vmo_reclaim_newest_bytes
1753 .as_ref()
1754 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1755 encoder,
1756 offset + cur_offset,
1757 depth,
1758 )?;
1759
1760 _prev_end_offset = cur_offset + envelope_size;
1761 if 16 > max_ordinal {
1762 return Ok(());
1763 }
1764
1765 let cur_offset: usize = (16 - 1) * envelope_size;
1768
1769 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1771
1772 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1777 self.vmo_reclaim_oldest_bytes
1778 .as_ref()
1779 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1780 encoder,
1781 offset + cur_offset,
1782 depth,
1783 )?;
1784
1785 _prev_end_offset = cur_offset + envelope_size;
1786 if 17 > max_ordinal {
1787 return Ok(());
1788 }
1789
1790 let cur_offset: usize = (17 - 1) * envelope_size;
1793
1794 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1796
1797 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1802 self.vmo_reclaim_disabled_bytes
1803 .as_ref()
1804 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1805 encoder,
1806 offset + cur_offset,
1807 depth,
1808 )?;
1809
1810 _prev_end_offset = cur_offset + envelope_size;
1811 if 18 > max_ordinal {
1812 return Ok(());
1813 }
1814
1815 let cur_offset: usize = (18 - 1) * envelope_size;
1818
1819 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1821
1822 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1827 self.vmo_discardable_locked_bytes
1828 .as_ref()
1829 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1830 encoder,
1831 offset + cur_offset,
1832 depth,
1833 )?;
1834
1835 _prev_end_offset = cur_offset + envelope_size;
1836 if 19 > max_ordinal {
1837 return Ok(());
1838 }
1839
1840 let cur_offset: usize = (19 - 1) * envelope_size;
1843
1844 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1846
1847 fidl::encoding::encode_in_envelope_optional::<u64, D>(
1852 self.vmo_discardable_unlocked_bytes
1853 .as_ref()
1854 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1855 encoder,
1856 offset + cur_offset,
1857 depth,
1858 )?;
1859
1860 _prev_end_offset = cur_offset + envelope_size;
1861
1862 Ok(())
1863 }
1864 }
1865
1866 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MemoryStats {
1867 #[inline(always)]
1868 fn new_empty() -> Self {
1869 Self::default()
1870 }
1871
1872 unsafe fn decode(
1873 &mut self,
1874 decoder: &mut fidl::encoding::Decoder<'_, D>,
1875 offset: usize,
1876 mut depth: fidl::encoding::Depth,
1877 ) -> fidl::Result<()> {
1878 decoder.debug_check_bounds::<Self>(offset);
1879 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1880 None => return Err(fidl::Error::NotNullable),
1881 Some(len) => len,
1882 };
1883 if len == 0 {
1885 return Ok(());
1886 };
1887 depth.increment()?;
1888 let envelope_size = 8;
1889 let bytes_len = len * envelope_size;
1890 let offset = decoder.out_of_line_offset(bytes_len)?;
1891 let mut _next_ordinal_to_read = 0;
1893 let mut next_offset = offset;
1894 let end_offset = offset + bytes_len;
1895 _next_ordinal_to_read += 1;
1896 if next_offset >= end_offset {
1897 return Ok(());
1898 }
1899
1900 while _next_ordinal_to_read < 1 {
1902 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1903 _next_ordinal_to_read += 1;
1904 next_offset += envelope_size;
1905 }
1906
1907 let next_out_of_line = decoder.next_out_of_line();
1908 let handles_before = decoder.remaining_handles();
1909 if let Some((inlined, num_bytes, num_handles)) =
1910 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1911 {
1912 let member_inline_size =
1913 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1914 if inlined != (member_inline_size <= 4) {
1915 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1916 }
1917 let inner_offset;
1918 let mut inner_depth = depth.clone();
1919 if inlined {
1920 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1921 inner_offset = next_offset;
1922 } else {
1923 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1924 inner_depth.increment()?;
1925 }
1926 let val_ref = self.total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
1927 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1928 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1929 {
1930 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1931 }
1932 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1933 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1934 }
1935 }
1936
1937 next_offset += envelope_size;
1938 _next_ordinal_to_read += 1;
1939 if next_offset >= end_offset {
1940 return Ok(());
1941 }
1942
1943 while _next_ordinal_to_read < 2 {
1945 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1946 _next_ordinal_to_read += 1;
1947 next_offset += envelope_size;
1948 }
1949
1950 let next_out_of_line = decoder.next_out_of_line();
1951 let handles_before = decoder.remaining_handles();
1952 if let Some((inlined, num_bytes, num_handles)) =
1953 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1954 {
1955 let member_inline_size =
1956 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1957 if inlined != (member_inline_size <= 4) {
1958 return Err(fidl::Error::InvalidInlineBitInEnvelope);
1959 }
1960 let inner_offset;
1961 let mut inner_depth = depth.clone();
1962 if inlined {
1963 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1964 inner_offset = next_offset;
1965 } else {
1966 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1967 inner_depth.increment()?;
1968 }
1969 let val_ref = self.free_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
1970 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
1971 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1972 {
1973 return Err(fidl::Error::InvalidNumBytesInEnvelope);
1974 }
1975 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1976 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1977 }
1978 }
1979
1980 next_offset += envelope_size;
1981 _next_ordinal_to_read += 1;
1982 if next_offset >= end_offset {
1983 return Ok(());
1984 }
1985
1986 while _next_ordinal_to_read < 3 {
1988 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1989 _next_ordinal_to_read += 1;
1990 next_offset += envelope_size;
1991 }
1992
1993 let next_out_of_line = decoder.next_out_of_line();
1994 let handles_before = decoder.remaining_handles();
1995 if let Some((inlined, num_bytes, num_handles)) =
1996 fidl::encoding::decode_envelope_header(decoder, next_offset)?
1997 {
1998 let member_inline_size =
1999 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2000 if inlined != (member_inline_size <= 4) {
2001 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2002 }
2003 let inner_offset;
2004 let mut inner_depth = depth.clone();
2005 if inlined {
2006 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2007 inner_offset = next_offset;
2008 } else {
2009 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2010 inner_depth.increment()?;
2011 }
2012 let val_ref = self.wired_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2013 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2014 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2015 {
2016 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2017 }
2018 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2019 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2020 }
2021 }
2022
2023 next_offset += envelope_size;
2024 _next_ordinal_to_read += 1;
2025 if next_offset >= end_offset {
2026 return Ok(());
2027 }
2028
2029 while _next_ordinal_to_read < 4 {
2031 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2032 _next_ordinal_to_read += 1;
2033 next_offset += envelope_size;
2034 }
2035
2036 let next_out_of_line = decoder.next_out_of_line();
2037 let handles_before = decoder.remaining_handles();
2038 if let Some((inlined, num_bytes, num_handles)) =
2039 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2040 {
2041 let member_inline_size =
2042 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2043 if inlined != (member_inline_size <= 4) {
2044 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2045 }
2046 let inner_offset;
2047 let mut inner_depth = depth.clone();
2048 if inlined {
2049 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2050 inner_offset = next_offset;
2051 } else {
2052 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2053 inner_depth.increment()?;
2054 }
2055 let val_ref = self.total_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2056 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2057 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2058 {
2059 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2060 }
2061 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2062 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2063 }
2064 }
2065
2066 next_offset += envelope_size;
2067 _next_ordinal_to_read += 1;
2068 if next_offset >= end_offset {
2069 return Ok(());
2070 }
2071
2072 while _next_ordinal_to_read < 5 {
2074 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2075 _next_ordinal_to_read += 1;
2076 next_offset += envelope_size;
2077 }
2078
2079 let next_out_of_line = decoder.next_out_of_line();
2080 let handles_before = decoder.remaining_handles();
2081 if let Some((inlined, num_bytes, num_handles)) =
2082 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2083 {
2084 let member_inline_size =
2085 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2086 if inlined != (member_inline_size <= 4) {
2087 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2088 }
2089 let inner_offset;
2090 let mut inner_depth = depth.clone();
2091 if inlined {
2092 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2093 inner_offset = next_offset;
2094 } else {
2095 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2096 inner_depth.increment()?;
2097 }
2098 let val_ref = self.free_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2099 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2100 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2101 {
2102 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2103 }
2104 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2105 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2106 }
2107 }
2108
2109 next_offset += envelope_size;
2110 _next_ordinal_to_read += 1;
2111 if next_offset >= end_offset {
2112 return Ok(());
2113 }
2114
2115 while _next_ordinal_to_read < 6 {
2117 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2118 _next_ordinal_to_read += 1;
2119 next_offset += envelope_size;
2120 }
2121
2122 let next_out_of_line = decoder.next_out_of_line();
2123 let handles_before = decoder.remaining_handles();
2124 if let Some((inlined, num_bytes, num_handles)) =
2125 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2126 {
2127 let member_inline_size =
2128 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2129 if inlined != (member_inline_size <= 4) {
2130 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2131 }
2132 let inner_offset;
2133 let mut inner_depth = depth.clone();
2134 if inlined {
2135 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2136 inner_offset = next_offset;
2137 } else {
2138 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2139 inner_depth.increment()?;
2140 }
2141 let val_ref = self.vmo_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2142 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2143 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2144 {
2145 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2146 }
2147 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2148 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2149 }
2150 }
2151
2152 next_offset += envelope_size;
2153 _next_ordinal_to_read += 1;
2154 if next_offset >= end_offset {
2155 return Ok(());
2156 }
2157
2158 while _next_ordinal_to_read < 7 {
2160 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2161 _next_ordinal_to_read += 1;
2162 next_offset += envelope_size;
2163 }
2164
2165 let next_out_of_line = decoder.next_out_of_line();
2166 let handles_before = decoder.remaining_handles();
2167 if let Some((inlined, num_bytes, num_handles)) =
2168 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2169 {
2170 let member_inline_size =
2171 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2172 if inlined != (member_inline_size <= 4) {
2173 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2174 }
2175 let inner_offset;
2176 let mut inner_depth = depth.clone();
2177 if inlined {
2178 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2179 inner_offset = next_offset;
2180 } else {
2181 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2182 inner_depth.increment()?;
2183 }
2184 let val_ref =
2185 self.mmu_overhead_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2186 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2187 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2188 {
2189 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2190 }
2191 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2192 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2193 }
2194 }
2195
2196 next_offset += envelope_size;
2197 _next_ordinal_to_read += 1;
2198 if next_offset >= end_offset {
2199 return Ok(());
2200 }
2201
2202 while _next_ordinal_to_read < 8 {
2204 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2205 _next_ordinal_to_read += 1;
2206 next_offset += envelope_size;
2207 }
2208
2209 let next_out_of_line = decoder.next_out_of_line();
2210 let handles_before = decoder.remaining_handles();
2211 if let Some((inlined, num_bytes, num_handles)) =
2212 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2213 {
2214 let member_inline_size =
2215 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2216 if inlined != (member_inline_size <= 4) {
2217 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2218 }
2219 let inner_offset;
2220 let mut inner_depth = depth.clone();
2221 if inlined {
2222 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2223 inner_offset = next_offset;
2224 } else {
2225 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2226 inner_depth.increment()?;
2227 }
2228 let val_ref = self.ipc_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2229 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2230 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2231 {
2232 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2233 }
2234 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2235 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2236 }
2237 }
2238
2239 next_offset += envelope_size;
2240 _next_ordinal_to_read += 1;
2241 if next_offset >= end_offset {
2242 return Ok(());
2243 }
2244
2245 while _next_ordinal_to_read < 9 {
2247 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2248 _next_ordinal_to_read += 1;
2249 next_offset += envelope_size;
2250 }
2251
2252 let next_out_of_line = decoder.next_out_of_line();
2253 let handles_before = decoder.remaining_handles();
2254 if let Some((inlined, num_bytes, num_handles)) =
2255 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2256 {
2257 let member_inline_size =
2258 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2259 if inlined != (member_inline_size <= 4) {
2260 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2261 }
2262 let inner_offset;
2263 let mut inner_depth = depth.clone();
2264 if inlined {
2265 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2266 inner_offset = next_offset;
2267 } else {
2268 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2269 inner_depth.increment()?;
2270 }
2271 let val_ref = self.other_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2272 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2273 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2274 {
2275 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2276 }
2277 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2278 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2279 }
2280 }
2281
2282 next_offset += envelope_size;
2283 _next_ordinal_to_read += 1;
2284 if next_offset >= end_offset {
2285 return Ok(());
2286 }
2287
2288 while _next_ordinal_to_read < 10 {
2290 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2291 _next_ordinal_to_read += 1;
2292 next_offset += envelope_size;
2293 }
2294
2295 let next_out_of_line = decoder.next_out_of_line();
2296 let handles_before = decoder.remaining_handles();
2297 if let Some((inlined, num_bytes, num_handles)) =
2298 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2299 {
2300 let member_inline_size =
2301 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2302 if inlined != (member_inline_size <= 4) {
2303 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2304 }
2305 let inner_offset;
2306 let mut inner_depth = depth.clone();
2307 if inlined {
2308 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2309 inner_offset = next_offset;
2310 } else {
2311 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2312 inner_depth.increment()?;
2313 }
2314 let val_ref =
2315 self.free_loaned_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2316 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2317 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2318 {
2319 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2320 }
2321 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2322 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2323 }
2324 }
2325
2326 next_offset += envelope_size;
2327 _next_ordinal_to_read += 1;
2328 if next_offset >= end_offset {
2329 return Ok(());
2330 }
2331
2332 while _next_ordinal_to_read < 11 {
2334 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2335 _next_ordinal_to_read += 1;
2336 next_offset += envelope_size;
2337 }
2338
2339 let next_out_of_line = decoder.next_out_of_line();
2340 let handles_before = decoder.remaining_handles();
2341 if let Some((inlined, num_bytes, num_handles)) =
2342 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2343 {
2344 let member_inline_size =
2345 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2346 if inlined != (member_inline_size <= 4) {
2347 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2348 }
2349 let inner_offset;
2350 let mut inner_depth = depth.clone();
2351 if inlined {
2352 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2353 inner_offset = next_offset;
2354 } else {
2355 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2356 inner_depth.increment()?;
2357 }
2358 let val_ref = self.cache_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2359 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2360 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2361 {
2362 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2363 }
2364 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2365 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2366 }
2367 }
2368
2369 next_offset += envelope_size;
2370 _next_ordinal_to_read += 1;
2371 if next_offset >= end_offset {
2372 return Ok(());
2373 }
2374
2375 while _next_ordinal_to_read < 12 {
2377 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2378 _next_ordinal_to_read += 1;
2379 next_offset += envelope_size;
2380 }
2381
2382 let next_out_of_line = decoder.next_out_of_line();
2383 let handles_before = decoder.remaining_handles();
2384 if let Some((inlined, num_bytes, num_handles)) =
2385 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2386 {
2387 let member_inline_size =
2388 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2389 if inlined != (member_inline_size <= 4) {
2390 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2391 }
2392 let inner_offset;
2393 let mut inner_depth = depth.clone();
2394 if inlined {
2395 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2396 inner_offset = next_offset;
2397 } else {
2398 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2399 inner_depth.increment()?;
2400 }
2401 let val_ref = self.slab_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2402 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2403 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2404 {
2405 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2406 }
2407 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2408 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2409 }
2410 }
2411
2412 next_offset += envelope_size;
2413 _next_ordinal_to_read += 1;
2414 if next_offset >= end_offset {
2415 return Ok(());
2416 }
2417
2418 while _next_ordinal_to_read < 13 {
2420 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2421 _next_ordinal_to_read += 1;
2422 next_offset += envelope_size;
2423 }
2424
2425 let next_out_of_line = decoder.next_out_of_line();
2426 let handles_before = decoder.remaining_handles();
2427 if let Some((inlined, num_bytes, num_handles)) =
2428 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2429 {
2430 let member_inline_size =
2431 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2432 if inlined != (member_inline_size <= 4) {
2433 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2434 }
2435 let inner_offset;
2436 let mut inner_depth = depth.clone();
2437 if inlined {
2438 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2439 inner_offset = next_offset;
2440 } else {
2441 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2442 inner_depth.increment()?;
2443 }
2444 let val_ref = self.zram_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2445 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2446 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2447 {
2448 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2449 }
2450 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2451 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2452 }
2453 }
2454
2455 next_offset += envelope_size;
2456 _next_ordinal_to_read += 1;
2457 if next_offset >= end_offset {
2458 return Ok(());
2459 }
2460
2461 while _next_ordinal_to_read < 14 {
2463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2464 _next_ordinal_to_read += 1;
2465 next_offset += envelope_size;
2466 }
2467
2468 let next_out_of_line = decoder.next_out_of_line();
2469 let handles_before = decoder.remaining_handles();
2470 if let Some((inlined, num_bytes, num_handles)) =
2471 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2472 {
2473 let member_inline_size =
2474 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2475 if inlined != (member_inline_size <= 4) {
2476 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2477 }
2478 let inner_offset;
2479 let mut inner_depth = depth.clone();
2480 if inlined {
2481 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2482 inner_offset = next_offset;
2483 } else {
2484 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2485 inner_depth.increment()?;
2486 }
2487 let val_ref =
2488 self.vmo_reclaim_total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2489 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2490 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2491 {
2492 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2493 }
2494 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2495 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2496 }
2497 }
2498
2499 next_offset += envelope_size;
2500 _next_ordinal_to_read += 1;
2501 if next_offset >= end_offset {
2502 return Ok(());
2503 }
2504
2505 while _next_ordinal_to_read < 15 {
2507 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2508 _next_ordinal_to_read += 1;
2509 next_offset += envelope_size;
2510 }
2511
2512 let next_out_of_line = decoder.next_out_of_line();
2513 let handles_before = decoder.remaining_handles();
2514 if let Some((inlined, num_bytes, num_handles)) =
2515 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2516 {
2517 let member_inline_size =
2518 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2519 if inlined != (member_inline_size <= 4) {
2520 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2521 }
2522 let inner_offset;
2523 let mut inner_depth = depth.clone();
2524 if inlined {
2525 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2526 inner_offset = next_offset;
2527 } else {
2528 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2529 inner_depth.increment()?;
2530 }
2531 let val_ref =
2532 self.vmo_reclaim_newest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2533 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2534 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2535 {
2536 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2537 }
2538 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2539 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2540 }
2541 }
2542
2543 next_offset += envelope_size;
2544 _next_ordinal_to_read += 1;
2545 if next_offset >= end_offset {
2546 return Ok(());
2547 }
2548
2549 while _next_ordinal_to_read < 16 {
2551 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2552 _next_ordinal_to_read += 1;
2553 next_offset += envelope_size;
2554 }
2555
2556 let next_out_of_line = decoder.next_out_of_line();
2557 let handles_before = decoder.remaining_handles();
2558 if let Some((inlined, num_bytes, num_handles)) =
2559 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2560 {
2561 let member_inline_size =
2562 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2563 if inlined != (member_inline_size <= 4) {
2564 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2565 }
2566 let inner_offset;
2567 let mut inner_depth = depth.clone();
2568 if inlined {
2569 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2570 inner_offset = next_offset;
2571 } else {
2572 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2573 inner_depth.increment()?;
2574 }
2575 let val_ref =
2576 self.vmo_reclaim_oldest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2577 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2578 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2579 {
2580 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2581 }
2582 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2583 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2584 }
2585 }
2586
2587 next_offset += envelope_size;
2588 _next_ordinal_to_read += 1;
2589 if next_offset >= end_offset {
2590 return Ok(());
2591 }
2592
2593 while _next_ordinal_to_read < 17 {
2595 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2596 _next_ordinal_to_read += 1;
2597 next_offset += envelope_size;
2598 }
2599
2600 let next_out_of_line = decoder.next_out_of_line();
2601 let handles_before = decoder.remaining_handles();
2602 if let Some((inlined, num_bytes, num_handles)) =
2603 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2604 {
2605 let member_inline_size =
2606 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2607 if inlined != (member_inline_size <= 4) {
2608 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2609 }
2610 let inner_offset;
2611 let mut inner_depth = depth.clone();
2612 if inlined {
2613 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2614 inner_offset = next_offset;
2615 } else {
2616 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2617 inner_depth.increment()?;
2618 }
2619 let val_ref =
2620 self.vmo_reclaim_disabled_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
2621 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2622 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2623 {
2624 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2625 }
2626 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2627 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2628 }
2629 }
2630
2631 next_offset += envelope_size;
2632 _next_ordinal_to_read += 1;
2633 if next_offset >= end_offset {
2634 return Ok(());
2635 }
2636
2637 while _next_ordinal_to_read < 18 {
2639 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2640 _next_ordinal_to_read += 1;
2641 next_offset += envelope_size;
2642 }
2643
2644 let next_out_of_line = decoder.next_out_of_line();
2645 let handles_before = decoder.remaining_handles();
2646 if let Some((inlined, num_bytes, num_handles)) =
2647 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2648 {
2649 let member_inline_size =
2650 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2651 if inlined != (member_inline_size <= 4) {
2652 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2653 }
2654 let inner_offset;
2655 let mut inner_depth = depth.clone();
2656 if inlined {
2657 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2658 inner_offset = next_offset;
2659 } else {
2660 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2661 inner_depth.increment()?;
2662 }
2663 let val_ref = self
2664 .vmo_discardable_locked_bytes
2665 .get_or_insert_with(|| fidl::new_empty!(u64, D));
2666 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2667 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2668 {
2669 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2670 }
2671 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2672 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2673 }
2674 }
2675
2676 next_offset += envelope_size;
2677 _next_ordinal_to_read += 1;
2678 if next_offset >= end_offset {
2679 return Ok(());
2680 }
2681
2682 while _next_ordinal_to_read < 19 {
2684 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2685 _next_ordinal_to_read += 1;
2686 next_offset += envelope_size;
2687 }
2688
2689 let next_out_of_line = decoder.next_out_of_line();
2690 let handles_before = decoder.remaining_handles();
2691 if let Some((inlined, num_bytes, num_handles)) =
2692 fidl::encoding::decode_envelope_header(decoder, next_offset)?
2693 {
2694 let member_inline_size =
2695 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2696 if inlined != (member_inline_size <= 4) {
2697 return Err(fidl::Error::InvalidInlineBitInEnvelope);
2698 }
2699 let inner_offset;
2700 let mut inner_depth = depth.clone();
2701 if inlined {
2702 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2703 inner_offset = next_offset;
2704 } else {
2705 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2706 inner_depth.increment()?;
2707 }
2708 let val_ref = self
2709 .vmo_discardable_unlocked_bytes
2710 .get_or_insert_with(|| fidl::new_empty!(u64, D));
2711 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2712 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2713 {
2714 return Err(fidl::Error::InvalidNumBytesInEnvelope);
2715 }
2716 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2717 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2718 }
2719 }
2720
2721 next_offset += envelope_size;
2722
2723 while next_offset < end_offset {
2725 _next_ordinal_to_read += 1;
2726 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2727 next_offset += envelope_size;
2728 }
2729
2730 Ok(())
2731 }
2732 }
2733
2734 impl MemoryStatsCompression {
2735 #[inline(always)]
2736 fn max_ordinal_present(&self) -> u64 {
2737 if let Some(_) = self.pages_decompressed_within_log_time {
2738 return 14;
2739 }
2740 if let Some(_) = self.pages_decompressed_unit_ns {
2741 return 13;
2742 }
2743 if let Some(_) = self.critical_memory_page_compressions {
2744 return 12;
2745 }
2746 if let Some(_) = self.memory_pressure_page_compressions {
2747 return 11;
2748 }
2749 if let Some(_) = self.eager_page_compressions {
2750 return 10;
2751 }
2752 if let Some(_) = self.compressed_page_evictions {
2753 return 9;
2754 }
2755 if let Some(_) = self.total_page_decompressions {
2756 return 8;
2757 }
2758 if let Some(_) = self.failed_page_compression_attempts {
2759 return 7;
2760 }
2761 if let Some(_) = self.total_page_compression_attempts {
2762 return 6;
2763 }
2764 if let Some(_) = self.decompression_time {
2765 return 5;
2766 }
2767 if let Some(_) = self.compression_time {
2768 return 4;
2769 }
2770 if let Some(_) = self.compressed_fragmentation_bytes {
2771 return 3;
2772 }
2773 if let Some(_) = self.compressed_storage_bytes {
2774 return 2;
2775 }
2776 if let Some(_) = self.uncompressed_storage_bytes {
2777 return 1;
2778 }
2779 0
2780 }
2781 }
2782
2783 impl fidl::encoding::ValueTypeMarker for MemoryStatsCompression {
2784 type Borrowed<'a> = &'a Self;
2785 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2786 value
2787 }
2788 }
2789
2790 unsafe impl fidl::encoding::TypeMarker for MemoryStatsCompression {
2791 type Owned = Self;
2792
2793 #[inline(always)]
2794 fn inline_align(_context: fidl::encoding::Context) -> usize {
2795 8
2796 }
2797
2798 #[inline(always)]
2799 fn inline_size(_context: fidl::encoding::Context) -> usize {
2800 16
2801 }
2802 }
2803
2804 unsafe impl<D: fidl::encoding::ResourceDialect>
2805 fidl::encoding::Encode<MemoryStatsCompression, D> for &MemoryStatsCompression
2806 {
2807 unsafe fn encode(
2808 self,
2809 encoder: &mut fidl::encoding::Encoder<'_, D>,
2810 offset: usize,
2811 mut depth: fidl::encoding::Depth,
2812 ) -> fidl::Result<()> {
2813 encoder.debug_check_bounds::<MemoryStatsCompression>(offset);
2814 let max_ordinal: u64 = self.max_ordinal_present();
2816 encoder.write_num(max_ordinal, offset);
2817 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2818 if max_ordinal == 0 {
2820 return Ok(());
2821 }
2822 depth.increment()?;
2823 let envelope_size = 8;
2824 let bytes_len = max_ordinal as usize * envelope_size;
2825 #[allow(unused_variables)]
2826 let offset = encoder.out_of_line_offset(bytes_len);
2827 let mut _prev_end_offset: usize = 0;
2828 if 1 > max_ordinal {
2829 return Ok(());
2830 }
2831
2832 let cur_offset: usize = (1 - 1) * envelope_size;
2835
2836 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2838
2839 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2844 self.uncompressed_storage_bytes
2845 .as_ref()
2846 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2847 encoder,
2848 offset + cur_offset,
2849 depth,
2850 )?;
2851
2852 _prev_end_offset = cur_offset + envelope_size;
2853 if 2 > max_ordinal {
2854 return Ok(());
2855 }
2856
2857 let cur_offset: usize = (2 - 1) * envelope_size;
2860
2861 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2863
2864 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2869 self.compressed_storage_bytes
2870 .as_ref()
2871 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2872 encoder,
2873 offset + cur_offset,
2874 depth,
2875 )?;
2876
2877 _prev_end_offset = cur_offset + envelope_size;
2878 if 3 > max_ordinal {
2879 return Ok(());
2880 }
2881
2882 let cur_offset: usize = (3 - 1) * envelope_size;
2885
2886 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2888
2889 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2894 self.compressed_fragmentation_bytes
2895 .as_ref()
2896 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2897 encoder,
2898 offset + cur_offset,
2899 depth,
2900 )?;
2901
2902 _prev_end_offset = cur_offset + envelope_size;
2903 if 4 > max_ordinal {
2904 return Ok(());
2905 }
2906
2907 let cur_offset: usize = (4 - 1) * envelope_size;
2910
2911 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2913
2914 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2919 self.compression_time
2920 .as_ref()
2921 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2922 encoder,
2923 offset + cur_offset,
2924 depth,
2925 )?;
2926
2927 _prev_end_offset = cur_offset + envelope_size;
2928 if 5 > max_ordinal {
2929 return Ok(());
2930 }
2931
2932 let cur_offset: usize = (5 - 1) * envelope_size;
2935
2936 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2938
2939 fidl::encoding::encode_in_envelope_optional::<i64, D>(
2944 self.decompression_time
2945 .as_ref()
2946 .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
2947 encoder,
2948 offset + cur_offset,
2949 depth,
2950 )?;
2951
2952 _prev_end_offset = cur_offset + envelope_size;
2953 if 6 > max_ordinal {
2954 return Ok(());
2955 }
2956
2957 let cur_offset: usize = (6 - 1) * envelope_size;
2960
2961 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2963
2964 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2969 self.total_page_compression_attempts
2970 .as_ref()
2971 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2972 encoder,
2973 offset + cur_offset,
2974 depth,
2975 )?;
2976
2977 _prev_end_offset = cur_offset + envelope_size;
2978 if 7 > max_ordinal {
2979 return Ok(());
2980 }
2981
2982 let cur_offset: usize = (7 - 1) * envelope_size;
2985
2986 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2988
2989 fidl::encoding::encode_in_envelope_optional::<u64, D>(
2994 self.failed_page_compression_attempts
2995 .as_ref()
2996 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2997 encoder,
2998 offset + cur_offset,
2999 depth,
3000 )?;
3001
3002 _prev_end_offset = cur_offset + envelope_size;
3003 if 8 > max_ordinal {
3004 return Ok(());
3005 }
3006
3007 let cur_offset: usize = (8 - 1) * envelope_size;
3010
3011 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3013
3014 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3019 self.total_page_decompressions
3020 .as_ref()
3021 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3022 encoder,
3023 offset + cur_offset,
3024 depth,
3025 )?;
3026
3027 _prev_end_offset = cur_offset + envelope_size;
3028 if 9 > max_ordinal {
3029 return Ok(());
3030 }
3031
3032 let cur_offset: usize = (9 - 1) * envelope_size;
3035
3036 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3038
3039 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3044 self.compressed_page_evictions
3045 .as_ref()
3046 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3047 encoder,
3048 offset + cur_offset,
3049 depth,
3050 )?;
3051
3052 _prev_end_offset = cur_offset + envelope_size;
3053 if 10 > max_ordinal {
3054 return Ok(());
3055 }
3056
3057 let cur_offset: usize = (10 - 1) * envelope_size;
3060
3061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3063
3064 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3069 self.eager_page_compressions
3070 .as_ref()
3071 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3072 encoder,
3073 offset + cur_offset,
3074 depth,
3075 )?;
3076
3077 _prev_end_offset = cur_offset + envelope_size;
3078 if 11 > max_ordinal {
3079 return Ok(());
3080 }
3081
3082 let cur_offset: usize = (11 - 1) * envelope_size;
3085
3086 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3088
3089 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3094 self.memory_pressure_page_compressions
3095 .as_ref()
3096 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3097 encoder,
3098 offset + cur_offset,
3099 depth,
3100 )?;
3101
3102 _prev_end_offset = cur_offset + envelope_size;
3103 if 12 > max_ordinal {
3104 return Ok(());
3105 }
3106
3107 let cur_offset: usize = (12 - 1) * envelope_size;
3110
3111 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3113
3114 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3119 self.critical_memory_page_compressions
3120 .as_ref()
3121 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3122 encoder,
3123 offset + cur_offset,
3124 depth,
3125 )?;
3126
3127 _prev_end_offset = cur_offset + envelope_size;
3128 if 13 > max_ordinal {
3129 return Ok(());
3130 }
3131
3132 let cur_offset: usize = (13 - 1) * envelope_size;
3135
3136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3138
3139 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3144 self.pages_decompressed_unit_ns
3145 .as_ref()
3146 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3147 encoder,
3148 offset + cur_offset,
3149 depth,
3150 )?;
3151
3152 _prev_end_offset = cur_offset + envelope_size;
3153 if 14 > max_ordinal {
3154 return Ok(());
3155 }
3156
3157 let cur_offset: usize = (14 - 1) * envelope_size;
3160
3161 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3163
3164 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u64, 8>, D>(
3169 self.pages_decompressed_within_log_time.as_ref().map(
3170 <fidl::encoding::Array<u64, 8> as fidl::encoding::ValueTypeMarker>::borrow,
3171 ),
3172 encoder,
3173 offset + cur_offset,
3174 depth,
3175 )?;
3176
3177 _prev_end_offset = cur_offset + envelope_size;
3178
3179 Ok(())
3180 }
3181 }
3182
3183 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3184 for MemoryStatsCompression
3185 {
3186 #[inline(always)]
3187 fn new_empty() -> Self {
3188 Self::default()
3189 }
3190
3191 unsafe fn decode(
3192 &mut self,
3193 decoder: &mut fidl::encoding::Decoder<'_, D>,
3194 offset: usize,
3195 mut depth: fidl::encoding::Depth,
3196 ) -> fidl::Result<()> {
3197 decoder.debug_check_bounds::<Self>(offset);
3198 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3199 None => return Err(fidl::Error::NotNullable),
3200 Some(len) => len,
3201 };
3202 if len == 0 {
3204 return Ok(());
3205 };
3206 depth.increment()?;
3207 let envelope_size = 8;
3208 let bytes_len = len * envelope_size;
3209 let offset = decoder.out_of_line_offset(bytes_len)?;
3210 let mut _next_ordinal_to_read = 0;
3212 let mut next_offset = offset;
3213 let end_offset = offset + bytes_len;
3214 _next_ordinal_to_read += 1;
3215 if next_offset >= end_offset {
3216 return Ok(());
3217 }
3218
3219 while _next_ordinal_to_read < 1 {
3221 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3222 _next_ordinal_to_read += 1;
3223 next_offset += envelope_size;
3224 }
3225
3226 let next_out_of_line = decoder.next_out_of_line();
3227 let handles_before = decoder.remaining_handles();
3228 if let Some((inlined, num_bytes, num_handles)) =
3229 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3230 {
3231 let member_inline_size =
3232 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3233 if inlined != (member_inline_size <= 4) {
3234 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3235 }
3236 let inner_offset;
3237 let mut inner_depth = depth.clone();
3238 if inlined {
3239 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3240 inner_offset = next_offset;
3241 } else {
3242 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3243 inner_depth.increment()?;
3244 }
3245 let val_ref =
3246 self.uncompressed_storage_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3247 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3248 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3249 {
3250 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3251 }
3252 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3253 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3254 }
3255 }
3256
3257 next_offset += envelope_size;
3258 _next_ordinal_to_read += 1;
3259 if next_offset >= end_offset {
3260 return Ok(());
3261 }
3262
3263 while _next_ordinal_to_read < 2 {
3265 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3266 _next_ordinal_to_read += 1;
3267 next_offset += envelope_size;
3268 }
3269
3270 let next_out_of_line = decoder.next_out_of_line();
3271 let handles_before = decoder.remaining_handles();
3272 if let Some((inlined, num_bytes, num_handles)) =
3273 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3274 {
3275 let member_inline_size =
3276 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3277 if inlined != (member_inline_size <= 4) {
3278 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3279 }
3280 let inner_offset;
3281 let mut inner_depth = depth.clone();
3282 if inlined {
3283 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3284 inner_offset = next_offset;
3285 } else {
3286 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3287 inner_depth.increment()?;
3288 }
3289 let val_ref =
3290 self.compressed_storage_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3291 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3292 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3293 {
3294 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3295 }
3296 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3297 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3298 }
3299 }
3300
3301 next_offset += envelope_size;
3302 _next_ordinal_to_read += 1;
3303 if next_offset >= end_offset {
3304 return Ok(());
3305 }
3306
3307 while _next_ordinal_to_read < 3 {
3309 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3310 _next_ordinal_to_read += 1;
3311 next_offset += envelope_size;
3312 }
3313
3314 let next_out_of_line = decoder.next_out_of_line();
3315 let handles_before = decoder.remaining_handles();
3316 if let Some((inlined, num_bytes, num_handles)) =
3317 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3318 {
3319 let member_inline_size =
3320 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3321 if inlined != (member_inline_size <= 4) {
3322 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3323 }
3324 let inner_offset;
3325 let mut inner_depth = depth.clone();
3326 if inlined {
3327 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3328 inner_offset = next_offset;
3329 } else {
3330 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3331 inner_depth.increment()?;
3332 }
3333 let val_ref = self
3334 .compressed_fragmentation_bytes
3335 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3336 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3337 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3338 {
3339 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3340 }
3341 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3342 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3343 }
3344 }
3345
3346 next_offset += envelope_size;
3347 _next_ordinal_to_read += 1;
3348 if next_offset >= end_offset {
3349 return Ok(());
3350 }
3351
3352 while _next_ordinal_to_read < 4 {
3354 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3355 _next_ordinal_to_read += 1;
3356 next_offset += envelope_size;
3357 }
3358
3359 let next_out_of_line = decoder.next_out_of_line();
3360 let handles_before = decoder.remaining_handles();
3361 if let Some((inlined, num_bytes, num_handles)) =
3362 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3363 {
3364 let member_inline_size =
3365 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3366 if inlined != (member_inline_size <= 4) {
3367 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3368 }
3369 let inner_offset;
3370 let mut inner_depth = depth.clone();
3371 if inlined {
3372 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3373 inner_offset = next_offset;
3374 } else {
3375 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3376 inner_depth.increment()?;
3377 }
3378 let val_ref = self.compression_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
3379 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3380 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3381 {
3382 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3383 }
3384 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3385 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3386 }
3387 }
3388
3389 next_offset += envelope_size;
3390 _next_ordinal_to_read += 1;
3391 if next_offset >= end_offset {
3392 return Ok(());
3393 }
3394
3395 while _next_ordinal_to_read < 5 {
3397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3398 _next_ordinal_to_read += 1;
3399 next_offset += envelope_size;
3400 }
3401
3402 let next_out_of_line = decoder.next_out_of_line();
3403 let handles_before = decoder.remaining_handles();
3404 if let Some((inlined, num_bytes, num_handles)) =
3405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3406 {
3407 let member_inline_size =
3408 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3409 if inlined != (member_inline_size <= 4) {
3410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3411 }
3412 let inner_offset;
3413 let mut inner_depth = depth.clone();
3414 if inlined {
3415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3416 inner_offset = next_offset;
3417 } else {
3418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3419 inner_depth.increment()?;
3420 }
3421 let val_ref =
3422 self.decompression_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
3423 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3424 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3425 {
3426 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3427 }
3428 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3429 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3430 }
3431 }
3432
3433 next_offset += envelope_size;
3434 _next_ordinal_to_read += 1;
3435 if next_offset >= end_offset {
3436 return Ok(());
3437 }
3438
3439 while _next_ordinal_to_read < 6 {
3441 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3442 _next_ordinal_to_read += 1;
3443 next_offset += envelope_size;
3444 }
3445
3446 let next_out_of_line = decoder.next_out_of_line();
3447 let handles_before = decoder.remaining_handles();
3448 if let Some((inlined, num_bytes, num_handles)) =
3449 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3450 {
3451 let member_inline_size =
3452 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3453 if inlined != (member_inline_size <= 4) {
3454 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3455 }
3456 let inner_offset;
3457 let mut inner_depth = depth.clone();
3458 if inlined {
3459 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3460 inner_offset = next_offset;
3461 } else {
3462 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3463 inner_depth.increment()?;
3464 }
3465 let val_ref = self
3466 .total_page_compression_attempts
3467 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3468 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3469 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3470 {
3471 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3472 }
3473 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3474 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3475 }
3476 }
3477
3478 next_offset += envelope_size;
3479 _next_ordinal_to_read += 1;
3480 if next_offset >= end_offset {
3481 return Ok(());
3482 }
3483
3484 while _next_ordinal_to_read < 7 {
3486 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3487 _next_ordinal_to_read += 1;
3488 next_offset += envelope_size;
3489 }
3490
3491 let next_out_of_line = decoder.next_out_of_line();
3492 let handles_before = decoder.remaining_handles();
3493 if let Some((inlined, num_bytes, num_handles)) =
3494 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3495 {
3496 let member_inline_size =
3497 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3498 if inlined != (member_inline_size <= 4) {
3499 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3500 }
3501 let inner_offset;
3502 let mut inner_depth = depth.clone();
3503 if inlined {
3504 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3505 inner_offset = next_offset;
3506 } else {
3507 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3508 inner_depth.increment()?;
3509 }
3510 let val_ref = self
3511 .failed_page_compression_attempts
3512 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3513 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3514 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3515 {
3516 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3517 }
3518 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3519 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3520 }
3521 }
3522
3523 next_offset += envelope_size;
3524 _next_ordinal_to_read += 1;
3525 if next_offset >= end_offset {
3526 return Ok(());
3527 }
3528
3529 while _next_ordinal_to_read < 8 {
3531 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3532 _next_ordinal_to_read += 1;
3533 next_offset += envelope_size;
3534 }
3535
3536 let next_out_of_line = decoder.next_out_of_line();
3537 let handles_before = decoder.remaining_handles();
3538 if let Some((inlined, num_bytes, num_handles)) =
3539 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3540 {
3541 let member_inline_size =
3542 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3543 if inlined != (member_inline_size <= 4) {
3544 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3545 }
3546 let inner_offset;
3547 let mut inner_depth = depth.clone();
3548 if inlined {
3549 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3550 inner_offset = next_offset;
3551 } else {
3552 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3553 inner_depth.increment()?;
3554 }
3555 let val_ref =
3556 self.total_page_decompressions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3557 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3558 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3559 {
3560 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3561 }
3562 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3563 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3564 }
3565 }
3566
3567 next_offset += envelope_size;
3568 _next_ordinal_to_read += 1;
3569 if next_offset >= end_offset {
3570 return Ok(());
3571 }
3572
3573 while _next_ordinal_to_read < 9 {
3575 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3576 _next_ordinal_to_read += 1;
3577 next_offset += envelope_size;
3578 }
3579
3580 let next_out_of_line = decoder.next_out_of_line();
3581 let handles_before = decoder.remaining_handles();
3582 if let Some((inlined, num_bytes, num_handles)) =
3583 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3584 {
3585 let member_inline_size =
3586 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3587 if inlined != (member_inline_size <= 4) {
3588 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3589 }
3590 let inner_offset;
3591 let mut inner_depth = depth.clone();
3592 if inlined {
3593 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3594 inner_offset = next_offset;
3595 } else {
3596 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3597 inner_depth.increment()?;
3598 }
3599 let val_ref =
3600 self.compressed_page_evictions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3601 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3602 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3603 {
3604 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3605 }
3606 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3607 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3608 }
3609 }
3610
3611 next_offset += envelope_size;
3612 _next_ordinal_to_read += 1;
3613 if next_offset >= end_offset {
3614 return Ok(());
3615 }
3616
3617 while _next_ordinal_to_read < 10 {
3619 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3620 _next_ordinal_to_read += 1;
3621 next_offset += envelope_size;
3622 }
3623
3624 let next_out_of_line = decoder.next_out_of_line();
3625 let handles_before = decoder.remaining_handles();
3626 if let Some((inlined, num_bytes, num_handles)) =
3627 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3628 {
3629 let member_inline_size =
3630 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3631 if inlined != (member_inline_size <= 4) {
3632 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3633 }
3634 let inner_offset;
3635 let mut inner_depth = depth.clone();
3636 if inlined {
3637 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3638 inner_offset = next_offset;
3639 } else {
3640 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3641 inner_depth.increment()?;
3642 }
3643 let val_ref =
3644 self.eager_page_compressions.get_or_insert_with(|| fidl::new_empty!(u64, D));
3645 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3646 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3647 {
3648 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3649 }
3650 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3651 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3652 }
3653 }
3654
3655 next_offset += envelope_size;
3656 _next_ordinal_to_read += 1;
3657 if next_offset >= end_offset {
3658 return Ok(());
3659 }
3660
3661 while _next_ordinal_to_read < 11 {
3663 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3664 _next_ordinal_to_read += 1;
3665 next_offset += envelope_size;
3666 }
3667
3668 let next_out_of_line = decoder.next_out_of_line();
3669 let handles_before = decoder.remaining_handles();
3670 if let Some((inlined, num_bytes, num_handles)) =
3671 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3672 {
3673 let member_inline_size =
3674 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3675 if inlined != (member_inline_size <= 4) {
3676 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3677 }
3678 let inner_offset;
3679 let mut inner_depth = depth.clone();
3680 if inlined {
3681 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3682 inner_offset = next_offset;
3683 } else {
3684 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3685 inner_depth.increment()?;
3686 }
3687 let val_ref = self
3688 .memory_pressure_page_compressions
3689 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3690 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3691 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3692 {
3693 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3694 }
3695 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3696 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3697 }
3698 }
3699
3700 next_offset += envelope_size;
3701 _next_ordinal_to_read += 1;
3702 if next_offset >= end_offset {
3703 return Ok(());
3704 }
3705
3706 while _next_ordinal_to_read < 12 {
3708 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3709 _next_ordinal_to_read += 1;
3710 next_offset += envelope_size;
3711 }
3712
3713 let next_out_of_line = decoder.next_out_of_line();
3714 let handles_before = decoder.remaining_handles();
3715 if let Some((inlined, num_bytes, num_handles)) =
3716 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3717 {
3718 let member_inline_size =
3719 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3720 if inlined != (member_inline_size <= 4) {
3721 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3722 }
3723 let inner_offset;
3724 let mut inner_depth = depth.clone();
3725 if inlined {
3726 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3727 inner_offset = next_offset;
3728 } else {
3729 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3730 inner_depth.increment()?;
3731 }
3732 let val_ref = self
3733 .critical_memory_page_compressions
3734 .get_or_insert_with(|| fidl::new_empty!(u64, D));
3735 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3736 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3737 {
3738 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3739 }
3740 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3741 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3742 }
3743 }
3744
3745 next_offset += envelope_size;
3746 _next_ordinal_to_read += 1;
3747 if next_offset >= end_offset {
3748 return Ok(());
3749 }
3750
3751 while _next_ordinal_to_read < 13 {
3753 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3754 _next_ordinal_to_read += 1;
3755 next_offset += envelope_size;
3756 }
3757
3758 let next_out_of_line = decoder.next_out_of_line();
3759 let handles_before = decoder.remaining_handles();
3760 if let Some((inlined, num_bytes, num_handles)) =
3761 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3762 {
3763 let member_inline_size =
3764 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3765 if inlined != (member_inline_size <= 4) {
3766 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3767 }
3768 let inner_offset;
3769 let mut inner_depth = depth.clone();
3770 if inlined {
3771 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3772 inner_offset = next_offset;
3773 } else {
3774 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3775 inner_depth.increment()?;
3776 }
3777 let val_ref =
3778 self.pages_decompressed_unit_ns.get_or_insert_with(|| fidl::new_empty!(u64, D));
3779 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3780 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3781 {
3782 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3783 }
3784 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3785 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3786 }
3787 }
3788
3789 next_offset += envelope_size;
3790 _next_ordinal_to_read += 1;
3791 if next_offset >= end_offset {
3792 return Ok(());
3793 }
3794
3795 while _next_ordinal_to_read < 14 {
3797 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3798 _next_ordinal_to_read += 1;
3799 next_offset += envelope_size;
3800 }
3801
3802 let next_out_of_line = decoder.next_out_of_line();
3803 let handles_before = decoder.remaining_handles();
3804 if let Some((inlined, num_bytes, num_handles)) =
3805 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3806 {
3807 let member_inline_size =
3808 <fidl::encoding::Array<u64, 8> as fidl::encoding::TypeMarker>::inline_size(
3809 decoder.context,
3810 );
3811 if inlined != (member_inline_size <= 4) {
3812 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3813 }
3814 let inner_offset;
3815 let mut inner_depth = depth.clone();
3816 if inlined {
3817 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3818 inner_offset = next_offset;
3819 } else {
3820 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3821 inner_depth.increment()?;
3822 }
3823 let val_ref = self
3824 .pages_decompressed_within_log_time
3825 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u64, 8>, D));
3826 fidl::decode!(fidl::encoding::Array<u64, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
3827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3828 {
3829 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3830 }
3831 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3832 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3833 }
3834 }
3835
3836 next_offset += envelope_size;
3837
3838 while next_offset < end_offset {
3840 _next_ordinal_to_read += 1;
3841 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3842 next_offset += envelope_size;
3843 }
3844
3845 Ok(())
3846 }
3847 }
3848
3849 impl MemoryStatsExtended {
3850 #[inline(always)]
3851 fn max_ordinal_present(&self) -> u64 {
3852 if let Some(_) = self.other_bytes {
3853 return 14;
3854 }
3855 if let Some(_) = self.ipc_bytes {
3856 return 13;
3857 }
3858 if let Some(_) = self.mmu_overhead_bytes {
3859 return 12;
3860 }
3861 if let Some(_) = self.vmo_discardable_unlocked_bytes {
3862 return 11;
3863 }
3864 if let Some(_) = self.vmo_discardable_locked_bytes {
3865 return 10;
3866 }
3867 if let Some(_) = self.vmo_pager_oldest_bytes {
3868 return 9;
3869 }
3870 if let Some(_) = self.vmo_pager_newest_bytes {
3871 return 8;
3872 }
3873 if let Some(_) = self.vmo_pager_total_bytes {
3874 return 7;
3875 }
3876 if let Some(_) = self.vmo_bytes {
3877 return 6;
3878 }
3879 if let Some(_) = self.free_heap_bytes {
3880 return 5;
3881 }
3882 if let Some(_) = self.total_heap_bytes {
3883 return 4;
3884 }
3885 if let Some(_) = self.wired_bytes {
3886 return 3;
3887 }
3888 if let Some(_) = self.free_bytes {
3889 return 2;
3890 }
3891 if let Some(_) = self.total_bytes {
3892 return 1;
3893 }
3894 0
3895 }
3896 }
3897
3898 impl fidl::encoding::ValueTypeMarker for MemoryStatsExtended {
3899 type Borrowed<'a> = &'a Self;
3900 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3901 value
3902 }
3903 }
3904
3905 unsafe impl fidl::encoding::TypeMarker for MemoryStatsExtended {
3906 type Owned = Self;
3907
3908 #[inline(always)]
3909 fn inline_align(_context: fidl::encoding::Context) -> usize {
3910 8
3911 }
3912
3913 #[inline(always)]
3914 fn inline_size(_context: fidl::encoding::Context) -> usize {
3915 16
3916 }
3917 }
3918
3919 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MemoryStatsExtended, D>
3920 for &MemoryStatsExtended
3921 {
3922 unsafe fn encode(
3923 self,
3924 encoder: &mut fidl::encoding::Encoder<'_, D>,
3925 offset: usize,
3926 mut depth: fidl::encoding::Depth,
3927 ) -> fidl::Result<()> {
3928 encoder.debug_check_bounds::<MemoryStatsExtended>(offset);
3929 let max_ordinal: u64 = self.max_ordinal_present();
3931 encoder.write_num(max_ordinal, offset);
3932 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3933 if max_ordinal == 0 {
3935 return Ok(());
3936 }
3937 depth.increment()?;
3938 let envelope_size = 8;
3939 let bytes_len = max_ordinal as usize * envelope_size;
3940 #[allow(unused_variables)]
3941 let offset = encoder.out_of_line_offset(bytes_len);
3942 let mut _prev_end_offset: usize = 0;
3943 if 1 > max_ordinal {
3944 return Ok(());
3945 }
3946
3947 let cur_offset: usize = (1 - 1) * envelope_size;
3950
3951 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3953
3954 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3959 self.total_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3960 encoder,
3961 offset + cur_offset,
3962 depth,
3963 )?;
3964
3965 _prev_end_offset = cur_offset + envelope_size;
3966 if 2 > max_ordinal {
3967 return Ok(());
3968 }
3969
3970 let cur_offset: usize = (2 - 1) * envelope_size;
3973
3974 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3976
3977 fidl::encoding::encode_in_envelope_optional::<u64, D>(
3982 self.free_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3983 encoder,
3984 offset + cur_offset,
3985 depth,
3986 )?;
3987
3988 _prev_end_offset = cur_offset + envelope_size;
3989 if 3 > max_ordinal {
3990 return Ok(());
3991 }
3992
3993 let cur_offset: usize = (3 - 1) * envelope_size;
3996
3997 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3999
4000 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4005 self.wired_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4006 encoder,
4007 offset + cur_offset,
4008 depth,
4009 )?;
4010
4011 _prev_end_offset = cur_offset + envelope_size;
4012 if 4 > max_ordinal {
4013 return Ok(());
4014 }
4015
4016 let cur_offset: usize = (4 - 1) * envelope_size;
4019
4020 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4022
4023 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4028 self.total_heap_bytes
4029 .as_ref()
4030 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4031 encoder,
4032 offset + cur_offset,
4033 depth,
4034 )?;
4035
4036 _prev_end_offset = cur_offset + envelope_size;
4037 if 5 > max_ordinal {
4038 return Ok(());
4039 }
4040
4041 let cur_offset: usize = (5 - 1) * envelope_size;
4044
4045 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4047
4048 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4053 self.free_heap_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4054 encoder,
4055 offset + cur_offset,
4056 depth,
4057 )?;
4058
4059 _prev_end_offset = cur_offset + envelope_size;
4060 if 6 > max_ordinal {
4061 return Ok(());
4062 }
4063
4064 let cur_offset: usize = (6 - 1) * envelope_size;
4067
4068 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4070
4071 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4076 self.vmo_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4077 encoder,
4078 offset + cur_offset,
4079 depth,
4080 )?;
4081
4082 _prev_end_offset = cur_offset + envelope_size;
4083 if 7 > max_ordinal {
4084 return Ok(());
4085 }
4086
4087 let cur_offset: usize = (7 - 1) * envelope_size;
4090
4091 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4093
4094 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4099 self.vmo_pager_total_bytes
4100 .as_ref()
4101 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4102 encoder,
4103 offset + cur_offset,
4104 depth,
4105 )?;
4106
4107 _prev_end_offset = cur_offset + envelope_size;
4108 if 8 > max_ordinal {
4109 return Ok(());
4110 }
4111
4112 let cur_offset: usize = (8 - 1) * envelope_size;
4115
4116 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4118
4119 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4124 self.vmo_pager_newest_bytes
4125 .as_ref()
4126 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4127 encoder,
4128 offset + cur_offset,
4129 depth,
4130 )?;
4131
4132 _prev_end_offset = cur_offset + envelope_size;
4133 if 9 > max_ordinal {
4134 return Ok(());
4135 }
4136
4137 let cur_offset: usize = (9 - 1) * envelope_size;
4140
4141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4143
4144 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4149 self.vmo_pager_oldest_bytes
4150 .as_ref()
4151 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4152 encoder,
4153 offset + cur_offset,
4154 depth,
4155 )?;
4156
4157 _prev_end_offset = cur_offset + envelope_size;
4158 if 10 > max_ordinal {
4159 return Ok(());
4160 }
4161
4162 let cur_offset: usize = (10 - 1) * envelope_size;
4165
4166 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4168
4169 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4174 self.vmo_discardable_locked_bytes
4175 .as_ref()
4176 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4177 encoder,
4178 offset + cur_offset,
4179 depth,
4180 )?;
4181
4182 _prev_end_offset = cur_offset + envelope_size;
4183 if 11 > max_ordinal {
4184 return Ok(());
4185 }
4186
4187 let cur_offset: usize = (11 - 1) * envelope_size;
4190
4191 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4193
4194 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4199 self.vmo_discardable_unlocked_bytes
4200 .as_ref()
4201 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4202 encoder,
4203 offset + cur_offset,
4204 depth,
4205 )?;
4206
4207 _prev_end_offset = cur_offset + envelope_size;
4208 if 12 > max_ordinal {
4209 return Ok(());
4210 }
4211
4212 let cur_offset: usize = (12 - 1) * envelope_size;
4215
4216 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4218
4219 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4224 self.mmu_overhead_bytes
4225 .as_ref()
4226 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4227 encoder,
4228 offset + cur_offset,
4229 depth,
4230 )?;
4231
4232 _prev_end_offset = cur_offset + envelope_size;
4233 if 13 > max_ordinal {
4234 return Ok(());
4235 }
4236
4237 let cur_offset: usize = (13 - 1) * envelope_size;
4240
4241 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4243
4244 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4249 self.ipc_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4250 encoder,
4251 offset + cur_offset,
4252 depth,
4253 )?;
4254
4255 _prev_end_offset = cur_offset + envelope_size;
4256 if 14 > max_ordinal {
4257 return Ok(());
4258 }
4259
4260 let cur_offset: usize = (14 - 1) * envelope_size;
4263
4264 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4266
4267 fidl::encoding::encode_in_envelope_optional::<u64, D>(
4272 self.other_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4273 encoder,
4274 offset + cur_offset,
4275 depth,
4276 )?;
4277
4278 _prev_end_offset = cur_offset + envelope_size;
4279
4280 Ok(())
4281 }
4282 }
4283
4284 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MemoryStatsExtended {
4285 #[inline(always)]
4286 fn new_empty() -> Self {
4287 Self::default()
4288 }
4289
4290 unsafe fn decode(
4291 &mut self,
4292 decoder: &mut fidl::encoding::Decoder<'_, D>,
4293 offset: usize,
4294 mut depth: fidl::encoding::Depth,
4295 ) -> fidl::Result<()> {
4296 decoder.debug_check_bounds::<Self>(offset);
4297 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4298 None => return Err(fidl::Error::NotNullable),
4299 Some(len) => len,
4300 };
4301 if len == 0 {
4303 return Ok(());
4304 };
4305 depth.increment()?;
4306 let envelope_size = 8;
4307 let bytes_len = len * envelope_size;
4308 let offset = decoder.out_of_line_offset(bytes_len)?;
4309 let mut _next_ordinal_to_read = 0;
4311 let mut next_offset = offset;
4312 let end_offset = offset + bytes_len;
4313 _next_ordinal_to_read += 1;
4314 if next_offset >= end_offset {
4315 return Ok(());
4316 }
4317
4318 while _next_ordinal_to_read < 1 {
4320 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4321 _next_ordinal_to_read += 1;
4322 next_offset += envelope_size;
4323 }
4324
4325 let next_out_of_line = decoder.next_out_of_line();
4326 let handles_before = decoder.remaining_handles();
4327 if let Some((inlined, num_bytes, num_handles)) =
4328 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4329 {
4330 let member_inline_size =
4331 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4332 if inlined != (member_inline_size <= 4) {
4333 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4334 }
4335 let inner_offset;
4336 let mut inner_depth = depth.clone();
4337 if inlined {
4338 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4339 inner_offset = next_offset;
4340 } else {
4341 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4342 inner_depth.increment()?;
4343 }
4344 let val_ref = self.total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4345 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4346 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4347 {
4348 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4349 }
4350 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4351 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4352 }
4353 }
4354
4355 next_offset += envelope_size;
4356 _next_ordinal_to_read += 1;
4357 if next_offset >= end_offset {
4358 return Ok(());
4359 }
4360
4361 while _next_ordinal_to_read < 2 {
4363 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4364 _next_ordinal_to_read += 1;
4365 next_offset += envelope_size;
4366 }
4367
4368 let next_out_of_line = decoder.next_out_of_line();
4369 let handles_before = decoder.remaining_handles();
4370 if let Some((inlined, num_bytes, num_handles)) =
4371 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4372 {
4373 let member_inline_size =
4374 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4375 if inlined != (member_inline_size <= 4) {
4376 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4377 }
4378 let inner_offset;
4379 let mut inner_depth = depth.clone();
4380 if inlined {
4381 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4382 inner_offset = next_offset;
4383 } else {
4384 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4385 inner_depth.increment()?;
4386 }
4387 let val_ref = self.free_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4388 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4389 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4390 {
4391 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4392 }
4393 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4394 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4395 }
4396 }
4397
4398 next_offset += envelope_size;
4399 _next_ordinal_to_read += 1;
4400 if next_offset >= end_offset {
4401 return Ok(());
4402 }
4403
4404 while _next_ordinal_to_read < 3 {
4406 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4407 _next_ordinal_to_read += 1;
4408 next_offset += envelope_size;
4409 }
4410
4411 let next_out_of_line = decoder.next_out_of_line();
4412 let handles_before = decoder.remaining_handles();
4413 if let Some((inlined, num_bytes, num_handles)) =
4414 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4415 {
4416 let member_inline_size =
4417 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4418 if inlined != (member_inline_size <= 4) {
4419 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4420 }
4421 let inner_offset;
4422 let mut inner_depth = depth.clone();
4423 if inlined {
4424 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4425 inner_offset = next_offset;
4426 } else {
4427 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4428 inner_depth.increment()?;
4429 }
4430 let val_ref = self.wired_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4431 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4432 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4433 {
4434 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4435 }
4436 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4437 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4438 }
4439 }
4440
4441 next_offset += envelope_size;
4442 _next_ordinal_to_read += 1;
4443 if next_offset >= end_offset {
4444 return Ok(());
4445 }
4446
4447 while _next_ordinal_to_read < 4 {
4449 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4450 _next_ordinal_to_read += 1;
4451 next_offset += envelope_size;
4452 }
4453
4454 let next_out_of_line = decoder.next_out_of_line();
4455 let handles_before = decoder.remaining_handles();
4456 if let Some((inlined, num_bytes, num_handles)) =
4457 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4458 {
4459 let member_inline_size =
4460 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4461 if inlined != (member_inline_size <= 4) {
4462 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4463 }
4464 let inner_offset;
4465 let mut inner_depth = depth.clone();
4466 if inlined {
4467 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4468 inner_offset = next_offset;
4469 } else {
4470 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4471 inner_depth.increment()?;
4472 }
4473 let val_ref = self.total_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4474 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4475 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4476 {
4477 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4478 }
4479 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4480 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4481 }
4482 }
4483
4484 next_offset += envelope_size;
4485 _next_ordinal_to_read += 1;
4486 if next_offset >= end_offset {
4487 return Ok(());
4488 }
4489
4490 while _next_ordinal_to_read < 5 {
4492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4493 _next_ordinal_to_read += 1;
4494 next_offset += envelope_size;
4495 }
4496
4497 let next_out_of_line = decoder.next_out_of_line();
4498 let handles_before = decoder.remaining_handles();
4499 if let Some((inlined, num_bytes, num_handles)) =
4500 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4501 {
4502 let member_inline_size =
4503 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4504 if inlined != (member_inline_size <= 4) {
4505 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4506 }
4507 let inner_offset;
4508 let mut inner_depth = depth.clone();
4509 if inlined {
4510 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4511 inner_offset = next_offset;
4512 } else {
4513 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4514 inner_depth.increment()?;
4515 }
4516 let val_ref = self.free_heap_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4517 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4518 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4519 {
4520 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4521 }
4522 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4523 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4524 }
4525 }
4526
4527 next_offset += envelope_size;
4528 _next_ordinal_to_read += 1;
4529 if next_offset >= end_offset {
4530 return Ok(());
4531 }
4532
4533 while _next_ordinal_to_read < 6 {
4535 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4536 _next_ordinal_to_read += 1;
4537 next_offset += envelope_size;
4538 }
4539
4540 let next_out_of_line = decoder.next_out_of_line();
4541 let handles_before = decoder.remaining_handles();
4542 if let Some((inlined, num_bytes, num_handles)) =
4543 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4544 {
4545 let member_inline_size =
4546 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4547 if inlined != (member_inline_size <= 4) {
4548 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4549 }
4550 let inner_offset;
4551 let mut inner_depth = depth.clone();
4552 if inlined {
4553 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4554 inner_offset = next_offset;
4555 } else {
4556 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4557 inner_depth.increment()?;
4558 }
4559 let val_ref = self.vmo_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4560 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4561 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4562 {
4563 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4564 }
4565 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4566 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4567 }
4568 }
4569
4570 next_offset += envelope_size;
4571 _next_ordinal_to_read += 1;
4572 if next_offset >= end_offset {
4573 return Ok(());
4574 }
4575
4576 while _next_ordinal_to_read < 7 {
4578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4579 _next_ordinal_to_read += 1;
4580 next_offset += envelope_size;
4581 }
4582
4583 let next_out_of_line = decoder.next_out_of_line();
4584 let handles_before = decoder.remaining_handles();
4585 if let Some((inlined, num_bytes, num_handles)) =
4586 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4587 {
4588 let member_inline_size =
4589 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4590 if inlined != (member_inline_size <= 4) {
4591 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4592 }
4593 let inner_offset;
4594 let mut inner_depth = depth.clone();
4595 if inlined {
4596 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4597 inner_offset = next_offset;
4598 } else {
4599 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4600 inner_depth.increment()?;
4601 }
4602 let val_ref =
4603 self.vmo_pager_total_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4604 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4605 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4606 {
4607 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4608 }
4609 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4610 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4611 }
4612 }
4613
4614 next_offset += envelope_size;
4615 _next_ordinal_to_read += 1;
4616 if next_offset >= end_offset {
4617 return Ok(());
4618 }
4619
4620 while _next_ordinal_to_read < 8 {
4622 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4623 _next_ordinal_to_read += 1;
4624 next_offset += envelope_size;
4625 }
4626
4627 let next_out_of_line = decoder.next_out_of_line();
4628 let handles_before = decoder.remaining_handles();
4629 if let Some((inlined, num_bytes, num_handles)) =
4630 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4631 {
4632 let member_inline_size =
4633 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4634 if inlined != (member_inline_size <= 4) {
4635 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4636 }
4637 let inner_offset;
4638 let mut inner_depth = depth.clone();
4639 if inlined {
4640 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4641 inner_offset = next_offset;
4642 } else {
4643 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4644 inner_depth.increment()?;
4645 }
4646 let val_ref =
4647 self.vmo_pager_newest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4648 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4649 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4650 {
4651 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4652 }
4653 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4654 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4655 }
4656 }
4657
4658 next_offset += envelope_size;
4659 _next_ordinal_to_read += 1;
4660 if next_offset >= end_offset {
4661 return Ok(());
4662 }
4663
4664 while _next_ordinal_to_read < 9 {
4666 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4667 _next_ordinal_to_read += 1;
4668 next_offset += envelope_size;
4669 }
4670
4671 let next_out_of_line = decoder.next_out_of_line();
4672 let handles_before = decoder.remaining_handles();
4673 if let Some((inlined, num_bytes, num_handles)) =
4674 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4675 {
4676 let member_inline_size =
4677 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4678 if inlined != (member_inline_size <= 4) {
4679 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4680 }
4681 let inner_offset;
4682 let mut inner_depth = depth.clone();
4683 if inlined {
4684 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4685 inner_offset = next_offset;
4686 } else {
4687 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4688 inner_depth.increment()?;
4689 }
4690 let val_ref =
4691 self.vmo_pager_oldest_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4692 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4693 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4694 {
4695 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4696 }
4697 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4698 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4699 }
4700 }
4701
4702 next_offset += envelope_size;
4703 _next_ordinal_to_read += 1;
4704 if next_offset >= end_offset {
4705 return Ok(());
4706 }
4707
4708 while _next_ordinal_to_read < 10 {
4710 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4711 _next_ordinal_to_read += 1;
4712 next_offset += envelope_size;
4713 }
4714
4715 let next_out_of_line = decoder.next_out_of_line();
4716 let handles_before = decoder.remaining_handles();
4717 if let Some((inlined, num_bytes, num_handles)) =
4718 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4719 {
4720 let member_inline_size =
4721 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4722 if inlined != (member_inline_size <= 4) {
4723 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4724 }
4725 let inner_offset;
4726 let mut inner_depth = depth.clone();
4727 if inlined {
4728 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4729 inner_offset = next_offset;
4730 } else {
4731 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4732 inner_depth.increment()?;
4733 }
4734 let val_ref = self
4735 .vmo_discardable_locked_bytes
4736 .get_or_insert_with(|| fidl::new_empty!(u64, D));
4737 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4738 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4739 {
4740 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4741 }
4742 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4743 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4744 }
4745 }
4746
4747 next_offset += envelope_size;
4748 _next_ordinal_to_read += 1;
4749 if next_offset >= end_offset {
4750 return Ok(());
4751 }
4752
4753 while _next_ordinal_to_read < 11 {
4755 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4756 _next_ordinal_to_read += 1;
4757 next_offset += envelope_size;
4758 }
4759
4760 let next_out_of_line = decoder.next_out_of_line();
4761 let handles_before = decoder.remaining_handles();
4762 if let Some((inlined, num_bytes, num_handles)) =
4763 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4764 {
4765 let member_inline_size =
4766 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4767 if inlined != (member_inline_size <= 4) {
4768 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4769 }
4770 let inner_offset;
4771 let mut inner_depth = depth.clone();
4772 if inlined {
4773 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4774 inner_offset = next_offset;
4775 } else {
4776 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4777 inner_depth.increment()?;
4778 }
4779 let val_ref = self
4780 .vmo_discardable_unlocked_bytes
4781 .get_or_insert_with(|| fidl::new_empty!(u64, D));
4782 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4783 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4784 {
4785 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4786 }
4787 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4788 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4789 }
4790 }
4791
4792 next_offset += envelope_size;
4793 _next_ordinal_to_read += 1;
4794 if next_offset >= end_offset {
4795 return Ok(());
4796 }
4797
4798 while _next_ordinal_to_read < 12 {
4800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4801 _next_ordinal_to_read += 1;
4802 next_offset += envelope_size;
4803 }
4804
4805 let next_out_of_line = decoder.next_out_of_line();
4806 let handles_before = decoder.remaining_handles();
4807 if let Some((inlined, num_bytes, num_handles)) =
4808 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4809 {
4810 let member_inline_size =
4811 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4812 if inlined != (member_inline_size <= 4) {
4813 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4814 }
4815 let inner_offset;
4816 let mut inner_depth = depth.clone();
4817 if inlined {
4818 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4819 inner_offset = next_offset;
4820 } else {
4821 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4822 inner_depth.increment()?;
4823 }
4824 let val_ref =
4825 self.mmu_overhead_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4826 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4827 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4828 {
4829 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4830 }
4831 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4832 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4833 }
4834 }
4835
4836 next_offset += envelope_size;
4837 _next_ordinal_to_read += 1;
4838 if next_offset >= end_offset {
4839 return Ok(());
4840 }
4841
4842 while _next_ordinal_to_read < 13 {
4844 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4845 _next_ordinal_to_read += 1;
4846 next_offset += envelope_size;
4847 }
4848
4849 let next_out_of_line = decoder.next_out_of_line();
4850 let handles_before = decoder.remaining_handles();
4851 if let Some((inlined, num_bytes, num_handles)) =
4852 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4853 {
4854 let member_inline_size =
4855 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4856 if inlined != (member_inline_size <= 4) {
4857 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4858 }
4859 let inner_offset;
4860 let mut inner_depth = depth.clone();
4861 if inlined {
4862 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4863 inner_offset = next_offset;
4864 } else {
4865 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4866 inner_depth.increment()?;
4867 }
4868 let val_ref = self.ipc_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4869 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4870 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4871 {
4872 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4873 }
4874 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4875 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4876 }
4877 }
4878
4879 next_offset += envelope_size;
4880 _next_ordinal_to_read += 1;
4881 if next_offset >= end_offset {
4882 return Ok(());
4883 }
4884
4885 while _next_ordinal_to_read < 14 {
4887 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4888 _next_ordinal_to_read += 1;
4889 next_offset += envelope_size;
4890 }
4891
4892 let next_out_of_line = decoder.next_out_of_line();
4893 let handles_before = decoder.remaining_handles();
4894 if let Some((inlined, num_bytes, num_handles)) =
4895 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4896 {
4897 let member_inline_size =
4898 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4899 if inlined != (member_inline_size <= 4) {
4900 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4901 }
4902 let inner_offset;
4903 let mut inner_depth = depth.clone();
4904 if inlined {
4905 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4906 inner_offset = next_offset;
4907 } else {
4908 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4909 inner_depth.increment()?;
4910 }
4911 let val_ref = self.other_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4912 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4913 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4914 {
4915 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4916 }
4917 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4918 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4919 }
4920 }
4921
4922 next_offset += envelope_size;
4923
4924 while next_offset < end_offset {
4926 _next_ordinal_to_read += 1;
4927 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4928 next_offset += envelope_size;
4929 }
4930
4931 Ok(())
4932 }
4933 }
4934
4935 impl PerCpuStats {
4936 #[inline(always)]
4937 fn max_ordinal_present(&self) -> u64 {
4938 if let Some(_) = self.generic_ipis {
4939 return 15;
4940 }
4941 if let Some(_) = self.reschedule_ipis {
4942 return 14;
4943 }
4944 if let Some(_) = self.syscalls {
4945 return 13;
4946 }
4947 if let Some(_) = self.exceptions {
4948 return 12;
4949 }
4950 if let Some(_) = self.page_faults {
4951 return 11;
4952 }
4953 if let Some(_) = self.timers {
4954 return 10;
4955 }
4956 if let Some(_) = self.timer_ints {
4957 return 9;
4958 }
4959 if let Some(_) = self.ints {
4960 return 8;
4961 }
4962 if let Some(_) = self.yields {
4963 return 7;
4964 }
4965 if let Some(_) = self.irq_preempts {
4966 return 6;
4967 }
4968 if let Some(_) = self.context_switches {
4969 return 5;
4970 }
4971 if let Some(_) = self.reschedules {
4972 return 4;
4973 }
4974 if let Some(_) = self.idle_time {
4975 return 3;
4976 }
4977 if let Some(_) = self.flags {
4978 return 2;
4979 }
4980 if let Some(_) = self.cpu_number {
4981 return 1;
4982 }
4983 0
4984 }
4985 }
4986
4987 impl fidl::encoding::ValueTypeMarker for PerCpuStats {
4988 type Borrowed<'a> = &'a Self;
4989 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4990 value
4991 }
4992 }
4993
4994 unsafe impl fidl::encoding::TypeMarker for PerCpuStats {
4995 type Owned = Self;
4996
4997 #[inline(always)]
4998 fn inline_align(_context: fidl::encoding::Context) -> usize {
4999 8
5000 }
5001
5002 #[inline(always)]
5003 fn inline_size(_context: fidl::encoding::Context) -> usize {
5004 16
5005 }
5006 }
5007
5008 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PerCpuStats, D>
5009 for &PerCpuStats
5010 {
5011 unsafe fn encode(
5012 self,
5013 encoder: &mut fidl::encoding::Encoder<'_, D>,
5014 offset: usize,
5015 mut depth: fidl::encoding::Depth,
5016 ) -> fidl::Result<()> {
5017 encoder.debug_check_bounds::<PerCpuStats>(offset);
5018 let max_ordinal: u64 = self.max_ordinal_present();
5020 encoder.write_num(max_ordinal, offset);
5021 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5022 if max_ordinal == 0 {
5024 return Ok(());
5025 }
5026 depth.increment()?;
5027 let envelope_size = 8;
5028 let bytes_len = max_ordinal as usize * envelope_size;
5029 #[allow(unused_variables)]
5030 let offset = encoder.out_of_line_offset(bytes_len);
5031 let mut _prev_end_offset: usize = 0;
5032 if 1 > max_ordinal {
5033 return Ok(());
5034 }
5035
5036 let cur_offset: usize = (1 - 1) * envelope_size;
5039
5040 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5042
5043 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5048 self.cpu_number.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5049 encoder,
5050 offset + cur_offset,
5051 depth,
5052 )?;
5053
5054 _prev_end_offset = cur_offset + envelope_size;
5055 if 2 > max_ordinal {
5056 return Ok(());
5057 }
5058
5059 let cur_offset: usize = (2 - 1) * envelope_size;
5062
5063 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5065
5066 fidl::encoding::encode_in_envelope_optional::<u32, D>(
5071 self.flags.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5072 encoder,
5073 offset + cur_offset,
5074 depth,
5075 )?;
5076
5077 _prev_end_offset = cur_offset + envelope_size;
5078 if 3 > max_ordinal {
5079 return Ok(());
5080 }
5081
5082 let cur_offset: usize = (3 - 1) * envelope_size;
5085
5086 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5088
5089 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5094 self.idle_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5095 encoder,
5096 offset + cur_offset,
5097 depth,
5098 )?;
5099
5100 _prev_end_offset = cur_offset + envelope_size;
5101 if 4 > max_ordinal {
5102 return Ok(());
5103 }
5104
5105 let cur_offset: usize = (4 - 1) * envelope_size;
5108
5109 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5111
5112 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5117 self.reschedules.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5118 encoder,
5119 offset + cur_offset,
5120 depth,
5121 )?;
5122
5123 _prev_end_offset = cur_offset + envelope_size;
5124 if 5 > max_ordinal {
5125 return Ok(());
5126 }
5127
5128 let cur_offset: usize = (5 - 1) * envelope_size;
5131
5132 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5134
5135 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5140 self.context_switches
5141 .as_ref()
5142 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5143 encoder,
5144 offset + cur_offset,
5145 depth,
5146 )?;
5147
5148 _prev_end_offset = cur_offset + envelope_size;
5149 if 6 > max_ordinal {
5150 return Ok(());
5151 }
5152
5153 let cur_offset: usize = (6 - 1) * envelope_size;
5156
5157 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5159
5160 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5165 self.irq_preempts.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5166 encoder,
5167 offset + cur_offset,
5168 depth,
5169 )?;
5170
5171 _prev_end_offset = cur_offset + envelope_size;
5172 if 7 > max_ordinal {
5173 return Ok(());
5174 }
5175
5176 let cur_offset: usize = (7 - 1) * envelope_size;
5179
5180 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5182
5183 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5188 self.yields.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5189 encoder,
5190 offset + cur_offset,
5191 depth,
5192 )?;
5193
5194 _prev_end_offset = cur_offset + envelope_size;
5195 if 8 > max_ordinal {
5196 return Ok(());
5197 }
5198
5199 let cur_offset: usize = (8 - 1) * envelope_size;
5202
5203 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5205
5206 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5211 self.ints.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5212 encoder,
5213 offset + cur_offset,
5214 depth,
5215 )?;
5216
5217 _prev_end_offset = cur_offset + envelope_size;
5218 if 9 > max_ordinal {
5219 return Ok(());
5220 }
5221
5222 let cur_offset: usize = (9 - 1) * envelope_size;
5225
5226 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5228
5229 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5234 self.timer_ints.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5235 encoder,
5236 offset + cur_offset,
5237 depth,
5238 )?;
5239
5240 _prev_end_offset = cur_offset + envelope_size;
5241 if 10 > max_ordinal {
5242 return Ok(());
5243 }
5244
5245 let cur_offset: usize = (10 - 1) * envelope_size;
5248
5249 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5251
5252 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5257 self.timers.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5258 encoder,
5259 offset + cur_offset,
5260 depth,
5261 )?;
5262
5263 _prev_end_offset = cur_offset + envelope_size;
5264 if 11 > max_ordinal {
5265 return Ok(());
5266 }
5267
5268 let cur_offset: usize = (11 - 1) * envelope_size;
5271
5272 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5274
5275 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5280 self.page_faults.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5281 encoder,
5282 offset + cur_offset,
5283 depth,
5284 )?;
5285
5286 _prev_end_offset = cur_offset + envelope_size;
5287 if 12 > max_ordinal {
5288 return Ok(());
5289 }
5290
5291 let cur_offset: usize = (12 - 1) * envelope_size;
5294
5295 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5297
5298 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5303 self.exceptions.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5304 encoder,
5305 offset + cur_offset,
5306 depth,
5307 )?;
5308
5309 _prev_end_offset = cur_offset + envelope_size;
5310 if 13 > max_ordinal {
5311 return Ok(());
5312 }
5313
5314 let cur_offset: usize = (13 - 1) * envelope_size;
5317
5318 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5320
5321 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5326 self.syscalls.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5327 encoder,
5328 offset + cur_offset,
5329 depth,
5330 )?;
5331
5332 _prev_end_offset = cur_offset + envelope_size;
5333 if 14 > max_ordinal {
5334 return Ok(());
5335 }
5336
5337 let cur_offset: usize = (14 - 1) * envelope_size;
5340
5341 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5349 self.reschedule_ipis.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5350 encoder,
5351 offset + cur_offset,
5352 depth,
5353 )?;
5354
5355 _prev_end_offset = cur_offset + envelope_size;
5356 if 15 > max_ordinal {
5357 return Ok(());
5358 }
5359
5360 let cur_offset: usize = (15 - 1) * envelope_size;
5363
5364 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5366
5367 fidl::encoding::encode_in_envelope_optional::<u64, D>(
5372 self.generic_ipis.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5373 encoder,
5374 offset + cur_offset,
5375 depth,
5376 )?;
5377
5378 _prev_end_offset = cur_offset + envelope_size;
5379
5380 Ok(())
5381 }
5382 }
5383
5384 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PerCpuStats {
5385 #[inline(always)]
5386 fn new_empty() -> Self {
5387 Self::default()
5388 }
5389
5390 unsafe fn decode(
5391 &mut self,
5392 decoder: &mut fidl::encoding::Decoder<'_, D>,
5393 offset: usize,
5394 mut depth: fidl::encoding::Depth,
5395 ) -> fidl::Result<()> {
5396 decoder.debug_check_bounds::<Self>(offset);
5397 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5398 None => return Err(fidl::Error::NotNullable),
5399 Some(len) => len,
5400 };
5401 if len == 0 {
5403 return Ok(());
5404 };
5405 depth.increment()?;
5406 let envelope_size = 8;
5407 let bytes_len = len * envelope_size;
5408 let offset = decoder.out_of_line_offset(bytes_len)?;
5409 let mut _next_ordinal_to_read = 0;
5411 let mut next_offset = offset;
5412 let end_offset = offset + bytes_len;
5413 _next_ordinal_to_read += 1;
5414 if next_offset >= end_offset {
5415 return Ok(());
5416 }
5417
5418 while _next_ordinal_to_read < 1 {
5420 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5421 _next_ordinal_to_read += 1;
5422 next_offset += envelope_size;
5423 }
5424
5425 let next_out_of_line = decoder.next_out_of_line();
5426 let handles_before = decoder.remaining_handles();
5427 if let Some((inlined, num_bytes, num_handles)) =
5428 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5429 {
5430 let member_inline_size =
5431 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5432 if inlined != (member_inline_size <= 4) {
5433 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5434 }
5435 let inner_offset;
5436 let mut inner_depth = depth.clone();
5437 if inlined {
5438 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5439 inner_offset = next_offset;
5440 } else {
5441 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5442 inner_depth.increment()?;
5443 }
5444 let val_ref = self.cpu_number.get_or_insert_with(|| fidl::new_empty!(u32, D));
5445 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5446 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5447 {
5448 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5449 }
5450 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5451 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5452 }
5453 }
5454
5455 next_offset += envelope_size;
5456 _next_ordinal_to_read += 1;
5457 if next_offset >= end_offset {
5458 return Ok(());
5459 }
5460
5461 while _next_ordinal_to_read < 2 {
5463 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5464 _next_ordinal_to_read += 1;
5465 next_offset += envelope_size;
5466 }
5467
5468 let next_out_of_line = decoder.next_out_of_line();
5469 let handles_before = decoder.remaining_handles();
5470 if let Some((inlined, num_bytes, num_handles)) =
5471 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5472 {
5473 let member_inline_size =
5474 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5475 if inlined != (member_inline_size <= 4) {
5476 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5477 }
5478 let inner_offset;
5479 let mut inner_depth = depth.clone();
5480 if inlined {
5481 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5482 inner_offset = next_offset;
5483 } else {
5484 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5485 inner_depth.increment()?;
5486 }
5487 let val_ref = self.flags.get_or_insert_with(|| fidl::new_empty!(u32, D));
5488 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5489 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5490 {
5491 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5492 }
5493 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5494 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5495 }
5496 }
5497
5498 next_offset += envelope_size;
5499 _next_ordinal_to_read += 1;
5500 if next_offset >= end_offset {
5501 return Ok(());
5502 }
5503
5504 while _next_ordinal_to_read < 3 {
5506 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5507 _next_ordinal_to_read += 1;
5508 next_offset += envelope_size;
5509 }
5510
5511 let next_out_of_line = decoder.next_out_of_line();
5512 let handles_before = decoder.remaining_handles();
5513 if let Some((inlined, num_bytes, num_handles)) =
5514 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5515 {
5516 let member_inline_size =
5517 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5518 if inlined != (member_inline_size <= 4) {
5519 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5520 }
5521 let inner_offset;
5522 let mut inner_depth = depth.clone();
5523 if inlined {
5524 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5525 inner_offset = next_offset;
5526 } else {
5527 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5528 inner_depth.increment()?;
5529 }
5530 let val_ref = self.idle_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
5531 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
5532 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5533 {
5534 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5535 }
5536 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5537 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5538 }
5539 }
5540
5541 next_offset += envelope_size;
5542 _next_ordinal_to_read += 1;
5543 if next_offset >= end_offset {
5544 return Ok(());
5545 }
5546
5547 while _next_ordinal_to_read < 4 {
5549 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5550 _next_ordinal_to_read += 1;
5551 next_offset += envelope_size;
5552 }
5553
5554 let next_out_of_line = decoder.next_out_of_line();
5555 let handles_before = decoder.remaining_handles();
5556 if let Some((inlined, num_bytes, num_handles)) =
5557 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5558 {
5559 let member_inline_size =
5560 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5561 if inlined != (member_inline_size <= 4) {
5562 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5563 }
5564 let inner_offset;
5565 let mut inner_depth = depth.clone();
5566 if inlined {
5567 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5568 inner_offset = next_offset;
5569 } else {
5570 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5571 inner_depth.increment()?;
5572 }
5573 let val_ref = self.reschedules.get_or_insert_with(|| fidl::new_empty!(u64, D));
5574 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5575 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5576 {
5577 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5578 }
5579 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5580 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5581 }
5582 }
5583
5584 next_offset += envelope_size;
5585 _next_ordinal_to_read += 1;
5586 if next_offset >= end_offset {
5587 return Ok(());
5588 }
5589
5590 while _next_ordinal_to_read < 5 {
5592 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5593 _next_ordinal_to_read += 1;
5594 next_offset += envelope_size;
5595 }
5596
5597 let next_out_of_line = decoder.next_out_of_line();
5598 let handles_before = decoder.remaining_handles();
5599 if let Some((inlined, num_bytes, num_handles)) =
5600 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5601 {
5602 let member_inline_size =
5603 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5604 if inlined != (member_inline_size <= 4) {
5605 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5606 }
5607 let inner_offset;
5608 let mut inner_depth = depth.clone();
5609 if inlined {
5610 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5611 inner_offset = next_offset;
5612 } else {
5613 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5614 inner_depth.increment()?;
5615 }
5616 let val_ref = self.context_switches.get_or_insert_with(|| fidl::new_empty!(u64, D));
5617 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5618 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5619 {
5620 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5621 }
5622 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5623 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5624 }
5625 }
5626
5627 next_offset += envelope_size;
5628 _next_ordinal_to_read += 1;
5629 if next_offset >= end_offset {
5630 return Ok(());
5631 }
5632
5633 while _next_ordinal_to_read < 6 {
5635 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5636 _next_ordinal_to_read += 1;
5637 next_offset += envelope_size;
5638 }
5639
5640 let next_out_of_line = decoder.next_out_of_line();
5641 let handles_before = decoder.remaining_handles();
5642 if let Some((inlined, num_bytes, num_handles)) =
5643 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5644 {
5645 let member_inline_size =
5646 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5647 if inlined != (member_inline_size <= 4) {
5648 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5649 }
5650 let inner_offset;
5651 let mut inner_depth = depth.clone();
5652 if inlined {
5653 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5654 inner_offset = next_offset;
5655 } else {
5656 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5657 inner_depth.increment()?;
5658 }
5659 let val_ref = self.irq_preempts.get_or_insert_with(|| fidl::new_empty!(u64, D));
5660 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5661 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5662 {
5663 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5664 }
5665 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5666 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5667 }
5668 }
5669
5670 next_offset += envelope_size;
5671 _next_ordinal_to_read += 1;
5672 if next_offset >= end_offset {
5673 return Ok(());
5674 }
5675
5676 while _next_ordinal_to_read < 7 {
5678 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5679 _next_ordinal_to_read += 1;
5680 next_offset += envelope_size;
5681 }
5682
5683 let next_out_of_line = decoder.next_out_of_line();
5684 let handles_before = decoder.remaining_handles();
5685 if let Some((inlined, num_bytes, num_handles)) =
5686 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5687 {
5688 let member_inline_size =
5689 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5690 if inlined != (member_inline_size <= 4) {
5691 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5692 }
5693 let inner_offset;
5694 let mut inner_depth = depth.clone();
5695 if inlined {
5696 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5697 inner_offset = next_offset;
5698 } else {
5699 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5700 inner_depth.increment()?;
5701 }
5702 let val_ref = self.yields.get_or_insert_with(|| fidl::new_empty!(u64, D));
5703 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5704 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5705 {
5706 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5707 }
5708 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5709 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5710 }
5711 }
5712
5713 next_offset += envelope_size;
5714 _next_ordinal_to_read += 1;
5715 if next_offset >= end_offset {
5716 return Ok(());
5717 }
5718
5719 while _next_ordinal_to_read < 8 {
5721 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5722 _next_ordinal_to_read += 1;
5723 next_offset += envelope_size;
5724 }
5725
5726 let next_out_of_line = decoder.next_out_of_line();
5727 let handles_before = decoder.remaining_handles();
5728 if let Some((inlined, num_bytes, num_handles)) =
5729 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5730 {
5731 let member_inline_size =
5732 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5733 if inlined != (member_inline_size <= 4) {
5734 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5735 }
5736 let inner_offset;
5737 let mut inner_depth = depth.clone();
5738 if inlined {
5739 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5740 inner_offset = next_offset;
5741 } else {
5742 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5743 inner_depth.increment()?;
5744 }
5745 let val_ref = self.ints.get_or_insert_with(|| fidl::new_empty!(u64, D));
5746 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5747 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5748 {
5749 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5750 }
5751 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5752 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5753 }
5754 }
5755
5756 next_offset += envelope_size;
5757 _next_ordinal_to_read += 1;
5758 if next_offset >= end_offset {
5759 return Ok(());
5760 }
5761
5762 while _next_ordinal_to_read < 9 {
5764 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5765 _next_ordinal_to_read += 1;
5766 next_offset += envelope_size;
5767 }
5768
5769 let next_out_of_line = decoder.next_out_of_line();
5770 let handles_before = decoder.remaining_handles();
5771 if let Some((inlined, num_bytes, num_handles)) =
5772 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5773 {
5774 let member_inline_size =
5775 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5776 if inlined != (member_inline_size <= 4) {
5777 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5778 }
5779 let inner_offset;
5780 let mut inner_depth = depth.clone();
5781 if inlined {
5782 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5783 inner_offset = next_offset;
5784 } else {
5785 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5786 inner_depth.increment()?;
5787 }
5788 let val_ref = self.timer_ints.get_or_insert_with(|| fidl::new_empty!(u64, D));
5789 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5791 {
5792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5793 }
5794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5796 }
5797 }
5798
5799 next_offset += envelope_size;
5800 _next_ordinal_to_read += 1;
5801 if next_offset >= end_offset {
5802 return Ok(());
5803 }
5804
5805 while _next_ordinal_to_read < 10 {
5807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5808 _next_ordinal_to_read += 1;
5809 next_offset += envelope_size;
5810 }
5811
5812 let next_out_of_line = decoder.next_out_of_line();
5813 let handles_before = decoder.remaining_handles();
5814 if let Some((inlined, num_bytes, num_handles)) =
5815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5816 {
5817 let member_inline_size =
5818 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5819 if inlined != (member_inline_size <= 4) {
5820 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5821 }
5822 let inner_offset;
5823 let mut inner_depth = depth.clone();
5824 if inlined {
5825 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5826 inner_offset = next_offset;
5827 } else {
5828 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5829 inner_depth.increment()?;
5830 }
5831 let val_ref = self.timers.get_or_insert_with(|| fidl::new_empty!(u64, D));
5832 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5833 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5834 {
5835 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5836 }
5837 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5838 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5839 }
5840 }
5841
5842 next_offset += envelope_size;
5843 _next_ordinal_to_read += 1;
5844 if next_offset >= end_offset {
5845 return Ok(());
5846 }
5847
5848 while _next_ordinal_to_read < 11 {
5850 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5851 _next_ordinal_to_read += 1;
5852 next_offset += envelope_size;
5853 }
5854
5855 let next_out_of_line = decoder.next_out_of_line();
5856 let handles_before = decoder.remaining_handles();
5857 if let Some((inlined, num_bytes, num_handles)) =
5858 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5859 {
5860 let member_inline_size =
5861 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5862 if inlined != (member_inline_size <= 4) {
5863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5864 }
5865 let inner_offset;
5866 let mut inner_depth = depth.clone();
5867 if inlined {
5868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5869 inner_offset = next_offset;
5870 } else {
5871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5872 inner_depth.increment()?;
5873 }
5874 let val_ref = self.page_faults.get_or_insert_with(|| fidl::new_empty!(u64, D));
5875 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5876 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5877 {
5878 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5879 }
5880 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5881 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5882 }
5883 }
5884
5885 next_offset += envelope_size;
5886 _next_ordinal_to_read += 1;
5887 if next_offset >= end_offset {
5888 return Ok(());
5889 }
5890
5891 while _next_ordinal_to_read < 12 {
5893 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5894 _next_ordinal_to_read += 1;
5895 next_offset += envelope_size;
5896 }
5897
5898 let next_out_of_line = decoder.next_out_of_line();
5899 let handles_before = decoder.remaining_handles();
5900 if let Some((inlined, num_bytes, num_handles)) =
5901 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5902 {
5903 let member_inline_size =
5904 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5905 if inlined != (member_inline_size <= 4) {
5906 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5907 }
5908 let inner_offset;
5909 let mut inner_depth = depth.clone();
5910 if inlined {
5911 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5912 inner_offset = next_offset;
5913 } else {
5914 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5915 inner_depth.increment()?;
5916 }
5917 let val_ref = self.exceptions.get_or_insert_with(|| fidl::new_empty!(u64, D));
5918 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5919 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5920 {
5921 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5922 }
5923 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5924 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5925 }
5926 }
5927
5928 next_offset += envelope_size;
5929 _next_ordinal_to_read += 1;
5930 if next_offset >= end_offset {
5931 return Ok(());
5932 }
5933
5934 while _next_ordinal_to_read < 13 {
5936 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5937 _next_ordinal_to_read += 1;
5938 next_offset += envelope_size;
5939 }
5940
5941 let next_out_of_line = decoder.next_out_of_line();
5942 let handles_before = decoder.remaining_handles();
5943 if let Some((inlined, num_bytes, num_handles)) =
5944 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5945 {
5946 let member_inline_size =
5947 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5948 if inlined != (member_inline_size <= 4) {
5949 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5950 }
5951 let inner_offset;
5952 let mut inner_depth = depth.clone();
5953 if inlined {
5954 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5955 inner_offset = next_offset;
5956 } else {
5957 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5958 inner_depth.increment()?;
5959 }
5960 let val_ref = self.syscalls.get_or_insert_with(|| fidl::new_empty!(u64, D));
5961 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5962 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5963 {
5964 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5965 }
5966 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5967 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5968 }
5969 }
5970
5971 next_offset += envelope_size;
5972 _next_ordinal_to_read += 1;
5973 if next_offset >= end_offset {
5974 return Ok(());
5975 }
5976
5977 while _next_ordinal_to_read < 14 {
5979 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5980 _next_ordinal_to_read += 1;
5981 next_offset += envelope_size;
5982 }
5983
5984 let next_out_of_line = decoder.next_out_of_line();
5985 let handles_before = decoder.remaining_handles();
5986 if let Some((inlined, num_bytes, num_handles)) =
5987 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5988 {
5989 let member_inline_size =
5990 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5991 if inlined != (member_inline_size <= 4) {
5992 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5993 }
5994 let inner_offset;
5995 let mut inner_depth = depth.clone();
5996 if inlined {
5997 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5998 inner_offset = next_offset;
5999 } else {
6000 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6001 inner_depth.increment()?;
6002 }
6003 let val_ref = self.reschedule_ipis.get_or_insert_with(|| fidl::new_empty!(u64, D));
6004 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6005 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6006 {
6007 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6008 }
6009 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6010 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6011 }
6012 }
6013
6014 next_offset += envelope_size;
6015 _next_ordinal_to_read += 1;
6016 if next_offset >= end_offset {
6017 return Ok(());
6018 }
6019
6020 while _next_ordinal_to_read < 15 {
6022 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6023 _next_ordinal_to_read += 1;
6024 next_offset += envelope_size;
6025 }
6026
6027 let next_out_of_line = decoder.next_out_of_line();
6028 let handles_before = decoder.remaining_handles();
6029 if let Some((inlined, num_bytes, num_handles)) =
6030 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6031 {
6032 let member_inline_size =
6033 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6034 if inlined != (member_inline_size <= 4) {
6035 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6036 }
6037 let inner_offset;
6038 let mut inner_depth = depth.clone();
6039 if inlined {
6040 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6041 inner_offset = next_offset;
6042 } else {
6043 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6044 inner_depth.increment()?;
6045 }
6046 let val_ref = self.generic_ipis.get_or_insert_with(|| fidl::new_empty!(u64, D));
6047 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
6048 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6049 {
6050 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6051 }
6052 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6053 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6054 }
6055 }
6056
6057 next_offset += envelope_size;
6058
6059 while next_offset < end_offset {
6061 _next_ordinal_to_read += 1;
6062 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6063 next_offset += envelope_size;
6064 }
6065
6066 Ok(())
6067 }
6068 }
6069}