parlib: Change opaque mutex/cv types to be structs
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 5 Apr 2017 18:19:39 +0000 (14:19 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Wed, 3 May 2017 16:13:02 +0000 (12:13 -0400)
Instead of pointers to structs.  We'll need this for the static
initialization of mutexes and whatnot.  The opaque types used to be
pointers, instead of a structs, since we didn't know their size.  That used
to be determined by the 2LS in its mutex/cv overrides.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
user/iplib/epoll.c
user/iplib/select.c
user/parlib/include/parlib/uthread.h
user/parlib/mutex.c
user/utest/cv.c
user/vmm/include/vmm/sched.h
user/vmm/nat.c

index 9a1c2fd..b191f61 100644 (file)
@@ -63,13 +63,13 @@ static struct kmem_cache *ep_alarms_cache;
 struct epoll_ctlr {
        TAILQ_ENTRY(epoll_ctlr)         link;
        struct event_queue                      *ceq_evq;
-       uth_mutex_t                                     mtx;
+       uth_mutex_t                                     *mtx;
        struct user_fd                          ufd;
 };
 
 TAILQ_HEAD(epoll_ctlrs, epoll_ctlr);
 static struct epoll_ctlrs all_ctlrs = TAILQ_HEAD_INITIALIZER(all_ctlrs);
-static uth_mutex_t ctlrs_mtx;
+static uth_mutex_t *ctlrs_mtx;
 
 /* There's some bookkeeping we need to maintain on every FD.  Right now, the FD
  * is the index into the CEQ event array, so we can just hook this into the user
index c50349b..3d3dce0 100644 (file)
@@ -64,9 +64,9 @@
 
 static int epoll_fd;
 static fd_set all_fds;
-static uth_mutex_t fdset_mtx;
+static uth_mutex_t *fdset_mtx;
 static uintptr_t unique_caller;
-static uth_mutex_t sleep_mtx;
+static uth_mutex_t *sleep_mtx;
 
 static bool fd_is_set(unsigned int fd, fd_set *set)
 {
index 97811b4..d9de32e 100644 (file)
@@ -167,9 +167,9 @@ static inline struct user_context *get_cur_uth_ctx(void)
 
 /* Uthread Mutexes / CVs / etc. */
 
-typedef struct uth_mutex uth_mutex_t;
-typedef struct uth_recurse_mutex uth_recurse_mutex_t;
-typedef struct uth_cond_var uth_cond_var_t;
+typedef struct uth_mutex uth_mutex_t;
+typedef struct uth_recurse_mutex uth_recurse_mutex_t;
+typedef struct uth_cond_var uth_cond_var_t;
 
 struct uth_mutex {
        struct spin_pdr_lock            lock;
@@ -178,7 +178,7 @@ struct uth_mutex {
 };
 
 struct uth_recurse_mutex {
-       uth_mutex_t                                     mtx;
+       uth_mutex_t                                     *mtx;
        struct uthread                          *lockholder;
        unsigned int                            count;
 };
@@ -188,26 +188,26 @@ struct uth_cond_var {
        uth_sync_t                                      sync_obj;
 };
 
-uth_mutex_t uth_mutex_alloc(void);
-void uth_mutex_free(uth_mutex_t m);
-void uth_mutex_lock(uth_mutex_t m);
-bool uth_mutex_trylock(uth_mutex_t m);
-void uth_mutex_unlock(uth_mutex_t m);
+uth_mutex_t *uth_mutex_alloc(void);
+void uth_mutex_free(uth_mutex_t *m);
+void uth_mutex_lock(uth_mutex_t *m);
+bool uth_mutex_trylock(uth_mutex_t *m);
+void uth_mutex_unlock(uth_mutex_t *m);
 
-uth_recurse_mutex_t uth_recurse_mutex_alloc(void);
-void uth_recurse_mutex_free(uth_recurse_mutex_t r_m);
-void uth_recurse_mutex_lock(uth_recurse_mutex_t r_m);
-bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_m);
-void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_m);
+uth_recurse_mutex_t *uth_recurse_mutex_alloc(void);
+void uth_recurse_mutex_free(uth_recurse_mutex_t *r_m);
+void uth_recurse_mutex_lock(uth_recurse_mutex_t *r_m);
+bool uth_recurse_mutex_trylock(uth_recurse_mutex_t *r_m);
+void uth_recurse_mutex_unlock(uth_recurse_mutex_t *r_m);
 
 /* Callers to cv_wait must hold the mutex, which it will atomically wait and
  * unlock, then relock when it returns.  Callers to signal and broadcast may
  * hold the mutex, if they choose. */
-uth_cond_var_t uth_cond_var_alloc(void);
-void uth_cond_var_free(uth_cond_var_t cv);
-void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t m);
-void uth_cond_var_signal(uth_cond_var_t cv);
-void uth_cond_var_broadcast(uth_cond_var_t cv);
+uth_cond_var_t *uth_cond_var_alloc(void);
+void uth_cond_var_free(uth_cond_var_t *cv);
+void uth_cond_var_wait(uth_cond_var_t *cv, uth_mutex_t *m);
+void uth_cond_var_signal(uth_cond_var_t *cv);
+void uth_cond_var_broadcast(uth_cond_var_t *cv);
 
 /* Called by gcc to see if we are multithreaded. */
 bool uth_2ls_is_multithreaded(void);
index 5d512a9..f485586 100644 (file)
@@ -14,7 +14,7 @@
 /************** Mutexes **************/
 
 
-uth_mutex_t uth_mutex_alloc(void)
+uth_mutex_t *uth_mutex_alloc(void)
 {
        struct uth_mutex *mtx;
 
@@ -26,7 +26,7 @@ uth_mutex_t uth_mutex_alloc(void)
        return mtx;
 }
 
-void uth_mutex_free(uth_mutex_t mtx)
+void uth_mutex_free(uth_mutex_t *mtx)
 {
        __uth_sync_free(mtx->sync_obj);
        free(mtx);
@@ -46,7 +46,7 @@ static void __mutex_cb(struct uthread *uth, void *arg)
        spin_pdr_unlock(&mtx->lock);
 }
 
-void uth_mutex_lock(uth_mutex_t mtx)
+void uth_mutex_lock(uth_mutex_t *mtx)
 {
        spin_pdr_lock(&mtx->lock);
        if (!mtx->locked) {
@@ -60,7 +60,7 @@ void uth_mutex_lock(uth_mutex_t mtx)
        uthread_yield(TRUE, __mutex_cb, mtx);
 }
 
-bool uth_mutex_trylock(uth_mutex_t mtx)
+bool uth_mutex_trylock(uth_mutex_t *mtx)
 {
        bool ret = FALSE;
 
@@ -73,7 +73,7 @@ bool uth_mutex_trylock(uth_mutex_t mtx)
        return ret;
 }
 
-void uth_mutex_unlock(uth_mutex_t mtx)
+void uth_mutex_unlock(uth_mutex_t *mtx)
 {
        struct uthread *uth;
 
@@ -90,7 +90,7 @@ void uth_mutex_unlock(uth_mutex_t mtx)
 /************** Recursive mutexes **************/
 
 
-uth_recurse_mutex_t uth_recurse_mutex_alloc(void)
+uth_recurse_mutex_t *uth_recurse_mutex_alloc(void)
 {
        struct uth_recurse_mutex *r_mtx = malloc(sizeof(struct uth_recurse_mutex));
 
@@ -101,13 +101,13 @@ uth_recurse_mutex_t uth_recurse_mutex_alloc(void)
        return r_mtx;
 }
 
-void uth_recurse_mutex_free(uth_recurse_mutex_t r_mtx)
+void uth_recurse_mutex_free(uth_recurse_mutex_t *r_mtx)
 {
        uth_mutex_free(r_mtx->mtx);
        free(r_mtx);
 }
 
-void uth_recurse_mutex_lock(uth_recurse_mutex_t r_mtx)
+void uth_recurse_mutex_lock(uth_recurse_mutex_t *r_mtx)
 {
        assert(!in_vcore_context());
        assert(current_uthread);
@@ -128,7 +128,7 @@ void uth_recurse_mutex_lock(uth_recurse_mutex_t r_mtx)
        r_mtx->count = 1;
 }
 
-bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_mtx)
+bool uth_recurse_mutex_trylock(uth_recurse_mutex_t *r_mtx)
 {
        bool ret;
 
@@ -146,7 +146,7 @@ bool uth_recurse_mutex_trylock(uth_recurse_mutex_t r_mtx)
        return ret;
 }
 
-void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_mtx)
+void uth_recurse_mutex_unlock(uth_recurse_mutex_t *r_mtx)
 {
        r_mtx->count--;
        if (!r_mtx->count) {
@@ -159,7 +159,7 @@ void uth_recurse_mutex_unlock(uth_recurse_mutex_t r_mtx)
 /************** Condition Variables **************/
 
 
-uth_cond_var_t uth_cond_var_alloc(void)
+uth_cond_var_t *uth_cond_var_alloc(void)
 {
        struct uth_cond_var *cv;
 
@@ -170,7 +170,7 @@ uth_cond_var_t uth_cond_var_alloc(void)
        return cv;
 }
 
-void uth_cond_var_free(uth_cond_var_t cv)
+void uth_cond_var_free(uth_cond_var_t *cv)
 {
        __uth_sync_free(cv->sync_obj);
        free(cv);
@@ -205,7 +205,7 @@ static void __cv_wait_cb(struct uthread *uth, void *arg)
         * sleep! (see below).  If that happens, the uthread is no longer sleeping
         * on the CV, and the sync_next is free.  The invariant is that a uthread
         * can only sleep on one sync_object at a time. */
-       uth_mutex_unlock((uth_mutex_t)mtx);
+       uth_mutex_unlock(mtx);
 }
 
 /* Caller holds mtx.  We will 'atomically' release it and wait.  On return,
@@ -261,7 +261,7 @@ static void __cv_wait_cb(struct uthread *uth, void *arg)
  *
  * Also note that we use the external API for the mutex operations.  A 2LS could
  * have their own mutex ops but still use the generic cv ops. */
-void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t mtx)
+void uth_cond_var_wait(uth_cond_var_t *cv, uth_mutex_t *mtx)
 {
        struct uth_cv_link link;
 
@@ -269,10 +269,10 @@ void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t mtx)
        link.mtx = mtx;
        spin_pdr_lock(&cv->lock);
        uthread_yield(TRUE, __cv_wait_cb, &link);
-       uth_mutex_lock((uth_mutex_t)mtx);
+       uth_mutex_lock(mtx);
 }
 
-void uth_cond_var_signal(uth_cond_var_t cv)
+void uth_cond_var_signal(uth_cond_var_t *cv)
 {
        struct uthread *uth;
 
@@ -283,7 +283,7 @@ void uth_cond_var_signal(uth_cond_var_t cv)
                uthread_runnable(uth);
 }
 
-void uth_cond_var_broadcast(uth_cond_var_t cv)
+void uth_cond_var_broadcast(uth_cond_var_t *cv)
 {
        struct uth_tailq restartees = TAILQ_HEAD_INITIALIZER(restartees);
        struct uthread *i, *safe;
index bc29041..da991bd 100644 (file)
@@ -11,8 +11,8 @@ TEST_SUITE("CV");
 /* <--- Begin definition of test cases ---> */
 
 struct common_args {
-       uth_cond_var_t                          cv;
-       uth_mutex_t                                     mtx;
+       uth_cond_var_t                          *cv;
+       uth_mutex_t                                     *mtx;
        bool                                            flag;
        unsigned int                            wait_sleep;
        unsigned int                            sig_sleep;
@@ -22,7 +22,7 @@ struct common_args {
 
 bool test_signal_no_wait(void)
 {
-       uth_cond_var_t cv = uth_cond_var_alloc();
+       uth_cond_var_t *cv = uth_cond_var_alloc();
 
        uth_cond_var_broadcast(cv);
        uth_cond_var_signal(cv);
index 9e79422..f8c9de0 100644 (file)
@@ -31,8 +31,8 @@ struct guest_thread {
        struct ctlr_thread                      *buddy;
        unsigned int                            gpc_id;
        bool                                            halt_exit;
-       uth_mutex_t                                     halt_mtx;
-       uth_cond_var_t                          halt_cv;
+       uth_mutex_t                                     *halt_mtx;
+       uth_cond_var_t                          *halt_cv;
        // TODO: work out a real ops strategy.
        bool (*vmcall)(struct guest_thread *gth, struct vm_trapframe *);
 };
index 01116d7..02212f3 100644 (file)
@@ -222,8 +222,8 @@ struct buf_pkt {
 STAILQ_HEAD(buf_pkt_stailq, buf_pkt);
 
 struct buf_pkt_stailq inject_pkts = STAILQ_HEAD_INITIALIZER(inject_pkts);
-uth_mutex_t rx_mtx;
-uth_cond_var_t rx_cv;
+uth_mutex_t *rx_mtx;
+uth_cond_var_t *rx_cv;
 struct event_queue *inbound_evq;
 
 static void tap_inbound_conv(int fd);