 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_condvar.c,v 1.45 2020/04/10 17:16:21 ad Exp $	*/
+/*	$NetBSD: kern_condvar.c,v 1.46 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 2006, 2007, 2008, 2019, 2020 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.
 @@ -24,27 +24,27 @@
  * 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.
  */
 /*
  * Kernel condition variable implementation.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.45 2020/04/10 17:16:21 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_condvar.c,v 1.46 2020/04/13 15:54:45 maxv Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/lwp.h>
 #include <sys/condvar.h>
 #include <sys/sleepq.h>
 #include <sys/lockdebug.h>
 #include <sys/cpu.h>
 #include <sys/kernel.h>
 /*
  * Accessors for the private contents of the kcondvar_t data type.
+ *
 @@ -330,33 +330,33 @@ timo2bintime(unsigned timo)
  */
 int
 cv_timedwaitbt(kcondvar_t *cv, kmutex_t *mtx, struct bintime *bt,
     const struct bintime *epsilon __diagused)
+{
 	struct bintime slept;
 	unsigned start, end;
 	int error;
 	KASSERTMSG(bt->sec >= 0, "negative timeout");
 	KASSERTMSG(epsilon != NULL, "specify maximum requested delay");
 	/*
-	 * hardclock_ticks is technically int, but nothing special
+	 * getticks() is technically int, but nothing special
 	 * happens instead of overflow, so we assume two's-complement
 	 * wraparound and just treat it as unsigned.
 	 */
-	start = hardclock_ticks;
+	start = getticks();
 	error = cv_timedwait(cv, mtx, bintime2timo(bt));
-	end = hardclock_ticks;
+	end = getticks();
 	slept = timo2bintime(end - start);
 	/* bt := bt - slept */
 	bintime_sub(bt, &slept);
 	return error;
+}
 /*
  * cv_timedwaitbt_sig:
+ *
  *	Wait on a condition variable until awoken, the specified
  *	timeout expires, or interrupted by a signal.  Returns zero if
 @@ -373,33 +373,33 @@ cv_timedwaitbt(kcondvar_t *cv, kmutex_t
  */
 int
 cv_timedwaitbt_sig(kcondvar_t *cv, kmutex_t *mtx, struct bintime *bt,
     const struct bintime *epsilon __diagused)
+{
 	struct bintime slept;
 	unsigned start, end;
 	int error;
 	KASSERTMSG(bt->sec >= 0, "negative timeout");
 	KASSERTMSG(epsilon != NULL, "specify maximum requested delay");
 	/*
-	 * hardclock_ticks is technically int, but nothing special
+	 * getticks() is technically int, but nothing special
 	 * happens instead of overflow, so we assume two's-complement
 	 * wraparound and just treat it as unsigned.
 	 */
-	start = hardclock_ticks;
+	start = getticks();
 	error = cv_timedwait_sig(cv, mtx, bintime2timo(bt));
-	end = hardclock_ticks;
+	end = getticks();
 	slept = timo2bintime(end - start);
 	/* bt := bt - slept */
 	bintime_sub(bt, &slept);
 	return error;
+}
 /*
  * cv_signal:
+ *
  *	Wake the highest priority LWP waiting on a condition variable.
  *	Must be called with the interlocking mutex held.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_runq.c,v 1.65 2020/04/04 20:17:58 ad Exp $	*/
+/*	$NetBSD: kern_runq.c,v 1.66 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 2019, 2020 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.
 @@ -46,27 +46,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: kern_runq.c,v 1.65 2020/04/04 20:17:58 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_runq.c,v 1.66 2020/04/13 15:54:45 maxv Exp $");
 #include "opt_dtrace.h"
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/bitops.h>
 #include <sys/cpu.h>
 #include <sys/idle.h>
 #include <sys/intr.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 @@ -407,27 +407,27 @@ sched_resched_lwp(struct lwp *l, bool un
  * Estimate if LWP is cache-hot.
  */
 static inline bool
 lwp_cache_hot(const struct lwp *l)
+{
 	/* Leave new LWPs in peace, determination has already been made. */
 	if (l->l_stat == LSIDL)
 		return true;
 	if (__predict_false(l->l_slptime != 0 || l->l_rticks == 0))
 		return false;
-	return (hardclock_ticks - l->l_rticks < mstohz(cacheht_time));
+	return (getticks() - l->l_rticks < mstohz(cacheht_time));
+}
 /*
  * Check if LWP can migrate to the chosen CPU.
  */
 static inline bool
 sched_migratable(const struct lwp *l, struct cpu_info *ci)
+{
 	const struct schedstate_percpu *spc = &ci->ci_schedstate;
 	KASSERT(lwp_locked(__UNCONST(l), NULL));
 	/* Is CPU offline? */
 	if (__predict_false(spc->spc_flags & SPCF_OFFLINE))
 @@ -830,30 +830,30 @@ sched_idle(void)
 		    spc->spc_psid == PS_NONE) {
 			return;
+		}
+	}
 	/*
 	 * Find something to run, unless this CPU exceeded the rate limit.
 	 * Start looking on the current package to maximise L2/L3 cache
 	 * locality.  Then expand to looking at the rest of the system.
+	 *
 	 * XXX Should probably look at 2nd class CPUs first, but they will
 	 * shed jobs via preempt() anyway.
 	 */
-	if (spc->spc_nextskim > hardclock_ticks) {
+	if (spc->spc_nextskim > getticks()) {
 		return;
+	}
-	spc->spc_nextskim = hardclock_ticks + mstohz(skim_interval);
+	spc->spc_nextskim = getticks() + mstohz(skim_interval);
 	/* In the outer loop scroll through all CPU packages, starting here. */
 	first = ci->ci_package1st;
 	outer = first;
 	do {
 		/* In the inner loop scroll through all CPUs in package. */
 		inner = outer;
 		do {
 			/* Don't hit the locks unless needed. */
 			tspc = &inner->ci_schedstate;
 			if (ci == inner || ci == mci ||
 			    spc->spc_psid != tspc->spc_psid ||
 			    tspc->spc_mcount < min_catch) {
 @@ -1047,45 +1047,45 @@ sched_lwp_stats(struct lwp *l)
 /*
  * Scheduler mill.
  */
 struct lwp *
 sched_nextlwp(void)
+{
 	struct cpu_info *ci = curcpu();
 	struct schedstate_percpu *spc;
 	TAILQ_HEAD(, lwp) *q_head;
 	struct lwp *l;
 	/* Update the last run time on switch */
 	l = curlwp;
-	l->l_rticksum += (hardclock_ticks - l->l_rticks);
+	l->l_rticksum += (getticks() - l->l_rticks);
 	/* Return to idle LWP if there is a migrating thread */
 	spc = &ci->ci_schedstate;
 	if (__predict_false(spc->spc_migrating != NULL))
 		return NULL;
 	/* Return to idle LWP if there is no runnable job */
 	if (__predict_false(spc->spc_count == 0))
 		return NULL;
 	/* Take the highest priority thread */
 	KASSERT(spc->spc_bitmap[spc->spc_maxpriority >> BITMAP_SHIFT]);
 	q_head = sched_getrq(spc, spc->spc_maxpriority);
 	l = TAILQ_FIRST(q_head);
 	KASSERT(l != NULL);
 	sched_oncpu(l);
-	l->l_rticks = hardclock_ticks;
+	l->l_rticks = getticks();
 	return l;
+}
 /*
  * sched_curcpu_runnable_p: return if curcpu() should exit the idle loop.
  */
 bool
 sched_curcpu_runnable_p(void)
+{
 	const struct cpu_info *ci;
 	const struct schedstate_percpu *spc;
 @@ -1194,19 +1194,19 @@ sched_print_runqueue(void (*pr)(const ch
 	(*pr)("   %5s %4s %4s %10s %3s %18s %4s %4s %s\n",
 	    "LID", "PRI", "EPRI", "FL", "ST", "LWP", "CPU", "TCI", "LRTICKS");
 	PROCLIST_FOREACH(p, &allproc) {
 		(*pr)(" /- %d (%s)\n", (int)p->p_pid, p->p_comm);
 		LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 			ci = l->l_cpu;
 			tci = l->l_target_cpu;
 			(*pr)(" | %5d %4u %4u 0x%8.8x %3s %18p %4u %4d %u\n",
 			    (int)l->l_lid, l->l_priority, lwp_eprio(l),
 			    l->l_flag, l->l_stat == LSRUN ? "RQ" :
 			    (l->l_stat == LSSLEEP ? "SQ" : "-"),
 			    l, ci->ci_index, (tci ? tci->ci_index : -1),
-			    (u_int)(hardclock_ticks - l->l_rticks));
+			    (u_int)(getticks() - l->l_rticks));
+		}
+	}
+}
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_sleepq.c,v 1.64 2020/04/10 17:16:21 ad Exp $	*/
+/*	$NetBSD: kern_sleepq.c,v 1.65 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 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 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.
 @@ -25,27 +25,27 @@
  * 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.
  */
 /*
  * Sleep queue implementation, used by turnstiles and general sleep/wakeup
  * interfaces.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.64 2020/04/10 17:16:21 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_sleepq.c,v 1.65 2020/04/13 15:54:45 maxv Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/cpu.h>
 #include <sys/intr.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/resourcevar.h>
 #include <sys/sched.h>
 #include <sys/systm.h>
 #include <sys/sleepq.h>
 #include <sys/ktrace.h>
 @@ -141,27 +141,27 @@ sleepq_remove(sleepq_t *sq, lwp_t *l)
 	/*
 	 * If the LWP is still on the CPU, mark it as LSONPROC.  It may be
 	 * about to call mi_switch(), in which case it will yield.
 	 */
 	if ((l->l_pflag & LP_RUNNING) != 0) {
 		l->l_stat = LSONPROC;
 		l->l_slptime = 0;
 		lwp_setlock(l, spc->spc_lwplock);
 		return;
+	}
 	/* Update sleep time delta, call the wake-up handler of scheduler */
-	l->l_slpticksum += (hardclock_ticks - l->l_slpticks);
+	l->l_slpticksum += (getticks() - l->l_slpticks);
 	sched_wakeup(l);
 	/* Look for a CPU to wake up */
 	l->l_cpu = sched_takecpu(l);
 	ci = l->l_cpu;
 	spc = &ci->ci_schedstate;
 	/*
 	 * Set it running.
 	 */
 	spc_lock(ci);
 	lwp_setlock(l, spc->spc_mutex);
 	sched_setrunnable(l);
 @@ -218,27 +218,27 @@ sleepq_enqueue(sleepq_t *sq, wchan_t wch
 	KASSERT(l->l_stat == LSONPROC);
 	KASSERT(l->l_wchan == NULL && l->l_sleepq == NULL);
 	l->l_syncobj = sobj;
 	l->l_wchan = wchan;
 	l->l_sleepq = sq;
 	l->l_wmesg = wmesg;
 	l->l_slptime = 0;
 	l->l_stat = LSSLEEP;
 	sleepq_insert(sq, l, sobj);
 	/* Save the time when thread has slept */
-	l->l_slpticks = hardclock_ticks;
+	l->l_slpticks = getticks();
 	sched_slept(l);
+}
 /*
  * sleepq_block:
+ *
  *	After any intermediate step such as releasing an interlock, switch.
  * 	sleepq_block() may return early under exceptional conditions, for
  * 	example if the LWP's containing process is exiting.
+ *
  *	timo is a timeout in ticks.  timo = 0 specifies an infinite timeout.
  */
 int

 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_timeout.c,v 1.59 2020/03/21 02:32:37 ad Exp $	*/
+/*	$NetBSD: kern_timeout.c,v 1.60 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 2003, 2006, 2007, 2008, 2009, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe, 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.
 @@ -49,27 +49,27 @@
  * THIS SOFTWARE IS PROVIDED ``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 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_timeout.c,v 1.59 2020/03/21 02:32:37 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_timeout.c,v 1.60 2020/04/13 15:54:45 maxv Exp $");
 /*
  * Timeouts are kept in a hierarchical timing wheel.  The c_time is the
  * value of c_cpu->cc_ticks when the timeout should be called.  There are
  * four levels with 256 buckets each. See 'Scheme 7' in "Hashed and
  * Hierarchical Timing Wheels: Efficient Data Structures for Implementing
  * a Timer Facility" by George Varghese and Tony Lauck.
+ *
  * Some of the "math" in here is a bit tricky.  We have to beware of
  * wrapping ints.
+ *
  * We use the fact that any element added to the queue must be added with
  * a positive time.  That means that any element `to' on the queue cannot
 @@ -829,27 +829,27 @@ db_show_callout_bucket(struct callout_cp
 		if (CIRCQ_LAST(&c->c_list, kbucket))
 			break;
+	}
+}
 void
 db_show_callout(db_expr_t addr, bool haddr, db_expr_t count, const char *modif)
+{
 	struct callout_cpu *cc, ccb;
 	struct cpu_info *ci, cib;
 	int b;
 #ifndef CRASH
-	db_printf("hardclock_ticks now: %d\n", hardclock_ticks);
+	db_printf("hardclock_ticks now: %d\n", getticks());
 #endif
 	db_printf("    ticks  wheel               arg  func\n");
 	/*
 	 * Don't lock the callwheel; all the other CPUs are paused
 	 * anyhow, and we might be called in a circumstance where
 	 * some other CPU was paused while holding the lock.
 	 */
 	for (ci = db_cpu_first(); ci != NULL; ci = db_cpu_next(ci)) {
 		db_read_bytes((db_addr_t)ci, sizeof(cib), (char *)&cib);
 		cc = cib.ci_data.cpu_callout;
 		db_read_bytes((db_addr_t)cc, sizeof(ccb), (char *)&ccb);
 		db_show_callout_bucket(&ccb, &cc->cc_todo, &ccb.cc_todo);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: sched_m2.c,v 1.37 2019/12/06 18:33:19 ad Exp $	*/
+/*	$NetBSD: sched_m2.c,v 1.38 2020/04/13 15:54:45 maxv Exp $	*/
 /*
  * Copyright (c) 2007, 2008 Mindaugas Rasiukevicius <rmind at NetBSD 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.
 @@ -23,27 +23,27 @@
  * 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.
  */
 /*
  * TODO:
  *  - Implementation of fair share queue;
  *  - Support for NUMA;
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: sched_m2.c,v 1.37 2019/12/06 18:33:19 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: sched_m2.c,v 1.38 2020/04/13 15:54:45 maxv Exp $");
 #include <sys/param.h>
 #include <sys/cpu.h>
 #include <sys/callout.h>
 #include <sys/errno.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/lwp.h>
 #include <sys/mutex.h>
 #include <sys/pool.h>
 #include <sys/proc.h>
 #include <sys/pset.h>
 @@ -245,27 +245,27 @@ sched_pstats_hook(struct lwp *l, int bat
 	 */
 	KASSERT(lwp_locked(l, NULL));
 	if (l->l_priority >= PRI_HIGHEST_TS)
 		return;
 	KASSERT(l->l_class == SCHED_OTHER);
 	/* If it is CPU-bound not a first time - decrease the priority */
 	prio = l->l_priority;
 	if (batch && prio != 0)
 		prio--;
 	/* If thread was not ran a second or more - set a high priority */
 	if (l->l_stat == LSRUN) {
-		if (l->l_rticks && (hardclock_ticks - l->l_rticks >= hz))
+		if (l->l_rticks && (getticks() - l->l_rticks >= hz))
 			prio = high_pri[prio];
 		/* Re-enqueue the thread if priority has changed */
 		if (prio != l->l_priority)
 			lwp_changepri(l, prio);
 	} else {
 		/* In other states, change the priority directly */
 		l->l_priority = prio;
+	}
+}
 void
 sched_oncpu(lwp_t *l)
+{

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_mount.c,v 1.76 2020/04/10 22:34:36 ad Exp $	*/
+/*	$NetBSD: vfs_mount.c,v 1.77 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 1997-2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, 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
 @@ -57,27 +57,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.
+ *
  *	@(#)vfs_subr.c	8.13 (Berkeley) 4/18/94
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.76 2020/04/10 22:34:36 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_mount.c,v 1.77 2020/04/13 15:54:45 maxv Exp $");
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/fcntl.h>
 #include <sys/filedesc.h>
 #include <sys/device.h>
 #include <sys/kauth.h>
 #include <sys/kmem.h>
 #include <sys/module.h>
 @@ -510,29 +510,29 @@ vfs_insmntque(vnode_t *vp, struct mount
  * If WRITECLOSE is set, only flush out regular file vnodes open for
  * writing.
+ *
  * SKIPSYSTEM causes any vnodes marked VV_SYSTEM to be skipped.
  */
 #ifdef DEBUG
 int busyprt = 0;	/* print out busy vnodes */
 struct ctldebug debug1 = { "busyprt", &busyprt };
 #endif
 static vnode_t *
 vflushnext(struct vnode_iterator *marker, int *when)
+{
-	if (hardclock_ticks > *when) {
+	if (getticks() > *when) {
 		yield();
-		*when = hardclock_ticks + hz / 10;
+		*when = getticks() + hz / 10;
+	}
 	return vfs_vnode_iterator_next1(marker, NULL, NULL, true);
+}
 /*
  * Flush one vnode.  Referenced on entry, unreferenced on return.
  */
 static int
 vflush_one(vnode_t *vp, vnode_t *skipvp, int flags)
+{
 	int error;
 	struct vattr vattr;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vfs_vnode.c,v 1.118 2020/04/04 20:54:42 ad Exp $	*/
+/*	$NetBSD: vfs_vnode.c,v 1.119 2020/04/13 15:54:45 maxv Exp $	*/
 /*-
  * Copyright (c) 1997-2011, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, by Charles M. Hannum, 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
 @@ -145,27 +145,27 @@
+ *
  * Note on v_usecount and its locking
+ *
  *	At nearly all points it is known that v_usecount could be zero,
  *	the vnode_t::v_interlock will be held.  To change the count away
  *	from zero, the interlock must be held.  To change from a non-zero
  *	value to zero, again the interlock must be held.
+ *
  *	Changing the usecount from a non-zero value to a non-zero value can
  *	safely be done using atomic operations, without the interlock held.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_vnode.c,v 1.118 2020/04/04 20:54:42 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_vnode.c,v 1.119 2020/04/13 15:54:45 maxv Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_pax.h"
 #endif
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/hash.h>
 @@ -473,38 +473,38 @@ lru_which(vnode_t *vp)
  */
 static void
 lru_requeue(vnode_t *vp, vnodelst_t *listhd)
+{
 	vnode_impl_t *vip;
 	int d;
 	/*
 	 * If the vnode is on the correct list, and was put there recently,
 	 * then leave it be, thus avoiding huge cache and lock contention.
 	 */
 	vip = VNODE_TO_VIMPL(vp);
 	if (listhd == vip->vi_lrulisthd &&
-	    (hardclock_ticks - vip->vi_lrulisttm) < hz) {
+	    (getticks() - vip->vi_lrulisttm) < hz) {
 	    	return;
+	}
 	mutex_enter(&vdrain_lock);
 	d = 0;
 	if (vip->vi_lrulisthd != NULL)
 		TAILQ_REMOVE(vip->vi_lrulisthd, vip, vi_lrulist);
 	else
 		d++;
 	vip->vi_lrulisthd = listhd;
-	vip->vi_lrulisttm = hardclock_ticks;
+	vip->vi_lrulisttm = getticks();
 	if (vip->vi_lrulisthd != NULL)
 		TAILQ_INSERT_TAIL(vip->vi_lrulisthd, vip, vi_lrulist);
 	else
 		d--;
 	if (d != 0) {
 		/*
 		 * Looks strange?  This is not a bug.  Don't store
 		 * numvnodes unless there is a change - avoid false
 		 * sharing on MP.
 		 */
 		numvnodes += d;
+	}
 	if (numvnodes > desiredvnodes || listhd == &lru_list[LRU_VRELE])
 @@ -530,27 +530,27 @@ vrele_flush(struct mount *mp)
 	TAILQ_INSERT_HEAD(&lru_list[LRU_VRELE], marker, vi_lrulist);
 	while ((vip = TAILQ_NEXT(marker, vi_lrulist))) {
 		TAILQ_REMOVE(&lru_list[LRU_VRELE], marker, vi_lrulist);
 		TAILQ_INSERT_AFTER(&lru_list[LRU_VRELE], vip, marker,
 		    vi_lrulist);
 		vp = VIMPL_TO_VNODE(vip);
 		if (vnis_marker(vp))
 			continue;
 		KASSERT(vip->vi_lrulisthd == &lru_list[LRU_VRELE]);
 		TAILQ_REMOVE(vip->vi_lrulisthd, vip, vi_lrulist);
 		vip->vi_lrulisthd = &lru_list[LRU_HOLD];
-		vip->vi_lrulisttm = hardclock_ticks;
+		vip->vi_lrulisttm = getticks();
 		TAILQ_INSERT_TAIL(vip->vi_lrulisthd, vip, vi_lrulist);
 		mutex_exit(&vdrain_lock);
 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 		mutex_enter(vp->v_interlock);
 		vrelel(vp, 0, LK_EXCLUSIVE);
 		mutex_enter(&vdrain_lock);
+	}
 	TAILQ_REMOVE(&lru_list[LRU_VRELE], marker, vi_lrulist);
 	mutex_exit(&vdrain_lock);
 @@ -612,27 +612,27 @@ vdrain_vrele(vnode_t *vp)
 	mp = vp->v_mount;
 	if (fstrans_start_nowait(mp) != 0)
 		return;
 	/*
 	 * First remove the vnode from the vrele list.
 	 * Put it on the last lru list, the last vrele()
 	 * will put it back onto the right list before
 	 * its v_usecount reaches zero.
 	 */
 	KASSERT(vip->vi_lrulisthd == &lru_list[LRU_VRELE]);
 	TAILQ_REMOVE(vip->vi_lrulisthd, vip, vi_lrulist);
 	vip->vi_lrulisthd = &lru_list[LRU_HOLD];
-	vip->vi_lrulisttm = hardclock_ticks;
+	vip->vi_lrulisttm = getticks();
 	TAILQ_INSERT_TAIL(vip->vi_lrulisthd, vip, vi_lrulist);
 	vdrain_retry = true;
 	mutex_exit(&vdrain_lock);
 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
 	mutex_enter(vp->v_interlock);
 	vrelel(vp, 0, LK_EXCLUSIVE);
 	fstrans_done(mp);
 	mutex_enter(&vdrain_lock);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tcp_usrreq.c,v 1.225 2019/08/06 15:48:18 riastradh Exp $	*/
+/*	$NetBSD: tcp_usrreq.c,v 1.226 2020/04/13 15:54:45 maxv Exp $	*/
 /*
  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
  * 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.
 @@ -89,27 +89,27 @@
  * 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.
+ *
  *	@(#)tcp_usrreq.c	8.5 (Berkeley) 6/21/95
  */
 /*
  * TCP protocol interface to socket abstraction.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tcp_usrreq.c,v 1.225 2019/08/06 15:48:18 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tcp_usrreq.c,v 1.226 2020/04/13 15:54:45 maxv Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_tcp_debug.h"
 #include "opt_mbuftrace.h"
 #include "opt_tcp_space.h"
 #include "opt_net_mpsafe.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/mbuf.h>
 @@ -246,27 +246,27 @@ tcp_fill_info(struct tcpcb *tp, struct t
 		ti->tcpi_options |= TCPI_OPT_TIMESTAMPS;
 	if (tp->t_flags & TF_SACK_PERMIT)
 		ti->tcpi_options |= TCPI_OPT_SACK;
 	if ((tp->t_flags & TF_REQ_SCALE) && (tp->t_flags & TF_RCVD_SCALE)) {
 		ti->tcpi_options |= TCPI_OPT_WSCALE;
 		ti->tcpi_snd_wscale = tp->snd_scale;
 		ti->tcpi_rcv_wscale = tp->rcv_scale;
+	}
 	if (tp->t_flags & TF_ECN_PERMIT) {
 		ti->tcpi_options |= TCPI_OPT_ECN;
+	}
 	ti->tcpi_rto = tp->t_rxtcur * tick;
-	ti->tcpi_last_data_recv = (long)(hardclock_ticks -
+	ti->tcpi_last_data_recv = (long)(getticks() -
 					 (int)tp->t_rcvtime) * tick;
 	ti->tcpi_rtt = ((u_int64_t)tp->t_srtt * tick) >> TCP_RTT_SHIFT;
 	ti->tcpi_rttvar = ((u_int64_t)tp->t_rttvar * tick) >> TCP_RTTVAR_SHIFT;
 	ti->tcpi_snd_ssthresh = tp->snd_ssthresh;
 	/* Linux API wants these in # of segments, apparently */
 	ti->tcpi_snd_cwnd = tp->snd_cwnd / tp->t_segsz;
 	ti->tcpi_snd_wnd = tp->snd_wnd / tp->t_segsz;
 	/*
 	 * FreeBSD-specific extension fields for tcp_info.
 	 */
 	ti->tcpi_rcv_space = tp->rcv_wnd;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdaemon.c,v 1.125 2020/02/23 15:46:43 ad Exp $	*/
+/*	$NetBSD: uvm_pdaemon.c,v 1.126 2020/04/13 15:54:45 maxv Exp $	*/
 /*
  * Copyright (c) 1997 Charles D. Cranor and Washington University.
  * Copyright (c) 1991, 1993, The Regents of the University of California.
+ *
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * The Mach Operating System project at Carnegie-Mellon University.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -56,27 +56,27 @@
  *  School of Computer Science
  *  Carnegie Mellon University
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 /*
  * uvm_pdaemon.c: the page daemon
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.125 2020/02/23 15:46:43 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.126 2020/04/13 15:54:45 maxv Exp $");
 #include "opt_uvmhist.h"
 #include "opt_readahead.h"
 #define	__RWLOCK_PRIVATE
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/pool.h>
 #include <sys/buf.h>
 #include <sys/module.h>
 @@ -988,29 +988,29 @@ uvmpd_pool_drain_thread(void *arg)
+{
 	struct pool *firstpool, *curpool;
 	int bufcnt, lastslept;
 	bool cycled;
 	firstpool = NULL;
 	cycled = true;
 	for (;;) {
 		/*
 		 * sleep until awoken by the pagedaemon.
 		 */
 		mutex_enter(&uvmpd_lock);
 		if (!uvmpd_pool_drain_run) {
-			lastslept = hardclock_ticks;
+			lastslept = getticks();
 			cv_wait(&uvmpd_pool_drain_cv, &uvmpd_lock);
-			if (hardclock_ticks != lastslept) {
+			if (getticks() != lastslept) {
 				cycled = false;
 				firstpool = NULL;
+			}
+		}
 		uvmpd_pool_drain_run = false;
 		mutex_exit(&uvmpd_lock);
 		/*
 		 * rate limit draining, otherwise in desperate circumstances
 		 * this can totally saturate the system with xcall activity.
 		 */
 		if (cycled) {
 			kpause("uvmpdlmt", false, 1, NULL);