Tracks state properly for paused uthreads
[akaros.git] / user / parlib / include / uthread.h
index acc8ad4..fcfe42e 100644 (file)
@@ -5,14 +5,16 @@
 #include <ros/syscall.h>
 
 #define UTHREAD_DONT_MIGRATE           0x001 /* don't move to another vcore */
-#define UTHREAD_DYING                          0x002 /* uthread is exiting */
+#define UTHREAD_SAVED                          0x002 /* uthread's state is in utf */
+#define UTHREAD_FPSAVED                                0x004 /* uthread's FP state is in uth->as */
 
 /* Thread States */
-#define UT_CREATED     1
-#define UT_RUNNABLE    2
-#define UT_RUNNING     3
-#define UT_BLOCKED     4
-#define UT_DYING       5
+#define UT_RUNNING             1
+#define UT_NOT_RUNNING 2
+
+/* Externally blocked thread reasons (for uthread_has_blocked()) */
+#define UTH_EXT_BLK_MUTEX                      1
+#define UTH_EXT_BLK_JUSTICE                    2       /* whatever.  might need more options */
 
 /* Bare necessities of a user thread.  2LSs should allocate a bigger struct and
  * cast their threads to uthreads when talking with vcore code.  Vcore/default
@@ -24,44 +26,80 @@ struct uthread {
        int flags;
        struct syscall *sysc;   /* syscall we're blocking on, if any */
        int state;
+       void (*yield_func)(struct uthread*, void*);
+       void *yield_arg;
 };
+typedef struct uthread uthread_t;
 extern __thread struct uthread *current_uthread;
 
 /* 2L-Scheduler operations.  Can be 0.  Examples in pthread.c. */
 struct schedule_ops {
        /* Functions supporting thread ops */
-       struct uthread *(*sched_init)(void);
        void (*sched_entry)(void);
-       struct uthread *(*thread_create)(void (*func)(void), void *);
        void (*thread_runnable)(struct uthread *);
-       void (*thread_yield)(struct uthread *);
-       void (*thread_exit)(struct uthread *);
-       void (*thread_blockon_sysc)(struct syscall *);
+       void (*thread_paused)(struct uthread *);
+       void (*thread_blockon_sysc)(struct uthread *, void *);
+       void (*thread_has_blocked)(struct uthread *, int);
        /* Functions event handling wants */
        void (*preempt_pending)(void);
        void (*spawn_thread)(uintptr_t pc_start, void *data);   /* don't run yet */
 };
 extern struct schedule_ops *sched_ops;
 
+/* Call this, passing it a uthread representing thread0, from your 2LS init
+ * routines.  When it returns, you're in _M mode (thread0 on vcore0) */
+int uthread_lib_init(struct uthread *uthread);
+
 /* Functions to make/manage uthreads.  Can be called by functions such as
  * pthread_create(), which can wrap these with their own stuff (like attrs,
  * retvals, etc). */
 
-/* Creates a uthread.  Will pass udata to sched_ops's thread_create.  Func is
- * what gets run, and if you want args, wrap it (like pthread) */
-struct uthread *uthread_create(void (*func)(void), void *udata);
+/* Does the uthread initialization of a uthread that the caller created.  Call
+ * this whenever you are "starting over" with a thread. */
+void uthread_init(struct uthread *new_thread);
+/* Low-level _S code calls this for basic uthreading without a 2LS */
+void uthread_slim_init(void);
+/* Call this when you are done with a uthread, forever, but before you free it */
+void uthread_cleanup(struct uthread *uthread);
 void uthread_runnable(struct uthread *uthread);
-void uthread_yield(void);
-void uthread_exit(void);
-/* Block the calling uthread on sysc until it makes progress or is done */
-void ros_syscall_blockon(struct syscall *sysc);
+void uthread_yield(bool save_state, void (*yield_func)(struct uthread*, void*),
+                   void *yield_arg);
+
+/* Utility functions */
+bool __check_preempt_pending(uint32_t vcoreid);        /* careful: check the code */
+void uth_disable_notifs(void);
+void uth_enable_notifs(void);
 
-/* Utility function.  Event code also calls this. */
-bool check_preempt_pending(uint32_t vcoreid);
 bool register_evq(struct syscall *sysc, struct event_queue *ev_q);
+void deregister_evq(struct syscall *sysc);
 
 /* Helpers, which sched_entry() can call */
+void highjack_current_uthread(struct uthread *uthread);
 void run_current_uthread(void);
 void run_uthread(struct uthread *uthread);
 
+static inline void
+init_uthread_tf(uthread_t *uth, void (*entry)(void),
+                void *stack_bottom, uint32_t size)
+{
+  init_user_tf(&uth->utf, (long)entry, (long)(stack_bottom));
+}
+
+#define uthread_set_tls_var(uthread, name, val)                          \
+{                                                                        \
+      typeof(val) __val = val;                                           \
+      begin_access_tls_vars(((uthread_t*)(uthread))->tls_desc);          \
+      name = __val;                                                      \
+      end_access_tls_vars();                                             \
+}
+
+#define uthread_get_tls_var(uthread, name)                               \
+({                                                                       \
+      typeof(name) val;                                                  \
+      begin_access_tls_vars(((uthread_t*)(uthread))->tls_desc);          \
+      val = name;                                                        \
+      end_access_tls_vars();                                             \
+      val;                                                               \
+})
+
 #endif /* _UTHREAD_H */