 @@ -1,14 +1,14 @@
-/*      $NetBSD: scheduler.c,v 1.22 2010/11/21 22:01:15 pooka Exp $	*/
+/*      $NetBSD: scheduler.c,v 1.23 2010/12/01 20:29:56 pooka Exp $	*/
 /*
  * Copyright (c) 2010 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: scheduler.c,v 1.22 2010/11/21 22:01:15 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: scheduler.c,v 1.23 2010/12/01 20:29:56 pooka Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/cpu.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 #include <sys/namei.h>
 #include <sys/queue.h>
 #include <sys/select.h>
 #include <sys/systm.h>
 #include <rump/rumpuser.h>
 @@ -332,26 +332,28 @@ rump_schedule_cpu_interlock(struct lwp *
+		}
 		/* Want CPU, wait until it's released an retry */
 		rcpu->rcpu_wanted++;
 		rumpuser_cv_wait_nowrap(rcpu->rcpu_cv, rcpu->rcpu_mtx);
 		rcpu->rcpu_wanted--;
+	}
 	rumpuser_mutex_exit(rcpu->rcpu_mtx);
  fastlane:
 	l->l_cpu = l->l_target_cpu = rcpu->rcpu_ci;
 	l->l_mutex = rcpu->rcpu_ci->ci_schedstate.spc_mutex;
 	l->l_ncsw++;
 	rcpu->rcpu_ci->ci_curlwp = l;
+}
 void
 rump_unschedule()
+{
 	struct lwp *l;
 	l = rumpuser_get_curlwp();
 	KASSERT(l->l_mutex == l->l_cpu->ci_schedstate.spc_mutex);
 	rump_unschedule_cpu(l);
 	l->l_mutex = NULL;
 	/*
 @@ -397,26 +399,27 @@ rump_unschedule_cpu_interlock(struct lwp
 	if ((l->l_pflag & LP_INTR) == 0)
 		rump_softint_run(l->l_cpu);
 	rump_unschedule_cpu1(l, interlock);
+}
 void
 rump_unschedule_cpu1(struct lwp *l, void *interlock)
+{
 	struct rumpcpu *rcpu;
 	struct cpu_info *ci;
 	void *old;
 	ci = l->l_cpu;
 	ci->ci_curlwp = NULL;
 	l->l_cpu = NULL;
 	rcpu = &rcpu_storage[ci-&rump_cpus[0]];
 	KASSERT(rcpu->rcpu_ci == ci);
 	/*
 	 * Make sure all stores are seen before the CPU release.  This
 	 * is relevant only in the non-fastpath scheduling case, but
 	 * we don't know here if that's going to happen, so need to
 	 * expect the worst.
 	 */
 	membar_exit();

 @@ -1,14 +1,14 @@
-/*	$NetBSD: vm.c,v 1.103 2010/12/01 11:19:18 pooka Exp $	*/
+/*	$NetBSD: vm.c,v 1.104 2010/12/01 20:29:57 pooka Exp $	*/
 /*
  * Copyright (c) 2007-2010 Antti Kantee.  All Rights Reserved.
+ *
  * Development of this software was supported by
  * The Finnish Cultural Foundation and the Research Foundation of
  * The Helsinki University of Technology.
+ *
  * 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.
 @@ -31,27 +31,27 @@
 /*
  * Virtual memory emulation routines.
  */
 /*
  * XXX: we abuse pg->uanon for the virtual address of the storage
  * for each page.  phys_addr would fit the job description better,
  * except that it will create unnecessary lossage on some platforms
  * due to not being a pointer type.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vm.c,v 1.103 2010/12/01 11:19:18 pooka Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vm.c,v 1.104 2010/12/01 20:29:57 pooka Exp $");
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/buf.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/mman.h>
 #include <sys/null.h>
 #include <sys/vnode.h>
 #include <machine/pmap.h>
 #include <rump/rumpuser.h>
 @@ -164,28 +164,29 @@ static struct pool_cache pagecache;
 /*
  * Called with the object locked.  We don't support anons.
  */
 struct vm_page *
 uvm_pagealloc_strat(struct uvm_object *uobj, voff_t off, struct vm_anon *anon,
 	int flags, int strat, int free_list)
+{
 	struct vm_page *pg;
 	KASSERT(uobj && mutex_owned(&uobj->vmobjlock));
 	KASSERT(anon == NULL);
 	pg = pool_cache_get(&pagecache, PR_NOWAIT);
-	if (__predict_false(pg == NULL))
+	if (__predict_false(pg == NULL)) {
 		return NULL;
+	}
 	pg->offset = off;
 	pg->uobject = uobj;
 	pg->flags = PG_CLEAN|PG_BUSY|PG_FAKE;
 	if (flags & UVM_PGA_ZERO) {
 		uvm_pagezero(pg);
+	}
 	TAILQ_INSERT_TAIL(&uobj->memq, pg, listq.queue);
 	(void)rb_tree_insert_node(&uobj->rb_tree, pg);
 	/*
 @@ -856,75 +857,90 @@ uvm_pageout_start(int npages)
+{
 	/* we don't have the heuristics */
+}
 void
 uvm_pageout_done(int npages)
+{
 	/* could wakeup waiters, but just let the pagedaemon do it */
+}
 static bool
-processpage(struct vm_page *pg)
+processpage(struct vm_page *pg, bool *lockrunning)
+{
 	struct uvm_object *uobj;
 	uobj = pg->uobject;
 	if (mutex_tryenter(&uobj->vmobjlock)) {
 		if ((pg->flags & PG_BUSY) == 0) {
 			mutex_exit(&uvm_pageqlock);
 			uobj->pgops->pgo_put(uobj, pg->offset,
 			    pg->offset + PAGE_SIZE,
 			    PGO_CLEANIT|PGO_FREE);
 			KASSERT(!mutex_owned(&uobj->vmobjlock));
 			return true;
 		} else {
 			mutex_exit(&uobj->vmobjlock);
+		}
 	} else if (*lockrunning == false && ncpu > 1) {
 		CPU_INFO_ITERATOR cii;
 		struct cpu_info *ci;
 		struct lwp *l;
 		l = mutex_owner(&uobj->vmobjlock);
 		for (CPU_INFO_FOREACH(cii, ci)) {
 			if (ci->ci_curlwp == l) {
 				*lockrunning = true;
 				break;
+			}
+		}
+	}
 	return false;
+}
 /*
  * The Diabolical pageDaemon Director (DDD).
  */
 void
 uvm_pageout(void *arg)
+{
 	struct vm_page *pg;
 	struct pool *pp, *pp_first;
 	uint64_t where;
 	int timo = 0;
 	int cleaned, skip, skipped;
 	bool succ = false;
 	bool lockrunning;
 	mutex_enter(&pdaemonmtx);
 	for (;;) {
 		if (succ) {
 			kernel_map->flags &= ~VM_MAP_WANTVA;
 			kmem_map->flags &= ~VM_MAP_WANTVA;
 			timo = 0;
 			if (pdaemon_waiters) {
 				pdaemon_waiters = 0;
 				cv_broadcast(&oomwait);
+			}
+		}
 		succ = false;
-		cv_timedwait(&pdaemoncv, &pdaemonmtx, timo);
+		if (pdaemon_waiters == 0) {
-		uvmexp.pdwoke++;
+			cv_timedwait(&pdaemoncv, &pdaemonmtx, timo);
 			uvmexp.pdwoke++;
+		}
 		/* tell the world that we are hungry */
 		kernel_map->flags |= VM_MAP_WANTVA;
 		kmem_map->flags |= VM_MAP_WANTVA;
 		if (pdaemon_waiters == 0 && !NEED_PAGEDAEMON())
 			continue;
 		mutex_exit(&pdaemonmtx);
 		/*
 		 * step one: reclaim the page cache.  this should give
 		 * us the biggest earnings since whole pages are released
 		 * into backing memory.
 @@ -933,53 +949,76 @@ uvm_pageout(void *arg)
 		if (!NEED_PAGEDAEMON()) {
 			succ = true;
 			mutex_enter(&pdaemonmtx);
 			continue;
+		}
 		/*
 		 * Ok, so that didn't help.  Next, try to hunt memory
 		 * by pushing out vnode pages.  The pages might contain
 		 * useful cached data, but we need the memory.
 		 */
 		cleaned = 0;
 		skip = 0;
 		lockrunning = false;
  again:
 		mutex_enter(&uvm_pageqlock);
 		while (cleaned < PAGEDAEMON_OBJCHUNK) {
 			skipped = 0;
 			TAILQ_FOREACH(pg, &vmpage_lruqueue, pageq.queue) {
 				/*
 				 * skip over pages we _might_ have tried
 				 * to handle earlier.  they might not be
 				 * exactly the same ones, but I'm not too
 				 * concerned.
 				 */
 				while (skipped++ < skip)
 					continue;
-				if (processpage(pg)) {
+				if (processpage(pg, &lockrunning)) {
 					cleaned++;
 					goto again;
+				}
 				skip++;
+			}
 			break;
+		}
 		mutex_exit(&uvm_pageqlock);
 		/*
 		 * Ok, someone is running with an object lock held.
 		 * We want to yield the host CPU to make sure the
 		 * thread is not parked on the host.  Since sched_yield()
 		 * doesn't appear to do anything on NetBSD, nanosleep
 		 * for the smallest possible time and hope we're back in
 		 * the game soon.
 		 */
 		if (cleaned == 0 && lockrunning) {
 			uint64_t sec, nsec;
 			sec = 0;
 			nsec = 1;
 			rumpuser_nanosleep(&sec, &nsec, NULL);
 			lockrunning = false;
 			skip = 0;
 			/* and here we go again */
 			goto again;
+		}
 		/*
 		 * And of course we need to reclaim the page cache
 		 * again to actually release memory.
 		 */
 		pool_cache_reclaim(&pagecache);
 		if (!NEED_PAGEDAEMON()) {
 			succ = true;
 			mutex_enter(&pdaemonmtx);
 			continue;
+		}
 		/*
 		 * Still not there?  sleeves come off right about now.
 		 * First: do reclaim on kernel/kmem map.
 @@ -1002,27 +1041,27 @@ uvm_pageout(void *arg)
 				break;
 			pool_drain_start(&pp, &where);
 			if (pp == pp_first) {
 				succ = pool_drain_end(pp, where);
 				break;
+			}
+		}
 		/*
 		 * Need to use PYEC on our bag of tricks.
 		 * Unfortunately, the wife just borrowed it.
 		 */
-		if (!succ) {
+		if (!succ && cleaned == 0) {
 			rumpuser_dprintf("pagedaemoness: failed to reclaim "
 			    "memory ... sleeping (deadlock?)\n");
 			timo = hz;
+		}
 		mutex_enter(&pdaemonmtx);
+	}
 	panic("you can swap out any time you like, but you can never leave");
+}
 void
 uvm_kick_pdaemon()