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
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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
114
115 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
117
118 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 let cur_offset: usize = (2 - 1) * envelope_size;
135
136 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
138
139 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 let cur_offset: usize = (3 - 1) * envelope_size;
158
159 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
161
162 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 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 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 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 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 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 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 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 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 let cur_offset: usize = (1 - 1) * envelope_size;
420
421 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
423
424 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 let cur_offset: usize = (2 - 1) * envelope_size;
445
446 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
448
449 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 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 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 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 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 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}