sys/kern/kern_kthread.c

   1 /*
   2  * Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD: src/sys/kern/kern_kthread.c,v 1.5.2.3 2001/12/25 01:51:14 dillon Exp $
  27  * $DragonFly: src/sys/kern/kern_kthread.c,v 1.13 2006/12/18 20:41:01 dillon Exp $
  28  */
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/proc.h>
  33 #include <sys/kthread.h>
  34 #include <sys/ptrace.h>
  35 #include <sys/resourcevar.h>
  36 #include <sys/signalvar.h>
  37 #include <sys/unistd.h>
  38 #include <sys/wait.h>
  39
  40 #include <machine/stdarg.h>
  41
  42 static struct lwkt_token kpsus_token = LWKT_TOKEN_INITIALIZER(kpsus_token);
  43
  44
  45 /*
  46  * Create a new lightweight kernel thread.
  47  */
  48 static int
  49 _kthread_create(void (*func)(void *), void *arg,
  50     struct thread **tdp, int cpu, const char *fmt, __va_list ap)
  51 {
  52     thread_t td;
  53     int flags = 0;
  54
  55     if (bootverbose)
  56         atomic_set_int(&flags, TDF_VERBOSE);
  57
  58     td = lwkt_alloc_thread(NULL, LWKT_THREAD_STACK, cpu, flags);
  59     if (tdp)
  60         *tdp = td;
  61     cpu_set_thread_handler(td, kthread_exit, func, arg);
  62
  63     /*
  64      * Set up arg0 for 'ps' etc
  65      */
  66     kvsnprintf(td->td_comm, sizeof(td->td_comm), fmt, ap);
  67
  68     td->td_ucred = crhold(proc0.p_ucred);
  69
  70     /*
  71      * Schedule the thread to run
  72      */
  73     lwkt_schedule(td);
  74
  75     return 0;
  76 }
  77
  78 /*
  79  * Creates a lwkt. No CPU preference.
  80  */
  81 int
  82 kthread_create(void (*func)(void *), void *arg,
  83                struct thread **tdp, const char *fmt, ...)
  84 {
  85         __va_list ap;
  86         int ret;
  87
  88         __va_start(ap, fmt);
  89         ret = _kthread_create(func, arg, tdp, -1, fmt, ap);
  90         __va_end(ap);
  91
  92         return ret;
  93 }
  94
  95 /*
  96  * Creates a lwkt and schedule it to run in a specific CPU.
  97  *
  98  */
  99 int
 100 kthread_create_cpu(void (*func)(void *), void *arg,
 101                    struct thread **tdp, int cpu, const char *fmt, ...)
 102 {
 103         __va_list ap;
 104         int ret;
 105
 106         __va_start(ap, fmt);
 107         ret = _kthread_create(func, arg, tdp, cpu, fmt, ap);
 108         __va_end(ap);
 109
 110         return ret;
 111 }
 112
 113 #if 0
 114 /*
 115  * Same as kthread_create() but you can specify a custom stack size.
 116  */
 117 int
 118 kthread_create_stk(void (*func)(void *), void *arg,
 119                    struct thread **tdp, int stksize, const char *fmt, ...)
 120 {
 121     thread_t td;
 122     __va_list ap;
 123
 124     td = lwkt_alloc_thread(NULL, stksize, -1, TDF_VERBOSE);
 125     if (tdp)
 126         *tdp = td;
 127     cpu_set_thread_handler(td, kthread_exit, func, arg);
 128
 129     __va_start(ap, fmt);
 130     kvsnprintf(td->td_comm, sizeof(td->td_comm), fmt, ap);
 131     __va_end(ap);
 132
 133     lwkt_schedule(td);
 134     return 0;
 135 }
 136 #endif
 137
 138 /*
 139  * Destroy an LWKT thread.   Warning!  This function is not called when
 140  * a process exits, cpu_proc_exit() directly calls cpu_thread_exit() and
 141  * uses a different reaping mechanism.
 142  *
 143  * XXX duplicates lwkt_exit()
 144  */
 145 void
 146 kthread_exit(void)
 147 {
 148     lwkt_exit();
 149 }
 150
 151 /*
 152  * Start a kernel process.  This is called after a fork() call in
 153  * mi_startup() in the file kern/init_main.c.
 154  *
 155  * This function is used to start "internal" daemons and intended
 156  * to be called from SYSINIT().
 157  *
 158  * These threads are created MPSAFE.
 159  */
 160 void
 161 kproc_start(const void *udata)
 162 {
 163         const struct kproc_desc *kp = udata;
 164         int error;
 165
 166         error = kthread_create((void (*)(void *))kp->func, NULL,
 167                                 kp->global_threadpp, kp->arg0);
 168         lwkt_setpri(*kp->global_threadpp, TDPRI_KERN_DAEMON);
 169         if (error)
 170                 panic("kproc_start: %s: error %d", kp->arg0, error);
 171 }
 172
 173 /*
 174  * Advise a kernel process to suspend (or resume) in its main loop.
 175  * Participation is voluntary.
 176  */
 177 int
 178 suspend_kproc(struct thread *td, int timo)
 179 {
 180         if (td->td_proc == NULL) {
 181                 lwkt_gettoken(&kpsus_token);
 182                 /* request thread pause */
 183                 atomic_set_int(&td->td_mpflags, TDF_MP_STOPREQ);
 184                 wakeup(td);
 185                 while (td->td_mpflags & TDF_MP_STOPREQ) {
 186                         int error = tsleep(td, 0, "suspkp", timo);
 187                         if (error == EWOULDBLOCK)
 188                                 break;
 189                 }
 190                 atomic_clear_int(&td->td_mpflags, TDF_MP_STOPREQ);
 191                 lwkt_reltoken(&kpsus_token);
 192                 return(0);
 193         } else {
 194                 return(EINVAL); /* not a kernel thread */
 195         }
 196 }
 197
 198 void
 199 kproc_suspend_loop(void)
 200 {
 201         struct thread *td = curthread;
 202
 203         if (td->td_mpflags & TDF_MP_STOPREQ) {
 204                 lwkt_gettoken(&kpsus_token);
 205                 atomic_clear_int(&td->td_mpflags, TDF_MP_STOPREQ);
 206                 while ((td->td_mpflags & TDF_MP_WAKEREQ) == 0) {
 207                         wakeup(td);
 208                         tsleep(td, 0, "kpsusp", 0);
 209                 }
 210                 atomic_clear_int(&td->td_mpflags, TDF_MP_WAKEREQ);
 211                 wakeup(td);
 212                 lwkt_reltoken(&kpsus_token);
 213         }
 214 }
 215