 @@ -1,14 +1,14 @@
-/*      $NetBSD: xengnt.c,v 1.20 2011/09/20 00:12:24 jym Exp $      */
+/*      $NetBSD: xengnt.c,v 1.21 2011/12/09 03:58:12 cherry Exp $      */
 /*
  * Copyright (c) 2006 Manuel Bouyer.
+ *
  * 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,35 +16,36 @@
  * 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: xengnt.c,v 1.20 2011/09/20 00:12:24 jym Exp $");
+__KERNEL_RCSID(0, "$NetBSD: xengnt.c,v 1.21 2011/12/09 03:58:12 cherry Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/malloc.h>
 #include <sys/queue.h>
 #include <sys/extent.h>
 #include <sys/kernel.h>
 #include <sys/mutex.h>
 #include <uvm/uvm.h>
 #include <xen/hypervisor.h>
 #include <xen/xen.h>
 #include <xen/granttables.h>
 /* #define XENDEBUG */
 #ifdef XENDEBUG
 #define DPRINTF(x) printf x
 #else
 #define DPRINTF(x)
 #endif
 @@ -54,26 +55,27 @@ __KERNEL_RCSID(0, "$NetBSD: xengnt.c,v 1
 int gnt_nr_grant_frames;
 /* Maximum number of frames that can make up the grant table */
 int gnt_max_grant_frames;
 /* table of free grant entries */
 grant_ref_t *gnt_entries;
 /* last free entry */
 int last_gnt_entry;
 /* empty entry in the list */
 #define XENGNT_NO_ENTRY 0xffffffff
 /* VM address of the grant table */
 grant_entry_t *grant_table;
 kmutex_t grant_lock;
 static grant_ref_t xengnt_get_entry(void);
 static void xengnt_free_entry(grant_ref_t);
 static int xengnt_more_entries(void);
 void
 xengnt_init(void)
+{
 	struct gnttab_query_size query;
 	int rc;
 	int nr_grant_entries;
 	int i;
 @@ -89,26 +91,28 @@ xengnt_init(void)
 	    gnt_max_grant_frames * NR_GRANT_ENTRIES_PER_PAGE;
 	grant_table = (void *)uvm_km_alloc(kernel_map,
 	    gnt_max_grant_frames * PAGE_SIZE, 0, UVM_KMF_VAONLY);
 	if (grant_table == NULL)
 		panic("xengnt_init() no VM space");
 	gnt_entries = malloc((nr_grant_entries + 1) * sizeof(grant_ref_t),
 	    M_DEVBUF, M_NOWAIT);
 	if (gnt_entries == NULL)
 		panic("xengnt_init() no space for bitmask");
 	for (i = 0; i <= nr_grant_entries; i++)
 		gnt_entries[i] = XENGNT_NO_ENTRY;
 	mutex_init(&grant_lock, MUTEX_DEFAULT, IPL_VM);
 	xengnt_resume();
+}
 /*
  * Resume grant table state
  */
 bool
 xengnt_resume(void)
+{
 	int previous_nr_grant_frames = gnt_nr_grant_frames;
 	last_gnt_entry = 0;
 @@ -207,115 +211,119 @@ xengnt_more_entries(void)
+	}
 	gnt_nr_grant_frames = nframes_new;
 	free(pages, M_DEVBUF);
 	return 0;
+}
 /*
  * Returns a reference to the first free entry in grant table
  */
 static grant_ref_t
 xengnt_get_entry(void)
+{
 	grant_ref_t entry;
-	int s = splvm();
+	mutex_enter(&grant_lock);
 	static struct timeval xengnt_nonmemtime;
 	static const struct timeval xengnt_nonmemintvl = {5,0};
 	if (last_gnt_entry == 0) {
 		if (xengnt_more_entries()) {
-			splx(s);
+			mutex_exit(&grant_lock);
 			if (ratecheck(&xengnt_nonmemtime, &xengnt_nonmemintvl))
 				printf("xengnt_get_entry: out of grant "
 				    "table entries\n");
 			return XENGNT_NO_ENTRY;
+		}
+	}
 	KASSERT(gnt_entries[last_gnt_entry] == XENGNT_NO_ENTRY);
 	last_gnt_entry--;
 	entry = gnt_entries[last_gnt_entry];
 	gnt_entries[last_gnt_entry] = XENGNT_NO_ENTRY;
-	splx(s);
+	mutex_exit(&grant_lock);
 	KASSERT(entry != XENGNT_NO_ENTRY);
 	KASSERT(last_gnt_entry >= 0);
 	KASSERT(last_gnt_entry <= gnt_max_grant_frames * NR_GRANT_ENTRIES_PER_PAGE);
 	return entry;
+}
 /*
  * Mark the grant table entry as free
  */
 static void
 xengnt_free_entry(grant_ref_t entry)
+{
-	int s = splvm();
+	mutex_enter(&grant_lock);
 	KASSERT(gnt_entries[last_gnt_entry] == XENGNT_NO_ENTRY);
 	KASSERT(last_gnt_entry >= 0);
 	KASSERT(last_gnt_entry <= gnt_max_grant_frames * NR_GRANT_ENTRIES_PER_PAGE);
 	gnt_entries[last_gnt_entry] = entry;
 	last_gnt_entry++;
-	splx(s);
+	mutex_exit(&grant_lock);
+}
 int
 xengnt_grant_access(domid_t dom, paddr_t ma, int ro, grant_ref_t *entryp)
+{
 	*entryp = xengnt_get_entry();
 	if (__predict_false(*entryp == XENGNT_NO_ENTRY))
 		return ENOMEM;
 	mutex_enter(&grant_lock);
 	grant_table[*entryp].frame = ma >> PAGE_SHIFT;
 	grant_table[*entryp].domid = dom;
 	/*
 	 * ensure that the above values reach global visibility
 	 * before permitting frame's access (done when we set flags)
 	 */
 	xen_rmb();
 	grant_table[*entryp].flags =
 	    GTF_permit_access | (ro ? GTF_readonly : 0);
 	mutex_exit(&grant_lock);
 	return 0;
+}
 void
 xengnt_revoke_access(grant_ref_t entry)
+{
 	uint16_t flags, nflags;
 	nflags = grant_table[entry].flags;
 	do {
 		if ((flags = nflags) & (GTF_reading|GTF_writing))
 			panic("xengnt_revoke_access: still in use");
 		nflags = xen_atomic_cmpxchg16(&grant_table[entry].flags,
 		    flags, 0);
 	} while (nflags != flags);
 	xengnt_free_entry(entry);
+}
 int
 xengnt_grant_transfer(domid_t dom, grant_ref_t *entryp)
+{
 	*entryp = xengnt_get_entry();
 	if (__predict_false(*entryp == XENGNT_NO_ENTRY))
 		return ENOMEM;
 	mutex_enter(&grant_lock);
 	grant_table[*entryp].frame = 0;
 	grant_table[*entryp].domid = dom;
 	/*
 	 * ensure that the above values reach global visibility
 	 * before permitting frame's transfer (done when we set flags)
 	 */
 	xen_rmb();
 	grant_table[*entryp].flags = GTF_accept_transfer;
 	mutex_exit(&grant_lock);
 	return 0;
+}
 paddr_t
 xengnt_revoke_transfer(grant_ref_t entry)
+{
 	paddr_t page;
 	uint16_t flags;
 	/* if the transfer has not started, free the entry and return 0 */
 	while (!((flags = grant_table[entry].flags) & GTF_transfer_committed)) {
 		if (xen_atomic_cmpxchg16(&grant_table[entry].flags,
 		    flags, 0) == flags ) {