Glibc syscalls now block properly (XCC)
[akaros.git] / tools / compilers / gcc-glibc / glibc-2.14.1-ros / sysdeps / ros / syscall.c
1 /* Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with the GNU C Library; if not, write to the Free
16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
17    02111-1307 USA.  */
18
19 #include <sysdep.h>
20 #include <errno.h>
21 #include <unistd.h>
22 #include <stdarg.h>
23 #include <sys/syscall.h>
24 #include <arch/atomic.h>
25 #include <ros/procdata.h>
26
27 /* This is a simple ev_q that routes notifs to vcore0's public mbox.  This
28  * should work for any bit messages, even if the process hasn't done any set up
29  * yet, since the memory for the mbox is allocted by the kernel (procdata).
30  * Don't send full messages to it, since the UCQ won't be initialized.  Note
31  * that the kernel will actually ignore your ev_mbox and just about everything
32  * other than flags if you're an SCP, but that might change later. */
33 struct event_queue __ros_scp_simple_evq =
34                   { .ev_mbox = &__procdata.vcore_preempt_data[0].ev_mbox_public,
35                     .ev_flags = EVENT_IPI | EVENT_NOMSG, 
36                     .ev_alert_pending = FALSE,
37                     .ev_vcore = 0,
38                     .ev_handler = 0 };
39
40 /* Helper, from u/p/uthread.c.  Keep it in sync.  (don't want to move this into
41  * glibc yet). */
42 static bool register_evq(struct syscall *sysc, struct event_queue *ev_q)
43 {
44         int old_flags;
45         sysc->ev_q = ev_q;
46         wrmb(); /* don't let that write pass any future reads (flags) */
47         /* Try and set the SC_UEVENT flag (so the kernel knows to look at ev_q) */
48         do {
49                 /* no cmb() needed, the atomic_read will reread flags */
50                 old_flags = atomic_read(&sysc->flags);
51                 /* Spin if the kernel is mucking with syscall flags */
52                 while (old_flags & SC_K_LOCK)
53                         old_flags = atomic_read(&sysc->flags);
54                 /* If the kernel finishes while we are trying to sign up for an event,
55                  * we need to bail out */
56                 if (old_flags & (SC_DONE | SC_PROGRESS)) {
57                         sysc->ev_q = 0;         /* not necessary, but might help with bugs */
58                         return FALSE;
59                 }
60         } while (!atomic_cas(&sysc->flags, old_flags, old_flags | SC_UEVENT));
61         return TRUE;
62 }
63
64 /* Glibc initial blockon, usable before parlib code can init things (or if it
65  * never can, like for RTLD).  MCPs will need the 'uthread-aware' blockon. */
66 void __ros_scp_syscall_blockon(struct syscall *sysc)
67 {
68         /* Ask for a SYSCALL event when the sysc is done.  We don't need a handler,
69          * we just need the kernel to restart us from proc_yield.  If register
70          * fails, we're already done. */
71         if (register_evq(sysc, &__ros_scp_simple_evq)) {
72                 /* Sending false for now - we want to signal proc code that we want to
73                  * wait (piggybacking on the MCP meaning of this variable) */
74                 __ros_syscall(SYS_yield, FALSE, 0, 0, 0, 0, 0, 0);
75         }
76 }
77
78 /* Function pointer for the blockon function.  MCPs need to switch to the parlib
79  * blockon before becoming an MCP.  Default is the glibc SCP handler */
80 void (*ros_syscall_blockon)(struct syscall *sysc) = __ros_scp_syscall_blockon;
81
82 /* TODO: make variants of __ros_syscall() based on the number of args (0 - 6) */
83 /* These are simple synchronous system calls, built on top of the kernel's async
84  * interface.  This version makes no assumptions about errno.  You usually don't
85  * want this. */
86 long __ros_syscall(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
87                    long _a4, long _a5, int *errno_loc)
88 {
89         int num_started;        /* not used yet */
90         struct syscall sysc = {0};
91         sysc.num = _num;
92         sysc.ev_q = 0;
93         sysc.arg0 = _a0;
94         sysc.arg1 = _a1;
95         sysc.arg2 = _a2;
96         sysc.arg3 = _a3;
97         sysc.arg4 = _a4;
98         sysc.arg5 = _a5;
99         num_started = __ros_arch_syscall(&sysc, 1);
100         /* Don't proceed til we are done */
101         while (!(atomic_read(&sysc.flags) & SC_DONE))
102                 ros_syscall_blockon(&sysc);
103         /* Need to wait til it is unlocked.  It's not really done until SC_DONE &
104          * !SC_K_LOCK. */
105         while (atomic_read(&sysc.flags) & SC_K_LOCK)
106                 cpu_relax();
107         if (errno_loc)
108                 *errno_loc = sysc.err;
109         return sysc.retval;
110 }
111
112 /* This version knows about errno and will handle it. */
113 long __ros_syscall_errno(unsigned int _num, long _a0, long _a1, long _a2,
114                          long _a3, long _a4, long _a5)
115 {
116         return __ros_syscall(_num, _a0, _a1, _a2, _a3, _a4, _a5, &errno);
117 }
118
119 long int syscall(long int num, ...)
120 {
121         va_list vl;
122         va_start(vl, num);
123         long int a0 = va_arg(vl, long int);
124         long int a1 = va_arg(vl, long int);
125         long int a2 = va_arg(vl, long int);
126         long int a3 = va_arg(vl, long int);
127         long int a4 = va_arg(vl, long int);
128         long int a5 = va_arg(vl, long int);
129         va_end(vl);
130         
131         return ros_syscall(num, a0, a1, a2, a3, a4, a5);
132 }
133