Author: royger Date: Mon Jun 16 08:54:04 2014 New Revision: 267536 URL: http://svnweb.freebsd.org/changeset/base/267536
Log: xen: add missing files Commit missing files that actually belong to previous commits. Sponsored by: Citrix Systems R&D Approved by: gibbs Added: head/sys/dev/xen/pvcpu/ head/sys/dev/xen/pvcpu/pvcpu.c (contents, props changed) head/sys/x86/xen/xen_apic.c (contents, props changed) head/sys/x86/xen/xen_nexus.c (contents, props changed) head/sys/x86/xen/xenpv.c (contents, props changed) head/sys/xen/xen_pv.h (contents, props changed) Added: head/sys/dev/xen/pvcpu/pvcpu.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/dev/xen/pvcpu/pvcpu.c Mon Jun 16 08:54:04 2014 (r267536) @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2013 Roger Pau Monné <[email protected]> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND + * ANY EXPRESS OR 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 OR CONTRIBUTORS 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> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/pcpu.h> +#include <sys/smp.h> + +#include <xen/xen-os.h> + +/* + * Dummy Xen cpu device + * + * Since there's no ACPI on PVH guests, we need to create a dummy + * CPU device in order to fill the pcpu->pc_device field. + */ + +static void +xenpvcpu_identify(driver_t *driver, device_t parent) +{ + int i; + + /* Only attach to PV guests, HVM guests use the ACPI CPU devices */ + if (!xen_pv_domain()) + return; + + CPU_FOREACH(i) { + if (BUS_ADD_CHILD(parent, 0, "pvcpu", i) == NULL) + panic("Unable to add Xen PV CPU device."); + } +} + +static int +xenpvcpu_probe(device_t dev) +{ + + device_set_desc(dev, "Xen PV CPU"); + return (BUS_PROBE_NOWILDCARD); +} + +static int +xenpvcpu_attach(device_t dev) +{ + struct pcpu *pc; + int cpu; + + cpu = device_get_unit(dev); + pc = pcpu_find(cpu); + pc->pc_device = dev; + return (0); +} + +static device_method_t xenpvcpu_methods[] = { + DEVMETHOD(device_identify, xenpvcpu_identify), + DEVMETHOD(device_probe, xenpvcpu_probe), + DEVMETHOD(device_attach, xenpvcpu_attach), + + DEVMETHOD_END +}; + +static driver_t xenpvcpu_driver = { + "pvcpu", + xenpvcpu_methods, + 0, +}; + +devclass_t xenpvcpu_devclass; + +DRIVER_MODULE(xenpvcpu, xenpv, xenpvcpu_driver, xenpvcpu_devclass, 0, 0); +MODULE_DEPEND(xenpvcpu, xenpv, 1, 1, 1); Added: head/sys/x86/xen/xen_apic.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/x86/xen/xen_apic.c Mon Jun 16 08:54:04 2014 (r267536) @@ -0,0 +1,546 @@ +/* + * Copyright (c) 2014 Roger Pau Monné <[email protected]> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND + * ANY EXPRESS OR 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 OR CONTRIBUTORS 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> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/proc.h> +#include <sys/smp.h> +#include <sys/systm.h> + +#include <vm/vm.h> +#include <vm/pmap.h> + +#include <machine/cpufunc.h> +#include <machine/cpu.h> +#include <machine/smp.h> + +#include <x86/apicreg.h> + +#include <xen/xen-os.h> +#include <xen/features.h> +#include <xen/gnttab.h> +#include <xen/hypervisor.h> +#include <xen/hvm.h> +#include <xen/xen_intr.h> + +#include <xen/interface/vcpu.h> + +/*--------------------------------- Macros -----------------------------------*/ + +#define XEN_APIC_UNSUPPORTED \ + panic("%s: not available in Xen PV port.", __func__) + + +/*--------------------------- Forward Declarations ---------------------------*/ +#ifdef SMP +static driver_filter_t xen_smp_rendezvous_action; +static driver_filter_t xen_invltlb; +static driver_filter_t xen_invlpg; +static driver_filter_t xen_invlrng; +static driver_filter_t xen_invlcache; +#ifdef __i386__ +static driver_filter_t xen_lazypmap; +#endif +static driver_filter_t xen_ipi_bitmap_handler; +static driver_filter_t xen_cpustop_handler; +static driver_filter_t xen_cpususpend_handler; +static driver_filter_t xen_cpustophard_handler; +#endif + +/*---------------------------- Extern Declarations ---------------------------*/ +/* Variables used by mp_machdep to perform the MMU related IPIs */ +#ifdef __i386__ +extern void pmap_lazyfix_action(void); +#endif +#ifdef __amd64__ +extern int pmap_pcid_enabled; +#endif + +extern int xen_vector_callback_enabled; + +/*---------------------------------- Macros ----------------------------------*/ +#define IPI_TO_IDX(ipi) ((ipi) - APIC_IPI_INTS) + +/*--------------------------------- Xen IPIs ---------------------------------*/ +#ifdef SMP +struct xen_ipi_handler +{ + driver_filter_t *filter; + const char *description; +}; + +static struct xen_ipi_handler xen_ipis[] = +{ + [IPI_TO_IDX(IPI_RENDEZVOUS)] = { xen_smp_rendezvous_action, "r" }, + [IPI_TO_IDX(IPI_INVLTLB)] = { xen_invltlb, "itlb"}, + [IPI_TO_IDX(IPI_INVLPG)] = { xen_invlpg, "ipg" }, + [IPI_TO_IDX(IPI_INVLRNG)] = { xen_invlrng, "irg" }, + [IPI_TO_IDX(IPI_INVLCACHE)] = { xen_invlcache, "ic" }, +#ifdef __i386__ + [IPI_TO_IDX(IPI_LAZYPMAP)] = { xen_lazypmap, "lp" }, +#endif + [IPI_TO_IDX(IPI_BITMAP_VECTOR)] = { xen_ipi_bitmap_handler, "b" }, + [IPI_TO_IDX(IPI_STOP)] = { xen_cpustop_handler, "st" }, + [IPI_TO_IDX(IPI_SUSPEND)] = { xen_cpususpend_handler, "sp" }, + [IPI_TO_IDX(IPI_STOP_HARD)] = { xen_cpustophard_handler, "sth" }, +}; +#endif + +/*------------------------------- Per-CPU Data -------------------------------*/ +#ifdef SMP +DPCPU_DEFINE(xen_intr_handle_t, ipi_handle[nitems(xen_ipis)]); +#endif + +/*------------------------------- Xen PV APIC --------------------------------*/ + +static void +xen_pv_lapic_create(u_int apic_id, int boot_cpu) +{ +#ifdef SMP + cpu_add(apic_id, boot_cpu); +#endif +} + +static void +xen_pv_lapic_init(vm_paddr_t addr) +{ + +} + +static void +xen_pv_lapic_setup(int boot) +{ + +} + +static void +xen_pv_lapic_dump(const char *str) +{ + + printf("cpu%d %s XEN PV LAPIC\n", PCPU_GET(cpuid), str); +} + +static void +xen_pv_lapic_disable(void) +{ + +} + +static void +xen_pv_lapic_eoi(void) +{ + + XEN_APIC_UNSUPPORTED; +} + +static int +xen_pv_lapic_id(void) +{ + + return (PCPU_GET(apic_id)); +} + +static int +xen_pv_lapic_intr_pending(u_int vector) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static u_int +xen_pv_apic_cpuid(u_int apic_id) +{ +#ifdef SMP + return (apic_cpuids[apic_id]); +#else + return (0); +#endif +} + +static u_int +xen_pv_apic_alloc_vector(u_int apic_id, u_int irq) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static u_int +xen_pv_apic_alloc_vectors(u_int apic_id, u_int *irqs, u_int count, u_int align) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static void +xen_pv_apic_disable_vector(u_int apic_id, u_int vector) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_apic_enable_vector(u_int apic_id, u_int vector) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_apic_free_vector(u_int apic_id, u_int vector, u_int irq) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_lapic_set_logical_id(u_int apic_id, u_int cluster, u_int cluster_id) +{ + + XEN_APIC_UNSUPPORTED; +} + +static int +xen_pv_lapic_enable_pmc(void) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static void +xen_pv_lapic_disable_pmc(void) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_lapic_reenable_pmc(void) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_lapic_enable_cmc(void) +{ + +} + +static void +xen_pv_lapic_ipi_raw(register_t icrlo, u_int dest) +{ + + XEN_APIC_UNSUPPORTED; +} + +static void +xen_pv_lapic_ipi_vectored(u_int vector, int dest) +{ + xen_intr_handle_t *ipi_handle; + int ipi_idx, to_cpu, self; + + ipi_idx = IPI_TO_IDX(vector); + if (ipi_idx > nitems(xen_ipis)) + panic("IPI out of range"); + + switch(dest) { + case APIC_IPI_DEST_SELF: + ipi_handle = DPCPU_GET(ipi_handle); + xen_intr_signal(ipi_handle[ipi_idx]); + break; + case APIC_IPI_DEST_ALL: + CPU_FOREACH(to_cpu) { + ipi_handle = DPCPU_ID_GET(to_cpu, ipi_handle); + xen_intr_signal(ipi_handle[ipi_idx]); + } + break; + case APIC_IPI_DEST_OTHERS: + self = PCPU_GET(cpuid); + CPU_FOREACH(to_cpu) { + if (to_cpu != self) { + ipi_handle = DPCPU_ID_GET(to_cpu, ipi_handle); + xen_intr_signal(ipi_handle[ipi_idx]); + } + } + break; + default: + to_cpu = apic_cpuid(dest); + ipi_handle = DPCPU_ID_GET(to_cpu, ipi_handle); + xen_intr_signal(ipi_handle[ipi_idx]); + break; + } +} + +static int +xen_pv_lapic_ipi_wait(int delay) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static int +xen_pv_lapic_set_lvt_mask(u_int apic_id, u_int lvt, u_char masked) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static int +xen_pv_lapic_set_lvt_mode(u_int apic_id, u_int lvt, uint32_t mode) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static int +xen_pv_lapic_set_lvt_polarity(u_int apic_id, u_int lvt, enum intr_polarity pol) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +static int +xen_pv_lapic_set_lvt_triggermode(u_int apic_id, u_int lvt, + enum intr_trigger trigger) +{ + + XEN_APIC_UNSUPPORTED; + return (0); +} + +/* Xen apic_ops implementation */ +struct apic_ops xen_apic_ops = { + .create = xen_pv_lapic_create, + .init = xen_pv_lapic_init, + .setup = xen_pv_lapic_setup, + .dump = xen_pv_lapic_dump, + .disable = xen_pv_lapic_disable, + .eoi = xen_pv_lapic_eoi, + .id = xen_pv_lapic_id, + .intr_pending = xen_pv_lapic_intr_pending, + .set_logical_id = xen_pv_lapic_set_logical_id, + .cpuid = xen_pv_apic_cpuid, + .alloc_vector = xen_pv_apic_alloc_vector, + .alloc_vectors = xen_pv_apic_alloc_vectors, + .enable_vector = xen_pv_apic_enable_vector, + .disable_vector = xen_pv_apic_disable_vector, + .free_vector = xen_pv_apic_free_vector, + .enable_pmc = xen_pv_lapic_enable_pmc, + .disable_pmc = xen_pv_lapic_disable_pmc, + .reenable_pmc = xen_pv_lapic_reenable_pmc, + .enable_cmc = xen_pv_lapic_enable_cmc, + .ipi_raw = xen_pv_lapic_ipi_raw, + .ipi_vectored = xen_pv_lapic_ipi_vectored, + .ipi_wait = xen_pv_lapic_ipi_wait, + .set_lvt_mask = xen_pv_lapic_set_lvt_mask, + .set_lvt_mode = xen_pv_lapic_set_lvt_mode, + .set_lvt_polarity = xen_pv_lapic_set_lvt_polarity, + .set_lvt_triggermode = xen_pv_lapic_set_lvt_triggermode, +}; + +#ifdef SMP +/*---------------------------- XEN PV IPI Handlers ---------------------------*/ +/* + * These are C clones of the ASM functions found in apic_vector. + */ +static int +xen_ipi_bitmap_handler(void *arg) +{ + struct trapframe *frame; + + frame = arg; + ipi_bitmap_handler(*frame); + return (FILTER_HANDLED); +} + +static int +xen_smp_rendezvous_action(void *arg) +{ +#ifdef COUNT_IPIS + (*ipi_rendezvous_counts[PCPU_GET(cpuid)])++; +#endif /* COUNT_IPIS */ + + smp_rendezvous_action(); + return (FILTER_HANDLED); +} + +static int +xen_invltlb(void *arg) +{ + + invltlb_handler(); + return (FILTER_HANDLED); +} + +#ifdef __amd64__ +static int +xen_invltlb_pcid(void *arg) +{ + + invltlb_pcid_handler(); + return (FILTER_HANDLED); +} +#endif + +static int +xen_invlpg(void *arg) +{ + + invlpg_handler(); + return (FILTER_HANDLED); +} + +#ifdef __amd64__ +static int +xen_invlpg_pcid(void *arg) +{ + + invlpg_pcid_handler(); + return (FILTER_HANDLED); +} +#endif + +static int +xen_invlrng(void *arg) +{ + + invlrng_handler(); + return (FILTER_HANDLED); +} + +static int +xen_invlcache(void *arg) +{ + + invlcache_handler(); + return (FILTER_HANDLED); +} + +#ifdef __i386__ +static int +xen_lazypmap(void *arg) +{ + + pmap_lazyfix_action(); + return (FILTER_HANDLED); +} +#endif + +static int +xen_cpustop_handler(void *arg) +{ + + cpustop_handler(); + return (FILTER_HANDLED); +} + +static int +xen_cpususpend_handler(void *arg) +{ + + cpususpend_handler(); + return (FILTER_HANDLED); +} + +static int +xen_cpustophard_handler(void *arg) +{ + + ipi_nmi_handler(); + return (FILTER_HANDLED); +} + +/*----------------------------- XEN PV IPI setup -----------------------------*/ +/* + * Those functions are provided outside of the Xen PV APIC implementation + * so PVHVM guests can also use PV IPIs without having an actual Xen PV APIC, + * because on PVHVM there's an emulated LAPIC provided by Xen. + */ +static void +xen_cpu_ipi_init(int cpu) +{ + xen_intr_handle_t *ipi_handle; + const struct xen_ipi_handler *ipi; + device_t dev; + int idx, rc; + + ipi_handle = DPCPU_ID_GET(cpu, ipi_handle); + dev = pcpu_find(cpu)->pc_device; + KASSERT((dev != NULL), ("NULL pcpu device_t")); + + for (ipi = xen_ipis, idx = 0; idx < nitems(xen_ipis); ipi++, idx++) { + + if (ipi->filter == NULL) { + ipi_handle[idx] = NULL; + continue; + } + + rc = xen_intr_alloc_and_bind_ipi(dev, cpu, ipi->filter, + INTR_TYPE_TTY, &ipi_handle[idx]); + if (rc != 0) + panic("Unable to allocate a XEN IPI port"); + xen_intr_describe(ipi_handle[idx], "%s", ipi->description); + } +} + +static void +xen_setup_cpus(void) +{ + int i; + + if (!xen_vector_callback_enabled) + return; + +#ifdef __amd64__ + if (pmap_pcid_enabled) { + xen_ipis[IPI_TO_IDX(IPI_INVLTLB)].filter = xen_invltlb_pcid; + xen_ipis[IPI_TO_IDX(IPI_INVLPG)].filter = xen_invlpg_pcid; + } +#endif + CPU_FOREACH(i) + xen_cpu_ipi_init(i); + + /* Set the xen pv ipi ops to replace the native ones */ + if (xen_hvm_domain()) + apic_ops.ipi_vectored = xen_pv_lapic_ipi_vectored; +} + +/* We need to setup IPIs before APs are started */ +SYSINIT(xen_setup_cpus, SI_SUB_SMP-1, SI_ORDER_FIRST, xen_setup_cpus, NULL); +#endif /* SMP */ Added: head/sys/x86/xen/xen_nexus.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/x86/xen/xen_nexus.c Mon Jun 16 08:54:04 2014 (r267536) @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2013 Roger Pau Monné <[email protected]> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND + * ANY EXPRESS OR 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 OR CONTRIBUTORS 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> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/sysctl.h> +#include <sys/systm.h> +#include <sys/smp.h> + +#include <machine/nexusvar.h> + +#include <xen/xen-os.h> + +/* + * Xen nexus(4) driver. + */ +static int +nexus_xen_probe(device_t dev) +{ + + if (!xen_pv_domain()) + return (ENXIO); + + return (BUS_PROBE_DEFAULT); +} + +static int +nexus_xen_attach(device_t dev) +{ + + nexus_init_resources(); + bus_generic_probe(dev); + bus_generic_attach(dev); + + return (0); +} + +static device_method_t nexus_xen_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, nexus_xen_probe), + DEVMETHOD(device_attach, nexus_xen_attach), + + { 0, 0 } +}; + +DEFINE_CLASS_1(nexus, nexus_xen_driver, nexus_xen_methods, 1, nexus_driver); +static devclass_t nexus_devclass; + +DRIVER_MODULE(nexus_xen, root, nexus_xen_driver, nexus_devclass, 0, 0); Added: head/sys/x86/xen/xenpv.c ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/x86/xen/xenpv.c Mon Jun 16 08:54:04 2014 (r267536) @@ -0,0 +1,121 @@ +/* + * Copyright (c) 2014 Roger Pau Monné <[email protected]> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND + * ANY EXPRESS OR 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 OR CONTRIBUTORS 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> +__FBSDID("$FreeBSD$"); + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/kernel.h> +#include <sys/module.h> +#include <sys/pcpu.h> +#include <sys/smp.h> + +#include <xen/xen-os.h> +#include <xen/gnttab.h> + +static devclass_t xenpv_devclass; + +static void +xenpv_identify(driver_t *driver, device_t parent) +{ + if (!xen_domain()) + return; + + /* Make sure there's only one xenpv device. */ + if (devclass_get_device(xenpv_devclass, 0)) + return; + + if (BUS_ADD_CHILD(parent, 0, "xenpv", 0) == NULL) + panic("Unable to attach xenpv bus."); +} + +static int +xenpv_probe(device_t dev) +{ + + device_set_desc(dev, "Xen PV bus"); + return (BUS_PROBE_NOWILDCARD); +} + +static int +xenpv_attach(device_t dev) +{ + device_t child; + int error; + + /* Initialize grant table before any Xen specific device is attached */ + error = gnttab_init(dev); + if (error != 0) { + device_printf(dev, "error initializing grant table: %d\n", + error); + return (error); + } + + /* + * Let our child drivers identify any child devices that they + * can find. Once that is done attach any devices that we + * found. + */ + bus_generic_probe(dev); + bus_generic_attach(dev); + + if (!devclass_get_device(devclass_find("isa"), 0)) { + child = BUS_ADD_CHILD(dev, 0, "isa", 0); + if (child == NULL) + panic("Failed to attach ISA bus."); + device_probe_and_attach(child); + } + + return (0); +} + +static device_method_t xenpv_methods[] = { + /* Device interface */ + DEVMETHOD(device_identify, xenpv_identify), + DEVMETHOD(device_probe, xenpv_probe), + DEVMETHOD(device_attach, xenpv_attach), + DEVMETHOD(device_suspend, bus_generic_suspend), + DEVMETHOD(device_resume, bus_generic_resume), + + /* Bus interface */ + DEVMETHOD(bus_add_child, bus_generic_add_child), + 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), + + DEVMETHOD_END +}; + +static driver_t xenpv_driver = { + "xenpv", + xenpv_methods, + 0, +}; + +DRIVER_MODULE(xenpv, nexus, xenpv_driver, xenpv_devclass, 0, 0); Added: head/sys/xen/xen_pv.h ============================================================================== --- /dev/null 00:00:00 1970 (empty, because file is newly added) +++ head/sys/xen/xen_pv.h Mon Jun 16 08:54:04 2014 (r267536) @@ -0,0 +1,34 @@ +/*- + * Copyright (c) 2014 Roger Pau Monné <[email protected]> + * All rights reserved. + * + * 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. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS AS IS'' AND + * ANY EXPRESS OR 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 OR CONTRIBUTORS 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. + * + * $FreeBSD$ + */ + +#ifndef __XEN_PV_H__ +#define __XEN_PV_H__ + +extern struct apic_ops xen_apic_ops; + +#endif _______________________________________________ [email protected] mailing list http://lists.freebsd.org/mailman/listinfo/svn-src-head To unsubscribe, send any mail to "[email protected]"
