Implement vector callback for PVHVM and unify event channel implementations

Re-structure Xen HVM support so that:
	- Xen is detected and hypercalls can be performed very
	  early in system startup.
	- Xen interrupt services are implemented using FreeBSD's native
	  interrupt delivery infrastructure.
	- the Xen interrupt service implementation is shared between PV
	  and HVM guests.
	- Xen interrupt handlers can optionally use a filter handler
	  in order to avoid the overhead of dispatch to an interrupt
	  thread.
	- interrupt load can be distributed among all available CPUs.
	- the overhead of accessing the emulated local and I/O apics
	  on HVM is removed for event channel port events.
	- a similar optimization can eventually, and fairly easily,
	  be used to optimize MSI.

Early Xen detection, HVM refactoring, PVHVM interrupt infrastructure,
and misc Xen cleanups:

Sponsored by: Spectra Logic Corporation

Unification of PV & HVM interrupt infrastructure, bug fixes,
and misc Xen cleanups:

Submitted by: Roger Pau Monné
Sponsored by: Citrix Systems R&D

sys/x86/x86/local_apic.c:
sys/amd64/include/apicvar.h:
sys/i386/include/apicvar.h:
sys/amd64/amd64/apic_vector.S:
sys/i386/i386/apic_vector.s:
sys/amd64/amd64/machdep.c:
sys/i386/i386/machdep.c:
sys/i386/xen/exception.s:
sys/x86/include/segments.h:
	Reserve IDT vector 0x93 for the Xen event channel upcall
	interrupt handler.  On Hypervisors that support the direct
	vector callback feature, we can request that this vector be
	called directly by an injected HVM interrupt event, instead
	of a simulated PCI interrupt on the Xen platform PCI device.
	This avoids all of the overhead of dealing with the emulated
	I/O APIC and local APIC.  It also means that the Hypervisor
	can inject these events on any CPU, allowing upcalls for
	different ports to be handled in parallel.

sys/amd64/amd64/mp_machdep.c:
sys/i386/i386/mp_machdep.c:
	Map Xen per-vcpu area during AP startup.

sys/amd64/include/intr_machdep.h:
sys/i386/include/intr_machdep.h:
	Increase the FreeBSD IRQ vector table to include space
	for event channel interrupt sources.

sys/amd64/include/pcpu.h:
sys/i386/include/pcpu.h:
	Remove Xen HVM per-cpu variable data.  These fields are now
	allocated via the dynamic per-cpu scheme.  See xen_intr.c
	for details.

sys/amd64/include/xen/hypercall.h:
sys/dev/xen/blkback/blkback.c:
sys/i386/include/xen/xenvar.h:
sys/i386/xen/clock.c:
sys/i386/xen/xen_machdep.c:
sys/xen/gnttab.c:
	Prefer FreeBSD primatives to Linux ones in Xen support code.

sys/amd64/include/xen/xen-os.h:
sys/i386/include/xen/xen-os.h:
sys/xen/xen-os.h:
sys/dev/xen/balloon/balloon.c:
sys/dev/xen/blkback/blkback.c:
sys/dev/xen/blkfront/blkfront.c:
sys/dev/xen/console/xencons_ring.c:
sys/dev/xen/control/control.c:
sys/dev/xen/netback/netback.c:
sys/dev/xen/netfront/netfront.c:
sys/dev/xen/xenpci/xenpci.c:
sys/i386/i386/machdep.c:
sys/i386/include/pmap.h:
sys/i386/include/xen/xenfunc.h:
sys/i386/isa/npx.c:
sys/i386/xen/clock.c:
sys/i386/xen/mp_machdep.c:
sys/i386/xen/mptable.c:
sys/i386/xen/xen_clock_util.c:
sys/i386/xen/xen_machdep.c:
sys/i386/xen/xen_rtc.c:
sys/xen/evtchn/evtchn_dev.c:
sys/xen/features.c:
sys/xen/gnttab.c:
sys/xen/gnttab.h:
sys/xen/hvm.h:
sys/xen/xenbus/xenbus.c:
sys/xen/xenbus/xenbus_if.m:
sys/xen/xenbus/xenbusb_front.c:
sys/xen/xenbus/xenbusvar.h:
sys/xen/xenstore/xenstore.c:
sys/xen/xenstore/xenstore_dev.c:
sys/xen/xenstore/xenstorevar.h:
	Pull common Xen OS support functions/settings into xen/xen-os.h.

sys/amd64/include/xen/xen-os.h:
sys/i386/include/xen/xen-os.h:
sys/xen/xen-os.h:
	Remove constants, macros, and functions unused in FreeBSD's Xen
	support.

sys/xen/xen-os.h:
sys/i386/xen/xen_machdep.c:
sys/x86/xen/hvm.c:
	Introduce new functions xen_domain(), xen_pv_domain(), and
	xen_hvm_domain().  These are used in favor of #ifdefs so that
	FreeBSD can dynamically detect and adapt to the presence of
	a hypervisor.  The goal is to have an HVM optimized GENERIC,
	but more is necessary before this is possible.

sys/amd64/amd64/machdep.c:
sys/dev/xen/xenpci/xenpcivar.h:
sys/dev/xen/xenpci/xenpci.c:
sys/x86/xen/hvm.c:
sys/sys/kernel.h:
	Refactor magic ioport, Hypercall table and Hypervisor shared
	information page setup, and move it to a dedicated HVM support
	module.

	HVM mode initialization is now triggered during the
	SI_SUB_HYPERVISOR phase of system startup.  This currently
	occurs just after the kernel VM is fully setup which is
	just enough infrastructure to allow the hypercall table
	and shared info page to be properly mapped.

sys/xen/hvm.h:
sys/x86/xen/hvm.c:
	Add definitions and a method for configuring Hypervisor event
	delievery via a direct vector callback.

sys/amd64/include/xen/xen-os.h:
sys/x86/xen/hvm.c:

sys/conf/files:
sys/conf/files.amd64:
sys/conf/files.i386:
	Adjust kernel build to reflect the refactoring of early
	Xen startup code and Xen interrupt services.

sys/dev/xen/blkback/blkback.c:
sys/dev/xen/blkfront/blkfront.c:
sys/dev/xen/blkfront/block.h:
sys/dev/xen/control/control.c:
sys/dev/xen/evtchn/evtchn_dev.c:
sys/dev/xen/netback/netback.c:
sys/dev/xen/netfront/netfront.c:
sys/xen/xenstore/xenstore.c:
sys/xen/evtchn/evtchn_dev.c:
sys/dev/xen/console/console.c:
sys/dev/xen/console/xencons_ring.c
	Adjust drivers to use new xen_intr_*() API.

sys/dev/xen/blkback/blkback.c:
	Since blkback defers all event handling to a taskqueue,
	convert this task queue to a "fast" taskqueue, and schedule
	it via an interrupt filter.  This avoids an unnecessary
	ithread context switch.

sys/xen/xenstore/xenstore.c:
	The xenstore driver is MPSAFE.  Indicate as much when
	registering its interrupt handler.

sys/xen/xenbus/xenbus.c:
sys/xen/xenbus/xenbusvar.h:
	Remove unused event channel APIs.

sys/xen/evtchn.h:
	Remove all kernel Xen interrupt service API definitions
	from this file.  It is now only used for structure and
	ioctl definitions related to the event channel userland
	device driver.

	Update the definitions in this file to match those from
	NetBSD.  Implementing this interface will be necessary for
	Dom0 support.

sys/xen/evtchn/evtchnvar.h:
	Add a header file for implemenation internal APIs related
	to managing event channels event delivery.  This is used
	to allow, for example, the event channel userland device
	driver to access low-level routines that typical kernel
	consumers of event channel services should never access.

sys/xen/interface/event_channel.h:
sys/xen/xen_intr.h:
	Standardize on the evtchn_port_t type for referring to
	an event channel port id.  In order to prevent low-level
	event channel APIs from leaking to kernel consumers who
	should not have access to this data, the type is defined
	twice: Once in the Xen provided event_channel.h, and again
	in xen/xen_intr.h.  The double declaration is protected by
	__XEN_EVTCHN_PORT_DEFINED__ to ensure it is never declared
	twice within a given compilation unit.

sys/xen/xen_intr.h:
sys/xen/evtchn/evtchn.c:
sys/x86/xen/xen_intr.c:
sys/dev/xen/xenpci/evtchn.c:
sys/dev/xen/xenpci/xenpcivar.h:
	New implementation of Xen interrupt services.  This is
	similar in many respects to the i386 PV implementation with
	the exception that events for bound to event channel ports
	(i.e. not IPI, virtual IRQ, or physical IRQ) are further
	optimized to avoid mask/unmask operations that aren't
	necessary for these edge triggered events.

	Stubs exist for supporting physical IRQ binding, but will
	need additional work before this implementation can be
	fully shared between PV and HVM.

sys/amd64/amd64/mp_machdep.c:
sys/i386/i386/mp_machdep.c:
sys/i386/xen/mp_machdep.c
sys/x86/xen/hvm.c:
	Add support for placing vcpu_info into an arbritary memory
	page instead of using HYPERVISOR_shared_info->vcpu_info.
	This allows the creation of domains with more than 32 vcpus.

sys/i386/i386/machdep.c:
sys/i386/xen/clock.c:
sys/i386/xen/xen_machdep.c:
sys/i386/xen/exception.s:
	Add support for new event channle implementation.

1 files changed, 204 insertions, 91 deletions

diff --git a/sys/xen/xen_intr.h b/sys/xen/xen_intr.h
index 2e753e6..109608f 100644
--- a/sys/xen/xen_intr.h
+++ b/sys/xen/xen_intr.h
@@ -1,103 +1,216 @@
-/* -*-  Mode:C; c-basic-offset:4; tab-width:4 -*- */
+/******************************************************************************
+ * xen_intr.h
+ * 
+ * APIs for managing Xen event channel, virtual IRQ, and physical IRQ
+ * notifications.
+ * 
+ * Copyright (c) 2004, K A Fraser
+ * Copyright (c) 2012, Spectra Logic Corporation
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ */
 #ifndef _XEN_INTR_H_
 #define _XEN_INTR_H_
 
-/*
-* The flat IRQ space is divided into two regions:
-*  1. A one-to-one mapping of real physical IRQs. This space is only used
-*     if we have physical device-access privilege. This region is at the 
-*     start of the IRQ space so that existing device drivers do not need
-*     to be modified to translate physical IRQ numbers into our IRQ space.
-*  3. A dynamic mapping of inter-domain and Xen-sourced virtual IRQs. These
-*     are bound using the provided bind/unbind functions.
-*
-*
-* $FreeBSD$
-*/
-
-#define PIRQ_BASE   0
-#define NR_PIRQS  128
-
-#define DYNIRQ_BASE (PIRQ_BASE + NR_PIRQS)
-#define NR_DYNIRQS  128
-
-#define NR_IRQS   (NR_PIRQS + NR_DYNIRQS)
-
-#define pirq_to_irq(_x)   ((_x) + PIRQ_BASE)
-#define irq_to_pirq(_x)   ((_x) - PIRQ_BASE)
-
-#define dynirq_to_irq(_x) ((_x) + DYNIRQ_BASE)
-#define irq_to_dynirq(_x) ((_x) - DYNIRQ_BASE)
-
-/* 
- * Dynamic binding of event channels and VIRQ sources to guest IRQ space.
+#ifndef __XEN_EVTCHN_PORT_DEFINED__
+typedef uint32_t evtchn_port_t;
+DEFINE_XEN_GUEST_HANDLE(evtchn_port_t);
+#define __XEN_EVTCHN_PORT_DEFINED__ 1
+#endif
+
+/** Registered Xen interrupt callback handle. */
+typedef void * xen_intr_handle_t;
+
+/** If non-zero, the hypervisor has been configured to use a direct vector */
+extern int xen_vector_callback_enabled;
+
+/**
+ * Associate an already allocated local event channel port an interrupt
+ * handler.
+ *
+ * \param dev         The device making this bind request.
+ * \param local_port  The event channel to bind.
+ * \param filter      An interrupt filter handler.  Specify NULL
+ *                    to always dispatch to the ithread handler.
+ * \param handler     An interrupt ithread handler.  Optional (can
+ *                    specify NULL) if all necessary event actions
+ *                    are performed by filter.
+ * \param arg         Argument to present to both filter and handler.
+ * \param irqflags    Interrupt handler flags.  See sys/bus.h.
+ * \param handlep     Pointer to an opaque handle used to manage this
+ *                    registration.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-
-/*
- * Bind a caller port event channel to an interrupt handler. If
- * successful, the guest IRQ number is returned in *irqp. Return zero
- * on success or errno otherwise.
+int xen_intr_bind_local_port(device_t dev, evtchn_port_t local_port,
+	driver_filter_t filter, driver_intr_t handler, void *arg,
+	enum intr_type irqflags, xen_intr_handle_t *handlep);
+
+/**
+ * Allocate a local event channel port, accessible by the specified
+ * remote/foreign domain and, if successful, associate the port with
+ * the specified interrupt handler.
+ *
+ * \param dev            The device making this bind request.
+ * \param remote_domain  Remote domain grant permission to signal the
+ *                       newly allocated local port.
+ * \param filter         An interrupt filter handler.  Specify NULL
+ *                       to always dispatch to the ithread handler.
+ * \param handler        An interrupt ithread handler.  Optional (can
+ *                       specify NULL) if all necessary event actions
+ *                       are performed by filter.
+ * \param arg            Argument to present to both filter and handler.
+ * \param irqflags       Interrupt handler flags.  See sys/bus.h.
+ * \param handlep        Pointer to an opaque handle used to manage this
+ *                       registration.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-extern int bind_caller_port_to_irqhandler(unsigned int caller_port,
-	const char *devname, driver_intr_t handler, void *arg,
-	unsigned long irqflags, unsigned int *irqp);
-
-/*
- * Bind a listening port to an interrupt handler. If successful, the
- * guest IRQ number is returned in *irqp. Return zero on success or
- * errno otherwise.
+int xen_intr_alloc_and_bind_local_port(device_t dev,
+	u_int remote_domain, driver_filter_t filter, driver_intr_t handler,
+	void *arg, enum intr_type irqflags, xen_intr_handle_t *handlep);
+
+/**
+ * Associate the specified interrupt handler with the remote event
+ * channel port specified by remote_domain and remote_port.
+ *
+ * \param dev            The device making this bind request.
+ * \param remote_domain  The domain peer for this event channel connection.
+ * \param remote_port    Remote domain's local port number for this event
+ *                       channel port.
+ * \param filter         An interrupt filter handler.  Specify NULL
+ *                       to always dispatch to the ithread handler.
+ * \param handler        An interrupt ithread handler.  Optional (can
+ *                       specify NULL) if all necessary event actions
+ *                       are performed by filter.
+ * \param arg            Argument to present to both filter and handler.
+ * \param irqflags       Interrupt handler flags.  See sys/bus.h.
+ * \param handlep        Pointer to an opaque handle used to manage this
+ *                       registration.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-extern int bind_listening_port_to_irqhandler(unsigned int remote_domain,
-	const char *devname, driver_intr_t handler, void *arg,
-	unsigned long irqflags, unsigned int *irqp);
-
-/*
- * Bind a VIRQ to an interrupt handler. If successful, the guest IRQ
- * number is returned in *irqp. Return zero on success or errno
- * otherwise.
+int xen_intr_bind_remote_port(device_t dev, u_int remote_domain,
+	evtchn_port_t remote_port, driver_filter_t filter,
+	driver_intr_t handler, void *arg, enum intr_type irqflags,
+	xen_intr_handle_t *handlep);
+
+/**
+ * Associate the specified interrupt handler with the specified Xen
+ * virtual interrupt source.
+ *
+ * \param dev       The device making this bind request.
+ * \param virq      The Xen virtual IRQ number for the Xen interrupt
+ *                  source being hooked.
+ * \param cpu       The cpu on which interrupt events should be delivered. 
+ * \param filter    An interrupt filter handler.  Specify NULL
+ *                  to always dispatch to the ithread handler.
+ * \param handler   An interrupt ithread handler.  Optional (can
+ *                  specify NULL) if all necessary event actions
+ *                  are performed by filter.
+ * \param arg       Argument to present to both filter and handler.
+ * \param irqflags  Interrupt handler flags.  See sys/bus.h.
+ * \param handlep   Pointer to an opaque handle used to manage this
+ *                  registration.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-extern int bind_virq_to_irqhandler(unsigned int virq, unsigned int cpu,
-	const char *devname, driver_filter_t filter, driver_intr_t handler,
-	void *arg, unsigned long irqflags,	unsigned int *irqp);
-
-/*
- * Bind an IPI to an interrupt handler. If successful, the guest
- * IRQ number is returned in *irqp. Return zero on success or errno
- * otherwise.
+int xen_intr_bind_virq(device_t dev, u_int virq, u_int cpu,
+	driver_filter_t filter, driver_intr_t handler,
+	void *arg, enum intr_type irqflags, xen_intr_handle_t *handlep);
+
+/**
+ * Associate an interprocessor interrupt vector with an interrupt handler.
+ *
+ * \param dev       The device making this bind request.
+ * \param ipi       The interprocessor interrupt vector number of the
+ *                  interrupt source being hooked.
+ * \param cpu       The cpu receiving the IPI.
+ * \param filter    An interrupt filter handler.  Specify NULL
+ *                  to always dispatch to the ithread handler.
+ * \param irqflags  Interrupt handler flags.  See sys/bus.h.
+ * \param handlep   Pointer to an opaque handle used to manage this
+ *                  registration.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-extern int bind_ipi_to_irqhandler(unsigned int ipi, unsigned int cpu,
-	const char *devname, driver_filter_t filter,
-	unsigned long irqflags, unsigned int *irqp);
-
-/*
- * Bind an interdomain event channel to an interrupt handler. If
- * successful, the guest IRQ number is returned in *irqp. Return zero
- * on success or errno otherwise.
+int xen_intr_bind_ipi(device_t dev, u_int ipi, u_int cpu,
+	driver_filter_t filter, enum intr_type irqflags,
+	xen_intr_handle_t *handlep);
+
+/**
+ * Unbind an interrupt handler from its interrupt source.
+ *
+ * \param handlep  A pointer to the opaque handle that was initialized
+ *		   at the time the interrupt source was bound.
+ *
+ * \returns  0 on success, otherwise an errno.
+ *
+ * \note  The event channel, if any, that was allocated at bind time is
+ *        closed upon successful return of this method.
+ *
+ * \note  It is always safe to call xen_intr_unbind() on a handle that
+ *        has been initilized to NULL.
  */
-extern int bind_interdomain_evtchn_to_irqhandler(unsigned int remote_domain,
-	unsigned int remote_port, const char *devname,
-	driver_intr_t handler, void *arg,
-	unsigned long irqflags, unsigned int *irqp);
-
-/*
- * Unbind an interrupt handler using the guest IRQ number returned
- * when it was bound.
+void xen_intr_unbind(xen_intr_handle_t *handle);
+
+/**
+ * Add a description to an interrupt handler.
+ *
+ * \param handle  The opaque handle that was initialized at the time
+ *		  the interrupt source was bound.
+ *
+ * \param fmt     The sprintf compatible format string for the description,
+ *                followed by optional sprintf arguments.
+ *
+ * \returns  0 on success, otherwise an errno.
  */
-extern void unbind_from_irqhandler(unsigned int irq);
-
-static __inline__ int irq_cannonicalize(unsigned int irq)
-{
-    return (irq == 2) ? 9 : irq;
-}
-
-extern void disable_irq(unsigned int);
-extern void disable_irq_nosync(unsigned int);
-extern void enable_irq(unsigned int);
-
-extern void irq_suspend(void);
-extern void irq_resume(void);
-
-extern void	idle_block(void);
-extern int	ap_cpu_initclocks(int cpu);
+int
+xen_intr_describe(xen_intr_handle_t port_handle, const char *fmt, ...)
+	__attribute__((format(printf, 2, 3)));
+
+/**
+ * Signal the remote peer of an interrupt source associated with an
+ * event channel port.
+ *
+ * \param handle  The opaque handle that was initialized at the time
+ *                the interrupt source was bound.
+ *
+ * \note  For xen interrupt sources other than event channel ports,
+ *        this method takes no action.
+ */
+void xen_intr_signal(xen_intr_handle_t handle);
+
+/**
+ * Get the local event channel port number associated with this interrupt
+ * source.
+ *
+ * \param handle  The opaque handle that was initialized at the time
+ *                the interrupt source was bound.
+ *
+ * \returns  0 if the handle is invalid, otherwise positive port number.
+ */
+evtchn_port_t xen_intr_port(xen_intr_handle_t handle);
 
 #endif /* _XEN_INTR_H_ */