 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdaemon.c,v 1.118 2019/12/21 16:10:20 ad Exp $	*/
+/*	$NetBSD: uvm_pdaemon.c,v 1.119 2019/12/30 18:08:37 ad 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,43 +56,44 @@
  *  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.118 2019/12/21 16:10:20 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdaemon.c,v 1.119 2019/12/30 18:08:37 ad Exp $");
 #include "opt_uvmhist.h"
 #include "opt_readahead.h"
 #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>
 #include <sys/atomic.h>
 #include <sys/kthread.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pdpolicy.h>
 #include <uvm/uvm_pgflcache.h>
 #ifdef UVMHIST
 UVMHIST_DEFINE(pdhist);
 #endif
 /*
  * UVMPD_NUMDIRTYREACTS is how many dirty pages the pagedaemon will reactivate
  * in a pass thru the inactive list when swap is full.  the value should be
  * "small"... if it's too large we'll cycle the active pages thru the inactive
  * queue too quickly to for them to be referenced and avoid being freed.
  */
 #define	UVMPD_NUMDIRTYREACTS	16
 @@ -588,94 +589,50 @@ static int
 swapcluster_nused(struct swapcluster *swc)
+{
 	return swc->swc_nused;
+}
 /*
  * uvmpd_dropswap: free any swap allocated to this page.
+ *
  * => called with owner locked.
  * => return true if a page had an associated slot.
  */
-static bool
+bool
 uvmpd_dropswap(struct vm_page *pg)
+{
 	bool result = false;
 	struct vm_anon *anon = pg->uanon;
 	if ((pg->flags & PG_ANON) && anon->an_swslot) {
 		uvm_swap_free(anon->an_swslot, 1);
 		anon->an_swslot = 0;
 		pg->flags &= ~PG_CLEAN;
 		result = true;
 	} else if (pg->flags & PG_AOBJ) {
 		int slot = uao_set_swslot(pg->uobject,
 		    pg->offset >> PAGE_SHIFT, 0);
 		if (slot) {
 			uvm_swap_free(slot, 1);
 			pg->flags &= ~PG_CLEAN;
 			result = true;
+		}
+	}
 	return result;
+}
 /*
  * uvmpd_trydropswap: try to free any swap allocated to this page.
  * => return true if a slot is successfully freed.
  * => page interlock must be held, and will be dropped.
  */
 bool
 uvmpd_trydropswap(struct vm_page *pg)
 	kmutex_t *slock;
 	bool result;
 	if ((pg->flags & PG_BUSY) != 0) {
 		mutex_exit(&pg->interlock);
 		return false;
 	/*
 	 * lock the page's owner.
 	 * this will drop pg->interlock.
 	 */
 	slock = uvmpd_trylockowner(pg);
 	if (slock == NULL) {
 		return false;
 	/*
 	 * skip this page if it's busy.
 	 */
 	if ((pg->flags & PG_BUSY) != 0) {
 		mutex_exit(slock);
 		return false;
 	result = uvmpd_dropswap(pg);
 	mutex_exit(slock);
 	return result;
 #endif /* defined(VMSWAP) */
 /*
  * uvmpd_scan_queue: scan an replace candidate list for pages
  * to clean or free.
+ *
  * => we work on meeting our free target by converting inactive pages
  *    into free pages.
  * => we handle the building of swap-backed clusters
  */
 static void
 uvmpd_scan_queue(void)
 @@ -899,26 +856,28 @@ uvmpd_scan_queue(void)
 		/*
 		 * the pageout is in progress.  bump counters and set up
 		 * for the next loop.
 		 */
 		atomic_inc_uint(&uvmexp.pdpending);
 #else /* defined(VMSWAP) */
 		uvm_pageactivate(p);
 		mutex_exit(slock);
 #endif /* defined(VMSWAP) */
+	}
 	uvmpdpol_scanfini();
 #if defined(VMSWAP)
 	swapcluster_flush(&swc, true);
 #endif /* defined(VMSWAP) */
+}
 /*
  * uvmpd_scan: scan the page queues and attempt to meet our targets.
  */
 static void
 uvmpd_scan(void)
+{
 	int swap_shortage, pages_freed, fpages;
 @@ -1021,51 +980,85 @@ uvm_estimatepageable(int *active, int *i
 	uvmpdpol_estimatepageable(active, inactive);
+}
 /*
  * Use a separate thread for draining pools.
  * This work can't done from the main pagedaemon thread because
  * some pool allocators need to take vm_map locks.
  */
 static void
 uvmpd_pool_drain_thread(void *arg)
+{
-	int bufcnt;
+	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;
 			cv_wait(&uvmpd_pool_drain_cv, &uvmpd_lock);
 			if (hardclock_ticks != 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);
 			cycled = false;
 			firstpool = NULL;
+		}
 		/*
 		 * drain and temporarily disable the freelist cache.
 		 */
 		uvm_pgflcache_pause();
 		/*
 		 * kill unused metadata buffers.
 		 */
 		bufcnt = uvmexp.freetarg - uvm_free();
 		if (bufcnt < 0)
 			bufcnt = 0;
 		mutex_enter(&bufcache_lock);
 		buf_drain(bufcnt << PAGE_SHIFT);
 		mutex_exit(&bufcache_lock);
 		/*
-		 * drain a pool.
+		 * drain a pool, and then re-enable the freelist cache.
 		 */
-		pool_drain(NULL);
+		(void)pool_drain(&curpool);
 		KASSERT(curpool != NULL);
 		if (firstpool == NULL) {
 			firstpool = curpool;
 		} else if (firstpool == curpool) {
 			cycled = true;
+		}
 		uvm_pgflcache_resume();
+	}
 	/*NOTREACHED*/
+}
 static void
 uvmpd_pool_drain_wakeup(void)
+{
 	mutex_enter(&uvmpd_lock);
 	uvmpd_pool_drain_run = true;
 	cv_signal(&uvmpd_pool_drain_cv);
 	mutex_exit(&uvmpd_lock);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdpolicy_clock.c,v 1.23 2019/12/27 13:13:17 ad Exp $	*/
+/*	$NetBSD: uvm_pdpolicy_clock.c,v 1.24 2019/12/30 18:08:38 ad Exp $	*/
 /*	NetBSD: uvm_pdaemon.c,v 1.72 2006/01/05 10:47:33 yamt 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
 @@ -59,27 +59,27 @@
  *  Pittsburgh PA 15213-3890
+ *
  * any improvements or extensions that they make and grant Carnegie the
  * rights to redistribute these changes.
  */
 #if defined(PDSIM)
 #include "pdsim.h"
 #else /* defined(PDSIM) */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clock.c,v 1.23 2019/12/27 13:13:17 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clock.c,v 1.24 2019/12/30 18:08:38 ad Exp $");
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pdpolicy.h>
 #include <uvm/uvm_pdpolicy_impl.h>
 #include <uvm/uvm_stat.h>
 #endif /* defined(PDSIM) */
 @@ -100,29 +100,28 @@ struct uvmpdpol_globalstate {
 	int s_active;
 	int s_inactive;
 	int s_inactarg;
 	struct uvm_pctparam s_anonmin;
 	struct uvm_pctparam s_filemin;
 	struct uvm_pctparam s_execmin;
 	struct uvm_pctparam s_anonmax;
 	struct uvm_pctparam s_filemax;
 	struct uvm_pctparam s_execmax;
 	struct uvm_pctparam s_inactivepct;
 };
 struct uvmpdpol_scanstate {
 	bool ss_first;
 	bool ss_anonreact, ss_filereact, ss_execreact;
-	struct vm_page *ss_nextpg;
+	struct vm_page ss_marker;
 };
 static void	uvmpdpol_pageactivate_locked(struct vm_page *);
 static void	uvmpdpol_pagedeactivate_locked(struct vm_page *);
 static void	uvmpdpol_pagedequeue_locked(struct vm_page *);
 static struct uvmpdpol_globalstate pdpol_state __cacheline_aligned;
 static struct uvmpdpol_scanstate pdpol_scanstate;
 PDPOL_EVCNT_DEFINE(reactexec)
 PDPOL_EVCNT_DEFINE(reactfile)
 PDPOL_EVCNT_DEFINE(reactanon)
 @@ -167,74 +166,86 @@ uvmpdpol_scaninit(void)
 	execunder = execpg <= UVM_PCTPARAM_APPLY(&s->s_execmin, t);
 	anonover = anonpg > UVM_PCTPARAM_APPLY(&s->s_anonmax, t);
 	fileover = filepg > UVM_PCTPARAM_APPLY(&s->s_filemax, t);
 	execover = execpg > UVM_PCTPARAM_APPLY(&s->s_execmax, t);
 	anonreact = anonunder || (!anonover && (fileover || execover));
 	filereact = fileunder || (!fileover && (anonover || execover));
 	execreact = execunder || (!execover && (anonover || fileover));
 	if (filereact && execreact && (anonreact || uvm_swapisfull())) {
 		anonreact = filereact = execreact = false;
+	}
 	ss->ss_anonreact = anonreact;
 	ss->ss_filereact = filereact;
 	ss->ss_execreact = execreact;
 	memset(&ss->ss_marker, 0, sizeof(ss->ss_marker));
 	ss->ss_marker.flags = PG_MARKER;
 	TAILQ_INSERT_HEAD(&pdpol_state.s_inactiveq, &ss->ss_marker, pdqueue);
 	mutex_exit(&s->lock);
+}
 void
 uvmpdpol_scanfini(void)
+{
 	struct uvmpdpol_globalstate *s = &pdpol_state;
 	struct uvmpdpol_scanstate *ss = &pdpol_scanstate;
-	ss->ss_first = true;
+	mutex_enter(&s->lock);
 	TAILQ_REMOVE(&pdpol_state.s_inactiveq, &ss->ss_marker, pdqueue);
 	mutex_exit(&s->lock);
+}
 struct vm_page *
 uvmpdpol_selectvictim(kmutex_t **plock)
+{
 	struct uvmpdpol_globalstate *s = &pdpol_state;
 	struct uvmpdpol_scanstate *ss = &pdpol_scanstate;
 	struct vm_page *pg;
 	kmutex_t *lock;
 	mutex_enter(&s->lock);
 	while (/* CONSTCOND */ 1) {
 		struct vm_anon *anon;
 		struct uvm_object *uobj;
-		if (ss->ss_first) {
+		pg = TAILQ_NEXT(&ss->ss_marker, pdqueue);
 			pg = TAILQ_FIRST(&pdpol_state.s_inactiveq);
 			ss->ss_first = false;
 		} else {
 			pg = ss->ss_nextpg;
 			if (pg != NULL && (pg->pqflags & PQ_INACTIVE) == 0) {
 				pg = TAILQ_FIRST(&pdpol_state.s_inactiveq);
 		if (pg == NULL) {
 			break;
+		}
-		ss->ss_nextpg = TAILQ_NEXT(pg, pdqueue);
+		KASSERT((pg->flags & PG_MARKER) == 0);
 		uvmexp.pdscans++;
 		/*
 		 * acquire interlock to stablize page identity.
 		 * if we have caught the page in a state of flux
 		 * and it should be dequeued, do it now and then
 		 * move on to the next.
 		 */
 		mutex_enter(&pg->interlock);
 	        if ((pg->uobject == NULL && pg->uanon == NULL) ||
 	            pg->wire_count > 0) {
 	            	mutex_exit(&pg->interlock);
 	            	uvmpdpol_pagedequeue_locked(pg);
 	            	continue;
+		}
 		/*
 		 * now prepare to move on to the next page.
 		 */
 		TAILQ_REMOVE(&pdpol_state.s_inactiveq, &ss->ss_marker,
 		    pdqueue);
 		TAILQ_INSERT_AFTER(&pdpol_state.s_inactiveq, pg,
 		    &ss->ss_marker, pdqueue);
 		/*
 		 * enforce the minimum thresholds on different
 		 * types of memory usage.  if reusing the current
 		 * page would reduce that type of usage below its
 		 * minimum, reactivate the page instead and move
 		 * on to the next page.
 		 */
 		anon = pg->uanon;
 		uobj = pg->uobject;
 		if (uobj && UVM_OBJ_IS_VTEXT(uobj) && ss->ss_execreact) {
 			mutex_exit(&pg->interlock);
 			uvmpdpol_pageactivate_locked(pg);
 			PDPOL_EVCNT_INCR(reactexec);
 			continue;
 @@ -290,87 +301,108 @@ uvmpdpol_selectvictim(kmutex_t **plock)
 		/* we have a potential victim. */
 		*plock = lock;
 		break;
+	}
 	mutex_exit(&s->lock);
 	return pg;
+}
 void
 uvmpdpol_balancequeue(int swap_shortage)
+{
 	struct uvmpdpol_globalstate *s = &pdpol_state;
 	int inactive_shortage;
-	struct vm_page *p, *nextpg;
+	struct vm_page *p, marker;
 	kmutex_t *lock;
 	/*
 	 * we have done the scan to get free pages.   now we work on meeting
 	 * our inactive target.
 	 */
-	mutex_enter(&s->lock);
+	memset(&marker, 0, sizeof(marker));
-	inactive_shortage = pdpol_state.s_inactarg - pdpol_state.s_inactive;
+	marker.flags = PG_MARKER;
 	for (p = TAILQ_FIRST(&pdpol_state.s_activeq);
 	     p != NULL && (inactive_shortage > 0 || swap_shortage > 0);
 	     p = nextpg) {
 		nextpg = TAILQ_NEXT(p, pdqueue);
-		/*
+	mutex_enter(&s->lock);
-		 * if there's a shortage of swap slots, try to free it.
+	TAILQ_INSERT_HEAD(&pdpol_state.s_activeq, &marker, pdqueue);
-		 */
+	for (;;) {
 		inactive_shortage =
-		if (swap_shortage > 0 && (p->flags & PG_SWAPBACKED) != 0) {
+		    pdpol_state.s_inactarg - pdpol_state.s_inactive;
-			mutex_enter(&p->interlock);
+		if (inactive_shortage <= 0 && swap_shortage <= 0) {
-			mutex_exit(&s->lock);
+			break;
 			if (uvmpd_trydropswap(p)) {
 				swap_shortage--;
 			/* p->interlock now released */
 			mutex_enter(&s->lock);
+		}
 		p = TAILQ_NEXT(&marker, pdqueue);
-		/*
+		if (p == NULL) {
-		 * if there's a shortage of inactive pages, deactivate.
+			break;
 		 */
 		if (inactive_shortage <= 0) {
 			continue;
+		}
 		KASSERT((p->flags & PG_MARKER) == 0);
 		/*
 		 * acquire interlock to stablize page identity.
 		 * if we have caught the page in a state of flux
 		 * and it should be dequeued, do it now and then
 		 * move on to the next.
 		 */
 		mutex_enter(&p->interlock);
 	        if ((p->uobject == NULL && p->uanon == NULL) ||
 	            p->wire_count > 0) {
 	            	mutex_exit(&p->interlock);
 	            	uvmpdpol_pagedequeue_locked(p);
 	            	continue;
+		}
 		mutex_exit(&s->lock);
-		lock = uvmpd_trylockowner(p);
+		/*
-		/* p->interlock now released */
+		 * now prepare to move on to the next page.
-		mutex_enter(&s->lock);
+		 */
 		if (lock != NULL) {
 		TAILQ_REMOVE(&pdpol_state.s_activeq, &marker, pdqueue);
 		TAILQ_INSERT_AFTER(&pdpol_state.s_activeq, p, &marker,
 		    pdqueue);
 		/*
 		 * try to lock the object that owns the page.  see comments
 		 * in uvmpdol_selectvictim().
 	         */
 	        mutex_exit(&s->lock);
         	lock = uvmpd_trylockowner(p);
         	/* p->interlock now released */
         	mutex_enter(&s->lock);
 		if (lock == NULL) {
 			/* didn't get it - try the next page. */
 			continue;
+		}
 		/*
 		 * if there's a shortage of swap slots, try to free it.
 		 */
 		if (swap_shortage > 0 && (p->flags & PG_SWAPBACKED) != 0 &&
 		    (p->flags & PG_BUSY) == 0) {
 			if (uvmpd_dropswap(p)) {
 				swap_shortage--;
+			}
+		}
 		/*
 		 * if there's a shortage of inactive pages, deactivate.
 		 */
 		if (inactive_shortage > 0) {
 			uvmpdpol_pagedeactivate_locked(p);
 			uvmexp.pddeact++;
 			inactive_shortage--;
 			mutex_exit(lock);
+		}
 		mutex_exit(lock);
+	}
 	TAILQ_REMOVE(&pdpol_state.s_activeq, &marker, pdqueue);
 	mutex_exit(&s->lock);
+}
 static void
 uvmpdpol_pagedeactivate_locked(struct vm_page *pg)
+{
 	KASSERT(uvm_page_locked_p(pg));
 	if (pg->pqflags & PQ_ACTIVE) {
 		TAILQ_REMOVE(&pdpol_state.s_activeq, pg, pdqueue);
 		pg->pqflags &= ~(PQ_ACTIVE | PQ_TIME);
 		KASSERT(pdpol_state.s_active > 0);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdpolicy_clockpro.c,v 1.19 2019/12/27 13:13:17 ad Exp $	*/
+/*	$NetBSD: uvm_pdpolicy_clockpro.c,v 1.20 2019/12/30 18:08:38 ad Exp $	*/
 /*-
  * Copyright (c)2005, 2006 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.
 @@ -33,27 +33,27 @@
  * approximation of the list of non-resident pages using hash:
  *	http://linux-mm.org/ClockProApproximation
  */
 /* #define	CLOCKPRO_DEBUG */
 #if defined(PDSIM)
 #include "pdsim.h"
 #else /* defined(PDSIM) */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clockpro.c,v 1.19 2019/12/27 13:13:17 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uvm_pdpolicy_clockpro.c,v 1.20 2019/12/30 18:08:38 ad Exp $");
 #include "opt_ddb.h"
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/hash.h>
 #include <uvm/uvm.h>
 #include <uvm/uvm_pdaemon.h>	/* for uvmpd_trylockowner */
 #include <uvm/uvm_pdpolicy.h>
 #include <uvm/uvm_pdpolicy_impl.h>
 @@ -1248,26 +1248,32 @@ uvmpdpol_pageisqueued_p(struct vm_page *
+}
 void
 uvmpdpol_scaninit(void)
+{
 	struct clockpro_state * const s = &clockpro;
 	struct clockpro_scanstate * const ss = &scanstate;
 	mutex_enter(&s->lock);
 	ss->ss_nscanned = 0;
 	mutex_exit(&s->lock);
+}
 void
 uvmpdpol_scanfini(void)
+{
+}
 struct vm_page *
 uvmpdpol_selectvictim(kmutex_t **plock)
+{
 	struct clockpro_state * const s = &clockpro;
 	struct clockpro_scanstate * const ss = &scanstate;
 	struct vm_page *pg;
 	kmutex_t *lock = NULL;
 	do {
 		mutex_enter(&s->lock);
 		if (ss->ss_nscanned > s->s_npages) {
 			DPRINTF("scan too much\n");
 			mutex_exit(&s->lock);
 @@ -1295,45 +1301,66 @@ uvmpdpol_selectvictim(kmutex_t **plock)
+		}
 		mutex_exit(&s->lock);
 		lock = uvmpd_trylockowner(pg);
 		/* pg->interlock now dropped */
 	} while (lock == NULL);
 	*plock = lock;
 	return pg;
+}
 static void
 clockpro_dropswap(pageq_t *q, int *todo)
+{
 	struct vm_page *pg;
 	kmutex_t *lock;
 	KASSERT(mutex_owned(&clockpro.lock));
 	TAILQ_FOREACH_REVERSE(pg, &q->q_q, pglist, pdqueue) {
 		if (*todo <= 0) {
 			break;
+		}
 		if ((pg->pqflags & PQ_HOT) == 0) {
 			continue;
+		}
 		mutex_enter(&pg->interlock);
 		if ((pg->flags & PG_SWAPBACKED) == 0) {
 			mutex_exit(&pg->interlock);
 			continue;
+		}
 		if (uvmpd_trydropswap(pg)) {
-			(*todo)--;
+		/*
 		 * try to lock the object that owns the page.
 	         */
 	        mutex_exit(&clockpro.lock);
         	lock = uvmpd_trylockowner(pg);
         	/* pg->interlock now released */
         	mutex_enter(&clockpro.lock);
 		if (lock == NULL) {
 			/* didn't get it - try the next page. */
 			/* XXXAD lost position in queue */
 			continue;
+		}
 		/* pg->interlock now dropped */
 		/*
 		 * if there's a shortage of swap slots, try to free it.
 		 */
 		if ((pg->flags & PG_SWAPBACKED) != 0 &&
 		    (pg->flags & PG_BUSY) == 0) {
 			if (uvmpd_dropswap(pg)) {
 				(*todo)--;
+			}
+		}
 		mutex_exit(lock);
+	}
+}
 void
 uvmpdpol_balancequeue(int swap_shortage)
+{
 	struct clockpro_state * const s = &clockpro;
 	int todo = swap_shortage;
 	if (todo == 0) {
 		return;
+	}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdaemon.h,v 1.17 2011/02/02 15:25:27 chuck Exp $	*/
+/*	$NetBSD: uvm_pdaemon.h,v 1.18 2019/12/30 18:08:38 ad 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:
 @@ -69,21 +69,21 @@
  */
 #ifdef _KERNEL
 /*
  * prototypes
  */
 void uvm_wait(const char *);
 bool uvm_reclaimable(void);
 kmutex_t *uvmpd_trylockowner(struct vm_page *);
 #ifdef VMSWAP
-bool uvmpd_trydropswap(struct vm_page *);
+bool uvmpd_dropswap(struct vm_page *);
 #else
-#define uvmpd_trydropswap(_a_) (/*CONSTCOND*/false)
+#define uvmpd_dropswap(_a_) (/*CONSTCOND*/false)
 #endif
 #endif /* _KERNEL */
 #endif /* _UVM_UVM_PDAEMON_H_ */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: uvm_pdpolicy.h,v 1.4 2019/12/13 20:10:22 ad Exp $	*/
+/*	$NetBSD: uvm_pdpolicy.h,v 1.5 2019/12/30 18:08:38 ad Exp $	*/
 /*-
  * Copyright (c)2005, 2006 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.
 @@ -41,19 +41,20 @@ void uvmpdpol_init(void);
 void uvmpdpol_reinit(void);
 void uvmpdpol_estimatepageable(int *, int *);
 bool uvmpdpol_needsscan_p(void);
 void uvmpdpol_pageactivate(struct vm_page *);
 void uvmpdpol_pagedeactivate(struct vm_page *);
 void uvmpdpol_pagedequeue(struct vm_page *);
 void uvmpdpol_pageenqueue(struct vm_page *);
 bool uvmpdpol_pageisqueued_p(struct vm_page *);
 void uvmpdpol_anfree(struct vm_anon *);
 void uvmpdpol_tune(void);
 void uvmpdpol_scaninit(void);
 void uvmpdpol_scanfini(void);
 struct vm_page *uvmpdpol_selectvictim(kmutex_t **lock);
 void uvmpdpol_balancequeue(int);
 void uvmpdpol_sysctlsetup(void);
 #endif /* !_UVM_PDPOLICY_H_ */