 @@ -1,14 +1,14 @@
-/* $NetBSD: acpi_cpu_md.c,v 1.79 2018/11/10 09:42:42 maxv Exp $ */
+/* $NetBSD: acpi_cpu_md.c,v 1.80 2019/10/06 15:11:17 uwe Exp $ */
 /*-
  * Copyright (c) 2010, 2011 Jukka Ruohonen <jruohonen@iki.fi>
  * 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
 @@ -17,27 +17,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_md.c,v 1.79 2018/11/10 09:42:42 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_cpu_md.c,v 1.80 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpufreq.h>
 #include <sys/device.h>
 #include <sys/kcore.h>
 #include <sys/sysctl.h>
 #include <sys/xcall.h>
 #include <x86/cpu.h>
 #include <x86/cpufunc.h>
 #include <x86/cputypes.h>
 #include <x86/cpuvar.h>
 @@ -368,43 +368,41 @@ acpicpu_md_cstate_start(struct acpicpu_s
+		}
+	}
 	x86_cpu_idle_set(acpicpu_cstate_idle, "acpi", ipi);
 	return 0;
+}
 int
 acpicpu_md_cstate_stop(void)
+{
 	static char text[16];
 	void (*func)(void);
 	uint64_t xc;
 	bool ipi;
 	x86_cpu_idle_get(&func, text, sizeof(text));
 	if (func == native_idle)
 		return EALREADY;
 	ipi = (native_idle != x86_cpu_idle_halt) ? false : true;
 	x86_cpu_idle_set(native_idle, native_idle_text, ipi);
 	/*
 	 * Run a cross-call to ensure that all CPUs are
 	 * out from the ACPI idle-loop before detachment.
 	 */
-	xc = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(xc);
 	return 0;
+}
 /*
  * Called with interrupts enabled.
  */
 void
 acpicpu_md_cstate_enter(int method, int state)
+{
 	struct cpu_info *ci = curcpu();
 	KASSERT(ci->ci_ilevel == IPL_NONE);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_lwp.c,v 1.204 2019/10/03 22:48:44 kamil Exp $	*/
+/*	$NetBSD: kern_lwp.c,v 1.205 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2001, 2006, 2007, 2008, 2009 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -201,27 +201,27 @@
  *	(But not always for kernel threads.  There are some special cases
  *	as mentioned above.  See kern_softint.c.)
+ *
  *	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.204 2019/10/03 22:48:44 kamil Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_lwp.c,v 1.205 2019/10/06 15:11:17 uwe 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>
 @@ -357,40 +357,38 @@ lwp0_init(void)
 	kauth_cred_hold(proc0.p_cred);
 	l->l_cred = proc0.p_cred;
 	kdtrace_thread_ctor(NULL, l);
 	lwp_initspecific(l);
 	SYSCALL_TIME_LWP_INIT(l);
+}
 static void
 lwp_dtor(void *arg, void *obj)
+{
 	lwp_t *l = obj;
 	uint64_t where;
 	(void)l;
 	/*
 	 * Provide a barrier to ensure that all mutex_oncpu() and rw_oncpu()
 	 * calls will exit before memory of LWP is returned to the pool, where
 	 * KVA of LWP structure might be freed and re-used for other purposes.
 	 * Kernel preemption is disabled around mutex_oncpu() and rw_oncpu()
 	 * callers, therefore cross-call to all CPUs will do the job.  Also,
 	 * the value of l->l_cpu must be still valid at this point.
 	 */
 	KASSERT(l->l_cpu != NULL);
-	where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(where);
+}
 /*
  * Set an suspended.
+ *
  * Must be called with p_lock held, and the LWP locked.  Will unlock the
  * LWP before return.
  */
 int
 lwp_suspend(struct lwp *curl, struct lwp *t)
+{
 	int error;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_ras.c,v 1.38 2016/07/04 07:56:07 maxv Exp $	*/
+/*	$NetBSD: kern_ras.c,v 1.39 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2002, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Gregory McGarry, and by 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,27 +20,27 @@
  * ``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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_ras.c,v 1.38 2016/07/04 07:56:07 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_ras.c,v 1.39 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/proc.h>
 #include <sys/ras.h>
 #include <sys/xcall.h>
 #include <sys/syscallargs.h>
 #include <uvm/uvm_extern.h>
 #define MAX_RAS_PER_PROC	16
 @@ -56,29 +56,27 @@ int ras_debug = 0;
 /*
  * Force all CPUs through cpu_switchto(), waiting until complete.
  * Context switching will drain the write buffer on the calling
  * CPU.
  */
 static void
 ras_sync(void)
+{
 	/* No need to sync if exiting or single threaded. */
 	if (curproc->p_nlwps > 1 && ncpu > 1) {
 #ifdef NO_SOFTWARE_PATENTS
-		uint64_t where;
+		xc_barrier(0);
 		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
 		xc_wait(where);
 #else
 		/*
 		 * Assumptions:
+		 *
 		 * o preemption is disabled by the thread in
 		 *   ras_lookup().
 		 * o proc::p_raslist is only inspected with
 		 *   preemption disabled.
 		 * o ras_lookup() plus loads reordered in advance
 		 *   will take no longer than 1/8s to complete.
 		 */
 		const int delta = hz >> 3;
 		int target = hardclock_ticks + delta;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_softint.c,v 1.47 2019/05/17 03:34:26 ozaki-r Exp $	*/
+/*	$NetBSD: kern_softint.c,v 1.48 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -160,27 +160,27 @@
  *		    interrupt;
  *	}
+ *
  *	Once the soft interrupt has fired (and even if it has blocked),
  *	no further soft interrupts at that level will be triggered by
  *	MI code until the soft interrupt handler has ceased execution.
  *	If a soft interrupt handler blocks and is resumed, it resumes
  *	execution as a normal LWP (kthread) and gains VM context.  Only
  *	when it has completed and is ready to fire again will it
  *	interrupt other threads.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.47 2019/05/17 03:34:26 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_softint.c,v 1.48 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/intr.h>
 #include <sys/ipi.h>
 #include <sys/mutex.h>
 #include <sys/kernel.h>
 #include <sys/kthread.h>
 #include <sys/evcnt.h>
 #include <sys/cpu.h>
 #include <sys/xcall.h>
 #include <sys/pserialize.h>
 @@ -397,53 +397,51 @@ softint_establish(u_int flags, void (*fu
  *	and trigger it again once this call is made.  The caller must not
  *	hold any locks that could be taken from soft interrupt context,
  *	because we will wait for the softint to complete if it's still
  *	running.
  */
 void
 softint_disestablish(void *arg)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	softcpu_t *sc;
 	softhand_t *sh;
 	uintptr_t offset;
 	uint64_t where;
 	u_int flags;
 	offset = (uintptr_t)arg;
 	KASSERTMSG(offset != 0 && offset < softint_bytes, "%"PRIuPTR" %u",
 	    offset, softint_bytes);
 	/*
 	 * Unregister an IPI handler if there is any.  Note: there is
 	 * no need to disable preemption here - ID is stable.
 	 */
 	sc = curcpu()->ci_data.cpu_softcpu;
 	sh = (softhand_t *)((uint8_t *)sc + offset);
 	if (sh->sh_ipi_id) {
 		ipi_unregister(sh->sh_ipi_id);
+	}
 	/*
 	 * Run a cross call so we see up to date values of sh_flags from
 	 * all CPUs.  Once softint_disestablish() is called, the caller
 	 * commits to not trigger the interrupt and set SOFTINT_ACTIVE on
 	 * it again.  So, we are only looking for handler records with
 	 * SOFTINT_ACTIVE already set.
 	 */
 	if (__predict_true(mp_online)) {
-		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+		xc_barrier(0);
 		xc_wait(where);
+	}
 	for (;;) {
 		/* Collect flag values from each CPU. */
 		flags = 0;
 		for (CPU_INFO_FOREACH(cii, ci)) {
 			sc = ci->ci_data.cpu_softcpu;
 			sh = (softhand_t *)((uint8_t *)sc + offset);
 			KASSERT(sh->sh_func != NULL);
 			flags |= sh->sh_flags;
+		}
 		/* Inactive on all CPUs? */
 		if ((flags & SOFTINT_ACTIVE) == 0) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_syscall.c,v 1.18 2019/05/06 08:05:03 kamil Exp $	*/
+/*	$NetBSD: kern_syscall.c,v 1.19 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software developed for The NetBSD Foundation
  * by 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -20,27 +20,27 @@
  * ``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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_syscall.c,v 1.18 2019/05/06 08:05:03 kamil Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_syscall.c,v 1.19 2019/10/06 15:11:17 uwe Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_modular.h"
 #include "opt_syscall_debug.h"
 #include "opt_ktrace.h"
 #include "opt_ptrace.h"
 #include "opt_dtrace.h"
 #endif
 /* XXX To get syscall prototypes. */
 #define SYSVSHM
 #define SYSVSEM
 #define SYSVMSG
 @@ -136,27 +136,26 @@ syscall_establish(const struct emul *em,
 	/* Everything looks good, patch them in. */
 	for (i = 0; sp[i].sp_call != NULL; i++) {
 		sy[sp[i].sp_code].sy_call = sp[i].sp_call;
+	}
 	return 0;
+}
 int
 syscall_disestablish(const struct emul *em, const struct syscall_package *sp)
+{
 	struct sysent *sy;
 	const uint32_t *sb;
 	uint64_t where;
 	lwp_t *l;
 	int i;
 	KASSERT(kernconfig_is_held());
 	if (em == NULL) {
 		em = &emul_netbsd;
+	}
 	sy = em->e_sysent;
 	sb = em->e_nomodbits;
 	/*
 	 * First, patch the system calls to sys_nomodule or sys_nosys
 @@ -165,28 +164,27 @@ syscall_disestablish(const struct emul *
 	for (i = 0; sp[i].sp_call != NULL; i++) {
 		KASSERT(sy[sp[i].sp_code].sy_call == sp[i].sp_call);
 		sy[sp[i].sp_code].sy_call =
 		    sb[sp[i].sp_code / 32] & (1 << (sp[i].sp_code % 32)) ?
 		      sys_nomodule : sys_nosys;
+	}
 	/*
 	 * Run a cross call to cycle through all CPUs.  This does two
 	 * things: lock activity provides a barrier and makes our update
 	 * of sy_call visible to all CPUs, and upon return we can be sure
 	 * that we see pertinent values of l_sysent posted by remote CPUs.
 	 */
-	where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(where);
 	/*
 	 * Now it's safe to check l_sysent.  Run through all LWPs and see
 	 * if anyone is still using the system call.
 	 */
 	for (i = 0; sp[i].sp_call != NULL; i++) {
 		mutex_enter(proc_lock);
 		LIST_FOREACH(l, &alllwp, l_list) {
 			if (l->l_sysent == &sy[sp[i].sp_code]) {
 				break;
+			}
+		}
 		mutex_exit(proc_lock);

 @@ -1,14 +1,14 @@
-/* $NetBSD: kern_tc.c,v 1.51 2018/07/01 15:12:06 riastradh Exp $ */
+/* $NetBSD: kern_tc.c,v 1.52 2019/10/06 15:11:17 uwe Exp $ */
 /*-
  * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -30,27 +30,27 @@
  */
 /*-
  * ----------------------------------------------------------------------------
  * "THE BEER-WARE LICENSE" (Revision 42):
  * <phk@FreeBSD.ORG> wrote this file.  As long as you retain this notice you
  * can do whatever you want with this stuff. If we meet some day, and you think
  * this stuff is worth it, you can buy me a beer in return.   Poul-Henning Kamp
  * ---------------------------------------------------------------------------
  */
 #include <sys/cdefs.h>
 /* __FBSDID("$FreeBSD: src/sys/kern/kern_tc.c,v 1.166 2005/09/19 22:16:31 andre Exp $"); */
-__KERNEL_RCSID(0, "$NetBSD: kern_tc.c,v 1.51 2018/07/01 15:12:06 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_tc.c,v 1.52 2019/10/06 15:11:17 uwe Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_ntp.h"
 #endif
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/reboot.h>	/* XXX just to get AB_VERBOSE */
 #include <sys/sysctl.h>
 #include <sys/syslog.h>
 #include <sys/systm.h>
 #include <sys/timepps.h>
 #include <sys/timetc.h>
 @@ -599,27 +599,26 @@ tc_gonebad(struct timecounter *tc)
 	membar_producer();
 	atomic_inc_uint(&timecounter_bad);
+}
 /*
  * Stop using a timecounter and remove it from the timecounters list.
  */
 int
 tc_detach(struct timecounter *target)
+{
 	struct timecounter *tc;
 	struct timecounter **tcp = NULL;
 	int removals;
 	uint64_t where;
 	lwp_t *l;
 	/* First, find the timecounter. */
 	mutex_spin_enter(&timecounter_lock);
 	for (tcp = &timecounters, tc = timecounters;
 	     tc != NULL;
 	     tcp = &tc->tc_next, tc = tc->tc_next) {
 		if (tc == target)
 			break;
+	}
 	if (tc == NULL) {
 		mutex_spin_exit(&timecounter_lock);
 		return ESRCH;
 @@ -642,28 +641,27 @@ tc_detach(struct timecounter *target)
 	 * We issue a broadcast cross call to elide memory ordering issues,
 	 * then scan all LWPs in the system looking at each's timecounter
 	 * generation number.  We need to see a value of zero (not actively
 	 * using a timecounter) or a value greater than our removal value.
+	 *
 	 * We may race with threads that read `timecounter_removals' and
 	 * and then get preempted before updating `l_tcgen'.  This is not
 	 * a problem, since it means that these threads have not yet started
 	 * accessing timecounter state.  All we do need is one clean
 	 * snapshot of the system where every thread appears not to be using
 	 * old timecounter state.
 	 */
 	for (;;) {
-		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+		xc_barrier(0);
 		xc_wait(where);
 		mutex_enter(proc_lock);
 		LIST_FOREACH(l, &alllwp, l_list) {
 			if (l->l_tcgen == 0 || l->l_tcgen > removals) {
 				/*
 				 * Not using timecounter or old timecounter
 				 * state at time of our xcall or later.
 				 */
 				continue;
+			}
 			break;
+		}
 		mutex_exit(proc_lock);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_pserialize.c,v 1.12 2018/08/14 01:06:01 ozaki-r Exp $	*/
+/*	$NetBSD: subr_pserialize.c,v 1.13 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2010, 2011 The NetBSD Foundation, Inc.
  * 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.
 @@ -28,27 +28,27 @@
 /*
  * Passive serialization.
+ *
  * Implementation accurately matches the lapsed US patent 4809168, therefore
  * code is patent-free in the United States.  Your use of this code is at
  * your own risk.
+ *
  * Note for NetBSD developers: all changes to this source file must be
  * approved by the <core>.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_pserialize.c,v 1.12 2018/08/14 01:06:01 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_pserialize.c,v 1.13 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/condvar.h>
 #include <sys/cpu.h>
 #include <sys/evcnt.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/pserialize.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/xcall.h>
 @@ -137,27 +137,26 @@ pserialize_destroy(pserialize_t psz)
 /*
  * pserialize_perform:
+ *
  *	Perform the write side of passive serialization.  The calling
  *	thread holds an exclusive lock on the data object(s) being updated.
  *	We wait until every processor in the system has made at least two
  *	passes through cpu_switchto().  The wait is made with the caller's
  *	update lock held, but is short term.
  */
 void
 pserialize_perform(pserialize_t psz)
+{
 	int n;
 	uint64_t xc;
 	KASSERT(!cpu_intr_p());
 	KASSERT(!cpu_softintr_p());
 	if (__predict_false(panicstr != NULL)) {
 		return;
+	}
 	KASSERT(psz->psz_owner == NULL);
 	KASSERT(ncpu > 0);
 	if (__predict_false(mp_online == false)) {
 		psz_ev_excl.ev_count++;
 		return;
 @@ -177,28 +176,27 @@ pserialize_perform(pserialize_t psz)
 	TAILQ_INSERT_TAIL(&psz_queue0, psz, psz_chain);
 	psz_work_todo++;
 	n = 0;
 	do {
 		mutex_spin_exit(&psz_lock);
 		/*
 		 * Force some context switch activity on every CPU, as
 		 * the system may not be busy.  Pause to not flood.
 		 */
 		if (n++ > 1)
 			kpause("psrlz", false, 1, NULL);
-		xc = xc_broadcast(XC_HIGHPRI, (xcfunc_t)nullop, NULL, NULL);
+		xc_barrier(XC_HIGHPRI);
 		xc_wait(xc);
 		mutex_spin_enter(&psz_lock);
 	} while (!kcpuset_iszero(psz->psz_target));
 	psz_ev_excl.ev_count++;
 	mutex_spin_exit(&psz_lock);
 	psz->psz_owner = NULL;
+}
 int
 pserialize_read_enter(void)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: subr_xcall.c,v 1.26 2018/02/07 04:25:09 ozaki-r Exp $	*/
+/*	$NetBSD: subr_xcall.c,v 1.27 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 2007-2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran and Mindaugas Rasiukevicius.
+ *
  * 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.
 @@ -64,27 +64,27 @@
  *	CPU, and so has exclusive access to the CPU.  Since this facility
  *	is heavyweight, it's expected that it will not be used often.
+ *
  *	Cross calls must not allocate memory, as the pagedaemon uses
  *	them (and memory allocation may need to wait on the pagedaemon).
+ *
  *	A low-overhead mechanism for high priority calls (XC_HIGHPRI) is
  *	also provided.  The function to be executed runs on a software
  *	interrupt context, at IPL_SOFTSERIAL level, and is expected to
  *	be very lightweight, e.g. avoid blocking.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: subr_xcall.c,v 1.26 2018/02/07 04:25:09 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: subr_xcall.c,v 1.27 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/xcall.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/evcnt.h>
 #include <sys/kthread.h>
 #include <sys/cpu.h>
 #ifdef _RUMPKERNEL
 #include "rump_private.h"
 #endif
 @@ -257,26 +257,50 @@ xc_broadcast(unsigned int flags, xcfunc_
+{
 	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
 	ASSERT_SLEEPABLE();
 	if ((flags & XC_HIGHPRI) != 0) {
 		int ipl = xc_extract_ipl(flags);
 		return xc_highpri(func, arg1, arg2, NULL, ipl);
 	} else {
 		return xc_lowpri(func, arg1, arg2, NULL);
+	}
+}
 static void
 xc_nop(void *arg1, void *arg2)
+{
     return;
+}
 /*
  * xc_barrier:
+ *
  *	Broadcast a nop to all CPUs in the system.
  */
 void
 xc_barrier(unsigned int flags)
+{
 	uint64_t where;
 	where = xc_broadcast(flags, xc_nop, NULL, NULL);
 	xc_wait(where);
+}
 /*
  * xc_unicast:
+ *
  *	Trigger a call on one CPU.
  */
 uint64_t
 xc_unicast(unsigned int flags, xcfunc_t func, void *arg1, void *arg2,
 	   struct cpu_info *ci)
+{
 	KASSERT(ci != NULL);
 	KASSERT(!cpu_intr_p() && !cpu_softintr_p());
 	ASSERT_SLEEPABLE();

 @@ -1,14 +1,14 @@
-/*	$NetBSD: if.c,v 1.462 2019/09/25 09:53:37 ozaki-r Exp $	*/
+/*	$NetBSD: if.c,v 1.463 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c) 1999, 2000, 2001, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by William Studenmund and Jason R. Thorpe.
+ *
  * 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.
 @@ -80,27 +80,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS 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.
+ *
  *	@(#)if.c	8.5 (Berkeley) 1/9/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if.c,v 1.462 2019/09/25 09:53:37 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if.c,v 1.463 2019/10/06 15:11:17 uwe Exp $");
 #if defined(_KERNEL_OPT)
 #include "opt_inet.h"
 #include "opt_ipsec.h"
 #include "opt_atalk.h"
 #include "opt_wlan.h"
 #include "opt_net_mpsafe.h"
 #include "opt_mrouting.h"
 #endif
 #include <sys/param.h>
 #include <sys/mbuf.h>
 #include <sys/systm.h>
 @@ -1297,27 +1297,26 @@ if_check_and_free_ifa_list(struct ifnet
  * as it may block.
  */
 void
 if_detach(struct ifnet *ifp)
+{
 	struct socket so;
 	struct ifaddr *ifa;
 #ifdef IFAREF_DEBUG
 	struct ifaddr *last_ifa = NULL;
 #endif
 	struct domain *dp;
 	const struct protosw *pr;
 	int s, i, family, purged;
 	uint64_t xc;
 #ifdef IFAREF_DEBUG
 	if_build_ifa_list(ifp);
 #endif
 	/*
 	 * XXX It's kind of lame that we have to have the
 	 * XXX socket structure...
 	 */
 	memset(&so, 0, sizeof(so));
 	s = splnet();
 	sysctl_teardown(&ifp->if_sysctl_log);
 @@ -1503,28 +1502,27 @@ restart:
 	/*
 	 * IP queues have to be processed separately: net-queue barrier
 	 * ensures that the packets are dequeued while a cross-call will
 	 * ensure that the interrupts have completed. FIXME: not quite..
 	 */
 #ifdef INET
 	pktq_barrier(ip_pktq);
 #endif
 #ifdef INET6
 	if (in6_present)
 		pktq_barrier(ip6_pktq);
 #endif
-	xc = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(xc);
 	if (ifp->if_percpuq != NULL) {
 		if_percpuq_destroy(ifp->if_percpuq);
 		ifp->if_percpuq = NULL;
+	}
 	mutex_obj_free(ifp->if_ioctl_lock);
 	ifp->if_ioctl_lock = NULL;
 	mutex_obj_free(ifp->if_snd.ifq_lock);
 	splx(s);
 #ifdef IFAREF_DEBUG

 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_agr.c,v 1.49 2019/04/26 11:51:56 pgoyette Exp $	*/
+/*	$NetBSD: if_agr.c,v 1.50 2019/10/06 15:11:17 uwe Exp $	*/
 /*-
  * Copyright (c)2005 YAMAMOTO Takashi,
  * 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.
 @@ -17,27 +17,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_agr.c,v 1.49 2019/04/26 11:51:56 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_agr.c,v 1.50 2019/10/06 15:11:17 uwe Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #endif
 #include <sys/param.h>
 #include <sys/callout.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/systm.h>
 #include <sys/types.h>
 #include <sys/queue.h>
 #include <sys/sockio.h>
 @@ -884,33 +884,31 @@ agrreq_copyout(void *ubuf, struct agrreq
 	error = copyout(ar, ubuf, sizeof(*ar));
 	if (error) {
 		return error;
+	}
 	return 0;
+}
 /* Make sure that if any interrupt handlers are out of the softc. */
 static void
 agr_sync(void)
+{
 	uint64_t h;
 	if (!mp_online)
 		return;
-	h = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(h);
+}
 static int
 agr_pause(struct agr_softc *sc)
+{
 	int error;
 	mutex_enter(&sc->sc_entry_mtx);
 	if ((error = sc->sc_noentry) != 0)
 		goto out;
 	sc->sc_noentry = EBUSY;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: crypto.c,v 1.109 2019/10/01 18:00:09 chs Exp $ */
+/*	$NetBSD: crypto.c,v 1.110 2019/10/06 15:11:17 uwe Exp $ */
 /*	$FreeBSD: src/sys/opencrypto/crypto.c,v 1.4.2.5 2003/02/26 00:14:05 sam Exp $	*/
 /*	$OpenBSD: crypto.c,v 1.41 2002/07/17 23:52:38 art Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Coyote Point Systems, Inc.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -43,27 +43,27 @@
  * Permission to use, copy, and modify this software with or without fee
  * is hereby granted, provided that this entire notice is included in
  * all source code copies of any software which is or includes a copy or
  * modification of this software.
+ *
  * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR
  * IMPLIED WARRANTY. IN PARTICULAR, NONE OF THE AUTHORS MAKES ANY
  * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE
  * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR
  * PURPOSE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: crypto.c,v 1.109 2019/10/01 18:00:09 chs Exp $");
+__KERNEL_RCSID(0, "$NetBSD: crypto.c,v 1.110 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/reboot.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/pool.h>
 #include <sys/kthread.h>
 #include <sys/once.h>
 #include <sys/sysctl.h>
 #include <sys/intr.h>
 #include <sys/errno.h>
 #include <sys/module.h>
 #include <sys/xcall.h>
 @@ -608,27 +608,26 @@ crypto_init(void)
+{
 	static ONCE_DECL(crypto_init_once);
 	return RUN_ONCE(&crypto_init_once, crypto_init0);
+}
 static int
 crypto_destroy(bool exit_kthread)
+{
 	int i;
 	if (exit_kthread) {
 		struct cryptocap *cap = NULL;
 		uint64_t where;
 		bool is_busy = false;
 		/* if we have any in-progress requests, don't unload */
 		percpu_foreach(crypto_crp_qs_percpu, crypto_crp_q_is_busy_pc,
 				   &is_busy);
 		if (is_busy)
 			return EBUSY;
 		/* FIXME:
 		 * prohibit enqueue to crp_q and crp_kq after here.
 		 */
 		mutex_enter(&crypto_drv_mtx);
 		for (i = 0; i < crypto_drivers_num; i++) {
 @@ -647,28 +646,27 @@ crypto_destroy(bool exit_kthread)
 		/*
 		 * Ensure cryptoret_softint() is never scheduled and then wait
 		 * for last softint_execute().
 		 */
 		for (i = 0; i < ncpu; i++) {
 			struct crypto_crp_ret_qs *qs;
 			struct cpu_info *ci = cpu_lookup(i);
 			qs = crypto_get_crp_ret_qs(ci);
 			qs->crp_ret_q_exit_flag = true;
 			crypto_put_crp_ret_qs(ci);
+		}
-		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+		xc_barrier(0);
 		xc_wait(where);
+	}
 	if (sysctl_opencrypto_clog != NULL)
 		sysctl_teardown(&sysctl_opencrypto_clog);
 	if (crypto_ret_si != NULL)
 		softint_disestablish(crypto_ret_si);
 	if (crypto_q_si != NULL)
 		softint_disestablish(crypto_q_si);
 	mutex_enter(&crypto_drv_mtx);
 	if (crypto_drivers != NULL)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sysproxy.c,v 1.7 2019/05/17 03:34:26 ozaki-r Exp $	*/
+/*	$NetBSD: sysproxy.c,v 1.8 2019/10/06 15:11:17 uwe Exp $	*/
 /*
  * Copyright (c) 2010, 2011 Antti Kantee.  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.
+ *
 @@ -16,27 +16,27 @@
  * 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sysproxy.c,v 1.7 2019/05/17 03:34:26 ozaki-r Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sysproxy.c,v 1.8 2019/10/06 15:11:17 uwe Exp $");
 #include <sys/param.h>
 #include <sys/filedesc.h>
 #include <sys/kmem.h>
 #include <sys/syscall.h>
 #include <sys/syscallvar.h>
 #include <sys/systm.h>
 #include <sys/xcall.h>
 #include <sys/lockdebug.h>
 #include <sys/psref.h>
 #define _RUMP_SYSPROXY
 #include <rump/rumpuser.h>
 @@ -131,50 +131,48 @@ hyp_rfork(void *priv, int flags, const c
 	if (initfds)
 		rump_consdev_init();
 	return 0;
+}
 /*
  * Order all lwps in a process to exit.  does *not* wait for them to drain.
  */
 static void
 hyp_lwpexit(void)
+{
 	struct proc *p = curproc;
 	uint64_t where;
 	struct lwp *l;
 	mutex_enter(p->p_lock);
 	/*
 	 * First pass: mark all lwps in the process with LW_RUMP_QEXIT
 	 * so that they know they should exit.
 	 */
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 		if (l == curlwp)
 			continue;
 		l->l_flag |= LW_RUMP_QEXIT;
+	}
 	mutex_exit(p->p_lock);
 	/*
 	 * Next, make sure everyone on all CPUs sees our status
 	 * update.  This keeps threads inside cv_wait() and makes
 	 * sure we don't access a stale cv pointer later when
 	 * we wake up the threads.
 	 */
-	where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
+	xc_barrier(0);
 	xc_wait(where);
 	/*
 	 * Ok, all lwps are either:
 	 *  1) not in the cv code
 	 *  2) sleeping on l->l_private
 	 *  3) sleeping on p->p_waitcv
+	 *
 	 * Either way, l_private is stable until we set PS_RUMP_LWPEXIT
 	 * in p->p_sflag.
 	 */
 	mutex_enter(p->p_lock);
 	LIST_FOREACH(l, &p->p_lwps, l_sibling) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: xcall.h,v 1.7 2018/08/27 07:10:15 riastradh Exp $	*/
+/*	$NetBSD: xcall.h,v 1.8 2019/10/06 15:11:16 uwe Exp $	*/
 /*-
  * Copyright (c) 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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
  *    notice, this list of conditions and the following disclaimer.
 @@ -43,18 +43,20 @@ typedef void (*xcfunc_t)(void *, void *)
 struct cpu_info;
 void		xc_init_cpu(struct cpu_info *);
 void		xc_send_ipi(struct cpu_info *);
 void		xc_ipi_handler(void);
 void		xc__highpri_intr(void *);
 uint64_t	xc_broadcast(u_int, xcfunc_t, void *, void *);
 uint64_t	xc_unicast(u_int, xcfunc_t, void *, void *, struct cpu_info *);
 void		xc_wait(uint64_t);
 void		xc_barrier(u_int);
 unsigned int	xc_encode_ipl(int);
 #endif	/* _KERNEL */
 #endif	/* _SYS_XCALL_H_ */