50faa9035bc3ee247567de99a56a7710c8e7e2d4
[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 #define UTHREAD_IS_THREAD0                      0x008 /* thread0: glibc's main() thread */
11
12 /* Thread States */
13 #define UT_RUNNING              1
14 #define UT_NOT_RUNNING  2
15
16 /* Externally blocked thread reasons (for uthread_has_blocked()) */
17 #define UTH_EXT_BLK_MUTEX                       1
18 #define UTH_EXT_BLK_JUSTICE                     2       /* whatever.  might need more options */
19
20 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
21  * cast their threads to uthreads when talking with vcore code.  Vcore/default
22  * 2LS code won't touch udata or beyond. */
23 struct uthread {
24         struct user_context u_ctx;
25         struct ancillary_state as;
26         void *tls_desc;
27         int flags;
28         int state;
29         struct syscall *sysc;   /* syscall we're blocking on, if any */
30         struct syscall local_sysc;      /* for when we don't want to use the stack */
31         void (*yield_func)(struct uthread*, void*);
32         void *yield_arg;
33         int err_no;
34         char err_str[MAX_ERRSTR_LEN];
35 };
36 typedef struct uthread uthread_t;
37 extern __thread struct uthread *current_uthread;
38
39 /* 2L-Scheduler operations.  Examples in pthread.c. */
40 struct schedule_ops {
41         /* Functions supporting thread ops */
42         void (*sched_entry)(void);
43         void (*thread_runnable)(struct uthread *);
44         void (*thread_paused)(struct uthread *);
45         void (*thread_blockon_sysc)(struct uthread *, void *);
46         void (*thread_has_blocked)(struct uthread *, int);
47         void (*thread_refl_fault)(struct uthread *, unsigned int, unsigned int,
48                                                           unsigned long);
49         /* Functions event handling wants */
50         void (*preempt_pending)(void);
51         void (*spawn_thread)(uintptr_t pc_start, void *data);   /* don't run yet */
52 };
53 extern struct schedule_ops *sched_ops;
54
55 /* Call this, passing it a uthread representing thread0, from your 2LS init
56  * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
57 void uthread_lib_init(struct uthread *uthread);
58
59 /* Functions to make/manage uthreads.  Can be called by functions such as
60  * pthread_create(), which can wrap these with their own stuff (like attrs,
61  * retvals, etc). */
62
63 /* uthread_init() does the uthread initialization of a uthread that the caller
64  * created.  Call this whenever you are "starting over" with a thread.  Pass in
65  * attr, if you want to override any defaults. */
66 struct uth_thread_attr {
67         bool want_tls;          /* default, no */
68 };
69 void uthread_init(struct uthread *new_thread, struct uth_thread_attr *attr);
70 /* Low-level _S code calls this for basic uthreading without a 2LS */
71 void uthread_slim_init(void);
72 /* Call this when you are done with a uthread, forever, but before you free it */
73 void uthread_cleanup(struct uthread *uthread);
74 void uthread_runnable(struct uthread *uthread);
75 void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
76                    void *yield_arg);
77 void uthread_sleep(unsigned int seconds);
78
79 /* Utility functions */
80 bool __check_preempt_pending(uint32_t vcoreid); /* careful: check the code */
81 void uth_disable_notifs(void);
82 void uth_enable_notifs(void);
83
84 bool register_evq(struct syscall *sysc, struct event_queue *ev_q);
85 void deregister_evq(struct syscall *sysc);
86
87 /* Helpers, which sched_entry() can call */
88 void highjack_current_uthread(struct uthread *uthread);
89 void run_current_uthread(void);
90 void run_uthread(struct uthread *uthread);
91 static inline struct uthread **get_cur_uth_addr(uint32_t vcoreid);
92
93 /* Asking for trouble with this API, when we just want stacktop (or whatever
94  * the SP will be). */
95 static inline void init_uthread_ctx(struct uthread *uth, void (*entry)(void),
96                                     void *stack_bottom, uint32_t size)
97 {
98         init_user_ctx(&uth->u_ctx, (long)entry, (long)(stack_bottom) + size);
99 }
100
101 #define uthread_set_tls_var(uth, name, val)                                    \
102 ({                                                                             \
103         typeof(val) __val = val;                                                   \
104         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
105         name = __val;                                                              \
106         end_access_tls_vars();                                                     \
107 })
108
109 #define uthread_get_tls_var(uth, name)                                         \
110 ({                                                                             \
111         typeof(name) val;                                                          \
112         begin_access_tls_vars(((struct uthread*)(uth))->tls_desc);                 \
113         val = name;                                                                \
114         end_access_tls_vars();                                                     \
115         val;                                                                       \
116 })
117
118 /* This works so long as we don't dlopen parlib (which we never do) */
119 static inline struct uthread **get_cur_uth_addr(uint32_t vcoreid)
120 {
121         uintptr_t vc_tls_desc = (uintptr_t)get_vcpd_tls_desc(vcoreid);
122         uintptr_t cur_uth_off = (uintptr_t)&current_uthread -
123                                 (uintptr_t)get_tls_desc(vcore_id());
124         return (struct uthread**)(vc_tls_desc + cur_uth_off);
125 }
126
127 #endif /* _UTHREAD_H */