printk: check for user pointers in format string parameters
[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 #include <rcu.h>
16
17 static void print_unhandled_trap(struct proc *p, struct user_context *ctx,
18                                  unsigned int trap_nr, unsigned int err,
19                                  unsigned long aux)
20 {
21         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
22         uint32_t vcoreid = pcpui->owning_vcoreid;
23         struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[vcoreid];
24         static spinlock_t print_trap_lock = SPINLOCK_INITIALIZER;
25
26         spin_lock(&print_trap_lock);
27         if (!proc_is_vcctx_ready(p))
28                 printk("Unhandled user trap from early SCP\n");
29         else if (vcpd->notif_disabled)
30                 printk("Unhandled user trap in vcore context from VC %d\n",
31                        vcoreid);
32         print_user_ctx(ctx);
33         printk("err 0x%x (for PFs: User 4, Wr 2, Rd 1), aux %p\n", err, aux);
34         debug_addr_proc(p, get_user_ctx_pc(ctx));
35         print_vmrs(p);
36         backtrace_user_ctx(p, ctx);
37         spin_unlock(&print_trap_lock);
38 }
39
40 /* Traps that are considered normal operations. */
41 static bool benign_trap(unsigned int err)
42 {
43         return err & PF_VMR_BACKED;
44 }
45
46 static void printx_unhandled_trap(struct proc *p, struct user_context *ctx,
47                                   unsigned int trap_nr, unsigned int err,
48                                   unsigned long aux)
49 {
50         if (printx_on && !benign_trap(err))
51                 print_unhandled_trap(p, ctx, trap_nr, err, aux);
52 }
53
54 /* Helper, reflects the current context back to the 2LS.  Returns 0 on success,
55  * -1 on failure. */
56 int reflect_current_context(void)
57 {
58         uint32_t coreid = core_id();
59         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
60         struct proc *p = pcpui->cur_proc;
61         uint32_t vcoreid = pcpui->owning_vcoreid;
62         struct preempt_data *vcpd = &p->procdata->vcore_preempt_data[vcoreid];
63
64         assert(pcpui->cur_proc == pcpui->owning_proc);
65         if (!proc_is_vcctx_ready(p))
66                 return -1;
67         if (vcpd->notif_disabled)
68                 return -1;
69         /* the guts of a __notify */
70         vcpd->notif_disabled = TRUE;
71         copy_current_ctx_to(&vcpd->uthread_ctx);
72         memset(pcpui->cur_ctx, 0, sizeof(struct user_context));
73         proc_init_ctx(pcpui->cur_ctx, vcoreid, vcpd->vcore_entry,
74                       vcpd->vcore_stack, vcpd->vcore_tls_desc);
75         return 0;
76 }
77
78 void reflect_unhandled_trap(unsigned int trap_nr, unsigned int err,
79                             unsigned long aux)
80 {
81         uint32_t coreid = core_id();
82         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
83         struct proc *p = pcpui->cur_proc;
84
85         assert(p);
86         assert(pcpui->cur_ctx && (pcpui->cur_ctx->type == ROS_HW_CTX));
87         /* need to store trap_nr, err code, and aux into the tf so that it can
88          * get extracted on the other end, and we need to flag the TF in some
89          * way so we can tell it was reflected.  for example, on a PF, we need
90          * some number (14 on x86), the prot violation (write, read, etc), and
91          * the virt addr (aux).  parlib will know how to extract this info. */
92         __arch_reflect_trap_hwtf(&pcpui->cur_ctx->tf.hw_tf, trap_nr, err, aux);
93         printx_unhandled_trap(p, pcpui->cur_ctx, trap_nr, err, aux);
94         if (reflect_current_context()) {
95                 print_unhandled_trap(p, pcpui->cur_ctx, trap_nr, err, aux);
96                 proc_destroy(p);
97         }
98 }
99
100 /* Helper, copies the current context to to_ctx. */
101 void copy_current_ctx_to(struct user_context *to_ctx)
102 {
103         struct user_context *cur_ctx = current_ctx;
104
105         /* Be sure to finalize into cur_ctx, not the to_ctx.  o/w the arch could
106          * get confused by other calls to finalize. */
107         arch_finalize_ctx(cur_ctx);
108         *to_ctx = *cur_ctx;
109 }
110
111 struct kmem_cache *kernel_msg_cache;
112
113 void kernel_msg_init(void)
114 {
115         kernel_msg_cache = kmem_cache_create("kernel_msgs",
116                                              sizeof(struct kernel_message),
117                                              ARCH_CL_SIZE, 0, NULL, 0, 0, NULL);
118 }
119
120 uint32_t send_kernel_message(uint32_t dst, amr_t pc, long arg0, long arg1,
121                              long arg2, int type)
122 {
123         kernel_message_t *k_msg;
124         assert(pc);
125         // note this will be freed on the destination core
126         k_msg = kmem_cache_alloc(kernel_msg_cache, 0);
127         k_msg->srcid = core_id();
128         k_msg->dstid = dst;
129         k_msg->pc = pc;
130         k_msg->arg0 = arg0;
131         k_msg->arg1 = arg1;
132         k_msg->arg2 = arg2;
133         switch (type) {
134         case KMSG_IMMEDIATE:
135                 spin_lock_irqsave(&per_cpu_info[dst].immed_amsg_lock);
136                 STAILQ_INSERT_TAIL(&per_cpu_info[dst].immed_amsgs, k_msg, link);
137                 spin_unlock_irqsave(&per_cpu_info[dst].immed_amsg_lock);
138                 break;
139         case KMSG_ROUTINE:
140                 spin_lock_irqsave(&per_cpu_info[dst].routine_amsg_lock);
141                 STAILQ_INSERT_TAIL(&per_cpu_info[dst].routine_amsgs, k_msg, link);
142                 spin_unlock_irqsave(&per_cpu_info[dst].routine_amsg_lock);
143                 break;
144         default:
145                 panic("Unknown type of kernel message!");
146         }
147         /* since we touched memory the other core will touch (the lock), we
148          * don't need an wmb_f() */
149         /* if we're sending a routine message locally, we don't want/need an IPI
150          */
151         if ((dst != k_msg->srcid) || (type == KMSG_IMMEDIATE))
152                 send_ipi(dst, I_KERNEL_MSG);
153         return 0;
154 }
155
156 /* Kernel message IPI/IRQ handler.
157  *
158  * This processes immediate messages, and that's it (it used to handle routines
159  * too, if it came in from userspace).  Routine messages will get processed when
160  * the kernel has a chance (right before popping to userspace or in smp_idle
161  * before halting).
162  *
163  * Note that all of this happens from interrupt context, and interrupts are
164  * disabled. */
165 void handle_kmsg_ipi(struct hw_trapframe *hw_tf, void *data)
166 {
167         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
168         struct kernel_message *kmsg_i, *temp;
169         /* Avoid locking if the list appears empty (lockless peek is okay) */
170         if (STAILQ_EMPTY(&pcpui->immed_amsgs))
171                 return;
172         /* The lock serves as a cmb to force a re-read of the head of the list*/
173         spin_lock_irqsave(&pcpui->immed_amsg_lock);
174         STAILQ_FOREACH_SAFE(kmsg_i, &pcpui->immed_amsgs, link, temp) {
175                 pcpui_trace_kmsg(pcpui, (uintptr_t)kmsg_i->pc);
176                 kmsg_i->pc(kmsg_i->srcid, kmsg_i->arg0, kmsg_i->arg1,
177                            kmsg_i->arg2);
178                 STAILQ_REMOVE(&pcpui->immed_amsgs, kmsg_i, kernel_message,
179                               link);
180                 kmem_cache_free(kernel_msg_cache, (void*)kmsg_i);
181         }
182         spin_unlock_irqsave(&pcpui->immed_amsg_lock);
183 }
184
185 bool has_routine_kmsg(void)
186 {
187         struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
188         /* lockless peek */
189         return !STAILQ_EMPTY(&pcpui->routine_amsgs);
190 }
191
192 /* Helper function, gets the next routine KMSG (RKM).  Returns 0 if the list was
193  * empty. */
194 static kernel_message_t *get_next_rkmsg(struct per_cpu_info *pcpui)
195 {
196         struct kernel_message *kmsg;
197
198         /* Avoid locking if the list appears empty (lockless peek is okay) */
199         if (STAILQ_EMPTY(&pcpui->routine_amsgs))
200                 return 0;
201         /* The lock serves as a cmb to force a re-read of the head of the list.
202          * IRQs are disabled by our caller. */
203         spin_lock(&pcpui->routine_amsg_lock);
204         kmsg = STAILQ_FIRST(&pcpui->routine_amsgs);
205         if (kmsg)
206                 STAILQ_REMOVE_HEAD(&pcpui->routine_amsgs, link);
207         spin_unlock(&pcpui->routine_amsg_lock);
208         return kmsg;
209 }
210
211 /* Runs a routine kernel message.  If we execute a message, this does not
212  * return, but instead will call smp_idle().
213  *
214  * Note that routine messages do not have to return, but almost all of them do.
215  * If you're thinking of changing this, take a look at __launch_kthread. */
216 void process_routine_kmsg(void)
217 {
218         uint32_t pcoreid = core_id();
219         struct per_cpu_info *pcpui = &per_cpu_info[pcoreid];
220         struct kernel_message msg_cp, *kmsg;
221
222         /* Important that callers have IRQs disabled when checking for RKMs.
223          * When sending cross-core RKMs, the IPI is used to keep the core from
224          * going to sleep - even though RKMs aren't handled in the kmsg handler.
225          * */
226         assert(!irq_is_enabled());
227         kmsg = get_next_rkmsg(pcpui);
228         if (!kmsg)
229                 return;
230         msg_cp = *kmsg;
231         kmem_cache_free(kernel_msg_cache, kmsg);
232         assert(msg_cp.dstid == pcoreid);
233         /* The kmsg could block.  If it does, we want the kthread code to know
234          * it's not running on behalf of a process, and we're actually spawning
235          * a kernel task.  While we do have a syscall that does work in an RKM
236          * (change_to), it's not really the rest of the syscall context.  When
237          * we return or otherwise call smp_idle, smp_idle will reset these
238          * flags. */
239         pcpui->cur_kthread->flags = KTH_KTASK_FLAGS;
240         pcpui_trace_kmsg(pcpui, (uintptr_t)msg_cp.pc);
241         msg_cp.pc(msg_cp.srcid, msg_cp.arg0, msg_cp.arg1, msg_cp.arg2);
242         smp_idle();
243 }
244
245 /* extremely dangerous and racy: prints out the immed and routine kmsgs for a
246  * specific core (so possibly remotely) */
247 void print_kmsgs(uint32_t coreid)
248 {
249         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
250         void __print_kmsgs(struct kernel_msg_list *list, char *type)
251         {
252                 struct kernel_message *kmsg_i;
253
254                 STAILQ_FOREACH(kmsg_i, list, link) {
255                         printk("%s KMSG on %d from %d to run %p(%s)(%p, %p, %p)\n",
256                                type, kmsg_i->dstid, kmsg_i->srcid, kmsg_i->pc,
257                                get_fn_name((long)kmsg_i->pc),
258                                kmsg_i->arg0, kmsg_i->arg1, kmsg_i->arg2);
259                 }
260         }
261         __print_kmsgs(&pcpui->immed_amsgs, "Immedte");
262         __print_kmsgs(&pcpui->routine_amsgs, "Routine");
263 }
264
265 void __kmsg_trampoline(uint32_t srcid, long a0, long a1, long a2)
266 {
267         ((void (*)(long arg0, long arg1))a0)(a1, a2);
268 }
269
270 /* Debugging stuff */
271 void kmsg_queue_stat(void)
272 {
273         struct kernel_message *kmsg;
274         bool immed_emp, routine_emp;
275
276         for (int i = 0; i < num_cores; i++) {
277                 spin_lock_irqsave(&per_cpu_info[i].immed_amsg_lock);
278                 immed_emp = STAILQ_EMPTY(&per_cpu_info[i].immed_amsgs);
279                 spin_unlock_irqsave(&per_cpu_info[i].immed_amsg_lock);
280                 spin_lock_irqsave(&per_cpu_info[i].routine_amsg_lock);
281                 routine_emp = STAILQ_EMPTY(&per_cpu_info[i].routine_amsgs);
282                 spin_unlock_irqsave(&per_cpu_info[i].routine_amsg_lock);
283                 printk("Core %d's immed_emp: %d, routine_emp %d\n", i,
284                        immed_emp, routine_emp);
285                 if (!immed_emp) {
286                         kmsg = STAILQ_FIRST(&per_cpu_info[i].immed_amsgs);
287                         printk("Immed msg on core %d:\n", i);
288                         printk("\tsrc:  %d\n", kmsg->srcid);
289                         printk("\tdst:  %d\n", kmsg->dstid);
290                         printk("\tpc:   %p\n", kmsg->pc);
291                         printk("\targ0: %p\n", kmsg->arg0);
292                         printk("\targ1: %p\n", kmsg->arg1);
293                         printk("\targ2: %p\n", kmsg->arg2);
294                 }
295                 if (!routine_emp) {
296                         kmsg = STAILQ_FIRST(&per_cpu_info[i].routine_amsgs);
297                         printk("Routine msg on core %d:\n", i);
298                         printk("\tsrc:  %d\n", kmsg->srcid);
299                         printk("\tdst:  %d\n", kmsg->dstid);
300                         printk("\tpc:   %p\n", kmsg->pc);
301                         printk("\targ0: %p\n", kmsg->arg0);
302                         printk("\targ1: %p\n", kmsg->arg1);
303                         printk("\targ2: %p\n", kmsg->arg2);
304                 }
305
306         }
307 }
308
309 void print_kctx_depths(const char *str)
310 {
311         uint32_t coreid = core_id();
312         struct per_cpu_info *pcpui = &per_cpu_info[coreid];
313
314         if (!str)
315                 str = "(none)";
316         printk("%s: Core %d, irq depth %d, ktrap depth %d, irqon %d\n", str,
317                coreid, irq_depth(pcpui), ktrap_depth(pcpui), irq_is_enabled());
318 }
319
320 void print_user_ctx(struct user_context *ctx)
321 {
322         switch (ctx->type) {
323         case ROS_HW_CTX:
324                 print_trapframe(&ctx->tf.hw_tf);
325                 break;
326         case ROS_SW_CTX:
327                 print_swtrapframe(&ctx->tf.sw_tf);
328                 break;
329         case ROS_VM_CTX:
330                 print_vmtrapframe(&ctx->tf.vm_tf);
331                 break;
332         default:
333                 printk("Bad TF %p type %d!\n", ctx, ctx->type);
334         }
335 }