git.barrelfish.org Git - barrelfish/blob - include/barrelfish/threads.h

   1 /**
   2  * \file
   3  * \brief Threads.
   4  */
   5
   6 /*
   7  * Copyright (c) 2007, 2008, 2009, 2010, 2011, ETH Zurich.
   8  * All rights reserved.
   9  *
  10  * This file is distributed under the terms in the attached LICENSE file.
  11  * If you do not find this file, copies can be found by writing to:
  12  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
  13  */
  14
  15 #ifndef LIBBARRELFISH_THREADS_H
  16 #define LIBBARRELFISH_THREADS_H
  17
  18 #include <assert.h>
  19 #include <sys/cdefs.h>
  20
  21 #include <barrelfish/caddr.h> // for struct capref.
  22 #include <barrelfish/thread_sync.h>
  23 #include <barrelfish_kpi/registers_arch.h>
  24 #include <barrelfish_kpi/dispatcher_handle.h>
  25 #include <errors/errno.h>
  26 #include <barrelfish/waitset.h>
  27
  28 __BEGIN_DECLS
  29
  30 typedef int (*thread_func_t)(void *);
  31
  32 /// Default size of a thread's stack
  33 #define THREADS_DEFAULT_STACK_BYTES     (64 * 1024)
  34
  35 struct thread *thread_create(thread_func_t start_func, void *data);
  36 struct thread *thread_create_varstack(thread_func_t start_func, void *arg,
  37                                       size_t stacksize);
  38 void thread_yield(void);
  39 void thread_yield_dispatcher(struct capref endpoint);
  40 void thread_exit(int status);
  41 struct thread *thread_self(void);
  42 struct thread *thread_self_disabled(void);
  43 errval_t thread_join(struct thread *thread, int *retval);
  44 errval_t thread_detach(struct thread *thread);
  45
  46 void thread_pause(struct thread *thread);
  47 void thread_pause_and_capture_state(struct thread *thread,
  48                                     arch_registers_state_t **ret_regs,
  49                                     arch_registers_fpu_state_t **ret_fpuregs);
  50 void thread_resume(struct thread *thread);
  51
  52 void thread_mutex_init(struct thread_mutex *mutex);
  53 void thread_mutex_lock(struct thread_mutex *mutex);
  54 bool thread_mutex_trylock(struct thread_mutex *mutex);
  55 void thread_mutex_lock_nested(struct thread_mutex *mutex);
  56 void thread_mutex_unlock(struct thread_mutex *mutex);
  57 struct thread *thread_mutex_unlock_disabled(dispatcher_handle_t handle,
  58                                             struct thread_mutex *mutex);
  59
  60 void thread_cond_init(struct thread_cond *cond);
  61 void thread_cond_signal(struct thread_cond *cond);
  62 void thread_cond_broadcast(struct thread_cond *cond);
  63 void thread_cond_wait(struct thread_cond *cond, struct thread_mutex *mutex);
  64
  65 void thread_sem_init(struct thread_sem *sem, unsigned int value);
  66 void thread_sem_wait(struct thread_sem *sem);
  67 bool thread_sem_trywait(struct thread_sem *sem);
  68 void thread_sem_post(struct thread_sem *sem);
  69
  70 void thread_set_tls(void *);
  71 void *thread_get_tls(void);
  72
  73 void thread_set_tls_key(int, void *);
  74 void *thread_get_tls_key(int);
  75
  76 uintptr_t thread_id(void);
  77 uintptr_t thread_get_id(struct thread *t);
  78 void thread_set_id(uintptr_t id);
  79
  80 uint32_t thread_set_token(struct waitset_chanstate *channel);
  81 void thread_clear_token(struct waitset_chanstate *channel);
  82 uint32_t thread_current_token(void);
  83
  84 void thread_set_outgoing_token(uint32_t token);
  85 void thread_get_outgoing_token(uint32_t *token);
  86
  87 struct flounder_rpc_context;
  88
  89 void thread_set_rpc_in_progress(bool v);
  90 bool thread_get_rpc_in_progress(void);
  91 void thread_set_async_error(errval_t e);
  92 errval_t thread_get_async_error(void);
  93
  94 extern __thread thread_once_t thread_once_local_epoch;
  95 extern void thread_once_internal(thread_once_t *control, void (*func)(void));
  96
  97 /**
  98  * \brief Run a routine exactly once; use this for thread-safe initialization.
  99  *
 100  * \param control Control word - should be initialized with THREAD_ONCE_INIT.
 101  * \param func Callback to be invoked.
 102  */
 103 static inline void thread_once(thread_once_t *control, void (*func)(void)) {
 104     assert(control != NULL);
 105     assert(func != NULL);
 106     thread_once_t x = *control; // unprotected access
 107     if (x > thread_once_local_epoch) {
 108         thread_once_internal(control, func);
 109     }
 110 }
 111
 112 __END_DECLS
 113
 114 #endif  // LIBBARRELFISH_THREADS_H