2005-01-06 23:35:40 +00:00
|
|
|
/*-
|
1999-07-01 13:21:46 +00:00
|
|
|
* Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
1999-07-01 13:21:46 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
2012-02-04 16:49:29 +00:00
|
|
|
#include <sys/cpuset.h>
|
1999-07-01 13:21:46 +00:00
|
|
|
#include <sys/kthread.h>
|
2000-12-23 19:43:10 +00:00
|
|
|
#include <sys/lock.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
#include <sys/proc.h>
|
2000-01-10 08:00:58 +00:00
|
|
|
#include <sys/resourcevar.h>
|
2010-10-23 13:16:39 +00:00
|
|
|
#include <sys/rwlock.h>
|
2000-01-07 08:36:44 +00:00
|
|
|
#include <sys/signalvar.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/sx.h>
|
2015-02-28 04:19:02 +00:00
|
|
|
#include <sys/umtx.h>
|
1999-07-01 13:21:46 +00:00
|
|
|
#include <sys/unistd.h>
|
|
|
|
#include <sys/wait.h>
|
2007-01-23 08:46:51 +00:00
|
|
|
#include <sys/sched.h>
|
2007-10-26 08:00:41 +00:00
|
|
|
#include <vm/vm.h>
|
|
|
|
#include <vm/vm_extern.h>
|
1999-07-01 13:21:46 +00:00
|
|
|
|
|
|
|
#include <machine/stdarg.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start a kernel process. This is called after a fork() call in
|
|
|
|
* mi_startup() in the file kern/init_main.c.
|
|
|
|
*
|
|
|
|
* This function is used to start "internal" daemons and intended
|
|
|
|
* to be called from SYSINIT().
|
|
|
|
*/
|
|
|
|
void
|
2015-06-28 09:44:58 +00:00
|
|
|
kproc_start(const void *udata)
|
1999-07-01 13:21:46 +00:00
|
|
|
{
|
|
|
|
const struct kproc_desc *kp = udata;
|
|
|
|
int error;
|
|
|
|
|
2007-10-20 23:23:23 +00:00
|
|
|
error = kproc_create((void (*)(void *))kp->func, NULL,
|
2002-10-02 07:44:29 +00:00
|
|
|
kp->global_procpp, 0, 0, "%s", kp->arg0);
|
1999-07-01 13:21:46 +00:00
|
|
|
if (error)
|
|
|
|
panic("kproc_start: %s: error %d", kp->arg0, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2000-09-07 01:33:02 +00:00
|
|
|
* Create a kernel process/thread/whatever. It shares its address space
|
1999-07-01 13:21:46 +00:00
|
|
|
* with proc0 - ie: kernel only.
|
2000-09-07 01:33:02 +00:00
|
|
|
*
|
|
|
|
* func is the function to start.
|
|
|
|
* arg is the parameter to pass to function on first startup.
|
|
|
|
* newpp is the return value pointing to the thread's struct proc.
|
|
|
|
* flags are flags to fork1 (in unistd.h)
|
|
|
|
* fmt and following will be *printf'd into (*newpp)->p_comm (for ps, etc.).
|
1999-07-01 13:21:46 +00:00
|
|
|
*/
|
|
|
|
int
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_create(void (*func)(void *), void *arg,
|
2002-10-02 07:44:29 +00:00
|
|
|
struct proc **newpp, int flags, int pages, const char *fmt, ...)
|
1999-07-01 13:21:46 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
va_list ap;
|
2002-09-11 08:13:56 +00:00
|
|
|
struct thread *td;
|
1999-07-01 13:21:46 +00:00
|
|
|
struct proc *p2;
|
|
|
|
|
2003-05-01 16:59:23 +00:00
|
|
|
if (!proc0.p_stats)
|
2007-10-20 23:23:23 +00:00
|
|
|
panic("kproc_create called too soon");
|
2000-09-07 01:33:02 +00:00
|
|
|
|
2002-02-07 23:06:26 +00:00
|
|
|
error = fork1(&thread0, RFMEM | RFFDG | RFPROC | RFSTOPPED | flags,
|
Add experimental support for process descriptors
A "process descriptor" file descriptor is used to manage processes
without using the PID namespace. This is required for Capsicum's
Capability Mode, where the PID namespace is unavailable.
New system calls pdfork(2) and pdkill(2) offer the functional equivalents
of fork(2) and kill(2). pdgetpid(2) allows querying the PID of the remote
process for debugging purposes. The currently-unimplemented pdwait(2) will,
in the future, allow querying rusage/exit status. In the interim, poll(2)
may be used to check (and wait for) process termination.
When a process is referenced by a process descriptor, it does not issue
SIGCHLD to the parent, making it suitable for use in libraries---a common
scenario when using library compartmentalisation from within large
applications (such as web browsers). Some observers may note a similarity
to Mach task ports; process descriptors provide a subset of this behaviour,
but in a UNIX style.
This feature is enabled by "options PROCDESC", but as with several other
Capsicum kernel features, is not enabled by default in GENERIC 9.0.
Reviewed by: jhb, kib
Approved by: re (kib), mentor (rwatson)
Sponsored by: Google Inc
2011-08-18 22:51:30 +00:00
|
|
|
pages, &p2, NULL, 0);
|
1999-07-01 13:21:46 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
/* save a global descriptor, if desired */
|
|
|
|
if (newpp != NULL)
|
|
|
|
*newpp = p2;
|
|
|
|
|
|
|
|
/* this is a non-swapped system process */
|
2001-01-24 10:47:50 +00:00
|
|
|
PROC_LOCK(p2);
|
2007-10-26 08:00:41 +00:00
|
|
|
td = FIRST_THREAD_IN_PROC(p2);
|
2001-01-24 10:47:50 +00:00
|
|
|
p2->p_flag |= P_SYSTEM | P_KTHREAD;
|
2007-10-26 08:00:41 +00:00
|
|
|
td->td_pflags |= TDP_KTHREAD;
|
- Merge struct procsig with struct sigacts.
- Move struct sigacts out of the u-area and malloc() it using the
M_SUBPROC malloc bucket.
- Add a small sigacts_*() API for managing sigacts structures: sigacts_alloc(),
sigacts_free(), sigacts_copy(), sigacts_share(), and sigacts_shared().
- Remove the p_sigignore, p_sigacts, and p_sigcatch macros.
- Add a mutex to struct sigacts that protects all the members of the struct.
- Add sigacts locking.
- Remove Giant from nosys(), kill(), killpg(), and kern_sigaction() now
that sigacts is locked.
- Several in-kernel functions such as psignal(), tdsignal(), trapsignal(),
and thread_stopped() are now MP safe.
Reviewed by: arch@
Approved by: re (rwatson)
2003-05-13 20:36:02 +00:00
|
|
|
mtx_lock(&p2->p_sigacts->ps_mtx);
|
|
|
|
p2->p_sigacts->ps_flag |= PS_NOCLDWAIT;
|
|
|
|
mtx_unlock(&p2->p_sigacts->ps_mtx);
|
2001-01-24 10:47:50 +00:00
|
|
|
PROC_UNLOCK(p2);
|
1999-07-01 13:21:46 +00:00
|
|
|
|
|
|
|
/* set up arg0 for 'ps', et al */
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(p2->p_comm, sizeof(p2->p_comm), fmt, ap);
|
|
|
|
va_end(ap);
|
2007-10-26 08:00:41 +00:00
|
|
|
/* set up arg0 for 'ps', et al */
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(td->td_name, sizeof(td->td_name), fmt, ap);
|
|
|
|
va_end(ap);
|
2012-03-08 19:41:05 +00:00
|
|
|
#ifdef KTR
|
|
|
|
sched_clear_tdname(td);
|
|
|
|
#endif
|
1999-07-01 13:21:46 +00:00
|
|
|
|
|
|
|
/* call the processes' main()... */
|
2002-09-11 08:13:56 +00:00
|
|
|
cpu_set_fork_handler(td, func, arg);
|
2012-02-04 16:49:29 +00:00
|
|
|
|
|
|
|
/* Avoid inheriting affinity from a random parent. */
|
|
|
|
cpuset_setthread(td->td_tid, cpuset_root);
|
2011-01-06 22:26:00 +00:00
|
|
|
thread_lock(td);
|
2002-09-11 08:13:56 +00:00
|
|
|
TD_SET_CAN_RUN(td);
|
2011-01-06 22:26:00 +00:00
|
|
|
sched_prio(td, PVM);
|
|
|
|
sched_user_prio(td, PUSER);
|
1999-07-01 13:21:46 +00:00
|
|
|
|
2000-12-06 03:45:15 +00:00
|
|
|
/* Delay putting it on the run queue until now. */
|
2011-01-06 22:26:00 +00:00
|
|
|
if (!(flags & RFSTOPPED))
|
2007-01-23 08:46:51 +00:00
|
|
|
sched_add(td, SRQ_BORING);
|
2011-01-06 22:26:00 +00:00
|
|
|
thread_unlock(td);
|
2000-12-06 03:45:15 +00:00
|
|
|
|
1999-07-01 13:21:46 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_exit(int ecode)
|
1999-07-01 13:21:46 +00:00
|
|
|
{
|
2001-11-12 08:53:34 +00:00
|
|
|
struct thread *td;
|
|
|
|
struct proc *p;
|
2000-12-23 19:43:10 +00:00
|
|
|
|
2001-11-12 08:53:34 +00:00
|
|
|
td = curthread;
|
|
|
|
p = td->td_proc;
|
2006-02-06 21:56:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Reparent curthread from proc0 to init so that the zombie
|
|
|
|
* is harvested.
|
|
|
|
*/
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xlock(&proctree_lock);
|
2001-11-12 08:42:20 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
proc_reparent(p, initproc);
|
|
|
|
PROC_UNLOCK(p);
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_xunlock(&proctree_lock);
|
2006-02-06 21:56:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wakeup anyone waiting for us to exit.
|
|
|
|
*/
|
|
|
|
wakeup(p);
|
|
|
|
|
|
|
|
/* Buh-bye! */
|
2001-11-12 08:53:34 +00:00
|
|
|
exit1(td, W_EXITCODE(ecode, 0));
|
1999-07-01 13:21:46 +00:00
|
|
|
}
|
|
|
|
|
2000-01-07 08:36:44 +00:00
|
|
|
/*
|
|
|
|
* Advise a kernel process to suspend (or resume) in its main loop.
|
|
|
|
* Participation is voluntary.
|
|
|
|
*/
|
|
|
|
int
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_suspend(struct proc *p, int timo)
|
2000-01-07 08:36:44 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure this is indeed a system process and we can safely
|
2002-10-01 17:15:53 +00:00
|
|
|
* use the p_siglist field.
|
2000-01-07 08:36:44 +00:00
|
|
|
*/
|
2001-03-07 02:36:47 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
if ((p->p_flag & P_KTHREAD) == 0) {
|
|
|
|
PROC_UNLOCK(p);
|
2000-01-07 08:36:44 +00:00
|
|
|
return (EINVAL);
|
2001-03-07 02:36:47 +00:00
|
|
|
}
|
2002-10-01 17:15:53 +00:00
|
|
|
SIGADDSET(p->p_siglist, SIGSTOP);
|
2001-12-19 01:31:12 +00:00
|
|
|
wakeup(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
return msleep(&p->p_siglist, &p->p_mtx, PPAUSE | PDROP, "suspkp", timo);
|
2000-01-07 08:36:44 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_resume(struct proc *p)
|
2000-01-07 08:36:44 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Make sure this is indeed a system process and we can safely
|
|
|
|
* use the p_siglist field.
|
|
|
|
*/
|
2001-03-07 02:36:47 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
if ((p->p_flag & P_KTHREAD) == 0) {
|
|
|
|
PROC_UNLOCK(p);
|
2000-01-07 08:36:44 +00:00
|
|
|
return (EINVAL);
|
2001-03-07 02:36:47 +00:00
|
|
|
}
|
2002-10-01 17:15:53 +00:00
|
|
|
SIGDELSET(p->p_siglist, SIGSTOP);
|
2001-03-07 02:36:47 +00:00
|
|
|
PROC_UNLOCK(p);
|
2002-10-01 17:15:53 +00:00
|
|
|
wakeup(&p->p_siglist);
|
2000-01-07 08:36:44 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-10-20 23:23:23 +00:00
|
|
|
kproc_suspend_check(struct proc *p)
|
2000-01-07 08:36:44 +00:00
|
|
|
{
|
2001-03-07 02:36:47 +00:00
|
|
|
PROC_LOCK(p);
|
2002-10-01 17:15:53 +00:00
|
|
|
while (SIGISMEMBER(p->p_siglist, SIGSTOP)) {
|
|
|
|
wakeup(&p->p_siglist);
|
2007-10-26 08:00:41 +00:00
|
|
|
msleep(&p->p_siglist, &p->p_mtx, PPAUSE, "kpsusp", 0);
|
2000-01-07 08:36:44 +00:00
|
|
|
}
|
2001-03-07 02:36:47 +00:00
|
|
|
PROC_UNLOCK(p);
|
2000-01-07 08:36:44 +00:00
|
|
|
}
|
2007-10-26 08:00:41 +00:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start a kernel thread.
|
|
|
|
*
|
|
|
|
* This function is used to start "internal" daemons and intended
|
|
|
|
* to be called from SYSINIT().
|
|
|
|
*/
|
|
|
|
|
|
|
|
void
|
|
|
|
kthread_start(udata)
|
|
|
|
const void *udata;
|
|
|
|
{
|
|
|
|
const struct kthread_desc *kp = udata;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = kthread_add((void (*)(void *))kp->func, NULL,
|
|
|
|
NULL, kp->global_threadpp, 0, 0, "%s", kp->arg0);
|
|
|
|
if (error)
|
|
|
|
panic("kthread_start: %s: error %d", kp->arg0, error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Create a kernel thread. It shares its address space
|
|
|
|
* with proc0 - ie: kernel only.
|
|
|
|
*
|
|
|
|
* func is the function to start.
|
|
|
|
* arg is the parameter to pass to function on first startup.
|
|
|
|
* newtdp is the return value pointing to the thread's struct thread.
|
|
|
|
* ** XXX fix this --> flags are flags to fork1 (in unistd.h)
|
|
|
|
* fmt and following will be *printf'd into (*newtd)->td_name (for ps, etc.).
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
kthread_add(void (*func)(void *), void *arg, struct proc *p,
|
|
|
|
struct thread **newtdp, int flags, int pages, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
struct thread *newtd, *oldtd;
|
|
|
|
|
|
|
|
if (!proc0.p_stats)
|
|
|
|
panic("kthread_add called too soon");
|
|
|
|
|
2007-10-27 00:54:16 +00:00
|
|
|
/* If no process supplied, put it on proc0 */
|
2013-08-17 17:02:43 +00:00
|
|
|
if (p == NULL)
|
2007-10-26 08:00:41 +00:00
|
|
|
p = &proc0;
|
|
|
|
|
2007-10-27 00:54:16 +00:00
|
|
|
/* Initialize our new td */
|
2009-09-01 11:41:51 +00:00
|
|
|
newtd = thread_alloc(pages);
|
2007-10-26 08:00:41 +00:00
|
|
|
if (newtd == NULL)
|
|
|
|
return (ENOMEM);
|
|
|
|
|
2013-08-17 17:02:43 +00:00
|
|
|
PROC_LOCK(p);
|
|
|
|
oldtd = FIRST_THREAD_IN_PROC(p);
|
|
|
|
|
2007-10-26 08:00:41 +00:00
|
|
|
bzero(&newtd->td_startzero,
|
|
|
|
__rangeof(struct thread, td_startzero, td_endzero));
|
|
|
|
bcopy(&oldtd->td_startcopy, &newtd->td_startcopy,
|
|
|
|
__rangeof(struct thread, td_startcopy, td_endcopy));
|
|
|
|
|
|
|
|
/* set up arg0 for 'ps', et al */
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(newtd->td_name, sizeof(newtd->td_name), fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
newtd->td_proc = p; /* needed for cpu_set_upcall */
|
|
|
|
|
|
|
|
/* XXX optimise this probably? */
|
|
|
|
/* On x86 (and probably the others too) it is way too full of junk */
|
|
|
|
/* Needs a better name */
|
|
|
|
cpu_set_upcall(newtd, oldtd);
|
|
|
|
/* put the designated function(arg) as the resume context */
|
|
|
|
cpu_set_fork_handler(newtd, func, arg);
|
|
|
|
|
|
|
|
newtd->td_pflags |= TDP_KTHREAD;
|
2015-06-10 10:43:59 +00:00
|
|
|
thread_cow_get_proc(newtd, p);
|
2007-10-26 08:00:41 +00:00
|
|
|
|
|
|
|
/* this code almost the same as create_thread() in kern_thr.c */
|
|
|
|
p->p_flag |= P_HADTHREADS;
|
|
|
|
thread_link(newtd, p);
|
|
|
|
thread_lock(oldtd);
|
|
|
|
/* let the scheduler know about these things. */
|
|
|
|
sched_fork_thread(oldtd, newtd);
|
|
|
|
TD_SET_CAN_RUN(newtd);
|
|
|
|
thread_unlock(oldtd);
|
|
|
|
PROC_UNLOCK(p);
|
|
|
|
|
2010-10-09 02:50:23 +00:00
|
|
|
tidhash_add(newtd);
|
2007-10-26 08:00:41 +00:00
|
|
|
|
2012-02-04 16:49:29 +00:00
|
|
|
/* Avoid inheriting affinity from a random parent. */
|
|
|
|
cpuset_setthread(newtd->td_tid, cpuset_root);
|
|
|
|
|
2007-10-26 08:00:41 +00:00
|
|
|
/* Delay putting it on the run queue until now. */
|
|
|
|
if (!(flags & RFSTOPPED)) {
|
|
|
|
thread_lock(newtd);
|
|
|
|
sched_add(newtd, SRQ_BORING);
|
|
|
|
thread_unlock(newtd);
|
|
|
|
}
|
|
|
|
if (newtdp)
|
|
|
|
*newtdp = newtd;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2007-10-26 17:03:22 +00:00
|
|
|
kthread_exit(void)
|
2007-10-26 08:00:41 +00:00
|
|
|
{
|
2007-11-15 21:45:17 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
2010-02-19 14:59:41 +00:00
|
|
|
p = curthread->td_proc;
|
|
|
|
|
2007-11-15 21:45:17 +00:00
|
|
|
/* A module may be waiting for us to exit. */
|
2007-10-27 00:54:16 +00:00
|
|
|
wakeup(curthread);
|
2011-01-03 16:29:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The last exiting thread in a kernel process must tear down
|
|
|
|
* the whole process.
|
|
|
|
*/
|
2010-10-23 13:16:39 +00:00
|
|
|
rw_wlock(&tidhash_lock);
|
2007-11-15 21:45:17 +00:00
|
|
|
PROC_LOCK(p);
|
2010-02-19 15:10:05 +00:00
|
|
|
if (p->p_numthreads == 1) {
|
2010-02-19 14:59:41 +00:00
|
|
|
PROC_UNLOCK(p);
|
2010-10-23 13:16:39 +00:00
|
|
|
rw_wunlock(&tidhash_lock);
|
2010-02-19 14:59:41 +00:00
|
|
|
kproc_exit(0);
|
|
|
|
}
|
2010-10-23 13:16:39 +00:00
|
|
|
LIST_REMOVE(curthread, td_hash);
|
|
|
|
rw_wunlock(&tidhash_lock);
|
2015-02-28 04:19:02 +00:00
|
|
|
umtx_thread_exit(curthread);
|
2007-11-15 21:45:17 +00:00
|
|
|
PROC_SLOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
thread_exit();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Advise a kernel process to suspend (or resume) in its main loop.
|
|
|
|
* Participation is voluntary.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
kthread_suspend(struct thread *td, int timo)
|
|
|
|
{
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
/*
|
2010-02-19 15:03:55 +00:00
|
|
|
* td_pflags should not be read by any thread other than
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
* curthread, but as long as this flag is invariant during the
|
2010-02-19 15:03:55 +00:00
|
|
|
* thread's lifetime, it is OK to check its state.
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
*/
|
|
|
|
if ((td->td_pflags & TDP_KTHREAD) == 0)
|
2007-10-26 08:00:41 +00:00
|
|
|
return (EINVAL);
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The caller of the primitive should have already checked that the
|
|
|
|
* thread is up and running, thus not being blocked by other
|
|
|
|
* conditions.
|
|
|
|
*/
|
|
|
|
PROC_LOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
thread_lock(td);
|
|
|
|
td->td_flags |= TDF_KTH_SUSP;
|
|
|
|
thread_unlock(td);
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
return (msleep(&td->td_flags, &p->p_mtx, PPAUSE | PDROP, "suspkt",
|
|
|
|
timo));
|
2007-10-26 08:00:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
* Resume a thread previously put asleep with kthread_suspend().
|
2007-10-26 08:00:41 +00:00
|
|
|
*/
|
|
|
|
int
|
|
|
|
kthread_resume(struct thread *td)
|
|
|
|
{
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
/*
|
2010-02-19 15:03:55 +00:00
|
|
|
* td_pflags should not be read by any thread other than
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
* curthread, but as long as this flag is invariant during the
|
2010-02-19 15:03:55 +00:00
|
|
|
* thread's lifetime, it is OK to check its state.
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
*/
|
|
|
|
if ((td->td_pflags & TDP_KTHREAD) == 0)
|
2007-10-26 08:00:41 +00:00
|
|
|
return (EINVAL);
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
|
|
|
|
PROC_LOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
thread_lock(td);
|
|
|
|
td->td_flags &= ~TDF_KTH_SUSP;
|
|
|
|
thread_unlock(td);
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
wakeup(&td->td_flags);
|
|
|
|
PROC_UNLOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Used by the thread to poll as to whether it should yield/sleep
|
|
|
|
* and notify the caller that is has happened.
|
|
|
|
*/
|
|
|
|
void
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
kthread_suspend_check()
|
2007-10-26 08:00:41 +00:00
|
|
|
{
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
struct proc *p;
|
|
|
|
struct thread *td;
|
|
|
|
|
|
|
|
td = curthread;
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
if ((td->td_pflags & TDP_KTHREAD) == 0)
|
|
|
|
panic("%s: curthread is not a valid kthread", __func__);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* As long as the double-lock protection is used when accessing the
|
|
|
|
* TDF_KTH_SUSP flag, synchronizing the read operation via proc mutex
|
|
|
|
* is fine.
|
|
|
|
*/
|
|
|
|
PROC_LOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
while (td->td_flags & TDF_KTH_SUSP) {
|
|
|
|
wakeup(&td->td_flags);
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
msleep(&td->td_flags, &p->p_mtx, PPAUSE, "ktsusp", 0);
|
2007-10-26 08:00:41 +00:00
|
|
|
}
|
- Fix the kthread_{suspend, resume, suspend_check}() locking.
In the current code, the locking is completely broken and may lead
easilly to deadlocks. Fix it by using the proc_mtx, linked to the
suspending thread, as lock for the operation. Keep using the
thread_lock for setting and reading the flag even if it is not entirely
necessary (atomic ops may do it as well, but this way the code is more
readable).
- Fix a deadlock within kthread_suspend().
The suspender should not sleep on a different channel wrt the suspended
thread, or, otherwise, the awaker should wakeup both. Uniform the
interface to what the kproc_* counterparts do (sleeping on the same
channel).
- Change the kthread_suspend_check() prototype.
kthread_suspend_check() always assumes curthread and must only refer to
it, so skip the thread pointer as it may be easilly mistaken.
If curthread is not a kthread, the system will panic.
In collabouration with: jhb
Tested by: Giovanni Trematerra
<giovanni dot trematerra at gmail dot com>
MFC: 2 weeks
2010-01-24 15:07:00 +00:00
|
|
|
PROC_UNLOCK(p);
|
2007-10-26 08:00:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
kproc_kthread_add(void (*func)(void *), void *arg,
|
|
|
|
struct proc **procptr, struct thread **tdptr,
|
2010-05-21 17:14:36 +00:00
|
|
|
int flags, int pages, const char *procname, const char *fmt, ...)
|
2007-10-26 08:00:41 +00:00
|
|
|
{
|
|
|
|
int error;
|
|
|
|
va_list ap;
|
|
|
|
char buf[100];
|
|
|
|
struct thread *td;
|
|
|
|
|
|
|
|
if (*procptr == 0) {
|
|
|
|
error = kproc_create(func, arg,
|
|
|
|
procptr, flags, pages, "%s", procname);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
td = FIRST_THREAD_IN_PROC(*procptr);
|
2008-04-29 22:43:15 +00:00
|
|
|
if (tdptr)
|
|
|
|
*tdptr = td;
|
2007-10-26 08:00:41 +00:00
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(td->td_name, sizeof(td->td_name), fmt, ap);
|
|
|
|
va_end(ap);
|
2012-03-08 19:41:05 +00:00
|
|
|
#ifdef KTR
|
|
|
|
sched_clear_tdname(td);
|
|
|
|
#endif
|
2007-10-26 08:00:41 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(buf, sizeof(buf), fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
error = kthread_add(func, arg, *procptr,
|
|
|
|
tdptr, flags, pages, "%s", buf);
|
|
|
|
return (error);
|
|
|
|
}
|