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