PERFORCE change 131944 for review

Kip Macy kmacy at FreeBSD.org
Fri Dec 28 17:34:11 PST 2007


http://perforce.freebsd.org/chv.cgi?CH=131944

Change 131944 by kmacy at pandemonium:kmacy:xen31 on 2007/12/29 01:33:52

	fix WITNESS complaints about xenbus
	compile in block and console devices
	we now hang waiting for block device interrupts when mounting root

Affected files ...

.. //depot/projects/xen31/sys/conf/files#11 edit
.. //depot/projects/xen31/sys/dev/xen/blkfront/blkfront.c#2 edit
.. //depot/projects/xen31/sys/dev/xen/console/console.c#2 edit
.. //depot/projects/xen31/sys/dev/xen/console/xencons_ring.c#2 edit
.. //depot/projects/xen31/sys/i386/include/xen/xen-public/io/console.h#1 add
.. //depot/projects/xen31/sys/xen/xenbus/xenbus_probe.c#3 edit
.. //depot/projects/xen31/sys/xen/xenbus/xenbus_xs.c#5 edit

Differences ...

==== //depot/projects/xen31/sys/conf/files#11 (text+ko) ====

@@ -2117,6 +2117,9 @@
 xen/xenbus/xenbus_dev.c		optional xen
 xen/xenbus/xenbus_probe.c	optional xen
 xen/xenbus/xenbus_xs.c		optional xen
+dev/xen/console/console.c	optional xen
+dev/xen/console/xencons_ring.c	optional xen
+dev/xen/blkfront/blkfront.c	optional xen
 
 #
 gnu/fs/xfs/xfs_alloc.c		optional xfs \

==== //depot/projects/xen31/sys/dev/xen/blkfront/blkfront.c#2 (text+ko) ====

@@ -37,17 +37,17 @@
 #include <machine/intr_machdep.h>
 #include <machine/vmparam.h>
 
-#include <machine/hypervisor.h>
-#include <machine/hypervisor-ifs.h>
-#include <machine/xen-os.h>
-#include <machine/xen_intr.h>
-#include <machine/xenbus.h>
-#include <machine/evtchn.h>
-#include <machine/xen-public/grant_table.h>
+#include <machine/xen/hypervisor.h>
+#include <machine/xen/hypervisor-ifs.h>
+#include <machine/xen/xen-os.h>
+#include <machine/xen/xen_intr.h>
+#include <machine/xen/xenbus.h>
+#include <machine/xen/evtchn.h>
+#include <machine/xen/xen-public/grant_table.h>
 
 #include <geom/geom_disk.h>
-#include <machine/xenfunc.h>
-#include <machine/gnttab.h>
+#include <machine/xen/xenfunc.h>
+#include <xen/gnttab.h>
 
 #include <dev/xen/blkfront/block.h>
 
@@ -245,8 +245,8 @@
 		return err;
 	}
 
-	info = malloc(sizeof(*info), M_DEVBUF, M_WAITOK);
-	if (!info) {
+	info = malloc(sizeof(*info), M_DEVBUF, M_NOWAIT);
+	if (info == NULL) {
 		xenbus_dev_fatal(dev, ENOMEM, "allocating info structure");
 		return ENOMEM;
 	}
@@ -362,8 +362,8 @@
 
 	info->ring_ref = GRANT_INVALID_REF;
 
-	sring = (blkif_sring_t *)malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK);
-	if (!sring) {
+	sring = (blkif_sring_t *)malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);
+	if (sring == NULL) {
 		xenbus_dev_fatal(dev, ENOMEM, "allocating shared ring");
 		return ENOMEM;
 	}
@@ -473,10 +473,10 @@
 	(void)xenbus_switch_state(info->xbdev, NULL, XenbusStateConnected); 
 
 	/* Kick pending requests. */
-	mtx_lock_spin(&blkif_io_lock);
+	mtx_lock(&blkif_io_lock);
 	info->connected = BLKIF_STATE_CONNECTED;
 	kick_pending_request_queues(info);
-	mtx_unlock_spin(&blkif_io_lock);
+	mtx_unlock(&blkif_io_lock);
 
 #if 0
 	add_disk(info->gd);
@@ -577,9 +577,10 @@
 static void blkif_restart_queue(void *arg)
 {
 	struct blkfront_info *info = (struct blkfront_info *)arg;
-	mtx_lock_spin(&blkif_io_lock);
+
+	mtx_lock(&blkif_io_lock);
 	kick_pending_request_queues(info);
-	mtx_unlock_spin(&blkif_io_lock);
+	mtx_unlock(&blkif_io_lock);
 }
 #endif
 
@@ -794,16 +795,15 @@
 	struct bio *bp;
 	blkif_response_t *bret;
 	RING_IDX i, rp;
-	unsigned long flags;
 	struct blkfront_info *info = xsc;
 	DPRINTK("");
 
 	TRACE_ENTER;
 
-	mtx_lock_irqsave(&blkif_io_lock, flags);
+	mtx_lock(&blkif_io_lock);
 
 	if (unlikely(info->connected != BLKIF_STATE_CONNECTED)) {
-		mtx_unlock_irqrestore(&blkif_io_lock, flags);
+		mtx_unlock(&blkif_io_lock);
 		return;
 	}
 
@@ -870,7 +870,7 @@
 
 	kick_pending_request_queues(info);
 
-	mtx_unlock_irqrestore(&blkif_io_lock, flags);
+	mtx_unlock(&blkif_io_lock);
 }
 
 static void 
@@ -878,10 +878,10 @@
 {
 	
 /* Prevent new requests being issued until we fix things up. */
-	mtx_lock_spin(&blkif_io_lock);
+	mtx_lock(&blkif_io_lock);
 	info->connected = suspend ? 
 		BLKIF_STATE_SUSPENDED : BLKIF_STATE_DISCONNECTED; 
-	mtx_unlock_spin(&blkif_io_lock);
+	mtx_unlock(&blkif_io_lock);
 
 	/* Free resources associated with old device channel. */
 	if (info->ring_ref != GRANT_INVALID_REF) {
@@ -957,17 +957,17 @@
 	(void)xenbus_switch_state(info->xbdev, NULL, XenbusStateConnected); 
 	
 	/* Now safe for us to use the shared ring */
-	mtx_lock_spin(&blkif_io_lock);
-        info->connected = BLKIF_STATE_CONNECTED;
-	mtx_unlock_spin(&blkif_io_lock);
+	mtx_lock(&blkif_io_lock);
+	info->connected = BLKIF_STATE_CONNECTED;
+	mtx_unlock(&blkif_io_lock);
 
 	/* Send off requeued requests */
 	flush_requests(info);
 
 	/* Kick any other new requests queued since we resumed */
-	mtx_lock_spin(&blkif_io_lock);
+	mtx_lock(&blkif_io_lock);
 	kick_pending_request_queues(info);
-	mtx_unlock_spin(&blkif_io_lock);
+	mtx_unlock(&blkif_io_lock);
 }
 
 static struct xenbus_device_id blkfront_ids[] = {
@@ -993,7 +993,7 @@
 	xenbus_register_frontend(&blkfront);
 }
 
-MTX_SYSINIT(ioreq, &blkif_io_lock, "BIO LOCK", MTX_SPIN | MTX_NOWITNESS); /* XXX how does one enroll a lock? */
+MTX_SYSINIT(ioreq, &blkif_io_lock, "BIO LOCK", MTX_NOWITNESS); /* XXX how does one enroll a lock? */
 MTX_SYSINIT(ioreq_block, &blkif_io_block_lock, "BIO BLOCK LOCK", MTX_SPIN | MTX_NOWITNESS);
 SYSINIT(xbdev, SI_SUB_PSEUDO, SI_ORDER_SECOND, xenbus_init, NULL);
 

==== //depot/projects/xen31/sys/dev/xen/console/console.c#2 (text+ko) ====

@@ -14,14 +14,14 @@
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <machine/stdarg.h>
-#include <machine/xen-os.h>
-#include <machine/hypervisor.h>
-#include <machine/xen_intr.h>
+#include <machine/xen/xen-os.h>
+#include <machine/xen/hypervisor.h>
+#include <machine/xen/xen_intr.h>
 #include <sys/cons.h>
 #include <sys/priv.h>
 
 #include <dev/xen/console/xencons_ring.h>
-#include <machine/xen-public/io/console.h>
+#include <machine/xen/xen-public/io/console.h>
 
 
 #include "opt_ddb.h"

==== //depot/projects/xen31/sys/dev/xen/console/xencons_ring.c#2 (text+ko) ====

@@ -14,16 +14,17 @@
 #include <sys/kernel.h>
 #include <sys/bus.h>
 #include <machine/stdarg.h>
-#include <machine/xen-os.h>
-#include <machine/hypervisor.h>
-#include <machine/xen_intr.h>
+#include <machine/xen/xen-os.h>
+#include <machine/xen/hypervisor.h>
+#include <machine/xen/xen_intr.h>
 #include <sys/cons.h>
 
 
 #include <dev/xen/console/xencons_ring.h>
-#include <machine/xen-public/io/console.h>
+#include <machine/xen/xen-public/io/console.h>
 
 
+#define console_evtchn	console.domU.evtchn
 extern char *console_page;
  
 static inline struct xencons_interface *

==== //depot/projects/xen31/sys/xen/xenbus/xenbus_probe.c#3 (text+ko) ====

@@ -48,6 +48,7 @@
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/bus.h>
+#include <sys/sx.h>
 
 #include <machine/xen/hypervisor.h>
 #include <machine/xen/xenbus.h>
@@ -81,7 +82,7 @@
 struct xendev_list_head xenbus_device_backend_list;
 static LIST_HEAD(, xenbus_driver) xendrv_list; 
 
-extern struct sema xenwatch_mutex;
+extern struct sx xenwatch_mutex;
 
 EVENTHANDLER_DECLARE(xenstore_event, xenstore_event_handler_t);
 static struct eventhandler_list *xenstore_chain;
@@ -563,12 +564,11 @@
 	drv->driver.probe = xenbus_dev_probe;
 	drv->driver.remove = xenbus_dev_remove;
 
-
 	return ret;
 #endif
-	down(&xenwatch_mutex);
+	sx_xlock(&xenwatch_mutex);
 	LIST_INSERT_HEAD(&xendrv_list, drv, list);
-	up(&xenwatch_mutex);
+	sx_xunlock(&xenwatch_mutex);
 	LIST_FOREACH(xdev, bus->bus, list) {
 		if (match_device(drv->ids, xdev)) {
 			xdev->driver = drv;

==== //depot/projects/xen31/sys/xen/xenbus/xenbus_xs.c#5 (text+ko) ====

@@ -37,6 +37,9 @@
 #include <sys/uio.h>
 #include <sys/kernel.h>
 #include <sys/time.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/sx.h>
 #include <sys/sema.h>
 #include <sys/malloc.h>
 #include <sys/libkern.h>
@@ -98,7 +101,7 @@
 		int reply_waitq;
 
 		/* One request at a time. */
-		struct semaphore request_mutex;
+		struct sx request_mutex;
 
 		/* Protect transactions against save/restore. */
 		struct rw_semaphore suspend_mutex;
@@ -119,7 +122,7 @@
  * carrying out work.
  */
 static pid_t xenwatch_pid;
-/* static */ DECLARE_MUTEX(xenwatch_mutex);
+struct sx xenwatch_mutex;
 static int watch_events_waitq;
 
 static int get_error(const char *errorstring)
@@ -184,12 +187,12 @@
 		msg.type = XS_DEBUG;
 		msg.len = sizeof("print") + count + 1;
 
-		down(&xs_state.request_mutex);
+		sx_xlock(&xs_state.request_mutex);
 		xb_write(&msg, sizeof(msg));
 		xb_write("print", sizeof("print"));
 		xb_write(str, count);
 		xb_write("", 1);
-		up(&xs_state.request_mutex);
+		sx_xunlock(&xs_state.request_mutex);
 }
 
 #endif
@@ -202,7 +205,7 @@
 		if (req_msg.type == XS_TRANSACTION_START)
 				down_read(&xs_state.suspend_mutex);
 
-		down(&xs_state.request_mutex);
+		sx_xlock(&xs_state.request_mutex);
 
 		err = xb_write(msg, sizeof(*msg) + msg->len);
 		if (err) {
@@ -212,7 +215,7 @@
 				ret = read_reply(&msg->type, &msg->len);
 		}
 
-		up(&xs_state.request_mutex);
+		sx_xunlock(&xs_state.request_mutex);
 
 		if ((msg->type == XS_TRANSACTION_END) ||
 			((req_msg.type == XS_TRANSACTION_START) &&
@@ -241,25 +244,25 @@
 		for (i = 0; i < num_vecs; i++)
 				msg.len += iovec[i].iov_len;
 
-		down(&xs_state.request_mutex);
+		sx_xlock(&xs_state.request_mutex);
 
 		err = xb_write(&msg, sizeof(msg));
 		if (err) {
-				up(&xs_state.request_mutex);
+				sx_xunlock(&xs_state.request_mutex);
 				return ERR_PTR(err);
 		}
 
 		for (i = 0; i < num_vecs; i++) {
 				err = xb_write(iovec[i].iov_base, iovec[i].iov_len);;
-				if (err) {
-						up(&xs_state.request_mutex);
+				if (err) {		
+						sx_xunlock(&xs_state.request_mutex);
 						return ERR_PTR(err);
 				}
 		}
 
 		ret = read_reply(&msg.type, len);
 
-		up(&xs_state.request_mutex);
+		sx_xunlock(&xs_state.request_mutex);
 
 		if (IS_ERR(ret))
 				return ret;
@@ -689,8 +692,8 @@
 
 		/* Flush any currently-executing callback, unless we are it. :-) */
 		if (curproc->p_pid != xenwatch_pid) {
-				down(&xenwatch_mutex);
-				up(&xenwatch_mutex);
+				sx_xlock(&xenwatch_mutex);
+				sx_xunlock(&xenwatch_mutex);
 		}
 }
 EXPORT_SYMBOL(unregister_xenbus_watch);
@@ -698,7 +701,7 @@
 void xs_suspend(void)
 {
 		down_write(&xs_state.suspend_mutex);
-		down(&xs_state.request_mutex);
+		sx_xlock(&xs_state.request_mutex);
 }
 
 void xs_resume(void)
@@ -706,7 +709,7 @@
 		struct xenbus_watch *watch;
 		char token[sizeof(watch) * 2 + 1];
 
-		up(&xs_state.request_mutex);
+		sx_xunlock(&xs_state.request_mutex);
 
 		/* No need for watches_lock: the suspend_mutex is sufficient. */
 		LIST_FOREACH(watch, &watches, list) {
@@ -725,7 +728,7 @@
 				wait_event_interruptible(&watch_events_waitq,
 										 !list_empty(&watch_events));
 
-				down(&xenwatch_mutex);
+				sx_xlock(&xenwatch_mutex);
 
 				spin_lock(&watch_events_lock);
 				msg = TAILQ_FIRST(&watch_events);
@@ -743,7 +746,7 @@
 						kfree(msg);
 				}
 
-				up(&xenwatch_mutex);
+				sx_xunlock(&xenwatch_mutex);
 		}
 }
 
@@ -829,13 +832,14 @@
 		TAILQ_INIT(&xs_state.reply_list);
 		TAILQ_INIT(&watch_events);
 		mtx_init(&xs_state.reply_lock, "state reply", NULL, MTX_DEF);
-		sema_init(&xs_state.request_mutex, 1, "xenstore request");
 		sema_init(&xs_state.suspend_mutex, 1, "xenstore suspend");
-		sema_init(&xenwatch_mutex, 1, "xenwatch");
+		sx_init(&xenwatch_mutex, "xenwatch");
+		sx_init(&xs_state.request_mutex, "xenstore request");
+		
 #if 0
-		mtx_init(&xs_state.request_mutex, "xenstore request", NULL, MTX_DEF);
 		mtx_init(&xs_state.suspend_mutex, "xenstore suspend", NULL, MTX_DEF);
-		mtx_init(&xenwatch_mutex, "xenwatch", NULL, MTX_DEF);
+		sema_init(&xs_state.request_mutex, 1, "xenstore request");
+		sema_init(&xenwatch_mutex, 1, "xenwatch");
 #endif
 		mtx_init(&watches_lock, "watches", NULL, MTX_DEF);
 		mtx_init(&watch_events_lock, "watch events", NULL, MTX_DEF);


More information about the p4-projects mailing list