parlib: Implement uthread mutexes with semaphores
[akaros.git] / user / parlib / include / parlib / uthread.h
index e12f4ea..6607b5f 100644 (file)
@@ -2,7 +2,10 @@
 
 #include <parlib/vcore.h>
 #include <parlib/signal.h>
+#include <parlib/spinlock.h>
+#include <parlib/parlib.h>
 #include <ros/syscall.h>
+#include <sys/queue.h>
 
 __BEGIN_DECLS
 
@@ -31,6 +34,7 @@ struct uthread {
        int state;
        struct sigstate sigstate;
        int notif_disabled_depth;
+       TAILQ_ENTRY(uthread) sync_next;
        struct syscall *sysc;   /* syscall we're blocking on, if any */
        struct syscall local_sysc;      /* for when we don't want to use the stack */
        void (*yield_func)(struct uthread*, void*);
@@ -38,14 +42,27 @@ struct uthread {
        int err_no;
        char err_str[MAX_ERRSTR_LEN];
 };
+TAILQ_HEAD(uth_tailq, uthread);
+
 extern __thread struct uthread *current_uthread;
 
-/* These structs are undefined.  We use them instead of void * so we can get
- * compiler warnings if someone passes the wrong pointer type.  Internally, we
- * use another struct type for mtx and cvs. */
-typedef struct __uth_mtx_opaque * uth_mutex_t;
-typedef struct __uth_recurse_mtx_opaque * uth_recurse_mutex_t;
-typedef struct __uth_cv_opaque * uth_cond_var_t;
+
+/* This struct is undefined.  We use it instead of void * so we can get
+ * compiler warnings if someone passes the wrong pointer type.  Internally, 2LSs
+ * and the default implementation use another object type. */
+typedef struct __uth_sync_opaque * uth_sync_t;
+
+/* 2LS-independent synchronization code (e.g. uthread mutexes) uses these
+ * helpers to access 2LS-specific functions.
+ *
+ * Note the spinlock associated with the higher-level sync primitive is held for
+ * these (where applicable). */
+uth_sync_t __uth_sync_alloc(void);
+void __uth_sync_free(uth_sync_t sync);
+struct uthread *__uth_sync_get_next(uth_sync_t sync);
+bool __uth_sync_get_uth(uth_sync_t sync, struct uthread *uth);
+/* 2LSs that use default sync objs will call this in their has_blocked op. */
+void __uth_default_sync_enqueue(struct uthread *uth, uth_sync_t sync);
 
 /* 2L-Scheduler operations.  Examples in pthread.c. */
 struct schedule_ops {
@@ -55,20 +72,13 @@ struct schedule_ops {
        void (*thread_runnable)(struct uthread *);
        void (*thread_paused)(struct uthread *);
        void (*thread_blockon_sysc)(struct uthread *, void *);
-       void (*thread_has_blocked)(struct uthread *, int);
+       void (*thread_has_blocked)(struct uthread *, uth_sync_t, int);
        void (*thread_refl_fault)(struct uthread *, struct user_context *);
        /**** Defining these functions is optional. ****/
-       /* 2LSs can leave the mutex/cv funcs empty for a default implementation */
-       uth_mutex_t (*mutex_alloc)(void);
-       void (*mutex_free)(uth_mutex_t);
-       void (*mutex_lock)(uth_mutex_t);
-       bool (*mutex_trylock)(uth_mutex_t);
-       void (*mutex_unlock)(uth_mutex_t);
-       uth_cond_var_t (*cond_var_alloc)(void);
-       void (*cond_var_free)(uth_cond_var_t);
-       void (*cond_var_wait)(uth_cond_var_t, uth_mutex_t);
-       void (*cond_var_signal)(uth_cond_var_t);
-       void (*cond_var_broadcast)(uth_cond_var_t);
+       uth_sync_t (*sync_alloc)(void);
+       void (*sync_free)(uth_sync_t);
+       struct uthread *(*sync_get_next)(uth_sync_t);
+       bool (*sync_get_uth)(uth_sync_t, struct uthread *);
        /* Functions event handling wants */
        void (*preempt_pending)(void);
 };
@@ -106,7 +116,7 @@ void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
 void uthread_sleep(unsigned int seconds);
 void uthread_usleep(unsigned int usecs);
 void __attribute__((noreturn)) uthread_sleep_forever(void);
-void uthread_has_blocked(struct uthread *uthread, int flags);
+void uthread_has_blocked(struct uthread *uthread, uth_sync_t sync, int flags);
 void uthread_paused(struct uthread *uthread);
 
 /* Utility functions */
@@ -156,31 +166,63 @@ static inline struct user_context *get_cur_uth_ctx(void)
        val;                                                                       \
 })
 
-/* Generic Uthread Mutexes.  2LSs implement their own methods, but we need a
- * 2LS-independent interface and default implementation. */
-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);
-
-/* Recursive mutexes.  Internally, these are built on top of the regular
- * mutexes, and 2LSs do not have their own version. */
-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);
-
-/* Generic Uthread Condition Variables.  2LSs can implement their own methods.
- * Callers to cv_wait must hold the mutex, which it will atomically wait and
+/* Uthread Mutexes / CVs / etc. */
+
+typedef struct uth_semaphore uth_semaphore_t;
+typedef struct uth_semaphore uth_mutex_t;
+typedef struct uth_recurse_mutex uth_recurse_mutex_t;
+typedef struct uth_cond_var uth_cond_var_t;
+
+struct uth_semaphore {
+       struct spin_pdr_lock            lock;
+       uth_sync_t                                      sync_obj;
+       unsigned int                            count;
+       parlib_once_t                           once_ctl;
+};
+#define UTH_SEMAPHORE_INIT(n) { .once_ctl = PARLIB_ONCE_INIT, .count = (n) }
+#define UTH_MUTEX_INIT { .once_ctl = PARLIB_ONCE_INIT }
+
+struct uth_recurse_mutex {
+       uth_mutex_t                                     mtx;
+       struct uthread                          *lockholder;
+       unsigned int                            count;
+       parlib_once_t                           once_ctl;
+};
+#define UTH_RECURSE_MUTEX_INIT { .once_ctl = PARLIB_ONCE_INIT }
+
+struct uth_cond_var {
+       struct spin_pdr_lock            lock;
+       uth_sync_t                                      sync_obj;
+       parlib_once_t                           once_ctl;
+};
+#define UTH_COND_VAR_INIT { .once_ctl = PARLIB_ONCE_INIT }
+
+uth_semaphore_t *uth_semaphore_alloc(unsigned int count);
+void uth_semaphore_free(uth_semaphore_t *sem);
+void uth_semaphore_down(uth_semaphore_t *sem);
+bool uth_semaphore_trydown(uth_semaphore_t *sem);
+void uth_semaphore_up(uth_semaphore_t *sem);
+
+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);
+
+/* 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);