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

fidl_fuchsia_hardware_tee__common/
fidl_fuchsia_hardware_tee__common.rs
