module/spl/spl-thread.c

   1 /*****************************************************************************\
   2  *  Copyright (C) 2007-2010 Lawrence Livermore National Security, LLC.
   3  *  Copyright (C) 2007 The Regents of the University of California.
   4  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
   5  *  Written by Brian Behlendorf <behlendorf1@llnl.gov>.
   6  *  UCRL-CODE-235197
   7  *
   8  *  This file is part of the SPL, Solaris Porting Layer.
   9  *  For details, see <http://github.com/behlendorf/spl/>.
  10  *
  11  *  The SPL is free software; you can redistribute it and/or modify it
  12  *  under the terms of the GNU General Public License as published by the
  13  *  Free Software Foundation; either version 2 of the License, or (at your
  14  *  option) any later version.
  15  *
  16  *  The SPL is distributed in the hope that it will be useful, but WITHOUT
  17  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19  *  for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with the SPL.  If not, see <http://www.gnu.org/licenses/>.
  23  *****************************************************************************
  24  *  Solaris Porting Layer (SPL) Thread Implementation.
  25 \*****************************************************************************/
  26
  27 #include <sys/thread.h>
  28 #include <sys/kmem.h>
  29 #include <sys/tsd.h>
  30 #include <spl-debug.h>
  31
  32 #ifdef SS_DEBUG_SUBSYS
  33 #undef SS_DEBUG_SUBSYS
  34 #endif
  35
  36 #define SS_DEBUG_SUBSYS SS_THREAD
  37
  38 /*
  39  * Thread interfaces
  40  */
  41 typedef struct thread_priv_s {
  42         unsigned long tp_magic;         /* Magic */
  43         int tp_name_size;               /* Name size */
  44         char *tp_name;                  /* Name (without _thread suffix) */
  45         void (*tp_func)(void *);        /* Registered function */
  46         void *tp_args;                  /* Args to be passed to function */
  47         size_t tp_len;                  /* Len to be passed to function */
  48         int tp_state;                   /* State to start thread at */
  49         pri_t tp_pri;                   /* Priority to start threat at */
  50 } thread_priv_t;
  51
  52 static int
  53 thread_generic_wrapper(void *arg)
  54 {
  55         thread_priv_t *tp = (thread_priv_t *)arg;
  56         void (*func)(void *);
  57         void *args;
  58
  59         ASSERT(tp->tp_magic == TP_MAGIC);
  60         func = tp->tp_func;
  61         args = tp->tp_args;
  62         set_current_state(tp->tp_state);
  63         set_user_nice((kthread_t *)current, PRIO_TO_NICE(tp->tp_pri));
  64         kmem_free(tp->tp_name, tp->tp_name_size);
  65         kmem_free(tp, sizeof(thread_priv_t));
  66
  67         if (func)
  68                 func(args);
  69
  70         return 0;
  71 }
  72
  73 void
  74 __thread_exit(void)
  75 {
  76         SENTRY;
  77         SEXIT;
  78         tsd_exit();
  79         complete_and_exit(NULL, 0);
  80         /* Unreachable */
  81 }
  82 EXPORT_SYMBOL(__thread_exit);
  83
  84 /* thread_create() may block forever if it cannot create a thread or
  85  * allocate memory.  This is preferable to returning a NULL which Solaris
  86  * style callers likely never check for... since it can't fail. */
  87 kthread_t *
  88 __thread_create(caddr_t stk, size_t  stksize, thread_func_t func,
  89                 const char *name, void *args, size_t len, proc_t *pp,
  90                 int state, pri_t pri)
  91 {
  92         thread_priv_t *tp;
  93         struct task_struct *tsk;
  94         char *p;
  95         SENTRY;
  96
  97         /* Option pp is simply ignored */
  98         /* Variable stack size unsupported */
  99         ASSERT(stk == NULL);
 100
 101         tp = kmem_alloc(sizeof(thread_priv_t), KM_PUSHPAGE);
 102         if (tp == NULL)
 103                 SRETURN(NULL);
 104
 105         tp->tp_magic = TP_MAGIC;
 106         tp->tp_name_size = strlen(name) + 1;
 107
 108         tp->tp_name = kmem_alloc(tp->tp_name_size, KM_PUSHPAGE);
 109         if (tp->tp_name == NULL) {
 110                 kmem_free(tp, sizeof(thread_priv_t));
 111                 SRETURN(NULL);
 112         }
 113
 114         strncpy(tp->tp_name, name, tp->tp_name_size);
 115
 116         /* Strip trailing "_thread" from passed name which will be the func
 117          * name since the exposed API has no parameter for passing a name.
 118          */
 119         p = strstr(tp->tp_name, "_thread");
 120         if (p)
 121                 p[0] = '\0';
 122
 123         tp->tp_func  = func;
 124         tp->tp_args  = args;
 125         tp->tp_len   = len;
 126         tp->tp_state = state;
 127         tp->tp_pri   = pri;
 128
 129         tsk = kthread_create(thread_generic_wrapper, (void *)tp,
 130                              "%s", tp->tp_name);
 131         if (IS_ERR(tsk)) {
 132                 SERROR("Failed to create thread: %ld\n", PTR_ERR(tsk));
 133                 SRETURN(NULL);
 134         }
 135
 136         wake_up_process(tsk);
 137         SRETURN((kthread_t *)tsk);
 138 }
 139 EXPORT_SYMBOL(__thread_create);