 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lwp.c,v 1.221 2020/01/26 19:06:24 ad Exp $	*/
+/*	$NetBSD: kern_lwp.c,v 1.222 2020/01/27 21:58:16 ad Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008, 2009, 2019, 2020
  *     The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Nathan J. Williams, and Andrew Doran.
+ *
  * 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
 @@ -201,27 +201,27 @@
  *	(But not always for kernel threads.  There are some special cases
  *	as mentioned above: soft interrupts, and the idle loops.)
+ *
  *	Note that an LWP is considered running or likely to run soon if in
  *	one of the following states.  This affects the value of p_nrlwps:
+ *
  *		LSRUN, LSONPROC, LSSLEEP
+ *
  *	p_lock does not need to be held when transitioning among these
  *	three states, hence p_lock is rarely taken for state transitions.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.221 2020/01/26 19:06:24 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.222 2020/01/27 21:58:16 ad Exp $");
 #include "opt_ddb.h"
 #include "opt_lockdebug.h"
 #include "opt_dtrace.h"
 #define _LWP_API_PRIVATE
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/cpu.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/syscallargs.h>
 @@ -643,38 +643,34 @@ lwp_wait(struct lwp *l, lwpid_t lid, lwp
 		if (error != 0)
 			break;
 		if (nfound == 0) {
 			error = ESRCH;
 			break;
+		}
 		/*
 		 * Note: since the lock will be dropped, need to restart on
 		 * wakeup to run all LWPs again, e.g. there may be new LWPs.
 		 */
 		if (exiting) {
 			KASSERT(p->p_nlwps > 1);
-			cv_wait(&p->p_lwpcv, p->p_lock);
+			error = cv_timedwait(&p->p_lwpcv, p->p_lock, 1);
 			error = EAGAIN;
 			break;
+		}
 		/*
 		 * If all other LWPs are waiting for exits or suspends
 		 * and the supply of zombies and potential zombies is
 		 * exhausted, then we are about to deadlock.
 		 * If the process is exiting (and this LWP is not the one
 		 * that is coordinating the exit) then bail out now.
 		 */
 		if ((p->p_sflag & PS_WEXIT) != 0 ||
 		    p->p_nrlwps + p->p_nzlwps - p->p_ndlwps <= p->p_nlwpwait) {
 			error = EDEADLK;
 			break;
+		}
 		/*
 		 * Sit around and wait for something to happen.  We'll be
 		 * awoken if any of the conditions examined change: if an
 		 * LWP exits, is collected, or is detached.
 		 */
 		if ((error = cv_wait_sig(&p->p_lwpcv, p->p_lock)) != 0)
 @@ -829,27 +825,27 @@ lwp_create(lwp_t *l1, proc_t *p2, vaddr_
 	l2->l_class = sclass;
 	/*
 	 * If vfork(), we want the LWP to run fast and on the same CPU
 	 * as its parent, so that it can reuse the VM context and cache
 	 * footprint on the local CPU.
 	 */
 	l2->l_kpriority = ((flags & LWP_VFORK) ? true : false);
 	l2->l_kpribase = PRI_KERNEL;
 	l2->l_priority = l1->l_priority;
 	l2->l_inheritedprio = -1;
 	l2->l_protectprio = -1;
 	l2->l_auxprio = -1;
-	l2->l_flag = (l1->l_flag & (LW_WEXIT | LW_WREBOOT | LW_WCORE));
+	l2->l_flag = 0;
 	l2->l_pflag = LP_MPSAFE;
 	TAILQ_INIT(&l2->l_ld_locks);
 	l2->l_psrefs = 0;
 	kmsan_lwp_alloc(l2);
 	/*
 	 * For vfork, borrow parent's lwpctl context if it exists.
 	 * This also causes us to return via lwp_userret.
 	 */
 	if (flags & LWP_VFORK && l1->l_lwpctl) {
 		l2->l_lwpctl = l1->l_lwpctl;
 		l2->l_flag |= LW_LWPCTL;
+	}
 @@ -911,26 +907,31 @@ lwp_create(lwp_t *l1, proc_t *p2, vaddr_
 		p2->p_nlwpid = lid + 1;
 	} else {
 		lid = 0;
+	}
 	mutex_enter(p2->p_lock);
 	if ((flags & LWP_DETACHED) != 0) {
 		l2->l_prflag = LPR_DETACHED;
 		p2->p_ndlwps++;
 	} else
 		l2->l_prflag = 0;
 	if (l1->l_proc == p2)
 		l2->l_flag |= (l1->l_flag & (LW_WEXIT | LW_WREBOOT | LW_WCORE));
 	else
 		l2->l_flag |= (l1->l_flag & LW_WREBOOT);
 	l2->l_sigstk = *sigstk;
 	l2->l_sigmask = *sigmask;
 	TAILQ_INIT(&l2->l_sigpend.sp_info);
 	sigemptyset(&l2->l_sigpend.sp_set);
 	if (__predict_true(lid == 0)) {
 		/*
 		 * XXX: l_lid are expected to be unique (for a process)
 		 * if LWP_PIDLID is sometimes set this won't be true.
 		 * Once 2^31 threads have been allocated we have to
 		 * scan to ensure we allocate a unique value.
 		 */
 		lid = ++p2->p_nlwpid;