fidl_fuchsia_driver_crash__common/
fidl_fuchsia_driver_crash__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
11#[derive(Clone, Debug, PartialEq)]
12pub struct CrashIntrospectFindDriverCrashResponse {
13    pub info: DriverCrashInfo,
14}
15
16impl fidl::Persistable for CrashIntrospectFindDriverCrashResponse {}
17
18/// Information stored when a thread crashes.
19#[derive(Clone, Debug, Default, PartialEq)]
20pub struct DriverCrashInfo {
21    pub url: Option<String>,
22    pub node_moniker: Option<String>,
23    #[doc(hidden)]
24    pub __source_breaking: fidl::marker::SourceBreaking,
25}
26
27impl fidl::Persistable for DriverCrashInfo {}
28
29pub mod crash_introspect_ordinals {
30    pub const FIND_DRIVER_CRASH: u64 = 0x41237ffcc46267bc;
31}
32
33mod internal {
34    use super::*;
35
36    impl fidl::encoding::ValueTypeMarker for CrashIntrospectFindDriverCrashResponse {
37        type Borrowed<'a> = &'a Self;
38        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
39            value
40        }
41    }
42
43    unsafe impl fidl::encoding::TypeMarker for CrashIntrospectFindDriverCrashResponse {
44        type Owned = Self;
45
46        #[inline(always)]
47        fn inline_align(_context: fidl::encoding::Context) -> usize {
48            8
49        }
50
51        #[inline(always)]
52        fn inline_size(_context: fidl::encoding::Context) -> usize {
53            16
54        }
55    }
56
57    unsafe impl<D: fidl::encoding::ResourceDialect>
58        fidl::encoding::Encode<CrashIntrospectFindDriverCrashResponse, D>
59        for &CrashIntrospectFindDriverCrashResponse
60    {
61        #[inline]
62        unsafe fn encode(
63            self,
64            encoder: &mut fidl::encoding::Encoder<'_, D>,
65            offset: usize,
66            _depth: fidl::encoding::Depth,
67        ) -> fidl::Result<()> {
68            encoder.debug_check_bounds::<CrashIntrospectFindDriverCrashResponse>(offset);
69            // Delegate to tuple encoding.
70            fidl::encoding::Encode::<CrashIntrospectFindDriverCrashResponse, D>::encode(
71                (<DriverCrashInfo as fidl::encoding::ValueTypeMarker>::borrow(&self.info),),
72                encoder,
73                offset,
74                _depth,
75            )
76        }
77    }
78    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DriverCrashInfo, D>>
79        fidl::encoding::Encode<CrashIntrospectFindDriverCrashResponse, D> for (T0,)
80    {
81        #[inline]
82        unsafe fn encode(
83            self,
84            encoder: &mut fidl::encoding::Encoder<'_, D>,
85            offset: usize,
86            depth: fidl::encoding::Depth,
87        ) -> fidl::Result<()> {
88            encoder.debug_check_bounds::<CrashIntrospectFindDriverCrashResponse>(offset);
89            // Zero out padding regions. There's no need to apply masks
90            // because the unmasked parts will be overwritten by fields.
91            // Write the fields.
92            self.0.encode(encoder, offset + 0, depth)?;
93            Ok(())
94        }
95    }
96
97    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
98        for CrashIntrospectFindDriverCrashResponse
99    {
100        #[inline(always)]
101        fn new_empty() -> Self {
102            Self { info: fidl::new_empty!(DriverCrashInfo, D) }
103        }
104
105        #[inline]
106        unsafe fn decode(
107            &mut self,
108            decoder: &mut fidl::encoding::Decoder<'_, D>,
109            offset: usize,
110            _depth: fidl::encoding::Depth,
111        ) -> fidl::Result<()> {
112            decoder.debug_check_bounds::<Self>(offset);
113            // Verify that padding bytes are zero.
114            fidl::decode!(DriverCrashInfo, D, &mut self.info, decoder, offset + 0, _depth)?;
115            Ok(())
116        }
117    }
118
119    impl DriverCrashInfo {
120        #[inline(always)]
121        fn max_ordinal_present(&self) -> u64 {
122            if let Some(_) = self.node_moniker {
123                return 2;
124            }
125            if let Some(_) = self.url {
126                return 1;
127            }
128            0
129        }
130    }
131
132    impl fidl::encoding::ValueTypeMarker for DriverCrashInfo {
133        type Borrowed<'a> = &'a Self;
134        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
135            value
136        }
137    }
138
139    unsafe impl fidl::encoding::TypeMarker for DriverCrashInfo {
140        type Owned = Self;
141
142        #[inline(always)]
143        fn inline_align(_context: fidl::encoding::Context) -> usize {
144            8
145        }
146
147        #[inline(always)]
148        fn inline_size(_context: fidl::encoding::Context) -> usize {
149            16
150        }
151    }
152
153    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DriverCrashInfo, D>
154        for &DriverCrashInfo
155    {
156        unsafe fn encode(
157            self,
158            encoder: &mut fidl::encoding::Encoder<'_, D>,
159            offset: usize,
160            mut depth: fidl::encoding::Depth,
161        ) -> fidl::Result<()> {
162            encoder.debug_check_bounds::<DriverCrashInfo>(offset);
163            // Vector header
164            let max_ordinal: u64 = self.max_ordinal_present();
165            encoder.write_num(max_ordinal, offset);
166            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
167            // Calling encoder.out_of_line_offset(0) is not allowed.
168            if max_ordinal == 0 {
169                return Ok(());
170            }
171            depth.increment()?;
172            let envelope_size = 8;
173            let bytes_len = max_ordinal as usize * envelope_size;
174            #[allow(unused_variables)]
175            let offset = encoder.out_of_line_offset(bytes_len);
176            let mut _prev_end_offset: usize = 0;
177            if 1 > max_ordinal {
178                return Ok(());
179            }
180
181            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
182            // are envelope_size bytes.
183            let cur_offset: usize = (1 - 1) * envelope_size;
184
185            // Zero reserved fields.
186            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
187
188            // Safety:
189            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
190            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
191            //   envelope_size bytes, there is always sufficient room.
192            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
193            self.url.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
194            encoder, offset + cur_offset, depth
195        )?;
196
197            _prev_end_offset = cur_offset + envelope_size;
198            if 2 > max_ordinal {
199                return Ok(());
200            }
201
202            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
203            // are envelope_size bytes.
204            let cur_offset: usize = (2 - 1) * envelope_size;
205
206            // Zero reserved fields.
207            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
208
209            // Safety:
210            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
211            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
212            //   envelope_size bytes, there is always sufficient room.
213            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<4096>, D>(
214            self.node_moniker.as_ref().map(<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow),
215            encoder, offset + cur_offset, depth
216        )?;
217
218            _prev_end_offset = cur_offset + envelope_size;
219
220            Ok(())
221        }
222    }
223
224    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DriverCrashInfo {
225        #[inline(always)]
226        fn new_empty() -> Self {
227            Self::default()
228        }
229
230        unsafe fn decode(
231            &mut self,
232            decoder: &mut fidl::encoding::Decoder<'_, D>,
233            offset: usize,
234            mut depth: fidl::encoding::Depth,
235        ) -> fidl::Result<()> {
236            decoder.debug_check_bounds::<Self>(offset);
237            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
238                None => return Err(fidl::Error::NotNullable),
239                Some(len) => len,
240            };
241            // Calling decoder.out_of_line_offset(0) is not allowed.
242            if len == 0 {
243                return Ok(());
244            };
245            depth.increment()?;
246            let envelope_size = 8;
247            let bytes_len = len * envelope_size;
248            let offset = decoder.out_of_line_offset(bytes_len)?;
249            // Decode the envelope for each type.
250            let mut _next_ordinal_to_read = 0;
251            let mut next_offset = offset;
252            let end_offset = offset + bytes_len;
253            _next_ordinal_to_read += 1;
254            if next_offset >= end_offset {
255                return Ok(());
256            }
257
258            // Decode unknown envelopes for gaps in ordinals.
259            while _next_ordinal_to_read < 1 {
260                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
261                _next_ordinal_to_read += 1;
262                next_offset += envelope_size;
263            }
264
265            let next_out_of_line = decoder.next_out_of_line();
266            let handles_before = decoder.remaining_handles();
267            if let Some((inlined, num_bytes, num_handles)) =
268                fidl::encoding::decode_envelope_header(decoder, next_offset)?
269            {
270                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
271                if inlined != (member_inline_size <= 4) {
272                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
273                }
274                let inner_offset;
275                let mut inner_depth = depth.clone();
276                if inlined {
277                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
278                    inner_offset = next_offset;
279                } else {
280                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
281                    inner_depth.increment()?;
282                }
283                let val_ref = self.url.get_or_insert_with(|| {
284                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
285                });
286                fidl::decode!(
287                    fidl::encoding::BoundedString<4096>,
288                    D,
289                    val_ref,
290                    decoder,
291                    inner_offset,
292                    inner_depth
293                )?;
294                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
295                {
296                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
297                }
298                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
299                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
300                }
301            }
302
303            next_offset += envelope_size;
304            _next_ordinal_to_read += 1;
305            if next_offset >= end_offset {
306                return Ok(());
307            }
308
309            // Decode unknown envelopes for gaps in ordinals.
310            while _next_ordinal_to_read < 2 {
311                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
312                _next_ordinal_to_read += 1;
313                next_offset += envelope_size;
314            }
315
316            let next_out_of_line = decoder.next_out_of_line();
317            let handles_before = decoder.remaining_handles();
318            if let Some((inlined, num_bytes, num_handles)) =
319                fidl::encoding::decode_envelope_header(decoder, next_offset)?
320            {
321                let member_inline_size = <fidl::encoding::BoundedString<4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
322                if inlined != (member_inline_size <= 4) {
323                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
324                }
325                let inner_offset;
326                let mut inner_depth = depth.clone();
327                if inlined {
328                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
329                    inner_offset = next_offset;
330                } else {
331                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
332                    inner_depth.increment()?;
333                }
334                let val_ref = self.node_moniker.get_or_insert_with(|| {
335                    fidl::new_empty!(fidl::encoding::BoundedString<4096>, D)
336                });
337                fidl::decode!(
338                    fidl::encoding::BoundedString<4096>,
339                    D,
340                    val_ref,
341                    decoder,
342                    inner_offset,
343                    inner_depth
344                )?;
345                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
346                {
347                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
348                }
349                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
350                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
351                }
352            }
353
354            next_offset += envelope_size;
355
356            // Decode the remaining unknown envelopes.
357            while next_offset < end_offset {
358                _next_ordinal_to_read += 1;
359                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
360                next_offset += envelope_size;
361            }
362
363            Ok(())
364        }
365    }
366}
fidl_fuchsia_driver_crash__common/fidl_fuchsia_driver_crash__common.rs

fidl_fuchsia_driver_crash__common/
fidl_fuchsia_driver_crash__common.rs
