Add generic uthread condition variables
[akaros.git] / user / parlib / include / parlib / uthread.h
1 #pragma once
2
3 #include <parlib/vcore.h>
4 #include <parlib/signal.h>
5 #include <ros/syscall.h>
6
7 __BEGIN_DECLS
8
9 #define UTHREAD_DONT_MIGRATE            0x001 /* don't move to another vcore */
10 #define UTHREAD_SAVED                           0x002 /* uthread's state is in utf */
11 #define UTHREAD_FPSAVED                         0x004 /* uthread's FP state is in uth->as */
12 #define UTHREAD_IS_THREAD0                      0x008 /* thread0: glibc's main() thread */
13
14 /* Thread States */
15 #define UT_RUNNING              1
16 #define UT_NOT_RUNNING  2
17
18 /* Externally blocked thread reasons (for uthread_has_blocked()) */
19 #define UTH_EXT_BLK_MUTEX                       1
20 #define UTH_EXT_BLK_EVENTQ                      2
21 #define UTH_EXT_BLK_JUSTICE                     3       /* whatever.  might need more options */
22
23 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
24  * cast their threads to uthreads when talking with vcore code.  Vcore/default
25  * 2LS code won't touch udata or beyond. */
26 struct uthread {
27         struct user_context u_ctx;
28         struct ancillary_state as;
29         void *tls_desc;
30         int flags;
31         int state;
32         struct sigstate sigstate;
33         int notif_disabled_depth;
34         struct syscall *sysc;   /* syscall we're blocking on, if any */
35         struct syscall local_sysc;      /* for when we don't want to use the stack */
36         void (*yield_func)(struct uthread*, void*);
37         void *yield_arg;
38         int err_no;
39         char err_str[MAX_ERRSTR_LEN];
40 };
41 extern __thread struct uthread *current_uthread;
42
43 /* These structs are undefined.  We use them instead of void * so we can get
44  * compiler warnings if someone passes the wrong pointer type.  Internally, we
45  * use another struct type for mtx and cvs. */
46 typedef struct __uth_mtx_opaque * uth_mutex_t;
47 typedef struct __uth_cv_opaque * uth_cond_var_t;
48
49 /* 2L-Scheduler operations.  Examples in pthread.c. */
50 struct schedule_ops {
51         /**** These functions must be defined ****/
52         /* Functions supporting thread ops */
53         void (*sched_entry)(void);
54         void (*thread_runnable)(struct uthread *);
55         void (*thread_paused)(struct uthread *);
56         void (*thread_blockon_sysc)(struct uthread *, void *);
57         void (*thread_has_blocked)(struct uthread *, int);
58         void (*thread_refl_fault)(struct uthread *, struct user_context *);
59         /**** Defining these functions is optional. ****/
60         /* 2LSs can leave the mutex/cv funcs empty for a default implementation */
61         uth_mutex_t (*mutex_alloc)(void);
62         void (*mutex_free)(uth_mutex_t);
63         void (*mutex_lock)(uth_mutex_t);
64         void (*mutex_unlock)(uth_mutex_t);
65         uth_cond_var_t (*cond_var_alloc)(void);
66         void (*cond_var_free)(uth_cond_var_t);
67         void (*cond_var_wait)(uth_cond_var_t, uth_mutex_t);
68         void (*cond_var_signal)(uth_cond_var_t);
69         void (*cond_var_broadcast)(uth_cond_var_t);
70         /* Functions event handling wants */
71         void (*preempt_pending)(void);
72 };
73 extern struct schedule_ops *sched_ops;
74
75 /* Low-level _S code calls this for basic uthreading without a 2LS */
76 void uthread_lib_init(void);
77 /* Call this, passing it a uthread representing thread0, from your 2LS init
78  * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
79 void uthread_2ls_init(struct uthread *uthread, struct schedule_ops *ops);
80 /* Call this to become an mcp capable of worling with uthreads. */
81 void uthread_mcp_init(void);
82
83 /* Functions to make/manage uthreads.  Can be called by functions such as
84  * pthread_create(), which can wrap these with their own stuff (like attrs,
85  * retvals, etc). */
86
87 /* uthread_init() does the uthread initialization of a uthread that the caller
88  * created.  Call this whenever you are "starting over" with a thread.  Pass in
89  * attr, if you want to override any defaults. */
90 struct uth_thread_attr {
91         bool want_tls;          /* default, no */
92 };
93 void uthread_init(struct uthread *new_thread, struct uth_thread_attr *attr);
94 /* Call this when you are done with a uthread, forever, but before you free it */
95 void uthread_cleanup(struct uthread *uthread);
96 void uthread_runnable(struct uthread *uthread);
97 void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
98                    void *yield_arg);
99 void uthread_sleep(unsigned int seconds);
100 void uthread_usleep(unsigned int usecs);
101 void uthread_sleep_forever(void);
102 void uthread_has_blocked(struct uthread *uthread, int flags);
103 void uthread_paused(struct uthread *uthread);
104
105 /* Utility functions */
106 bool __check_preempt_pending(uint32_t vcoreid); /* careful: check the code */
107 void uth_disable_notifs(void);
108 void uth_enable_notifs(void);
109
110 /* Helpers, which the 2LS can call */
111 void __block_uthread_on_async_sysc(struct uthread *uth);
112 void highjack_current_uthread(struct uthread *uthread);
113 struct uthread *stop_current_uthread(void);
114 void __attribute__((noreturn)) run_current_uthread(void);
115 void __attribute__((noreturn)) run_uthread(struct uthread *uthread);
116
117 /* Asking for trouble with this API, when we just want stacktop (or whatever
118  * the SP will be). */
119 static inline void init_uthread_ctx(struct uthread *uth, void (*entry)(void),
120                                     void *stack_bottom, uint32_t size)
121 {
122         init_user_ctx(&uth->u_ctx, (long)entry, (long)(stack_bottom) + size);
123 }
124
125 #define uthread_set_tls_var(uth, name, val)                                    \
126 ({                                                                             \
127         typeof(val) __val = val;                                                   \
128         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
129         name = __val;                                                              \
130         end_access_tls_vars();                                                     \
131 })
132
133 #define uthread_get_tls_var(uth, name)                                         \
134 ({                                                                             \
135         typeof(name) val;                                                          \
136         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
137         val = name;                                                                \
138         end_access_tls_vars();                                                     \
139         val;                                                                       \
140 })
141
142 /* Generic Uthread Mutexes.  2LSs implement their own methods, but we need a
143  * 2LS-independent interface and default implementation. */
144 uth_mutex_t uth_mutex_alloc(void);
145 void uth_mutex_free(uth_mutex_t m);
146 void uth_mutex_lock(uth_mutex_t m);
147 void uth_mutex_unlock(uth_mutex_t m);
148
149 /* Generic Uthread Condition Variables.  2LSs can implement their own methods.
150  * Callers to cv_wait must hold the mutex, which it will atomically wait and
151  * unlock, then relock when it returns.  Callers to signal and broadcast may
152  * hold the mutex, if they choose. */
153 uth_cond_var_t uth_cond_var_alloc(void);
154 void uth_cond_var_free(uth_cond_var_t cv);
155 void uth_cond_var_wait(uth_cond_var_t cv, uth_mutex_t m);
156 void uth_cond_var_signal(uth_cond_var_t cv);
157 void uth_cond_var_broadcast(uth_cond_var_t cv);
158
159 __END_DECLS