fidl_fuchsia_hardware_tee__common/
fidl_fuchsia_hardware_tee__common.rs1#![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#[derive(Clone, Debug, Default, PartialEq)]
17pub struct CustomThreadConfig {
18 pub role: Option<String>,
20 pub count: Option<u32>,
22 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#[derive(Clone, Debug, Default, PartialEq)]
32pub struct TeeMetadata {
33 pub default_thread_count: Option<u32>,
35 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
119
120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
122
123 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 let cur_offset: usize = (2 - 1) * envelope_size;
140
141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
143
144 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 let cur_offset: usize = (3 - 1) * envelope_size;
163
164 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
166
167 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
425
426 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
428
429 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 let cur_offset: usize = (2 - 1) * envelope_size;
450
451 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
453
454 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 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 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 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 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 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}