Pass sched_ops to uthread_2ls_init()
authorBarret Rhoden <brho@cs.berkeley.edu>
Mon, 24 Aug 2015 14:03:21 +0000 (10:03 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 24 Aug 2015 14:18:28 +0000 (10:18 -0400)
This is necessary so that in a later commit we can "atomically" set the
2LS ops and change current_uthread.  Ops like signal_ops aren't as
critical in this regard.

tests/mcp_halt.c
tests/mhello.c
tests/old/syscall.c
user/parlib/include/uthread.h
user/parlib/uthread.c
user/pthread/pthread.c

index ee234e6..79db5a2 100644 (file)
@@ -36,13 +36,10 @@ int main(int argc, char** argv)
        else
                nr_vcores = atoi(argv[1]);
 
-       /* set up our sched ops. */
-       sched_ops = &ghetto_sched_ops;
-
        /* Inits a thread for us, though we won't use it.  Just a hack to get into
         * _M mode.  Note this requests one vcore for us */
        struct uthread dummy = {0};
-       uthread_2ls_init(&dummy);
+       uthread_2ls_init(&dummy, &ghetto_sched_ops);
        uthread_mcp_init();
 
        /* Reset the blockon to be the spinner...  This is really shitty.  Any
index e9940a6..5a7352e 100644 (file)
@@ -41,9 +41,6 @@ int main(int argc, char** argv)
        uint32_t vcoreid;
        int retval;
 
-       /* set up our sched ops. */
-       sched_ops = &ghetto_sched_ops;
-
        /* Initialize our barrier. */
        mcs_barrier_init(&b, max_vcores());
 
@@ -80,7 +77,7 @@ int main(int argc, char** argv)
        /* Inits a thread for us, though we won't use it.  Just a hack to get into
         * _M mode.  Note this requests one vcore for us */
        struct uthread dummy = {0};
-       uthread_2ls_init(&dummy);
+       uthread_2ls_init(&dummy, &ghetto_sched_ops);
        uthread_mcp_init();
        /* Reset the blockon to be the spinner...  This is really shitty.  Any
         * blocking calls after we become an MCP and before this will fail.  This is
index 1572a45..c7a7eb0 100644 (file)
@@ -18,7 +18,6 @@ void ghetto_vcore_entry(void);
 struct schedule_ops ghetto_sched_ops = {
        .sched_entry = ghetto_vcore_entry,
 };
-struct schedule_ops *sched_ops = &ghetto_sched_ops;
 
 int main(int argc, char** argv)
 {
@@ -57,7 +56,7 @@ int main(int argc, char** argv)
        /* Inits a thread for us, though we won't use it.  Just a hack to get into
         * _M mode.  Note this requests one vcore for us */
        struct uthread dummy = {0};
-       uthread_2ls_init(&dummy);
+       uthread_2ls_init(&dummy, &ghetto_sched_ops);
        uthread_mcs_init();
        /* Need to save our floating point state somewhere (like in the
         * user_thread_tcb so it can be restarted too */
index cfd2fbb..bf8c8c4 100644 (file)
@@ -59,7 +59,7 @@ extern struct schedule_ops *sched_ops;
 void uthread_lib_init(void);
 /* Call this, passing it a uthread representing thread0, from your 2LS init
  * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
-void uthread_2ls_init(struct uthread *uthread);
+void uthread_2ls_init(struct uthread *uthread, struct schedule_ops *ops);
 /* Call this to become an mcp capable of worling with uthreads. */
 void uthread_mcp_init(void);
 
index 89c9c54..69816ff 100644 (file)
@@ -134,13 +134,14 @@ void uthread_mcp_init()
 }
 
 /* The real 2LS calls this, passing in a uthread representing thread0. */
-void uthread_2ls_init(struct uthread *uthread)
+void uthread_2ls_init(struct uthread *uthread, struct schedule_ops *ops)
 {
        /* All we need to do is set up thread0 to run with our new 2LS specific
         * uthread pointer. Under the hood, this function will free any previously
         * allocated uthread structs representing thread0 (e.g. the one set up by
         * uthread_lib_init() previously). */
        uthread_manage_thread0(uthread);
+       sched_ops = ops;
 }
 
 /* Helper: tells the kernel our SCP is capable of going into vcore context on
@@ -196,7 +197,7 @@ void __attribute__((constructor)) uthread_lib_init(void)
                             sizeof(struct uthread));
        assert(!ret);
        memset(thread0_uth, 0, sizeof(struct uthread)); /* aggressively 0 for bugs*/
-       uthread_manage_thread0(thread0_uth);
+       uthread_2ls_init(thread0_uth, &thread0_2ls_ops);
        scp_vcctx_ready();
        /* Change our blockon from glibc's internal one to the regular one, which
         * uses vcore context and works for SCPs (with or without 2LS) and MCPs.
index 956428c..8fcfa9b 100644 (file)
@@ -590,10 +590,6 @@ void __attribute__((constructor)) pthread_lib_init(void)
        init_once_racy(return);
        uthread_lib_init();
 
-       /* Publish our sched_ops and signal_ops, overriding the defaults */
-       sched_ops = &pthread_sched_ops;
-       signal_ops = &pthread_signal_ops;
-
        mcs_pdr_init(&queue_lock);
        /* Create a pthread_tcb for the main thread */
        ret = posix_memalign((void**)&t, __alignof__(struct pthread_tcb),
@@ -666,7 +662,9 @@ void __attribute__((constructor)) pthread_lib_init(void)
                sysc_mgmt[i].ev_q->ev_mbox = sysc_mbox;
        }
 #endif
-       uthread_2ls_init((struct uthread*)t);
+       /* Publish our signal_ops.  Sched ops is set by 2ls_init */
+       signal_ops = &pthread_signal_ops;
+       uthread_2ls_init((struct uthread*)t, &pthread_sched_ops);
        atomic_init(&threads_total, 1);                 /* one for thread0 */
 }