parlib: Add static initializers for mutexes / CVs
[akaros.git] / user / parlib / include / parlib / uthread.h
1 #pragma once
2
3 #include <parlib/vcore.h>
4 #include <parlib/signal.h>
5 #include <parlib/spinlock.h>
6 #include <parlib/parlib.h>
7 #include <ros/syscall.h>
8 #include <sys/queue.h>
9
10 __BEGIN_DECLS
11
12 #define UTHREAD_DONT_MIGRATE            0x001 /* don't move to another vcore */
13 #define UTHREAD_SAVED                           0x002 /* uthread's state is in utf */
14 #define UTHREAD_FPSAVED                         0x004 /* uthread's FP state is in uth->as */
15 #define UTHREAD_IS_THREAD0                      0x008 /* thread0: glibc's main() thread */
16
17 /* Thread States */
18 #define UT_RUNNING              1
19 #define UT_NOT_RUNNING  2
20
21 /* Externally blocked thread reasons (for uthread_has_blocked()) */
22 #define UTH_EXT_BLK_MUTEX                       1
23 #define UTH_EXT_BLK_EVENTQ                      2
24 #define UTH_EXT_BLK_JUSTICE                     3       /* whatever.  might need more options */
25
26 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
27  * cast their threads to uthreads when talking with vcore code.  Vcore/default
28  * 2LS code won't touch udata or beyond. */
29 struct uthread {
30         struct user_context u_ctx;
31         struct ancillary_state as;
32         void *tls_desc;
33         int flags;
34         int state;
35         struct sigstate sigstate;
36         int notif_disabled_depth;
37         TAILQ_ENTRY(uthread) sync_next;
38         struct syscall *sysc;   /* syscall we're blocking on, if any */
39         struct syscall local_sysc;      /* for when we don't want to use the stack */
40         void (*yield_func)(struct uthread*, void*);
41         void *yield_arg;
42         int err_no;
43         char err_str[MAX_ERRSTR_LEN];
44 };
45 TAILQ_HEAD(uth_tailq, uthread);
46
47 extern __thread struct uthread *current_uthread;
48
49
50 /* This struct is undefined.  We use it instead of void * so we can get
51  * compiler warnings if someone passes the wrong pointer type.  Internally, 2LSs
52  * and the default implementation use another object type. */
53 typedef struct __uth_sync_opaque * uth_sync_t;
54
55 /* 2LS-independent synchronization code (e.g. uthread mutexes) uses these
56  * helpers to access 2LS-specific functions.
57  *
58  * Note the spinlock associated with the higher-level sync primitive is held for
59  * these (where applicable). */
60 uth_sync_t __uth_sync_alloc(void);
61 void __uth_sync_free(uth_sync_t sync);
62 struct uthread *__uth_sync_get_next(uth_sync_t sync);
63 bool __uth_sync_get_uth(uth_sync_t sync, struct uthread *uth);
64 /* 2LSs that use default sync objs will call this in their has_blocked op. */
65 void __uth_default_sync_enqueue(struct uthread *uth, uth_sync_t sync);
66
67 /* 2L-Scheduler operations.  Examples in pthread.c. */
68 struct schedule_ops {
69         /**** These functions must be defined ****/
70         /* Functions supporting thread ops */
71         void (*sched_entry)(void);
72         void (*thread_runnable)(struct uthread *);
73         void (*thread_paused)(struct uthread *);
74         void (*thread_blockon_sysc)(struct uthread *, void *);
75         void (*thread_has_blocked)(struct uthread *, uth_sync_t, int);
76         void (*thread_refl_fault)(struct uthread *, struct user_context *);
77         /**** Defining these functions is optional. ****/
78         uth_sync_t (*sync_alloc)(void);
79         void (*sync_free)(uth_sync_t);
80         struct uthread *(*sync_get_next)(uth_sync_t);
81         bool (*sync_get_uth)(uth_sync_t, struct uthread *);
82         /* Functions event handling wants */
83         void (*preempt_pending)(void);
84 };
85 extern struct schedule_ops *sched_ops;
86
87 /* Low-level _S code calls this for basic uthreading without a 2LS */
88 void uthread_lib_init(void);
89 /* Call this from your 2LS init routines.  Pass it a uthread representing
90  * thread0, your 2LS ops, and your syscall handler + data.
91  *
92  * When it returns, you're in _M mode (thread0 on vcore0) */
93 void uthread_2ls_init(struct uthread *uthread, struct schedule_ops *ops,
94                       void (*handle_sysc)(struct event_msg *, unsigned int,
95                                           void *),
96                       void *data);
97 /* Call this to become an mcp capable of worling with uthreads. */
98 void uthread_mcp_init(void);
99
100 /* Functions to make/manage uthreads.  Can be called by functions such as
101  * pthread_create(), which can wrap these with their own stuff (like attrs,
102  * retvals, etc). */
103
104 /* uthread_init() does the uthread initialization of a uthread that the caller
105  * created.  Call this whenever you are "starting over" with a thread.  Pass in
106  * attr, if you want to override any defaults. */
107 struct uth_thread_attr {
108         bool want_tls;          /* default, no */
109 };
110 void uthread_init(struct uthread *new_thread, struct uth_thread_attr *attr);
111 /* Call this when you are done with a uthread, forever, but before you free it */
112 void uthread_cleanup(struct uthread *uthread);
113 void uthread_runnable(struct uthread *uthread);
114 void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
115                    void *yield_arg);
116 void uthread_sleep(unsigned int seconds);
117 void uthread_usleep(unsigned int usecs);
118 void __attribute__((noreturn)) uthread_sleep_forever(void);
119 void uthread_has_blocked(struct uthread *uthread, uth_sync_t sync, int flags);
120 void uthread_paused(struct uthread *uthread);
121
122 /* Utility functions */
123 bool __check_preempt_pending(uint32_t vcoreid); /* careful: check the code */
124 void uth_disable_notifs(void);
125 void uth_enable_notifs(void);
126
127 /* Helpers, which the 2LS can call */
128 void __block_uthread_on_async_sysc(struct uthread *uth);
129 void highjack_current_uthread(struct uthread *uthread);
130 struct uthread *stop_current_uthread(void);
131 void __attribute__((noreturn)) run_current_uthread(void);
132 void __attribute__((noreturn)) run_uthread(struct uthread *uthread);
133
134 /* Asking for trouble with this API, when we just want stacktop (or whatever
135  * the SP will be). */
136 static inline void init_uthread_ctx(struct uthread *uth, void (*entry)(void),
137                                     void *stack_bottom, uint32_t size)
138 {
139         init_user_ctx(&uth->u_ctx, (long)entry, (long)(stack_bottom) + size);
140 }
141
142 /* When we look at the current_uthread, its context might be in the uthread
143  * struct or it might be in VCPD.  This returns a pointer to the right place. */
144 static inline struct user_context *get_cur_uth_ctx(void)
145 {
146         if (current_uthread->flags & UTHREAD_SAVED)
147                 return &current_uthread->u_ctx;
148         else
149                 return &vcpd_of(vcore_id())->uthread_ctx;
150 }
151
152 #define uthread_set_tls_var(uth, name, val)                                    \
153 ({                                                                             \
154         typeof(val) __val = val;                                                   \
155         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
156         name = __val;                                                              \
157         end_access_tls_vars();                                                     \
158 })
159
160 #define uthread_get_tls_var(uth, name)                                         \
161 ({                                                                             \
162         typeof(name) val;                                                          \
163         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
164         val = name;                                                                \
165         end_access_tls_vars();                                                     \
166         val;                                                                       \
167 })
168
169 /* Uthread Mutexes / CVs / etc. */
170
171 typedef struct uth_mutex uth_mutex_t;
172 typedef struct uth_recurse_mutex uth_recurse_mutex_t;
173 typedef struct uth_cond_var uth_cond_var_t;
174
175 struct uth_mutex {
176         struct spin_pdr_lock            lock;
177         uth_sync_t                                      sync_obj;
178         bool                                            locked;
179         parlib_once_t                           once_ctl;
180 };
181 #define UTH_MUTEX_INIT { .once_ctl = PARLIB_ONCE_INIT }
182
183 struct uth_recurse_mutex {
184         uth_mutex_t                                     mtx;
185         struct uthread                          *lockholder;
186         unsigned int                            count;
187         parlib_once_t                           once_ctl;
188 };
189 #define UTH_RECURSE_MUTEX_INIT { .once_ctl = PARLIB_ONCE_INIT }
190
191 struct uth_cond_var {
192         struct spin_pdr_lock            lock;
193         uth_sync_t                                      sync_obj;
194         parlib_once_t                           once_ctl;
195 };
196 #define UTH_COND_VAR_INIT { .once_ctl = PARLIB_ONCE_INIT }
197
198 uth_mutex_t *uth_mutex_alloc(void);
199 void uth_mutex_free(uth_mutex_t *m);
200 void uth_mutex_lock(uth_mutex_t *m);
201 bool uth_mutex_trylock(uth_mutex_t *m);
202 void uth_mutex_unlock(uth_mutex_t *m);
203
204 uth_recurse_mutex_t *uth_recurse_mutex_alloc(void);
205 void uth_recurse_mutex_free(uth_recurse_mutex_t *r_m);
206 void uth_recurse_mutex_lock(uth_recurse_mutex_t *r_m);
207 bool uth_recurse_mutex_trylock(uth_recurse_mutex_t *r_m);
208 void uth_recurse_mutex_unlock(uth_recurse_mutex_t *r_m);
209
210 /* Callers to cv_wait must hold the mutex, which it will atomically wait and
211  * unlock, then relock when it returns.  Callers to signal and broadcast may
212  * hold the mutex, if they choose. */
213 uth_cond_var_t *uth_cond_var_alloc(void);
214 void uth_cond_var_free(uth_cond_var_t *cv);
215 void uth_cond_var_wait(uth_cond_var_t *cv, uth_mutex_t *m);
216 void uth_cond_var_signal(uth_cond_var_t *cv);
217 void uth_cond_var_broadcast(uth_cond_var_t *cv);
218
219 /* Called by gcc to see if we are multithreaded. */
220 bool uth_2ls_is_multithreaded(void);
221
222 __END_DECLS