Bypass GOT/PLT for __ros_syscall within libc
[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         /* Need to disable notifs before registering, so we don't take an __notify
69          * that drops us into VC ctx and forces us to eat the notif_pending that was
70          * meant to prevent us from yielding if the syscall completed early. */
71         __procdata.vcore_preempt_data[0].notif_disabled = FALSE;
72         /* Ask for a SYSCALL event when the sysc is done.  We don't need a handler,
73          * we just need the kernel to restart us from proc_yield.  If register
74          * fails, we're already done. */
75         if (register_evq(sysc, &__ros_scp_simple_evq)) {
76                 /* Sending false for now - we want to signal proc code that we want to
77                  * wait (piggybacking on the MCP meaning of this variable) */
78                 __ros_syscall(SYS_yield, FALSE, 0, 0, 0, 0, 0, 0);
79         }
80         /* Manually doing an enable_notifs for VC 0 */
81         __procdata.vcore_preempt_data[0].notif_disabled = TRUE;
82         wrmb(); /* need to read after the write that enabled notifs */
83         if (__procdata.vcore_preempt_data[0].notif_pending)
84                 __ros_syscall(SYS_self_notify, 0, EV_NONE, 0, TRUE, 0, 0, 0);
85 }
86
87 /* Function pointer for the blockon function.  MCPs need to switch to the parlib
88  * blockon before becoming an MCP.  Default is the glibc SCP handler */
89 void (*ros_syscall_blockon)(struct syscall *sysc) = __ros_scp_syscall_blockon;
90
91 /* TODO: make variants of __ros_syscall() based on the number of args (0 - 6) */
92 /* These are simple synchronous system calls, built on top of the kernel's async
93  * interface.  This version makes no assumptions about errno.  You usually don't
94  * want this. */
95 static inline struct syscall
96 __ros_syscall_inline(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
97                      long _a4, long _a5)
98 {
99         int num_started;        /* not used yet */
100         struct syscall sysc = {0};
101         sysc.num = _num;
102         sysc.ev_q = 0;
103         sysc.arg0 = _a0;
104         sysc.arg1 = _a1;
105         sysc.arg2 = _a2;
106         sysc.arg3 = _a3;
107         sysc.arg4 = _a4;
108         sysc.arg5 = _a5;
109         num_started = __ros_arch_syscall(&sysc, 1);
110         /* Don't proceed til we are done */
111         while (!(atomic_read(&sysc.flags) & SC_DONE))
112                 ros_syscall_blockon(&sysc);
113         /* Need to wait til it is unlocked.  It's not really done until SC_DONE &
114          * !SC_K_LOCK. */
115         while (atomic_read(&sysc.flags) & SC_K_LOCK)
116                 cpu_relax();
117         return sysc;
118 }
119
120 long __ros_syscall(unsigned int _num, long _a0, long _a1, long _a2, long _a3,
121                    long _a4, long _a5, int *errno_loc)
122 {
123         struct syscall sysc = __ros_syscall_inline(_num, _a0, _a1, _a2, _a3,
124                                                    _a4, _a5);
125         if (__builtin_expect(errno_loc && sysc.err, 0))
126                 *errno_loc = sysc.err;
127         return sysc.retval;
128 }
129 libc_hidden_def(__ros_syscall)
130
131 /* This version knows about errno and will handle it. */
132 long __ros_syscall_errno(unsigned int _num, long _a0, long _a1, long _a2,
133                          long _a3, long _a4, long _a5)
134 {
135         struct syscall sysc = __ros_syscall_inline(_num, _a0, _a1, _a2, _a3,
136                                                    _a4, _a5);
137         if (__builtin_expect(sysc.err, 0))
138                 errno = sysc.err;
139         return sysc.retval;
140 }
141 libc_hidden_def(__ros_syscall_errno)
142
143 long int syscall(long int num, ...)
144 {
145         va_list vl;
146         va_start(vl, num);
147         long int a0 = va_arg(vl, long int);
148         long int a1 = va_arg(vl, long int);
149         long int a2 = va_arg(vl, long int);
150         long int a3 = va_arg(vl, long int);
151         long int a4 = va_arg(vl, long int);
152         long int a5 = va_arg(vl, long int);
153         va_end(vl);
154         
155         return ros_syscall(num, a0, a1, a2, a3, a4, a5);
156 }
157