Added calls neessary to get lithe running on ROS
[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_CREATED      1
13 #define UT_RUNNABLE     2
14 #define UT_RUNNING      3
15 #define UT_BLOCKED      4
16 #define UT_DYING        5
17
18 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
19  * cast their threads to uthreads when talking with vcore code.  Vcore/default
20  * 2LS code won't touch udata or beyond. */
21 struct uthread {
22         struct user_trapframe utf;
23         struct ancillary_state as;
24         void *tls_desc;
25         int flags;
26         struct syscall *sysc;   /* syscall we're blocking on, if any */
27         int state;
28 };
29 typedef struct uthread uthread_t;
30 extern __thread struct uthread *current_uthread;
31
32 /* 2L-Scheduler operations.  Can be 0.  Examples in pthread.c. */
33 struct schedule_ops {
34         /* Functions supporting thread ops */
35         void (*sched_entry)(void);
36         void (*thread_runnable)(struct uthread *);
37         void (*thread_yield)(struct uthread *);
38         void (*thread_paused)(struct uthread *);
39         void (*thread_blockon_sysc)(struct syscall *);
40         /* Functions event handling wants */
41         void (*preempt_pending)(void);
42         void (*spawn_thread)(uintptr_t pc_start, void *data);   /* don't run yet */
43 };
44 extern struct schedule_ops *sched_ops;
45
46 /* Call this, passing it a uthread representing thread0, from your 2LS init
47  * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
48 int uthread_lib_init(struct uthread *uthread);
49
50 /* Functions to make/manage uthreads.  Can be called by functions such as
51  * pthread_create(), which can wrap these with their own stuff (like attrs,
52  * retvals, etc). */
53
54 /* Does the uthread initialization of a uthread that the caller created.  Call
55  * this whenever you are "starting over" with a thread. */
56 void uthread_init(struct uthread *new_thread);
57 /* Low-level _S code calls this for basic uthreading without a 2LS */
58 void uthread_slim_init(void);
59 /* Call this when you are done with a uthread, forever, but before you free it */
60 void uthread_cleanup(struct uthread *uthread);
61 void uthread_runnable(struct uthread *uthread);
62 void uthread_yield(bool save_state);
63
64 /* Utility functions */
65 bool __check_preempt_pending(uint32_t vcoreid); /* careful: check the code */
66 void uth_disable_notifs(void);
67 void uth_enable_notifs(void);
68 void copyout_uthread(struct preempt_data *vcpd, struct uthread *uthread);
69
70 bool register_evq(struct syscall *sysc, struct event_queue *ev_q);
71 void deregister_evq(struct syscall *sysc);
72
73 /* Helpers, which sched_entry() can call */
74 void highjack_current_uthread(struct uthread *uthread);
75 void run_current_uthread(void);
76 void run_uthread(struct uthread *uthread);
77
78 static inline void
79 init_uthread_tf(uthread_t *uth, void (*entry)(void),
80                 void *stack_bottom, uint32_t size)
81 {
82   init_user_tf(&uth->utf, (long)entry, (long)(stack_bottom));
83 }
84
85 #define uthread_set_tls_var(uthread, name, val)                          \
86 {                                                                        \
87       typeof(val) __val = val;                                           \
88       begin_access_tls_vars(((uthread_t*)(uthread))->tls_desc);          \
89       name = __val;                                                      \
90       end_access_tls_vars();                                             \
91 }
92
93 #define uthread_get_tls_var(uthread, name)                               \
94 ({                                                                       \
95       typeof(name) val;                                                  \
96       begin_access_tls_vars(((uthread_t*)(uthread))->tls_desc);          \
97       val = name;                                                        \
98       end_access_tls_vars();                                             \
99       val;                                                               \
100 })
101
102 #endif /* _UTHREAD_H */