fidl_fuchsia_hardware_block_common/
fidl_fuchsia_hardware_block_common.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub const MAPPINGS_BATCH_SIZE: u8 = 64;
12
13/// The maximum value for a transfer size, identifying that there
14/// effectively exists no maximum for a single operation.
15pub const MAX_TRANSFER_UNBOUNDED: u32 = 4294967295;
16
17/// Value reserved for "invalid" VmoId. Will never be allocated by the server,
18/// and may be utilized as a local value for an unallocated ID.
19pub const VMOID_INVALID: u16 = 0;
20
21bitflags! {
22    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
23    pub struct Flag: u32 {
24        /// All writes to the block device will fail.
25        const READONLY = 1;
26        /// The block device may be removed from the device during operation.
27        const REMOVABLE = 2;
28        /// The device has a bootdata partition map.
29        const BOOTPART = 4;
30        /// The device provides trim support.
31        const TRIM_SUPPORT = 8;
32        /// The device provides fua support.
33        const FUA_SUPPORT = 16;
34    }
35}
36
37impl Flag {
38    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
39    #[inline(always)]
40    pub fn has_unknown_bits(&self) -> bool {
41        false
42    }
43
44    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
45    #[inline(always)]
46    pub fn get_unknown_bits(&self) -> u32 {
47        0
48    }
49}
50
51#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
52pub struct BlockGetStatsRequest {
53    pub clear: bool,
54}
55
56impl fidl::Persistable for BlockGetStatsRequest {}
57
58#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
59pub struct BlockInfo {
60    /// The number of blocks in this block device.
61    pub block_count: u64,
62    /// The size of a single block.
63    pub block_size: u32,
64    /// The maximum size, in bytes, of a transfer.
65    /// Set to MAX_TRANSFER_UNBOUNDED if no such maximum exists.
66    pub max_transfer_size: u32,
67    /// Identifiers about the device.
68    pub flags: Flag,
69}
70
71impl fidl::Persistable for BlockInfo {}
72
73/// Describes a re-mapping of a block range.  See OffsetMap.
74/// Note that all fields are in *blocks*, not bytes.
75#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
76#[repr(C)]
77pub struct BlockOffsetMapping {
78    pub source_block_offset: u64,
79    pub target_block_offset: u64,
80    pub length: u64,
81}
82
83impl fidl::Persistable for BlockOffsetMapping {}
84
85/// Returns stats about the block device on the provided buffer. If `clear` is true, the
86/// operation counters will be cleared.
87#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
88#[repr(C)]
89pub struct BlockStats {
90    /// Stats about block read operations from the device.
91    pub read: OperationStats,
92    /// Stats about block write operations to the device.
93    pub write: OperationStats,
94    /// Stats about TRIM commands issued to the device.
95    pub trim: OperationStats,
96    /// Stats about flush commands issued to the device.
97    pub flush: OperationStats,
98}
99
100impl fidl::Persistable for BlockStats {}
101
102#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
103pub struct BlockGetInfoResponse {
104    pub info: BlockInfo,
105}
106
107impl fidl::Persistable for BlockGetInfoResponse {}
108
109#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
110#[repr(C)]
111pub struct BlockGetStatsResponse {
112    pub stats: BlockStats,
113}
114
115impl fidl::Persistable for BlockGetStatsResponse {}
116
117#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
118#[repr(C)]
119pub struct FtlFormatResponse {
120    pub status: i32,
121}
122
123impl fidl::Persistable for FtlFormatResponse {}
124
125#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
126#[repr(C)]
127pub struct OffsetMapQueryRequest {
128    pub source_block_offset: u64,
129    pub length: u64,
130}
131
132impl fidl::Persistable for OffsetMapQueryRequest {}
133
134#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
135pub struct OffsetMapQueryResponse {
136    pub mappings: Vec<BlockOffsetMapping>,
137}
138
139impl fidl::Persistable for OffsetMapQueryResponse {}
140
141/// Helper struct to track device requests grouped by successful versus failed requests.
142#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
143#[repr(C)]
144pub struct OperationStats {
145    /// Stats for successful requests.
146    pub success: RequestStats,
147    /// Stats for failed requests.
148    pub failure: RequestStats,
149}
150
151impl fidl::Persistable for OperationStats {}
152
153/// Stats captured for specific block requests. Unless specified otherwise, time units are in
154/// nanoseconds and data transferred is in bytes
155#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
156#[repr(C)]
157pub struct RequestStats {
158    /// Minimum time taken by a request to be served.
159    pub minimum_latency: u64,
160    /// Maximum time taken by a request to be served.
161    pub maximum_latency: u64,
162    /// Total time spent to serve requests.
163    pub total_time_spent: u64,
164    /// Total number of calls.
165    pub total_calls: u64,
166    /// bytes_transferred represents a specific quantity to the operation being measured. It has
167    /// special meaning for success vs failed calls.
168    /// On success:
169    ///    Partitally succeeded calls, bytes fetched is less than bytes requested,
170    ///    can be considered as successful. To keep latency and time_spent numbers
171    ///    accurate, on success, bytes transferred is number bytes returned to
172    ///    caller. It is NOT the number of bytes fetched from underlying subsystem
173    ///    and it is NOT number of bytes requested by the caller.
174    /// On failure:
175    ///    On failure, bytes_transferred is the number of bytes requested by the caller.
176    pub bytes_transferred: u64,
177}
178
179impl fidl::Persistable for RequestStats {}
180
181#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
182#[repr(C)]
183pub struct SessionAttachVmoResponse {
184    pub vmoid: VmoId,
185}
186
187impl fidl::Persistable for SessionAttachVmoResponse {}
188
189#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
190#[repr(C)]
191pub struct VmoId {
192    pub id: u16,
193}
194
195impl fidl::Persistable for VmoId {}
196
197mod internal {
198    use super::*;
199    unsafe impl fidl::encoding::TypeMarker for Flag {
200        type Owned = Self;
201
202        #[inline(always)]
203        fn inline_align(_context: fidl::encoding::Context) -> usize {
204            4
205        }
206
207        #[inline(always)]
208        fn inline_size(_context: fidl::encoding::Context) -> usize {
209            4
210        }
211    }
212
213    impl fidl::encoding::ValueTypeMarker for Flag {
214        type Borrowed<'a> = Self;
215        #[inline(always)]
216        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
217            *value
218        }
219    }
220
221    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Flag {
222        #[inline]
223        unsafe fn encode(
224            self,
225            encoder: &mut fidl::encoding::Encoder<'_, D>,
226            offset: usize,
227            _depth: fidl::encoding::Depth,
228        ) -> fidl::Result<()> {
229            encoder.debug_check_bounds::<Self>(offset);
230            if self.bits() & Self::all().bits() != self.bits() {
231                return Err(fidl::Error::InvalidBitsValue);
232            }
233            encoder.write_num(self.bits(), offset);
234            Ok(())
235        }
236    }
237
238    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Flag {
239        #[inline(always)]
240        fn new_empty() -> Self {
241            Self::empty()
242        }
243
244        #[inline]
245        unsafe fn decode(
246            &mut self,
247            decoder: &mut fidl::encoding::Decoder<'_, D>,
248            offset: usize,
249            _depth: fidl::encoding::Depth,
250        ) -> fidl::Result<()> {
251            decoder.debug_check_bounds::<Self>(offset);
252            let prim = decoder.read_num::<u32>(offset);
253            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
254            Ok(())
255        }
256    }
257
258    impl fidl::encoding::ValueTypeMarker for BlockGetStatsRequest {
259        type Borrowed<'a> = &'a Self;
260        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
261            value
262        }
263    }
264
265    unsafe impl fidl::encoding::TypeMarker for BlockGetStatsRequest {
266        type Owned = Self;
267
268        #[inline(always)]
269        fn inline_align(_context: fidl::encoding::Context) -> usize {
270            1
271        }
272
273        #[inline(always)]
274        fn inline_size(_context: fidl::encoding::Context) -> usize {
275            1
276        }
277    }
278
279    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockGetStatsRequest, D>
280        for &BlockGetStatsRequest
281    {
282        #[inline]
283        unsafe fn encode(
284            self,
285            encoder: &mut fidl::encoding::Encoder<'_, D>,
286            offset: usize,
287            _depth: fidl::encoding::Depth,
288        ) -> fidl::Result<()> {
289            encoder.debug_check_bounds::<BlockGetStatsRequest>(offset);
290            // Delegate to tuple encoding.
291            fidl::encoding::Encode::<BlockGetStatsRequest, D>::encode(
292                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.clear),),
293                encoder,
294                offset,
295                _depth,
296            )
297        }
298    }
299    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
300        fidl::encoding::Encode<BlockGetStatsRequest, D> for (T0,)
301    {
302        #[inline]
303        unsafe fn encode(
304            self,
305            encoder: &mut fidl::encoding::Encoder<'_, D>,
306            offset: usize,
307            depth: fidl::encoding::Depth,
308        ) -> fidl::Result<()> {
309            encoder.debug_check_bounds::<BlockGetStatsRequest>(offset);
310            // Zero out padding regions. There's no need to apply masks
311            // because the unmasked parts will be overwritten by fields.
312            // Write the fields.
313            self.0.encode(encoder, offset + 0, depth)?;
314            Ok(())
315        }
316    }
317
318    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockGetStatsRequest {
319        #[inline(always)]
320        fn new_empty() -> Self {
321            Self { clear: fidl::new_empty!(bool, D) }
322        }
323
324        #[inline]
325        unsafe fn decode(
326            &mut self,
327            decoder: &mut fidl::encoding::Decoder<'_, D>,
328            offset: usize,
329            _depth: fidl::encoding::Depth,
330        ) -> fidl::Result<()> {
331            decoder.debug_check_bounds::<Self>(offset);
332            // Verify that padding bytes are zero.
333            fidl::decode!(bool, D, &mut self.clear, decoder, offset + 0, _depth)?;
334            Ok(())
335        }
336    }
337
338    impl fidl::encoding::ValueTypeMarker for BlockInfo {
339        type Borrowed<'a> = &'a Self;
340        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
341            value
342        }
343    }
344
345    unsafe impl fidl::encoding::TypeMarker for BlockInfo {
346        type Owned = Self;
347
348        #[inline(always)]
349        fn inline_align(_context: fidl::encoding::Context) -> usize {
350            8
351        }
352
353        #[inline(always)]
354        fn inline_size(_context: fidl::encoding::Context) -> usize {
355            24
356        }
357    }
358
359    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockInfo, D>
360        for &BlockInfo
361    {
362        #[inline]
363        unsafe fn encode(
364            self,
365            encoder: &mut fidl::encoding::Encoder<'_, D>,
366            offset: usize,
367            _depth: fidl::encoding::Depth,
368        ) -> fidl::Result<()> {
369            encoder.debug_check_bounds::<BlockInfo>(offset);
370            // Delegate to tuple encoding.
371            fidl::encoding::Encode::<BlockInfo, D>::encode(
372                (
373                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.block_count),
374                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.block_size),
375                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.max_transfer_size),
376                    <Flag as fidl::encoding::ValueTypeMarker>::borrow(&self.flags),
377                ),
378                encoder,
379                offset,
380                _depth,
381            )
382        }
383    }
384    unsafe impl<
385            D: fidl::encoding::ResourceDialect,
386            T0: fidl::encoding::Encode<u64, D>,
387            T1: fidl::encoding::Encode<u32, D>,
388            T2: fidl::encoding::Encode<u32, D>,
389            T3: fidl::encoding::Encode<Flag, D>,
390        > fidl::encoding::Encode<BlockInfo, D> for (T0, T1, T2, T3)
391    {
392        #[inline]
393        unsafe fn encode(
394            self,
395            encoder: &mut fidl::encoding::Encoder<'_, D>,
396            offset: usize,
397            depth: fidl::encoding::Depth,
398        ) -> fidl::Result<()> {
399            encoder.debug_check_bounds::<BlockInfo>(offset);
400            // Zero out padding regions. There's no need to apply masks
401            // because the unmasked parts will be overwritten by fields.
402            unsafe {
403                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
404                (ptr as *mut u64).write_unaligned(0);
405            }
406            // Write the fields.
407            self.0.encode(encoder, offset + 0, depth)?;
408            self.1.encode(encoder, offset + 8, depth)?;
409            self.2.encode(encoder, offset + 12, depth)?;
410            self.3.encode(encoder, offset + 16, depth)?;
411            Ok(())
412        }
413    }
414
415    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockInfo {
416        #[inline(always)]
417        fn new_empty() -> Self {
418            Self {
419                block_count: fidl::new_empty!(u64, D),
420                block_size: fidl::new_empty!(u32, D),
421                max_transfer_size: fidl::new_empty!(u32, D),
422                flags: fidl::new_empty!(Flag, D),
423            }
424        }
425
426        #[inline]
427        unsafe fn decode(
428            &mut self,
429            decoder: &mut fidl::encoding::Decoder<'_, D>,
430            offset: usize,
431            _depth: fidl::encoding::Depth,
432        ) -> fidl::Result<()> {
433            decoder.debug_check_bounds::<Self>(offset);
434            // Verify that padding bytes are zero.
435            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
436            let padval = unsafe { (ptr as *const u64).read_unaligned() };
437            let mask = 0xffffffff00000000u64;
438            let maskedval = padval & mask;
439            if maskedval != 0 {
440                return Err(fidl::Error::NonZeroPadding {
441                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
442                });
443            }
444            fidl::decode!(u64, D, &mut self.block_count, decoder, offset + 0, _depth)?;
445            fidl::decode!(u32, D, &mut self.block_size, decoder, offset + 8, _depth)?;
446            fidl::decode!(u32, D, &mut self.max_transfer_size, decoder, offset + 12, _depth)?;
447            fidl::decode!(Flag, D, &mut self.flags, decoder, offset + 16, _depth)?;
448            Ok(())
449        }
450    }
451
452    impl fidl::encoding::ValueTypeMarker for BlockOffsetMapping {
453        type Borrowed<'a> = &'a Self;
454        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
455            value
456        }
457    }
458
459    unsafe impl fidl::encoding::TypeMarker for BlockOffsetMapping {
460        type Owned = Self;
461
462        #[inline(always)]
463        fn inline_align(_context: fidl::encoding::Context) -> usize {
464            8
465        }
466
467        #[inline(always)]
468        fn inline_size(_context: fidl::encoding::Context) -> usize {
469            24
470        }
471        #[inline(always)]
472        fn encode_is_copy() -> bool {
473            true
474        }
475
476        #[inline(always)]
477        fn decode_is_copy() -> bool {
478            true
479        }
480    }
481
482    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockOffsetMapping, D>
483        for &BlockOffsetMapping
484    {
485        #[inline]
486        unsafe fn encode(
487            self,
488            encoder: &mut fidl::encoding::Encoder<'_, D>,
489            offset: usize,
490            _depth: fidl::encoding::Depth,
491        ) -> fidl::Result<()> {
492            encoder.debug_check_bounds::<BlockOffsetMapping>(offset);
493            unsafe {
494                // Copy the object into the buffer.
495                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
496                (buf_ptr as *mut BlockOffsetMapping)
497                    .write_unaligned((self as *const BlockOffsetMapping).read());
498                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
499                // done second because the memcpy will write garbage to these bytes.
500            }
501            Ok(())
502        }
503    }
504    unsafe impl<
505            D: fidl::encoding::ResourceDialect,
506            T0: fidl::encoding::Encode<u64, D>,
507            T1: fidl::encoding::Encode<u64, D>,
508            T2: fidl::encoding::Encode<u64, D>,
509        > fidl::encoding::Encode<BlockOffsetMapping, D> for (T0, T1, T2)
510    {
511        #[inline]
512        unsafe fn encode(
513            self,
514            encoder: &mut fidl::encoding::Encoder<'_, D>,
515            offset: usize,
516            depth: fidl::encoding::Depth,
517        ) -> fidl::Result<()> {
518            encoder.debug_check_bounds::<BlockOffsetMapping>(offset);
519            // Zero out padding regions. There's no need to apply masks
520            // because the unmasked parts will be overwritten by fields.
521            // Write the fields.
522            self.0.encode(encoder, offset + 0, depth)?;
523            self.1.encode(encoder, offset + 8, depth)?;
524            self.2.encode(encoder, offset + 16, depth)?;
525            Ok(())
526        }
527    }
528
529    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockOffsetMapping {
530        #[inline(always)]
531        fn new_empty() -> Self {
532            Self {
533                source_block_offset: fidl::new_empty!(u64, D),
534                target_block_offset: fidl::new_empty!(u64, D),
535                length: fidl::new_empty!(u64, D),
536            }
537        }
538
539        #[inline]
540        unsafe fn decode(
541            &mut self,
542            decoder: &mut fidl::encoding::Decoder<'_, D>,
543            offset: usize,
544            _depth: fidl::encoding::Depth,
545        ) -> fidl::Result<()> {
546            decoder.debug_check_bounds::<Self>(offset);
547            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
548            // Verify that padding bytes are zero.
549            // Copy from the buffer into the object.
550            unsafe {
551                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 24);
552            }
553            Ok(())
554        }
555    }
556
557    impl fidl::encoding::ValueTypeMarker for BlockStats {
558        type Borrowed<'a> = &'a Self;
559        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
560            value
561        }
562    }
563
564    unsafe impl fidl::encoding::TypeMarker for BlockStats {
565        type Owned = Self;
566
567        #[inline(always)]
568        fn inline_align(_context: fidl::encoding::Context) -> usize {
569            8
570        }
571
572        #[inline(always)]
573        fn inline_size(_context: fidl::encoding::Context) -> usize {
574            320
575        }
576        #[inline(always)]
577        fn encode_is_copy() -> bool {
578            true
579        }
580
581        #[inline(always)]
582        fn decode_is_copy() -> bool {
583            true
584        }
585    }
586
587    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockStats, D>
588        for &BlockStats
589    {
590        #[inline]
591        unsafe fn encode(
592            self,
593            encoder: &mut fidl::encoding::Encoder<'_, D>,
594            offset: usize,
595            _depth: fidl::encoding::Depth,
596        ) -> fidl::Result<()> {
597            encoder.debug_check_bounds::<BlockStats>(offset);
598            unsafe {
599                // Copy the object into the buffer.
600                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
601                (buf_ptr as *mut BlockStats).write_unaligned((self as *const BlockStats).read());
602                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
603                // done second because the memcpy will write garbage to these bytes.
604            }
605            Ok(())
606        }
607    }
608    unsafe impl<
609            D: fidl::encoding::ResourceDialect,
610            T0: fidl::encoding::Encode<OperationStats, D>,
611            T1: fidl::encoding::Encode<OperationStats, D>,
612            T2: fidl::encoding::Encode<OperationStats, D>,
613            T3: fidl::encoding::Encode<OperationStats, D>,
614        > fidl::encoding::Encode<BlockStats, D> for (T0, T1, T2, T3)
615    {
616        #[inline]
617        unsafe fn encode(
618            self,
619            encoder: &mut fidl::encoding::Encoder<'_, D>,
620            offset: usize,
621            depth: fidl::encoding::Depth,
622        ) -> fidl::Result<()> {
623            encoder.debug_check_bounds::<BlockStats>(offset);
624            // Zero out padding regions. There's no need to apply masks
625            // because the unmasked parts will be overwritten by fields.
626            // Write the fields.
627            self.0.encode(encoder, offset + 0, depth)?;
628            self.1.encode(encoder, offset + 80, depth)?;
629            self.2.encode(encoder, offset + 160, depth)?;
630            self.3.encode(encoder, offset + 240, depth)?;
631            Ok(())
632        }
633    }
634
635    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockStats {
636        #[inline(always)]
637        fn new_empty() -> Self {
638            Self {
639                read: fidl::new_empty!(OperationStats, D),
640                write: fidl::new_empty!(OperationStats, D),
641                trim: fidl::new_empty!(OperationStats, D),
642                flush: fidl::new_empty!(OperationStats, D),
643            }
644        }
645
646        #[inline]
647        unsafe fn decode(
648            &mut self,
649            decoder: &mut fidl::encoding::Decoder<'_, D>,
650            offset: usize,
651            _depth: fidl::encoding::Depth,
652        ) -> fidl::Result<()> {
653            decoder.debug_check_bounds::<Self>(offset);
654            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
655            // Verify that padding bytes are zero.
656            // Copy from the buffer into the object.
657            unsafe {
658                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 320);
659            }
660            Ok(())
661        }
662    }
663
664    impl fidl::encoding::ValueTypeMarker for BlockGetInfoResponse {
665        type Borrowed<'a> = &'a Self;
666        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
667            value
668        }
669    }
670
671    unsafe impl fidl::encoding::TypeMarker for BlockGetInfoResponse {
672        type Owned = Self;
673
674        #[inline(always)]
675        fn inline_align(_context: fidl::encoding::Context) -> usize {
676            8
677        }
678
679        #[inline(always)]
680        fn inline_size(_context: fidl::encoding::Context) -> usize {
681            24
682        }
683    }
684
685    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockGetInfoResponse, D>
686        for &BlockGetInfoResponse
687    {
688        #[inline]
689        unsafe fn encode(
690            self,
691            encoder: &mut fidl::encoding::Encoder<'_, D>,
692            offset: usize,
693            _depth: fidl::encoding::Depth,
694        ) -> fidl::Result<()> {
695            encoder.debug_check_bounds::<BlockGetInfoResponse>(offset);
696            // Delegate to tuple encoding.
697            fidl::encoding::Encode::<BlockGetInfoResponse, D>::encode(
698                (<BlockInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
699                encoder,
700                offset,
701                _depth,
702            )
703        }
704    }
705    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlockInfo, D>>
706        fidl::encoding::Encode<BlockGetInfoResponse, D> for (T0,)
707    {
708        #[inline]
709        unsafe fn encode(
710            self,
711            encoder: &mut fidl::encoding::Encoder<'_, D>,
712            offset: usize,
713            depth: fidl::encoding::Depth,
714        ) -> fidl::Result<()> {
715            encoder.debug_check_bounds::<BlockGetInfoResponse>(offset);
716            // Zero out padding regions. There's no need to apply masks
717            // because the unmasked parts will be overwritten by fields.
718            // Write the fields.
719            self.0.encode(encoder, offset + 0, depth)?;
720            Ok(())
721        }
722    }
723
724    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockGetInfoResponse {
725        #[inline(always)]
726        fn new_empty() -> Self {
727            Self { info: fidl::new_empty!(BlockInfo, D) }
728        }
729
730        #[inline]
731        unsafe fn decode(
732            &mut self,
733            decoder: &mut fidl::encoding::Decoder<'_, D>,
734            offset: usize,
735            _depth: fidl::encoding::Depth,
736        ) -> fidl::Result<()> {
737            decoder.debug_check_bounds::<Self>(offset);
738            // Verify that padding bytes are zero.
739            fidl::decode!(BlockInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
740            Ok(())
741        }
742    }
743
744    impl fidl::encoding::ValueTypeMarker for BlockGetStatsResponse {
745        type Borrowed<'a> = &'a Self;
746        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
747            value
748        }
749    }
750
751    unsafe impl fidl::encoding::TypeMarker for BlockGetStatsResponse {
752        type Owned = Self;
753
754        #[inline(always)]
755        fn inline_align(_context: fidl::encoding::Context) -> usize {
756            8
757        }
758
759        #[inline(always)]
760        fn inline_size(_context: fidl::encoding::Context) -> usize {
761            320
762        }
763        #[inline(always)]
764        fn encode_is_copy() -> bool {
765            true
766        }
767
768        #[inline(always)]
769        fn decode_is_copy() -> bool {
770            true
771        }
772    }
773
774    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlockGetStatsResponse, D>
775        for &BlockGetStatsResponse
776    {
777        #[inline]
778        unsafe fn encode(
779            self,
780            encoder: &mut fidl::encoding::Encoder<'_, D>,
781            offset: usize,
782            _depth: fidl::encoding::Depth,
783        ) -> fidl::Result<()> {
784            encoder.debug_check_bounds::<BlockGetStatsResponse>(offset);
785            unsafe {
786                // Copy the object into the buffer.
787                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
788                (buf_ptr as *mut BlockGetStatsResponse)
789                    .write_unaligned((self as *const BlockGetStatsResponse).read());
790                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
791                // done second because the memcpy will write garbage to these bytes.
792            }
793            Ok(())
794        }
795    }
796    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlockStats, D>>
797        fidl::encoding::Encode<BlockGetStatsResponse, D> for (T0,)
798    {
799        #[inline]
800        unsafe fn encode(
801            self,
802            encoder: &mut fidl::encoding::Encoder<'_, D>,
803            offset: usize,
804            depth: fidl::encoding::Depth,
805        ) -> fidl::Result<()> {
806            encoder.debug_check_bounds::<BlockGetStatsResponse>(offset);
807            // Zero out padding regions. There's no need to apply masks
808            // because the unmasked parts will be overwritten by fields.
809            // Write the fields.
810            self.0.encode(encoder, offset + 0, depth)?;
811            Ok(())
812        }
813    }
814
815    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlockGetStatsResponse {
816        #[inline(always)]
817        fn new_empty() -> Self {
818            Self { stats: fidl::new_empty!(BlockStats, D) }
819        }
820
821        #[inline]
822        unsafe fn decode(
823            &mut self,
824            decoder: &mut fidl::encoding::Decoder<'_, D>,
825            offset: usize,
826            _depth: fidl::encoding::Depth,
827        ) -> fidl::Result<()> {
828            decoder.debug_check_bounds::<Self>(offset);
829            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
830            // Verify that padding bytes are zero.
831            // Copy from the buffer into the object.
832            unsafe {
833                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 320);
834            }
835            Ok(())
836        }
837    }
838
839    impl fidl::encoding::ValueTypeMarker for FtlFormatResponse {
840        type Borrowed<'a> = &'a Self;
841        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
842            value
843        }
844    }
845
846    unsafe impl fidl::encoding::TypeMarker for FtlFormatResponse {
847        type Owned = Self;
848
849        #[inline(always)]
850        fn inline_align(_context: fidl::encoding::Context) -> usize {
851            4
852        }
853
854        #[inline(always)]
855        fn inline_size(_context: fidl::encoding::Context) -> usize {
856            4
857        }
858        #[inline(always)]
859        fn encode_is_copy() -> bool {
860            true
861        }
862
863        #[inline(always)]
864        fn decode_is_copy() -> bool {
865            true
866        }
867    }
868
869    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FtlFormatResponse, D>
870        for &FtlFormatResponse
871    {
872        #[inline]
873        unsafe fn encode(
874            self,
875            encoder: &mut fidl::encoding::Encoder<'_, D>,
876            offset: usize,
877            _depth: fidl::encoding::Depth,
878        ) -> fidl::Result<()> {
879            encoder.debug_check_bounds::<FtlFormatResponse>(offset);
880            unsafe {
881                // Copy the object into the buffer.
882                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
883                (buf_ptr as *mut FtlFormatResponse)
884                    .write_unaligned((self as *const FtlFormatResponse).read());
885                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
886                // done second because the memcpy will write garbage to these bytes.
887            }
888            Ok(())
889        }
890    }
891    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
892        fidl::encoding::Encode<FtlFormatResponse, D> for (T0,)
893    {
894        #[inline]
895        unsafe fn encode(
896            self,
897            encoder: &mut fidl::encoding::Encoder<'_, D>,
898            offset: usize,
899            depth: fidl::encoding::Depth,
900        ) -> fidl::Result<()> {
901            encoder.debug_check_bounds::<FtlFormatResponse>(offset);
902            // Zero out padding regions. There's no need to apply masks
903            // because the unmasked parts will be overwritten by fields.
904            // Write the fields.
905            self.0.encode(encoder, offset + 0, depth)?;
906            Ok(())
907        }
908    }
909
910    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FtlFormatResponse {
911        #[inline(always)]
912        fn new_empty() -> Self {
913            Self { status: fidl::new_empty!(i32, D) }
914        }
915
916        #[inline]
917        unsafe fn decode(
918            &mut self,
919            decoder: &mut fidl::encoding::Decoder<'_, D>,
920            offset: usize,
921            _depth: fidl::encoding::Depth,
922        ) -> fidl::Result<()> {
923            decoder.debug_check_bounds::<Self>(offset);
924            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
925            // Verify that padding bytes are zero.
926            // Copy from the buffer into the object.
927            unsafe {
928                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
929            }
930            Ok(())
931        }
932    }
933
934    impl fidl::encoding::ValueTypeMarker for OffsetMapQueryRequest {
935        type Borrowed<'a> = &'a Self;
936        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
937            value
938        }
939    }
940
941    unsafe impl fidl::encoding::TypeMarker for OffsetMapQueryRequest {
942        type Owned = Self;
943
944        #[inline(always)]
945        fn inline_align(_context: fidl::encoding::Context) -> usize {
946            8
947        }
948
949        #[inline(always)]
950        fn inline_size(_context: fidl::encoding::Context) -> usize {
951            16
952        }
953        #[inline(always)]
954        fn encode_is_copy() -> bool {
955            true
956        }
957
958        #[inline(always)]
959        fn decode_is_copy() -> bool {
960            true
961        }
962    }
963
964    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OffsetMapQueryRequest, D>
965        for &OffsetMapQueryRequest
966    {
967        #[inline]
968        unsafe fn encode(
969            self,
970            encoder: &mut fidl::encoding::Encoder<'_, D>,
971            offset: usize,
972            _depth: fidl::encoding::Depth,
973        ) -> fidl::Result<()> {
974            encoder.debug_check_bounds::<OffsetMapQueryRequest>(offset);
975            unsafe {
976                // Copy the object into the buffer.
977                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
978                (buf_ptr as *mut OffsetMapQueryRequest)
979                    .write_unaligned((self as *const OffsetMapQueryRequest).read());
980                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
981                // done second because the memcpy will write garbage to these bytes.
982            }
983            Ok(())
984        }
985    }
986    unsafe impl<
987            D: fidl::encoding::ResourceDialect,
988            T0: fidl::encoding::Encode<u64, D>,
989            T1: fidl::encoding::Encode<u64, D>,
990        > fidl::encoding::Encode<OffsetMapQueryRequest, D> for (T0, T1)
991    {
992        #[inline]
993        unsafe fn encode(
994            self,
995            encoder: &mut fidl::encoding::Encoder<'_, D>,
996            offset: usize,
997            depth: fidl::encoding::Depth,
998        ) -> fidl::Result<()> {
999            encoder.debug_check_bounds::<OffsetMapQueryRequest>(offset);
1000            // Zero out padding regions. There's no need to apply masks
1001            // because the unmasked parts will be overwritten by fields.
1002            // Write the fields.
1003            self.0.encode(encoder, offset + 0, depth)?;
1004            self.1.encode(encoder, offset + 8, depth)?;
1005            Ok(())
1006        }
1007    }
1008
1009    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OffsetMapQueryRequest {
1010        #[inline(always)]
1011        fn new_empty() -> Self {
1012            Self { source_block_offset: fidl::new_empty!(u64, D), length: fidl::new_empty!(u64, D) }
1013        }
1014
1015        #[inline]
1016        unsafe fn decode(
1017            &mut self,
1018            decoder: &mut fidl::encoding::Decoder<'_, D>,
1019            offset: usize,
1020            _depth: fidl::encoding::Depth,
1021        ) -> fidl::Result<()> {
1022            decoder.debug_check_bounds::<Self>(offset);
1023            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1024            // Verify that padding bytes are zero.
1025            // Copy from the buffer into the object.
1026            unsafe {
1027                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
1028            }
1029            Ok(())
1030        }
1031    }
1032
1033    impl fidl::encoding::ValueTypeMarker for OffsetMapQueryResponse {
1034        type Borrowed<'a> = &'a Self;
1035        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1036            value
1037        }
1038    }
1039
1040    unsafe impl fidl::encoding::TypeMarker for OffsetMapQueryResponse {
1041        type Owned = Self;
1042
1043        #[inline(always)]
1044        fn inline_align(_context: fidl::encoding::Context) -> usize {
1045            8
1046        }
1047
1048        #[inline(always)]
1049        fn inline_size(_context: fidl::encoding::Context) -> usize {
1050            16
1051        }
1052    }
1053
1054    unsafe impl<D: fidl::encoding::ResourceDialect>
1055        fidl::encoding::Encode<OffsetMapQueryResponse, D> for &OffsetMapQueryResponse
1056    {
1057        #[inline]
1058        unsafe fn encode(
1059            self,
1060            encoder: &mut fidl::encoding::Encoder<'_, D>,
1061            offset: usize,
1062            _depth: fidl::encoding::Depth,
1063        ) -> fidl::Result<()> {
1064            encoder.debug_check_bounds::<OffsetMapQueryResponse>(offset);
1065            // Delegate to tuple encoding.
1066            fidl::encoding::Encode::<OffsetMapQueryResponse, D>::encode(
1067                (
1068                    <fidl::encoding::Vector<BlockOffsetMapping, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.mappings),
1069                ),
1070                encoder, offset, _depth
1071            )
1072        }
1073    }
1074    unsafe impl<
1075            D: fidl::encoding::ResourceDialect,
1076            T0: fidl::encoding::Encode<fidl::encoding::Vector<BlockOffsetMapping, 64>, D>,
1077        > fidl::encoding::Encode<OffsetMapQueryResponse, D> for (T0,)
1078    {
1079        #[inline]
1080        unsafe fn encode(
1081            self,
1082            encoder: &mut fidl::encoding::Encoder<'_, D>,
1083            offset: usize,
1084            depth: fidl::encoding::Depth,
1085        ) -> fidl::Result<()> {
1086            encoder.debug_check_bounds::<OffsetMapQueryResponse>(offset);
1087            // Zero out padding regions. There's no need to apply masks
1088            // because the unmasked parts will be overwritten by fields.
1089            // Write the fields.
1090            self.0.encode(encoder, offset + 0, depth)?;
1091            Ok(())
1092        }
1093    }
1094
1095    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1096        for OffsetMapQueryResponse
1097    {
1098        #[inline(always)]
1099        fn new_empty() -> Self {
1100            Self { mappings: fidl::new_empty!(fidl::encoding::Vector<BlockOffsetMapping, 64>, D) }
1101        }
1102
1103        #[inline]
1104        unsafe fn decode(
1105            &mut self,
1106            decoder: &mut fidl::encoding::Decoder<'_, D>,
1107            offset: usize,
1108            _depth: fidl::encoding::Depth,
1109        ) -> fidl::Result<()> {
1110            decoder.debug_check_bounds::<Self>(offset);
1111            // Verify that padding bytes are zero.
1112            fidl::decode!(fidl::encoding::Vector<BlockOffsetMapping, 64>, D, &mut self.mappings, decoder, offset + 0, _depth)?;
1113            Ok(())
1114        }
1115    }
1116
1117    impl fidl::encoding::ValueTypeMarker for OperationStats {
1118        type Borrowed<'a> = &'a Self;
1119        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1120            value
1121        }
1122    }
1123
1124    unsafe impl fidl::encoding::TypeMarker for OperationStats {
1125        type Owned = Self;
1126
1127        #[inline(always)]
1128        fn inline_align(_context: fidl::encoding::Context) -> usize {
1129            8
1130        }
1131
1132        #[inline(always)]
1133        fn inline_size(_context: fidl::encoding::Context) -> usize {
1134            80
1135        }
1136        #[inline(always)]
1137        fn encode_is_copy() -> bool {
1138            true
1139        }
1140
1141        #[inline(always)]
1142        fn decode_is_copy() -> bool {
1143            true
1144        }
1145    }
1146
1147    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OperationStats, D>
1148        for &OperationStats
1149    {
1150        #[inline]
1151        unsafe fn encode(
1152            self,
1153            encoder: &mut fidl::encoding::Encoder<'_, D>,
1154            offset: usize,
1155            _depth: fidl::encoding::Depth,
1156        ) -> fidl::Result<()> {
1157            encoder.debug_check_bounds::<OperationStats>(offset);
1158            unsafe {
1159                // Copy the object into the buffer.
1160                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1161                (buf_ptr as *mut OperationStats)
1162                    .write_unaligned((self as *const OperationStats).read());
1163                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1164                // done second because the memcpy will write garbage to these bytes.
1165            }
1166            Ok(())
1167        }
1168    }
1169    unsafe impl<
1170            D: fidl::encoding::ResourceDialect,
1171            T0: fidl::encoding::Encode<RequestStats, D>,
1172            T1: fidl::encoding::Encode<RequestStats, D>,
1173        > fidl::encoding::Encode<OperationStats, D> for (T0, T1)
1174    {
1175        #[inline]
1176        unsafe fn encode(
1177            self,
1178            encoder: &mut fidl::encoding::Encoder<'_, D>,
1179            offset: usize,
1180            depth: fidl::encoding::Depth,
1181        ) -> fidl::Result<()> {
1182            encoder.debug_check_bounds::<OperationStats>(offset);
1183            // Zero out padding regions. There's no need to apply masks
1184            // because the unmasked parts will be overwritten by fields.
1185            // Write the fields.
1186            self.0.encode(encoder, offset + 0, depth)?;
1187            self.1.encode(encoder, offset + 40, depth)?;
1188            Ok(())
1189        }
1190    }
1191
1192    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OperationStats {
1193        #[inline(always)]
1194        fn new_empty() -> Self {
1195            Self {
1196                success: fidl::new_empty!(RequestStats, D),
1197                failure: fidl::new_empty!(RequestStats, D),
1198            }
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            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1210            // Verify that padding bytes are zero.
1211            // Copy from the buffer into the object.
1212            unsafe {
1213                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 80);
1214            }
1215            Ok(())
1216        }
1217    }
1218
1219    impl fidl::encoding::ValueTypeMarker for RequestStats {
1220        type Borrowed<'a> = &'a Self;
1221        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1222            value
1223        }
1224    }
1225
1226    unsafe impl fidl::encoding::TypeMarker for RequestStats {
1227        type Owned = Self;
1228
1229        #[inline(always)]
1230        fn inline_align(_context: fidl::encoding::Context) -> usize {
1231            8
1232        }
1233
1234        #[inline(always)]
1235        fn inline_size(_context: fidl::encoding::Context) -> usize {
1236            40
1237        }
1238        #[inline(always)]
1239        fn encode_is_copy() -> bool {
1240            true
1241        }
1242
1243        #[inline(always)]
1244        fn decode_is_copy() -> bool {
1245            true
1246        }
1247    }
1248
1249    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RequestStats, D>
1250        for &RequestStats
1251    {
1252        #[inline]
1253        unsafe fn encode(
1254            self,
1255            encoder: &mut fidl::encoding::Encoder<'_, D>,
1256            offset: usize,
1257            _depth: fidl::encoding::Depth,
1258        ) -> fidl::Result<()> {
1259            encoder.debug_check_bounds::<RequestStats>(offset);
1260            unsafe {
1261                // Copy the object into the buffer.
1262                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1263                (buf_ptr as *mut RequestStats)
1264                    .write_unaligned((self as *const RequestStats).read());
1265                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1266                // done second because the memcpy will write garbage to these bytes.
1267            }
1268            Ok(())
1269        }
1270    }
1271    unsafe impl<
1272            D: fidl::encoding::ResourceDialect,
1273            T0: fidl::encoding::Encode<u64, D>,
1274            T1: fidl::encoding::Encode<u64, D>,
1275            T2: fidl::encoding::Encode<u64, D>,
1276            T3: fidl::encoding::Encode<u64, D>,
1277            T4: fidl::encoding::Encode<u64, D>,
1278        > fidl::encoding::Encode<RequestStats, D> for (T0, T1, T2, T3, T4)
1279    {
1280        #[inline]
1281        unsafe fn encode(
1282            self,
1283            encoder: &mut fidl::encoding::Encoder<'_, D>,
1284            offset: usize,
1285            depth: fidl::encoding::Depth,
1286        ) -> fidl::Result<()> {
1287            encoder.debug_check_bounds::<RequestStats>(offset);
1288            // Zero out padding regions. There's no need to apply masks
1289            // because the unmasked parts will be overwritten by fields.
1290            // Write the fields.
1291            self.0.encode(encoder, offset + 0, depth)?;
1292            self.1.encode(encoder, offset + 8, depth)?;
1293            self.2.encode(encoder, offset + 16, depth)?;
1294            self.3.encode(encoder, offset + 24, depth)?;
1295            self.4.encode(encoder, offset + 32, depth)?;
1296            Ok(())
1297        }
1298    }
1299
1300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RequestStats {
1301        #[inline(always)]
1302        fn new_empty() -> Self {
1303            Self {
1304                minimum_latency: fidl::new_empty!(u64, D),
1305                maximum_latency: fidl::new_empty!(u64, D),
1306                total_time_spent: fidl::new_empty!(u64, D),
1307                total_calls: fidl::new_empty!(u64, D),
1308                bytes_transferred: fidl::new_empty!(u64, D),
1309            }
1310        }
1311
1312        #[inline]
1313        unsafe fn decode(
1314            &mut self,
1315            decoder: &mut fidl::encoding::Decoder<'_, D>,
1316            offset: usize,
1317            _depth: fidl::encoding::Depth,
1318        ) -> fidl::Result<()> {
1319            decoder.debug_check_bounds::<Self>(offset);
1320            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1321            // Verify that padding bytes are zero.
1322            // Copy from the buffer into the object.
1323            unsafe {
1324                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
1325            }
1326            Ok(())
1327        }
1328    }
1329
1330    impl fidl::encoding::ValueTypeMarker for SessionAttachVmoResponse {
1331        type Borrowed<'a> = &'a Self;
1332        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1333            value
1334        }
1335    }
1336
1337    unsafe impl fidl::encoding::TypeMarker for SessionAttachVmoResponse {
1338        type Owned = Self;
1339
1340        #[inline(always)]
1341        fn inline_align(_context: fidl::encoding::Context) -> usize {
1342            2
1343        }
1344
1345        #[inline(always)]
1346        fn inline_size(_context: fidl::encoding::Context) -> usize {
1347            2
1348        }
1349        #[inline(always)]
1350        fn encode_is_copy() -> bool {
1351            true
1352        }
1353
1354        #[inline(always)]
1355        fn decode_is_copy() -> bool {
1356            true
1357        }
1358    }
1359
1360    unsafe impl<D: fidl::encoding::ResourceDialect>
1361        fidl::encoding::Encode<SessionAttachVmoResponse, D> for &SessionAttachVmoResponse
1362    {
1363        #[inline]
1364        unsafe fn encode(
1365            self,
1366            encoder: &mut fidl::encoding::Encoder<'_, D>,
1367            offset: usize,
1368            _depth: fidl::encoding::Depth,
1369        ) -> fidl::Result<()> {
1370            encoder.debug_check_bounds::<SessionAttachVmoResponse>(offset);
1371            unsafe {
1372                // Copy the object into the buffer.
1373                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1374                (buf_ptr as *mut SessionAttachVmoResponse)
1375                    .write_unaligned((self as *const SessionAttachVmoResponse).read());
1376                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1377                // done second because the memcpy will write garbage to these bytes.
1378            }
1379            Ok(())
1380        }
1381    }
1382    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<VmoId, D>>
1383        fidl::encoding::Encode<SessionAttachVmoResponse, D> for (T0,)
1384    {
1385        #[inline]
1386        unsafe fn encode(
1387            self,
1388            encoder: &mut fidl::encoding::Encoder<'_, D>,
1389            offset: usize,
1390            depth: fidl::encoding::Depth,
1391        ) -> fidl::Result<()> {
1392            encoder.debug_check_bounds::<SessionAttachVmoResponse>(offset);
1393            // Zero out padding regions. There's no need to apply masks
1394            // because the unmasked parts will be overwritten by fields.
1395            // Write the fields.
1396            self.0.encode(encoder, offset + 0, depth)?;
1397            Ok(())
1398        }
1399    }
1400
1401    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1402        for SessionAttachVmoResponse
1403    {
1404        #[inline(always)]
1405        fn new_empty() -> Self {
1406            Self { vmoid: fidl::new_empty!(VmoId, D) }
1407        }
1408
1409        #[inline]
1410        unsafe fn decode(
1411            &mut self,
1412            decoder: &mut fidl::encoding::Decoder<'_, D>,
1413            offset: usize,
1414            _depth: fidl::encoding::Depth,
1415        ) -> fidl::Result<()> {
1416            decoder.debug_check_bounds::<Self>(offset);
1417            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1418            // Verify that padding bytes are zero.
1419            // Copy from the buffer into the object.
1420            unsafe {
1421                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1422            }
1423            Ok(())
1424        }
1425    }
1426
1427    impl fidl::encoding::ValueTypeMarker for VmoId {
1428        type Borrowed<'a> = &'a Self;
1429        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1430            value
1431        }
1432    }
1433
1434    unsafe impl fidl::encoding::TypeMarker for VmoId {
1435        type Owned = Self;
1436
1437        #[inline(always)]
1438        fn inline_align(_context: fidl::encoding::Context) -> usize {
1439            2
1440        }
1441
1442        #[inline(always)]
1443        fn inline_size(_context: fidl::encoding::Context) -> usize {
1444            2
1445        }
1446        #[inline(always)]
1447        fn encode_is_copy() -> bool {
1448            true
1449        }
1450
1451        #[inline(always)]
1452        fn decode_is_copy() -> bool {
1453            true
1454        }
1455    }
1456
1457    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<VmoId, D> for &VmoId {
1458        #[inline]
1459        unsafe fn encode(
1460            self,
1461            encoder: &mut fidl::encoding::Encoder<'_, D>,
1462            offset: usize,
1463            _depth: fidl::encoding::Depth,
1464        ) -> fidl::Result<()> {
1465            encoder.debug_check_bounds::<VmoId>(offset);
1466            unsafe {
1467                // Copy the object into the buffer.
1468                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1469                (buf_ptr as *mut VmoId).write_unaligned((self as *const VmoId).read());
1470                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1471                // done second because the memcpy will write garbage to these bytes.
1472            }
1473            Ok(())
1474        }
1475    }
1476    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
1477        fidl::encoding::Encode<VmoId, D> for (T0,)
1478    {
1479        #[inline]
1480        unsafe fn encode(
1481            self,
1482            encoder: &mut fidl::encoding::Encoder<'_, D>,
1483            offset: usize,
1484            depth: fidl::encoding::Depth,
1485        ) -> fidl::Result<()> {
1486            encoder.debug_check_bounds::<VmoId>(offset);
1487            // Zero out padding regions. There's no need to apply masks
1488            // because the unmasked parts will be overwritten by fields.
1489            // Write the fields.
1490            self.0.encode(encoder, offset + 0, depth)?;
1491            Ok(())
1492        }
1493    }
1494
1495    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for VmoId {
1496        #[inline(always)]
1497        fn new_empty() -> Self {
1498            Self { id: fidl::new_empty!(u16, D) }
1499        }
1500
1501        #[inline]
1502        unsafe fn decode(
1503            &mut self,
1504            decoder: &mut fidl::encoding::Decoder<'_, D>,
1505            offset: usize,
1506            _depth: fidl::encoding::Depth,
1507        ) -> fidl::Result<()> {
1508            decoder.debug_check_bounds::<Self>(offset);
1509            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1510            // Verify that padding bytes are zero.
1511            // Copy from the buffer into the object.
1512            unsafe {
1513                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
1514            }
1515            Ok(())
1516        }
1517    }
1518}
fidl_fuchsia_hardware_block_common/fidl_fuchsia_hardware_block_common.rs

fidl_fuchsia_hardware_block_common/
fidl_fuchsia_hardware_block_common.rs
