1use core::ffi::c_int;
8use core::sync::atomic::{Ordering, compiler_fence};
9
10use sel4_config::{sel4_cfg, sel4_cfg_if};
11
12#[allow(unused_imports)]
13use crate::{
14 ReplyAuthority, WaitMessageInfo, seL4_CPtr, seL4_IPCBuffer, seL4_MessageInfo, seL4_Uint32,
15 seL4_Word, syscall_id,
16};
17
18#[allow(unused_imports)]
19use crate::seL4_Error;
20
21use super::helpers::*;
22
23const UNUSED_REPLY_ARG: seL4_Word = 0;
24
25fn reply_authority_to_sys_arg(#[allow(unused_variables)] authority: ReplyAuthority) -> seL4_Word {
26 sel4_cfg_if! {
27 if #[sel4_cfg(KERNEL_MCS)] {
28 authority
29 } else {
30 UNUSED_REPLY_ARG
31 }
32 }
33}
34
35macro_rules! fill_mrs_from_ipc_buffer {
36 ($ipcbuf:ident, $mr0:ident, $mr1:ident, $mr2:ident, $mr3:ident) => {
37 $mr0 = $ipcbuf.get_mr(0);
38 $mr1 = $ipcbuf.get_mr(1);
39 $mr2 = $ipcbuf.get_mr(2);
40 $mr3 = $ipcbuf.get_mr(3);
41 };
42}
43
44macro_rules! empty_mrs_to_ipc_buffer {
45 ($ipcbuf:ident, $mr0:ident, $mr1:ident, $mr2:ident, $mr3:ident) => {
46 $ipcbuf.set_mr(0, $mr0);
47 $ipcbuf.set_mr(1, $mr1);
48 $ipcbuf.set_mr(2, $mr2);
49 $ipcbuf.set_mr(3, $mr3);
50 };
51}
52
53#[rustfmt::skip]
54macro_rules! fill_mrs_from_args {
55 (
56 $msg_info:ident,
57 $mr0:ident, $mr1:ident, $mr2:ident, $mr3:ident,
58 $msg0:ident, $msg1:ident, $msg2:ident, $msg3:ident,
59 ) => {
60 $mr0 = 0;
61 $mr1 = 0;
62 $mr2 = 0;
63 $mr3 = 0;
64
65 let n = $msg_info.get_length();
66
67 if let Some(msg) = &$msg0 && n > 0 {
68 $mr0 = **msg;
69 }
70 if let Some(msg) = &$msg1 && n > 1 {
71 $mr1 = **msg;
72 }
73 if let Some(msg) = &$msg2 && n > 2 {
74 $mr2 = **msg;
75 }
76 if let Some(msg) = &$msg3 && n > 3 {
77 $mr3 = **msg;
78 }
79 };
80}
81
82macro_rules! fill_mrs_from_in_args {
83 (
84 $msg_info:ident,
85 $mr0:ident, $mr1:ident, $mr2:ident, $mr3:ident,
86 $msg0:ident, $msg1:ident, $msg2:ident, $msg3:ident,
87 ) => {
88 $mr0 = $msg_info.msg_helper($msg0, 0);
89 $mr1 = $msg_info.msg_helper($msg1, 1);
90 $mr2 = $msg_info.msg_helper($msg2, 2);
91 $mr3 = $msg_info.msg_helper($msg3, 3);
92 };
93}
94
95macro_rules! empty_mrs_to_args {
96 (
97 $mr0:ident, $mr1:ident, $mr2:ident, $mr3:ident,
98 $msg0:ident, $msg1:ident, $msg2:ident, $msg3:ident,
99 ) => {
100 if let Some(msg) = $msg0 {
101 *msg = $mr0;
102 }
103 if let Some(msg) = $msg1 {
104 *msg = $mr1;
105 }
106 if let Some(msg) = $msg2 {
107 *msg = $mr2;
108 }
109 if let Some(msg) = $msg3 {
110 *msg = $mr3;
111 }
112 };
113}
114
115macro_rules! fence {
117 () => {
118 compiler_fence(Ordering::SeqCst);
119 };
120}
121
122#[allow(dead_code)]
123fn sys_send_recv_simple(sys_id: c_int, arg: seL4_Word) -> seL4_Word {
124 let mut mr0 = 0;
125 let mut mr1 = 0;
126 let mut mr2 = 0;
127 let mut mr3 = 0;
128
129 let (_msg_info, ret) = sys_send_recv(
130 sys_id,
131 arg,
132 seL4_MessageInfo::new(0, 0, 0, 0),
133 &mut mr0,
134 &mut mr1,
135 &mut mr2,
136 &mut mr3,
137 UNUSED_REPLY_ARG,
138 );
139
140 ret
141}
142
143impl seL4_IPCBuffer {
144 pub fn seL4_Send(&mut self, dest: seL4_CPtr, msg_info: seL4_MessageInfo) {
145 let mr0;
146 let mr1;
147 let mr2;
148 let mr3;
149
150 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
151
152 sys_send(syscall_id::Send, dest, msg_info, mr0, mr1, mr2, mr3)
153 }
154
155 pub fn seL4_SendWithMRs(
156 &mut self,
157 dest: seL4_CPtr,
158 msg_info: seL4_MessageInfo,
159 msg0: Option<seL4_Word>,
160 msg1: Option<seL4_Word>,
161 msg2: Option<seL4_Word>,
162 msg3: Option<seL4_Word>,
163 ) {
164 seL4_SendWithMRsWithoutIPCBuffer(dest, msg_info, msg0, msg1, msg2, msg3)
165 }
166
167 pub fn seL4_NBSend(&mut self, dest: seL4_CPtr, msg_info: seL4_MessageInfo) {
168 let mr0;
169 let mr1;
170 let mr2;
171 let mr3;
172
173 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
174
175 sys_send(syscall_id::NBSend, dest, msg_info, mr0, mr1, mr2, mr3)
176 }
177
178 pub fn seL4_NBSendWithMRs(
179 &mut self,
180 dest: seL4_CPtr,
181 msg_info: seL4_MessageInfo,
182 msg0: Option<seL4_Word>,
183 msg1: Option<seL4_Word>,
184 msg2: Option<seL4_Word>,
185 msg3: Option<seL4_Word>,
186 ) {
187 seL4_NBSendWithMRsWithoutIPCBuffer(dest, msg_info, msg0, msg1, msg2, msg3)
188 }
189
190 #[sel4_cfg(not(KERNEL_MCS))]
191 pub fn seL4_Reply(&mut self, msg_info: seL4_MessageInfo) {
192 let mr0;
193 let mr1;
194 let mr2;
195 let mr3;
196
197 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
198
199 sys_reply(syscall_id::Reply, msg_info, mr0, mr1, mr2, mr3)
200 }
201
202 #[sel4_cfg(not(KERNEL_MCS))]
203 pub fn seL4_ReplyWithMRs(
204 &mut self,
205 msg_info: seL4_MessageInfo,
206 msg0: Option<seL4_Word>,
207 msg1: Option<seL4_Word>,
208 msg2: Option<seL4_Word>,
209 msg3: Option<seL4_Word>,
210 ) {
211 seL4_ReplyWithMRsWithoutIPCBuffer(msg_info, msg0, msg1, msg2, msg3)
212 }
213
214 pub fn seL4_Signal(&mut self, dest: seL4_CPtr) {
215 let msg_info = seL4_MessageInfo::new(0, 0, 0, 0);
216
217 sys_send_null(syscall_id::Send, dest, msg_info)
218 }
219
220 pub fn seL4_Recv(
221 &mut self,
222 src: seL4_CPtr,
223 reply_authority: ReplyAuthority,
224 ) -> (seL4_MessageInfo, seL4_Word) {
225 let mut mr0 = 0;
226 let mut mr1 = 0;
227 let mut mr2 = 0;
228 let mut mr3 = 0;
229
230 let ret = sys_recv(
231 syscall_id::Recv,
232 src,
233 &mut mr0,
234 &mut mr1,
235 &mut mr2,
236 &mut mr3,
237 reply_authority_to_sys_arg(reply_authority),
238 );
239
240 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
241
242 ret
243 }
244
245 pub fn seL4_RecvWithMRs(
246 &mut self,
247 src: seL4_CPtr,
248 msg0: Option<&mut seL4_Word>,
249 msg1: Option<&mut seL4_Word>,
250 msg2: Option<&mut seL4_Word>,
251 msg3: Option<&mut seL4_Word>,
252 reply_authority: ReplyAuthority,
253 ) -> (seL4_MessageInfo, seL4_Word) {
254 seL4_RecvWithMRsWithoutIPCBuffer(src, msg0, msg1, msg2, msg3, reply_authority)
255 }
256
257 pub fn seL4_NBRecv(
258 &mut self,
259 src: seL4_CPtr,
260 reply_authority: ReplyAuthority,
261 ) -> (seL4_MessageInfo, seL4_Word) {
262 let mut mr0 = 0;
263 let mut mr1 = 0;
264 let mut mr2 = 0;
265 let mut mr3 = 0;
266
267 let ret = sys_recv(
268 syscall_id::NBRecv,
269 src,
270 &mut mr0,
271 &mut mr1,
272 &mut mr2,
273 &mut mr3,
274 reply_authority_to_sys_arg(reply_authority),
275 );
276
277 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
278
279 ret
280 }
281
282 pub fn seL4_Call(&mut self, dest: seL4_CPtr, msg_info: seL4_MessageInfo) -> seL4_MessageInfo {
283 let mut mr0;
284 let mut mr1;
285 let mut mr2;
286 let mut mr3;
287
288 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
289
290 let (out_msg_info, _badge) = sys_send_recv(
291 syscall_id::Call,
292 dest,
293 msg_info,
294 &mut mr0,
295 &mut mr1,
296 &mut mr2,
297 &mut mr3,
298 UNUSED_REPLY_ARG,
299 );
300
301 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
302
303 out_msg_info
304 }
305
306 pub fn seL4_CallWithMRs(
307 &mut self,
308 dest: seL4_CPtr,
309 msg_info: seL4_MessageInfo,
310 msg0: Option<&mut seL4_Word>,
311 msg1: Option<&mut seL4_Word>,
312 msg2: Option<&mut seL4_Word>,
313 msg3: Option<&mut seL4_Word>,
314 ) -> seL4_MessageInfo {
315 seL4_CallWithMRsWithoutIPCBuffer(dest, msg_info, msg0, msg1, msg2, msg3)
316 }
317
318 pub fn seL4_ReplyRecv(
319 &mut self,
320 src: seL4_CPtr,
321 msg_info: seL4_MessageInfo,
322 reply_authority: ReplyAuthority,
323 ) -> (seL4_MessageInfo, seL4_Word) {
324 let mut mr0;
325 let mut mr1;
326 let mut mr2;
327 let mut mr3;
328
329 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
330
331 let ret = sys_send_recv(
332 syscall_id::ReplyRecv,
333 src,
334 msg_info,
335 &mut mr0,
336 &mut mr1,
337 &mut mr2,
338 &mut mr3,
339 reply_authority_to_sys_arg(reply_authority),
340 );
341
342 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
343
344 ret
345 }
346
347 sel4_cfg_if! {
348 if #[sel4_cfg(KERNEL_MCS)] {
349 pub fn seL4_NBSendRecv(
350 &mut self,
351 dest: seL4_CPtr,
352 msg_info: seL4_MessageInfo,
353 src: seL4_CPtr,
354 reply_authority: ReplyAuthority,
355 ) -> (seL4_MessageInfo, seL4_Word) {
356 let mut mr0;
357 let mut mr1;
358 let mut mr2;
359 let mut mr3;
360
361 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
362
363 let ret = sys_nb_send_recv(
364 syscall_id::NBSendRecv,
365 dest,
366 src,
367 msg_info,
368 &mut mr0,
369 &mut mr1,
370 &mut mr2,
371 &mut mr3,
372 reply_authority_to_sys_arg(reply_authority),
373 );
374
375 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
376
377 ret
378 }
379
380 pub fn seL4_NBSendWait(
381 &mut self,
382 dest: seL4_CPtr,
383 msg_info: seL4_MessageInfo,
384 src: seL4_CPtr,
385 ) -> (seL4_MessageInfo, seL4_Word) {
386 let mut mr0;
387 let mut mr1;
388 let mut mr2;
389 let mut mr3;
390
391 fill_mrs_from_ipc_buffer!(self, mr0, mr1, mr2, mr3);
392
393 let ret = sys_nb_send_recv(
394 syscall_id::NBSendWait,
395 0,
396 src,
397 msg_info,
398 &mut mr0,
399 &mut mr1,
400 &mut mr2,
401 &mut mr3,
402 dest,
403 );
404
405 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
406
407 ret
408 }
409
410 pub fn seL4_Wait(&mut self, src: seL4_CPtr) -> (WaitMessageInfo, seL4_Word) {
411 let mut mr0 = 0;
412 let mut mr1 = 0;
413 let mut mr2 = 0;
414 let mut mr3 = 0;
415
416 let ret = sys_recv(
417 syscall_id::Wait,
418 src,
419 &mut mr0,
420 &mut mr1,
421 &mut mr2,
422 &mut mr3,
423 UNUSED_REPLY_ARG,
424 );
425
426 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
427
428 ret
429 }
430
431 #[sel4_cfg(KERNEL_MCS)]
432 pub fn seL4_WaitWithMRs(
433 &mut self,
434 src: seL4_CPtr,
435 msg0: Option<&mut seL4_Word>,
436 msg1: Option<&mut seL4_Word>,
437 msg2: Option<&mut seL4_Word>,
438 msg3: Option<&mut seL4_Word>,
439 ) -> (WaitMessageInfo, seL4_Word) {
440 seL4_WaitWithMRsWithoutIPCBuffer(src, msg0, msg1, msg2, msg3)
441 }
442
443 pub fn seL4_NBWait(&mut self, src: seL4_CPtr) -> (WaitMessageInfo, seL4_Word) {
444 let mut mr0 = 0;
445 let mut mr1 = 0;
446 let mut mr2 = 0;
447 let mut mr3 = 0;
448
449 let ret = sys_recv(
450 syscall_id::NBWait,
451 src,
452 &mut mr0,
453 &mut mr1,
454 &mut mr2,
455 &mut mr3,
456 UNUSED_REPLY_ARG,
457 );
458
459 empty_mrs_to_ipc_buffer!(self, mr0, mr1, mr2, mr3);
460
461 ret
462 }
463 } else {
464
465 pub fn seL4_Wait(&mut self, src: seL4_CPtr) -> (WaitMessageInfo, seL4_Word) {
466 let (_msg_info, badge) = self.seL4_Recv(src, ());
467 ((), badge)
468 }
469
470 }
471 }
472
473 pub fn seL4_Poll(&mut self, src: seL4_CPtr) -> (seL4_MessageInfo, seL4_Word) {
474 sel4_cfg_if! {
475 if #[sel4_cfg(KERNEL_MCS)] {
476 self.seL4_NBWait(src)
477 } else {
478 self.seL4_NBRecv(src, ())
479 }
480 }
481 }
482}
483
484pub fn seL4_SendWithMRsWithoutIPCBuffer(
485 dest: seL4_CPtr,
486 msg_info: seL4_MessageInfo,
487 msg0: Option<seL4_Word>,
488 msg1: Option<seL4_Word>,
489 msg2: Option<seL4_Word>,
490 msg3: Option<seL4_Word>,
491) {
492 let mr0;
493 let mr1;
494 let mr2;
495 let mr3;
496
497 fill_mrs_from_in_args!(msg_info, mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
498
499 sys_send(syscall_id::Send, dest, msg_info, mr0, mr1, mr2, mr3)
500}
501
502pub fn seL4_NBSendWithMRsWithoutIPCBuffer(
503 dest: seL4_CPtr,
504 msg_info: seL4_MessageInfo,
505 msg0: Option<seL4_Word>,
506 msg1: Option<seL4_Word>,
507 msg2: Option<seL4_Word>,
508 msg3: Option<seL4_Word>,
509) {
510 let mr0;
511 let mr1;
512 let mr2;
513 let mr3;
514
515 fill_mrs_from_in_args!(msg_info, mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
516
517 sys_send(syscall_id::NBSend, dest, msg_info, mr0, mr1, mr2, mr3)
518}
519
520#[sel4_cfg(not(KERNEL_MCS))]
521pub fn seL4_ReplyWithMRsWithoutIPCBuffer(
522 msg_info: seL4_MessageInfo,
523 msg0: Option<seL4_Word>,
524 msg1: Option<seL4_Word>,
525 msg2: Option<seL4_Word>,
526 msg3: Option<seL4_Word>,
527) {
528 let mr0;
529 let mr1;
530 let mr2;
531 let mr3;
532
533 fill_mrs_from_in_args!(msg_info, mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
534
535 sys_reply(syscall_id::Reply, msg_info, mr0, mr1, mr2, mr3)
536}
537
538pub fn seL4_RecvWithMRsWithoutIPCBuffer(
539 src: seL4_CPtr,
540 msg0: Option<&mut seL4_Word>,
541 msg1: Option<&mut seL4_Word>,
542 msg2: Option<&mut seL4_Word>,
543 msg3: Option<&mut seL4_Word>,
544 reply_authority: ReplyAuthority,
545) -> (seL4_MessageInfo, seL4_Word) {
546 let mut mr0 = 0;
547 let mut mr1 = 0;
548 let mut mr2 = 0;
549 let mut mr3 = 0;
550
551 let ret = sys_recv(
552 syscall_id::Recv,
553 src,
554 &mut mr0,
555 &mut mr1,
556 &mut mr2,
557 &mut mr3,
558 reply_authority_to_sys_arg(reply_authority),
559 );
560
561 empty_mrs_to_args!(mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
562
563 ret
564}
565
566pub fn seL4_CallWithMRsWithoutIPCBuffer(
567 dest: seL4_CPtr,
568 msg_info: seL4_MessageInfo,
569 msg0: Option<&mut seL4_Word>,
570 msg1: Option<&mut seL4_Word>,
571 msg2: Option<&mut seL4_Word>,
572 msg3: Option<&mut seL4_Word>,
573) -> seL4_MessageInfo {
574 let mut mr0;
575 let mut mr1;
576 let mut mr2;
577 let mut mr3;
578
579 fill_mrs_from_args!(msg_info, mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
580
581 let (out_msg_info, _badge) = sys_send_recv(
582 syscall_id::Call,
583 dest,
584 msg_info,
585 &mut mr0,
586 &mut mr1,
587 &mut mr2,
588 &mut mr3,
589 UNUSED_REPLY_ARG,
590 );
591
592 empty_mrs_to_args!(mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
593
594 out_msg_info
595}
596
597#[sel4_cfg(KERNEL_MCS)]
598pub fn seL4_WaitWithMRsWithoutIPCBuffer(
599 src: seL4_CPtr,
600 msg0: Option<&mut seL4_Word>,
601 msg1: Option<&mut seL4_Word>,
602 msg2: Option<&mut seL4_Word>,
603 msg3: Option<&mut seL4_Word>,
604) -> (WaitMessageInfo, seL4_Word) {
605 let mut mr0 = 0;
606 let mut mr1 = 0;
607 let mut mr2 = 0;
608 let mut mr3 = 0;
609
610 let ret = sys_recv(
611 syscall_id::Wait,
612 src,
613 &mut mr0,
614 &mut mr1,
615 &mut mr2,
616 &mut mr3,
617 UNUSED_REPLY_ARG,
618 );
619
620 empty_mrs_to_args!(mr0, mr1, mr2, mr3, msg0, msg1, msg2, msg3,);
621
622 ret
623}
624
625pub fn seL4_Yield() {
626 sys_null(syscall_id::Yield);
627 fence!();
628}
629
630#[sel4_cfg(PRINTING)]
631pub fn seL4_DebugPutChar(c: u8) {
632 sys_send_recv_simple(syscall_id::DebugPutChar, c as seL4_Word);
633}
634
635sel4_cfg_if! {
636 if #[sel4_cfg(DEBUG_BUILD)] {
637 pub fn seL4_DebugHalt() {
638 sys_null(syscall_id::DebugHalt);
639 fence!();
640 }
641
642 pub fn seL4_DebugSnapshot() {
643 sys_null(syscall_id::DebugSnapshot);
644 fence!();
645 }
646
647 pub fn seL4_DebugCapIdentify(cap: seL4_CPtr) -> seL4_Uint32 {
648 sys_send_recv_simple(syscall_id::DebugCapIdentify, cap) as seL4_Uint32
649 }
650
651 pub fn seL4_DebugNameThread(tcb: seL4_CPtr, name: &[u8], ipc_buffer: &mut seL4_IPCBuffer) {
652 let mut mr0 = 0;
653 let mut mr1 = 0;
654 let mut mr2 = 0;
655 let mut mr3 = 0;
656
657 let ipc_buffer_msg_bytes = ipc_buffer.msg_bytes_mut();
658 ipc_buffer_msg_bytes[0..name.len()].copy_from_slice(name);
659 ipc_buffer_msg_bytes[name.len()] = 0;
660
661 let _ = sys_send_recv(
662 syscall_id::DebugNameThread,
663 tcb,
664 seL4_MessageInfo::new(0, 0, 0, 0),
665 &mut mr0,
666 &mut mr1,
667 &mut mr2,
668 &mut mr3,
669 UNUSED_REPLY_ARG,
670 );
671 }
672 }
673}
674
675sel4_cfg_if! {
676 if #[sel4_cfg(ENABLE_BENCHMARKS)] {
677 pub fn seL4_BenchmarkResetLog() -> seL4_Error::Type {
678 sys_send_recv_simple(
679 syscall_id::BenchmarkResetLog,
680 0,
681 ) as seL4_Error::Type
682 }
683
684 pub fn seL4_BenchmarkFinalizeLog() -> seL4_Word {
685 sys_send_recv_simple(
686 syscall_id::BenchmarkFinalizeLog,
687 0,
688 )
689 }
690
691 pub fn seL4_BenchmarkSetLogBuffer(frame_cap: seL4_CPtr) -> seL4_Error::Type {
692 sys_send_recv_simple(
693 syscall_id::BenchmarkSetLogBuffer,
694 frame_cap,
695 ) as seL4_Error::Type
696 }
697
698 sel4_cfg_if! {
699 if #[sel4_cfg(BENCHMARK_TRACK_UTILISATION)] {
700 pub fn seL4_BenchmarkGetThreadUtilisation(tcb: seL4_CPtr) {
701 sys_send_recv_simple(
702 syscall_id::BenchmarkGetThreadUtilisation,
703 tcb,
704 );
705 }
706
707 pub fn seL4_BenchmarkResetThreadUtilisation(tcb: seL4_CPtr) {
708 sys_send_recv_simple(
709 syscall_id::BenchmarkResetThreadUtilisation,
710 tcb,
711 );
712 }
713
714 sel4_cfg_if! {
715 if #[sel4_cfg(DEBUG_BUILD)] {
716 pub fn seL4_BenchmarkDumpAllThreadsUtilisation() {
717 sys_send_recv_simple(
718 syscall_id::BenchmarkDumpAllThreadsUtilisation,
719 0,
720 );
721 }
722
723 pub fn seL4_BenchmarkResetAllThreadsUtilisation() {
724 sys_send_recv_simple(
725 syscall_id::BenchmarkResetAllThreadsUtilisation,
726 0,
727 );
728 }
729 }
730 }
731 }
732 }
733 }
734}
735
736#[sel4_cfg(SET_TLS_BASE_SELF)]
737pub fn seL4_SetTLSBase(tls_base: seL4_Word) {
738 let msg_info = seL4_MessageInfo::new(0, 0, 0, 0);
739 sys_send_null(syscall_id::SetTLSBase, tls_base, msg_info)
740}