Use a lock when printing trap info
[akaros.git] / kern / src / trap.c
1 /* Copyright (c) 2012 The Regents of the University of California
2  * Barret Rhoden <brho@cs.berkeley.edu>
3  * See LICENSE for details.
4  *
5  * Arch-independent trap handling and kernel messaging */
6
7 #include <arch/arch.h>
8 #include <smp.h>
9 #include <trap.h>
10 #include <stdio.h>
11 #include <slab.h>
12 #include <assert.h>
13 #include <kdebug.h>
14 #include <kmalloc.h>
15
16 static void print_unhandled_trap(struct proc *p, struct user_context *ctx,
17                                  unsigned int trap_nr, unsigned int err,
18                                  unsigned long aux)
19 {
20         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
21         uint32_t vcoreid = pcpui->owning_vcoreid;
22         struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[vcoreid];
23         static spinlock_t print_trap_lock = SPINLOCK_INITIALIZER;
24
25         spin_lock(&print_trap_lock);
26         if (!proc_is_vcctx_ready(p))
27                 printk("Unhandled user trap from early SCP\n");
28         else if (vcpd->notif_disabled)
29                 printk("Unhandled user trap in vcore context from VC %d\n", vcoreid);
30         print_user_ctx(ctx);
31         printk("err 0x%x (for PFs: User 4, Wr 2, Rd 1), aux %p\n", err, aux);
32         debug_addr_proc(p, get_user_ctx_pc(ctx));
33         print_vmrs(p);
34         backtrace_user_ctx(p, ctx);
35         spin_unlock(&print_trap_lock);
36 }
37
38 /* Traps that are considered normal operations. */
39 static bool benign_trap(unsigned int err)
40 {
41         return err & PF_VMR_BACKED;
42 }
43
44 static void printx_unhandled_trap(struct proc *p, struct user_context *ctx,
45                                   unsigned int trap_nr, unsigned int err,
46                                   unsigned long aux)
47 {
48         if (printx_on && !benign_trap(err))
49                 print_unhandled_trap(p, ctx, trap_nr, err, aux);
50 }
51
52 /* Helper, reflects the current context back to the 2LS.  Returns 0 on success,
53  * -1 on failure. */
54 int reflect_current_context(void)
55 {
56         uint32_t coreid = core_id();
57         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
58         struct proc *p = pcpui->cur_proc;
59         uint32_t vcoreid = pcpui->owning_vcoreid;
60         struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[vcoreid];
61
62         if (!proc_is_vcctx_ready(p))
63                 return -1;
64         if (vcpd->notif_disabled)
65                 return -1;
66         /* the guts of a __notify */
67         vcpd->notif_disabled = TRUE;
68         copy_current_ctx_to(&vcpd->uthread_ctx);
69         memset(pcpui->cur_ctx, 0, sizeof(struct user_context));
70         proc_init_ctx(pcpui->cur_ctx, vcoreid, vcpd->vcore_entry,
71                       vcpd->vcore_stack, vcpd->vcore_tls_desc);
72         return 0;
73 }
74
75 void reflect_unhandled_trap(unsigned int trap_nr, unsigned int err,
76                             unsigned long aux)
77 {
78         uint32_t coreid = core_id();
79         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
80         struct proc *p = pcpui->cur_proc;
81
82         assert(p);
83         assert(pcpui->cur_ctx && (pcpui->cur_ctx->type == ROS_HW_CTX));
84         /* need to store trap_nr, err code, and aux into the tf so that it can get
85          * extracted on the other end, and we need to flag the TF in some way so we
86          * can tell it was reflected.  for example, on a PF, we need some number (14
87          * on x86), the prot violation (write, read, etc), and the virt addr (aux).
88          * parlib will know how to extract this info. */
89         __arch_reflect_trap_hwtf(&pcpui->cur_ctx->tf.hw_tf, trap_nr, err, aux);
90         printx_unhandled_trap(p, pcpui->cur_ctx, trap_nr, err, aux);
91         if (reflect_current_context()) {
92                 print_unhandled_trap(p, pcpui->cur_ctx, trap_nr, err, aux);
93                 proc_destroy(p);
94         }
95 }
96
97 uintptr_t get_user_ctx_pc(struct user_context *ctx)
98 {
99         switch (ctx->type) {
100         case ROS_HW_CTX:
101                 return get_hwtf_pc(&ctx->tf.hw_tf);
102         case ROS_SW_CTX:
103                 return get_swtf_pc(&ctx->tf.sw_tf);
104         case ROS_VM_CTX:
105                 return get_vmtf_pc(&ctx->tf.vm_tf);
106         default:
107                 panic("Bad context type %d for ctx %p\n", ctx->type, ctx);
108         }
109 }
110
111 uintptr_t get_user_ctx_fp(struct user_context *ctx)
112 {
113         switch (ctx->type) {
114         case ROS_HW_CTX:
115                 return get_hwtf_fp(&ctx->tf.hw_tf);
116         case ROS_SW_CTX:
117                 return get_swtf_fp(&ctx->tf.sw_tf);
118         case ROS_VM_CTX:
119                 return get_vmtf_fp(&ctx->tf.vm_tf);
120         default:
121                 panic("Bad context type %d for ctx %p\n", ctx->type, ctx);
122         }
123 }
124
125 uintptr_t get_user_ctx_sp(struct user_context *ctx)
126 {
127         switch (ctx->type) {
128         case ROS_HW_CTX:
129                 return get_hwtf_sp(&ctx->tf.hw_tf);
130         case ROS_SW_CTX:
131                 return get_swtf_sp(&ctx->tf.sw_tf);
132         case ROS_VM_CTX:
133                 return get_vmtf_sp(&ctx->tf.vm_tf);
134         default:
135                 panic("Bad context type %d for ctx %p\n", ctx->type, ctx);
136         }
137 }
138
139 /* Helper, copies the current context to to_ctx. */
140 void copy_current_ctx_to(struct user_context *to_ctx)
141 {
142         struct user_context *cur_ctx = current_ctx;
143
144         /* Be sure to finalize into cur_ctx, not the to_ctx.  o/w the arch could get
145          * confused by other calls to finalize. */
146         arch_finalize_ctx(cur_ctx);
147         *to_ctx = *cur_ctx;
148 }
149
150 struct kmem_cache *kernel_msg_cache;
151
152 void kernel_msg_init(void)
153 {
154         kernel_msg_cache = kmem_cache_create("kernel_msgs",
155                            sizeof(struct kernel_message), ARCH_CL_SIZE, 0, 0, 0);
156 }
157
158 uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
159                              long arg2, int type)
160 {
161         kernel_message_t *k_msg;
162         assert(pc);
163         // note this will be freed on the destination core
164         k_msg = kmem_cache_alloc(kernel_msg_cache, 0);
165         k_msg->srcid = core_id();
166         k_msg->dstid = dst;
167         k_msg->pc = pc;
168         k_msg->arg0 = arg0;
169         k_msg->arg1 = arg1;
170         k_msg->arg2 = arg2;
171         switch (type) {
172                 case KMSG_IMMEDIATE:
173                         spin_lock_irqsave(&per_cpu_info[dst].immed_amsg_lock);
174                         STAILQ_INSERT_TAIL(&per_cpu_info[dst].immed_amsgs, k_msg, link);
175                         spin_unlock_irqsave(&per_cpu_info[dst].immed_amsg_lock);
176                         break;
177                 case KMSG_ROUTINE:
178                         spin_lock_irqsave(&per_cpu_info[dst].routine_amsg_lock);
179                         STAILQ_INSERT_TAIL(&per_cpu_info[dst].routine_amsgs, k_msg, link);
180                         spin_unlock_irqsave(&per_cpu_info[dst].routine_amsg_lock);
181                         break;
182                 default:
183                         panic("Unknown type of kernel message!");
184         }
185         /* since we touched memory the other core will touch (the lock), we don't
186          * need an wmb_f() */
187         /* if we're sending a routine message locally, we don't want/need an IPI */
188         if ((dst != k_msg->srcid) || (type == KMSG_IMMEDIATE))
189                 send_ipi(dst, I_KERNEL_MSG);
190         return 0;
191 }
192
193 /* Kernel message IPI/IRQ handler.
194  *
195  * This processes immediate messages, and that's it (it used to handle routines
196  * too, if it came in from userspace).  Routine messages will get processed when
197  * the kernel has a chance (right before popping to userspace or in smp_idle
198  * before halting).
199  *
200  * Note that all of this happens from interrupt context, and interrupts are
201  * disabled. */
202 void handle_kmsg_ipi(struct hw_trapframe *hw_tf, void *data)
203 {
204         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
205         struct kernel_message *kmsg_i, *temp;
206         /* Avoid locking if the list appears empty (lockless peek is okay) */
207         if (STAILQ_EMPTY(&pcpui->immed_amsgs))
208                 return;
209         /* The lock serves as a cmb to force a re-read of the head of the list */
210         spin_lock_irqsave(&pcpui->immed_amsg_lock);
211         STAILQ_FOREACH_SAFE(kmsg_i, &pcpui->immed_amsgs, link, temp) {
212                 pcpui_trace_kmsg(pcpui, (uintptr_t)kmsg_i->pc);
213                 kmsg_i->pc(kmsg_i->srcid, kmsg_i->arg0, kmsg_i->arg1, kmsg_i->arg2);
214                 STAILQ_REMOVE(&pcpui->immed_amsgs, kmsg_i, kernel_message, link);
215                 kmem_cache_free(kernel_msg_cache, (void*)kmsg_i);
216         }
217         spin_unlock_irqsave(&pcpui->immed_amsg_lock);
218 }
219
220 bool has_routine_kmsg(void)
221 {
222         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
223         /* lockless peek */
224         return !STAILQ_EMPTY(&pcpui->routine_amsgs);
225 }
226
227 /* Helper function, gets the next routine KMSG (RKM).  Returns 0 if the list was
228  * empty. */
229 static kernel_message_t *get_next_rkmsg(struct per_cpu_info *pcpui)
230 {
231         struct kernel_message *kmsg;
232         /* Avoid locking if the list appears empty (lockless peek is okay) */
233         if (STAILQ_EMPTY(&pcpui->routine_amsgs))
234                 return 0;
235         /* The lock serves as a cmb to force a re-read of the head of the list.
236          * IRQs are disabled by our caller. */
237         spin_lock(&pcpui->routine_amsg_lock);
238         kmsg = STAILQ_FIRST(&pcpui->routine_amsgs);
239         if (kmsg)
240                 STAILQ_REMOVE_HEAD(&pcpui->routine_amsgs, link);
241         spin_unlock(&pcpui->routine_amsg_lock);
242         return kmsg;
243 }
244
245 /* Runs routine kernel messages.  This might not return.  In the past, this
246  * would also run immediate messages, but this is unnecessary.  Immediates will
247  * run whenever we reenable IRQs.  We could have some sort of ordering or
248  * guarantees between KMSG classes, but that's not particularly useful at this
249  * point.
250  *
251  * Note this runs from normal context, with interruptes disabled.  However, a
252  * particular RKM could enable interrupts - for instance __launch_kthread() will
253  * restore an old kthread that may have had IRQs on. */
254 void process_routine_kmsg(void)
255 {
256         uint32_t pcoreid = core_id();
257         struct per_cpu_info *pcpui = &per_cpu_info[pcoreid];
258         struct kernel_message msg_cp, *kmsg;
259
260         /* Important that callers have IRQs disabled.  When sending cross-core RKMs,
261          * the IPI is used to keep the core from going to sleep - even though RKMs
262          * aren't handled in the kmsg handler.  Check smp_idle() for more info. */
263         assert(!irq_is_enabled());
264         while ((kmsg = get_next_rkmsg(pcpui))) {
265                 /* Copy in, and then free, in case we don't return */
266                 msg_cp = *kmsg;
267                 kmem_cache_free(kernel_msg_cache, (void*)kmsg);
268                 assert(msg_cp.dstid == pcoreid);        /* caught a brutal bug with this */
269                 set_rkmsg(pcpui);                                       /* we're now in early RKM ctx */
270                 /* The kmsg could block.  If it does, we want the kthread code to know
271                  * it's not running on behalf of a process, and we're actually spawning
272                  * a kernel task.  While we do have a syscall that does work in an RKM
273                  * (change_to), it's not really the rest of the syscall context. */
274                 pcpui->cur_kthread->flags = KTH_KTASK_FLAGS;
275                 pcpui_trace_kmsg(pcpui, (uintptr_t)msg_cp.pc);
276                 msg_cp.pc(msg_cp.srcid, msg_cp.arg0, msg_cp.arg1, msg_cp.arg2);
277                 /* And if we make it back, be sure to restore the default flags.  If we
278                  * never return, but the kthread exits via some other way (smp_idle()),
279                  * then smp_idle() will deal with the flags.  The default state includes
280                  * 'not a ktask'. */
281                 pcpui->cur_kthread->flags = KTH_DEFAULT_FLAGS;
282                 /* If we aren't still in early RKM, it is because the KMSG blocked
283                  * (thus leaving early RKM, finishing in default context) and then
284                  * returned.  This is a 'detached' RKM.  Must idle in this scenario,
285                  * since we might have migrated or otherwise weren't meant to PRKM
286                  * (can't return twice).  Also note that this may involve a core
287                  * migration, so we need to reread pcpui.*/
288                 cmb();
289                 pcpui = &per_cpu_info[core_id()];
290                 if (!in_early_rkmsg_ctx(pcpui))
291                         smp_idle();
292                 clear_rkmsg(pcpui);
293                 /* Some RKMs might turn on interrupts (perhaps in the future) and then
294                  * return. */
295                 disable_irq();
296         }
297 }
298
299 /* extremely dangerous and racy: prints out the immed and routine kmsgs for a
300  * specific core (so possibly remotely) */
301 void print_kmsgs(uint32_t coreid)
302 {
303         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
304         void __print_kmsgs(struct kernel_msg_list *list, char *type)
305         {
306                 char *fn_name;
307                 struct kernel_message *kmsg_i;
308                 STAILQ_FOREACH(kmsg_i, list, link) {
309                         fn_name = get_fn_name((long)kmsg_i->pc);
310                         printk("%s KMSG on %d from %d to run %p(%s)\n", type,
311                                kmsg_i->dstid, kmsg_i->srcid, kmsg_i->pc, fn_name);
312                         kfree(fn_name);
313                 }
314         }
315         __print_kmsgs(&pcpui->immed_amsgs, "Immedte");
316         __print_kmsgs(&pcpui->routine_amsgs, "Routine");
317 }
318
319 /* Debugging stuff */
320 void kmsg_queue_stat(void)
321 {
322         struct kernel_message *kmsg;
323         bool immed_emp, routine_emp;
324         for (int i = 0; i < num_cores; i++) {
325                 spin_lock_irqsave(&per_cpu_info[i].immed_amsg_lock);
326                 immed_emp = STAILQ_EMPTY(&per_cpu_info[i].immed_amsgs);
327                 spin_unlock_irqsave(&per_cpu_info[i].immed_amsg_lock);
328                 spin_lock_irqsave(&per_cpu_info[i].routine_amsg_lock);
329                 routine_emp = STAILQ_EMPTY(&per_cpu_info[i].routine_amsgs);
330                 spin_unlock_irqsave(&per_cpu_info[i].routine_amsg_lock);
331                 printk("Core %d's immed_emp: %d, routine_emp %d\n", i, immed_emp,
332                routine_emp);
333                 if (!immed_emp) {
334                         kmsg = STAILQ_FIRST(&per_cpu_info[i].immed_amsgs);
335                         printk("Immed msg on core %d:\n", i);
336                         printk("\tsrc:  %d\n", kmsg->srcid);
337                         printk("\tdst:  %d\n", kmsg->dstid);
338                         printk("\tpc:   %p\n", kmsg->pc);
339                         printk("\targ0: %p\n", kmsg->arg0);
340                         printk("\targ1: %p\n", kmsg->arg1);
341                         printk("\targ2: %p\n", kmsg->arg2);
342                 }
343                 if (!routine_emp) {
344                         kmsg = STAILQ_FIRST(&per_cpu_info[i].routine_amsgs);
345                         printk("Routine msg on core %d:\n", i);
346                         printk("\tsrc:  %d\n", kmsg->srcid);
347                         printk("\tdst:  %d\n", kmsg->dstid);
348                         printk("\tpc:   %p\n", kmsg->pc);
349                         printk("\targ0: %p\n", kmsg->arg0);
350                         printk("\targ1: %p\n", kmsg->arg1);
351                         printk("\targ2: %p\n", kmsg->arg2);
352                 }
353
354         }
355 }
356
357 void print_kctx_depths(const char *str)
358 {
359         uint32_t coreid = core_id();
360         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
361
362         if (!str)
363                 str = "(none)";
364         printk("%s: Core %d, irq depth %d, ktrap depth %d, irqon %d\n", str, coreid,
365                irq_depth(pcpui), ktrap_depth(pcpui), irq_is_enabled());
366 }
367
368 void print_user_ctx(struct user_context *ctx)
369 {
370         switch (ctx->type) {
371         case ROS_HW_CTX:
372                 print_trapframe(&ctx->tf.hw_tf);
373                 break;
374         case ROS_SW_CTX:
375                 print_swtrapframe(&ctx->tf.sw_tf);
376                 break;
377         case ROS_VM_CTX:
378                 print_vmtrapframe(&ctx->tf.vm_tf);
379                 break;
380         default:
381                 printk("Bad TF %p type %d!\n", ctx, ctx->type);
382         }
383 }