Remove the return value from vcore_request_more()
[akaros.git] / user / parlib / include / parlib / x86 / vcore32.h
1 #pragma once
2
3 #ifndef PARLIB_ARCH_VCORE_H
4 #error "Do not include include vcore32.h directly"
5 #endif
6
7 #include <parlib/common.h>
8 #include <ros/trapframe.h>
9 #include <ros/procdata.h>
10 #include <ros/syscall.h>
11 #include <ros/arch/mmu.h>
12 #include <sys/tls.h>
13
14 __BEGIN_DECLS
15
16 /* Here's how the HW popping works:  It sets up the future stack pointer to
17  * have extra stuff after it, and then it pops the registers, then pops the new
18  * context's stack pointer.  Then it uses the extra stuff (the new PC is on the
19  * stack, the location of notif_disabled, and a clobbered work register) to
20  * enable notifs, make sure notif IPIs weren't pending, restore the work reg,
21  * and then "ret".
22  *
23  * This is what the target uthread's stack will look like (growing down):
24  *
25  * Target ESP -> |   u_thread's old stuff   | the future %esp, tf->tf_esp
26  *               |   new eip                | 0x04 below %esp (one slot is 0x04)
27  *               |   eflags space           | 0x08 below
28  *               |   eax save space         | 0x0c below
29  *               |   actual syscall         | 0x10 below (0x30 space)
30  *               |   *sysc ptr to syscall   | 0x40 below (0x10 + 0x30)
31  *               |   notif_pending_loc      | 0x44 below (0x10 + 0x30)
32  *               |   notif_disabled_loc     | 0x48 below (0x10 + 0x30)
33  *
34  * The important thing is that it can handle a notification after it enables
35  * notifications, and when it gets resumed it can ultimately run the new
36  * context.  Enough state is saved in the running context and stack to continue
37  * running.
38  *
39  * Related to that is whether or not our stack pointer is sufficiently far down
40  * so that restarting *this* code won't clobber shit we need later.  The way we
41  * do this is that we do any "stack jumping" before we enable interrupts/notifs.
42  * These jumps are when we directly modify esp, specifically in the down
43  * direction (subtracts).  Adds would be okay.
44  *
45  * Another related concern is the storage for sysc.  It used to be on the
46  * vcore's stack, but if an interrupt comes in before we use it, we trash the
47  * vcore's stack (and thus the storage for sysc!).  Instead, we put it on the
48  * stack of the user tf.  Moral: don't touch a vcore's stack with notifs
49  * enabled. */
50
51 /* Helper for writing the info we need later to the u_tf's stack.  Note, this
52  * could get fucked if the struct syscall isn't a multiple of 4-bytes.  Also,
53  * note this goes backwards, since memory reads up the stack. */
54 struct restart_helper {
55         uint32_t                                        notif_disab_loc;
56         uint32_t                                        notif_pend_loc;
57         struct syscall                          *sysc;
58         struct syscall                          local_sysc;     /* unused for now */
59         uint32_t                                        eax_save;
60         uint32_t                                        eflags;
61         uint32_t                                        eip;
62 };
63
64 /* Static syscall, used for self-notifying.  We never wait on it, and we
65  * actually might submit it multiple times in parallel on different cores!
66  * While this may seem dangerous, the kernel needs to be able to handle this
67  * scenario.  It's also important that we never wait on this, since for all but
68  * the first call, the DONE flag will be set.  (Set once, then never reset) */
69 extern struct syscall vc_entry; /* in x86/vcore.c */
70
71 static inline void pop_hw_tf(struct hw_trapframe *tf, uint32_t vcoreid)
72 {
73         struct restart_helper *rst;
74         struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
75         if (!tf->tf_cs) { /* sysenter TF.  esp and eip are in other regs. */
76                 tf->tf_esp = tf->tf_regs.reg_ebp;
77                 tf->tf_eip = tf->tf_regs.reg_edx;
78         }
79         /* The stuff we need to write will be below the current stack of the utf */
80         rst = (struct restart_helper*)((void*)tf->tf_esp -
81                                        sizeof(struct restart_helper));
82         /* Fill in the info we'll need later */
83         rst->notif_disab_loc = (uint32_t)&vcpd->notif_disabled;
84         rst->notif_pend_loc = (uint32_t)&vcpd->notif_pending;
85         rst->sysc = &vc_entry;
86         rst->eax_save = 0;                      /* avoid bugs */
87         rst->eflags = tf->tf_eflags;
88         rst->eip = tf->tf_eip;
89
90         asm volatile ("movl %0,%%esp;        " /* jump esp to the utf */
91                       "popal;                " /* restore normal registers */
92                       "addl $0x24,%%esp;     " /* move to the esp slot in the tf */
93                       "popl %%esp;           " /* change to the utf's %esp */
94                       "subl $0x08,%%esp;     " /* move esp to below eax's slot */
95                       "pushl %%eax;          " /* save eax, will clobber soon */
96                                   "movl %2,%%eax;        " /* sizeof struct syscall */
97                                   "addl $0x0c,%%eax;     " /* more offset btw eax/notif_en_loc*/
98                       "subl %%eax,%%esp;     " /* move to notif_en_loc slot */
99                       "popl %%eax;           " /* load notif_disabled addr */
100                       "movb $0x00,(%%eax);   " /* enable notifications */
101                                   /* Need a wrmb() here so the write of enable_notif can't pass
102                                    * the read of notif_pending (racing with a potential
103                                    * cross-core call with proc_notify()). */
104                                   "lock addl $0,(%%esp); " /* LOCK is a CPU mb() */
105                                   /* From here down, we can get interrupted and restarted */
106                       "popl %%eax;           " /* get notif_pending status */
107                       "testb $0x01,(%%eax);  " /* test if a notif is pending */
108                       "jz 1f;                " /* if not pending, skip syscall */
109                                   /* Actual syscall.  Note we don't wait on the async call */
110                       "popl %%eax;           " /* &sysc, trap arg0 */
111                       "pushl %%edx;          " /* save edx, will be trap arg1 */
112                       "movl $0x1,%%edx;      " /* sending one async syscall: arg1 */
113                       "int %1;               " /* fire the syscall */
114                       "popl %%edx;           " /* restore regs after syscall */
115                       "jmp 2f;               " /* skip 1:, already popped */
116                                   "1: popl %%eax;        " /* discard &sysc (on non-sc path) */
117                       "2: addl %2,%%esp;     " /* jump over the sysc (both paths) */
118                       "popl %%eax;           " /* restore tf's %eax */
119                                   "popfl;                " /* restore utf's eflags */
120                       "ret;                  " /* return to the new PC */
121                       :
122                       : "g"(tf), "i"(T_SYSCALL), "i"(sizeof(struct syscall))
123                       : "memory");
124 }
125
126 static inline void pop_sw_tf(struct sw_trapframe *sw_tf, uint32_t vcoreid)
127 {
128         struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
129
130         /* Restore callee-saved FPU state.  We need to clear exceptions before
131          * reloading the FP CW, in case the new CW unmasks any.  We also need to
132          * reset the tag word to clear out the stack.
133          *
134          * The main issue here is that while our context was saved in an
135          * ABI-complaint manner, we may be starting up on a somewhat random FPU
136          * state.  Having gibberish in registers isn't a big deal, but some of the
137          * FP environment settings could cause trouble.  If fnclex; emms isn't
138          * enough, we could also save/restore the entire FP env with fldenv, or do
139          * an fninit before fldcw. */
140         asm volatile ("ldmxcsr %0" : : "m"(sw_tf->tf_mxcsr));
141         asm volatile ("fnclex; emms; fldcw %0" : : "m"(sw_tf->tf_fpucw));
142         /* Basic plan: restore all regs, off ecx as the sw_tf.  Switch to the new
143          * stack, push the PC so we can pop it later.  Use eax and edx for the
144          * locations of sysc and vcpd.  Once on the new stack, we enable notifs,
145          * check if we missed one, and if so, self notify. */
146         asm volatile ("movl 0x00(%0),%%ebp;  " /* restore regs */
147                       "movl 0x04(%0),%%ebx;  "
148                       "movl 0x08(%0),%%esi;  "
149                       "movl 0x0c(%0),%%edi;  "
150                       "movl 0x10(%0),%%esp;  " /* jump to future stack */
151                       "pushl 0x14(%0);       " /* save PC for future ret */
152                       "movl %2,%%ecx;        " /* vcpd loc into ecx */
153                       "addl %4,%%ecx;        " /* notif_disabled loc into ecx */
154                       "movb $0x00,(%%ecx);   " /* enable notifications */
155                       /* Need a wrmb() here so the write of enable_notif can't pass
156                        * the read of notif_pending (racing with a potential
157                        * cross-core call with proc_notify()). */
158                       "lock addl $0,(%%esp); " /* LOCK is a CPU mb() */
159                       /* From here down, we can get interrupted and restarted */
160                       "movl %2,%%ecx;        " /* vcpd loc into ecx */
161                       "addl %5,%%ecx;        " /* notif_pending loc into ecx */
162                       "testb $0x01,(%%ecx);  " /* test if a notif is pending */
163                       "jz 1f;                " /* if not pending, skip syscall */
164                       /* Actual syscall.  Note we don't wait on the async call.
165                        * &sysc is already in eax (trap arg0). */
166                       "movl $0x1,%%edx;      " /* sending one async syscall: arg1 */
167                       "int %3;               " /* fire the syscall */
168                       "1: ret;               " /* retaddr was pushed earlier */
169                       :
170                       : "c"(sw_tf),
171                         "a"(&vc_entry),
172                         "d"(vcpd),
173                         "i"(T_SYSCALL),
174                         "i"(offsetof(struct preempt_data, notif_disabled)),
175                         "i"(offsetof(struct preempt_data, notif_pending))
176                       : "memory");
177 }
178
179 /* Pops a user context, reanabling notifications at the same time.  A Userspace
180  * scheduler can call this when transitioning off the transition stack.
181  *
182  * At some point in vcore context before calling this, you need to clear
183  * notif_pending (do this by calling handle_events()).  As a potential
184  * optimization, consider clearing the notif_pending flag / handle_events again
185  * (right before popping), right before calling this.  If notif_pending is not
186  * clear, this will self_notify this core, since it should be because we missed
187  * a notification message while notifs were disabled. */
188 static inline void pop_user_ctx(struct user_context *ctx, uint32_t vcoreid)
189 {
190         if (ctx->type == ROS_HW_CTX)
191                 pop_hw_tf(&ctx->tf.hw_tf, vcoreid);
192         else
193                 pop_sw_tf(&ctx->tf.sw_tf, vcoreid);
194 }
195
196 /* Like the regular pop_user_ctx, but this one doesn't check or clear
197  * notif_pending.  The only case where we use this is when an IRQ/notif
198  * interrupts a uthread that is in the process of disabling notifs. */
199 static inline void pop_user_ctx_raw(struct user_context *ctx, uint32_t vcoreid)
200 {
201         struct hw_trapframe *tf = &ctx->tf.hw_tf;
202         assert(ctx->type == ROS_HW_CTX);
203         struct restart_helper *rst;
204         struct preempt_data *vcpd = &__procdata.vcore_preempt_data[vcoreid];
205         if (!tf->tf_cs) { /* sysenter TF.  esp and eip are in other regs. */
206                 tf->tf_esp = tf->tf_regs.reg_ebp;
207                 tf->tf_eip = tf->tf_regs.reg_edx;
208         }
209         /* The stuff we need to write will be below the current stack of the utf */
210         rst = (struct restart_helper*)((void*)tf->tf_esp -
211                                        sizeof(struct restart_helper));
212         /* Fill in the info we'll need later */
213         rst->notif_disab_loc = (uint32_t)&vcpd->notif_disabled;
214         rst->eax_save = 0;                      /* avoid bugs */
215         rst->eflags = tf->tf_eflags;
216         rst->eip = tf->tf_eip;
217
218         asm volatile ("movl %0,%%esp;        " /* jump esp to the utf */
219                       "popal;                " /* restore normal registers */
220                       "addl $0x24,%%esp;     " /* move to the esp slot in the tf */
221                       "popl %%esp;           " /* change to the utf's %esp */
222                       "subl $0x08,%%esp;     " /* move esp to below eax's slot */
223                       "pushl %%eax;          " /* save eax, will clobber soon */
224                                   "movl %2,%%eax;        " /* sizeof struct syscall */
225                                   "addl $0x0c,%%eax;     " /* more offset btw eax/notif_en_loc*/
226                       "subl %%eax,%%esp;     " /* move to notif_en_loc slot */
227                       "popl %%eax;           " /* load notif_disabled addr */
228                       "movb $0x00,(%%eax);   " /* enable notifications */
229                                   /* Here's where we differ from the regular pop_user_ctx().
230                                    * We do the same pops/esp moves, just to keep things similar
231                                    * and simple, but don't do test, clear notif_pending, or
232                                    * call a syscall. */
233                                   /* From here down, we can get interrupted and restarted */
234                       "popl %%eax;           " /* get notif_pending status */
235                                   "popl %%eax;           " /* discard &sysc (on non-sc path) */
236                       "addl %2,%%esp;        " /* jump over the sysc (both paths) */
237                       "popl %%eax;           " /* restore tf's %eax */
238                                   "popfl;                " /* restore utf's eflags */
239                       "ret;                  " /* return to the new PC */
240                       :
241                       : "g"(tf), "i"(T_SYSCALL), "i"(sizeof(struct syscall))
242                       : "memory");
243 }
244
245 /* Save's a SW context, setting the PC to the end of this function.  We only
246  * save callee-saved registers (of the sysv abi).  The compiler knows to save
247  * the others via the input/clobber lists.
248  *
249  * Callers of this function need to have at least one
250  * 'calling-convention-compliant' function call between this and any floating
251  * point, so that the compiler saves any caller-saved FP before getting to
252  * here.
253  *
254  * To some extent, TLS is 'callee-saved', in that no one ever expects it to
255  * change.  We handle uthread TLS changes separately, since we often change to
256  * them early to set some variables.  Arguably we should do this different. */
257 static inline void save_user_ctx(struct user_context *ctx)
258 {
259         struct sw_trapframe *sw_tf = &ctx->tf.sw_tf;
260         long dummy;
261         ctx->type = ROS_SW_CTX;
262         asm volatile ("stmxcsr %0" : "=m"(sw_tf->tf_mxcsr));
263         asm volatile ("fnstcw %0" : "=m"(sw_tf->tf_fpucw));
264         /* Pretty simple: save all the regs, IAW the sys-v ABI */
265         asm volatile ("movl %%ebp,0x00(%0);   "
266                       "movl %%ebx,0x04(%0);   "
267                       "movl %%esi,0x08(%0);   "
268                       "movl %%edi,0x0c(%0);   "
269                       "movl %%esp,0x10(%0);   "
270                       "leal 1f,%%eax;         " /* get future eip */
271                       "movl %%eax,0x14(%0);   "
272                       "1:                     " /* where this tf will restart */
273                       : "=c"(dummy)     /* force clobber for ecx */
274                       : "c"(sw_tf)
275                       : "eax", "edx", "memory", "cc");
276 } __attribute__((always_inline, returns_twice))
277
278 /* The old version, kept around for testing */
279 static inline void save_user_ctx_hw(struct user_context *ctx)
280 {
281         struct hw_trapframe *tf = &ctx->tf.hw_tf;
282         ctx->type = ROS_HW_CTX;
283         memset(tf, 0, sizeof(struct hw_trapframe)); /* sanity */
284         /* set CS and make sure eflags is okay */
285         tf->tf_cs = GD_UT | 3;
286         tf->tf_eflags = 0x00000200; /* interrupts enabled.  bare minimum eflags. */
287         /* Save the regs and the future esp. */
288         asm volatile("movl %%esp,(%0);       " /* save esp in it's slot*/
289                      "pushl %%eax;           " /* temp save eax */
290                      "leal 1f,%%eax;         " /* get future eip */
291                      "movl %%eax,(%1);       " /* store future eip */
292                      "popl %%eax;            " /* restore eax */
293                      "movl %2,%%esp;         " /* move to the beginning of the tf */
294                      "addl $0x20,%%esp;      " /* move to after the push_regs */
295                      "pushal;                " /* save regs */
296                      "addl $0x44,%%esp;      " /* move to esp slot */
297                      "popl %%esp;            " /* restore esp */
298                      "1:                     " /* where this tf will restart */
299                      : 
300                      : "g"(&tf->tf_esp), "g"(&tf->tf_eip), "g"(tf)
301                      : "eax", "memory", "cc");
302 } __attribute__((always_inline, returns_twice))
303
304 static inline void init_user_ctx(struct user_context *ctx, uint32_t entry_pt,
305                                  uint32_t stack_top)
306 {
307         struct sw_trapframe *sw_tf = &ctx->tf.sw_tf;
308         ctx->type = ROS_SW_CTX;
309         /* No need to bother with setting the other GP registers; the called
310          * function won't care about their contents. */
311         sw_tf->tf_esp = stack_top;
312         sw_tf->tf_eip = entry_pt;
313         sw_tf->tf_mxcsr = 0x00001f80;   /* x86 default mxcsr */
314         sw_tf->tf_fpucw = 0x037f;               /* x86 default FP CW */
315 }
316
317 static inline uintptr_t get_user_ctx_stack(struct user_context *ctx)
318 {
319         if (ctx->type == ROS_HW_CTX)
320                 return ctx->tf.hw_tf.tf_esp;
321         else
322                 return ctx->tf.sw_tf.tf_esp;
323 }
324
325 // this is how we get our thread id on entry.
326 #define __vcore_id_on_entry \
327 ({ \
328         register int temp asm ("ebx"); \
329         temp; \
330 })
331
332 static bool has_refl_fault(struct user_context *ctx)
333 {
334         return ctx->tf.hw_tf.tf_padding3 == ROS_ARCH_REFL_ID;
335 }
336
337 static void clear_refl_fault(struct user_context *ctx)
338 {
339         ctx->tf.hw_tf.tf_padding3 = 0;
340 }
341
342 static unsigned int __arch_refl_get_nr(struct user_context *ctx)
343 {
344         return ctx->tf.hw_tf.tf_trapno;
345 }
346
347 static unsigned int __arch_refl_get_err(struct user_context *ctx)
348 {
349         return ctx->tf.hw_tf.tf_err;
350 }
351
352 static unsigned long __arch_refl_get_aux(struct user_context *ctx)
353 {
354         return ctx->tf.hw_tf.tf_regs.reg_oesp;
355 }
356
357 __END_DECLS