2LS thread_blockon now takes the uthread*
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 18 Apr 2012 20:58:12 +0000 (13:58 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 18 Apr 2012 22:40:20 +0000 (15:40 -0700)
Keeps it in line with the other 2LS thread ops.  Need to do some void*
trickery for upcoming patches, and because C is picky about void* vs
struct xme* as parameters in function pointers.

user/parlib/include/uthread.h
user/parlib/uthread.c
user/pthread/pthread.c

index e39004a..f659b50 100644 (file)
@@ -33,7 +33,7 @@ struct schedule_ops {
        void (*thread_runnable)(struct uthread *);
        void (*thread_yield)(struct uthread *);
        void (*thread_paused)(struct uthread *);
-       void (*thread_blockon_sysc)(struct syscall *);
+       void (*thread_blockon_sysc)(struct uthread *, void *);
        /* Functions event handling wants */
        void (*preempt_pending)(void);
        void (*spawn_thread)(uintptr_t pc_start, void *data);   /* don't run yet */
index e0a99b2..309752e 100644 (file)
@@ -233,7 +233,7 @@ __uthread_yield(void)
         * up doing this differently when/if we have more ways to yield. */
        if (uthread->sysc) {
                assert(sched_ops->thread_blockon_sysc);
-               sched_ops->thread_blockon_sysc(uthread->sysc);
+               sched_ops->thread_blockon_sysc(uthread, uthread->sysc);
                /* make sure you don't touch uthread after that sched ops call */
        } else { /* generic yield */
                assert(sched_ops->thread_yield);
index 0eb1ff8..01d5796 100644 (file)
@@ -37,9 +37,9 @@ void pth_sched_entry(void);
 void pth_thread_runnable(struct uthread *uthread);
 void pth_thread_yield(struct uthread *uthread);
 void pth_thread_paused(struct uthread *uthread);
+void pth_thread_blockon_sysc(struct uthread *uthread, void *sysc);
 void pth_preempt_pending(void);
 void pth_spawn_thread(uintptr_t pc_start, void *data);
-void pth_blockon_sysc(struct syscall *sysc);
 
 /* Event Handlers */
 static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type);
@@ -49,7 +49,7 @@ struct schedule_ops pthread_sched_ops = {
        pth_thread_runnable,
        pth_thread_yield,
        pth_thread_paused,
-       pth_blockon_sysc,
+       pth_thread_blockon_sysc,
        0, /* pth_preempt_pending, */
        0, /* pth_spawn_thread, */
 };
@@ -273,22 +273,21 @@ static void pth_handle_syscall(struct event_msg *ev_msg, unsigned int ev_type)
  * and is trying to block on sysc.  Need to put it somewhere were we can wake it
  * up when the sysc is done.  For now, we'll have the kernel send us an event
  * when the syscall is done. */
-void pth_blockon_sysc(struct syscall *sysc)
+void pth_thread_blockon_sysc(struct uthread *uthread, void *syscall)
 {
+       struct syscall *sysc = (struct syscall*)syscall;
        int old_flags;
        bool need_to_restart = FALSE;
        uint32_t vcoreid = vcore_id();
-
        /* rip from the active queue */
-       struct pthread_tcb *pthread = (struct pthread_tcb*)current_uthread;
+       struct pthread_tcb *pthread = (struct pthread_tcb*)uthread;
        pthread->state = PTH_BLK_SYSC;
        mcs_pdr_lock(&queue_lock);
        threads_active--;
        TAILQ_REMOVE(&active_queue, pthread, next);
        mcs_pdr_unlock(&queue_lock);
-
        /* Set things up so we can wake this thread up later */
-       sysc->u_data = current_uthread;
+       sysc->u_data = uthread;
        /* Register our vcore's syscall ev_q to hear about this syscall. */
        if (!register_evq(sysc, sysc_mgmt[vcoreid].ev_q)) {
                /* Lost the race with the call being done.  The kernel won't send the