Synchronize Xen support with current, excluding console API changes in

the PV Xen console driver.

Merged revisions
================
r199734 | kmacy | 2009-11-24 00:17:51 -0700 (Tue, 24 Nov 2009) | 2 lines

    fixup kernel core dumps on paravirtual guests

r199959 | kmacy | 2009-11-29 21:20:43 -0700 (Sun, 29 Nov 2009) | 3 lines

    Update license to reflect terms in xen 2.0 as of the time when the
    driver was ported to FreeBSD

r199960 | kmacy | 2009-11-29 21:32:34 -0700 (Sun, 29 Nov 2009) | 2 lines

    Merge Scott Long's latest blkfront now that the licensing issues are
    resolved

r201234 | gibbs | 2009-12-29 16:28:13 -0700 (Tue, 29 Dec 2009) | 5 lines

    Correct bug introduced while purging the -ERRNO Linuxism from the
    grant table API.  Valid grant refs are in the range of positive 32bit
    integers.  ENOSPACE, being 29, is also a positive integer.  Return
    GNTTAB_LIST_END (-1) instead when gnttab_claim_grant_reference() fails.

r201138 | gibbs | 2009-12-28 11:59:13 -0700 (Mon, 28 Dec 2009) | 8 lines

    Correct alignment and boundary constraints in blkfront's bus dma tag.  The
    blkif interface in Xen requires all I/O to be 512 byte aligned with each
    segment bounded by a 4k page.

    Note: This submission only documents the proper contraints for blkif I/O.
          The alignment code in busdma does not yet handle alignment constraints
          correctly in all cases.

r201236 | gibbs | 2009-12-29 16:31:21 -0700 (Tue, 29 Dec 2009) | 3 lines

    In blkif_queue_cb(), test the return value from
    gnttab_claim_grant_reference() for >= 0 instead of != ENOSPC.

r204159 | kmacy | 2010-02-20 18:12:18 -0700 (Sat, 20 Feb 2010) | 2 lines

    don't hold spin lock across free

r214077 | gibbs | 2010-10-19 14:53:30 -0600 (Tue, 19 Oct 2010) | 342 lines

    Improve the Xen para-virtualized device infrastructure of FreeBSD:

     o Add support for backend devices (e.g. blkback)
     o Implement extensions to the Xen para-virtualized block API to allow
       for larger and more outstanding I/Os.
     o Import a completely rewritten block back driver with support for
       fronting I/O to both raw devices and files.
     o General cleanup and documentation of the XenBus and XenStore support
       code.
     o Robustness and performance updates for the block front driver.
     o Fixes to the netfront driver.

    Sponsored by: Spectra Logic Corporation

    sys/xen/xenbus/init.txt:
            Deleted: This file explains the Linux method for XenBus device
            enumeration and thus does not apply to FreeBSD's NewBus approach.

    sys/xen/xenbus/xenbus_probe_backend.c:
           Deleted: Linux version of backend XenBus service routines.  It
           was never ported to FreeBSD.  See xenbusb.c, xenbusb_if.m,
           xenbusb_front.c xenbusb_back.c for details of FreeBSD's XenBus
           support.

    sys/xen/xenbus/xenbusvar.h:
    sys/xen/xenbus/xenbus_xs.c:
    sys/xen/xenbus/xenbus_comms.c:
    sys/xen/xenbus/xenbus_comms.h:
    sys/xen/xenstore/xenstorevar.h:
    sys/xen/xenstore/xenstore.c:
            Split XenStore into its own tree.  XenBus is a software layer
            built on top of XenStore.  The old arrangement and the naming of
            some structures and functions blurred these lines making it
            difficult to discern what services are provided by which layer
            and at what times these services are available (e.g. during
            system startup and shutdown).

    sys/xen/xenbus/xenbus_client.c:
    sys/xen/xenbus/xenbus.c:
    sys/xen/xenbus/xenbus_probe.c:
    sys/xen/xenbus/xenbusb.c:
    sys/xen/xenbus/xenbusb.h:
            Split up XenBus code into methods available for use by client
            drivers (xenbus.c) and code used by the XenBus "bus code" to
            enumerate, attach, detach, and service bus drivers.

    sys/xen/reboot.c:
    sys/dev/xen/control/control.c:
	    Add a XenBus front driver for handling shutdown, reboot,
	    suspend, and resume events published in the XenStore.
	    Move all PV suspend/reboot support from reboot.c into
	    this driver.

    sys/xen/blkif.h:
            New file from Xen vendor with macros and structures used by
            a block back driver to service requests from a VM running a
            different ABI (e.g. amd64 back with i386 front).

    sys/conf/files:
            Adjust kernel build spec for new XenBus/XenStore layout and added
            Xen functionality.

    sys/dev/xen/balloon/balloon.c:
    sys/dev/xen/netfront/netfront.c:
    sys/dev/xen/blkfront/blkfront.c:
    sys/xen/xenbus/...
    sys/xen/xenstore/...
            o Rename XenStore APIs and structures from xenbus_* to xs_*.
	    o Adjust to use of M_XENBUS and M_XENSTORE malloc types
	      for allocation of objects returned by these APIs.
	    o Adjust for changes in the bus interface for Xen
	    drivers.

    sys/xen/xenbus/...
    sys/xen/xenstore/...
            Add Doxygen comments for these interfaces and the code that
            implements them.

    sys/dev/xen/blkback/blkback.c:
            o Rewrite the Block Back driver to attach properly via newbus,
              operate correctly in both PV and HVM mode regardless of domain
              (e.g. can be in a DOM other than 0), and to deal with the latest
              metadata available in XenStore for block devices.

            o Allow users to specify a file as a backend to blkback, in addition
              to character devices.  Use the namei lookup of the backend path
              to automatically configure, based on file type, the appropriate
              backend method.

            The current implementation is limited to a single outstanding I/O
            at a time to file backed storage.

    sys/dev/xen/blkback/blkback.c:
    sys/xen/interface/io/blkif.h:
    sys/xen/blkif.h:
    sys/dev/xen/blkfront/blkfront.c:
    sys/dev/xen/blkfront/block.h:
            Extend the Xen blkif API: Negotiable request size and number of
            requests.

            This change extends the information recorded in the XenStore
            allowing block front/back devices to negotiate for optimal I/O
            parameters.  This has been achieved without sacrificing backward
            compatibility with drivers that are unaware of these protocol
            enhancements.  The extensions center around the connection protocol
            which now includes these additions:

            o The back-end device publishes its maximum supported values for,
              request I/O size, the number of page segments that can be
              associated with a request, the maximum number of requests that
              can be concurrently active, and the maximum number of pages that
              can be in the shared request ring.  These values are published
              before the back-end enters the XenbusStateInitWait state.

            o The front-end waits for the back-end to enter either the InitWait
              or Initialize state.  At this point, the front end limits it's
              own capabilities to the lesser of the values it finds published
              by the backend, it's own maximums, or, should any back-end data
              be missing in the store, the values supported by the original
              protocol.  It then initializes it's internal data structures
              including allocation of the shared ring, publishes its maximum
              capabilities to the XenStore and transitions to the Initialized
              state.

            o The back-end waits for the front-end to enter the Initalized
              state.  At this point, the back end limits it's own capabilities
              to the lesser of the values it finds published by the frontend,
              it's own maximums, or, should any front-end data be missing in
              the store, the values supported by the original protocol.  It
              then initializes it's internal data structures, attaches to the
              shared ring and transitions to the Connected state.

            o The front-end waits for the back-end to enter the Connnected
              state, transitions itself to the connected state, and can
              commence I/O.

            Although an updated front-end driver must be aware of the back-end's
            InitWait state, the back-end has been coded such that it can
            tolerate a front-end that skips this step and transitions directly
            to the Initialized state without waiting for the back-end.

    sys/xen/interface/io/blkif.h:
            o Increase BLKIF_MAX_SEGMENTS_PER_REQUEST to 255.  This is
              the maximum number possible without changing the blkif
              request header structure (nr_segs is a uint8_t).

            o Add two new constants:
              BLKIF_MAX_SEGMENTS_PER_HEADER_BLOCK, and
              BLKIF_MAX_SEGMENTS_PER_SEGMENT_BLOCK.  These respectively
              indicate the number of segments that can fit in the first
              ring-buffer entry of a request, and for each subsequent
              (sg element only) ring-buffer entry associated with the
              "header" ring-buffer entry of the request.

            o Add the blkif_request_segment_t typedef for segment
              elements.

            o Add the BLKRING_GET_SG_REQUEST() macro which wraps the
              RING_GET_REQUEST() macro and returns a properly cast
              pointer to an array of blkif_request_segment_ts.

            o Add the BLKIF_SEGS_TO_BLOCKS() macro which calculates the
              number of ring entries that will be consumed by a blkif
              request with the given number of segments.

    sys/xen/blkif.h:
            o Update for changes in interface/io/blkif.h macros.

            o Update the BLKIF_MAX_RING_REQUESTS() macro to take the
              ring size as an argument to allow this calculation on
              multi-page rings.

            o Add a companion macro to BLKIF_MAX_RING_REQUESTS(),
              BLKIF_RING_PAGES().  This macro determines the number of
              ring pages required in order to support a ring with the
              supplied number of request blocks.

    sys/dev/xen/blkback/blkback.c:
    sys/dev/xen/blkfront/blkfront.c:
    sys/dev/xen/blkfront/block.h:
            o Negotiate with the other-end with the following limits:
                  Reqeust Size:   MAXPHYS
                  Max Segments:   (MAXPHYS/PAGE_SIZE) + 1
                  Max Requests:   256
                  Max Ring Pages: Sufficient to support Max Requests with
                                  Max Segments.

            o Dynamically allocate request pools and segemnts-per-request.

            o Update ring allocation/attachment code to support a
              multi-page shared ring.

            o Update routines that access the shared ring to handle
              multi-block requests.

    sys/dev/xen/blkfront/blkfront.c:
            o Track blkfront allocations in a blkfront driver specific
              malloc pool.

            o Strip out XenStore transaction retry logic in the
              connection code.  Transactions only need to be used when
              the update to multiple XenStore nodes must be atomic.
              That is not the case here.

            o Fully disable blkif_resume() until it can be fixed
              properly (it didn't work before this change).

            o Destroy bus-dma objects during device instance tear-down.

            o Properly handle backend devices with powef-of-2 sector
              sizes larger than 512b.

    sys/dev/xen/blkback/blkback.c:
            Advertise support for and implement the BLKIF_OP_WRITE_BARRIER
            and BLKIF_OP_FLUSH_DISKCACHE blkif opcodes using BIO_FLUSH and
            the BIO_ORDERED attribute of bios.

    sys/dev/xen/blkfront/blkfront.c:
    sys/dev/xen/blkfront/block.h:
            Fix various bugs in blkfront.

           o gnttab_alloc_grant_references() returns 0 for success and
             non-zero for failure.  The check for < 0 is a leftover
             Linuxism.

           o When we negotiate with blkback and have to reduce some of our
             capabilities, print out the original and reduced capability before
             changing the local capability.  So the user now gets the correct
             information.

            o Fix blkif_restart_queue_callback() formatting.  Make sure we hold
              the mutex in that function before calling xb_startio().

            o Fix a couple of KASSERT()s.

            o Fix a check in the xb_remove_* macro to be a little more specific.

    sys/xen/gnttab.h:
    sys/xen/gnttab.c:
            Define GNTTAB_LIST_END publicly as GRANT_REF_INVALID.

    sys/dev/xen/netfront/netfront.c:
            Use GRANT_REF_INVALID instead of driver private definitions of the
            same constant.

    sys/xen/gnttab.h:
    sys/xen/gnttab.c:
            Add the gnttab_end_foreign_access_references() API.

	    This API allows a client to batch the release of an
	    array of grant references, instead of coding a private
	    for loop.  The implementation takes advantage of this
	    batching to reduce lock overhead to one acquisition and
	    release per-batch instead of per-freed grant reference.

	    While here, reduce the duration the gnttab_list_lock
	    is held during gnttab_free_grant_references() operations.
	    The search to find the tail of the incoming free list
	    does not rely on global state and so can be performed
	    without holding the lock.

    sys/dev/xen/xenpci/evtchn.c:
    sys/dev/xen/evtchn/evtchn.c:
    sys/xen/xen_intr.h:
	    o Implement the bind_interdomain_evtchn_to_irqhandler
	      API for HVM mode.  This allows an HVM domain to serve
	      back end devices to other domains.  This API is already
	      implemented for PV mode.

            o Synchronize the API between HVM and PV.

    sys/dev/xen/xenpci/xenpci.c:
	    o Scan the full region of CPUID space in which the Xen
	      VMM interface may be implemented.  On systems using
	      SuSE as a Dom0 where the Viridian API is also exported,
	      the VMM interface is above the region we used to
	      search.

            o Pass through bus_alloc_resource() calls so that XenBus drivers
              attaching on an HVM system can allocate unused physical address
              space from the nexus.  The block back driver makes use of this
              facility.

    sys/i386/xen/xen_machdep.c:
            Use the correct type for accessing the statically mapped xenstore
            metadata.

    sys/xen/interface/hvm/params.h:
    sys/xen/xenstore/xenstore.c:
            Move hvm_get_parameter() to the correct global header file instead
            of as a private method to the XenStore.

    sys/xen/interface/io/protocols.h:
            Sync with vendor.

    sys/xeninterface/io/ring.h:
            Add macro for calculating the number of ring pages needed for an N
            deep ring.

            To avoid duplication within the macros, create and use the new
            __RING_HEADER_SIZE() macro.  This macro calculates the size of the
            ring book keeping struct (producer/consumer indexes, etc.) that
            resides at the head of the ring.

            Add the __RING_PAGES() macro which calculates the number of shared
            ring pages required to support a ring with the given number of
            requests.

            These APIs are used to support the multi-page ring version of the
            Xen block API.

    sys/xeninterface/io/xenbus.h:
            Add Comments.

    sys/xen/xenbus/...
	    o Refactor the FreeBSD XenBus support code to allow for
	      both front and backend device attachments.

            o Make use of new config_intr_hook capabilities to allow
              front and back devices to be probed/attached in parallel.

	    o Fix bugs in probe/attach state machine that could
	      cause the system to hang when confronted with a failure
	      either in the local domain or in a remote domain to
	      which one of our driver instances is attaching.

	    o Publish all required state to the XenStore on device
	      detach and failure.  The majority of the missing
	      functionality was for serving as a back end since the
	      typical "hot-plug" scripts in Dom0 don't handle the
	      case of cleaning up for a "service domain" that is
	      not itself.

            o Add dynamic sysctl nodes exposing the generic ivars of
              XenBus devices.

            o Add doxygen style comments to the majority of the code.

            o Cleanup types, formatting, etc.

    sys/xen/xenbus/xenbusb.c:
            Common code used by both front and back XenBus busses.

    sys/xen/xenbus/xenbusb_if.m:
            Method definitions for a XenBus bus.

    sys/xen/xenbus/xenbusb_front.c:
    sys/xen/xenbus/xenbusb_back.c:
            XenBus bus specialization for front and back devices.

r214444 | gibbs | 2010-10-27 22:14:28 -0600 (Wed, 27 Oct 2010) | 9 lines

    sys/dev/xen/blkback/blkback.c:
            In xbb_detach() only perform cleanup of our taskqueue and
            device statistics structures if they have been initialized.
            This avoids a panic when xbb_detach() is called on a partially
            initialized device instance, due to an early failure in
            attach.

    Sponsored by:   Spectra Logic Corporation

r215681 | jhb | 2010-11-22 08:15:11 -0700 (Mon, 22 Nov 2010) | 2 lines

    Remove some bogus, self-referential mergeinfo.

r215682 | jhb | 2010-11-22 08:26:47 -0700 (Mon, 22 Nov 2010) | 5 lines

    Purge mergeinfo on sys/dev/xen/xenpci.  The only unique mergeinfo compared
    to head was not useful (it came in with the merge from /user/dfr/xenhvm/7
    and that mergeinfo is still present at sys/) and not worth keeping an extra
    set of mergeinfo around in the kernel.

1 files changed, 39 insertions, 33 deletions

diff --git a/sys/dev/xen/netfront/netfront.c b/sys/dev/xen/netfront/netfront.c
index a6fd9ea28866..423df9761546 100644
--- a/sys/dev/xen/netfront/netfront.c
+++ b/sys/dev/xen/netfront/netfront.c
@@ -91,8 +91,6 @@ __FBSDID("$FreeBSD$");
 
 #define XN_CSUM_FEATURES	(CSUM_TCP | CSUM_UDP | CSUM_TSO)
 
-#define GRANT_INVALID_REF	0
-
 #define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE)
 #define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE)
 
@@ -373,7 +371,8 @@ xennet_get_rx_ref(struct netfront_info *np, RING_IDX ri)
 {
 	int i = xennet_rxidx(ri);
 	grant_ref_t ref = np->grant_rx_ref[i];
-	np->grant_rx_ref[i] = GRANT_INVALID_REF;
+	KASSERT(ref != GRANT_REF_INVALID, ("Invalid grant reference!\n"));
+	np->grant_rx_ref[i] = GRANT_REF_INVALID;
 	return ref;
 }
 
@@ -404,7 +403,7 @@ xen_net_read_mac(device_t dev, uint8_t mac[])
 	int error, i;
 	char *s, *e, *macstr;
 
-	error = xenbus_read(XBT_NIL, xenbus_get_node(dev), "mac", NULL,
+	error = xs_read(XST_NIL, xenbus_get_node(dev), "mac", NULL,
 	    (void **) &macstr);
 	if (error)
 		return (error);
@@ -413,12 +412,12 @@ xen_net_read_mac(device_t dev, uint8_t mac[])
 	for (i = 0; i < ETHER_ADDR_LEN; i++) {
 		mac[i] = strtoul(s, &e, 16);
 		if (s == e || (e[0] != ':' && e[0] != 0)) {
-			free(macstr, M_DEVBUF);
+			free(macstr, M_XENBUS);
 			return (ENOENT);
 		}
 		s = &e[1];
 	}
-	free(macstr, M_DEVBUF);
+	free(macstr, M_XENBUS);
 	return (0);
 }
 
@@ -483,7 +482,7 @@ static int
 talk_to_backend(device_t dev, struct netfront_info *info)
 {
 	const char *message;
-	struct xenbus_transaction xbt;
+	struct xs_transaction xst;
 	const char *node = xenbus_get_node(dev);
 	int err;
 
@@ -499,54 +498,54 @@ talk_to_backend(device_t dev, struct netfront_info *info)
 		goto out;
 	
  again:
-	err = xenbus_transaction_start(&xbt);
+	err = xs_transaction_start(&xst);
 	if (err) {
 		xenbus_dev_fatal(dev, err, "starting transaction");
 		goto destroy_ring;
 	}
-	err = xenbus_printf(xbt, node, "tx-ring-ref","%u",
+	err = xs_printf(xst, node, "tx-ring-ref","%u",
 			info->tx_ring_ref);
 	if (err) {
 		message = "writing tx ring-ref";
 		goto abort_transaction;
 	}
-	err = xenbus_printf(xbt, node, "rx-ring-ref","%u",
+	err = xs_printf(xst, node, "rx-ring-ref","%u",
 			info->rx_ring_ref);
 	if (err) {
 		message = "writing rx ring-ref";
 		goto abort_transaction;
 	}
-	err = xenbus_printf(xbt, node,
+	err = xs_printf(xst, node,
 			"event-channel", "%u", irq_to_evtchn_port(info->irq));
 	if (err) {
 		message = "writing event-channel";
 		goto abort_transaction;
 	}
-	err = xenbus_printf(xbt, node, "request-rx-copy", "%u",
+	err = xs_printf(xst, node, "request-rx-copy", "%u",
 			info->copying_receiver);
 	if (err) {
 		message = "writing request-rx-copy";
 		goto abort_transaction;
 	}
-	err = xenbus_printf(xbt, node, "feature-rx-notify", "%d", 1);
+	err = xs_printf(xst, node, "feature-rx-notify", "%d", 1);
 	if (err) {
 		message = "writing feature-rx-notify";
 		goto abort_transaction;
 	}
-	err = xenbus_printf(xbt, node, "feature-sg", "%d", 1);
+	err = xs_printf(xst, node, "feature-sg", "%d", 1);
 	if (err) {
 		message = "writing feature-sg";
 		goto abort_transaction;
 	}
 #if __FreeBSD_version >= 700000
-	err = xenbus_printf(xbt, node, "feature-gso-tcpv4", "%d", 1);
+	err = xs_printf(xst, node, "feature-gso-tcpv4", "%d", 1);
 	if (err) {
 		message = "writing feature-gso-tcpv4";
 		goto abort_transaction;
 	}
 #endif
 
-	err = xenbus_transaction_end(xbt, 0);
+	err = xs_transaction_end(xst, 0);
 	if (err) {
 		if (err == EAGAIN)
 			goto again;
@@ -557,7 +556,7 @@ talk_to_backend(device_t dev, struct netfront_info *info)
 	return 0;
 	
  abort_transaction:
-	xenbus_transaction_end(xbt, 1);
+	xs_transaction_end(xst, 1);
 	xenbus_dev_fatal(dev, err, "%s", message);
  destroy_ring:
 	netif_free(info);
@@ -576,8 +575,8 @@ setup_device(device_t dev, struct netfront_info *info)
 	
 	ifp = info->xn_ifp;
 
-	info->tx_ring_ref = GRANT_INVALID_REF;
-	info->rx_ring_ref = GRANT_INVALID_REF;
+	info->tx_ring_ref = GRANT_REF_INVALID;
+	info->rx_ring_ref = GRANT_REF_INVALID;
 	info->rx.sring = NULL;
 	info->tx.sring = NULL;
 	info->irq = 0;
@@ -750,7 +749,7 @@ netif_release_tx_bufs(struct netfront_info *np)
 		    GNTMAP_readonly);
 		gnttab_release_grant_reference(&np->gref_tx_head,
 		    np->grant_tx_ref[i]);
-		np->grant_tx_ref[i] = GRANT_INVALID_REF;
+		np->grant_tx_ref[i] = GRANT_REF_INVALID;
 		add_id_to_freelist(np->tx_mbufs, i);
 		np->xn_cdata.xn_tx_chain_cnt--;
 		if (np->xn_cdata.xn_tx_chain_cnt < 0) {
@@ -854,7 +853,8 @@ refill:
 		sc->rx_mbufs[id] = m_new;
 
 		ref = gnttab_claim_grant_reference(&sc->gref_rx_head);
-		KASSERT((short)ref >= 0, ("negative ref"));
+		KASSERT(ref != GNTTAB_LIST_END,
+			("reserved grant references exhuasted"));
 		sc->grant_rx_ref[id] = ref;
 
 		vaddr = mtod(m_new, vm_offset_t);
@@ -1135,7 +1135,7 @@ xn_txeof(struct netfront_info *np)
 				np->grant_tx_ref[id]);
 			gnttab_release_grant_reference(
 				&np->gref_tx_head, np->grant_tx_ref[id]);
-			np->grant_tx_ref[id] = GRANT_INVALID_REF;
+			np->grant_tx_ref[id] = GRANT_REF_INVALID;
 			
 			np->tx_mbufs[id] = NULL;
 			add_id_to_freelist(np->tx_mbufs, id);
@@ -1318,12 +1318,13 @@ xennet_get_responses(struct netfront_info *np,
 		 * the backend driver. In future this should flag the bad
 		 * situation to the system controller to reboot the backed.
 		 */
-		if (ref == GRANT_INVALID_REF) {
+		if (ref == GRANT_REF_INVALID) {
 
 #if 0 				
 			if (net_ratelimit())
 				WPRINTK("Bad rx response id %d.\n", rx->id);
 #endif			
+			printf("%s: Bad rx response id %d.\n", __func__,rx->id);
 			err = EINVAL;
 			goto next;
 		}
@@ -1384,7 +1385,7 @@ next_skip_queue:
 			err = ENOENT;
 			printf("%s: cons %u frags %u rp %u, not enough frags\n",
 			       __func__, *cons, frags, rp);
-				break;
+			break;
 		}
 		/*
 		 * Note that m can be NULL, if rx->status < 0 or if
@@ -1526,6 +1527,11 @@ xn_assemble_tx_request(struct netfront_info *sc, struct mbuf *m_head)
 	 * tell the TCP stack to generate a shorter chain of packets.
 	 */
 	if (nfrags > MAX_TX_REQ_FRAGS) {
+#ifdef DEBUG
+		printf("%s: nfrags %d > MAX_TX_REQ_FRAGS %d, netback "
+		       "won't be able to handle it, dropping\n",
+		       __func__, nfrags, MAX_TX_REQ_FRAGS);
+#endif
 		m_freem(m_head);
 		return (EMSGSIZE);
 	}
@@ -1881,11 +1887,11 @@ network_connect(struct netfront_info *np)
 	netif_rx_request_t *req;
 	u_int feature_rx_copy, feature_rx_flip;
 
-	error = xenbus_scanf(XBT_NIL, xenbus_get_otherend_path(np->xbdev),
+	error = xs_scanf(XST_NIL, xenbus_get_otherend_path(np->xbdev),
 	    "feature-rx-copy", NULL, "%u", &feature_rx_copy);
 	if (error)
 		feature_rx_copy = 0;
-	error = xenbus_scanf(XBT_NIL, xenbus_get_otherend_path(np->xbdev),
+	error = xs_scanf(XST_NIL, xenbus_get_otherend_path(np->xbdev),
 	    "feature-rx-flip", NULL, "%u", &feature_rx_flip);
 	if (error)
 		feature_rx_flip = 1;
@@ -1999,14 +2005,14 @@ create_netdev(device_t dev)
 	/* Initialise {tx,rx}_skbs to be a free chain containing every entry. */
 	for (i = 0; i <= NET_TX_RING_SIZE; i++) {
 		np->tx_mbufs[i] = (void *) ((u_long) i+1);
-		np->grant_tx_ref[i] = GRANT_INVALID_REF;	
+		np->grant_tx_ref[i] = GRANT_REF_INVALID;	
 	}
 	np->tx_mbufs[NET_TX_RING_SIZE] = (void *)0;
 
 	for (i = 0; i <= NET_RX_RING_SIZE; i++) {
 
 		np->rx_mbufs[i] = NULL;
-		np->grant_rx_ref[i] = GRANT_INVALID_REF;
+		np->grant_rx_ref[i] = GRANT_REF_INVALID;
 	}
 	/* A grant for every tx ring slot */
 	if (gnttab_alloc_grant_references(NET_TX_RING_SIZE,
@@ -2128,8 +2134,8 @@ netif_disconnect_backend(struct netfront_info *info)
 
 	end_access(info->tx_ring_ref, info->tx.sring);
 	end_access(info->rx_ring_ref, info->rx.sring);
-	info->tx_ring_ref = GRANT_INVALID_REF;
-	info->rx_ring_ref = GRANT_INVALID_REF;
+	info->tx_ring_ref = GRANT_REF_INVALID;
+	info->rx_ring_ref = GRANT_REF_INVALID;
 	info->tx.sring = NULL;
 	info->rx.sring = NULL;
 
@@ -2143,7 +2149,7 @@ netif_disconnect_backend(struct netfront_info *info)
 static void
 end_access(int ref, void *page)
 {
-	if (ref != GRANT_INVALID_REF)
+	if (ref != GRANT_REF_INVALID)
 		gnttab_end_foreign_access(ref, page);
 }
 
@@ -2171,7 +2177,7 @@ static device_method_t netfront_methods[] = {
 	DEVMETHOD(device_resume,        netfront_resume), 
  
 	/* Xenbus interface */
-	DEVMETHOD(xenbus_backend_changed, netfront_backend_changed),
+	DEVMETHOD(xenbus_otherend_changed, netfront_backend_changed),
 
 	{ 0, 0 } 
 }; 
@@ -2183,4 +2189,4 @@ static driver_t netfront_driver = {
 }; 
 devclass_t netfront_devclass; 
  
-DRIVER_MODULE(xe, xenbus, netfront_driver, netfront_devclass, 0, 0); 
+DRIVER_MODULE(xe, xenbusb_front, netfront_driver, netfront_devclass, 0, 0);