Adds per cpu errbuf pointers
authorBarret Rhoden <brho@cs.berkeley.edu>
Sat, 24 Aug 2013 00:51:31 +0000 (17:51 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 16 Jan 2014 00:34:53 +0000 (16:34 -0800)
So we don't need to track perrbuf throughout all of the waserror-using code.

I'm tracking it as a void*, since the errbuf stuff isn't even in this branch
yet.

kern/include/kthread.h
kern/include/smp.h
kern/include/syscall.h
kern/src/kthread.c
kern/src/process.c
kern/src/syscall.c

index 43e01d6..fb00a0f 100644 (file)
@@ -30,6 +30,7 @@ struct kthread {
        uintptr_t                                       stacktop;
        struct proc                                     *proc;
        struct syscall                          *sysc;
+       void                                            *errbuf;        /* TODO: avoiding include loops */
        TAILQ_ENTRY(kthread)            link;
        /* ID, other shit, etc */
 };
index 168e80e..998ed09 100644 (file)
@@ -38,6 +38,7 @@ struct per_cpu_info {
        uint32_t __ctx_depth;           /* don't access directly.  see trap.h. */
        int __lock_checking_enabled;/* == 1, enables spinlock depth checking */
        struct syscall *cur_sysc;       /* ptr is into cur_proc's address space */
+       void *cur_errbuf;                       /* ptr to current err stack buffer */
        struct kthread *spare;          /* useful when restarting */
        struct timer_chain tchain;      /* for the per-core alarm */
        unsigned int lock_depth;
index 7e9082f..f4ca925 100644 (file)
@@ -47,6 +47,8 @@ intreg_t syscall(struct proc *p, uintreg_t sc_num, uintreg_t a0, uintreg_t a1,
 void set_errno(int errno);
 void set_errstr(char *errstr);
 char *current_errstr(void);
+struct errbuf *get_cur_errbuf(void);
+void set_cur_errbuf(struct errbuf *ebuf);
 void __signal_syscall(struct syscall *sysc, struct proc *p);
 
 /* Tracing functions */
index c27d1b9..2e98441 100644 (file)
@@ -72,6 +72,7 @@ void restart_kthread(struct kthread *kthread)
        /* Tell the core which syscall we are running (if any) */
        assert(!pcpui->cur_sysc);       /* catch bugs, prev user should clear */
        pcpui->cur_sysc = kthread->sysc;
+       pcpui->cur_errbuf = kthread->errbuf;
        /* Finally, restart our thread */
        pop_kernel_ctx(&kthread->context);
 }
@@ -229,7 +230,9 @@ void sem_down(struct semaphore *sem)
        kthread->proc = current;
        /* kthread tracks the syscall it is working on, which implies errno */
        kthread->sysc = pcpui->cur_sysc;
+       kthread->errbuf = pcpui->cur_errbuf;
        pcpui->cur_sysc = 0;                            /* this core no longer works on sysc */
+       pcpui->cur_errbuf = 0;                          /* this core no longer has an errbuf */
        if (kthread->proc)
                proc_incref(kthread->proc, 1);
        /* Save the context, toggle blocking for the reactivation */
index 7c35eb3..04daab8 100644 (file)
@@ -1629,6 +1629,7 @@ void abandon_core(void)
        /* Syscalls that don't return will ultimately call abadon_core(), so we need
         * to make sure we don't think we are still working on a syscall. */
        pcpui->cur_sysc = 0;
+       pcpui->cur_errbuf = 0;  /* just in case */
        if (pcpui->cur_proc)
                __abandon_core();
 }
index aa85f2a..b82cffd 100644 (file)
@@ -120,6 +120,18 @@ char *current_errstr(void)
        return pcpui->cur_sysc->errstr;
 }
 
+struct errbuf *get_cur_errbuf(void)
+{
+       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
+       return (struct errbuf*)pcpui->cur_errbuf;
+}
+
+void set_cur_errbuf(struct errbuf *ebuf)
+{
+       struct per_cpu_info *pcpui = &per_cpu_info[core_id()];
+       pcpui->cur_errbuf = ebuf;
+}
+
 /************** Utility Syscalls **************/
 
 static int sys_null(void)