xref: /freebsd/sys/contrib/openzfs/module/os/linux/spl/spl-thread.c (revision f126890ac5386406dadf7c4cfa9566cbb56537c5)
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  * The "why" argument indicates the allowable side-effects of the call:
156  *
157  * FORREAL:  Extract the next pending signal from p_sig into p_cursig;
158  * stop the process if a stop has been requested or if a traced signal
159  * is pending.
160  *
161  * JUSTLOOKING:  Don't stop the process, just indicate whether or not
162  * a signal might be pending (FORREAL is needed to tell for sure).
163  */
164 int
165 issig(int why)
166 {
167 	ASSERT(why == FORREAL || why == JUSTLOOKING);
168 
169 	if (!signal_pending(current))
170 		return (0);
171 
172 	if (why != FORREAL)
173 		return (1);
174 
175 	struct task_struct *task = current;
176 	spl_kernel_siginfo_t __info;
177 	sigset_t set;
178 	siginitsetinv(&set, 1ULL << (SIGSTOP - 1) | 1ULL << (SIGTSTP - 1));
179 	sigorsets(&set, &task->blocked, &set);
180 
181 	spin_lock_irq(&task->sighand->siglock);
182 #ifdef HAVE_DEQUEUE_SIGNAL_4ARG
183 	enum pid_type __type;
184 	if (dequeue_signal(task, &set, &__info, &__type) != 0) {
185 #else
186 	if (dequeue_signal(task, &set, &__info) != 0) {
187 #endif
188 #ifdef HAVE_SIGNAL_STOP
189 		spin_unlock_irq(&task->sighand->siglock);
190 		kernel_signal_stop();
191 #else
192 		if (current->jobctl & JOBCTL_STOP_DEQUEUED)
193 			spl_set_special_state(TASK_STOPPED);
194 
195 		spin_unlock_irq(&current->sighand->siglock);
196 
197 		schedule();
198 #endif
199 		return (0);
200 	}
201 
202 	spin_unlock_irq(&task->sighand->siglock);
203 
204 	return (1);
205 }
206 
207 EXPORT_SYMBOL(issig);
208