Subversion Repositories HelenOS

Rev

Rev 2568 | Rev 4256 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  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 <kernel/proc/uarg.h>
  40. #include <fibril.h>
  41. #include <string.h>
  42. #include <async.h>
  43.  
  44. #ifndef THREAD_INITIAL_STACK_PAGES_NO
  45. #define THREAD_INITIAL_STACK_PAGES_NO 1
  46. #endif
  47.  
  48. /** Main thread function.
  49.  *
  50.  * This function is called from __thread_entry() and is used
  51.  * to call the thread's implementing function and perform cleanup
  52.  * and exit when thread returns back. Do not call this function
  53.  * directly.
  54.  *
  55.  * @param uarg Pointer to userspace argument structure.
  56.  */
  57. void __thread_main(uspace_arg_t *uarg)
  58. {
  59.     fibril_t *f;
  60.  
  61.     f = fibril_setup();
  62.     __tcb_set(f->tcb);
  63.  
  64.     uarg->uspace_thread_function(uarg->uspace_thread_arg);
  65.     /* XXX: we cannot free the userspace stack while running on it */
  66. //  free(uarg->uspace_stack);
  67. //  free(uarg);
  68.  
  69.     /* If there is a manager, destroy it */
  70.     async_destroy_manager();
  71.     fibril_teardown(f);
  72.  
  73.     thread_exit(0);
  74. }
  75.  
  76. /** Create userspace thread.
  77.  *
  78.  * This function creates new userspace thread and allocates userspace
  79.  * stack and userspace argument structure for it.
  80.  *
  81.  * @param function Function implementing the thread.
  82.  * @param arg Argument to be passed to thread.
  83.  * @param name Symbolic name of the thread.
  84.  * @param tid Thread ID of the newly created thread.
  85.  *
  86.  * @return Zero on success or a code from @ref errno.h on failure.
  87.  */
  88. int thread_create(void (* function)(void *), void *arg, char *name,
  89.     thread_id_t *tid)
  90. {
  91.     char *stack;
  92.     uspace_arg_t *uarg;
  93.     int rc;
  94.  
  95.     stack = (char *) malloc(getpagesize() * THREAD_INITIAL_STACK_PAGES_NO);
  96.     if (!stack)
  97.         return -1;
  98.        
  99.     uarg = (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
  100.     if (!uarg) {
  101.         free(stack);
  102.         return -1;
  103.     }
  104.    
  105.     uarg->uspace_entry = (void *) FADDR(__thread_entry);
  106.     uarg->uspace_stack = (void *) stack;
  107.     uarg->uspace_thread_function = function;
  108.     uarg->uspace_thread_arg = arg;
  109.     uarg->uspace_uarg = uarg;
  110.    
  111.     rc = __SYSCALL3(SYS_THREAD_CREATE, (sysarg_t) uarg, (sysarg_t) name,
  112.         (sysarg_t) tid);
  113.    
  114.     if (rc) {
  115.         /*
  116.          * Failed to create a new thread.
  117.          * Free up the allocated structures.
  118.          */
  119.         free(uarg);
  120.         free(stack);
  121.     }
  122.  
  123.     return rc;
  124. }
  125.  
  126. /** Terminate current thread.
  127.  *
  128.  * @param status Exit status. Currently not used.
  129.  */
  130. void thread_exit(int status)
  131. {
  132.     __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status);
  133. }
  134.  
  135. /** Detach thread.
  136.  *
  137.  * Currently not implemented.
  138.  *
  139.  * @param thread TID.
  140.  */
  141. void thread_detach(thread_id_t thread)
  142. {
  143. }
  144.  
  145. /** Join thread.
  146.  *
  147.  * Currently not implemented.
  148.  *
  149.  * @param thread TID.
  150.  *
  151.  * @return Thread exit status.
  152.  */
  153. int thread_join(thread_id_t thread)
  154. {
  155. }
  156.  
  157. /** Get current thread ID.
  158.  *
  159.  * @return Current thread ID.
  160.  */
  161. thread_id_t thread_get_id(void)
  162. {
  163.     thread_id_t thread_id;
  164.  
  165.     (void) __SYSCALL1(SYS_THREAD_GET_ID, (sysarg_t) &thread_id);
  166.  
  167.     return thread_id;
  168. }
  169.  
  170. /** @}
  171.  */
  172.