Xen project Mailing List

[Xen-changelog] [linux-2.6.18-xen] merge with linux-2.6.18-xen.hg

From: "Xen patchbot-linux-2.6.18-xen" <patchbot-linux-2.6.18-xen@xxxxxxxxxxxxxxxxxxx>

Date: Tue, 20 May 2008 08:30:49 -0700

Delivery-date: Tue, 20 May 2008 08:32:41 -0700

List-id: BK change log <xen-changelog.lists.xensource.com>

# HG changeset patch # User Isaku Yamahata <yamahata@xxxxxxxxxxxxx> # Date 1210642684 -32400 # Node ID f6fcc65413aee0da4b6b1df03a876342fd526667 # Parent 5d938fac27a2f7365f1cc0b28a0dcbe1af95b727 # Parent 05b7df5cc607bf5b00725232085c35e5b6d493fe merge with linux-2.6.18-xen.hg --- arch/i386/kernel/acpi/Makefile | 1 arch/i386/kernel/acpi/processor.c | 11 arch/i386/kernel/acpi/processor_extcntl_xen.c | 142 ++++ arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c | 11 arch/x86_64/kernel/acpi/Makefile | 2 buildconfigs/linux-defconfig_xen0_x86_32 | 1 buildconfigs/linux-defconfig_xen0_x86_64 | 1 buildconfigs/linux-defconfig_xen_x86_32 | 1 buildconfigs/linux-defconfig_xen_x86_64 | 1 drivers/acpi/Kconfig | 6 drivers/acpi/Makefile | 3 drivers/acpi/processor_core.c | 70 ++ drivers/acpi/processor_extcntl.c | 137 ++++ drivers/acpi/processor_idle.c | 44 + drivers/acpi/processor_perflib.c | 5 drivers/pci/Kconfig | 1 drivers/pci/msi-xen.c | 709 ++++++++++++++++++++++++ drivers/pci/msi.h | 5 drivers/xen/core/evtchn.c | 5 drivers/xen/pciback/Makefile | 1 drivers/xen/pciback/conf_space_capability_msi.c | 60 ++ drivers/xen/pciback/pci_stub.c | 24 drivers/xen/pciback/pciback.h | 14 drivers/xen/pciback/pciback_ops.c | 38 + drivers/xen/pcifront/pci_op.c | 116 +++ drivers/xen/privcmd/privcmd.c | 2 include/acpi/processor.h | 97 +++ include/asm-i386/io_apic.h | 2 include/asm-x86_64/io_apic.h | 2 include/asm-x86_64/msi.h | 9 include/linux/pci.h | 3 include/xen/evtchn.h | 14 include/xen/interface/arch-ia64.h | 59 - include/xen/interface/arch-ia64/hvm/memmap.h | 88 ++ include/xen/interface/arch-ia64/sioemu.h | 53 + include/xen/interface/arch-x86/xen-x86_32.h | 7 include/xen/interface/domctl.h | 23 include/xen/interface/hvm/hvm_op.h | 16 include/xen/interface/hvm/params.h | 8 include/xen/interface/io/protocols.h | 3 include/xen/interface/io/xs_wire.h | 1 include/xen/interface/libelf.h | 4 include/xen/interface/physdev.h | 32 + include/xen/interface/platform.h | 65 ++ include/xen/interface/sysctl.h | 11 include/xen/interface/xen.h | 2 include/xen/interface/xsm/acm.h | 8 47 files changed, 1829 insertions(+), 89 deletions(-) diff -r 5d938fac27a2 -r f6fcc65413ae arch/i386/kernel/acpi/Makefile --- a/arch/i386/kernel/acpi/Makefile Thu Apr 24 14:08:54 2008 -0600 +++ b/arch/i386/kernel/acpi/Makefile Tue May 13 10:38:04 2008 +0900 @@ -4,6 +4,7 @@ obj-$(CONFIG_ACPI_SLEEP) += sleep.o wake ifneq ($(CONFIG_ACPI_PROCESSOR),) obj-y += cstate.o processor.o +obj-$(CONFIG_XEN) += processor_extcntl_xen.o endif disabled-obj-$(CONFIG_XEN) := cstate.o wakeup.o diff -r 5d938fac27a2 -r f6fcc65413ae arch/i386/kernel/acpi/processor.c --- a/arch/i386/kernel/acpi/processor.c Thu Apr 24 14:08:54 2008 -0600 +++ b/arch/i386/kernel/acpi/processor.c Tue May 13 10:38:04 2008 +0900 @@ -62,7 +62,18 @@ static void init_intel_pdc(struct acpi_p /* Initialize _PDC data based on the CPU vendor */ void arch_acpi_processor_init_pdc(struct acpi_processor *pr) { +#ifdef CONFIG_XEN + /* + * As a work-around, just use cpu0's cpuinfo for all processors. + * Further work is required to expose xen hypervisor interface of + * getting physical cpuinfo to dom0 kernel and then + * arch_acpi_processor_init_pdc can set _PDC parameters according + * to Xen's phys information. + */ + unsigned int cpu = 0; +#else unsigned int cpu = pr->id; +#endif /* CONFIG_XEN */ struct cpuinfo_x86 *c = cpu_data + cpu; pr->pdc = NULL; diff -r 5d938fac27a2 -r f6fcc65413ae arch/i386/kernel/acpi/processor_extcntl_xen.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/arch/i386/kernel/acpi/processor_extcntl_xen.c Tue May 13 10:38:04 2008 +0900 @@ -0,0 +1,142 @@ +/* + * processor_extcntl_xen.c - interface to notify Xen + * + * Copyright (C) 2008, Intel corporation + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or (at + * your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + * + */ + +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/types.h> +#include <linux/acpi.h> +#include <linux/pm.h> +#include <linux/cpu.h> + +#include <acpi/processor.h> +#include <asm/hypercall.h> + +static int xen_processor_pmbits; +static int __init set_xen_processor_pmbits(char *str) +{ + get_option(&str, &xen_processor_pmbits); + + return 1; +} +__setup("xen_processor_pmbits=", set_xen_processor_pmbits); +EXPORT_SYMBOL(xen_processor_pmbits); + +static int xen_cx_notifier(struct acpi_processor *pr, int action) +{ + int ret, count = 0, i; + xen_platform_op_t op = { + .cmd = XENPF_set_processor_pminfo, + .interface_version = XENPF_INTERFACE_VERSION, + .u.set_pminfo.id = pr->acpi_id, + .u.set_pminfo.type = XEN_PM_CX, + }; + struct xen_processor_cx *data, *buf; + struct acpi_processor_cx *cx; + + if (action == PROCESSOR_PM_CHANGE) + return -EINVAL; + + /* Convert to Xen defined structure and hypercall */ + buf = kzalloc(pr->power.count * sizeof(struct xen_processor_cx), + GFP_KERNEL); + if (!buf) + return -ENOMEM; + + data = buf; + for (i = 1; i <= pr->power.count; i++) { + cx = &pr->power.states[i]; + /* Skip invalid cstate entry */ + if (!cx->valid) + continue; + + data->type = cx->type; + data->latency = cx->latency; + data->power = cx->power; + data->reg.space_id = cx->reg.space_id; + data->reg.bit_width = cx->reg.bit_width; + data->reg.bit_offset = cx->reg.bit_offset; + data->reg.access_size = cx->reg.reserved; + data->reg.address = cx->reg.address; + + /* Get dependency relationships */ + if (cx->csd_count) { + printk("Wow! _CSD is found. Not support for now!\n"); + kfree(buf); + return -EINVAL; + } else { + data->dpcnt = 0; + set_xen_guest_handle(data->dp, NULL); + } + + data++; + count++; + } + + if (!count) { + printk("No available Cx info for cpu %d\n", pr->acpi_id); + kfree(buf); + return -EINVAL; + } + + op.u.set_pminfo.power.count = count; + op.u.set_pminfo.power.flags.bm_control = pr->flags.bm_control; + op.u.set_pminfo.power.flags.bm_check = pr->flags.bm_check; + op.u.set_pminfo.power.flags.has_cst = pr->flags.has_cst; + op.u.set_pminfo.power.flags.power_setup_done = pr->flags.power_setup_done; + + set_xen_guest_handle(op.u.set_pminfo.power.states, buf); + ret = HYPERVISOR_platform_op(&op); + kfree(buf); + return ret; +} + +static int xen_px_notifier(struct acpi_processor *pr, int action) +{ + return -EINVAL; +} + +static int xen_tx_notifier(struct acpi_processor *pr, int action) +{ + return -EINVAL; +} +static int xen_hotplug_notifier(struct acpi_processor *pr, int event) +{ + return -EINVAL; +} + +static struct processor_extcntl_ops xen_extcntl_ops = { + .hotplug = xen_hotplug_notifier, +}; + +static int __cpuinit xen_init_processor_extcntl(void) +{ + if (xen_processor_pmbits & XEN_PROCESSOR_PM_CX) + xen_extcntl_ops.pm_ops[PM_TYPE_IDLE] = xen_cx_notifier; + if (xen_processor_pmbits & XEN_PROCESSOR_PM_PX) + xen_extcntl_ops.pm_ops[PM_TYPE_PERF] = xen_px_notifier; + if (xen_processor_pmbits & XEN_PROCESSOR_PM_TX) + xen_extcntl_ops.pm_ops[PM_TYPE_THR] = xen_tx_notifier; + + return processor_register_extcntl(&xen_extcntl_ops); +} +core_initcall(xen_init_processor_extcntl); diff -r 5d938fac27a2 -r f6fcc65413ae arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c --- a/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c Thu Apr 24 14:08:54 2008 -0600 +++ b/arch/i386/kernel/cpu/cpufreq/acpi-cpufreq.c Tue May 13 10:38:04 2008 +0900 @@ -568,6 +568,17 @@ acpi_cpufreq_init (void) { dprintk("acpi_cpufreq_init\n"); +#ifdef CONFIG_XEN + /* + * This effectively blocks in-kernel cpufreq driver to interfere + * external control logic + */ + if (processor_pmperf_external()) { + printk("CPUFREQ is controllerd externally...exit then!\n"); + return -1; + } +#endif /* CONFIG_XEN */ + acpi_cpufreq_early_init_acpi(); return cpufreq_register_driver(&acpi_cpufreq_driver); diff -r 5d938fac27a2 -r f6fcc65413ae arch/x86_64/kernel/acpi/Makefile --- a/arch/x86_64/kernel/acpi/Makefile Thu Apr 24 14:08:54 2008 -0600 +++ b/arch/x86_64/kernel/acpi/Makefile Tue May 13 10:38:04 2008 +0900 @@ -8,4 +8,6 @@ processor-$(CONFIG_XEN) := ../../../i386 processor-$(CONFIG_XEN) := ../../../i386/kernel/acpi/processor.o endif +obj-$(CONFIG_XEN) += processor_extcnt_xen.o +processor_extcnt_xen-$(CONFIG_XEN) := ../../../i386/kernel/acpi/processor_extcntl_xen.o disabled-obj-$(CONFIG_XEN) := wakeup.o diff -r 5d938fac27a2 -r f6fcc65413ae buildconfigs/linux-defconfig_xen0_x86_32 --- a/buildconfigs/linux-defconfig_xen0_x86_32 Thu Apr 24 14:08:54 2008 -0600 +++ b/buildconfigs/linux-defconfig_xen0_x86_32 Tue May 13 10:38:04 2008 +0900 @@ -248,6 +248,7 @@ CONFIG_XEN_PCIDEV_FRONTEND=y CONFIG_XEN_PCIDEV_FRONTEND=y # CONFIG_XEN_PCIDEV_FE_DEBUG is not set # CONFIG_PCIEPORTBUS is not set +# CONFIG_PCI_MSI is not set # CONFIG_PCI_DEBUG is not set CONFIG_ISA_DMA_API=y # CONFIG_SCx200 is not set diff -r 5d938fac27a2 -r f6fcc65413ae buildconfigs/linux-defconfig_xen0_x86_64 --- a/buildconfigs/linux-defconfig_xen0_x86_64 Thu Apr 24 14:08:54 2008 -0600 +++ b/buildconfigs/linux-defconfig_xen0_x86_64 Tue May 13 10:38:04 2008 +0900 @@ -204,6 +204,7 @@ CONFIG_XEN_PCIDEV_FRONTEND=y CONFIG_XEN_PCIDEV_FRONTEND=y # CONFIG_XEN_PCIDEV_FE_DEBUG is not set # CONFIG_PCIEPORTBUS is not set +# CONFIG_PCI_MSI is not set # CONFIG_PCI_DEBUG is not set # diff -r 5d938fac27a2 -r f6fcc65413ae buildconfigs/linux-defconfig_xen_x86_32 --- a/buildconfigs/linux-defconfig_xen_x86_32 Thu Apr 24 14:08:54 2008 -0600 +++ b/buildconfigs/linux-defconfig_xen_x86_32 Tue May 13 10:38:04 2008 +0900 @@ -254,6 +254,7 @@ CONFIG_XEN_PCIDEV_FRONTEND=y CONFIG_XEN_PCIDEV_FRONTEND=y # CONFIG_XEN_PCIDEV_FE_DEBUG is not set # CONFIG_PCIEPORTBUS is not set +# CONFIG_PCI_MSI is not set # CONFIG_PCI_DEBUG is not set CONFIG_ISA_DMA_API=y CONFIG_SCx200=m diff -r 5d938fac27a2 -r f6fcc65413ae buildconfigs/linux-defconfig_xen_x86_64 --- a/buildconfigs/linux-defconfig_xen_x86_64 Thu Apr 24 14:08:54 2008 -0600 +++ b/buildconfigs/linux-defconfig_xen_x86_64 Tue May 13 10:38:04 2008 +0900 @@ -209,6 +209,7 @@ CONFIG_XEN_PCIDEV_FRONTEND=y CONFIG_XEN_PCIDEV_FRONTEND=y # CONFIG_XEN_PCIDEV_FE_DEBUG is not set # CONFIG_PCIEPORTBUS is not set +# CONFIG_PCI_MSI is not set # CONFIG_PCI_DEBUG is not set # diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/Kconfig --- a/drivers/acpi/Kconfig Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/acpi/Kconfig Tue May 13 10:38:04 2008 +0900 @@ -367,6 +367,12 @@ config ACPI_PV_SLEEP bool depends on X86 && XEN && ACPI_SLEEP default y + +config PROCESSOR_EXTERNAL_CONTROL + bool + depends on X86 && XEN + select ACPI_PROCESSOR + default y endif # ACPI endmenu diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/Makefile --- a/drivers/acpi/Makefile Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/acpi/Makefile Tue May 13 10:38:04 2008 +0900 @@ -34,6 +34,9 @@ ifdef CONFIG_CPU_FREQ ifdef CONFIG_CPU_FREQ processor-objs += processor_perflib.o endif +ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL +processor-objs += processor_extcntl.o +endif obj-y += sleep/ obj-y += bus.o glue.o diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/processor_core.c --- a/drivers/acpi/processor_core.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/acpi/processor_core.c Tue May 13 10:38:04 2008 +0900 @@ -474,8 +474,14 @@ static int acpi_processor_get_info(struc * they are physically not present. */ if (cpu_index == -1) { +#ifdef CONFIG_XEN + if (ACPI_FAILURE + (acpi_processor_hotadd_init(pr->handle, &pr->id)) && + !processor_cntl_external()) { +#else if (ACPI_FAILURE (acpi_processor_hotadd_init(pr->handle, &pr->id))) { +#endif /* CONFIG_XEN */ printk(KERN_ERR PREFIX "Getting cpuindex for acpiid 0x%x\n", pr->acpi_id); @@ -517,7 +523,11 @@ static int acpi_processor_get_info(struc return 0; } +#ifdef CONFIG_XEN +static void *processor_device_array[NR_ACPI_CPUS]; +#else static void *processor_device_array[NR_CPUS]; +#endif /* CONFIG_XEN */ static int acpi_processor_start(struct acpi_device *device) { @@ -529,27 +539,48 @@ static int acpi_processor_start(struct a pr = acpi_driver_data(device); result = acpi_processor_get_info(pr); +#ifdef CONFIG_XEN + if (result || + ((pr->id == -1) && !processor_cntl_external())) { +#else if (result) { +#endif /* CONFIG_XEN */ /* Processor is physically not present */ return 0; } +#ifdef CONFIG_XEN + BUG_ON(!processor_cntl_external() && + ((pr->id >= NR_CPUS) || (pr->id < 0))); +#else BUG_ON((pr->id >= NR_CPUS) || (pr->id < 0)); +#endif /* CONFIG_XEN */ /* * Buggy BIOS check * ACPI id of processors can be reported wrongly by the BIOS. * Don't trust it blindly */ +#ifdef CONFIG_XEN + if (processor_device_array[pr->acpi_id] != NULL && + processor_device_array[pr->acpi_id] != (void *)device) { +#else if (processor_device_array[pr->id] != NULL && processor_device_array[pr->id] != (void *)device) { +#endif /* CONFIG_XEN */ printk(KERN_WARNING "BIOS reported wrong ACPI id" "for the processor\n"); return -ENODEV; } +#ifdef CONFIG_XEN + processor_device_array[pr->acpi_id] = (void *)device; + if (pr->id != -1) + processors[pr->id] = pr; +#else processor_device_array[pr->id] = (void *)device; processors[pr->id] = pr; +#endif /* CONFIG_XEN */ result = acpi_processor_add_fs(device); if (result) @@ -563,6 +594,10 @@ static int acpi_processor_start(struct a acpi_processor_set_pdc(pr); acpi_processor_power_init(pr, device); + +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL + processor_extcntl_init(pr); +#endif if (pr->flags.throttling) { printk(KERN_INFO PREFIX "%s [%s] (supports", @@ -656,7 +691,13 @@ static int acpi_processor_remove(struct acpi_processor_remove_fs(device); +#ifdef CONFIG_XEN + if (pr->id != -1) + processors[pr->id] = NULL; +#else processors[pr->id] = NULL; +#endif /* CONFIG_XEN */ + kfree(pr); @@ -709,6 +750,12 @@ int acpi_processor_device_add(acpi_handl pr = acpi_driver_data(*device); if (!pr) return -ENODEV; + +#ifdef CONFIG_XEN + if (processor_cntl_external()) + processor_notify_external(pr, + PROCESSOR_HOTPLUG, HOTPLUG_TYPE_ADD); +#endif /* CONFIG_XEN */ if ((pr->id >= 0) && (pr->id < NR_CPUS)) { kobject_uevent(&(*device)->kobj, KOBJ_ONLINE); @@ -747,6 +794,12 @@ acpi_processor_hotplug_notify(acpi_handl printk(KERN_ERR PREFIX "Driver data is NULL\n"); break; } + +#ifdef CONFIG_XEN + if (processor_cntl_external()) + processor_notify_external(pr, + PROCESSOR_HOTPLUG, HOTPLUG_TYPE_ADD); +#endif /* CONFIG_XEN */ if (pr->id >= 0 && (pr->id < NR_CPUS)) { kobject_uevent(&device->kobj, KOBJ_OFFLINE); @@ -777,8 +830,20 @@ acpi_processor_hotplug_notify(acpi_handl return; } +#ifdef CONFIG_XEN + if ((pr->id >= 0) && (pr->id < NR_CPUS) + && (cpu_present(pr->id))) +#else if ((pr->id < NR_CPUS) && (cpu_present(pr->id))) +#endif /* CONFIG_XEN */ kobject_uevent(&device->kobj, KOBJ_OFFLINE); + +#ifdef CONFIG_XEN + if (processor_cntl_external()) + processor_notify_external(pr, PROCESSOR_HOTPLUG, + HOTPLUG_TYPE_REMOVE); +#endif /* CONFIG_XEN */ + break; default: ACPI_DEBUG_PRINT((ACPI_DB_INFO, @@ -843,6 +908,11 @@ static acpi_status acpi_processor_hotadd static int acpi_processor_handle_eject(struct acpi_processor *pr) { +#ifdef CONFIG_XEN + if (pr->id == -1) + return (0); +#endif /* CONFIG_XEN */ + if (cpu_online(pr->id)) { return (-EINVAL); } diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/processor_extcntl.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/acpi/processor_extcntl.c Tue May 13 10:38:04 2008 +0900 @@ -0,0 +1,137 @@ +/* + * processor_extcntl.c - channel to external control logic + * + * Copyright (C) 2008, Intel corporation + * + * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or (at + * your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, write to the Free Software Foundation, Inc., + * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA. + * + */ + +#include <linux/kernel.h> +#include <linux/init.h> +#include <linux/types.h> +#include <linux/acpi.h> +#include <linux/pm.h> +#include <linux/cpu.h> + +#include <acpi/processor.h> + +static int processor_extcntl_parse_csd(struct acpi_processor *pr); +/* + * External processor control logic may register with its own set of + * ops to get ACPI related notification. One example is like VMM. + */ +struct processor_extcntl_ops *processor_extcntl_ops; + +int processor_notify_external(struct acpi_processor *pr, int event, int type) +{ + int ret = -EINVAL; + + if (!processor_cntl_external()) + return -EINVAL; + + switch (event) { + case PROCESSOR_PM_INIT: + case PROCESSOR_PM_CHANGE: + if ((type >= PM_TYPE_MAX) || + !processor_extcntl_ops->pm_ops[type]) + break; + + ret = processor_extcntl_ops->pm_ops[type](pr, event); + break; + case PROCESSOR_HOTPLUG: + if (processor_extcntl_ops->hotplug) + ret = processor_extcntl_ops->hotplug(pr, type); + break; + default: + printk(KERN_ERR "Unsupport processor events %d.\n", event); + break; + } + + return ret; +} + +/* + * External control logic can decide to grab full or part of physical + * processor control bits. Take a VMM for example, physical processors + * are owned by VMM and thus existence information like hotplug is + * always required to be notified to VMM. Similar is processor idle + * state which is also necessarily controlled by VMM. But for other + * control bits like performance/throttle states, VMM may choose to + * control or not upon its own policy. + * + * Such ownership is unlikely to be switched in the fly, and thus + * not sure unregister interface is required or not. Being same reason, + * lock is not forced now. + */ +int processor_register_extcntl(struct processor_extcntl_ops *ops) +{ + if (!ops) + return -EINVAL; + + if (processor_extcntl_ops && + (processor_extcntl_ops != ops)) + return -EBUSY; + + processor_extcntl_ops = ops; + return 0; +} + +int processor_unregister_extcntl(struct processor_extcntl_ops *ops) +{ + if (processor_extcntl_ops == ops) + processor_extcntl_ops = NULL; + + return 0; +} + +/* + * This is called from ACPI processor init, and targeted to hold + * some tricky housekeeping jobs to satisfy external control model. + * For example, we may put dependency parse stub here for idle + * and performance state. Those information may be not available + * if splitting from dom0 control logic like cpufreq driver. + */ +int processor_extcntl_init(struct acpi_processor *pr) +{ + /* parse cstate dependency information */ + processor_extcntl_parse_csd(pr); + + return 0; +} + +/* + * Currently no _CSD is implemented which is why existing ACPI code + * doesn't parse _CSD at all. But to keep interface complete with + * external control logic, we put a placeholder here for future + * compatibility. + */ +static int processor_extcntl_parse_csd(struct acpi_processor *pr) +{ + int i; + + for (i = 0; i < pr->power.count; i++) { + if (!pr->power.states[i].valid) + continue; + + /* No dependency by default */ + pr->power.states[i].domain_info = NULL; + pr->power.states[i].csd_count = 0; + } + + return 0; +} diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/processor_idle.c --- a/drivers/acpi/processor_idle.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/acpi/processor_idle.c Tue May 13 10:38:04 2008 +0900 @@ -714,8 +714,17 @@ static int acpi_processor_get_power_info (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) continue; +#ifdef CONFIG_XEN + if (!processor_pm_external()) + cx.address = (reg->space_id == + ACPI_ADR_SPACE_FIXED_HARDWARE) ? + 0 : reg->address; + else + cx.address = reg->address; +#else cx.address = (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) ? 0 : reg->address; +#endif /* CONFIG_XEN */ /* There should be an easy way to extract an integer... */ obj = (union acpi_object *)&(element->package.elements[1]); @@ -724,9 +733,17 @@ static int acpi_processor_get_power_info cx.type = obj->integer.value; +#ifdef CONFIG_XEN + /* Following check doesn't apply to external control case */ + if (!processor_pm_external()) + if ((cx.type != ACPI_STATE_C1) && + (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO)) + continue; +#else if ((cx.type != ACPI_STATE_C1) && (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO)) continue; +#endif /* CONFIG_XEN */ if ((cx.type < ACPI_STATE_C2) || (cx.type > ACPI_STATE_C3)) continue; @@ -742,6 +759,12 @@ static int acpi_processor_get_power_info continue; cx.power = obj->integer.value; + +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL + /* cache control methods to notify external logic */ + if (processor_pm_external()) + memcpy(&cx.reg, reg, sizeof(*reg)); +#endif current_count++; memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx)); @@ -985,12 +1008,24 @@ int acpi_processor_cst_has_changed(struc return -ENODEV; /* Fall back to the default idle loop */ +#ifdef CONFIG_XEN + if (!processor_pm_external()) + pm_idle = pm_idle_save; +#else pm_idle = pm_idle_save; +#endif /* CONFIG_XEN */ synchronize_sched(); /* Relies on interrupts forcing exit from idle. */ pr->flags.power = 0; result = acpi_processor_get_power_info(pr); +#ifdef CONFIG_XEN + if (processor_pm_external()) + processor_notify_external(pr, + PROCESSOR_PM_CHANGE, PM_TYPE_IDLE); + else if ((pr->flags.power == 1) && (pr->flags.power_setup_done)) +#else if ((pr->flags.power == 1) && (pr->flags.power_setup_done)) +#endif /* CONFIG_XEN */ pm_idle = acpi_processor_idle; return result; @@ -1122,7 +1157,11 @@ int acpi_processor_power_init(struct acp pr->power.states[i].type); printk(")\n"); +#ifdef CONFIG_XEN + if (!processor_pm_external() && (pr->id == 0)) { +#else if (pr->id == 0) { +#endif /* CONFIG_XEN */ pm_idle_save = pm_idle; pm_idle = acpi_processor_idle; } @@ -1141,6 +1180,11 @@ int acpi_processor_power_init(struct acp pr->flags.power_setup_done = 1; +#ifdef CONFIG_XEN + if (processor_pm_external()) + processor_notify_external(pr, + PROCESSOR_PM_INIT, PM_TYPE_IDLE); +#endif /* CONFIG_XEN */ return 0; } diff -r 5d938fac27a2 -r f6fcc65413ae drivers/acpi/processor_perflib.c --- a/drivers/acpi/processor_perflib.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/acpi/processor_perflib.c Tue May 13 10:38:04 2008 +0900 @@ -136,6 +136,11 @@ int acpi_processor_ppc_has_changed(struc int ret = acpi_processor_get_platform_limit(pr); if (ret < 0) return (ret); +#ifdef CONFIG_XEN + else if (processor_pmperf_external()) + return processor_notify_external(pr, + PROCESSOR_PM_CHANGE, PM_TYPE_PERF); +#endif /* CONFIG_XEN */ else return cpufreq_update_policy(pr->id); } diff -r 5d938fac27a2 -r f6fcc65413ae drivers/pci/Kconfig --- a/drivers/pci/Kconfig Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/pci/Kconfig Tue May 13 10:38:04 2008 +0900 @@ -5,7 +5,6 @@ config PCI_MSI bool "Message Signaled Interrupts (MSI and MSI-X)" depends on PCI depends on (X86_LOCAL_APIC && X86_IO_APIC) || IA64 - depends on !XEN help This allows device drivers to enable MSI (Message Signaled Interrupts). Message Signaled Interrupts enable a device to diff -r 5d938fac27a2 -r f6fcc65413ae drivers/pci/msi-xen.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/pci/msi-xen.c Tue May 13 10:38:04 2008 +0900 @@ -0,0 +1,709 @@ +/* + * File: msi.c + * Purpose: PCI Message Signaled Interrupt (MSI) + * + * Copyright (C) 2003-2004 Intel + * Copyright (C) Tom Long Nguyen (tom.l.nguyen@xxxxxxxxx) + */ + +#include <linux/mm.h> +#include <linux/irq.h> +#include <linux/interrupt.h> +#include <linux/init.h> +#include <linux/ioport.h> +#include <linux/smp_lock.h> +#include <linux/pci.h> +#include <linux/proc_fs.h> + +#include <asm/errno.h> +#include <asm/io.h> +#include <asm/smp.h> + +#include "pci.h" +#include "msi.h" + +static int pci_msi_enable = 1; + +static struct msi_ops *msi_ops; + +int msi_register(struct msi_ops *ops) +{ + msi_ops = ops; + return 0; +} + +static struct list_head msi_dev_head; +static int msi_dev_head_inited = 0; +DEFINE_SPINLOCK(msi_dev_lock); + +struct msi_dev_list { + struct pci_dev *dev; + struct list_head list; + spinlock_t pirq_list_lock; + struct list_head pirq_list_head; +}; + +struct msi_pirq_entry { + struct list_head list; + int pirq; + int entry_nr; +}; + +static struct msi_dev_list *get_msi_dev_pirq_list(struct pci_dev *dev) +{ + struct msi_dev_list *msi_dev_list, *ret = NULL; + unsigned long flags; + + if (!msi_dev_head_inited) { + INIT_LIST_HEAD(&msi_dev_head); + msi_dev_head_inited = 1; + } + + spin_lock_irqsave(&msi_dev_lock, flags); + + list_for_each_entry(msi_dev_list, &msi_dev_head, list) + if ( msi_dev_list->dev == dev ) + ret = msi_dev_list; + + if ( ret ) { + spin_unlock_irqrestore(&msi_dev_lock, flags); + return ret; + } + + /* Has not allocate msi_dev until now. */ + ret = kmalloc(sizeof(struct msi_dev_list), GFP_ATOMIC); + + /* Failed to allocate msi_dev structure */ + if ( !ret ) { + spin_unlock_irqrestore(&msi_dev_lock, flags); + return NULL; + } + + list_add_tail(&ret->list, &msi_dev_head); + spin_unlock_irqrestore(&msi_dev_lock, flags); + spin_lock_init(&ret->pirq_list_lock); + INIT_LIST_HEAD(&ret->pirq_list_head); + return ret; +} + +static int attach_pirq_entry(int pirq, int entry_nr, + struct msi_dev_list *msi_dev_entry) +{ + struct msi_pirq_entry *entry = kmalloc(sizeof(*entry), GFP_ATOMIC); + unsigned long flags; + + if (!entry) + return -ENOMEM; + entry->pirq = pirq; + entry->entry_nr = entry_nr; + spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); + list_add_tail(&entry->list, &msi_dev_entry->pirq_list_head); + spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); + return 0; +} + +/* + * pciback will provide device's owner + */ +int (*get_owner)(struct pci_dev *dev); + +int register_msi_get_owner(int (*func)(struct pci_dev *dev)) +{ + if (get_owner) { + printk(KERN_WARNING "register msi_get_owner again\n"); + return -EEXIST; + } + get_owner = func; + return 0; +} + +int unregister_msi_get_owner(int (*func)(struct pci_dev *dev)) +{ + if (get_owner == func) + get_owner = NULL; + return 0; +} + +static int msi_get_dev_owner(struct pci_dev *dev) +{ + int owner = DOMID_SELF; + + BUG_ON(!is_initial_xendomain()); + if (get_owner && (owner = get_owner(dev)) >=0 ) { + printk(KERN_INFO "get owner for dev %x get %x \n", + dev->devfn, owner); + return owner; + } + else + return DOMID_SELF; +} + +static int msi_unmap_pirq(struct pci_dev *dev, int pirq) +{ + struct physdev_unmap_pirq unmap; + int rc; + domid_t domid = DOMID_SELF; + + domid = msi_get_dev_owner(dev); + unmap.domid = domid; + unmap.pirq = pirq; + + if ((rc = HYPERVISOR_physdev_op(PHYSDEVOP_unmap_pirq, &unmap))) + printk(KERN_WARNING "unmap irq %x failed\n", pirq); + + if (rc < 0) + return rc; + return 0; +} + +/* + * Protected by msi_lock + */ +static int msi_map_pirq_to_vector(struct pci_dev *dev, int pirq, + int entry_nr, int msi) +{ + struct physdev_map_pirq map_irq; + int rc; + domid_t domid = DOMID_SELF; + + domid = msi_get_dev_owner(dev); + + map_irq.domid = domid; + map_irq.type = MAP_PIRQ_TYPE_MSI; + map_irq.index = -1; + map_irq.pirq = pirq; + map_irq.msi_info.bus = dev->bus->number; + map_irq.msi_info.devfn = dev->devfn; + map_irq.msi_info.entry_nr = entry_nr; + map_irq.msi_info.msi = msi; + + if ((rc = HYPERVISOR_physdev_op(PHYSDEVOP_map_pirq, &map_irq))) + printk(KERN_WARNING "map irq failed\n"); + + if (rc < 0) + return rc; + + return map_irq.pirq; +} + +static int msi_map_vector(struct pci_dev *dev, int entry_nr, int msi) +{ + return msi_map_pirq_to_vector(dev, -1, entry_nr, msi); +} + +static int msi_init(void) +{ + static int status = 0; + + if (pci_msi_quirk) { + pci_msi_enable = 0; + printk(KERN_WARNING "PCI: MSI quirk detected. MSI disabled.\n"); + status = -EINVAL; + } + + return status; +} + +void pci_scan_msi_device(struct pci_dev *dev) { } + +void disable_msi_mode(struct pci_dev *dev, int pos, int type) +{ + u16 control; + + pci_read_config_word(dev, msi_control_reg(pos), &control); + if (type == PCI_CAP_ID_MSI) { + /* Set enabled bits to single MSI & enable MSI_enable bit */ + msi_disable(control); + pci_write_config_word(dev, msi_control_reg(pos), control); + dev->msi_enabled = 0; + } else { + msix_disable(control); + pci_write_config_word(dev, msi_control_reg(pos), control); + dev->msix_enabled = 0; + } + if (pci_find_capability(dev, PCI_CAP_ID_EXP)) { + /* PCI Express Endpoint device detected */ + pci_intx(dev, 1); /* enable intx */ + } +} + +static void enable_msi_mode(struct pci_dev *dev, int pos, int type) +{ + u16 control; + + pci_read_config_word(dev, msi_control_reg(pos), &control); + if (type == PCI_CAP_ID_MSI) { + /* Set enabled bits to single MSI & enable MSI_enable bit */ + msi_enable(control, 1); + pci_write_config_word(dev, msi_control_reg(pos), control); + dev->msi_enabled = 1; + } else { + msix_enable(control); + pci_write_config_word(dev, msi_control_reg(pos), control); + dev->msix_enabled = 1; + } + if (pci_find_capability(dev, PCI_CAP_ID_EXP)) { + /* PCI Express Endpoint device detected */ + pci_intx(dev, 0); /* disable intx */ + } +} + +#ifdef CONFIG_PM +int pci_save_msi_state(struct pci_dev *dev) +{ + int pos; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); + if (pos <= 0 || dev->no_msi) + return 0; + + if (!dev->msi_enabled) + return 0; + + /* Restore dev->irq to its default pin-assertion vector */ + msi_unmap_pirq(dev, dev->irq); + /* Disable MSI mode */ + disable_msi_mode(dev, pos, PCI_CAP_ID_MSI); + /* Set the flags for use of restore */ + dev->msi_enabled = 1; + return 0; +} + +void pci_restore_msi_state(struct pci_dev *dev) +{ + int pos, pirq; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); + if (pos <= 0) + return; + + if (!dev->msi_enabled) + return; + + pirq = msi_map_pirq_to_vector(dev, dev->irq, 0, 1); + if (pirq < 0) + return; + enable_msi_mode(dev, pos, PCI_CAP_ID_MSI); +} + +int pci_save_msix_state(struct pci_dev *dev) +{ + int pos; + unsigned long flags; + struct msi_dev_list *msi_dev_entry; + struct msi_pirq_entry *pirq_entry, *tmp; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); + if (pos <= 0 || dev->no_msi) + return 0; + + /* save the capability */ + if (!dev->msix_enabled) + return 0; + + msi_dev_entry = get_msi_dev_pirq_list(dev); + + spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); + if (!list_empty_careful(&msi_dev_entry->pirq_list_head)) + list_for_each_entry_safe(pirq_entry, tmp, + &msi_dev_entry->pirq_list_head, list) + msi_unmap_pirq(dev, pirq_entry->pirq); + spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); + + disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); + /* Set the flags for use of restore */ + dev->msix_enabled = 1; + + return 0; +} + +void pci_restore_msix_state(struct pci_dev *dev) +{ + int pos; + unsigned long flags; + struct msi_dev_list *msi_dev_entry; + struct msi_pirq_entry *pirq_entry, *tmp; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); + if (pos <= 0) + return; + + if (!dev->msix_enabled) + return; + + msi_dev_entry = get_msi_dev_pirq_list(dev); + + spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); + list_for_each_entry_safe(pirq_entry, tmp, + &msi_dev_entry->pirq_list_head, list) + msi_map_pirq_to_vector(dev, pirq_entry->pirq, pirq_entry->entry_nr, 0); + spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); + + enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); +} +#endif + +/** + * msi_capability_init - configure device's MSI capability structure + * @dev: pointer to the pci_dev data structure of MSI device function + * + * Setup the MSI capability structure of device function with a single + * MSI vector, regardless of device function is capable of handling + * multiple messages. A return of zero indicates the successful setup + * of an entry zero with the new MSI vector or non-zero for otherwise. + **/ +static int msi_capability_init(struct pci_dev *dev) +{ + int pos, pirq; + u16 control; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); + pci_read_config_word(dev, msi_control_reg(pos), &control); + + pirq = msi_map_vector(dev, 0, 1); + if (pirq < 0) + return -EBUSY; + + dev->irq = pirq; + /* Set MSI enabled bits */ + enable_msi_mode(dev, pos, PCI_CAP_ID_MSI); + dev->msi_enabled = 1; + + return 0; +} + +/** + * msix_capability_init - configure device's MSI-X capability + * @dev: pointer to the pci_dev data structure of MSI-X device function + * @entries: pointer to an array of struct msix_entry entries + * @nvec: number of @entries + * + * Setup the MSI-X capability structure of device function with a + * single MSI-X vector. A return of zero indicates the successful setup of + * requested MSI-X entries with allocated vectors or non-zero for otherwise. + **/ +static int msix_capability_init(struct pci_dev *dev, + struct msix_entry *entries, int nvec) +{ + int pirq, i, pos; + struct msi_dev_list *msi_dev_entry = get_msi_dev_pirq_list(dev); + struct msi_pirq_entry *pirq_entry, *tmp; + unsigned long flags; + + if (!msi_dev_entry) + return -ENOMEM; + + spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); + if (!list_empty_careful(&msi_dev_entry->pirq_list_head)) + { + printk(KERN_WARNING "msix pirqs for dev %02x:%02x:%01x are not freed \ + before acquire again.\n", dev->bus->number, PCI_SLOT(dev->devfn), + PCI_FUNC(dev->devfn)); + list_for_each_entry_safe(pirq_entry, tmp, + &msi_dev_entry->pirq_list_head, list) { + msi_unmap_pirq(dev, pirq_entry->pirq); + list_del(&pirq_entry->list); + kfree(pirq_entry); + } + } + spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); + + /* MSI-X Table Initialization */ + for (i = 0; i < nvec; i++) { + pirq = msi_map_vector(dev, entries[i].entry, 0); + if (pirq < 0) + break; + attach_pirq_entry(pirq, entries[i].entry, msi_dev_entry); + (entries + i)->vector = pirq; + } + if (i != nvec) { + msi_unmap_pirq(dev, dev->irq); + (entries + i)->vector = 0; + return -EBUSY; + } + + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); + enable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); + dev->msix_enabled = 1; + + return 0; +} + +/** + * pci_enable_msi - configure device's MSI capability structure + * @dev: pointer to the pci_dev data structure of MSI device function + * + * Setup the MSI capability structure of device function with + * a single MSI vector upon its software driver call to request for + * MSI mode enabled on its hardware device function. A return of zero + * indicates the successful setup of an entry zero with the new MSI + * vector or non-zero for otherwise. + **/ +extern int pci_frontend_enable_msi(struct pci_dev *dev); +int pci_enable_msi(struct pci_dev* dev) +{ + struct pci_bus *bus; + int pos, temp, status = -EINVAL; + + if (!pci_msi_enable || !dev) + return status; + + if (dev->no_msi) + return status; + + for (bus = dev->bus; bus; bus = bus->parent) + if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI) + return -EINVAL; + + status = msi_init(); + if (status < 0) + return status; + +#ifdef CONFIG_XEN_PCIDEV_FRONTEND + if (!is_initial_xendomain()) + { + int ret; + + temp = dev->irq; + ret = pci_frontend_enable_msi(dev); + if (ret) + return ret; + + dev->irq_old = temp; + + return ret; + } +#endif + + temp = dev->irq; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); + if (!pos) + return -EINVAL; + + /* Check whether driver already requested for MSI-X vectors */ + if (dev->msix_enabled) { + printk(KERN_INFO "PCI: %s: Can't enable MSI. " + "Device already has MSI-X vectors assigned\n", + pci_name(dev)); + dev->irq = temp; + return -EINVAL; + } + + status = msi_capability_init(dev); + if ( !status ) + dev->irq_old = temp; + else + dev->irq = temp; + + return status; +} + +extern void pci_frontend_disable_msi(struct pci_dev* dev); +void pci_disable_msi(struct pci_dev* dev) +{ + int pos; + int pirq; + + if (!pci_msi_enable) + return; + if (!dev) + return; + +#ifdef CONFIG_XEN_PCIDEV_FRONTEND + if (!is_initial_xendomain()) { + pci_frontend_disable_msi(dev); + dev->irq = dev->irq_old; + return; + } +#endif + + pos = pci_find_capability(dev, PCI_CAP_ID_MSI); + if (!pos) + return; + + pirq = dev->irq; + /* Restore dev->irq to its default pin-assertion vector */ + dev->irq = dev->irq_old; + msi_unmap_pirq(dev, pirq); + + /* Disable MSI mode */ + disable_msi_mode(dev, pos, PCI_CAP_ID_MSI); +} + +/** + * pci_enable_msix - configure device's MSI-X capability structure + * @dev: pointer to the pci_dev data structure of MSI-X device function + * @entries: pointer to an array of MSI-X entries + * @nvec: number of MSI-X vectors requested for allocation by device driver + * + * Setup the MSI-X capability structure of device function with the number + * of requested vectors upon its software driver call to request for + * MSI-X mode enabled on its hardware device function. A return of zero + * indicates the successful configuration of MSI-X capability structure + * with new allocated MSI-X vectors. A return of < 0 indicates a failure. + * Or a return of > 0 indicates that driver request is exceeding the number + * of vectors available. Driver should use the returned value to re-send + * its request. + **/ +extern int pci_frontend_enable_msix(struct pci_dev *dev, + struct msix_entry *entries, int nvec); +int pci_enable_msix(struct pci_dev* dev, struct msix_entry *entries, int nvec) +{ + struct pci_bus *bus; + int status, pos, nr_entries; + int i, j, temp; + u16 control; + + if (!pci_msi_enable || !dev || !entries) + return -EINVAL; + + if (dev->no_msi) + return -EINVAL; + + for (bus = dev->bus; bus; bus = bus->parent) + if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI) + return -EINVAL; + +#ifdef CONFIG_XEN_PCIDEV_FRONTEND + if (!is_initial_xendomain()) { + int ret; + + ret = pci_frontend_enable_msix(dev, entries, nvec); + if (ret) { + printk("get %x from pci_frontend_enable_msix\n", ret); + return ret; + } + + return 0; + } +#endif + + status = msi_init(); + if (status < 0) + return status; + + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); + if (!pos) + return -EINVAL; + + pci_read_config_word(dev, msi_control_reg(pos), &control); + nr_entries = multi_msix_capable(control); + if (nvec > nr_entries) + return -EINVAL; + + /* Check for any invalid entries */ + for (i = 0; i < nvec; i++) { + if (entries[i].entry >= nr_entries) + return -EINVAL; /* invalid entry */ + for (j = i + 1; j < nvec; j++) { + if (entries[i].entry == entries[j].entry) + return -EINVAL; /* duplicate entry */ + } + } + + temp = dev->irq; + /* Check whether driver already requested for MSI vector */ + if (dev->msi_enabled) { + printk(KERN_INFO "PCI: %s: Can't enable MSI-X. " + "Device already has an MSI vector assigned\n", + pci_name(dev)); + dev->irq = temp; + return -EINVAL; + } + + status = msix_capability_init(dev, entries, nvec); + + if ( !status ) + dev->irq_old = temp; + else + dev->irq = temp; + + return status; +} + +extern void pci_frontend_disable_msix(struct pci_dev* dev); +void pci_disable_msix(struct pci_dev* dev) +{ + int pos; + u16 control; + + + if (!pci_msi_enable) + return; + if (!dev) + return; + +#ifdef CONFIG_XEN_PCIDEV_FRONTEND + if (!is_initial_xendomain()) { + pci_frontend_disable_msix(dev); + dev->irq = dev->irq_old; + return; + } +#endif + + pos = pci_find_capability(dev, PCI_CAP_ID_MSIX); + if (!pos) + return; + + pci_read_config_word(dev, msi_control_reg(pos), &control); + if (!(control & PCI_MSIX_FLAGS_ENABLE)) + return; + + msi_remove_pci_irq_vectors(dev); + + /* Disable MSI mode */ + disable_msi_mode(dev, pos, PCI_CAP_ID_MSIX); +} + +/** + * msi_remove_pci_irq_vectors - reclaim MSI(X) vectors to unused state + * @dev: pointer to the pci_dev data structure of MSI(X) device function + * + * Being called during hotplug remove, from which the device function + * is hot-removed. All previous assigned MSI/MSI-X vectors, if + * allocated for this device function, are reclaimed to unused state, + * which may be used later on. + **/ +void msi_remove_pci_irq_vectors(struct pci_dev* dev) +{ + unsigned long flags; + struct msi_dev_list *msi_dev_entry; + struct msi_pirq_entry *pirq_entry, *tmp; + + if (!pci_msi_enable || !dev) + return; + + msi_dev_entry = get_msi_dev_pirq_list(dev); + + spin_lock_irqsave(&msi_dev_entry->pirq_list_lock, flags); + if (!list_empty_careful(&msi_dev_entry->pirq_list_head)) + { + printk(KERN_WARNING "msix pirqs for dev %02x:%02x:%01x are not freed \ + before acquire again.\n", dev->bus->number, PCI_SLOT(dev->devfn), + PCI_FUNC(dev->devfn)); + list_for_each_entry_safe(pirq_entry, tmp, + &msi_dev_entry->pirq_list_head, list) { + msi_unmap_pirq(dev, pirq_entry->pirq); + list_del(&pirq_entry->list); + kfree(pirq_entry); + } + } + spin_unlock_irqrestore(&msi_dev_entry->pirq_list_lock, flags); + dev->irq = dev->irq_old; +} + +void pci_no_msi(void) +{ + pci_msi_enable = 0; +} + +EXPORT_SYMBOL(pci_enable_msi); +EXPORT_SYMBOL(pci_disable_msi); +EXPORT_SYMBOL(pci_enable_msix); +EXPORT_SYMBOL(pci_disable_msix); +#ifdef CONFIG_XEN +EXPORT_SYMBOL(register_msi_get_owner); +EXPORT_SYMBOL(unregister_msi_get_owner); +#endif + diff -r 5d938fac27a2 -r f6fcc65413ae drivers/pci/msi.h --- a/drivers/pci/msi.h Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/pci/msi.h Tue May 13 10:38:04 2008 +0900 @@ -84,6 +84,11 @@ extern void (*interrupt[NR_IRQS])(void); extern void (*interrupt[NR_IRQS])(void); extern int pci_vector_resources(int last, int nr_released); +#ifdef CONFIG_XEN +extern int unregister_msi_get_owner(int (*func)(struct pci_dev *dev)); +extern int register_msi_get_owner(int (*func)(struct pci_dev *dev)); +#endif + /* * MSI-X Address Register */ diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/core/evtchn.c --- a/drivers/xen/core/evtchn.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/core/evtchn.c Tue May 13 10:38:04 2008 +0900 @@ -200,9 +200,6 @@ static inline void exit_idle(void) {} (regs)->IRQ_REG = ~(irq); \ do_IRQ((regs)); \ } while (0) -#elif defined (__powerpc__) -#define do_IRQ(irq, regs) __do_IRQ(irq, regs) -static inline void exit_idle(void) {} #endif /* Xen will never allocate port zero for any purpose. */ @@ -246,7 +243,7 @@ asmlinkage void evtchn_do_upcall(struct #ifndef CONFIG_X86 /* No need for a barrier -- XCHG is a barrier on x86. */ /* Clear master flag /before/ clearing selector flag. */ - rmb(); + wmb(); #endif l1 = xchg(&vcpu_info->evtchn_pending_sel, 0); diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pciback/Makefile --- a/drivers/xen/pciback/Makefile Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/pciback/Makefile Tue May 13 10:38:04 2008 +0900 @@ -6,6 +6,7 @@ pciback-y += conf_space.o conf_space_hea conf_space_capability_vpd.o \ conf_space_capability_pm.o \ conf_space_quirks.o +pciback-$(CONFIG_PCI_MSI) += conf_space_capability_msi.o pciback-$(CONFIG_XEN_PCIDEV_BACKEND_VPCI) += vpci.o pciback-$(CONFIG_XEN_PCIDEV_BACKEND_SLOT) += slot.o pciback-$(CONFIG_XEN_PCIDEV_BACKEND_PASS) += passthrough.o diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pciback/conf_space_capability_msi.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/drivers/xen/pciback/conf_space_capability_msi.c Tue May 13 10:38:04 2008 +0900 @@ -0,0 +1,60 @@ +/* + * PCI Backend -- Configuration overlay for MSI capability + */ +#include <linux/pci.h> +#include "conf_space.h" +#include "conf_space_capability.h" +#include <xen/interface/io/pciif.h> +#include "pciback.h" + +int pciback_enable_msi(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op) +{ + int otherend = pdev->xdev->otherend_id; + int irq; + int status; + + status = pci_enable_msi(dev); + + if (status) { + printk("error enable msi for guest %x status %x\n", otherend, status); + op->value = 0; + return XEN_PCI_ERR_op_failed; + } + + op->value = dev->irq; + return 0; +} + +int pciback_disable_msi(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op) +{ + int old_irq = dev->irq; + + pci_disable_msi(dev); + + op->value = dev->irq; + return 0; +} + +int pciback_enable_msix(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op) +{ + int otherend = pdev->xdev->otherend_id, result, i; + + result = pci_enable_msix(dev, op->msix_entries, op->value); + + op->value = result; + return result; +} + +int pciback_disable_msix(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op) +{ + + pci_disable_msix(dev); + + op->value = dev->irq; + return 0; +} + diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pciback/pci_stub.c --- a/drivers/xen/pciback/pci_stub.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/pciback/pci_stub.c Tue May 13 10:38:04 2008 +0900 @@ -805,6 +805,23 @@ static ssize_t permissive_show(struct de DRIVER_ATTR(permissive, S_IRUSR | S_IWUSR, permissive_show, permissive_add); +#ifdef CONFIG_PCI_MSI + +int pciback_get_owner(struct pci_dev *dev) +{ + struct pcistub_device *psdev; + + psdev = pcistub_device_find(pci_domain_nr(dev->bus), dev->bus->number, + PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn)); + /* XXX will other domain has pciback support ??? */ + if (!psdev || !psdev->pdev) { + printk(KERN_WARNING "no ownder\n"); + return -1; + } + return psdev->pdev->xdev->otherend_id; +} +#endif + static void pcistub_exit(void) { driver_remove_file(&pciback_pci_driver.driver, &driver_attr_new_slot); @@ -815,6 +832,9 @@ static void pcistub_exit(void) driver_remove_file(&pciback_pci_driver.driver, &driver_attr_permissive); pci_unregister_driver(&pciback_pci_driver); +#ifdef CONFIG_PCI_MSI + unregister_msi_get_owner(pciback_get_owner); +#endif } static int __init pcistub_init(void) @@ -872,6 +892,10 @@ static int __init pcistub_init(void) err = driver_create_file(&pciback_pci_driver.driver, &driver_attr_permissive); +#ifdef CONFIG_PCI_MSI + if (!err) + err = register_msi_get_owner(pciback_get_owner); +#endif if (err) pcistub_exit(); diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pciback/pciback.h --- a/drivers/xen/pciback/pciback.h Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/pciback/pciback.h Tue May 13 10:38:04 2008 +0900 @@ -93,5 +93,19 @@ int pciback_xenbus_register(void); int pciback_xenbus_register(void); void pciback_xenbus_unregister(void); +#ifdef CONFIG_PCI_MSI +int pciback_enable_msi(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op); + +int pciback_disable_msi(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op); + + +int pciback_enable_msix(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op); + +int pciback_disable_msix(struct pciback_device *pdev, + struct pci_dev *dev, struct xen_pci_op *op); +#endif extern int verbose_request; #endif diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pciback/pciback_ops.c --- a/drivers/xen/pciback/pciback_ops.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/pciback/pciback_ops.c Tue May 13 10:38:04 2008 +0900 @@ -61,15 +61,37 @@ void pciback_do_op(void *data) if (dev == NULL) op->err = XEN_PCI_ERR_dev_not_found; - else if (op->cmd == XEN_PCI_OP_conf_read) - op->err = pciback_config_read(dev, op->offset, op->size, - &op->value); - else if (op->cmd == XEN_PCI_OP_conf_write) - op->err = pciback_config_write(dev, op->offset, op->size, - op->value); else - op->err = XEN_PCI_ERR_not_implemented; - + { + switch (op->cmd) + { + case XEN_PCI_OP_conf_read: + op->err = pciback_config_read(dev, + op->offset, op->size, &op->value); + break; + case XEN_PCI_OP_conf_write: + op->err = pciback_config_write(dev, + op->offset, op->size, op->value); + break; +#ifdef CONFIG_PCI_MSI + case XEN_PCI_OP_enable_msi: + op->err = pciback_enable_msi(pdev, dev, op); + break; + case XEN_PCI_OP_disable_msi: + op->err = pciback_disable_msi(pdev, dev, op); + break; + case XEN_PCI_OP_enable_msix: + op->err = pciback_enable_msix(pdev, dev, op); + break; + case XEN_PCI_OP_disable_msix: + op->err = pciback_disable_msix(pdev, dev, op); + break; +#endif + default: + op->err = XEN_PCI_ERR_not_implemented; + break; + } + } /* Tell the driver domain that we're done. */ wmb(); clear_bit(_XEN_PCIF_active, (unsigned long *)&pdev->sh_info->flags); diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/pcifront/pci_op.c --- a/drivers/xen/pcifront/pci_op.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/pcifront/pci_op.c Tue May 13 10:38:04 2008 +0900 @@ -277,6 +277,122 @@ struct pci_ops pcifront_bus_ops = { .write = pcifront_bus_write, }; +#ifdef CONFIG_PCI_MSI +int pci_frontend_enable_msix(struct pci_dev *dev, + struct msix_entry *entries, + int nvec) +{ + int err; + int i; + struct xen_pci_op op = { + .cmd = XEN_PCI_OP_enable_msix, + .domain = pci_domain_nr(dev->bus), + .bus = dev->bus->number, + .devfn = dev->devfn, + .value = nvec, + }; + struct pcifront_sd *sd = dev->bus->sysdata; + struct pcifront_device *pdev = pcifront_get_pdev(sd); + + if (nvec > SH_INFO_MAX_VEC) { + printk("too much vector for pci frontend%x\n", nvec); + return -EINVAL; + } + + for (i = 0; i < nvec; i++) { + op.msix_entries[i].entry = entries[i].entry; + op.msix_entries[i].vector = entries[i].vector; + } + + err = do_pci_op(pdev, &op); + + if (!err) { + if (!op.value) { + /* we get the result */ + for ( i = 0; i < nvec; i++) + entries[i].vector = op.msix_entries[i].vector; + return 0; + } + else { + printk("enable msix get value %x\n", op.value); + return op.value; + } + } + else { + printk("enable msix get err %x\n", err); + return err; + } +} + +void pci_frontend_disable_msix(struct pci_dev* dev) +{ + int err; + struct xen_pci_op op = { + .cmd = XEN_PCI_OP_disable_msix, + .domain = pci_domain_nr(dev->bus), + .bus = dev->bus->number, + .devfn = dev->devfn, + }; + struct pcifront_sd *sd = dev->bus->sysdata; + struct pcifront_device *pdev = pcifront_get_pdev(sd); + + err = do_pci_op(pdev, &op); + + /* What should do for error ? */ + if (err) + printk("pci_disable_msix get err %x\n", err); +} + +int pci_frontend_enable_msi(struct pci_dev *dev) +{ + int err; + struct xen_pci_op op = { + .cmd = XEN_PCI_OP_enable_msi, + .domain = pci_domain_nr(dev->bus), + .bus = dev->bus->number, + .devfn = dev->devfn, + }; + struct pcifront_sd *sd = dev->bus->sysdata; + struct pcifront_device *pdev = pcifront_get_pdev(sd); + + err = do_pci_op(pdev, &op); + if (likely(!err)) { + dev->irq = op.value; + } + else { + printk("pci frontend enable msi failed for dev %x:%x \n", + op.bus, op.devfn); + err = -EINVAL; + } + return err; +} + +void pci_frontend_disable_msi(struct pci_dev* dev) +{ + int err; + struct xen_pci_op op = { + .cmd = XEN_PCI_OP_disable_msi, + .domain = pci_domain_nr(dev->bus), + .bus = dev->bus->number, + .devfn = dev->devfn, + }; + struct pcifront_sd *sd = dev->bus->sysdata; + struct pcifront_device *pdev = pcifront_get_pdev(sd); + + err = do_pci_op(pdev, &op); + if (err == XEN_PCI_ERR_dev_not_found) { + /* XXX No response from backend, what shall we do? */ + printk("get no response from backend for disable MSI\n"); + return; + } + if (likely(!err)) + dev->irq = op.value; + else + /* how can pciback notify us fail? */ + printk("get fake response frombackend \n"); +} +#endif /* CONFIG_PCI_MSI */ + /* Claim resources for the PCI frontend as-is, backend won't allow changes */ static void pcifront_claim_resource(struct pci_dev *dev, void *data) { diff -r 5d938fac27a2 -r f6fcc65413ae drivers/xen/privcmd/privcmd.c --- a/drivers/xen/privcmd/privcmd.c Thu Apr 24 14:08:54 2008 -0600 +++ b/drivers/xen/privcmd/privcmd.c Tue May 13 10:38:04 2008 +0900 @@ -229,11 +229,9 @@ static struct vm_operations_struct privc static int privcmd_mmap(struct file * file, struct vm_area_struct * vma) { -#ifndef __powerpc__ /* PowerPC has a trick to safely do this. */ /* Unsupported for auto-translate guests. */ if (xen_feature(XENFEAT_auto_translated_physmap)) return -ENOSYS; -#endif /* DONTCOPY is essential for Xen as copy_page_range is broken. */ vma->vm_flags |= VM_RESERVED | VM_IO | VM_DONTCOPY; diff -r 5d938fac27a2 -r f6fcc65413ae include/acpi/processor.h --- a/include/acpi/processor.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/acpi/processor.h Tue May 13 10:38:04 2008 +0900 @@ -20,6 +20,10 @@ #define ACPI_PSD_REV0_REVISION 0 /* Support for _PSD as in ACPI 3.0 */ #define ACPI_PSD_REV0_ENTRIES 5 + +#ifdef CONFIG_XEN +#define NR_ACPI_CPUS 256 +#endif /* CONFIG_XEN */ /* * Types of coordination defined in ACPI 3.0. Same macros can be used across @@ -32,6 +36,17 @@ /* Power Management */ struct acpi_processor_cx; + +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL +struct acpi_csd_package { + acpi_integer num_entries; + acpi_integer revision; + acpi_integer domain; + acpi_integer coord_type; + acpi_integer num_processors; + acpi_integer index; +} __attribute__ ((packed)); +#endif struct acpi_power_register { u8 descriptor; @@ -63,6 +78,12 @@ struct acpi_processor_cx { u32 power; u32 usage; u64 time; +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL + /* Require raw information for external control logic */ + struct acpi_power_register reg; + u32 csd_count; + struct acpi_csd_package *domain_info; +#endif struct acpi_processor_cx_policy promotion; struct acpi_processor_cx_policy demotion; }; @@ -275,4 +296,78 @@ static inline void acpi_thermal_cpufreq_ } #endif -#endif +#ifdef CONFIG_XEN +/* + * Following are interfaces geared to external processor PM control + * logic like a VMM + */ +/* Events notified to external control logic */ +#define PROCESSOR_PM_INIT 1 +#define PROCESSOR_PM_CHANGE 2 +#define PROCESSOR_HOTPLUG 3 + +/* Objects for the PM envents */ +#define PM_TYPE_IDLE 0 +#define PM_TYPE_PERF 1 +#define PM_TYPE_THR 2 +#define PM_TYPE_MAX 3 + +/* Processor hotplug events */ +#define HOTPLUG_TYPE_ADD 0 +#define HOTPLUG_TYPE_REMOVE 1 + +#ifdef CONFIG_PROCESSOR_EXTERNAL_CONTROL +struct processor_extcntl_ops { + /* Transfer processor PM events to external control logic */ + int (*pm_ops[PM_TYPE_MAX])(struct acpi_processor *pr, int event); + /* Notify physical processor status to external control logic */ + int (*hotplug)(struct acpi_processor *pr, int event); +}; +extern struct processor_extcntl_ops *processor_extcntl_ops; + +static inline int processor_cntl_external(void) +{ + return (processor_extcntl_ops != NULL); +} + +static inline int processor_pm_external(void) +{ + return processor_cntl_external() && + (processor_extcntl_ops->pm_ops[PM_TYPE_IDLE] != NULL); +} + +static inline int processor_pmperf_external(void) +{ + return processor_cntl_external() && + (processor_extcntl_ops->pm_ops[PM_TYPE_PERF] != NULL); +} + +static inline int processor_pmthr_external(void) +{ + return processor_cntl_external() && + (processor_extcntl_ops->pm_ops[PM_TYPE_THR] != NULL); +} + +extern int processor_notify_external(struct acpi_processor *pr, + int event, int type); +extern int processor_register_extcntl(struct processor_extcntl_ops *ops); +extern int processor_unregister_extcntl(struct processor_extcntl_ops *ops); +extern int processor_extcntl_init(struct acpi_processor *pr); +#else +static inline int processor_cntl_external(void) {return 0;} +static inline int processor_pm_external(void) {return 0;} +static inline int processor_pmperf_external(void) {return 0;} +static inline int processor_pmthr_external(void) {return 0;} +static inline int processor_notify_external(struct acpi_processor *pr, + int event, int type) +{ + return -EINVAL; +} +static inline int processor_extcntl_init(struct acpi_processor *pr) +{ + return -EINVAL; +} +#endif /* CONFIG_PROCESSOR_EXTERNAL_CONTROL */ +#endif /* CONFIG_XEN */ + +#endif diff -r 5d938fac27a2 -r f6fcc65413ae include/asm-i386/io_apic.h --- a/include/asm-i386/io_apic.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/asm-i386/io_apic.h Tue May 13 10:38:04 2008 +0900 @@ -12,7 +12,7 @@ #ifdef CONFIG_X86_IO_APIC -#ifdef CONFIG_PCI_MSI +#if defined(CONFIG_PCI_MSI) && !defined(CONFIG_XEN) static inline int use_pci_vector(void) {return 1;} static inline void disable_edge_ioapic_vector(unsigned int vector) { } static inline void mask_and_ack_level_ioapic_vector(unsigned int vector) { } diff -r 5d938fac27a2 -r f6fcc65413ae include/asm-x86_64/io_apic.h --- a/include/asm-x86_64/io_apic.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/asm-x86_64/io_apic.h Tue May 13 10:38:04 2008 +0900 @@ -12,7 +12,7 @@ #ifdef CONFIG_X86_IO_APIC -#ifdef CONFIG_PCI_MSI +#if defined(CONFIG_PCI_MSI) && !defined(CONFIG_XEN) static inline int use_pci_vector(void) {return 1;} static inline void disable_edge_ioapic_vector(unsigned int vector) { } static inline void mask_and_ack_level_ioapic_vector(unsigned int vector) { } diff -r 5d938fac27a2 -r f6fcc65413ae include/asm-x86_64/msi.h --- a/include/asm-x86_64/msi.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/asm-x86_64/msi.h Tue May 13 10:38:04 2008 +0900 @@ -7,14 +7,21 @@ #define ASM_MSI_H #include <asm/desc.h> +#ifndef CONFIG_XEN #include <asm/mach_apic.h> +#endif #include <asm/smp.h> +#ifndef CONFIG_XEN #define LAST_DEVICE_VECTOR (FIRST_SYSTEM_VECTOR - 1) +#else +#define LAST_DYNAMIC_VECTOR 0xdf +#define LAST_DEVICE_VECTOR (LAST_DYNAMIC_VECTOR) +#endif + #define MSI_TARGET_CPU_SHIFT 12 extern struct msi_ops msi_apic_ops; - static inline int msi_arch_init(void) { msi_register(&msi_apic_ops); diff -r 5d938fac27a2 -r f6fcc65413ae include/linux/pci.h --- a/include/linux/pci.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/linux/pci.h Tue May 13 10:38:04 2008 +0900 @@ -152,6 +152,9 @@ struct pci_dev { * directly, use the values stored here. They might be different! */ unsigned int irq; +#ifdef CONFIG_XEN + unsigned int irq_old; +#endif struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */ /* These fields are used by common fixups */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/evtchn.h --- a/include/xen/evtchn.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/evtchn.h Tue May 13 10:38:04 2008 +0900 @@ -136,4 +136,18 @@ void notify_remote_via_irq(int irq); void notify_remote_via_irq(int irq); int irq_to_evtchn_port(int irq); +#define PIRQ_SET_MAPPING 0x0 +#define PIRQ_CLEAR_MAPPING 0x1 +#define PIRQ_GET_MAPPING 0x3 +int pirq_mapstatus(int pirq, int action); +int set_pirq_hw_action(int pirq, int (*action)(int pirq, int action)); +int clear_pirq_hw_action(int pirq); + +#define PIRQ_STARTUP 1 +#define PIRQ_SHUTDOWN 2 +#define PIRQ_ENABLE 3 +#define PIRQ_DISABLE 4 +#define PIRQ_END 5 +#define PIRQ_ACK 6 + #endif /* __ASM_EVTCHN_H__ */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/arch-ia64.h --- a/include/xen/interface/arch-ia64.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/arch-ia64.h Tue May 13 10:38:04 2008 +0900 @@ -68,6 +68,10 @@ typedef unsigned long xen_pfn_t; /* WARNING: before changing this, check that shared_info fits on a page */ #define MAX_VIRT_CPUS 64 +/* IO ports location for PV. */ +#define IO_PORTS_PADDR 0x00000ffffc000000UL +#define IO_PORTS_SIZE 0x0000000004000000UL + #ifndef __ASSEMBLY__ typedef unsigned long xen_ulong_t; @@ -79,54 +83,6 @@ typedef unsigned long xen_ulong_t; #endif #define INVALID_MFN (~0UL) - -#define MEM_G (1UL << 30) -#define MEM_M (1UL << 20) -#define MEM_K (1UL << 10) - -/* Guest physical address of IO ports space. */ -#define IO_PORTS_PADDR 0x00000ffffc000000UL -#define IO_PORTS_SIZE 0x0000000004000000UL - -#define MMIO_START (3 * MEM_G) -#define MMIO_SIZE (512 * MEM_M) - -#define VGA_IO_START 0xA0000UL -#define VGA_IO_SIZE 0x20000 - -#define LEGACY_IO_START (MMIO_START + MMIO_SIZE) -#define LEGACY_IO_SIZE (64*MEM_M) - -#define IO_PAGE_START (LEGACY_IO_START + LEGACY_IO_SIZE) -#define IO_PAGE_SIZE XEN_PAGE_SIZE - -#define STORE_PAGE_START (IO_PAGE_START + IO_PAGE_SIZE) -#define STORE_PAGE_SIZE XEN_PAGE_SIZE - -#define BUFFER_IO_PAGE_START (STORE_PAGE_START + STORE_PAGE_SIZE) -#define BUFFER_IO_PAGE_SIZE XEN_PAGE_SIZE - -#define BUFFER_PIO_PAGE_START (BUFFER_IO_PAGE_START + BUFFER_IO_PAGE_SIZE) -#define BUFFER_PIO_PAGE_SIZE XEN_PAGE_SIZE - -#define IO_SAPIC_START 0xfec00000UL -#define IO_SAPIC_SIZE 0x100000 - -#define PIB_START 0xfee00000UL -#define PIB_SIZE 0x200000 - -#define GFW_START (4*MEM_G -16*MEM_M) -#define GFW_SIZE (16*MEM_M) - -/* Nvram belongs to GFW memory space */ -#define NVRAM_SIZE (MEM_K * 64) -#define NVRAM_START (GFW_START + 10 * MEM_M) - -#define NVRAM_VALID_SIG 0x4650494e45584948 // "HIXENIPF" -struct nvram_save_addr { - unsigned long addr; - unsigned long signature; -}; struct pt_fpreg { union { @@ -509,6 +465,9 @@ DEFINE_XEN_GUEST_HANDLE(vcpu_guest_conte /* Internal only: associated with PGC_allocated bit */ #define _ASSIGN_pgc_allocated 3 #define ASSIGN_pgc_allocated (1UL << _ASSIGN_pgc_allocated) +/* Page is an IO page. */ +#define _ASSIGN_io 4 +#define ASSIGN_io (1UL << _ASSIGN_io) /* This structure has the same layout of struct ia64_boot_param, defined in <asm/system.h>. It is redefined here to ease use. */ @@ -644,6 +603,10 @@ DEFINE_XEN_GUEST_HANDLE(pfarg_load_t); #endif /* __ASSEMBLY__ */ #endif /* XEN */ +#ifndef __ASSEMBLY__ +#include "arch-ia64/hvm/memmap.h" +#endif + #endif /* __HYPERVISOR_IF_IA64_H__ */ /* diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/arch-ia64/hvm/memmap.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/include/xen/interface/arch-ia64/hvm/memmap.h Tue May 13 10:38:04 2008 +0900 @@ -0,0 +1,88 @@ +/****************************************************************************** + * memmap.h + * + * Copyright (c) 2008 Tristan Gingold <tgingold AT free fr> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef __XEN_PUBLIC_HVM_MEMMAP_IA64_H__ +#define __XEN_PUBLIC_HVM_MEMMAP_IA64_H__ + +#define MEM_G (1UL << 30) +#define MEM_M (1UL << 20) +#define MEM_K (1UL << 10) + +/* Guest physical address of IO ports space. */ +#define MMIO_START (3 * MEM_G) +#define MMIO_SIZE (512 * MEM_M) + +#define VGA_IO_START 0xA0000UL +#define VGA_IO_SIZE 0x20000 + +#define LEGACY_IO_START (MMIO_START + MMIO_SIZE) +#define LEGACY_IO_SIZE (64 * MEM_M) + +#define IO_PAGE_START (LEGACY_IO_START + LEGACY_IO_SIZE) +#define IO_PAGE_SIZE XEN_PAGE_SIZE + +#define STORE_PAGE_START (IO_PAGE_START + IO_PAGE_SIZE) +#define STORE_PAGE_SIZE XEN_PAGE_SIZE + +#define BUFFER_IO_PAGE_START (STORE_PAGE_START + STORE_PAGE_SIZE) +#define BUFFER_IO_PAGE_SIZE XEN_PAGE_SIZE + +#define BUFFER_PIO_PAGE_START (BUFFER_IO_PAGE_START + BUFFER_IO_PAGE_SIZE) +#define BUFFER_PIO_PAGE_SIZE XEN_PAGE_SIZE + +#define IO_SAPIC_START 0xfec00000UL +#define IO_SAPIC_SIZE 0x100000 + +#define PIB_START 0xfee00000UL +#define PIB_SIZE 0x200000 + +#define GFW_START (4 * MEM_G - 16 * MEM_M) +#define GFW_SIZE (16 * MEM_M) + +/* domVTI */ +#define GPFN_FRAME_BUFFER 0x1 /* VGA framebuffer */ +#define GPFN_LOW_MMIO 0x2 /* Low MMIO range */ +#define GPFN_PIB 0x3 /* PIB base */ +#define GPFN_IOSAPIC 0x4 /* IOSAPIC base */ +#define GPFN_LEGACY_IO 0x5 /* Legacy I/O base */ +#define GPFN_HIGH_MMIO 0x6 /* High MMIO range */ + +/* Nvram belongs to GFW memory space */ +#define NVRAM_SIZE (MEM_K * 64) +#define NVRAM_START (GFW_START + 10 * MEM_M) + +#define NVRAM_VALID_SIG 0x4650494e45584948 /* "HIXENIPF" */ +struct nvram_save_addr { + unsigned long addr; + unsigned long signature; +}; + +#endif /* __XEN_PUBLIC_HVM_MEMMAP_IA64_H__ */ + +/* + * Local variables: + * mode: C + * c-set-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/arch-ia64/sioemu.h --- a/include/xen/interface/arch-ia64/sioemu.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/arch-ia64/sioemu.h Tue May 13 10:38:04 2008 +0900 @@ -22,6 +22,9 @@ #ifndef __XEN_PUBLIC_IA64_SIOEMU_H__ #define __XEN_PUBLIC_IA64_SIOEMU_H__ +/* SIOEMU specific hypercalls. + The numbers are the minor part of FW_HYPERCALL_SIOEMU. */ + /* Defines the callback entry point. r8=ip, r9=data. Must be called per-vcpu. */ #define SIOEMU_HYPERCALL_SET_CALLBACK 0x01 @@ -35,8 +38,52 @@ /* Get wallclock time. */ #define SIOEMU_HYPERCALL_GET_TIME 0x04 -/* Return from callback. r16=0. - Unmask vcpu events. */ -#define SIOEMU_HYPERPRIVOP_CALLBACK_RETURN 0x01 +/* Flush cache. */ +#define SIOEMU_HYPERCALL_FLUSH_CACHE 0x07 +/* Get freq base. */ +#define SIOEMU_HYPERCALL_FREQ_BASE 0x08 + +/* Return from callback. */ +#define SIOEMU_HYPERCALL_CALLBACK_RETURN 0x09 + +/* Deliver an interrupt. */ +#define SIOEMU_HYPERCALL_DELIVER_INT 0x0a + +/* SIOEMU callback reason. */ + +/* An event (from event channel) has to be delivered. */ +#define SIOEMU_CB_EVENT 0x00 + +/* Emulate an IO access. */ +#define SIOEMU_CB_IO_EMULATE 0x01 + +/* An IPI is sent to a dead vcpu. */ +#define SIOEMU_CB_WAKEUP_VCPU 0x02 + +/* A SAL hypercall is executed. */ +#define SIOEMU_CB_SAL_ASSIST 0x03 + +#ifndef __ASSEMBLY__ +struct sioemu_callback_info { + /* Saved registers. */ + unsigned long ip; + unsigned long psr; + unsigned long ifs; + unsigned long nats; + unsigned long r8; + unsigned long r9; + unsigned long r10; + unsigned long r11; + + /* Callback parameters. */ + unsigned long cause; + unsigned long arg0; + unsigned long arg1; + unsigned long arg2; + unsigned long arg3; + unsigned long _pad2[2]; + unsigned long r2; +}; +#endif /* __ASSEMBLY__ */ #endif /* __XEN_PUBLIC_IA64_SIOEMU_H__ */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/arch-x86/xen-x86_32.h --- a/include/xen/interface/arch-x86/xen-x86_32.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/arch-x86/xen-x86_32.h Tue May 13 10:38:04 2008 +0900 @@ -74,6 +74,7 @@ #define MACH2PHYS_VIRT_END_PAE \ mk_unsigned_long(__MACH2PHYS_VIRT_END_PAE) +/* Non-PAE bounds are obsolete. */ #define __HYPERVISOR_VIRT_START_NONPAE 0xFC000000 #define __MACH2PHYS_VIRT_START_NONPAE 0xFC000000 #define __MACH2PHYS_VIRT_END_NONPAE 0xFC400000 @@ -84,15 +85,9 @@ #define MACH2PHYS_VIRT_END_NONPAE \ mk_unsigned_long(__MACH2PHYS_VIRT_END_NONPAE) -#ifdef CONFIG_X86_PAE #define __HYPERVISOR_VIRT_START __HYPERVISOR_VIRT_START_PAE #define __MACH2PHYS_VIRT_START __MACH2PHYS_VIRT_START_PAE #define __MACH2PHYS_VIRT_END __MACH2PHYS_VIRT_END_PAE -#else -#define __HYPERVISOR_VIRT_START __HYPERVISOR_VIRT_START_NONPAE -#define __MACH2PHYS_VIRT_START __MACH2PHYS_VIRT_START_NONPAE -#define __MACH2PHYS_VIRT_END __MACH2PHYS_VIRT_END_NONPAE -#endif #ifndef HYPERVISOR_VIRT_START #define HYPERVISOR_VIRT_START mk_unsigned_long(__HYPERVISOR_VIRT_START) diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/domctl.h --- a/include/xen/interface/domctl.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/domctl.h Tue May 13 10:38:04 2008 +0900 @@ -454,7 +454,8 @@ DEFINE_XEN_GUEST_HANDLE(xen_domctl_assig #define XEN_DOMCTL_unbind_pt_irq 48 typedef enum pt_irq_type_e { PT_IRQ_TYPE_PCI, - PT_IRQ_TYPE_ISA + PT_IRQ_TYPE_ISA, + PT_IRQ_TYPE_MSI, } pt_irq_type_t; struct xen_domctl_bind_pt_irq { uint32_t machine_irq; @@ -470,6 +471,10 @@ struct xen_domctl_bind_pt_irq { uint8_t device; uint8_t intx; } pci; + struct { + uint8_t gvec; + uint32_t gflags; + } msi; } u; }; typedef struct xen_domctl_bind_pt_irq xen_domctl_bind_pt_irq_t; @@ -571,6 +576,19 @@ typedef struct xen_domctl_set_target xen typedef struct xen_domctl_set_target xen_domctl_set_target_t; DEFINE_XEN_GUEST_HANDLE(xen_domctl_set_target_t); +#if defined(__i386__) || defined(__x86_64__) +# define XEN_CPUID_INPUT_UNUSED 0xFFFFFFFF +# define XEN_DOMCTL_set_cpuid 49 +struct xen_domctl_cpuid { + unsigned int input[2]; + unsigned int eax; + unsigned int ebx; + unsigned int ecx; + unsigned int edx; +}; +typedef struct xen_domctl_cpuid xen_domctl_cpuid_t; +DEFINE_XEN_GUEST_HANDLE(xen_domctl_cpuid_t); +#endif struct xen_domctl { uint32_t cmd; @@ -609,6 +627,9 @@ struct xen_domctl { struct xen_domctl_ext_vcpucontext ext_vcpucontext; struct xen_domctl_set_opt_feature set_opt_feature; struct xen_domctl_set_target set_target; +#if defined(__i386__) || defined(__x86_64__) + struct xen_domctl_cpuid cpuid; +#endif uint8_t pad[128]; } u; }; diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/hvm/hvm_op.h --- a/include/xen/interface/hvm/hvm_op.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/hvm/hvm_op.h Tue May 13 10:38:04 2008 +0900 @@ -73,4 +73,20 @@ DEFINE_XEN_GUEST_HANDLE(xen_hvm_set_pci_ /* Flushes all VCPU TLBs: @arg must be NULL. */ #define HVMOP_flush_tlbs 5 +/* Track dirty VRAM. */ +#define HVMOP_track_dirty_vram 6 +struct xen_hvm_track_dirty_vram { + /* Domain to be tracked. */ + domid_t domid; + /* First pfn to track. */ + uint64_aligned_t first_pfn; + /* Number of pages to track. */ + uint64_aligned_t nr; + /* OUT variable. */ + /* Dirty bitmap buffer. */ + XEN_GUEST_HANDLE_64(uint8) dirty_bitmap; +}; +typedef struct xen_hvm_track_dirty_vram xen_hvm_track_dirty_vram_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_track_dirty_vram_t); + #endif /* __XEN_PUBLIC_HVM_HVM_OP_H__ */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/hvm/params.h --- a/include/xen/interface/hvm/params.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/hvm/params.h Tue May 13 10:38:04 2008 +0900 @@ -84,6 +84,12 @@ /* Boolean: Enable virtual HPET (high-precision event timer)? (x86-only) */ #define HVM_PARAM_HPET_ENABLED 11 -#define HVM_NR_PARAMS 12 +/* Identity-map page directory used by Intel EPT when CR0.PG=0. */ +#define HVM_PARAM_IDENT_PT 12 + +/* Device Model domain, defaults to 0. */ +#define HVM_PARAM_DM_DOMAIN 13 + +#define HVM_NR_PARAMS 14 #endif /* __XEN_PUBLIC_HVM_PARAMS_H__ */ diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/io/protocols.h --- a/include/xen/interface/io/protocols.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/io/protocols.h Tue May 13 10:38:04 2008 +0900 @@ -26,7 +26,6 @@ #define XEN_IO_PROTO_ABI_X86_32 "x86_32-abi" #define XEN_IO_PROTO_ABI_X86_64 "x86_64-abi" #define XEN_IO_PROTO_ABI_IA64 "ia64-abi" -#define XEN_IO_PROTO_ABI_POWERPC64 "powerpc64-abi" #if defined(__i386__) # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_32 @@ -34,8 +33,6 @@ # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_X86_64 #elif defined(__ia64__) # define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_IA64 -#elif defined(__powerpc64__) -# define XEN_IO_PROTO_ABI_NATIVE XEN_IO_PROTO_ABI_POWERPC64 #else # error arch fixup needed here #endif diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/io/xs_wire.h --- a/include/xen/interface/io/xs_wire.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/io/xs_wire.h Tue May 13 10:38:04 2008 +0900 @@ -61,6 +61,7 @@ struct xsd_errors const char *errstring; }; #define XSD_ERROR(x) { x, #x } +/* LINTED: static unused */ static struct xsd_errors xsd_errors[] #if defined(__GNUC__) __attribute__((unused)) diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/libelf.h --- a/include/xen/interface/libelf.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/libelf.h Tue May 13 10:38:04 2008 +0900 @@ -23,10 +23,8 @@ #ifndef __XC_LIBELF__ #define __XC_LIBELF__ 1 -#if defined(__i386__) || defined(__x86_64) || defined(__ia64__) +#if defined(__i386__) || defined(__x86_64__) || defined(__ia64__) #define XEN_ELF_LITTLE_ENDIAN -#elif defined(__powerpc__) -#define XEN_ELF_BIG_ENDIAN #else #error define architectural endianness #endif diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/physdev.h --- a/include/xen/interface/physdev.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/physdev.h Tue May 13 10:38:04 2008 +0900 @@ -121,6 +121,38 @@ struct physdev_irq { }; typedef struct physdev_irq physdev_irq_t; DEFINE_XEN_GUEST_HANDLE(physdev_irq_t); + +#define MAP_PIRQ_TYPE_MSI 0x0 +#define MAP_PIRQ_TYPE_GSI 0x1 +#define MAP_PIRQ_TYPE_UNKNOWN 0x2 + +#define PHYSDEVOP_map_pirq 13 +struct physdev_map_pirq { + domid_t domid; + /* IN */ + int type; + /* IN */ + int index; + /* IN or OUT */ + int pirq; + /* IN */ + struct { + int bus, devfn, entry_nr; + int msi; /* 0 - MSIX 1 - MSI */ + } msi_info; +}; +typedef struct physdev_map_pirq physdev_map_pirq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_map_pirq_t); + +#define PHYSDEVOP_unmap_pirq 14 +struct physdev_unmap_pirq { + domid_t domid; + /* IN */ + int pirq; +}; + +typedef struct physdev_unmap_pirq physdev_unmap_pirq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_unmap_pirq_t); /* * Argument to physdev_op_compat() hypercall. Superceded by new physdev_op() diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/platform.h --- a/include/xen/interface/platform.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/platform.h Tue May 13 10:38:04 2008 +0900 @@ -199,6 +199,70 @@ typedef struct xenpf_getidletime xenpf_g typedef struct xenpf_getidletime xenpf_getidletime_t; DEFINE_XEN_GUEST_HANDLE(xenpf_getidletime_t); +#define XENPF_set_processor_pminfo 54 + +/* ability bits */ +#define XEN_PROCESSOR_PM_CX 1 +#define XEN_PROCESSOR_PM_PX 2 +#define XEN_PROCESSOR_PM_TX 4 + +/* cmd type */ +#define XEN_PM_CX 0 +#define XEN_PM_PX 1 +#define XEN_PM_TX 2 + +struct xen_power_register { + uint32_t space_id; + uint32_t bit_width; + uint32_t bit_offset; + uint32_t access_size; + uint64_t address; +}; + +struct xen_processor_csd { + uint32_t domain; /* domain number of one dependent group */ + uint32_t coord_type; /* coordination type */ + uint32_t num; /* number of processors in same domain */ +}; +typedef struct xen_processor_csd xen_processor_csd_t; +DEFINE_XEN_GUEST_HANDLE(xen_processor_csd_t); + +struct xen_processor_cx { + struct xen_power_register reg; /* GAS for Cx trigger register */ + uint8_t type; /* cstate value, c0: 0, c1: 1, ... */ + uint32_t latency; /* worst latency (ms) to enter/exit this cstate */ + uint32_t power; /* average power consumption(mW) */ + uint32_t dpcnt; /* number of dependency entries */ + XEN_GUEST_HANDLE(xen_processor_csd_t) dp; /* NULL if no dependency */ +}; +typedef struct xen_processor_cx xen_processor_cx_t; +DEFINE_XEN_GUEST_HANDLE(xen_processor_cx_t); + +struct xen_processor_flags { + uint32_t bm_control:1; + uint32_t bm_check:1; + uint32_t has_cst:1; + uint32_t power_setup_done:1; + uint32_t bm_rld_set:1; +}; + +struct xen_processor_power { + uint32_t count; /* number of C state entries in array below */ + struct xen_processor_flags flags; /* global flags of this processor */ + XEN_GUEST_HANDLE(xen_processor_cx_t) states; /* supported c states */ +}; + +struct xenpf_set_processor_pminfo { + /* IN variables */ + uint32_t id; /* ACPI CPU ID */ + uint32_t type; /* {XEN_PM_CX, ...} */ + union { + struct xen_processor_power power;/* Cx: _CST/_CSD */ + }; +}; +typedef struct xenpf_set_processor_pminfo xenpf_set_processor_pminfo_t; +DEFINE_XEN_GUEST_HANDLE(xenpf_set_processor_pminfo_t); + struct xen_platform_op { uint32_t cmd; uint32_t interface_version; /* XENPF_INTERFACE_VERSION */ @@ -213,6 +277,7 @@ struct xen_platform_op { struct xenpf_enter_acpi_sleep enter_acpi_sleep; struct xenpf_change_freq change_freq; struct xenpf_getidletime getidletime; + struct xenpf_set_processor_pminfo set_pminfo; uint8_t pad[128]; } u; }; diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/sysctl.h --- a/include/xen/interface/sysctl.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/sysctl.h Tue May 13 10:38:04 2008 +0900 @@ -84,8 +84,13 @@ DEFINE_XEN_GUEST_HANDLE(xen_sysctl_tbuf_ * Get physical information about the host machine */ #define XEN_SYSCTL_physinfo 3 + /* (x86) The platform supports HVM guests. */ +#define _XEN_SYSCTL_PHYSCAP_hvm 0 +#define XEN_SYSCTL_PHYSCAP_hvm (1u<<_XEN_SYSCTL_PHYSCAP_hvm) + /* (x86) The platform supports HVM-guest direct access to I/O devices. */ +#define _XEN_SYSCTL_PHYSCAP_hvm_directio 1 +#define XEN_SYSCTL_PHYSCAP_hvm_directio (1u<<_XEN_SYSCTL_PHYSCAP_hvm_directio) struct xen_sysctl_physinfo { - /* IN variables. */ uint32_t threads_per_core; uint32_t cores_per_socket; uint32_t nr_cpus; @@ -96,7 +101,6 @@ struct xen_sysctl_physinfo { uint64_aligned_t scrub_pages; uint32_t hw_cap[8]; - /* IN/OUT variables. */ /* * IN: maximum addressable entry in the caller-provided cpu_to_node array. * OUT: largest cpu identifier in the system. @@ -112,6 +116,9 @@ struct xen_sysctl_physinfo { * elements of the array will not be written by the sysctl. */ XEN_GUEST_HANDLE_64(uint32) cpu_to_node; + + /* XEN_SYSCTL_PHYSCAP_??? */ + uint32_t capabilities; }; typedef struct xen_sysctl_physinfo xen_sysctl_physinfo_t; DEFINE_XEN_GUEST_HANDLE(xen_sysctl_physinfo_t); diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/xen.h --- a/include/xen/interface/xen.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/xen.h Tue May 13 10:38:04 2008 +0900 @@ -33,8 +33,6 @@ #include "arch-x86/xen.h" #elif defined(__ia64__) #include "arch-ia64.h" -#elif defined(__powerpc__) -#include "arch-powerpc.h" #else #error "Unsupported architecture" #endif diff -r 5d938fac27a2 -r f6fcc65413ae include/xen/interface/xsm/acm.h --- a/include/xen/interface/xsm/acm.h Thu Apr 24 14:08:54 2008 -0600 +++ b/include/xen/interface/xsm/acm.h Tue May 13 10:38:04 2008 +0900 @@ -91,7 +91,7 @@ * whenever the interpretation of the related * policy's data structure changes */ -#define ACM_POLICY_VERSION 3 +#define ACM_POLICY_VERSION 4 #define ACM_CHWALL_VERSION 1 #define ACM_STE_VERSION 1 @@ -102,6 +102,7 @@ typedef uint32_t ssidref_t; #define ACMHOOK_none 0 #define ACMHOOK_sharing 1 #define ACMHOOK_authorization 2 +#define ACMHOOK_conflictset 3 /* -------security policy relevant type definitions-------- */ @@ -130,6 +131,10 @@ typedef uint16_t domaintype_t; /* high-16 = version, low-16 = check magic */ #define ACM_MAGIC 0x0001debc +/* size of the SHA1 hash identifying the XML policy from which the + binary policy was created */ +#define ACM_SHA1_HASH_SIZE 20 + /* each offset in bytes from start of the struct they * are part of */ @@ -159,6 +164,7 @@ struct acm_policy_buffer { uint32_t secondary_policy_code; uint32_t secondary_buffer_offset; struct acm_policy_version xml_pol_version; /* add in V3 */ + uint8_t xml_policy_hash[ACM_SHA1_HASH_SIZE]; /* added in V4 */ }; _______________________________________________ Xen-changelog mailing list Xen-changelog@xxxxxxxxxxxxxxxxxxx http://lists.xensource.com/xen-changelog

©2013 Xen Project, A Linux Foundation Collaborative Project. All Rights Reserved.
Linux Foundation is a registered trademark of The Linux Foundation.
Xen Project is a trademark of The Linux Foundation.