uspace/lib/c/generic/thread.c

   1 /*
   2  * Copyright (c) 2006 Jakub Jermar
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * - Redistributions of source code must retain the above copyright
  10  *   notice, this list of conditions and the following disclaimer.
  11  * - Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in the
  13  *   documentation and/or other materials provided with the distribution.
  14  * - The name of the author may not be used to endorse or promote products
  15  *   derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /** @addtogroup libc
  30  * @{
  31  */
  32 /** @file
  33  */
  34
  35 #include <thread.h>
  36 #include <libc.h>
  37 #include <stdlib.h>
  38 #include <libarch/faddr.h>
  39 #include <abi/proc/uarg.h>
  40 #include <fibril.h>
  41 #include <stack.h>
  42 #include <str.h>
  43 #include <async.h>
  44 #include <errno.h>
  45 #include <as.h>
  46 #include "private/thread.h"
  47
  48 #ifdef FUTEX_UPGRADABLE
  49 #include <rcu.h>
  50 #endif
  51
  52
  53 /** Main thread function.
  54  *
  55  * This function is called from __thread_entry() and is used
  56  * to call the thread's implementing function and perform cleanup
  57  * and exit when thread returns back.
  58  *
  59  * @param uarg Pointer to userspace argument structure.
  60  *
  61  */
  62 void __thread_main(uspace_arg_t *uarg)
  63 {
  64         fibril_t *fibril = fibril_setup();
  65         if (fibril == NULL)
  66                 thread_exit(0);
  67
  68         __tcb_set(fibril->tcb);
  69
  70 #ifdef FUTEX_UPGRADABLE
  71         rcu_register_fibril();
  72         futex_upgrade_all_and_wait();
  73 #endif
  74
  75         uarg->uspace_thread_function(uarg->uspace_thread_arg);
  76         /*
  77          * XXX: we cannot free the userspace stack while running on it
  78          *
  79          * free(uarg->uspace_stack);
  80          * free(uarg);
  81          */
  82
  83         /* If there is a manager, destroy it */
  84         async_destroy_manager();
  85
  86 #ifdef FUTEX_UPGRADABLE
  87         rcu_deregister_fibril();
  88 #endif
  89
  90         fibril_teardown(fibril, false);
  91
  92         thread_exit(0);
  93 }
  94
  95 /** Create userspace thread.
  96  *
  97  * This function creates new userspace thread and allocates userspace
  98  * stack and userspace argument structure for it.
  99  *
 100  * @param function Function implementing the thread.
 101  * @param arg Argument to be passed to thread.
 102  * @param name Symbolic name of the thread.
 103  * @param tid Thread ID of the newly created thread.
 104  *
 105  * @return Zero on success or a code from @ref errno.h on failure.
 106  */
 107 errno_t thread_create(void (* function)(void *), void *arg, const char *name,
 108     thread_id_t *tid)
 109 {
 110         uspace_arg_t *uarg =
 111             (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
 112         if (!uarg)
 113                 return ENOMEM;
 114
 115         size_t stack_size = stack_size_get();
 116         void *stack = as_area_create(AS_AREA_ANY, stack_size,
 117             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
 118             AS_AREA_LATE_RESERVE, AS_AREA_UNPAGED);
 119         if (stack == AS_MAP_FAILED) {
 120                 free(uarg);
 121                 return ENOMEM;
 122         }
 123
 124         /* Make heap thread safe. */
 125         malloc_enable_multithreaded();
 126
 127         uarg->uspace_entry = (void *) FADDR(__thread_entry);
 128         uarg->uspace_stack = stack;
 129         uarg->uspace_stack_size = stack_size;
 130         uarg->uspace_thread_function = function;
 131         uarg->uspace_thread_arg = arg;
 132         uarg->uspace_uarg = uarg;
 133
 134         errno_t rc = (errno_t) __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
 135             (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
 136
 137         if (rc != EOK) {
 138                 /*
 139                  * Failed to create a new thread.
 140                  * Free up the allocated data.
 141                  */
 142                 as_area_destroy(stack);
 143                 free(uarg);
 144         }
 145
 146         return rc;
 147 }
 148
 149 /** Terminate current thread.
 150  *
 151  * @param status Exit status. Currently not used.
 152  *
 153  */
 154 void thread_exit(int status)
 155 {
 156         __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status);
 157
 158         /* Unreachable */
 159         while (1);
 160 }
 161
 162 /** Detach thread.
 163  *
 164  * Currently not implemented.
 165  *
 166  * @param thread TID.
 167  */
 168 void thread_detach(thread_id_t thread)
 169 {
 170 }
 171
 172 /** Join thread.
 173  *
 174  * Currently not implemented.
 175  *
 176  * @param thread TID.
 177  *
 178  * @return Thread exit status.
 179  */
 180 errno_t thread_join(thread_id_t thread)
 181 {
 182         return 0;
 183 }
 184
 185 /** Get current thread ID.
 186  *
 187  * @return Current thread ID.
 188  */
 189 thread_id_t thread_get_id(void)
 190 {
 191         thread_id_t thread_id;
 192
 193         (void) __SYSCALL1(SYS_THREAD_GET_ID, (sysarg_t) &thread_id);
 194
 195         return thread_id;
 196 }
 197
 198 /** Wait unconditionally for specified number of microseconds
 199  *
 200  */
 201 int thread_usleep(useconds_t usec)
 202 {
 203         (void) __SYSCALL1(SYS_THREAD_USLEEP, usec);
 204         return 0;
 205 }
 206
 207 /** Wait unconditionally for specified number of seconds
 208  *
 209  */
 210 unsigned int thread_sleep(unsigned int sec)
 211 {
 212         /*
 213          * Sleep in 1000 second steps to support
 214          * full argument range
 215          */
 216
 217         while (sec > 0) {
 218                 unsigned int period = (sec > 1000) ? 1000 : sec;
 219
 220                 thread_usleep(period * 1000000);
 221                 sec -= period;
 222         }
 223
 224         return 0;
 225 }
 226
 227 /** @}
 228  */