fidl_fuchsia_hardware_tee__common/
fidl_fuchsia_hardware_tee__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 MAX_NUM_OF_THREAD_POOLS: u32 = 64;
12
13pub const MAX_NUM_OF_TRUSTED_APPS: u32 = 64;
14
15/// Used to inform TEE driver about thread pool configuration
16#[derive(Clone, Debug, Default, PartialEq)]
17pub struct CustomThreadConfig {
18    /// Role name for custom thread pool.
19    pub role: Option<String>,
20    /// Number of threads in the thread pool.
21    pub count: Option<u32>,
22    /// List of TA UUIDs which should be assigned to this thread pool.
23    pub trusted_apps: Option<Vec<fidl_fuchsia_tee__common::Uuid>>,
24    #[doc(hidden)]
25    pub __source_breaking: fidl::marker::SourceBreaking,
26}
27
28impl fidl::Persistable for CustomThreadConfig {}
29
30/// Passed to the TEE driver in metadata as DEVICE_METADATA_TEE_THREAD_CONFIG
31#[derive(Clone, Debug, Default, PartialEq)]
32pub struct TeeMetadata {
33    /// Number of threads in the default pool.
34    pub default_thread_count: Option<u32>,
35    /// List of custom pool configurations.
36    pub custom_threads: Option<Vec<CustomThreadConfig>>,
37    #[doc(hidden)]
38    pub __source_breaking: fidl::marker::SourceBreaking,
39}
40
41impl fidl::Persistable for TeeMetadata {}
42
43pub mod device_connector_ordinals {
44    pub const CONNECT_TO_DEVICE_INFO: u64 = 0x5fa3623fd14f786;
45    pub const CONNECT_TO_APPLICATION: u64 = 0x6e7f7e307df7816a;
46}
47
48mod internal {
49    use super::*;
50
51    impl CustomThreadConfig {
52        #[inline(always)]
53        fn max_ordinal_present(&self) -> u64 {
54            if let Some(_) = self.trusted_apps {
55                return 3;
56            }
57            if let Some(_) = self.count {
58                return 2;
59            }
60            if let Some(_) = self.role {
61                return 1;
62            }
63            0
64        }
65    }
66
67    impl fidl::encoding::ValueTypeMarker for CustomThreadConfig {
68        type Borrowed<'a> = &'a Self;
69        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
70            value
71        }
72    }
73
74    unsafe impl fidl::encoding::TypeMarker for CustomThreadConfig {
75        type Owned = Self;
76
77        #[inline(always)]
78        fn inline_align(_context: fidl::encoding::Context) -> usize {
79            8
80        }
81
82        #[inline(always)]
83        fn inline_size(_context: fidl::encoding::Context) -> usize {
84            16
85        }
86    }
87
88    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CustomThreadConfig, D>
89        for &CustomThreadConfig
90    {
91        unsafe fn encode(
92            self,
93            encoder: &mut fidl::encoding::Encoder<'_, D>,
94            offset: usize,
95            mut depth: fidl::encoding::Depth,
96        ) -> fidl::Result<()> {
97            encoder.debug_check_bounds::<CustomThreadConfig>(offset);
98            // Vector header
99            let max_ordinal: u64 = self.max_ordinal_present();
100            encoder.write_num(max_ordinal, offset);
101            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
102            // Calling encoder.out_of_line_offset(0) is not allowed.
103            if max_ordinal == 0 {
104                return Ok(());
105            }
106            depth.increment()?;
107            let envelope_size = 8;
108            let bytes_len = max_ordinal as usize * envelope_size;
109            #[allow(unused_variables)]
110            let offset = encoder.out_of_line_offset(bytes_len);
111            let mut _prev_end_offset: usize = 0;
112            if 1 > max_ordinal {
113                return Ok(());
114            }
115
116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
117            // are envelope_size bytes.
118            let cur_offset: usize = (1 - 1) * envelope_size;
119
120            // Zero reserved fields.
121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
122
123            // Safety:
124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
126            //   envelope_size bytes, there is always sufficient room.
127            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<2048>, D>(
128            self.role.as_ref().map(<fidl::encoding::BoundedString<2048> as fidl::encoding::ValueTypeMarker>::borrow),
129            encoder, offset + cur_offset, depth
130        )?;
131
132            _prev_end_offset = cur_offset + envelope_size;
133            if 2 > max_ordinal {
134                return Ok(());
135            }
136
137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
138            // are envelope_size bytes.
139            let cur_offset: usize = (2 - 1) * envelope_size;
140
141            // Zero reserved fields.
142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
143
144            // Safety:
145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
147            //   envelope_size bytes, there is always sufficient room.
148            fidl::encoding::encode_in_envelope_optional::<u32, D>(
149                self.count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
150                encoder,
151                offset + cur_offset,
152                depth,
153            )?;
154
155            _prev_end_offset = cur_offset + envelope_size;
156            if 3 > max_ordinal {
157                return Ok(());
158            }
159
160            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
161            // are envelope_size bytes.
162            let cur_offset: usize = (3 - 1) * envelope_size;
163
164            // Zero reserved fields.
165            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
166
167            // Safety:
168            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
169            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
170            //   envelope_size bytes, there is always sufficient room.
171            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_tee__common::Uuid, 64>, D>(
172            self.trusted_apps.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_tee__common::Uuid, 64> as fidl::encoding::ValueTypeMarker>::borrow),
173            encoder, offset + cur_offset, depth
174        )?;
175
176            _prev_end_offset = cur_offset + envelope_size;
177
178            Ok(())
179        }
180    }
181
182    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CustomThreadConfig {
183        #[inline(always)]
184        fn new_empty() -> Self {
185            Self::default()
186        }
187
188        unsafe fn decode(
189            &mut self,
190            decoder: &mut fidl::encoding::Decoder<'_, D>,
191            offset: usize,
192            mut depth: fidl::encoding::Depth,
193        ) -> fidl::Result<()> {
194            decoder.debug_check_bounds::<Self>(offset);
195            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
196                None => return Err(fidl::Error::NotNullable),
197                Some(len) => len,
198            };
199            // Calling decoder.out_of_line_offset(0) is not allowed.
200            if len == 0 {
201                return Ok(());
202            };
203            depth.increment()?;
204            let envelope_size = 8;
205            let bytes_len = len * envelope_size;
206            let offset = decoder.out_of_line_offset(bytes_len)?;
207            // Decode the envelope for each type.
208            let mut _next_ordinal_to_read = 0;
209            let mut next_offset = offset;
210            let end_offset = offset + bytes_len;
211            _next_ordinal_to_read += 1;
212            if next_offset >= end_offset {
213                return Ok(());
214            }
215
216            // Decode unknown envelopes for gaps in ordinals.
217            while _next_ordinal_to_read < 1 {
218                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
219                _next_ordinal_to_read += 1;
220                next_offset += envelope_size;
221            }
222
223            let next_out_of_line = decoder.next_out_of_line();
224            let handles_before = decoder.remaining_handles();
225            if let Some((inlined, num_bytes, num_handles)) =
226                fidl::encoding::decode_envelope_header(decoder, next_offset)?
227            {
228                let member_inline_size = <fidl::encoding::BoundedString<2048> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
229                if inlined != (member_inline_size <= 4) {
230                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
231                }
232                let inner_offset;
233                let mut inner_depth = depth.clone();
234                if inlined {
235                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
236                    inner_offset = next_offset;
237                } else {
238                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
239                    inner_depth.increment()?;
240                }
241                let val_ref = self.role.get_or_insert_with(|| {
242                    fidl::new_empty!(fidl::encoding::BoundedString<2048>, D)
243                });
244                fidl::decode!(
245                    fidl::encoding::BoundedString<2048>,
246                    D,
247                    val_ref,
248                    decoder,
249                    inner_offset,
250                    inner_depth
251                )?;
252                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
253                {
254                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
255                }
256                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
257                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
258                }
259            }
260
261            next_offset += envelope_size;
262            _next_ordinal_to_read += 1;
263            if next_offset >= end_offset {
264                return Ok(());
265            }
266
267            // Decode unknown envelopes for gaps in ordinals.
268            while _next_ordinal_to_read < 2 {
269                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
270                _next_ordinal_to_read += 1;
271                next_offset += envelope_size;
272            }
273
274            let next_out_of_line = decoder.next_out_of_line();
275            let handles_before = decoder.remaining_handles();
276            if let Some((inlined, num_bytes, num_handles)) =
277                fidl::encoding::decode_envelope_header(decoder, next_offset)?
278            {
279                let member_inline_size =
280                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
281                if inlined != (member_inline_size <= 4) {
282                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
283                }
284                let inner_offset;
285                let mut inner_depth = depth.clone();
286                if inlined {
287                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
288                    inner_offset = next_offset;
289                } else {
290                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
291                    inner_depth.increment()?;
292                }
293                let val_ref = self.count.get_or_insert_with(|| fidl::new_empty!(u32, D));
294                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
295                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
296                {
297                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
298                }
299                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
300                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
301                }
302            }
303
304            next_offset += envelope_size;
305            _next_ordinal_to_read += 1;
306            if next_offset >= end_offset {
307                return Ok(());
308            }
309
310            // Decode unknown envelopes for gaps in ordinals.
311            while _next_ordinal_to_read < 3 {
312                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
313                _next_ordinal_to_read += 1;
314                next_offset += envelope_size;
315            }
316
317            let next_out_of_line = decoder.next_out_of_line();
318            let handles_before = decoder.remaining_handles();
319            if let Some((inlined, num_bytes, num_handles)) =
320                fidl::encoding::decode_envelope_header(decoder, next_offset)?
321            {
322                let member_inline_size = <fidl::encoding::Vector<fidl_fuchsia_tee__common::Uuid, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
323                if inlined != (member_inline_size <= 4) {
324                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
325                }
326                let inner_offset;
327                let mut inner_depth = depth.clone();
328                if inlined {
329                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
330                    inner_offset = next_offset;
331                } else {
332                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
333                    inner_depth.increment()?;
334                }
335                let val_ref =
336                self.trusted_apps.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_tee__common::Uuid, 64>, D));
337                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_tee__common::Uuid, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
338                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
339                {
340                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
341                }
342                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
343                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
344                }
345            }
346
347            next_offset += envelope_size;
348
349            // Decode the remaining unknown envelopes.
350            while next_offset < end_offset {
351                _next_ordinal_to_read += 1;
352                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
353                next_offset += envelope_size;
354            }
355
356            Ok(())
357        }
358    }
359
360    impl TeeMetadata {
361        #[inline(always)]
362        fn max_ordinal_present(&self) -> u64 {
363            if let Some(_) = self.custom_threads {
364                return 2;
365            }
366            if let Some(_) = self.default_thread_count {
367                return 1;
368            }
369            0
370        }
371    }
372
373    impl fidl::encoding::ValueTypeMarker for TeeMetadata {
374        type Borrowed<'a> = &'a Self;
375        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
376            value
377        }
378    }
379
380    unsafe impl fidl::encoding::TypeMarker for TeeMetadata {
381        type Owned = Self;
382
383        #[inline(always)]
384        fn inline_align(_context: fidl::encoding::Context) -> usize {
385            8
386        }
387
388        #[inline(always)]
389        fn inline_size(_context: fidl::encoding::Context) -> usize {
390            16
391        }
392    }
393
394    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TeeMetadata, D>
395        for &TeeMetadata
396    {
397        unsafe fn encode(
398            self,
399            encoder: &mut fidl::encoding::Encoder<'_, D>,
400            offset: usize,
401            mut depth: fidl::encoding::Depth,
402        ) -> fidl::Result<()> {
403            encoder.debug_check_bounds::<TeeMetadata>(offset);
404            // Vector header
405            let max_ordinal: u64 = self.max_ordinal_present();
406            encoder.write_num(max_ordinal, offset);
407            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
408            // Calling encoder.out_of_line_offset(0) is not allowed.
409            if max_ordinal == 0 {
410                return Ok(());
411            }
412            depth.increment()?;
413            let envelope_size = 8;
414            let bytes_len = max_ordinal as usize * envelope_size;
415            #[allow(unused_variables)]
416            let offset = encoder.out_of_line_offset(bytes_len);
417            let mut _prev_end_offset: usize = 0;
418            if 1 > max_ordinal {
419                return Ok(());
420            }
421
422            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
423            // are envelope_size bytes.
424            let cur_offset: usize = (1 - 1) * envelope_size;
425
426            // Zero reserved fields.
427            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
428
429            // Safety:
430            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
431            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
432            //   envelope_size bytes, there is always sufficient room.
433            fidl::encoding::encode_in_envelope_optional::<u32, D>(
434                self.default_thread_count
435                    .as_ref()
436                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
437                encoder,
438                offset + cur_offset,
439                depth,
440            )?;
441
442            _prev_end_offset = cur_offset + envelope_size;
443            if 2 > max_ordinal {
444                return Ok(());
445            }
446
447            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
448            // are envelope_size bytes.
449            let cur_offset: usize = (2 - 1) * envelope_size;
450
451            // Zero reserved fields.
452            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
453
454            // Safety:
455            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
456            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
457            //   envelope_size bytes, there is always sufficient room.
458            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CustomThreadConfig, 64>, D>(
459            self.custom_threads.as_ref().map(<fidl::encoding::Vector<CustomThreadConfig, 64> as fidl::encoding::ValueTypeMarker>::borrow),
460            encoder, offset + cur_offset, depth
461        )?;
462
463            _prev_end_offset = cur_offset + envelope_size;
464
465            Ok(())
466        }
467    }
468
469    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TeeMetadata {
470        #[inline(always)]
471        fn new_empty() -> Self {
472            Self::default()
473        }
474
475        unsafe fn decode(
476            &mut self,
477            decoder: &mut fidl::encoding::Decoder<'_, D>,
478            offset: usize,
479            mut depth: fidl::encoding::Depth,
480        ) -> fidl::Result<()> {
481            decoder.debug_check_bounds::<Self>(offset);
482            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
483                None => return Err(fidl::Error::NotNullable),
484                Some(len) => len,
485            };
486            // Calling decoder.out_of_line_offset(0) is not allowed.
487            if len == 0 {
488                return Ok(());
489            };
490            depth.increment()?;
491            let envelope_size = 8;
492            let bytes_len = len * envelope_size;
493            let offset = decoder.out_of_line_offset(bytes_len)?;
494            // Decode the envelope for each type.
495            let mut _next_ordinal_to_read = 0;
496            let mut next_offset = offset;
497            let end_offset = offset + bytes_len;
498            _next_ordinal_to_read += 1;
499            if next_offset >= end_offset {
500                return Ok(());
501            }
502
503            // Decode unknown envelopes for gaps in ordinals.
504            while _next_ordinal_to_read < 1 {
505                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
506                _next_ordinal_to_read += 1;
507                next_offset += envelope_size;
508            }
509
510            let next_out_of_line = decoder.next_out_of_line();
511            let handles_before = decoder.remaining_handles();
512            if let Some((inlined, num_bytes, num_handles)) =
513                fidl::encoding::decode_envelope_header(decoder, next_offset)?
514            {
515                let member_inline_size =
516                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
517                if inlined != (member_inline_size <= 4) {
518                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
519                }
520                let inner_offset;
521                let mut inner_depth = depth.clone();
522                if inlined {
523                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
524                    inner_offset = next_offset;
525                } else {
526                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
527                    inner_depth.increment()?;
528                }
529                let val_ref =
530                    self.default_thread_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
531                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
532                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
533                {
534                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
535                }
536                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
537                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
538                }
539            }
540
541            next_offset += envelope_size;
542            _next_ordinal_to_read += 1;
543            if next_offset >= end_offset {
544                return Ok(());
545            }
546
547            // Decode unknown envelopes for gaps in ordinals.
548            while _next_ordinal_to_read < 2 {
549                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
550                _next_ordinal_to_read += 1;
551                next_offset += envelope_size;
552            }
553
554            let next_out_of_line = decoder.next_out_of_line();
555            let handles_before = decoder.remaining_handles();
556            if let Some((inlined, num_bytes, num_handles)) =
557                fidl::encoding::decode_envelope_header(decoder, next_offset)?
558            {
559                let member_inline_size = <fidl::encoding::Vector<CustomThreadConfig, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
560                if inlined != (member_inline_size <= 4) {
561                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
562                }
563                let inner_offset;
564                let mut inner_depth = depth.clone();
565                if inlined {
566                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
567                    inner_offset = next_offset;
568                } else {
569                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
570                    inner_depth.increment()?;
571                }
572                let val_ref = self.custom_threads.get_or_insert_with(
573                    || fidl::new_empty!(fidl::encoding::Vector<CustomThreadConfig, 64>, D),
574                );
575                fidl::decode!(fidl::encoding::Vector<CustomThreadConfig, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
576                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
577                {
578                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
579                }
580                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
581                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
582                }
583            }
584
585            next_offset += envelope_size;
586
587            // Decode the remaining unknown envelopes.
588            while next_offset < end_offset {
589                _next_ordinal_to_read += 1;
590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
591                next_offset += envelope_size;
592            }
593
594            Ok(())
595        }
596    }
597}