1#[derive(Default)]
2pub struct seL4_TCB_SetFlags_ret {
3 pub error: seL4_Error::Type,
4 pub flags: seL4_Word,
5}
6#[derive(Default)]
7pub struct seL4_RISCV_Page_GetAddress_ret {
8 pub error: seL4_Error::Type,
9 pub paddr: seL4_Word,
10}
11impl seL4_IPCBuffer {
12 #[allow(clippy::field_reassign_with_default)]
13 pub fn seL4_Untyped_Retype(
14 &mut self,
15 service: seL4_Untyped,
16 r#type: seL4_Word,
17 r#size_bits: seL4_Word,
18 r#root: seL4_CNode,
19 r#node_index: seL4_Word,
20 r#node_depth: seL4_Word,
21 r#node_offset: seL4_Word,
22 r#num_objects: seL4_Word,
23 ) -> seL4_Error::Type {
24 log::trace!(
25 "seL4_Untyped_Retype(_service={:?}, type={:?}, size_bits={:?}, root={:?}, node_index={:?}, node_depth={:?}, node_offset={:?}, num_objects={:?})",
26 service, r#type, r#size_bits, r#root, r#node_index, r#node_depth,
27 r#node_offset, r#num_objects,
28 );
29 self.msg[..6usize].fill(0);
30 self.set_mr_bits(0usize..32usize, r#type);
31 self.set_mr_bits(32usize..64usize, r#size_bits);
32 self.set_cap(0usize, r#root);
33 self.set_mr_bits(64usize..96usize, r#node_index);
34 self.set_mr_bits(96usize..128usize, r#node_depth);
35 self.set_mr_bits(128usize..160usize, r#node_offset);
36 self.set_mr_bits(160usize..192usize, r#num_objects);
37 let info_in = seL4_MessageInfo::new(
38 invocation_label::UntypedRetype.into(),
39 0,
40 1u32,
41 6u32,
42 );
43 let info_out = self.seL4_Call(service, info_in);
44 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
45 err
46 }
47 #[allow(clippy::field_reassign_with_default)]
48 pub fn seL4_TCB_ReadRegisters(
49 &mut self,
50 service: seL4_TCB,
51 r#suspend_source: seL4_Bool,
52 r#arch_flags: seL4_Uint8,
53 r#count: seL4_Word,
54 r#regs: &mut seL4_UserContext,
55 ) -> seL4_Error::Type {
56 log::trace!(
57 "seL4_TCB_ReadRegisters(_service={:?}, suspend_source={:?}, arch_flags={:?}, count={:?})",
58 service, r#suspend_source, r#arch_flags, r#count,
59 );
60 self.msg[..2usize].fill(0);
61 self.set_mr_bits(0usize..1usize, r#suspend_source);
62 self.set_mr_bits(8usize..16usize, r#arch_flags);
63 self.set_mr_bits(32usize..64usize, r#count);
64 let info_in = seL4_MessageInfo::new(
65 invocation_label::TCBReadRegisters.into(),
66 0,
67 0u32,
68 2u32,
69 );
70 let info_out = self.seL4_Call(service, info_in);
71 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
72 regs.pc = self.get_mr_bits(0usize..32usize);
73 regs.ra = self.get_mr_bits(32usize..64usize);
74 regs.sp = self.get_mr_bits(64usize..96usize);
75 regs.gp = self.get_mr_bits(96usize..128usize);
76 regs.s0 = self.get_mr_bits(128usize..160usize);
77 regs.s1 = self.get_mr_bits(160usize..192usize);
78 regs.s2 = self.get_mr_bits(192usize..224usize);
79 regs.s3 = self.get_mr_bits(224usize..256usize);
80 regs.s4 = self.get_mr_bits(256usize..288usize);
81 regs.s5 = self.get_mr_bits(288usize..320usize);
82 regs.s6 = self.get_mr_bits(320usize..352usize);
83 regs.s7 = self.get_mr_bits(352usize..384usize);
84 regs.s8 = self.get_mr_bits(384usize..416usize);
85 regs.s9 = self.get_mr_bits(416usize..448usize);
86 regs.s10 = self.get_mr_bits(448usize..480usize);
87 regs.s11 = self.get_mr_bits(480usize..512usize);
88 regs.a0 = self.get_mr_bits(512usize..544usize);
89 regs.a1 = self.get_mr_bits(544usize..576usize);
90 regs.a2 = self.get_mr_bits(576usize..608usize);
91 regs.a3 = self.get_mr_bits(608usize..640usize);
92 regs.a4 = self.get_mr_bits(640usize..672usize);
93 regs.a5 = self.get_mr_bits(672usize..704usize);
94 regs.a6 = self.get_mr_bits(704usize..736usize);
95 regs.a7 = self.get_mr_bits(736usize..768usize);
96 regs.t0 = self.get_mr_bits(768usize..800usize);
97 regs.t1 = self.get_mr_bits(800usize..832usize);
98 regs.t2 = self.get_mr_bits(832usize..864usize);
99 regs.t3 = self.get_mr_bits(864usize..896usize);
100 regs.t4 = self.get_mr_bits(896usize..928usize);
101 regs.t5 = self.get_mr_bits(928usize..960usize);
102 regs.t6 = self.get_mr_bits(960usize..992usize);
103 regs.tp = self.get_mr_bits(992usize..1024usize);
104 err
105 }
106 #[allow(clippy::field_reassign_with_default)]
107 pub fn seL4_TCB_WriteRegisters(
108 &mut self,
109 service: seL4_TCB,
110 r#resume_target: seL4_Bool,
111 r#arch_flags: seL4_Uint8,
112 r#count: seL4_Word,
113 r#regs: &seL4_UserContext,
114 ) -> seL4_Error::Type {
115 log::trace!(
116 "seL4_TCB_WriteRegisters(_service={:?}, resume_target={:?}, arch_flags={:?}, count={:?}, regs={:?})",
117 service, r#resume_target, r#arch_flags, r#count, r#regs,
118 );
119 self.msg[..34usize].fill(0);
120 self.set_mr_bits(0usize..1usize, r#resume_target);
121 self.set_mr_bits(8usize..16usize, r#arch_flags);
122 self.set_mr_bits(32usize..64usize, r#count);
123 self.set_mr_bits(64usize..96usize, regs.pc);
124 self.set_mr_bits(96usize..128usize, regs.ra);
125 self.set_mr_bits(128usize..160usize, regs.sp);
126 self.set_mr_bits(160usize..192usize, regs.gp);
127 self.set_mr_bits(192usize..224usize, regs.s0);
128 self.set_mr_bits(224usize..256usize, regs.s1);
129 self.set_mr_bits(256usize..288usize, regs.s2);
130 self.set_mr_bits(288usize..320usize, regs.s3);
131 self.set_mr_bits(320usize..352usize, regs.s4);
132 self.set_mr_bits(352usize..384usize, regs.s5);
133 self.set_mr_bits(384usize..416usize, regs.s6);
134 self.set_mr_bits(416usize..448usize, regs.s7);
135 self.set_mr_bits(448usize..480usize, regs.s8);
136 self.set_mr_bits(480usize..512usize, regs.s9);
137 self.set_mr_bits(512usize..544usize, regs.s10);
138 self.set_mr_bits(544usize..576usize, regs.s11);
139 self.set_mr_bits(576usize..608usize, regs.a0);
140 self.set_mr_bits(608usize..640usize, regs.a1);
141 self.set_mr_bits(640usize..672usize, regs.a2);
142 self.set_mr_bits(672usize..704usize, regs.a3);
143 self.set_mr_bits(704usize..736usize, regs.a4);
144 self.set_mr_bits(736usize..768usize, regs.a5);
145 self.set_mr_bits(768usize..800usize, regs.a6);
146 self.set_mr_bits(800usize..832usize, regs.a7);
147 self.set_mr_bits(832usize..864usize, regs.t0);
148 self.set_mr_bits(864usize..896usize, regs.t1);
149 self.set_mr_bits(896usize..928usize, regs.t2);
150 self.set_mr_bits(928usize..960usize, regs.t3);
151 self.set_mr_bits(960usize..992usize, regs.t4);
152 self.set_mr_bits(992usize..1024usize, regs.t5);
153 self.set_mr_bits(1024usize..1056usize, regs.t6);
154 self.set_mr_bits(1056usize..1088usize, regs.tp);
155 let info_in = seL4_MessageInfo::new(
156 invocation_label::TCBWriteRegisters.into(),
157 0,
158 0u32,
159 34u32,
160 );
161 let info_out = self.seL4_Call(service, info_in);
162 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
163 err
164 }
165 #[allow(clippy::field_reassign_with_default)]
166 pub fn seL4_TCB_CopyRegisters(
167 &mut self,
168 service: seL4_TCB,
169 r#source: seL4_TCB,
170 r#suspend_source: seL4_Bool,
171 r#resume_target: seL4_Bool,
172 r#transfer_frame: seL4_Bool,
173 r#transfer_integer: seL4_Bool,
174 r#arch_flags: seL4_Uint8,
175 ) -> seL4_Error::Type {
176 log::trace!(
177 "seL4_TCB_CopyRegisters(_service={:?}, source={:?}, suspend_source={:?}, resume_target={:?}, transfer_frame={:?}, transfer_integer={:?}, arch_flags={:?})",
178 service, r#source, r#suspend_source, r#resume_target, r#transfer_frame,
179 r#transfer_integer, r#arch_flags,
180 );
181 self.msg[..1usize].fill(0);
182 self.set_cap(0usize, r#source);
183 self.set_mr_bits(0usize..1usize, r#suspend_source);
184 self.set_mr_bits(1usize..2usize, r#resume_target);
185 self.set_mr_bits(2usize..3usize, r#transfer_frame);
186 self.set_mr_bits(3usize..4usize, r#transfer_integer);
187 self.set_mr_bits(8usize..16usize, r#arch_flags);
188 let info_in = seL4_MessageInfo::new(
189 invocation_label::TCBCopyRegisters.into(),
190 0,
191 1u32,
192 1u32,
193 );
194 let info_out = self.seL4_Call(service, info_in);
195 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
196 err
197 }
198 #[allow(clippy::field_reassign_with_default)]
199 pub fn seL4_TCB_Configure(
200 &mut self,
201 service: seL4_TCB,
202 r#fault_ep: seL4_Word,
203 r#cspace_root: seL4_CNode,
204 r#cspace_root_data: seL4_Word,
205 r#vspace_root: seL4_CPtr,
206 r#vspace_root_data: seL4_Word,
207 r#buffer: seL4_Word,
208 r#bufferFrame: seL4_CPtr,
209 ) -> seL4_Error::Type {
210 log::trace!(
211 "seL4_TCB_Configure(_service={:?}, fault_ep={:?}, cspace_root={:?}, cspace_root_data={:?}, vspace_root={:?}, vspace_root_data={:?}, buffer={:?}, bufferFrame={:?})",
212 service, r#fault_ep, r#cspace_root, r#cspace_root_data, r#vspace_root,
213 r#vspace_root_data, r#buffer, r#bufferFrame,
214 );
215 self.msg[..4usize].fill(0);
216 self.set_mr_bits(0usize..32usize, r#fault_ep);
217 self.set_cap(0usize, r#cspace_root);
218 self.set_mr_bits(32usize..64usize, r#cspace_root_data);
219 self.set_cap(1usize, r#vspace_root);
220 self.set_mr_bits(64usize..96usize, r#vspace_root_data);
221 self.set_mr_bits(96usize..128usize, r#buffer);
222 self.set_cap(2usize, r#bufferFrame);
223 let info_in = seL4_MessageInfo::new(
224 invocation_label::TCBConfigure.into(),
225 0,
226 3u32,
227 4u32,
228 );
229 let info_out = self.seL4_Call(service, info_in);
230 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
231 err
232 }
233 #[allow(clippy::field_reassign_with_default)]
234 pub fn seL4_TCB_SetPriority(
235 &mut self,
236 service: seL4_TCB,
237 r#authority: seL4_TCB,
238 r#priority: seL4_Word,
239 ) -> seL4_Error::Type {
240 log::trace!(
241 "seL4_TCB_SetPriority(_service={:?}, authority={:?}, priority={:?})",
242 service, r#authority, r#priority,
243 );
244 self.msg[..1usize].fill(0);
245 self.set_cap(0usize, r#authority);
246 self.set_mr_bits(0usize..32usize, r#priority);
247 let info_in = seL4_MessageInfo::new(
248 invocation_label::TCBSetPriority.into(),
249 0,
250 1u32,
251 1u32,
252 );
253 let info_out = self.seL4_Call(service, info_in);
254 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
255 err
256 }
257 #[allow(clippy::field_reassign_with_default)]
258 pub fn seL4_TCB_SetMCPriority(
259 &mut self,
260 service: seL4_TCB,
261 r#authority: seL4_TCB,
262 r#mcp: seL4_Word,
263 ) -> seL4_Error::Type {
264 log::trace!(
265 "seL4_TCB_SetMCPriority(_service={:?}, authority={:?}, mcp={:?})", service,
266 r#authority, r#mcp,
267 );
268 self.msg[..1usize].fill(0);
269 self.set_cap(0usize, r#authority);
270 self.set_mr_bits(0usize..32usize, r#mcp);
271 let info_in = seL4_MessageInfo::new(
272 invocation_label::TCBSetMCPriority.into(),
273 0,
274 1u32,
275 1u32,
276 );
277 let info_out = self.seL4_Call(service, info_in);
278 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
279 err
280 }
281 #[allow(clippy::field_reassign_with_default)]
282 pub fn seL4_TCB_SetSchedParams(
283 &mut self,
284 service: seL4_TCB,
285 r#authority: seL4_TCB,
286 r#mcp: seL4_Word,
287 r#priority: seL4_Word,
288 ) -> seL4_Error::Type {
289 log::trace!(
290 "seL4_TCB_SetSchedParams(_service={:?}, authority={:?}, mcp={:?}, priority={:?})",
291 service, r#authority, r#mcp, r#priority,
292 );
293 self.msg[..2usize].fill(0);
294 self.set_cap(0usize, r#authority);
295 self.set_mr_bits(0usize..32usize, r#mcp);
296 self.set_mr_bits(32usize..64usize, r#priority);
297 let info_in = seL4_MessageInfo::new(
298 invocation_label::TCBSetSchedParams.into(),
299 0,
300 1u32,
301 2u32,
302 );
303 let info_out = self.seL4_Call(service, info_in);
304 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
305 err
306 }
307 #[allow(clippy::field_reassign_with_default)]
308 pub fn seL4_TCB_SetIPCBuffer(
309 &mut self,
310 service: seL4_TCB,
311 r#buffer: seL4_Word,
312 r#bufferFrame: seL4_CPtr,
313 ) -> seL4_Error::Type {
314 log::trace!(
315 "seL4_TCB_SetIPCBuffer(_service={:?}, buffer={:?}, bufferFrame={:?})",
316 service, r#buffer, r#bufferFrame,
317 );
318 self.msg[..1usize].fill(0);
319 self.set_mr_bits(0usize..32usize, r#buffer);
320 self.set_cap(0usize, r#bufferFrame);
321 let info_in = seL4_MessageInfo::new(
322 invocation_label::TCBSetIPCBuffer.into(),
323 0,
324 1u32,
325 1u32,
326 );
327 let info_out = self.seL4_Call(service, info_in);
328 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
329 err
330 }
331 #[allow(clippy::field_reassign_with_default)]
332 pub fn seL4_TCB_SetSpace(
333 &mut self,
334 service: seL4_TCB,
335 r#fault_ep: seL4_Word,
336 r#cspace_root: seL4_CNode,
337 r#cspace_root_data: seL4_Word,
338 r#vspace_root: seL4_CPtr,
339 r#vspace_root_data: seL4_Word,
340 ) -> seL4_Error::Type {
341 log::trace!(
342 "seL4_TCB_SetSpace(_service={:?}, fault_ep={:?}, cspace_root={:?}, cspace_root_data={:?}, vspace_root={:?}, vspace_root_data={:?})",
343 service, r#fault_ep, r#cspace_root, r#cspace_root_data, r#vspace_root,
344 r#vspace_root_data,
345 );
346 self.msg[..3usize].fill(0);
347 self.set_mr_bits(0usize..32usize, r#fault_ep);
348 self.set_cap(0usize, r#cspace_root);
349 self.set_mr_bits(32usize..64usize, r#cspace_root_data);
350 self.set_cap(1usize, r#vspace_root);
351 self.set_mr_bits(64usize..96usize, r#vspace_root_data);
352 let info_in = seL4_MessageInfo::new(
353 invocation_label::TCBSetSpace.into(),
354 0,
355 2u32,
356 3u32,
357 );
358 let info_out = self.seL4_Call(service, info_in);
359 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
360 err
361 }
362 #[allow(clippy::field_reassign_with_default)]
363 pub fn seL4_TCB_Suspend(&mut self, service: seL4_TCB) -> seL4_Error::Type {
364 log::trace!("seL4_TCB_Suspend(_service={:?})", service,);
365 self.msg[..0usize].fill(0);
366 let info_in = seL4_MessageInfo::new(
367 invocation_label::TCBSuspend.into(),
368 0,
369 0u32,
370 0u32,
371 );
372 let info_out = self.seL4_Call(service, info_in);
373 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
374 err
375 }
376 #[allow(clippy::field_reassign_with_default)]
377 pub fn seL4_TCB_Resume(&mut self, service: seL4_TCB) -> seL4_Error::Type {
378 log::trace!("seL4_TCB_Resume(_service={:?})", service,);
379 self.msg[..0usize].fill(0);
380 let info_in = seL4_MessageInfo::new(
381 invocation_label::TCBResume.into(),
382 0,
383 0u32,
384 0u32,
385 );
386 let info_out = self.seL4_Call(service, info_in);
387 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
388 err
389 }
390 #[allow(clippy::field_reassign_with_default)]
391 pub fn seL4_TCB_BindNotification(
392 &mut self,
393 service: seL4_TCB,
394 r#notification: seL4_CPtr,
395 ) -> seL4_Error::Type {
396 log::trace!(
397 "seL4_TCB_BindNotification(_service={:?}, notification={:?})", service,
398 r#notification,
399 );
400 self.msg[..0usize].fill(0);
401 self.set_cap(0usize, r#notification);
402 let info_in = seL4_MessageInfo::new(
403 invocation_label::TCBBindNotification.into(),
404 0,
405 1u32,
406 0u32,
407 );
408 let info_out = self.seL4_Call(service, info_in);
409 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
410 err
411 }
412 #[allow(clippy::field_reassign_with_default)]
413 pub fn seL4_TCB_UnbindNotification(
414 &mut self,
415 service: seL4_TCB,
416 ) -> seL4_Error::Type {
417 log::trace!("seL4_TCB_UnbindNotification(_service={:?})", service,);
418 self.msg[..0usize].fill(0);
419 let info_in = seL4_MessageInfo::new(
420 invocation_label::TCBUnbindNotification.into(),
421 0,
422 0u32,
423 0u32,
424 );
425 let info_out = self.seL4_Call(service, info_in);
426 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
427 err
428 }
429 #[allow(clippy::field_reassign_with_default)]
430 pub fn seL4_TCB_SetTLSBase(
431 &mut self,
432 service: seL4_TCB,
433 r#tls_base: seL4_Word,
434 ) -> seL4_Error::Type {
435 log::trace!(
436 "seL4_TCB_SetTLSBase(_service={:?}, tls_base={:?})", service, r#tls_base,
437 );
438 self.msg[..1usize].fill(0);
439 self.set_mr_bits(0usize..32usize, r#tls_base);
440 let info_in = seL4_MessageInfo::new(
441 invocation_label::TCBSetTLSBase.into(),
442 0,
443 0u32,
444 1u32,
445 );
446 let info_out = self.seL4_Call(service, info_in);
447 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
448 err
449 }
450 #[allow(clippy::field_reassign_with_default)]
451 pub fn seL4_TCB_SetFlags(
452 &mut self,
453 service: seL4_TCB,
454 r#clear: seL4_Word,
455 r#set: seL4_Word,
456 ) -> seL4_TCB_SetFlags_ret {
457 log::trace!(
458 "seL4_TCB_SetFlags(_service={:?}, clear={:?}, set={:?})", service, r#clear,
459 r#set,
460 );
461 self.msg[..2usize].fill(0);
462 self.set_mr_bits(0usize..32usize, r#clear);
463 self.set_mr_bits(32usize..64usize, r#set);
464 let info_in = seL4_MessageInfo::new(
465 invocation_label::TCBSetFlags.into(),
466 0,
467 0u32,
468 2u32,
469 );
470 let info_out = self.seL4_Call(service, info_in);
471 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
472 let mut ret: seL4_TCB_SetFlags_ret = Default::default();
473 ret.error = err;
474 ret.flags = self.get_mr_bits(0usize..32usize);
475 ret
476 }
477 #[allow(clippy::field_reassign_with_default)]
478 pub fn seL4_CNode_Revoke(
479 &mut self,
480 service: seL4_CNode,
481 r#index: seL4_Word,
482 r#depth: seL4_Uint8,
483 ) -> seL4_Error::Type {
484 log::trace!(
485 "seL4_CNode_Revoke(_service={:?}, index={:?}, depth={:?})", service, r#index,
486 r#depth,
487 );
488 self.msg[..2usize].fill(0);
489 self.set_mr_bits(0usize..32usize, r#index);
490 self.set_mr_bits(32usize..40usize, r#depth);
491 let info_in = seL4_MessageInfo::new(
492 invocation_label::CNodeRevoke.into(),
493 0,
494 0u32,
495 2u32,
496 );
497 let info_out = self.seL4_Call(service, info_in);
498 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
499 err
500 }
501 #[allow(clippy::field_reassign_with_default)]
502 pub fn seL4_CNode_Delete(
503 &mut self,
504 service: seL4_CNode,
505 r#index: seL4_Word,
506 r#depth: seL4_Uint8,
507 ) -> seL4_Error::Type {
508 log::trace!(
509 "seL4_CNode_Delete(_service={:?}, index={:?}, depth={:?})", service, r#index,
510 r#depth,
511 );
512 self.msg[..2usize].fill(0);
513 self.set_mr_bits(0usize..32usize, r#index);
514 self.set_mr_bits(32usize..40usize, r#depth);
515 let info_in = seL4_MessageInfo::new(
516 invocation_label::CNodeDelete.into(),
517 0,
518 0u32,
519 2u32,
520 );
521 let info_out = self.seL4_Call(service, info_in);
522 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
523 err
524 }
525 #[allow(clippy::field_reassign_with_default)]
526 pub fn seL4_CNode_CancelBadgedSends(
527 &mut self,
528 service: seL4_CNode,
529 r#index: seL4_Word,
530 r#depth: seL4_Uint8,
531 ) -> seL4_Error::Type {
532 log::trace!(
533 "seL4_CNode_CancelBadgedSends(_service={:?}, index={:?}, depth={:?})",
534 service, r#index, r#depth,
535 );
536 self.msg[..2usize].fill(0);
537 self.set_mr_bits(0usize..32usize, r#index);
538 self.set_mr_bits(32usize..40usize, r#depth);
539 let info_in = seL4_MessageInfo::new(
540 invocation_label::CNodeCancelBadgedSends.into(),
541 0,
542 0u32,
543 2u32,
544 );
545 let info_out = self.seL4_Call(service, info_in);
546 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
547 err
548 }
549 #[allow(clippy::field_reassign_with_default)]
550 pub fn seL4_CNode_Copy(
551 &mut self,
552 service: seL4_CNode,
553 r#dest_index: seL4_Word,
554 r#dest_depth: seL4_Uint8,
555 r#src_root: seL4_CNode,
556 r#src_index: seL4_Word,
557 r#src_depth: seL4_Uint8,
558 r#rights: seL4_CapRights_t,
559 ) -> seL4_Error::Type {
560 log::trace!(
561 "seL4_CNode_Copy(_service={:?}, dest_index={:?}, dest_depth={:?}, src_root={:?}, src_index={:?}, src_depth={:?}, rights={:?})",
562 service, r#dest_index, r#dest_depth, r#src_root, r#src_index, r#src_depth,
563 r#rights,
564 );
565 self.msg[..5usize].fill(0);
566 self.set_mr_bits(0usize..32usize, r#dest_index);
567 self.set_mr_bits(32usize..40usize, r#dest_depth);
568 self.set_cap(0usize, r#src_root);
569 self.set_mr_bits(64usize..96usize, r#src_index);
570 self.set_mr_bits(96usize..104usize, r#src_depth);
571 self.set_mr_bits_from_slice(128usize..160usize, r#rights.0.inner());
572 let info_in = seL4_MessageInfo::new(
573 invocation_label::CNodeCopy.into(),
574 0,
575 1u32,
576 5u32,
577 );
578 let info_out = self.seL4_Call(service, info_in);
579 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
580 err
581 }
582 #[allow(clippy::field_reassign_with_default)]
583 pub fn seL4_CNode_Mint(
584 &mut self,
585 service: seL4_CNode,
586 r#dest_index: seL4_Word,
587 r#dest_depth: seL4_Uint8,
588 r#src_root: seL4_CNode,
589 r#src_index: seL4_Word,
590 r#src_depth: seL4_Uint8,
591 r#rights: seL4_CapRights_t,
592 r#badge: seL4_Word,
593 ) -> seL4_Error::Type {
594 log::trace!(
595 "seL4_CNode_Mint(_service={:?}, dest_index={:?}, dest_depth={:?}, src_root={:?}, src_index={:?}, src_depth={:?}, rights={:?}, badge={:?})",
596 service, r#dest_index, r#dest_depth, r#src_root, r#src_index, r#src_depth,
597 r#rights, r#badge,
598 );
599 self.msg[..6usize].fill(0);
600 self.set_mr_bits(0usize..32usize, r#dest_index);
601 self.set_mr_bits(32usize..40usize, r#dest_depth);
602 self.set_cap(0usize, r#src_root);
603 self.set_mr_bits(64usize..96usize, r#src_index);
604 self.set_mr_bits(96usize..104usize, r#src_depth);
605 self.set_mr_bits_from_slice(128usize..160usize, r#rights.0.inner());
606 self.set_mr_bits(160usize..192usize, r#badge);
607 let info_in = seL4_MessageInfo::new(
608 invocation_label::CNodeMint.into(),
609 0,
610 1u32,
611 6u32,
612 );
613 let info_out = self.seL4_Call(service, info_in);
614 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
615 err
616 }
617 #[allow(clippy::field_reassign_with_default)]
618 pub fn seL4_CNode_Move(
619 &mut self,
620 service: seL4_CNode,
621 r#dest_index: seL4_Word,
622 r#dest_depth: seL4_Uint8,
623 r#src_root: seL4_CNode,
624 r#src_index: seL4_Word,
625 r#src_depth: seL4_Uint8,
626 ) -> seL4_Error::Type {
627 log::trace!(
628 "seL4_CNode_Move(_service={:?}, dest_index={:?}, dest_depth={:?}, src_root={:?}, src_index={:?}, src_depth={:?})",
629 service, r#dest_index, r#dest_depth, r#src_root, r#src_index, r#src_depth,
630 );
631 self.msg[..4usize].fill(0);
632 self.set_mr_bits(0usize..32usize, r#dest_index);
633 self.set_mr_bits(32usize..40usize, r#dest_depth);
634 self.set_cap(0usize, r#src_root);
635 self.set_mr_bits(64usize..96usize, r#src_index);
636 self.set_mr_bits(96usize..104usize, r#src_depth);
637 let info_in = seL4_MessageInfo::new(
638 invocation_label::CNodeMove.into(),
639 0,
640 1u32,
641 4u32,
642 );
643 let info_out = self.seL4_Call(service, info_in);
644 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
645 err
646 }
647 #[allow(clippy::field_reassign_with_default)]
648 pub fn seL4_CNode_Mutate(
649 &mut self,
650 service: seL4_CNode,
651 r#dest_index: seL4_Word,
652 r#dest_depth: seL4_Uint8,
653 r#src_root: seL4_CNode,
654 r#src_index: seL4_Word,
655 r#src_depth: seL4_Uint8,
656 r#badge: seL4_Word,
657 ) -> seL4_Error::Type {
658 log::trace!(
659 "seL4_CNode_Mutate(_service={:?}, dest_index={:?}, dest_depth={:?}, src_root={:?}, src_index={:?}, src_depth={:?}, badge={:?})",
660 service, r#dest_index, r#dest_depth, r#src_root, r#src_index, r#src_depth,
661 r#badge,
662 );
663 self.msg[..5usize].fill(0);
664 self.set_mr_bits(0usize..32usize, r#dest_index);
665 self.set_mr_bits(32usize..40usize, r#dest_depth);
666 self.set_cap(0usize, r#src_root);
667 self.set_mr_bits(64usize..96usize, r#src_index);
668 self.set_mr_bits(96usize..104usize, r#src_depth);
669 self.set_mr_bits(128usize..160usize, r#badge);
670 let info_in = seL4_MessageInfo::new(
671 invocation_label::CNodeMutate.into(),
672 0,
673 1u32,
674 5u32,
675 );
676 let info_out = self.seL4_Call(service, info_in);
677 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
678 err
679 }
680 #[allow(clippy::field_reassign_with_default)]
681 pub fn seL4_CNode_Rotate(
682 &mut self,
683 service: seL4_CNode,
684 r#dest_index: seL4_Word,
685 r#dest_depth: seL4_Uint8,
686 r#dest_badge: seL4_Word,
687 r#pivot_root: seL4_CNode,
688 r#pivot_index: seL4_Word,
689 r#pivot_depth: seL4_Uint8,
690 r#pivot_badge: seL4_Word,
691 r#src_root: seL4_CNode,
692 r#src_index: seL4_Word,
693 r#src_depth: seL4_Uint8,
694 ) -> seL4_Error::Type {
695 log::trace!(
696 "seL4_CNode_Rotate(_service={:?}, dest_index={:?}, dest_depth={:?}, dest_badge={:?}, pivot_root={:?}, pivot_index={:?}, pivot_depth={:?}, pivot_badge={:?}, src_root={:?}, src_index={:?}, src_depth={:?})",
697 service, r#dest_index, r#dest_depth, r#dest_badge, r#pivot_root,
698 r#pivot_index, r#pivot_depth, r#pivot_badge, r#src_root, r#src_index,
699 r#src_depth,
700 );
701 self.msg[..8usize].fill(0);
702 self.set_mr_bits(0usize..32usize, r#dest_index);
703 self.set_mr_bits(32usize..40usize, r#dest_depth);
704 self.set_mr_bits(64usize..96usize, r#dest_badge);
705 self.set_cap(0usize, r#pivot_root);
706 self.set_mr_bits(96usize..128usize, r#pivot_index);
707 self.set_mr_bits(128usize..136usize, r#pivot_depth);
708 self.set_mr_bits(160usize..192usize, r#pivot_badge);
709 self.set_cap(1usize, r#src_root);
710 self.set_mr_bits(192usize..224usize, r#src_index);
711 self.set_mr_bits(224usize..232usize, r#src_depth);
712 let info_in = seL4_MessageInfo::new(
713 invocation_label::CNodeRotate.into(),
714 0,
715 2u32,
716 8u32,
717 );
718 let info_out = self.seL4_Call(service, info_in);
719 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
720 err
721 }
722 #[allow(clippy::field_reassign_with_default)]
723 pub fn seL4_CNode_SaveCaller(
724 &mut self,
725 service: seL4_CNode,
726 r#index: seL4_Word,
727 r#depth: seL4_Uint8,
728 ) -> seL4_Error::Type {
729 log::trace!(
730 "seL4_CNode_SaveCaller(_service={:?}, index={:?}, depth={:?})", service,
731 r#index, r#depth,
732 );
733 self.msg[..2usize].fill(0);
734 self.set_mr_bits(0usize..32usize, r#index);
735 self.set_mr_bits(32usize..40usize, r#depth);
736 let info_in = seL4_MessageInfo::new(
737 invocation_label::CNodeSaveCaller.into(),
738 0,
739 0u32,
740 2u32,
741 );
742 let info_out = self.seL4_Call(service, info_in);
743 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
744 err
745 }
746 #[allow(clippy::field_reassign_with_default)]
747 pub fn seL4_IRQControl_Get(
748 &mut self,
749 service: seL4_IRQControl,
750 r#irq: seL4_Word,
751 r#root: seL4_CNode,
752 r#index: seL4_Word,
753 r#depth: seL4_Uint8,
754 ) -> seL4_Error::Type {
755 log::trace!(
756 "seL4_IRQControl_Get(_service={:?}, irq={:?}, root={:?}, index={:?}, depth={:?})",
757 service, r#irq, r#root, r#index, r#depth,
758 );
759 self.msg[..3usize].fill(0);
760 self.set_mr_bits(0usize..32usize, r#irq);
761 self.set_cap(0usize, r#root);
762 self.set_mr_bits(32usize..64usize, r#index);
763 self.set_mr_bits(64usize..72usize, r#depth);
764 let info_in = seL4_MessageInfo::new(
765 invocation_label::IRQIssueIRQHandler.into(),
766 0,
767 1u32,
768 3u32,
769 );
770 let info_out = self.seL4_Call(service, info_in);
771 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
772 err
773 }
774 #[allow(clippy::field_reassign_with_default)]
775 pub fn seL4_IRQHandler_Ack(&mut self, service: seL4_IRQHandler) -> seL4_Error::Type {
776 log::trace!("seL4_IRQHandler_Ack(_service={:?})", service,);
777 self.msg[..0usize].fill(0);
778 let info_in = seL4_MessageInfo::new(
779 invocation_label::IRQAckIRQ.into(),
780 0,
781 0u32,
782 0u32,
783 );
784 let info_out = self.seL4_Call(service, info_in);
785 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
786 err
787 }
788 #[allow(clippy::field_reassign_with_default)]
789 pub fn seL4_IRQHandler_SetNotification(
790 &mut self,
791 service: seL4_IRQHandler,
792 r#notification: seL4_CPtr,
793 ) -> seL4_Error::Type {
794 log::trace!(
795 "seL4_IRQHandler_SetNotification(_service={:?}, notification={:?})", service,
796 r#notification,
797 );
798 self.msg[..0usize].fill(0);
799 self.set_cap(0usize, r#notification);
800 let info_in = seL4_MessageInfo::new(
801 invocation_label::IRQSetIRQHandler.into(),
802 0,
803 1u32,
804 0u32,
805 );
806 let info_out = self.seL4_Call(service, info_in);
807 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
808 err
809 }
810 #[allow(clippy::field_reassign_with_default)]
811 pub fn seL4_IRQHandler_Clear(
812 &mut self,
813 service: seL4_IRQHandler,
814 ) -> seL4_Error::Type {
815 log::trace!("seL4_IRQHandler_Clear(_service={:?})", service,);
816 self.msg[..0usize].fill(0);
817 let info_in = seL4_MessageInfo::new(
818 invocation_label::IRQClearIRQHandler.into(),
819 0,
820 0u32,
821 0u32,
822 );
823 let info_out = self.seL4_Call(service, info_in);
824 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
825 err
826 }
827 #[allow(clippy::field_reassign_with_default)]
828 pub fn seL4_DomainSet_Set(
829 &mut self,
830 service: seL4_DomainSet,
831 r#domain: seL4_Uint8,
832 r#thread: seL4_TCB,
833 ) -> seL4_Error::Type {
834 log::trace!(
835 "seL4_DomainSet_Set(_service={:?}, domain={:?}, thread={:?})", service,
836 r#domain, r#thread,
837 );
838 self.msg[..1usize].fill(0);
839 self.set_mr_bits(0usize..8usize, r#domain);
840 self.set_cap(0usize, r#thread);
841 let info_in = seL4_MessageInfo::new(
842 invocation_label::DomainSetSet.into(),
843 0,
844 1u32,
845 1u32,
846 );
847 let info_out = self.seL4_Call(service, info_in);
848 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
849 err
850 }
851 #[allow(clippy::field_reassign_with_default)]
852 pub fn seL4_RISCV_PageTable_Map(
853 &mut self,
854 service: seL4_RISCV_PageTable,
855 r#vspace: seL4_RISCV_PageTable,
856 r#vaddr: seL4_Word,
857 r#attr: seL4_RISCV_VMAttributes::Type,
858 ) -> seL4_Error::Type {
859 log::trace!(
860 "seL4_RISCV_PageTable_Map(_service={:?}, vspace={:?}, vaddr={:?}, attr={:?})",
861 service, r#vspace, r#vaddr, r#attr,
862 );
863 self.msg[..2usize].fill(0);
864 self.set_cap(0usize, r#vspace);
865 self.set_mr_bits(0usize..32usize, r#vaddr);
866 self.set_mr_bits(32usize..64usize, r#attr);
867 let info_in = seL4_MessageInfo::new(
868 invocation_label::RISCVPageTableMap.into(),
869 0,
870 1u32,
871 2u32,
872 );
873 let info_out = self.seL4_Call(service, info_in);
874 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
875 err
876 }
877 #[allow(clippy::field_reassign_with_default)]
878 pub fn seL4_RISCV_PageTable_Unmap(
879 &mut self,
880 service: seL4_RISCV_PageTable,
881 ) -> seL4_Error::Type {
882 log::trace!("seL4_RISCV_PageTable_Unmap(_service={:?})", service,);
883 self.msg[..0usize].fill(0);
884 let info_in = seL4_MessageInfo::new(
885 invocation_label::RISCVPageTableUnmap.into(),
886 0,
887 0u32,
888 0u32,
889 );
890 let info_out = self.seL4_Call(service, info_in);
891 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
892 err
893 }
894 #[allow(clippy::field_reassign_with_default)]
895 pub fn seL4_RISCV_Page_Map(
896 &mut self,
897 service: seL4_RISCV_Page,
898 r#vspace: seL4_RISCV_PageTable,
899 r#vaddr: seL4_Word,
900 r#rights: seL4_CapRights_t,
901 r#attr: seL4_RISCV_VMAttributes::Type,
902 ) -> seL4_Error::Type {
903 log::trace!(
904 "seL4_RISCV_Page_Map(_service={:?}, vspace={:?}, vaddr={:?}, rights={:?}, attr={:?})",
905 service, r#vspace, r#vaddr, r#rights, r#attr,
906 );
907 self.msg[..3usize].fill(0);
908 self.set_cap(0usize, r#vspace);
909 self.set_mr_bits(0usize..32usize, r#vaddr);
910 self.set_mr_bits_from_slice(32usize..64usize, r#rights.0.inner());
911 self.set_mr_bits(64usize..96usize, r#attr);
912 let info_in = seL4_MessageInfo::new(
913 invocation_label::RISCVPageMap.into(),
914 0,
915 1u32,
916 3u32,
917 );
918 let info_out = self.seL4_Call(service, info_in);
919 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
920 err
921 }
922 #[allow(clippy::field_reassign_with_default)]
923 pub fn seL4_RISCV_Page_Unmap(
924 &mut self,
925 service: seL4_RISCV_Page,
926 ) -> seL4_Error::Type {
927 log::trace!("seL4_RISCV_Page_Unmap(_service={:?})", service,);
928 self.msg[..0usize].fill(0);
929 let info_in = seL4_MessageInfo::new(
930 invocation_label::RISCVPageUnmap.into(),
931 0,
932 0u32,
933 0u32,
934 );
935 let info_out = self.seL4_Call(service, info_in);
936 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
937 err
938 }
939 #[allow(clippy::field_reassign_with_default)]
940 pub fn seL4_RISCV_Page_GetAddress(
941 &mut self,
942 service: seL4_RISCV_Page,
943 ) -> seL4_RISCV_Page_GetAddress_ret {
944 log::trace!("seL4_RISCV_Page_GetAddress(_service={:?})", service,);
945 self.msg[..0usize].fill(0);
946 let info_in = seL4_MessageInfo::new(
947 invocation_label::RISCVPageGetAddress.into(),
948 0,
949 0u32,
950 0u32,
951 );
952 let info_out = self.seL4_Call(service, info_in);
953 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
954 let mut ret: seL4_RISCV_Page_GetAddress_ret = Default::default();
955 ret.error = err;
956 ret.paddr = self.get_mr_bits(0usize..32usize);
957 ret
958 }
959 #[allow(clippy::field_reassign_with_default)]
960 pub fn seL4_RISCV_ASIDControl_MakePool(
961 &mut self,
962 service: seL4_RISCV_ASIDControl,
963 r#untyped: seL4_Untyped,
964 r#root: seL4_CNode,
965 r#index: seL4_Word,
966 r#depth: seL4_Uint8,
967 ) -> seL4_Error::Type {
968 log::trace!(
969 "seL4_RISCV_ASIDControl_MakePool(_service={:?}, untyped={:?}, root={:?}, index={:?}, depth={:?})",
970 service, r#untyped, r#root, r#index, r#depth,
971 );
972 self.msg[..2usize].fill(0);
973 self.set_cap(0usize, r#untyped);
974 self.set_cap(1usize, r#root);
975 self.set_mr_bits(0usize..32usize, r#index);
976 self.set_mr_bits(32usize..40usize, r#depth);
977 let info_in = seL4_MessageInfo::new(
978 invocation_label::RISCVASIDControlMakePool.into(),
979 0,
980 2u32,
981 2u32,
982 );
983 let info_out = self.seL4_Call(service, info_in);
984 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
985 err
986 }
987 #[allow(clippy::field_reassign_with_default)]
988 pub fn seL4_RISCV_ASIDPool_Assign(
989 &mut self,
990 service: seL4_RISCV_ASIDPool,
991 r#vspace: seL4_CPtr,
992 ) -> seL4_Error::Type {
993 log::trace!(
994 "seL4_RISCV_ASIDPool_Assign(_service={:?}, vspace={:?})", service, r#vspace,
995 );
996 self.msg[..0usize].fill(0);
997 self.set_cap(0usize, r#vspace);
998 let info_in = seL4_MessageInfo::new(
999 invocation_label::RISCVASIDPoolAssign.into(),
1000 0,
1001 1u32,
1002 0u32,
1003 );
1004 let info_out = self.seL4_Call(service, info_in);
1005 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
1006 err
1007 }
1008 #[allow(clippy::field_reassign_with_default)]
1009 pub fn seL4_IRQControl_GetTrigger(
1010 &mut self,
1011 service: seL4_IRQControl,
1012 r#irq: seL4_Word,
1013 r#trigger: seL4_Word,
1014 r#root: seL4_CNode,
1015 r#index: seL4_Word,
1016 r#depth: seL4_Uint8,
1017 ) -> seL4_Error::Type {
1018 log::trace!(
1019 "seL4_IRQControl_GetTrigger(_service={:?}, irq={:?}, trigger={:?}, root={:?}, index={:?}, depth={:?})",
1020 service, r#irq, r#trigger, r#root, r#index, r#depth,
1021 );
1022 self.msg[..4usize].fill(0);
1023 self.set_mr_bits(0usize..32usize, r#irq);
1024 self.set_mr_bits(32usize..64usize, r#trigger);
1025 self.set_cap(0usize, r#root);
1026 self.set_mr_bits(64usize..96usize, r#index);
1027 self.set_mr_bits(96usize..104usize, r#depth);
1028 let info_in = seL4_MessageInfo::new(
1029 invocation_label::RISCVIRQIssueIRQHandlerTrigger.into(),
1030 0,
1031 1u32,
1032 4u32,
1033 );
1034 let info_out = self.seL4_Call(service, info_in);
1035 let err: seL4_Error::Type = info_out.get_label().try_into().unwrap();
1036 err
1037 }
1038}