7ccfbfa88c9581f88759a001c5ad816936fdcb7d
[akaros.git] / user / parlib / include / uthread.h
1 #ifndef _UTHREAD_H
2 #define _UTHREAD_H
3
4 #include <vcore.h>
5 #include <ros/syscall.h>
6
7 #define UTHREAD_DONT_MIGRATE            0x001 /* don't move to another vcore */
8 #define UTHREAD_SAVED                           0x002 /* uthread's state is in utf */
9 #define UTHREAD_FPSAVED                         0x004 /* uthread's FP state is in uth->as */
10
11 /* Thread States */
12 #define UT_RUNNING              1
13 #define UT_NOT_RUNNING  2
14
15 /* Externally blocked thread reasons (for uthread_has_blocked()) */
16 #define UTH_EXT_BLK_MUTEX                       1
17 #define UTH_EXT_BLK_JUSTICE                     2       /* whatever.  might need more options */
18
19 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
20  * cast their threads to uthreads when talking with vcore code.  Vcore/default
21  * 2LS code won't touch udata or beyond. */
22 struct uthread {
23         struct user_context u_ctx;
24         struct ancillary_state as;
25         void *tls_desc;
26         int flags;
27         struct syscall *sysc;   /* syscall we're blocking on, if any */
28         int state;
29         void (*yield_func)(struct uthread*, void*);
30         void *yield_arg;
31 };
32 typedef struct uthread uthread_t;
33 extern __thread struct uthread *current_uthread;
34
35 /* 2L-Scheduler operations.  Can be 0.  Examples in pthread.c. */
36 struct schedule_ops {
37         /* Functions supporting thread ops */
38         void (*sched_entry)(void);
39         void (*thread_runnable)(struct uthread *);
40         void (*thread_paused)(struct uthread *);
41         void (*thread_blockon_sysc)(struct uthread *, void *);
42         void (*thread_has_blocked)(struct uthread *, int);
43         /* Functions event handling wants */
44         void (*preempt_pending)(void);
45         void (*spawn_thread)(uintptr_t pc_start, void *data);   /* don't run yet */
46 };
47 extern struct schedule_ops *sched_ops;
48
49 /* Call this, passing it a uthread representing thread0, from your 2LS init
50  * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
51 void uthread_lib_init(struct uthread *uthread);
52
53 /* Functions to make/manage uthreads.  Can be called by functions such as
54  * pthread_create(), which can wrap these with their own stuff (like attrs,
55  * retvals, etc). */
56
57 /* Does the uthread initialization of a uthread that the caller created.  Call
58  * this whenever you are "starting over" with a thread. */
59 void uthread_init(struct uthread *new_thread);
60 /* Low-level _S code calls this for basic uthreading without a 2LS */
61 void uthread_slim_init(void);
62 /* Call this when you are done with a uthread, forever, but before you free it */
63 void uthread_cleanup(struct uthread *uthread);
64 void uthread_runnable(struct uthread *uthread);
65 void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
66                    void *yield_arg);
67
68 /* Utility functions */
69 bool __check_preempt_pending(uint32_t vcoreid); /* careful: check the code */
70 void uth_disable_notifs(void);
71 void uth_enable_notifs(void);
72
73 bool register_evq(struct syscall *sysc, struct event_queue *ev_q);
74 void deregister_evq(struct syscall *sysc);
75
76 /* Helpers, which sched_entry() can call */
77 void highjack_current_uthread(struct uthread *uthread);
78 void run_current_uthread(void);
79 void run_uthread(struct uthread *uthread);
80
81 /* Event handlers - exported globally so programs can wrap them */
82 void handle_vc_preempt(struct event_msg *ev_msg, unsigned int ev_type);
83 void handle_vc_indir(struct event_msg *ev_msg, unsigned int ev_type);
84
85 /* Asking for trouble with this API, when we just want stacktop (or whatever
86  * the SP will be). */
87 static inline void init_uthread_ctx(struct uthread *uth, void (*entry)(void),
88                                     void *stack_bottom, uint32_t size)
89 {
90         init_user_ctx(&uth->u_ctx, (long)entry, (long)(stack_bottom) + size);
91 }
92
93 #define uthread_set_tls_var(uth, name, val)                                    \
94 ({                                                                             \
95         typeof(val) __val = val;                                                   \
96         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
97         name = __val;                                                              \
98         end_access_tls_vars();                                                     \
99 })
100
101 #define uthread_get_tls_var(uth, name)                                         \
102 ({                                                                             \
103         typeof(name) val;                                                          \
104         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
105         val = name;                                                                \
106         end_access_tls_vars();                                                     \
107         val;                                                                       \
108 })
109
110 #endif /* _UTHREAD_H */