xref: /freebsd/sys/kern/kern_thr.c (revision 6161b98c9935eb5f5d2a64b6feaecc8affd6fe29)
19454b2d8SWarner Losh /*-
28a36da99SPedro F. Giffuni  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
38a36da99SPedro F. Giffuni  *
489bb1cefSJeff Roberson  * Copyright (c) 2003, Jeffrey Roberson <jeff@freebsd.org>
589bb1cefSJeff Roberson  * All rights reserved.
689bb1cefSJeff Roberson  *
789bb1cefSJeff Roberson  * Redistribution and use in source and binary forms, with or without
889bb1cefSJeff Roberson  * modification, are permitted provided that the following conditions
989bb1cefSJeff Roberson  * are met:
1089bb1cefSJeff Roberson  * 1. Redistributions of source code must retain the above copyright
1189bb1cefSJeff Roberson  *    notice unmodified, this list of conditions, and the following
1289bb1cefSJeff Roberson  *    disclaimer.
1389bb1cefSJeff Roberson  * 2. Redistributions in binary form must reproduce the above copyright
1489bb1cefSJeff Roberson  *    notice, this list of conditions and the following disclaimer in the
1589bb1cefSJeff Roberson  *    documentation and/or other materials provided with the distribution.
1689bb1cefSJeff Roberson  *
1789bb1cefSJeff Roberson  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
1889bb1cefSJeff Roberson  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
1989bb1cefSJeff Roberson  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
2089bb1cefSJeff Roberson  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
2189bb1cefSJeff Roberson  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
2289bb1cefSJeff Roberson  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
2389bb1cefSJeff Roberson  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
2489bb1cefSJeff Roberson  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
2589bb1cefSJeff Roberson  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2689bb1cefSJeff Roberson  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2789bb1cefSJeff Roberson  */
2889bb1cefSJeff Roberson 
29677b542eSDavid E. O'Brien #include <sys/cdefs.h>
30677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
31677b542eSDavid E. O'Brien 
3260088160SDavid Xu #include "opt_posix.h"
33*6161b98cSMatt Macy #include "opt_hwpmc_hooks.h"
3489bb1cefSJeff Roberson #include <sys/param.h>
3589bb1cefSJeff Roberson #include <sys/kernel.h>
3689bb1cefSJeff Roberson #include <sys/lock.h>
3789bb1cefSJeff Roberson #include <sys/mutex.h>
38acd3428bSRobert Watson #include <sys/priv.h>
3989bb1cefSJeff Roberson #include <sys/proc.h>
40c4f7f0fdSTom Rhodes #include <sys/posix4.h>
418d570f64SJohn Baldwin #include <sys/ptrace.h>
4258c77a9dSEdward Tomasz Napierala #include <sys/racct.h>
4389bb1cefSJeff Roberson #include <sys/resourcevar.h>
440d036d55SDavid Xu #include <sys/rwlock.h>
45a22ec9d8SJeff Roberson #include <sys/sched.h>
46a8b491c1SJulian Elischer #include <sys/sysctl.h>
47ed062c8dSJulian Elischer #include <sys/smp.h>
48a66fde8dSJohn Baldwin #include <sys/syscallsubr.h>
4989bb1cefSJeff Roberson #include <sys/sysent.h>
5089bb1cefSJeff Roberson #include <sys/systm.h>
5189bb1cefSJeff Roberson #include <sys/sysproto.h>
5289bb1cefSJeff Roberson #include <sys/signalvar.h>
5325a9cfc9SKonstantin Belousov #include <sys/sysctl.h>
5489bb1cefSJeff Roberson #include <sys/ucontext.h>
5589bb1cefSJeff Roberson #include <sys/thr.h>
56a0712c99SDavid Xu #include <sys/rtprio.h>
574938faa6SDavid Xu #include <sys/umtx.h>
584938faa6SDavid Xu #include <sys/limits.h>
59*6161b98cSMatt Macy #ifdef	HWPMC_HOOKS
60*6161b98cSMatt Macy #include <sys/pmckern.h>
61*6161b98cSMatt Macy #endif
6289bb1cefSJeff Roberson 
6389bb1cefSJeff Roberson #include <machine/frame.h>
6489bb1cefSJeff Roberson 
650b1f0611SDavid Xu #include <security/audit/audit.h>
660b1f0611SDavid Xu 
676472ac3dSEd Schouten static SYSCTL_NODE(_kern, OID_AUTO, threads, CTLFLAG_RW, 0,
686472ac3dSEd Schouten     "thread allocation");
6925a9cfc9SKonstantin Belousov 
7025a9cfc9SKonstantin Belousov static int max_threads_per_proc = 1500;
7125a9cfc9SKonstantin Belousov SYSCTL_INT(_kern_threads, OID_AUTO, max_threads_per_proc, CTLFLAG_RW,
7225a9cfc9SKonstantin Belousov     &max_threads_per_proc, 0, "Limit on threads per proc");
7325a9cfc9SKonstantin Belousov 
7425a9cfc9SKonstantin Belousov static int max_threads_hits;
7525a9cfc9SKonstantin Belousov SYSCTL_INT(_kern_threads, OID_AUTO, max_threads_hits, CTLFLAG_RD,
763eb9ab52SEitan Adler     &max_threads_hits, 0, "kern.threads.max_threads_per_proc hit count");
7725a9cfc9SKonstantin Belousov 
78841c0c7eSNathan Whitehorn #ifdef COMPAT_FREEBSD32
79cda9a0d1SDavid Xu 
80cda9a0d1SDavid Xu static inline int
81cda9a0d1SDavid Xu suword_lwpid(void *addr, lwpid_t lwpid)
82cda9a0d1SDavid Xu {
83cda9a0d1SDavid Xu 	int error;
84cda9a0d1SDavid Xu 
85b4cf0e62SKonstantin Belousov 	if (SV_CURPROC_FLAG(SV_LP64))
86cda9a0d1SDavid Xu 		error = suword(addr, lwpid);
87cda9a0d1SDavid Xu 	else
88cda9a0d1SDavid Xu 		error = suword32(addr, lwpid);
89cda9a0d1SDavid Xu 	return (error);
90cda9a0d1SDavid Xu }
91cda9a0d1SDavid Xu 
92cda9a0d1SDavid Xu #else
93cda9a0d1SDavid Xu #define suword_lwpid	suword
94cda9a0d1SDavid Xu #endif
95cda9a0d1SDavid Xu 
9689bb1cefSJeff Roberson /*
9789bb1cefSJeff Roberson  * System call interface.
9889bb1cefSJeff Roberson  */
995a170c1bSEd Schouten 
1005a170c1bSEd Schouten struct thr_create_initthr_args {
1015a170c1bSEd Schouten 	ucontext_t ctx;
1025a170c1bSEd Schouten 	long *tid;
1035a170c1bSEd Schouten };
1045a170c1bSEd Schouten 
1055a170c1bSEd Schouten static int
1065a170c1bSEd Schouten thr_create_initthr(struct thread *td, void *thunk)
1075a170c1bSEd Schouten {
1085a170c1bSEd Schouten 	struct thr_create_initthr_args *args;
1095a170c1bSEd Schouten 
1105a170c1bSEd Schouten 	/* Copy out the child tid. */
1115a170c1bSEd Schouten 	args = thunk;
1125a170c1bSEd Schouten 	if (args->tid != NULL && suword_lwpid(args->tid, td->td_tid))
1135a170c1bSEd Schouten 		return (EFAULT);
1145a170c1bSEd Schouten 
1155a170c1bSEd Schouten 	return (set_mcontext(td, &args->ctx.uc_mcontext));
1165a170c1bSEd Schouten }
1175a170c1bSEd Schouten 
11889bb1cefSJeff Roberson int
1198451d0ddSKip Macy sys_thr_create(struct thread *td, struct thr_create_args *uap)
120cd28f17dSMarcel Moolenaar     /* ucontext_t *ctx, long *id, int flags */
12189bb1cefSJeff Roberson {
1225a170c1bSEd Schouten 	struct thr_create_initthr_args args;
12389bb1cefSJeff Roberson 	int error;
12489bb1cefSJeff Roberson 
1255a170c1bSEd Schouten 	if ((error = copyin(uap->ctx, &args.ctx, sizeof(args.ctx))))
12689bb1cefSJeff Roberson 		return (error);
1275a170c1bSEd Schouten 	args.tid = uap->id;
1285a170c1bSEd Schouten 	return (thread_create(td, NULL, thr_create_initthr, &args));
129c4bd610fSDavid Xu }
130c4bd610fSDavid Xu 
131c4bd610fSDavid Xu int
1328451d0ddSKip Macy sys_thr_new(struct thread *td, struct thr_new_args *uap)
133c4bd610fSDavid Xu     /* struct thr_param * */
134c4bd610fSDavid Xu {
135c4bd610fSDavid Xu 	struct thr_param param;
136cda9a0d1SDavid Xu 	int error;
137cda9a0d1SDavid Xu 
138cda9a0d1SDavid Xu 	if (uap->param_size < 0 || uap->param_size > sizeof(param))
139cda9a0d1SDavid Xu 		return (EINVAL);
140cda9a0d1SDavid Xu 	bzero(&param, sizeof(param));
141cda9a0d1SDavid Xu 	if ((error = copyin(uap->param, &param, uap->param_size)))
142cda9a0d1SDavid Xu 		return (error);
143cda9a0d1SDavid Xu 	return (kern_thr_new(td, &param));
144cda9a0d1SDavid Xu }
145cda9a0d1SDavid Xu 
1465a170c1bSEd Schouten static int
1475a170c1bSEd Schouten thr_new_initthr(struct thread *td, void *thunk)
1485a170c1bSEd Schouten {
1495a170c1bSEd Schouten 	stack_t stack;
1505a170c1bSEd Schouten 	struct thr_param *param;
1515a170c1bSEd Schouten 
1525a170c1bSEd Schouten 	/*
1535a170c1bSEd Schouten 	 * Here we copy out tid to two places, one for child and one
1545a170c1bSEd Schouten 	 * for parent, because pthread can create a detached thread,
1555a170c1bSEd Schouten 	 * if parent wants to safely access child tid, it has to provide
1565a170c1bSEd Schouten 	 * its storage, because child thread may exit quickly and
1575a170c1bSEd Schouten 	 * memory is freed before parent thread can access it.
1585a170c1bSEd Schouten 	 */
1595a170c1bSEd Schouten 	param = thunk;
1605a170c1bSEd Schouten 	if ((param->child_tid != NULL &&
1615a170c1bSEd Schouten 	    suword_lwpid(param->child_tid, td->td_tid)) ||
1625a170c1bSEd Schouten 	    (param->parent_tid != NULL &&
1635a170c1bSEd Schouten 	    suword_lwpid(param->parent_tid, td->td_tid)))
1645a170c1bSEd Schouten 		return (EFAULT);
1655a170c1bSEd Schouten 
1665a170c1bSEd Schouten 	/* Set up our machine context. */
1675a170c1bSEd Schouten 	stack.ss_sp = param->stack_base;
1685a170c1bSEd Schouten 	stack.ss_size = param->stack_size;
1695a170c1bSEd Schouten 	/* Set upcall address to user thread entry function. */
1705c2cf818SKonstantin Belousov 	cpu_set_upcall(td, param->start_func, param->arg, &stack);
1715a170c1bSEd Schouten 	/* Setup user TLS address and TLS pointer register. */
1725a170c1bSEd Schouten 	return (cpu_set_user_tls(td, param->tls_base));
1735a170c1bSEd Schouten }
1745a170c1bSEd Schouten 
175cda9a0d1SDavid Xu int
176cda9a0d1SDavid Xu kern_thr_new(struct thread *td, struct thr_param *param)
177cda9a0d1SDavid Xu {
17873fa3e5bSDavid Xu 	struct rtprio rtp, *rtpp;
179c4bd610fSDavid Xu 	int error;
180c4bd610fSDavid Xu 
18173fa3e5bSDavid Xu 	rtpp = NULL;
182cda9a0d1SDavid Xu 	if (param->rtp != 0) {
183cda9a0d1SDavid Xu 		error = copyin(param->rtp, &rtp, sizeof(struct rtprio));
184e4866772SRoman Divacky 		if (error)
185e4866772SRoman Divacky 			return (error);
18673fa3e5bSDavid Xu 		rtpp = &rtp;
187a0712c99SDavid Xu 	}
1885a170c1bSEd Schouten 	return (thread_create(td, rtpp, thr_new_initthr, param));
189c4bd610fSDavid Xu }
190c4bd610fSDavid Xu 
1915a170c1bSEd Schouten int
1925a170c1bSEd Schouten thread_create(struct thread *td, struct rtprio *rtp,
1935a170c1bSEd Schouten     int (*initialize_thread)(struct thread *, void *), void *thunk)
194c4bd610fSDavid Xu {
195c4bd610fSDavid Xu 	struct thread *newtd;
196c4bd610fSDavid Xu 	struct proc *p;
197adc9c950SDavid Xu 	int error;
198c4bd610fSDavid Xu 
199c4bd610fSDavid Xu 	p = td->td_proc;
200c4bd610fSDavid Xu 
20173fa3e5bSDavid Xu 	if (rtp != NULL) {
20273fa3e5bSDavid Xu 		switch(rtp->type) {
20373fa3e5bSDavid Xu 		case RTP_PRIO_REALTIME:
20473fa3e5bSDavid Xu 		case RTP_PRIO_FIFO:
205a0712c99SDavid Xu 			/* Only root can set scheduler policy */
206acd3428bSRobert Watson 			if (priv_check(td, PRIV_SCHED_SETPOLICY) != 0)
207a0712c99SDavid Xu 				return (EPERM);
20873fa3e5bSDavid Xu 			if (rtp->prio > RTP_PRIO_MAX)
209a0712c99SDavid Xu 				return (EINVAL);
2102dca4ca7SDavid Xu 			break;
21173fa3e5bSDavid Xu 		case RTP_PRIO_NORMAL:
21273fa3e5bSDavid Xu 			rtp->prio = 0;
2132dca4ca7SDavid Xu 			break;
2142dca4ca7SDavid Xu 		default:
2152dca4ca7SDavid Xu 			return (EINVAL);
216a0712c99SDavid Xu 		}
217a0712c99SDavid Xu 	}
218a0712c99SDavid Xu 
219afcc55f3SEdward Tomasz Napierala #ifdef RACCT
2204b5c9cf6SEdward Tomasz Napierala 	if (racct_enable) {
221203322f9SMateusz Guzik 		PROC_LOCK(p);
22258c77a9dSEdward Tomasz Napierala 		error = racct_add(p, RACCT_NTHR, 1);
223203322f9SMateusz Guzik 		PROC_UNLOCK(p);
22458c77a9dSEdward Tomasz Napierala 		if (error != 0)
22558c77a9dSEdward Tomasz Napierala 			return (EPROCLIM);
2264b5c9cf6SEdward Tomasz Napierala 	}
227afcc55f3SEdward Tomasz Napierala #endif
22858c77a9dSEdward Tomasz Napierala 
229ad1e7d28SJulian Elischer 	/* Initialize our td */
23009baafb4SDmitry Chagin 	error = kern_thr_alloc(p, 0, &newtd);
23109baafb4SDmitry Chagin 	if (error)
23258c77a9dSEdward Tomasz Napierala 		goto fail;
233c4bd610fSDavid Xu 
2345c2cf818SKonstantin Belousov 	cpu_copy_thread(newtd, td);
235cdea31e3SPeter Holm 
236ed062c8dSJulian Elischer 	bzero(&newtd->td_startzero,
2376db36923SDavid Schultz 	    __rangeof(struct thread, td_startzero, td_endzero));
238ed062c8dSJulian Elischer 	bcopy(&td->td_startcopy, &newtd->td_startcopy,
2396db36923SDavid Schultz 	    __rangeof(struct thread, td_startcopy, td_endcopy));
240c4bd610fSDavid Xu 	newtd->td_proc = td->td_proc;
2418a06de9eSKonstantin Belousov 	newtd->td_rb_list = newtd->td_rbp_list = newtd->td_rb_inact = 0;
2424ea6a9a2SMateusz Guzik 	thread_cow_get(newtd, td);
24389bb1cefSJeff Roberson 
2445a170c1bSEd Schouten 	error = initialize_thread(newtd, thunk);
245c4bd610fSDavid Xu 	if (error != 0) {
2464ea6a9a2SMateusz Guzik 		thread_cow_free(newtd);
247c4bd610fSDavid Xu 		thread_free(newtd);
24858c77a9dSEdward Tomasz Napierala 		goto fail;
249c4bd610fSDavid Xu 	}
250c4bd610fSDavid Xu 
251203322f9SMateusz Guzik 	PROC_LOCK(p);
252203322f9SMateusz Guzik 	p->p_flag |= P_HADTHREADS;
2538460a577SJohn Birrell 	thread_link(newtd, p);
254c67ddc21SJulian Elischer 	bcopy(p->p_comm, newtd->td_name, sizeof(newtd->td_name));
255982d11f8SJeff Roberson 	thread_lock(td);
256ed062c8dSJulian Elischer 	/* let the scheduler know about these things. */
257ed062c8dSJulian Elischer 	sched_fork_thread(td, newtd);
258982d11f8SJeff Roberson 	thread_unlock(td);
259b7edba77SJeff Roberson 	if (P_SHOULDSTOP(p))
260b7edba77SJeff Roberson 		newtd->td_flags |= TDF_ASTPENDING | TDF_NEEDSUSPCHK;
2618d570f64SJohn Baldwin 	if (p->p_ptevents & PTRACE_LWP)
2625fcfab6eSJohn Baldwin 		newtd->td_dbgflags |= TDB_BORN;
2636520495aSAdrian Chadd 
264982d11f8SJeff Roberson 	PROC_UNLOCK(p);
265*6161b98cSMatt Macy #ifdef	HWPMC_HOOKS
266*6161b98cSMatt Macy 	if (PMC_PROC_IS_USING_PMCS(p))
267*6161b98cSMatt Macy 		PMC_CALL_HOOK(newtd, PMC_FN_THR_CREATE, NULL);
268*6161b98cSMatt Macy #endif
269cf7d9a8cSDavid Xu 
270cf7d9a8cSDavid Xu 	tidhash_add(newtd);
271cf7d9a8cSDavid Xu 
272982d11f8SJeff Roberson 	thread_lock(newtd);
27373fa3e5bSDavid Xu 	if (rtp != NULL) {
2748460a577SJohn Birrell 		if (!(td->td_pri_class == PRI_TIMESHARE &&
2758460a577SJohn Birrell 		      rtp->type == RTP_PRIO_NORMAL)) {
2768460a577SJohn Birrell 			rtp_to_pri(rtp, newtd);
2778460a577SJohn Birrell 			sched_prio(newtd, newtd->td_user_pri);
2788460a577SJohn Birrell 		} /* ignore timesharing class */
2798460a577SJohn Birrell 	}
280ed062c8dSJulian Elischer 	TD_SET_CAN_RUN(newtd);
281f0393f06SJeff Roberson 	sched_add(newtd, SRQ_BORING);
282982d11f8SJeff Roberson 	thread_unlock(newtd);
28389bb1cefSJeff Roberson 
284c90c9021SEd Schouten 	return (0);
28558c77a9dSEdward Tomasz Napierala 
28658c77a9dSEdward Tomasz Napierala fail:
287afcc55f3SEdward Tomasz Napierala #ifdef RACCT
2884b5c9cf6SEdward Tomasz Napierala 	if (racct_enable) {
28958c77a9dSEdward Tomasz Napierala 		PROC_LOCK(p);
29058c77a9dSEdward Tomasz Napierala 		racct_sub(p, RACCT_NTHR, 1);
29158c77a9dSEdward Tomasz Napierala 		PROC_UNLOCK(p);
2924b5c9cf6SEdward Tomasz Napierala 	}
293afcc55f3SEdward Tomasz Napierala #endif
29458c77a9dSEdward Tomasz Napierala 	return (error);
29589bb1cefSJeff Roberson }
29689bb1cefSJeff Roberson 
29789bb1cefSJeff Roberson int
2988451d0ddSKip Macy sys_thr_self(struct thread *td, struct thr_self_args *uap)
299cd28f17dSMarcel Moolenaar     /* long *id */
30089bb1cefSJeff Roberson {
30189bb1cefSJeff Roberson 	int error;
30289bb1cefSJeff Roberson 
303cda9a0d1SDavid Xu 	error = suword_lwpid(uap->id, (unsigned)td->td_tid);
304cda9a0d1SDavid Xu 	if (error == -1)
305cda9a0d1SDavid Xu 		return (EFAULT);
30689bb1cefSJeff Roberson 	return (0);
30789bb1cefSJeff Roberson }
30889bb1cefSJeff Roberson 
30989bb1cefSJeff Roberson int
3108451d0ddSKip Macy sys_thr_exit(struct thread *td, struct thr_exit_args *uap)
311401901acSMike Makonnen     /* long *state */
31289bb1cefSJeff Roberson {
31389bb1cefSJeff Roberson 
3142a339d9eSKonstantin Belousov 	umtx_thread_exit(td);
3152a339d9eSKonstantin Belousov 
316401901acSMike Makonnen 	/* Signal userland that it can free the stack. */
3174938faa6SDavid Xu 	if ((void *)uap->state != NULL) {
318cda9a0d1SDavid Xu 		suword_lwpid(uap->state, 1);
3193bba58f2SDavid Xu 		kern_umtx_wake(td, uap->state, INT_MAX, 0);
3204938faa6SDavid Xu 	}
321401901acSMike Makonnen 
32295be6d2bSDmitry Chagin 	return (kern_thr_exit(td));
32395be6d2bSDmitry Chagin }
32458c77a9dSEdward Tomasz Napierala 
32595be6d2bSDmitry Chagin int
32695be6d2bSDmitry Chagin kern_thr_exit(struct thread *td)
32795be6d2bSDmitry Chagin {
32895be6d2bSDmitry Chagin 	struct proc *p;
32995be6d2bSDmitry Chagin 
33095be6d2bSDmitry Chagin 	p = td->td_proc;
33195be6d2bSDmitry Chagin 
3325fcfab6eSJohn Baldwin 	/*
3335fcfab6eSJohn Baldwin 	 * If all of the threads in a process call this routine to
3345fcfab6eSJohn Baldwin 	 * exit (e.g. all threads call pthread_exit()), exactly one
3355fcfab6eSJohn Baldwin 	 * thread should return to the caller to terminate the process
3365fcfab6eSJohn Baldwin 	 * instead of the thread.
3375fcfab6eSJohn Baldwin 	 *
3385fcfab6eSJohn Baldwin 	 * Checking p_numthreads alone is not sufficient since threads
3395fcfab6eSJohn Baldwin 	 * might be committed to terminating while the PROC_LOCK is
3405fcfab6eSJohn Baldwin 	 * dropped in either ptracestop() or while removing this thread
3415fcfab6eSJohn Baldwin 	 * from the tidhash.  Instead, the p_pendingexits field holds
3425fcfab6eSJohn Baldwin 	 * the count of threads in either of those states and a thread
3435fcfab6eSJohn Baldwin 	 * is considered the "last" thread if all of the other threads
3445fcfab6eSJohn Baldwin 	 * in a process are already terminating.
3455fcfab6eSJohn Baldwin 	 */
34689bb1cefSJeff Roberson 	PROC_LOCK(p);
3475fcfab6eSJohn Baldwin 	if (p->p_numthreads == p->p_pendingexits + 1) {
3485fcfab6eSJohn Baldwin 		/*
3495fcfab6eSJohn Baldwin 		 * Ignore attempts to shut down last thread in the
3505fcfab6eSJohn Baldwin 		 * proc.  This will actually call _exit(2) in the
3515fcfab6eSJohn Baldwin 		 * usermode trampoline when it returns.
3525fcfab6eSJohn Baldwin 		 */
3535fcfab6eSJohn Baldwin 		PROC_UNLOCK(p);
3545fcfab6eSJohn Baldwin 		return (0);
3555fcfab6eSJohn Baldwin 	}
35658c77a9dSEdward Tomasz Napierala 
3575fcfab6eSJohn Baldwin 	p->p_pendingexits++;
3585fcfab6eSJohn Baldwin 	td->td_dbgflags |= TDB_EXIT;
3598d570f64SJohn Baldwin 	if (p->p_ptevents & PTRACE_LWP)
36082a4538fSEric Badger 		ptracestop(td, SIGTRAP, NULL);
3615fcfab6eSJohn Baldwin 	PROC_UNLOCK(p);
3625fcfab6eSJohn Baldwin 	tidhash_remove(td);
3635fcfab6eSJohn Baldwin 	PROC_LOCK(p);
3645fcfab6eSJohn Baldwin 	p->p_pendingexits--;
3655fcfab6eSJohn Baldwin 
3665fcfab6eSJohn Baldwin 	/*
3675fcfab6eSJohn Baldwin 	 * The check above should prevent all other threads from this
3685fcfab6eSJohn Baldwin 	 * process from exiting while the PROC_LOCK is dropped, so
3695fcfab6eSJohn Baldwin 	 * there must be at least one other thread other than the
3705fcfab6eSJohn Baldwin 	 * current thread.
3715fcfab6eSJohn Baldwin 	 */
3725fcfab6eSJohn Baldwin 	KASSERT(p->p_numthreads > 1, ("too few threads"));
37347f6635cSEdward Tomasz Napierala 	racct_sub(p, RACCT_NTHR, 1);
3740d036d55SDavid Xu 	tdsigcleanup(td);
3750d036d55SDavid Xu 	PROC_SLOCK(p);
37671b7afb2SDavid Xu 	thread_stopped(p);
377ed062c8dSJulian Elischer 	thread_exit();
378ed062c8dSJulian Elischer 	/* NOTREACHED */
379ed062c8dSJulian Elischer }
38074d5b4afSKonstantin Belousov 
38189bb1cefSJeff Roberson int
3828451d0ddSKip Macy sys_thr_kill(struct thread *td, struct thr_kill_args *uap)
383cd28f17dSMarcel Moolenaar     /* long id, int sig */
38489bb1cefSJeff Roberson {
3855f73a7ebSBruno Ducrot 	ksiginfo_t ksi;
38689bb1cefSJeff Roberson 	struct thread *ttd;
38789bb1cefSJeff Roberson 	struct proc *p;
38889bb1cefSJeff Roberson 	int error;
38989bb1cefSJeff Roberson 
39089bb1cefSJeff Roberson 	p = td->td_proc;
3915f73a7ebSBruno Ducrot 	ksiginfo_init(&ksi);
3925f73a7ebSBruno Ducrot 	ksi.ksi_signo = uap->sig;
393baf28b69SDavid Xu 	ksi.ksi_code = SI_LWP;
3945f73a7ebSBruno Ducrot 	ksi.ksi_pid = p->p_pid;
3955f73a7ebSBruno Ducrot 	ksi.ksi_uid = td->td_ucred->cr_ruid;
3960a5cd498SDavid Xu 	if (uap->id == -1) {
3970a5cd498SDavid Xu 		if (uap->sig != 0 && !_SIG_VALID(uap->sig)) {
39889bb1cefSJeff Roberson 			error = EINVAL;
3990a5cd498SDavid Xu 		} else {
4000a5cd498SDavid Xu 			error = ESRCH;
401cf7d9a8cSDavid Xu 			PROC_LOCK(p);
4020a5cd498SDavid Xu 			FOREACH_THREAD_IN_PROC(p, ttd) {
4030a5cd498SDavid Xu 				if (ttd != td) {
4040a5cd498SDavid Xu 					error = 0;
4050a5cd498SDavid Xu 					if (uap->sig == 0)
4060a5cd498SDavid Xu 						break;
407ad6eec7bSJohn Baldwin 					tdksignal(ttd, uap->sig, &ksi);
4080a5cd498SDavid Xu 				}
4090a5cd498SDavid Xu 			}
410cf7d9a8cSDavid Xu 			PROC_UNLOCK(p);
4110a5cd498SDavid Xu 		}
4120a5cd498SDavid Xu 	} else {
413cf7d9a8cSDavid Xu 		error = 0;
414cf7d9a8cSDavid Xu 		ttd = tdfind((lwpid_t)uap->id, p->p_pid);
4150a5cd498SDavid Xu 		if (ttd == NULL)
416cf7d9a8cSDavid Xu 			return (ESRCH);
417cf7d9a8cSDavid Xu 		if (uap->sig == 0)
4180a5cd498SDavid Xu 			;
4190a5cd498SDavid Xu 		else if (!_SIG_VALID(uap->sig))
4200a5cd498SDavid Xu 			error = EINVAL;
4210a5cd498SDavid Xu 		else
422ad6eec7bSJohn Baldwin 			tdksignal(ttd, uap->sig, &ksi);
423cf7d9a8cSDavid Xu 		PROC_UNLOCK(ttd->td_proc);
4240a5cd498SDavid Xu 	}
42589bb1cefSJeff Roberson 	return (error);
42689bb1cefSJeff Roberson }
4271713a516SMike Makonnen 
4281713a516SMike Makonnen int
4298451d0ddSKip Macy sys_thr_kill2(struct thread *td, struct thr_kill2_args *uap)
4300b1f0611SDavid Xu     /* pid_t pid, long id, int sig */
4310b1f0611SDavid Xu {
4325f73a7ebSBruno Ducrot 	ksiginfo_t ksi;
4330b1f0611SDavid Xu 	struct thread *ttd;
4340b1f0611SDavid Xu 	struct proc *p;
4350b1f0611SDavid Xu 	int error;
4360b1f0611SDavid Xu 
43714961ba7SRobert Watson 	AUDIT_ARG_SIGNUM(uap->sig);
4380b1f0611SDavid Xu 
4395f73a7ebSBruno Ducrot 	ksiginfo_init(&ksi);
4405f73a7ebSBruno Ducrot 	ksi.ksi_signo = uap->sig;
441baf28b69SDavid Xu 	ksi.ksi_code = SI_LWP;
4425f73a7ebSBruno Ducrot 	ksi.ksi_pid = td->td_proc->p_pid;
4435f73a7ebSBruno Ducrot 	ksi.ksi_uid = td->td_ucred->cr_ruid;
4440b1f0611SDavid Xu 	if (uap->id == -1) {
445cf7d9a8cSDavid Xu 		if ((p = pfind(uap->pid)) == NULL)
446cf7d9a8cSDavid Xu 			return (ESRCH);
447cf7d9a8cSDavid Xu 		AUDIT_ARG_PROCESS(p);
448cf7d9a8cSDavid Xu 		error = p_cansignal(td, p, uap->sig);
449cf7d9a8cSDavid Xu 		if (error) {
450cf7d9a8cSDavid Xu 			PROC_UNLOCK(p);
451cf7d9a8cSDavid Xu 			return (error);
452cf7d9a8cSDavid Xu 		}
4530b1f0611SDavid Xu 		if (uap->sig != 0 && !_SIG_VALID(uap->sig)) {
4540b1f0611SDavid Xu 			error = EINVAL;
4550b1f0611SDavid Xu 		} else {
4560b1f0611SDavid Xu 			error = ESRCH;
4570b1f0611SDavid Xu 			FOREACH_THREAD_IN_PROC(p, ttd) {
4580b1f0611SDavid Xu 				if (ttd != td) {
4590b1f0611SDavid Xu 					error = 0;
4600b1f0611SDavid Xu 					if (uap->sig == 0)
4610b1f0611SDavid Xu 						break;
462ad6eec7bSJohn Baldwin 					tdksignal(ttd, uap->sig, &ksi);
4630b1f0611SDavid Xu 				}
4640b1f0611SDavid Xu 			}
4650b1f0611SDavid Xu 		}
466cf7d9a8cSDavid Xu 		PROC_UNLOCK(p);
4670b1f0611SDavid Xu 	} else {
468cf7d9a8cSDavid Xu 		ttd = tdfind((lwpid_t)uap->id, uap->pid);
4690b1f0611SDavid Xu 		if (ttd == NULL)
470cf7d9a8cSDavid Xu 			return (ESRCH);
471cf7d9a8cSDavid Xu 		p = ttd->td_proc;
472cf7d9a8cSDavid Xu 		AUDIT_ARG_PROCESS(p);
473cf7d9a8cSDavid Xu 		error = p_cansignal(td, p, uap->sig);
474cf7d9a8cSDavid Xu 		if (uap->sig == 0)
4750b1f0611SDavid Xu 			;
4760b1f0611SDavid Xu 		else if (!_SIG_VALID(uap->sig))
4770b1f0611SDavid Xu 			error = EINVAL;
4780b1f0611SDavid Xu 		else
479ad6eec7bSJohn Baldwin 			tdksignal(ttd, uap->sig, &ksi);
4800b1f0611SDavid Xu 		PROC_UNLOCK(p);
481cf7d9a8cSDavid Xu 	}
4820b1f0611SDavid Xu 	return (error);
4830b1f0611SDavid Xu }
4840b1f0611SDavid Xu 
4850b1f0611SDavid Xu int
4868451d0ddSKip Macy sys_thr_suspend(struct thread *td, struct thr_suspend_args *uap)
4871713a516SMike Makonnen 	/* const struct timespec *timeout */
4881713a516SMike Makonnen {
489cda9a0d1SDavid Xu 	struct timespec ts, *tsp;
4901713a516SMike Makonnen 	int error;
4911713a516SMike Makonnen 
492cda9a0d1SDavid Xu 	tsp = NULL;
4931713a516SMike Makonnen 	if (uap->timeout != NULL) {
4949a1d0cf6SPeter Holm 		error = umtx_copyin_timeout(uap->timeout, &ts);
4951713a516SMike Makonnen 		if (error != 0)
4961713a516SMike Makonnen 			return (error);
497cda9a0d1SDavid Xu 		tsp = &ts;
498cda9a0d1SDavid Xu 	}
499cda9a0d1SDavid Xu 
500cda9a0d1SDavid Xu 	return (kern_thr_suspend(td, tsp));
501cda9a0d1SDavid Xu }
502cda9a0d1SDavid Xu 
503cda9a0d1SDavid Xu int
504cda9a0d1SDavid Xu kern_thr_suspend(struct thread *td, struct timespec *tsp)
505cda9a0d1SDavid Xu {
506cfca8a18SDavid Xu 	struct proc *p = td->td_proc;
507cda9a0d1SDavid Xu 	struct timeval tv;
5082961a782SDavid Xu 	int error = 0;
5092961a782SDavid Xu 	int timo = 0;
510cda9a0d1SDavid Xu 
511745fbd3aSDavid Xu 	if (td->td_pflags & TDP_WAKEUP) {
512745fbd3aSDavid Xu 		td->td_pflags &= ~TDP_WAKEUP;
513745fbd3aSDavid Xu 		return (0);
514745fbd3aSDavid Xu 	}
515745fbd3aSDavid Xu 
516cfca8a18SDavid Xu 	if (tsp != NULL) {
5172961a782SDavid Xu 		if (tsp->tv_sec == 0 && tsp->tv_nsec == 0)
5182961a782SDavid Xu 			error = EWOULDBLOCK;
5192961a782SDavid Xu 		else {
5202961a782SDavid Xu 			TIMESPEC_TO_TIMEVAL(&tv, tsp);
5212961a782SDavid Xu 			timo = tvtohz(&tv);
522cfca8a18SDavid Xu 		}
523cfca8a18SDavid Xu 	}
524cfca8a18SDavid Xu 
525cfca8a18SDavid Xu 	PROC_LOCK(p);
526cfca8a18SDavid Xu 	if (error == 0 && (td->td_flags & TDF_THRWAKEUP) == 0)
527cfca8a18SDavid Xu 		error = msleep((void *)td, &p->p_mtx,
5282961a782SDavid Xu 			 PCATCH, "lthr", timo);
5292961a782SDavid Xu 
530c1df5a1aSDavid Xu 	if (td->td_flags & TDF_THRWAKEUP) {
531982d11f8SJeff Roberson 		thread_lock(td);
5321713a516SMike Makonnen 		td->td_flags &= ~TDF_THRWAKEUP;
533982d11f8SJeff Roberson 		thread_unlock(td);
534cfca8a18SDavid Xu 		PROC_UNLOCK(p);
535c1df5a1aSDavid Xu 		return (0);
536c1df5a1aSDavid Xu 	}
537cfca8a18SDavid Xu 	PROC_UNLOCK(p);
538c1df5a1aSDavid Xu 	if (error == EWOULDBLOCK)
539c1df5a1aSDavid Xu 		error = ETIMEDOUT;
540c1df5a1aSDavid Xu 	else if (error == ERESTART) {
5412961a782SDavid Xu 		if (timo != 0)
542c1df5a1aSDavid Xu 			error = EINTR;
543c1df5a1aSDavid Xu 	}
544c1df5a1aSDavid Xu 	return (error);
5451713a516SMike Makonnen }
5461713a516SMike Makonnen 
5471713a516SMike Makonnen int
5488451d0ddSKip Macy sys_thr_wake(struct thread *td, struct thr_wake_args *uap)
549cd28f17dSMarcel Moolenaar 	/* long id */
5501713a516SMike Makonnen {
55144355392SDavid Xu 	struct proc *p;
552cd28f17dSMarcel Moolenaar 	struct thread *ttd;
5531713a516SMike Makonnen 
554745fbd3aSDavid Xu 	if (uap->id == td->td_tid) {
555745fbd3aSDavid Xu 		td->td_pflags |= TDP_WAKEUP;
556745fbd3aSDavid Xu 		return (0);
557745fbd3aSDavid Xu 	}
558745fbd3aSDavid Xu 
55944355392SDavid Xu 	p = td->td_proc;
560cf7d9a8cSDavid Xu 	ttd = tdfind((lwpid_t)uap->id, p->p_pid);
561cf7d9a8cSDavid Xu 	if (ttd == NULL)
5621713a516SMike Makonnen 		return (ESRCH);
563982d11f8SJeff Roberson 	thread_lock(ttd);
564cd28f17dSMarcel Moolenaar 	ttd->td_flags |= TDF_THRWAKEUP;
565982d11f8SJeff Roberson 	thread_unlock(ttd);
566c1df5a1aSDavid Xu 	wakeup((void *)ttd);
56744355392SDavid Xu 	PROC_UNLOCK(p);
5681713a516SMike Makonnen 	return (0);
5691713a516SMike Makonnen }
5709e7d7224SDavid Xu 
5719e7d7224SDavid Xu int
5728451d0ddSKip Macy sys_thr_set_name(struct thread *td, struct thr_set_name_args *uap)
5739e7d7224SDavid Xu {
574cf7d9a8cSDavid Xu 	struct proc *p;
5759e7d7224SDavid Xu 	char name[MAXCOMLEN + 1];
5769e7d7224SDavid Xu 	struct thread *ttd;
5779e7d7224SDavid Xu 	int error;
5789e7d7224SDavid Xu 
5799e7d7224SDavid Xu 	error = 0;
5809e7d7224SDavid Xu 	name[0] = '\0';
5819e7d7224SDavid Xu 	if (uap->name != NULL) {
582ff07dd91SEric van Gyzen 		error = copyinstr(uap->name, name, sizeof(name), NULL);
583ff07dd91SEric van Gyzen 		if (error == ENAMETOOLONG) {
584ff07dd91SEric van Gyzen 			error = copyin(uap->name, name, sizeof(name) - 1);
585ff07dd91SEric van Gyzen 			name[sizeof(name) - 1] = '\0';
586ff07dd91SEric van Gyzen 		}
5879e7d7224SDavid Xu 		if (error)
5889e7d7224SDavid Xu 			return (error);
5899e7d7224SDavid Xu 	}
590cf7d9a8cSDavid Xu 	p = td->td_proc;
591cf7d9a8cSDavid Xu 	ttd = tdfind((lwpid_t)uap->id, p->p_pid);
592cf7d9a8cSDavid Xu 	if (ttd == NULL)
593cf7d9a8cSDavid Xu 		return (ESRCH);
5949e7d7224SDavid Xu 	strcpy(ttd->td_name, name);
59544ad5475SJohn Baldwin #ifdef KTR
59644ad5475SJohn Baldwin 	sched_clear_tdname(ttd);
59744ad5475SJohn Baldwin #endif
5989e7d7224SDavid Xu 	PROC_UNLOCK(p);
5999e7d7224SDavid Xu 	return (error);
6009e7d7224SDavid Xu }
60109baafb4SDmitry Chagin 
60209baafb4SDmitry Chagin int
60309baafb4SDmitry Chagin kern_thr_alloc(struct proc *p, int pages, struct thread **ntd)
60409baafb4SDmitry Chagin {
60509baafb4SDmitry Chagin 
60609baafb4SDmitry Chagin 	/* Have race condition but it is cheap. */
60709baafb4SDmitry Chagin 	if (p->p_numthreads >= max_threads_per_proc) {
60809baafb4SDmitry Chagin 		++max_threads_hits;
60909baafb4SDmitry Chagin 		return (EPROCLIM);
61009baafb4SDmitry Chagin 	}
61109baafb4SDmitry Chagin 
61209baafb4SDmitry Chagin 	*ntd = thread_alloc(pages);
61309baafb4SDmitry Chagin 	if (*ntd == NULL)
61409baafb4SDmitry Chagin 		return (ENOMEM);
61509baafb4SDmitry Chagin 
61609baafb4SDmitry Chagin 	return (0);
61709baafb4SDmitry Chagin }
618