sys/kern/kern_kthread.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 1999 Peter Wemm <peter@FreeBSD.org>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/cpuset.h>
  32 #include <sys/kthread.h>
  33 #include <sys/lock.h>
  34 #include <sys/mutex.h>
  35 #include <sys/proc.h>
  36 #include <sys/resourcevar.h>
  37 #include <sys/rwlock.h>
  38 #include <sys/signalvar.h>
  39 #include <sys/sysent.h>
  40 #include <sys/sx.h>
  41 #include <sys/umtxvar.h>
  42 #include <sys/unistd.h>
  43 #include <sys/wait.h>
  44 #include <sys/sched.h>
  45 #include <sys/tslog.h>
  46 #include <vm/vm.h>
  47 #include <vm/vm_extern.h>
  48
  49 #include <machine/stdarg.h>
  50
  51 /*
  52  * Start a kernel process.  This is called after a fork() call in
  53  * mi_startup() in the file kern/init_main.c.
  54  *
  55  * This function is used to start "internal" daemons and intended
  56  * to be called from SYSINIT().
  57  */
  58 void
  59 kproc_start(const void *udata)
  60 {
  61         const struct kproc_desc *kp = udata;
  62         int error;
  63
  64         error = kproc_create((void (*)(void *))kp->func, NULL,
  65             kp->global_procpp, 0, 0, "%s", kp->arg0);
  66         if (error)
  67                 panic("kproc_start: %s: error %d", kp->arg0, error);
  68 }
  69
  70 /*
  71  * Create a kernel process/thread/whatever.  It shares its address space
  72  * with proc0 - ie: kernel only.
  73  *
  74  * func is the function to start.
  75  * arg is the parameter to pass to function on first startup.
  76  * newpp is the return value pointing to the thread's struct proc.
  77  * flags are flags to fork1 (in unistd.h)
  78  * fmt and following will be *printf'd into (*newpp)->p_comm (for ps, etc.).
  79  */
  80 static int
  81 kproc_create1(void (*func)(void *), void *arg,
  82     struct proc **newpp, int flags, int pages, const char *tdname)
  83 {
  84         struct fork_req fr;
  85         int error;
  86         struct thread *td;
  87         struct proc *p2;
  88
  89         if (!proc0.p_stats)
  90                 panic("kproc_create called too soon");
  91
  92         bzero(&fr, sizeof(fr));
  93         fr.fr_flags = RFMEM | RFFDG | RFPROC | RFSTOPPED | flags;
  94         fr.fr_flags2 = FR2_KPROC;
  95         fr.fr_pages = pages;
  96         fr.fr_procp = &p2;
  97         error = fork1(&thread0, &fr);
  98         if (error != 0)
  99                 return (error);
 100
 101         /* save a global descriptor, if desired */
 102         if (newpp != NULL)
 103                 *newpp = p2;
 104
 105         /* set up arg0 for 'ps', et al */
 106         strcpy(p2->p_comm, tdname);
 107         td = FIRST_THREAD_IN_PROC(p2);
 108         strcpy(td->td_name, tdname);
 109 #ifdef KTR
 110         sched_clear_tdname(td);
 111 #endif
 112         TSTHREAD(td, td->td_name);
 113 #ifdef HWPMC_HOOKS
 114         if (PMC_SYSTEM_SAMPLING_ACTIVE()) {
 115                 PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_PROC_CREATE_LOG, p2);
 116                 PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_THR_CREATE_LOG, NULL);
 117         }
 118 #endif
 119
 120         /* call the processes' main()... */
 121         cpu_fork_kthread_handler(td, func, arg);
 122
 123         /* Avoid inheriting affinity from a random parent. */
 124         cpuset_kernthread(td);
 125         thread_lock(td);
 126         TD_SET_CAN_RUN(td);
 127         sched_prio(td, PVM);
 128         sched_user_prio(td, PUSER);
 129
 130         /* Delay putting it on the run queue until now. */
 131         if ((flags & RFSTOPPED) == 0)
 132                 sched_add(td, SRQ_BORING);
 133         else
 134                 thread_unlock(td);
 135
 136         return (0);
 137 }
 138
 139 int
 140 kproc_create(void (*func)(void *), void *arg,
 141     struct proc **newpp, int flags, int pages, const char *fmt, ...)
 142 {
 143         va_list ap;
 144         int error;
 145         char tdname[MAXCOMLEN + 1];
 146
 147         va_start(ap, fmt);
 148         vsnprintf(tdname, sizeof(tdname), fmt, ap);
 149         va_end(ap);
 150         DROP_GIANT();
 151         error = kproc_create1(func, arg, newpp, flags, pages, tdname);
 152         PICKUP_GIANT();
 153         return (error);
 154 }
 155
 156 void
 157 kproc_exit(int ecode)
 158 {
 159         struct thread *td;
 160         struct proc *p;
 161
 162         td = curthread;
 163         p = td->td_proc;
 164
 165         /*
 166          * Reparent curthread from proc0 to init so that the zombie
 167          * is harvested.
 168          */
 169         sx_xlock(&proctree_lock);
 170         PROC_LOCK(p);
 171         proc_reparent(p, initproc, true);
 172         PROC_UNLOCK(p);
 173         sx_xunlock(&proctree_lock);
 174
 175         /*
 176          * Wakeup anyone waiting for us to exit.
 177          */
 178         wakeup(p);
 179
 180         /* Buh-bye! */
 181         exit1(td, ecode, 0);
 182 }
 183
 184 /*
 185  * Advise a kernel process to suspend (or resume) in its main loop.
 186  * Participation is voluntary.
 187  */
 188 int
 189 kproc_suspend(struct proc *p, int timo)
 190 {
 191         /*
 192          * Make sure this is indeed a system process and we can safely
 193          * use the p_siglist field.
 194          */
 195         PROC_LOCK(p);
 196         if ((p->p_flag & P_KPROC) == 0) {
 197                 PROC_UNLOCK(p);
 198                 return (EINVAL);
 199         }
 200         SIGADDSET(p->p_siglist, SIGSTOP);
 201         wakeup(p);
 202         return (msleep(&p->p_siglist, &p->p_mtx, PPAUSE | PDROP,
 203             "suspkp", timo));
 204 }
 205
 206 int
 207 kproc_resume(struct proc *p)
 208 {
 209         /*
 210          * Make sure this is indeed a system process and we can safely
 211          * use the p_siglist field.
 212          */
 213         PROC_LOCK(p);
 214         if ((p->p_flag & P_KPROC) == 0) {
 215                 PROC_UNLOCK(p);
 216                 return (EINVAL);
 217         }
 218         SIGDELSET(p->p_siglist, SIGSTOP);
 219         PROC_UNLOCK(p);
 220         wakeup(&p->p_siglist);
 221         return (0);
 222 }
 223
 224 void
 225 kproc_suspend_check(struct proc *p)
 226 {
 227         PROC_LOCK(p);
 228         while (SIGISMEMBER(p->p_siglist, SIGSTOP)) {
 229                 wakeup(&p->p_siglist);
 230                 msleep(&p->p_siglist, &p->p_mtx, PPAUSE, "kpsusp", 0);
 231         }
 232         PROC_UNLOCK(p);
 233 }
 234
 235 /*
 236  * Start a kernel thread.
 237  *
 238  * This function is used to start "internal" daemons and intended
 239  * to be called from SYSINIT().
 240  */
 241
 242 void
 243 kthread_start(const void *udata)
 244 {
 245         const struct kthread_desc *kp = udata;
 246         int error;
 247
 248         error = kthread_add((void (*)(void *))kp->func, NULL,
 249             NULL, kp->global_threadpp, 0, 0, "%s", kp->arg0);
 250         if (error)
 251                 panic("kthread_start: %s: error %d", kp->arg0, error);
 252 }
 253
 254 /*
 255  * Create a kernel thread.  It shares its address space
 256  * with proc0 - ie: kernel only.
 257  *
 258  * func is the function to start.
 259  * arg is the parameter to pass to function on first startup.
 260  * newtdp is the return value pointing to the thread's struct thread.
 261  *  ** XXX fix this --> flags are flags to fork1 (in unistd.h)
 262  * fmt and following will be *printf'd into (*newtd)->td_name (for ps, etc.).
 263  */
 264 static int
 265 kthread_add1(void (*func)(void *), void *arg, struct proc *p,
 266     struct thread **newtdp, int flags, int pages, const char *tdname)
 267 {
 268         struct thread *newtd, *oldtd;
 269
 270         if (!proc0.p_stats)
 271                 panic("kthread_add called too soon");
 272
 273         /* If no process supplied, put it on proc0 */
 274         if (p == NULL)
 275                 p = &proc0;
 276
 277         /* Initialize our new td  */
 278         newtd = thread_alloc(pages);
 279         if (newtd == NULL)
 280                 return (ENOMEM);
 281
 282         PROC_LOCK(p);
 283         if (p->p_state == PRS_ZOMBIE || (p->p_flag2 & P2_WEXIT) != 0) {
 284                 PROC_UNLOCK(p);
 285                 return (ESRCH);
 286         }
 287         oldtd = FIRST_THREAD_IN_PROC(p);
 288
 289         bzero(&newtd->td_startzero,
 290             __rangeof(struct thread, td_startzero, td_endzero));
 291         bcopy(&oldtd->td_startcopy, &newtd->td_startcopy,
 292             __rangeof(struct thread, td_startcopy, td_endcopy));
 293
 294         /* set up arg0 for 'ps', et al */
 295         strcpy(newtd->td_name, tdname);
 296
 297         TSTHREAD(newtd, newtd->td_name);
 298
 299         newtd->td_proc = p;  /* needed for cpu_copy_thread */
 300         newtd->td_pflags |= TDP_KTHREAD;
 301
 302         /* might be further optimized for kthread */
 303         cpu_copy_thread(newtd, oldtd);
 304
 305         /* put the designated function(arg) as the resume context */
 306         cpu_fork_kthread_handler(newtd, func, arg);
 307
 308         thread_cow_get_proc(newtd, p);
 309
 310         /* This code is similar to thread_create() in kern_thr.c. */
 311         p->p_flag |= P_HADTHREADS;
 312         thread_link(newtd, p);
 313         thread_lock(oldtd);
 314         /* let the scheduler know about these things. */
 315         sched_fork_thread(oldtd, newtd);
 316         TD_SET_CAN_RUN(newtd);
 317         thread_unlock(oldtd);
 318         PROC_UNLOCK(p);
 319
 320         tidhash_add(newtd);
 321
 322         /* Avoid inheriting affinity from a random parent. */
 323         cpuset_kernthread(newtd);
 324 #ifdef HWPMC_HOOKS
 325         if (PMC_SYSTEM_SAMPLING_ACTIVE())
 326                 PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_THR_CREATE_LOG, NULL);
 327 #endif
 328         /* Delay putting it on the run queue until now. */
 329         if ((flags & RFSTOPPED) == 0) {
 330                 thread_lock(newtd);
 331                 sched_add(newtd, SRQ_BORING);
 332         }
 333         if (newtdp)
 334                 *newtdp = newtd;
 335         return (0);
 336 }
 337
 338 int
 339 kthread_add(void (*func)(void *), void *arg, struct proc *p,
 340     struct thread **newtdp, int flags, int pages, const char *fmt, ...)
 341 {
 342         va_list ap;
 343         int error;
 344         char tdname[MAXCOMLEN + 1];
 345
 346         va_start(ap, fmt);
 347         vsnprintf(tdname, sizeof(tdname), fmt, ap);
 348         va_end(ap);
 349         DROP_GIANT();
 350         error = kthread_add1(func, arg, p, newtdp, flags, pages, tdname);
 351         PICKUP_GIANT();
 352         return (error);
 353 }
 354
 355 void
 356 kthread_exit(void)
 357 {
 358         struct proc *p;
 359         struct thread *td;
 360
 361         td = curthread;
 362         p = td->td_proc;
 363
 364 #ifdef HWPMC_HOOKS
 365         if (PMC_SYSTEM_SAMPLING_ACTIVE())
 366                 PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_THR_EXIT_LOG, NULL);
 367 #endif
 368         /* A module may be waiting for us to exit. */
 369         wakeup(td);
 370
 371         /*
 372          * The last exiting thread in a kernel process must tear down
 373          * the whole process.
 374          */
 375         PROC_LOCK(p);
 376         if (p->p_numthreads == 1) {
 377                 PROC_UNLOCK(p);
 378                 kproc_exit(0);
 379         }
 380
 381         if (p->p_sysent->sv_ontdexit != NULL)
 382                 p->p_sysent->sv_ontdexit(td);
 383
 384         tidhash_remove(td);
 385         umtx_thread_exit(td);
 386         tdsigcleanup(td);
 387         PROC_SLOCK(p);
 388         thread_exit();
 389 }
 390
 391 /*
 392  * Advise a kernel process to suspend (or resume) in its main loop.
 393  * Participation is voluntary.
 394  */
 395 int
 396 kthread_suspend(struct thread *td, int timo)
 397 {
 398         struct proc *p;
 399
 400         p = td->td_proc;
 401
 402         /*
 403          * td_pflags should not be read by any thread other than
 404          * curthread, but as long as this flag is invariant during the
 405          * thread's lifetime, it is OK to check its state.
 406          */
 407         if ((td->td_pflags & TDP_KTHREAD) == 0)
 408                 return (EINVAL);
 409
 410         /*
 411          * The caller of the primitive should have already checked that the
 412          * thread is up and running, thus not being blocked by other
 413          * conditions.
 414          */
 415         PROC_LOCK(p);
 416         thread_lock(td);
 417         td->td_flags |= TDF_KTH_SUSP;
 418         thread_unlock(td);
 419         return (msleep(&td->td_flags, &p->p_mtx, PPAUSE | PDROP, "suspkt",
 420             timo));
 421 }
 422
 423 /*
 424  * Resume a thread previously put asleep with kthread_suspend().
 425  */
 426 int
 427 kthread_resume(struct thread *td)
 428 {
 429         struct proc *p;
 430
 431         p = td->td_proc;
 432
 433         /*
 434          * td_pflags should not be read by any thread other than
 435          * curthread, but as long as this flag is invariant during the
 436          * thread's lifetime, it is OK to check its state.
 437          */
 438         if ((td->td_pflags & TDP_KTHREAD) == 0)
 439                 return (EINVAL);
 440
 441         PROC_LOCK(p);
 442         thread_lock(td);
 443         td->td_flags &= ~TDF_KTH_SUSP;
 444         thread_unlock(td);
 445         wakeup(&td->td_flags);
 446         PROC_UNLOCK(p);
 447         return (0);
 448 }
 449
 450 /*
 451  * Used by the thread to poll as to whether it should yield/sleep
 452  * and notify the caller that is has happened.
 453  */
 454 void
 455 kthread_suspend_check(void)
 456 {
 457         struct proc *p;
 458         struct thread *td;
 459
 460         td = curthread;
 461         p = td->td_proc;
 462
 463         if ((td->td_pflags & TDP_KTHREAD) == 0)
 464                 panic("%s: curthread is not a valid kthread", __func__);
 465
 466         /*
 467          * Setting the TDF_KTH_SUSP flag is protected by process lock.
 468          *
 469          * Do an unlocked read first to avoid serializing with all other threads
 470          * in the common case of not suspending.
 471          */
 472         if ((td->td_flags & TDF_KTH_SUSP) == 0)
 473                 return;
 474         PROC_LOCK(p);
 475         while ((td->td_flags & TDF_KTH_SUSP) != 0) {
 476                 wakeup(&td->td_flags);
 477                 msleep(&td->td_flags, &p->p_mtx, PPAUSE, "ktsusp", 0);
 478         }
 479         PROC_UNLOCK(p);
 480 }
 481
 482 int
 483 kproc_kthread_add(void (*func)(void *), void *arg,
 484     struct proc **procptr, struct thread **tdptr,
 485     int flags, int pages, const char *procname, const char *fmt, ...)
 486 {
 487         int error;
 488         va_list ap;
 489         char buf[100];
 490         struct thread *td;
 491
 492         if (*procptr == NULL) {
 493                 error = kproc_create(func, arg,
 494                     procptr, flags, pages, "%s", procname);
 495                 if (error)
 496                         return (error);
 497                 td = FIRST_THREAD_IN_PROC(*procptr);
 498                 if (tdptr)
 499                         *tdptr = td;
 500                 va_start(ap, fmt);
 501                 vsnprintf(td->td_name, sizeof(td->td_name), fmt, ap);
 502                 va_end(ap);
 503 #ifdef KTR
 504                 sched_clear_tdname(td);
 505 #endif
 506                 return (0);
 507         }
 508         va_start(ap, fmt);
 509         vsnprintf(buf, sizeof(buf), fmt, ap);
 510         va_end(ap);
 511         error = kthread_add(func, arg, *procptr,
 512             tdptr, flags, pages, "%s", buf);
 513         return (error);
 514 }