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