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 * 10 * The SPL is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the 12 * Free Software Foundation; either version 2 of the License, or (at your 13 * option) any later version. 14 * 15 * The SPL is distributed in the hope that it will be useful, but WITHOUT 16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 18 * for more details. 19 * 20 * You should have received a copy of the GNU General Public License along 21 * with the SPL. If not, see <http://www.gnu.org/licenses/>. 22 * 23 * Solaris Porting Layer (SPL) Thread Implementation. 24 */ 25 26 #include <sys/thread.h> 27 #include <sys/kmem.h> 28 #include <sys/tsd.h> 29 #include <sys/string.h> 30 31 /* 32 * Thread interfaces 33 */ 34 typedef struct thread_priv_s { 35 unsigned long tp_magic; /* Magic */ 36 int tp_name_size; /* Name size */ 37 char *tp_name; /* Name (without _thread suffix) */ 38 void (*tp_func)(void *); /* Registered function */ 39 void *tp_args; /* Args to be passed to function */ 40 size_t tp_len; /* Len to be passed to function */ 41 int tp_state; /* State to start thread at */ 42 pri_t tp_pri; /* Priority to start threat at */ 43 } thread_priv_t; 44 45 static int 46 thread_generic_wrapper(void *arg) 47 { 48 thread_priv_t *tp = (thread_priv_t *)arg; 49 void (*func)(void *); 50 void *args; 51 52 ASSERT(tp->tp_magic == TP_MAGIC); 53 func = tp->tp_func; 54 args = tp->tp_args; 55 set_current_state(tp->tp_state); 56 set_user_nice((kthread_t *)current, PRIO_TO_NICE(tp->tp_pri)); 57 kmem_free(tp->tp_name, tp->tp_name_size); 58 kmem_free(tp, sizeof (thread_priv_t)); 59 60 if (func) 61 func(args); 62 63 return (0); 64 } 65 66 /* 67 * thread_create() may block forever if it cannot create a thread or 68 * allocate memory. This is preferable to returning a NULL which Solaris 69 * style callers likely never check for... since it can't fail. 70 */ 71 kthread_t * 72 __thread_create(caddr_t stk, size_t stksize, thread_func_t func, 73 const char *name, void *args, size_t len, proc_t *pp, int state, pri_t pri) 74 { 75 thread_priv_t *tp; 76 struct task_struct *tsk; 77 char *p; 78 79 /* Option pp is simply ignored */ 80 /* Variable stack size unsupported */ 81 ASSERT(stk == NULL); 82 83 tp = kmem_alloc(sizeof (thread_priv_t), KM_PUSHPAGE); 84 if (tp == NULL) 85 return (NULL); 86 87 tp->tp_magic = TP_MAGIC; 88 tp->tp_name_size = strlen(name) + 1; 89 90 tp->tp_name = kmem_alloc(tp->tp_name_size, KM_PUSHPAGE); 91 if (tp->tp_name == NULL) { 92 kmem_free(tp, sizeof (thread_priv_t)); 93 return (NULL); 94 } 95 96 strlcpy(tp->tp_name, name, tp->tp_name_size); 97 98 /* 99 * Strip trailing "_thread" from passed name which will be the func 100 * name since the exposed API has no parameter for passing a name. 101 */ 102 p = strstr(tp->tp_name, "_thread"); 103 if (p) 104 p[0] = '\0'; 105 106 tp->tp_func = func; 107 tp->tp_args = args; 108 tp->tp_len = len; 109 tp->tp_state = state; 110 tp->tp_pri = pri; 111 112 tsk = spl_kthread_create(thread_generic_wrapper, (void *)tp, 113 "%s", tp->tp_name); 114 if (IS_ERR(tsk)) 115 return (NULL); 116 117 wake_up_process(tsk); 118 return ((kthread_t *)tsk); 119 } 120 EXPORT_SYMBOL(__thread_create); 121 122 /* 123 * spl_kthread_create - Wrapper providing pre-3.13 semantics for 124 * kthread_create() in which it is not killable and less likely 125 * to return -ENOMEM. 126 */ 127 struct task_struct * 128 spl_kthread_create(int (*func)(void *), void *data, const char namefmt[], ...) 129 { 130 struct task_struct *tsk; 131 va_list args; 132 char name[TASK_COMM_LEN]; 133 134 va_start(args, namefmt); 135 vsnprintf(name, sizeof (name), namefmt, args); 136 va_end(args); 137 do { 138 tsk = kthread_create(func, data, "%s", name); 139 if (IS_ERR(tsk)) { 140 if (signal_pending(current)) { 141 clear_thread_flag(TIF_SIGPENDING); 142 continue; 143 } 144 if (PTR_ERR(tsk) == -ENOMEM) 145 continue; 146 return (NULL); 147 } else { 148 return (tsk); 149 } 150 } while (1); 151 } 152 EXPORT_SYMBOL(spl_kthread_create); 153 154 /* 155 * Extract the next pending signal from p_sig into p_cursig; stop the process 156 * if a stop has been requested or if a traced signal is pending. 157 */ 158 int 159 issig(void) 160 { 161 162 if (!signal_pending(current)) 163 return (0); 164 165 spl_kernel_siginfo_t __info; 166 sigset_t set; 167 siginitsetinv(&set, 1ULL << (SIGSTOP - 1) | 1ULL << (SIGTSTP - 1)); 168 sigorsets(&set, ¤t->blocked, &set); 169 170 spin_lock_irq(¤t->sighand->siglock); 171 #if defined(HAVE_DEQUEUE_SIGNAL_4ARG) 172 enum pid_type __type; 173 if (dequeue_signal(current, &set, &__info, &__type) != 0) { 174 #elif defined(HAVE_DEQUEUE_SIGNAL_3ARG_TYPE) 175 enum pid_type __type; 176 if (dequeue_signal(&set, &__info, &__type) != 0) { 177 #else 178 if (dequeue_signal(current, &set, &__info) != 0) { 179 #endif 180 spin_unlock_irq(¤t->sighand->siglock); 181 kernel_signal_stop(); 182 183 /* 184 * Dequeued SIGSTOP/SIGTSTP. 185 * Check if process has other singal pending. 186 */ 187 if (signal_pending(current)) 188 return (1); 189 190 return (0); 191 } 192 193 spin_unlock_irq(¤t->sighand->siglock); 194 195 return (1); 196 } 197 198 EXPORT_SYMBOL(issig); 199