831bbfaf75
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. MFC after: 1 month
296 lines
9.0 KiB
C
296 lines
9.0 KiB
C
/******************************************************************************
|
|
* Talks to Xen Store to figure out what devices we have.
|
|
*
|
|
* Copyright (C) 2009, 2010 Spectra Logic Corporation
|
|
* Copyright (C) 2008 Doug Rabson
|
|
* Copyright (C) 2005 Rusty Russell, IBM Corporation
|
|
* Copyright (C) 2005 Mike Wray, Hewlett-Packard
|
|
* Copyright (C) 2005 XenSource Ltd
|
|
*
|
|
* This file may be distributed separately from the Linux kernel, or
|
|
* incorporated into other software packages, subject to the following license:
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this source file (the "Software"), to deal in the Software without
|
|
* restriction, including without limitation the rights to use, copy, modify,
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
* IN THE SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* \file xenbusb_back.c
|
|
*
|
|
* XenBus management of the NewBus bus containing the backend instances of
|
|
* Xen split devices.
|
|
*/
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/bus.h>
|
|
#include <sys/kernel.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/module.h>
|
|
#include <sys/sbuf.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/syslog.h>
|
|
#include <sys/systm.h>
|
|
#include <sys/sx.h>
|
|
#include <sys/taskqueue.h>
|
|
|
|
#include <machine/xen/xen-os.h>
|
|
#include <machine/stdarg.h>
|
|
|
|
#include <xen/gnttab.h>
|
|
#include <xen/xenbus/xenbusvar.h>
|
|
#include <xen/xenbus/xenbusb.h>
|
|
|
|
|
|
/*------------------ Private Device Attachment Functions --------------------*/
|
|
/**
|
|
* \brief Probe for the existance of the XenBus back bus.
|
|
*
|
|
* \param dev NewBus device_t for this XenBus back bus instance.
|
|
*
|
|
* \return Always returns 0 indicating success.
|
|
*/
|
|
static int
|
|
xenbusb_back_probe(device_t dev)
|
|
{
|
|
device_set_desc(dev, "Xen Backend Devices");
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* \brief Attach the XenBus back bus.
|
|
*
|
|
* \param dev NewBus device_t for this XenBus back bus instance.
|
|
*
|
|
* \return On success, 0. Otherwise an errno value indicating the
|
|
* type of failure.
|
|
*/
|
|
static int
|
|
xenbusb_back_attach(device_t dev)
|
|
{
|
|
struct xenbusb_softc *xbs;
|
|
int error;
|
|
|
|
xbs = device_get_softc(dev);
|
|
error = xenbusb_attach(dev, "backend", /*id_components*/2);
|
|
|
|
/*
|
|
* Backend devices operate to serve other domains,
|
|
* so there is no need to hold up boot processing
|
|
* while connections to foreign domains are made.
|
|
*/
|
|
mtx_lock(&xbs->xbs_lock);
|
|
if ((xbs->xbs_flags & XBS_ATTACH_CH_ACTIVE) != 0) {
|
|
xbs->xbs_flags &= ~XBS_ATTACH_CH_ACTIVE;
|
|
mtx_unlock(&xbs->xbs_lock);
|
|
config_intrhook_disestablish(&xbs->xbs_attach_ch);
|
|
} else {
|
|
mtx_unlock(&xbs->xbs_lock);
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
/**
|
|
* \brief Enumerate all devices of the given type on this bus.
|
|
*
|
|
* \param dev NewBus device_t for this XenBus backend bus instance.
|
|
* \param type String indicating the device sub-tree (e.g. "vfb", "vif")
|
|
* to enumerate.
|
|
*
|
|
* \return On success, 0. Otherwise an errno value indicating the
|
|
* type of failure.
|
|
*
|
|
* Devices that are found are entered into the NewBus hierarchy via
|
|
* xenbusb_add_device(). xenbusb_add_device() ignores duplicate detects
|
|
* and ignores duplicate devices, so it can be called unconditionally
|
|
* for any device found in the XenStore.
|
|
*
|
|
* The backend XenStore hierarchy has the following format:
|
|
*
|
|
* backend/<device type>/<frontend vm id>/<device id>
|
|
*
|
|
*/
|
|
static int
|
|
xenbusb_back_enumerate_type(device_t dev, const char *type)
|
|
{
|
|
struct xenbusb_softc *xbs;
|
|
const char **vms;
|
|
u_int vm_idx;
|
|
u_int vm_count;
|
|
int error;
|
|
|
|
xbs = device_get_softc(dev);
|
|
error = xs_directory(XST_NIL, xbs->xbs_node, type, &vm_count, &vms);
|
|
if (error)
|
|
return (error);
|
|
for (vm_idx = 0; vm_idx < vm_count; vm_idx++) {
|
|
struct sbuf *vm_path;
|
|
const char *vm;
|
|
const char **devs;
|
|
u_int dev_idx;
|
|
u_int dev_count;
|
|
|
|
vm = vms[vm_idx];
|
|
|
|
vm_path = xs_join(type, vm);
|
|
error = xs_directory(XST_NIL, xbs->xbs_node, sbuf_data(vm_path),
|
|
&dev_count, &devs);
|
|
sbuf_delete(vm_path);
|
|
if (error)
|
|
break;
|
|
|
|
for (dev_idx = 0; dev_idx < dev_count; dev_idx++) {
|
|
const char *dev_num;
|
|
struct sbuf *id;
|
|
|
|
dev_num = devs[dev_idx];
|
|
id = xs_join(vm, dev_num);
|
|
xenbusb_add_device(dev, type, sbuf_data(id));
|
|
sbuf_delete(id);
|
|
}
|
|
free(devs, M_XENSTORE);
|
|
}
|
|
|
|
free(vms, M_XENSTORE);
|
|
|
|
return (0);
|
|
}
|
|
|
|
/**
|
|
* \brief Determine and store the XenStore path for the other end of
|
|
* a split device whose local end is represented by ivars.
|
|
*
|
|
* \param dev NewBus device_t for this XenBus backend bus instance.
|
|
* \param ivars Instance variables from the XenBus child device for
|
|
* which to perform this function.
|
|
*
|
|
* \return On success, 0. Otherwise an errno value indicating the
|
|
* type of failure.
|
|
*
|
|
* If successful, the xd_otherend_path field of the child's instance
|
|
* variables will be updated.
|
|
*
|
|
*/
|
|
static int
|
|
xenbusb_back_get_otherend_node(device_t dev, struct xenbus_device_ivars *ivars)
|
|
{
|
|
char *otherend_path;
|
|
int error;
|
|
|
|
if (ivars->xd_otherend_path != NULL) {
|
|
free(ivars->xd_otherend_path, M_XENBUS);
|
|
ivars->xd_otherend_path = NULL;
|
|
}
|
|
|
|
error = xs_gather(XST_NIL, ivars->xd_node,
|
|
"frontend-id", "%i", &ivars->xd_otherend_id,
|
|
"frontend", NULL, &otherend_path,
|
|
NULL);
|
|
|
|
if (error == 0) {
|
|
ivars->xd_otherend_path = strdup(otherend_path, M_XENBUS);
|
|
free(otherend_path, M_XENSTORE);
|
|
}
|
|
return (error);
|
|
}
|
|
|
|
/**
|
|
* \brief Backend XenBus child instance variable write access method.
|
|
*
|
|
* \param dev The NewBus device representing this XenBus bus.
|
|
* \param child The NewBus device representing a child of dev%'s XenBus bus.
|
|
* \param index The index of the instance variable to access.
|
|
* \param value The new value to set in the instance variable accessed.
|
|
*
|
|
* \return On success, 0. Otherwise an errno value indicating the
|
|
* type of failure.
|
|
*
|
|
* Xenbus_back overrides this method so that it can trap state transitions
|
|
* of local backend devices and clean up their XenStore entries as necessary
|
|
* during device instance teardown.
|
|
*/
|
|
static int
|
|
xenbusb_back_write_ivar(device_t dev, device_t child, int index,
|
|
uintptr_t value)
|
|
{
|
|
int error;
|
|
|
|
error = xenbusb_write_ivar(dev, child, index, value);
|
|
|
|
if (index == XENBUS_IVAR_STATE
|
|
&& (enum xenbus_state)value == XenbusStateClosed
|
|
&& xenbus_dev_is_online(child) == 0) {
|
|
|
|
/*
|
|
* Cleanup the hotplug entry in the XenStore if
|
|
* present. The control domain expects any userland
|
|
* component associated with this device to destroy
|
|
* this node in order to signify it is safe to
|
|
* teardown the device. However, not all backends
|
|
* rely on userland components, and those that
|
|
* do should either use a communication channel
|
|
* other than the XenStore, or ensure the hotplug
|
|
* data is already cleaned up.
|
|
*
|
|
* This removal ensures that no matter what path
|
|
* is taken to mark a back-end closed, the control
|
|
* domain will understand that it is closed.
|
|
*/
|
|
xs_rm(XST_NIL, xenbus_get_node(child), "hotplug-status");
|
|
}
|
|
|
|
return (error);
|
|
}
|
|
|
|
/*-------------------- Private Device Attachment Data -----------------------*/
|
|
static device_method_t xenbusb_back_methods[] = {
|
|
/* Device interface */
|
|
DEVMETHOD(device_identify, xenbusb_identify),
|
|
DEVMETHOD(device_probe, xenbusb_back_probe),
|
|
DEVMETHOD(device_attach, xenbusb_back_attach),
|
|
DEVMETHOD(device_detach, bus_generic_detach),
|
|
DEVMETHOD(device_shutdown, bus_generic_shutdown),
|
|
DEVMETHOD(device_suspend, bus_generic_suspend),
|
|
DEVMETHOD(device_resume, bus_generic_resume),
|
|
|
|
/* Bus Interface */
|
|
DEVMETHOD(bus_print_child, xenbusb_print_child),
|
|
DEVMETHOD(bus_read_ivar, xenbusb_read_ivar),
|
|
DEVMETHOD(bus_write_ivar, xenbusb_back_write_ivar),
|
|
DEVMETHOD(bus_alloc_resource, bus_generic_alloc_resource),
|
|
DEVMETHOD(bus_release_resource, bus_generic_release_resource),
|
|
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
|
|
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
|
|
|
|
/* XenBus Bus Interface */
|
|
DEVMETHOD(xenbusb_enumerate_type, xenbusb_back_enumerate_type),
|
|
DEVMETHOD(xenbusb_get_otherend_node, xenbusb_back_get_otherend_node),
|
|
{ 0, 0 }
|
|
};
|
|
|
|
DEFINE_CLASS_0(xenbusb_back, xenbusb_back_driver, xenbusb_back_methods,
|
|
sizeof(struct xenbusb_softc));
|
|
devclass_t xenbusb_back_devclass;
|
|
|
|
DRIVER_MODULE(xenbusb_back, xenstore, xenbusb_back_driver,
|
|
xenbusb_back_devclass, 0, 0);
|