From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Jiang, Yunhong" Subject: RE: Re: [PATCH] Add hypercall to expose physical CPU in xen hypervisor Date: Tue, 10 Nov 2009 20:16:42 +0800 Message-ID: References: <4AF891B6.8010003@goop.org> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="_002_E2263E4A5B2284449EEBD0AAB751098418E5238629PDSMSX501ccrc_" Return-path: In-Reply-To: <4AF891B6.8010003@goop.org> Content-Language: en-US List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: Jeremy Fitzhardinge , Keir Fraser Cc: "xen-devel@lists.xensource.com" List-Id: xen-devel@lists.xenproject.org --_002_E2263E4A5B2284449EEBD0AAB751098418E5238629PDSMSX501ccrc_ Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Jeremy, here is the update patch according to the new interface, please hav= e a look. One changes in this patch is, the apic_id/acpi_id is exposed in sysfs also. Thanks yunhong Jiang Export host physical CPU information to dom0 From: Jiang, Yunhong This patch expose host's physical CPU information to dom0 in sysfs, so that= dom0's management tools can control the physical CPU if needed. It also provides interface in sysfs to logical online/offline a physical CP= U. Notice: The information in dom0 is synced with xen hypervisor asynchronousl= y. Signed-off-by: Jiang, Yunhong --- drivers/xen/Makefile | 2 drivers/xen/pcpu.c | 462 ++++++++++++++++++++++++++++++++++= ++++ include/xen/interface/platform.h | 48 ++++ include/xen/interface/xen.h | 1 include/xen/pcpu.h | 30 ++ 5 files changed, 542 insertions(+), 1 deletions(-) create mode 100644 drivers/xen/pcpu.c create mode 100644 include/xen/pcpu.h diff --git a/drivers/xen/Makefile b/drivers/xen/Makefile index cddfffb..5d01856 100644 --- a/drivers/xen/Makefile +++ b/drivers/xen/Makefile @@ -1,4 +1,4 @@ -obj-y +=3D grant-table.o features.o events.o manage.o biomerge.o +obj-y +=3D grant-table.o features.o events.o manage.o biomerge.o pcpu.o obj-y +=3D xenbus/ live_maps.o nostackp :=3D $(call cc-option, -fno-stack-protector) diff --git a/drivers/xen/pcpu.c b/drivers/xen/pcpu.c new file mode 100644 index 0000000..fc2f70f --- /dev/null +++ b/drivers/xen/pcpu.c @@ -0,0 +1,462 @@ +/* + * pcpu.c - management physical cpu in dom0 environment + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static struct sysdev_class xen_pcpu_sysdev_class =3D { + .name =3D "xen_pcpu", +}; + +static DEFINE_SPINLOCK(xen_pcpu_spinlock); +static RAW_NOTIFIER_HEAD(xen_pcpu_chain); + +/* No need for irq disable since hotplug notify is in workqueue context */ +#define get_pcpu_lock() spin_lock(&xen_pcpu_spinlock); +#define put_pcpu_lock() spin_unlock(&xen_pcpu_spinlock); + +struct xen_pcpus { + struct list_head list; + int possible; + int present; +}; +static struct xen_pcpus xen_pcpus; + +int register_xen_pcpu_notifier(struct notifier_block *nb) +{ + int ret; + + /* All refer to the chain notifier is protected by the pcpu_lock */ + get_pcpu_lock(); + ret =3D raw_notifier_chain_register(&xen_pcpu_chain, nb); + put_pcpu_lock(); + return ret; +} +EXPORT_SYMBOL_GPL(register_xen_pcpu_notifier); + +void unregister_xen_pcpu_notifier(struct notifier_block *nb) +{ + get_pcpu_lock(); + raw_notifier_chain_unregister(&xen_pcpu_chain, nb); + put_pcpu_lock(); +} +EXPORT_SYMBOL_GPL(unregister_xen_pcpu_notifier); + +static int xen_pcpu_down(uint32_t xen_id) +{ + int ret; + xen_platform_op_t op =3D { + .cmd =3D XENPF_resource_hotplug, + .interface_version =3D XENPF_INTERFACE_VERSION, + .u.resource.u.cpu_ol.cpuid =3D xen_id, + }; + + op.u.resource.sub_cmd =3D XEN_CPU_offline; + ret =3D HYPERVISOR_dom0_op(&op); + return ret; +} + +static int xen_pcpu_up(uint32_t xen_id) +{ + int ret; + xen_platform_op_t op =3D { + .cmd =3D XENPF_resource_hotplug, + .interface_version =3D XENPF_INTERFACE_VERSION, + .u.resource.u.cpu_ol.cpuid =3D xen_id, + }; + + op.u.resource.sub_cmd =3D XEN_CPU_online; + ret =3D HYPERVISOR_dom0_op(&op); + return ret; +} + +static ssize_t show_online(struct sys_device *dev, + struct sysdev_attribute *attr, + char *buf) +{ + struct pcpu *cpu =3D container_of(dev, struct pcpu, sysdev); + + return sprintf(buf, "%u\n", !!(cpu->flags & XEN_PCPU_FLAGS_ONLINE))= ; +} + +static ssize_t __ref store_online(struct sys_device *dev, + struct sysdev_attribute *attr, + const char *buf, size_t count) +{ + struct pcpu *cpu =3D container_of(dev, struct pcpu, sysdev); + ssize_t ret; + + switch (buf[0]) { + case '0': + ret =3D xen_pcpu_down(cpu->xen_id); + break; + case '1': + ret =3D xen_pcpu_up(cpu->xen_id); + break; + default: + ret =3D -EINVAL; + } + + if (ret >=3D 0) + ret =3D count; + return ret; +} + +static SYSDEV_ATTR(online, 0644, show_online, store_online); + +static ssize_t show_apicid(struct sys_device *dev, + struct sysdev_attribute *attr, + char *buf) +{ + struct pcpu *cpu =3D container_of(dev, struct pcpu, sysdev); + + return sprintf(buf, "%u\n", cpu->apic_id); +} + +static ssize_t show_acpiid(struct sys_device *dev, + struct sysdev_attribute *attr, + char *buf) +{ + struct pcpu *cpu =3D container_of(dev, struct pcpu, sysdev); + + return sprintf(buf, "%u\n", cpu->acpi_id); +} +static SYSDEV_ATTR(apic_id, 0444, show_apicid, NULL); +static SYSDEV_ATTR(acpi_id, 0444, show_acpiid, NULL); + +static int xen_pcpu_free(struct pcpu *pcpu) +{ + if (!pcpu) + return 0; + + sysdev_remove_file(&pcpu->sysdev, &attr_online); + sysdev_unregister(&pcpu->sysdev); + list_del(&pcpu->pcpu_list); + kfree(pcpu); + + return 0; +} + +static struct pcpu *xen_pcpu_add(struct xen_physical_cpuinfo *info) +{ + struct pcpu *cpu; + int error; + + printk(KERN_DEBUG "xen_pcpu_add: xen_id %x apic_id %x acpi_id %x\n= ", + info->xen_cpuid, info->apic_id, info->acpi_id); + + if (info->flags & XEN_PCPU_FLAGS_INVALID) + return NULL; + + cpu =3D kzalloc(sizeof(struct pcpu), GFP_KERNEL); + if (!cpu) + return NULL; + + INIT_LIST_HEAD(&cpu->pcpu_list); + cpu->xen_id =3D info->xen_cpuid; + cpu->apic_id =3D info->apic_id; + cpu->acpi_id =3D info->acpi_id; + cpu->flags =3D info->flags; + + cpu->sysdev.cls =3D &xen_pcpu_sysdev_class; + cpu->sysdev.id =3D info->xen_cpuid; + + error =3D sysdev_register(&cpu->sysdev); + if (error) { + printk(KERN_WARNING "xen_pcpu_add: Failed to register pcpu\= n"); + kfree(cpu); + return NULL; + } + sysdev_create_file(&cpu->sysdev, &attr_online); + sysdev_create_file(&cpu->sysdev, &attr_apic_id); + sysdev_create_file(&cpu->sysdev, &attr_acpi_id); + list_add_tail(&cpu->pcpu_list, &xen_pcpus.list); + + return cpu; +} + +static struct xen_physical_cpuinfo *xen_pcpu_info_fetch(int *num, + int *possible) +{ + int cpu_num, ret =3D 0, i; + struct xen_physical_cpuinfo *info; + xen_platform_op_t op =3D { + .cmd =3D XENPF_get_cpuinfo, + .interface_version =3D XENPF_INTERFACE_VERSION, + .u.pcpu_info.info_num =3D 0, + }; + + set_xen_guest_handle(op.u.pcpu_info.info, NULL); + + ret =3D HYPERVISOR_dom0_op(&op); + if (ret) + return NULL; + + cpu_num =3D op.u.pcpu_info.max_present; + + info =3D kzalloc(cpu_num * sizeof(struct xen_physical_cpuinfo), + GFP_KERNEL); + if (!info) + return NULL; + + op.u.pcpu_info.info_num =3D cpu_num; + for (i =3D 0; i < cpu_num; i++) + info[i].xen_cpuid =3D i; + + set_xen_guest_handle(op.u.pcpu_info.info, info); + + ret =3D HYPERVISOR_dom0_op(&op); + if (ret) { + kfree(info); + printk(KERN_WARNING "xen_pcpu_info_fetch: Error fetch pcpu = info\n"); + return NULL; + } + + /* present cpus is changed, that mean hotplug may happen */ + if (cpu_num !=3D op.u.pcpu_info.max_present) + printk(KERN_WARNING "Max present cpus changed when fetch cp= u info\n"); + + if (possible) + *possible =3D op.u.pcpu_info.max_possible; + if (num) + *num =3D cpu_num; + + return info; +} + +static inline int same_pcpu(struct xen_physical_cpuinfo *info, + struct pcpu *pcpu) +{ + return (pcpu->apic_id =3D=3D info->apic_id) && + (pcpu->xen_id =3D=3D info->xen_cpuid); +} + +/* + * Return 1 if online status changed + */ +static int xen_pcpu_online_check(struct xen_physical_cpuinfo *info, + struct pcpu *pcpu) +{ + int result =3D 0; + + if (!same_pcpu(info, pcpu)) + return 0; + + if (xen_pcpu_online(info->flags) && !xen_pcpu_online(pcpu->flags)) = { + /* the pcpu is onlined */ + pcpu->flags |=3D XEN_PCPU_FLAGS_ONLINE; + kobject_uevent(&pcpu->sysdev.kobj, KOBJ_ONLINE); + raw_notifier_call_chain(&xen_pcpu_chain, + XEN_PCPU_ONLINE, (void *)(long)pcpu->xen_id); + result =3D 1; + } else if (!xen_pcpu_online(info->flags) && + xen_pcpu_online(pcpu->flags)) { + /* The pcpu is offlined now */ + pcpu->flags &=3D ~XEN_PCPU_FLAGS_ONLINE; + kobject_uevent(&pcpu->sysdev.kobj, KOBJ_OFFLINE); + raw_notifier_call_chain(&xen_pcpu_chain, + XEN_PCPU_OFFLINE, (void *)(long)pcpu->xen_id); + result =3D 1; + } + + return result; +} + +/* + * Sync dom0's pcpu information with xen hypervisor's + */ +static int xen_pcpu_sync(void) +{ + struct xen_physical_cpuinfo *info; + int cpu_num, i, ret =3D -1, possible, present =3D 0; + struct list_head *elem, *tmp; + struct pcpu *pcpu; + + info =3D xen_pcpu_info_fetch(&cpu_num, &possible); + if (!info) + return -1; + + get_pcpu_lock(); + + xen_pcpus.possible =3D possible; + + /* Check for current cpu list */ + for (i =3D 0; i < cpu_num; i++) { + int found =3D 0; + + if (info[i].flags & XEN_PCPU_FLAGS_INVALID) + continue; + + present++; + list_for_each_entry(pcpu, &xen_pcpus.list, pcpu_list) { + if (same_pcpu(&info[i], pcpu)) { + xen_pcpu_online_check(&info[i], pcpu); + pcpu->status |=3D PCPU_LOOPED; + found =3D 1; + } + } + if (!found) { + struct pcpu *cpu; + + /* + * Normally a physical cpu is onlined in two step + * Firstly, the physical CPU is hot-added, secondly + * it will be take online through sysfs writing + * So a hot-added CPU should be offlined initially + */ + if (xen_pcpu_online(info[i].flags)) + printk(KERN_WARNING "xen_pcpu_sync:" + "A hotadd cpu is onlined also\n"); + + cpu =3D xen_pcpu_add(&info[i]); + if (cpu =3D=3D NULL) + goto failed; + raw_notifier_call_chain(&xen_pcpu_chain, + XEN_PCPU_ADD, + (void *)(long)cpu->xen_id); + cpu->status |=3D PCPU_LOOPED; + } + } + + list_for_each_safe(elem, tmp, &xen_pcpus.list) { + pcpu =3D list_entry(elem, struct pcpu, pcpu_list); + if (pcpu->status & PCPU_LOOPED) + pcpu->status &=3D ~PCPU_LOOPED; + else { + /* The pcpu does not exist any more, remove it */ + raw_notifier_call_chain(&xen_pcpu_chain, + XEN_PCPU_REMOVE, + (void *)(long)pcpu->xen_id); + xen_pcpu_free(pcpu); + } + } + + xen_pcpus.present =3D present; + ret =3D 0; +failed: + put_pcpu_lock(); + kfree(info); + return ret; +} + +static int __init xen_pcpu_info_init(void) +{ + int possible, cpu_num, i; + struct xen_physical_cpuinfo *info =3D NULL; + struct list_head *elem, *tmp; + struct pcpu *pcpu; + + info =3D xen_pcpu_info_fetch(&cpu_num, &possible); + if (!info) { + printk(KERN_WARNING + "xen_pcpu_info_init: Failed to fetch pcpu_info\n"); + return -1; + } + + get_pcpu_lock(); + + INIT_LIST_HEAD(&xen_pcpus.list); + xen_pcpus.possible =3D possible; + xen_pcpus.present =3D 0; + + for (i =3D 0; i < cpu_num; i++) { + if (info[i].flags & XEN_PCPU_FLAGS_INVALID) + continue; + pcpu =3D xen_pcpu_add(&info[i]); + if (!pcpu) + goto failed; + xen_pcpus.present++; + } + + put_pcpu_lock(); + kfree(info); + + return 0; +failed: + list_for_each_safe(elem, tmp, &xen_pcpus.list) { + pcpu =3D list_entry(elem, struct pcpu, pcpu_list); + xen_pcpu_free(pcpu); + } + xen_pcpus.possible =3D xen_pcpus.present =3D 0; + INIT_LIST_HEAD(&xen_pcpus.list); + put_pcpu_lock(); + + kfree(info); + return -1; +} + +static void xen_pcpu_dpc(struct work_struct *work) +{ + if (xen_pcpu_sync() < 0) + printk(KERN_WARNING + "xen_pcpu_dpc: Failed to sync pcpu information\n"); +} +static DECLARE_WORK(xen_pcpu_work, xen_pcpu_dpc); + +/* + * type: 0 add, 1 remove + */ +int xen_pcpu_hotplug(int type, uint32_t apic_id) +{ + struct pcpu *pcpu; + int found =3D 0; + + xen_pcpu_sync(); + get_pcpu_lock(); + list_for_each_entry(pcpu, &xen_pcpus.list, pcpu_list) + { + if (pcpu->apic_id =3D=3D apic_id) { + found =3D 1; + break; + } + } + put_pcpu_lock(); + + if (!found && (type =3D=3D HOTPLUG_TYPE_ADD)) + printk(KERN_WARNING "The cpu is not added into Xen HV?\n"); + + if (found && (type =3D=3D HOTPLUG_TYPE_REMOVE)) + printk(KERN_WARNING "The cpu still exits in Xen HV?\n"); + return 0; +} +EXPORT_SYMBOL(xen_pcpu_hotplug); + +static irqreturn_t xen_pcpu_interrupt(int irq, void *dev_id) +{ + schedule_work(&xen_pcpu_work); + return IRQ_HANDLED; +} + +static int __init xen_pcpu_init(void) +{ + int err; + + if (!xen_initial_domain()) + return 0; + + err =3D sysdev_class_register(&xen_pcpu_sysdev_class); + if (err) { + printk(KERN_WARNING + "xen_pcpu_init: register xen_pcpu sysdev Failed!\n"= ); + return err; + } + + err =3D xen_pcpu_info_init(); + if (!err) + err =3D bind_virq_to_irqhandler(VIRQ_PCPU_STATE, + 0, xen_pcpu_interrupt, 0, "pcpu", NULL); + if (err < 0) + printk(KERN_WARNING "xen_pcpu_init: " + "Failed to bind pcpu_state virq\n" + "You will lost latest information! \n"); + return err; +} + +subsys_initcall(xen_pcpu_init); diff --git a/include/xen/interface/platform.h b/include/xen/interface/platf= orm.h index 6783fce..a9cf4e2 100644 --- a/include/xen/interface/platform.h +++ b/include/xen/interface/platform.h @@ -312,6 +312,52 @@ struct xenpf_set_processor_pminfo { typedef struct xenpf_set_processor_pminfo xenpf_set_processor_pminfo_t; DEFINE_GUEST_HANDLE_STRUCT(xenpf_set_processor_pminfo); +#define XENPF_get_cpuinfo 55 +struct xen_physical_cpuinfo { + /* IN */ + uint32_t xen_cpuid; + /* OUT */ + uint32_t apic_id; + uint32_t acpi_id; +#define XEN_PCPU_FLAGS_ONLINE 1 + /* Correponding xen_cpuid is not present*/ +#define XEN_PCPU_FLAGS_INVALID 2 + uint32_t flags; + uint8_t pad[128]; +}; +typedef struct xen_physical_cpuinfo xen_physical_cpuinfo_t; +DEFINE_GUEST_HANDLE_STRUCT(xen_physical_cpuinfo); + +struct xenpf_pcpu_info { + /* OUT */ + /* The maxium cpu_id that is present */ + uint32_t max_present; + /* The maxium possible cpus */ + uint32_t max_possible; + + /* IN */ + uint32_t info_num; + GUEST_HANDLE(xen_physical_cpuinfo) info; +}; +typedef struct xenpf_pcpu_info xenpf_pcpu_info_t; +DEFINE_GUEST_HANDLE_STRUCT(xenpf_pcpu_info); + +struct xenpf_cpu_ol { + uint32_t cpuid; +}; + +#define XENPF_resource_hotplug 56 +struct xenpf_resource_hotplug { + uint32_t sub_cmd; +#define XEN_CPU_online 1 +#define XEN_CPU_offline 2 + union { + struct xenpf_cpu_ol cpu_ol; + uint8_t pad[64]; + } u; +}; + + struct xen_platform_op { uint32_t cmd; uint32_t interface_version; /* XENPF_INTERFACE_VERSION */ @@ -327,6 +373,8 @@ struct xen_platform_op { struct xenpf_change_freq change_freq; struct xenpf_getidletime getidletime; struct xenpf_set_processor_pminfo set_pminfo; + struct xenpf_pcpu_info pcpu_info; + struct xenpf_resource_hotplug resource; uint8_t pad[128]; } u; }; diff --git a/include/xen/interface/xen.h b/include/xen/interface/xen.h index 812ffd5..9ffaee0 100644 --- a/include/xen/interface/xen.h +++ b/include/xen/interface/xen.h @@ -79,6 +79,7 @@ #define VIRQ_CONSOLE 2 /* (DOM0) Bytes received on emergency console. = */ #define VIRQ_DOM_EXC 3 /* (DOM0) Exceptional event for some domain. = */ #define VIRQ_DEBUGGER 6 /* (DOM0) A domain has paused for debugging. = */ +#define VIRQ_PCPU_STATE 9 /* (DOM0) PCPU state changed = */ /* Architecture-specific VIRQ definitions. */ #define VIRQ_ARCH_0 16 diff --git a/include/xen/pcpu.h b/include/xen/pcpu.h new file mode 100644 index 0000000..32fcb0d --- /dev/null +++ b/include/xen/pcpu.h @@ -0,0 +1,30 @@ +#ifndef _XEN_PCPU_H +#define _XEN_PCPU_H + +#include +extern int xen_pcpu_hotplug(int type, uint32_t apic_id); +#define XEN_PCPU_ONLINE 0x01 +#define XEN_PCPU_OFFLINE 0x02 +#define XEN_PCPU_ADD 0x04 +#define XEN_PCPU_REMOVE 0x08 + +struct pcpu { + struct list_head pcpu_list; + struct sys_device sysdev; + uint32_t xen_id; + uint32_t apic_id; + uint32_t acpi_id; + uint32_t flags; +#define PCPU_LOOPED 0x10000000 + uint32_t status; +}; + +static inline int xen_pcpu_online(uint32_t flags) +{ + return !!(flags & XEN_PCPU_FLAGS_ONLINE); +} + +extern int register_xen_pcpu_notifier(struct notifier_block *nb); + +extern void unregister_xen_pcpu_notifier(struct notifier_block *nb); +#endif xen-devel-bounces@lists.xensource.com wrote: > On 11/07/09 23:46, Keir Fraser wrote: >>> The Linux patch is initially part of patch for CPU hotplug. >>> >> Ah, I see it's part of the phys hotplug stuff. It's okay with me if >> Jeremy will ack it. Also XENPF_get_cpuinfo should be made >> extensible, and should get a comment in public/platform.h, e.g., >> about what ncpus and max_cpus mean. >> > > The kernel patch looks nice and self-contained, so I'd have no > problems applying it based on its form. I'll hold off applying it > until you've got a final extensible form for the ABI. > > J > > _______________________________________________ > Xen-devel mailing list > Xen-devel@lists.xensource.com > http://lists.xensource.com/xen-devel --_002_E2263E4A5B2284449EEBD0AAB751098418E5238629PDSMSX501ccrc_ Content-Type: application/octet-stream; name="01-dom0_pcpu.patch" Content-Description: 01-dom0_pcpu.patch Content-Disposition: attachment; filename="01-dom0_pcpu.patch"; size=15684; creation-date="Tue, 10 Nov 2009 19:57:21 GMT"; modification-date="Tue, 10 Nov 2009 05:39:32 GMT" Content-Transfer-Encoding: base64 RXhwb3J0IGhvc3QgcGh5c2ljYWwgQ1BVIGluZm9ybWF0aW9uIHRvIGRvbTAKCkZyb206IEppYW5n LCBZdW5ob25nIDx5dW5ob25nLmppYW5nQGludGVsLmNvbT4KClRoaXMgcGF0Y2ggZXhwb3NlIGhv c3QncyBwaHlzaWNhbCBDUFUgaW5mb3JtYXRpb24gdG8gZG9tMCBpbiBzeXNmcywgc28gdGhhdCBk b20wJ3MgbWFuYWdlbWVudCB0b29scyBjYW4gY29udHJvbCB0aGUgcGh5c2ljYWwgQ1BVIGlmIG5l ZWRlZC4KCkl0IGFsc28gcHJvdmlkZXMgaW50ZXJmYWNlIGluIHN5c2ZzIHRvIGxvZ2ljYWwgb25s aW5lL29mZmxpbmUgYSBwaHlzaWNhbCBDUFUuCgpOb3RpY2U6IFRoZSBpbmZvcm1hdGlvbiBpbiBk b20wIGlzIHN5bmNlZCB3aXRoIHhlbiBoeXBlcnZpc29yIGFzeW5jaHJvbm91c2x5LgoKU2lnbmVk LW9mZi1ieTogSmlhbmcsIFl1bmhvbmcgPHl1bmhvbmcuamlhbmdAaW50ZWwuY29tPgotLS0KCiBk cml2ZXJzL3hlbi9NYWtlZmlsZSAgICAgICAgICAgICB8ICAgIDIgCiBkcml2ZXJzL3hlbi9wY3B1 LmMgICAgICAgICAgICAgICB8ICA0NjIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGluY2x1ZGUveGVuL2ludGVyZmFjZS9wbGF0Zm9ybS5oIHwgICA0OCArKysrCiBpbmNs dWRlL3hlbi9pbnRlcmZhY2UveGVuLmggICAgICB8ICAgIDEgCiBpbmNsdWRlL3hlbi9wY3B1Lmgg ICAgICAgICAgICAgICB8ICAgMzAgKysKIDUgZmlsZXMgY2hhbmdlZCwgNTQyIGluc2VydGlvbnMo KyksIDEgZGVsZXRpb25zKC0pCiBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy94ZW4vcGNwdS5j CiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS94ZW4vcGNwdS5oCgoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMveGVuL01ha2VmaWxlIGIvZHJpdmVycy94ZW4vTWFrZWZpbGUKaW5kZXggY2RkZmZmYi4u NWQwMTg1NiAxMDA2NDQKLS0tIGEvZHJpdmVycy94ZW4vTWFrZWZpbGUKKysrIGIvZHJpdmVycy94 ZW4vTWFrZWZpbGUKQEAgLTEsNCArMSw0IEBACi1vYmoteQkrPSBncmFudC10YWJsZS5vIGZlYXR1 cmVzLm8gZXZlbnRzLm8gbWFuYWdlLm8gYmlvbWVyZ2Uubworb2JqLXkJKz0gZ3JhbnQtdGFibGUu byBmZWF0dXJlcy5vIGV2ZW50cy5vIG1hbmFnZS5vIGJpb21lcmdlLm8gcGNwdS5vCiBvYmoteQkr PSB4ZW5idXMvIGxpdmVfbWFwcy5vCiAKIG5vc3RhY2twIDo9ICQoY2FsbCBjYy1vcHRpb24sIC1m bm8tc3RhY2stcHJvdGVjdG9yKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy94ZW4vcGNwdS5jIGIvZHJp dmVycy94ZW4vcGNwdS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZjMmY3 MGYKLS0tIC9kZXYvbnVsbAorKysgYi9kcml2ZXJzL3hlbi9wY3B1LmMKQEAgLTAsMCArMSw0NjIg QEAKKy8qCisgKiBwY3B1LmMgLSBtYW5hZ2VtZW50IHBoeXNpY2FsIGNwdSBpbiBkb20wIGVudmly b25tZW50CisgKi8KKyNpbmNsdWRlIDxsaW51eC9pbnRlcnJ1cHQuaD4KKyNpbmNsdWRlIDxsaW51 eC9zcGlubG9jay5oPgorI2luY2x1ZGUgPGFzbS94ZW4vaHlwZXJ2aXNvci5oPgorI2luY2x1ZGUg PGFzbS94ZW4vaHlwZXJjYWxsLmg+CisjaW5jbHVkZSA8bGludXgvY3B1Lmg+CisjaW5jbHVkZSA8 eGVuL3hlbmJ1cy5oPgorI2luY2x1ZGUgPHhlbi9wY3B1Lmg+CisjaW5jbHVkZSA8eGVuL2V2ZW50 cy5oPgorI2luY2x1ZGUgPHhlbi9hY3BpLmg+CisKK3N0YXRpYyBzdHJ1Y3Qgc3lzZGV2X2NsYXNz IHhlbl9wY3B1X3N5c2Rldl9jbGFzcyA9IHsKKwkubmFtZSA9ICJ4ZW5fcGNwdSIsCit9OworCitz dGF0aWMgREVGSU5FX1NQSU5MT0NLKHhlbl9wY3B1X3NwaW5sb2NrKTsKK3N0YXRpYyBSQVdfTk9U SUZJRVJfSEVBRCh4ZW5fcGNwdV9jaGFpbik7CisKKy8qIE5vIG5lZWQgZm9yIGlycSBkaXNhYmxl IHNpbmNlIGhvdHBsdWcgbm90aWZ5IGlzIGluIHdvcmtxdWV1ZSBjb250ZXh0ICovCisjZGVmaW5l IGdldF9wY3B1X2xvY2soKSAgc3Bpbl9sb2NrKCZ4ZW5fcGNwdV9zcGlubG9jayk7CisjZGVmaW5l IHB1dF9wY3B1X2xvY2soKSAgc3Bpbl91bmxvY2soJnhlbl9wY3B1X3NwaW5sb2NrKTsKKworc3Ry dWN0IHhlbl9wY3B1cyB7CisJc3RydWN0IGxpc3RfaGVhZCBsaXN0OworCWludCBwb3NzaWJsZTsK KwlpbnQgcHJlc2VudDsKK307CitzdGF0aWMgc3RydWN0IHhlbl9wY3B1cyB4ZW5fcGNwdXM7CisK K2ludCByZWdpc3Rlcl94ZW5fcGNwdV9ub3RpZmllcihzdHJ1Y3Qgbm90aWZpZXJfYmxvY2sgKm5i KQoreworCWludCByZXQ7CisKKwkvKiBBbGwgcmVmZXIgdG8gdGhlIGNoYWluIG5vdGlmaWVyIGlz IHByb3RlY3RlZCBieSB0aGUgcGNwdV9sb2NrICovCisJZ2V0X3BjcHVfbG9jaygpOworCXJldCA9 IHJhd19ub3RpZmllcl9jaGFpbl9yZWdpc3RlcigmeGVuX3BjcHVfY2hhaW4sIG5iKTsKKwlwdXRf cGNwdV9sb2NrKCk7CisJcmV0dXJuIHJldDsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHJlZ2lzdGVy X3hlbl9wY3B1X25vdGlmaWVyKTsKKwordm9pZCB1bnJlZ2lzdGVyX3hlbl9wY3B1X25vdGlmaWVy KHN0cnVjdCBub3RpZmllcl9ibG9jayAqbmIpCit7CisJZ2V0X3BjcHVfbG9jaygpOworCXJhd19u b3RpZmllcl9jaGFpbl91bnJlZ2lzdGVyKCZ4ZW5fcGNwdV9jaGFpbiwgbmIpOworCXB1dF9wY3B1 X2xvY2soKTsKK30KK0VYUE9SVF9TWU1CT0xfR1BMKHVucmVnaXN0ZXJfeGVuX3BjcHVfbm90aWZp ZXIpOworCitzdGF0aWMgaW50IHhlbl9wY3B1X2Rvd24odWludDMyX3QgeGVuX2lkKQoreworCWlu dCByZXQ7CisJeGVuX3BsYXRmb3JtX29wX3Qgb3AgPSB7CisJCS5jbWQJCQk9IFhFTlBGX3Jlc291 cmNlX2hvdHBsdWcsCisJCS5pbnRlcmZhY2VfdmVyc2lvbgk9IFhFTlBGX0lOVEVSRkFDRV9WRVJT SU9OLAorCQkudS5yZXNvdXJjZS51LmNwdV9vbC5jcHVpZCA9IHhlbl9pZCwKKwl9OworCisJb3Au dS5yZXNvdXJjZS5zdWJfY21kCT0gWEVOX0NQVV9vZmZsaW5lOworCXJldCA9IEhZUEVSVklTT1Jf ZG9tMF9vcCgmb3ApOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgeGVuX3BjcHVfdXAo dWludDMyX3QgeGVuX2lkKQoreworCWludCByZXQ7CisJeGVuX3BsYXRmb3JtX29wX3Qgb3AgPSB7 CisJCS5jbWQJCQk9IFhFTlBGX3Jlc291cmNlX2hvdHBsdWcsCisJCS5pbnRlcmZhY2VfdmVyc2lv bgk9IFhFTlBGX0lOVEVSRkFDRV9WRVJTSU9OLAorCQkudS5yZXNvdXJjZS51LmNwdV9vbC5jcHVp ZCA9IHhlbl9pZCwKKwl9OworCisJb3AudS5yZXNvdXJjZS5zdWJfY21kCT0gWEVOX0NQVV9vbmxp bmU7CisJcmV0ID0gSFlQRVJWSVNPUl9kb20wX29wKCZvcCk7CisJcmV0dXJuIHJldDsKK30KKwor c3RhdGljIHNzaXplX3Qgc2hvd19vbmxpbmUoc3RydWN0IHN5c19kZXZpY2UgKmRldiwKKwkJCXN0 cnVjdCBzeXNkZXZfYXR0cmlidXRlICphdHRyLAorCQkJY2hhciAqYnVmKQoreworCXN0cnVjdCBw Y3B1ICpjcHUgPSBjb250YWluZXJfb2YoZGV2LCBzdHJ1Y3QgcGNwdSwgc3lzZGV2KTsKKworCXJl dHVybiBzcHJpbnRmKGJ1ZiwgIiV1XG4iLCAhIShjcHUtPmZsYWdzICYgWEVOX1BDUFVfRkxBR1Nf T05MSU5FKSk7Cit9CisKK3N0YXRpYyBzc2l6ZV90IF9fcmVmIHN0b3JlX29ubGluZShzdHJ1Y3Qg c3lzX2RldmljZSAqZGV2LAorCQkJCSAgc3RydWN0IHN5c2Rldl9hdHRyaWJ1dGUgKmF0dHIsCisJ CQkJICBjb25zdCBjaGFyICpidWYsIHNpemVfdCBjb3VudCkKK3sKKwlzdHJ1Y3QgcGNwdSAqY3B1 ID0gY29udGFpbmVyX29mKGRldiwgc3RydWN0IHBjcHUsIHN5c2Rldik7CisJc3NpemVfdCByZXQ7 CisKKwlzd2l0Y2ggKGJ1ZlswXSkgeworCWNhc2UgJzAnOgorCQlyZXQgPSB4ZW5fcGNwdV9kb3du KGNwdS0+eGVuX2lkKTsKKwkJYnJlYWs7CisJY2FzZSAnMSc6CisJCXJldCA9IHhlbl9wY3B1X3Vw KGNwdS0+eGVuX2lkKTsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJcmV0ID0gLUVJTlZBTDsKKwl9 CisKKwlpZiAocmV0ID49IDApCisJCXJldCA9IGNvdW50OworCXJldHVybiByZXQ7Cit9CisKK3N0 YXRpYyBTWVNERVZfQVRUUihvbmxpbmUsIDA2NDQsIHNob3dfb25saW5lLCBzdG9yZV9vbmxpbmUp OworCitzdGF0aWMgc3NpemVfdCBzaG93X2FwaWNpZChzdHJ1Y3Qgc3lzX2RldmljZSAqZGV2LAor CQkJc3RydWN0IHN5c2Rldl9hdHRyaWJ1dGUgKmF0dHIsCisJCQljaGFyICpidWYpCit7CisJc3Ry dWN0IHBjcHUgKmNwdSA9IGNvbnRhaW5lcl9vZihkZXYsIHN0cnVjdCBwY3B1LCBzeXNkZXYpOwor CisJcmV0dXJuIHNwcmludGYoYnVmLCAiJXVcbiIsIGNwdS0+YXBpY19pZCk7Cit9CisKK3N0YXRp YyBzc2l6ZV90IHNob3dfYWNwaWlkKHN0cnVjdCBzeXNfZGV2aWNlICpkZXYsCisJCQlzdHJ1Y3Qg c3lzZGV2X2F0dHJpYnV0ZSAqYXR0ciwKKwkJCWNoYXIgKmJ1ZikKK3sKKwlzdHJ1Y3QgcGNwdSAq Y3B1ID0gY29udGFpbmVyX29mKGRldiwgc3RydWN0IHBjcHUsIHN5c2Rldik7CisKKwlyZXR1cm4g c3ByaW50ZihidWYsICIldVxuIiwgY3B1LT5hY3BpX2lkKTsKK30KK3N0YXRpYyBTWVNERVZfQVRU UihhcGljX2lkLCAwNDQ0LCBzaG93X2FwaWNpZCwgTlVMTCk7CitzdGF0aWMgU1lTREVWX0FUVFIo YWNwaV9pZCwgMDQ0NCwgc2hvd19hY3BpaWQsIE5VTEwpOworCitzdGF0aWMgaW50IHhlbl9wY3B1 X2ZyZWUoc3RydWN0IHBjcHUgKnBjcHUpCit7CisJaWYgKCFwY3B1KQorCQlyZXR1cm4gMDsKKwor CXN5c2Rldl9yZW1vdmVfZmlsZSgmcGNwdS0+c3lzZGV2LCAmYXR0cl9vbmxpbmUpOworCXN5c2Rl dl91bnJlZ2lzdGVyKCZwY3B1LT5zeXNkZXYpOworCWxpc3RfZGVsKCZwY3B1LT5wY3B1X2xpc3Qp OworCWtmcmVlKHBjcHUpOworCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBzdHJ1Y3QgcGNwdSAq eGVuX3BjcHVfYWRkKHN0cnVjdCB4ZW5fcGh5c2ljYWxfY3B1aW5mbyAqaW5mbykKK3sKKwlzdHJ1 Y3QgcGNwdSAqY3B1OworCWludCBlcnJvcjsKKworCXByaW50ayhLRVJOX0RFQlVHICJ4ZW5fcGNw dV9hZGQ6ICB4ZW5faWQgJXggYXBpY19pZCAleCBhY3BpX2lkICV4XG4iLAorCQkJICAgaW5mby0+ eGVuX2NwdWlkLCBpbmZvLT5hcGljX2lkLCBpbmZvLT5hY3BpX2lkKTsKKworCWlmIChpbmZvLT5m bGFncyAmIFhFTl9QQ1BVX0ZMQUdTX0lOVkFMSUQpCisJCXJldHVybiBOVUxMOworCisJY3B1ID0g a3phbGxvYyhzaXplb2Yoc3RydWN0IHBjcHUpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWNwdSkKKwkJ cmV0dXJuIE5VTEw7CisKKwlJTklUX0xJU1RfSEVBRCgmY3B1LT5wY3B1X2xpc3QpOworCWNwdS0+ eGVuX2lkID0gaW5mby0+eGVuX2NwdWlkOworCWNwdS0+YXBpY19pZCA9IGluZm8tPmFwaWNfaWQ7 CisJY3B1LT5hY3BpX2lkID0gaW5mby0+YWNwaV9pZDsKKwljcHUtPmZsYWdzID0gaW5mby0+Zmxh Z3M7CisKKwljcHUtPnN5c2Rldi5jbHMgPSAmeGVuX3BjcHVfc3lzZGV2X2NsYXNzOworCWNwdS0+ c3lzZGV2LmlkID0gaW5mby0+eGVuX2NwdWlkOworCisJZXJyb3IgPSBzeXNkZXZfcmVnaXN0ZXIo JmNwdS0+c3lzZGV2KTsKKwlpZiAoZXJyb3IpIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklORyAieGVu X3BjcHVfYWRkOiBGYWlsZWQgdG8gcmVnaXN0ZXIgcGNwdVxuIik7CisJCWtmcmVlKGNwdSk7CisJ CXJldHVybiBOVUxMOworCX0KKwlzeXNkZXZfY3JlYXRlX2ZpbGUoJmNwdS0+c3lzZGV2LCAmYXR0 cl9vbmxpbmUpOworCXN5c2Rldl9jcmVhdGVfZmlsZSgmY3B1LT5zeXNkZXYsICZhdHRyX2FwaWNf aWQpOworCXN5c2Rldl9jcmVhdGVfZmlsZSgmY3B1LT5zeXNkZXYsICZhdHRyX2FjcGlfaWQpOwor CWxpc3RfYWRkX3RhaWwoJmNwdS0+cGNwdV9saXN0LCAmeGVuX3BjcHVzLmxpc3QpOworCisJcmV0 dXJuIGNwdTsKK30KKworc3RhdGljIHN0cnVjdCB4ZW5fcGh5c2ljYWxfY3B1aW5mbyAqeGVuX3Bj cHVfaW5mb19mZXRjaChpbnQgKm51bSwKKwkJaW50ICpwb3NzaWJsZSkKK3sKKwlpbnQgY3B1X251 bSwgcmV0ID0gMCwgaTsKKwlzdHJ1Y3QgeGVuX3BoeXNpY2FsX2NwdWluZm8gKmluZm87CisJeGVu X3BsYXRmb3JtX29wX3Qgb3AgPSB7CisJCS5jbWQgICAgICAgICAgICA9IFhFTlBGX2dldF9jcHVp bmZvLAorCQkuaW50ZXJmYWNlX3ZlcnNpb24gID0gWEVOUEZfSU5URVJGQUNFX1ZFUlNJT04sCisJ CS51LnBjcHVfaW5mby5pbmZvX251bSAgID0gMCwKKwl9OworCisJc2V0X3hlbl9ndWVzdF9oYW5k bGUob3AudS5wY3B1X2luZm8uaW5mbywgTlVMTCk7CisKKwlyZXQgPSBIWVBFUlZJU09SX2RvbTBf b3AoJm9wKTsKKwlpZiAocmV0KQorCQlyZXR1cm4gTlVMTDsKKworCWNwdV9udW0gPSBvcC51LnBj cHVfaW5mby5tYXhfcHJlc2VudDsKKworCWluZm8gPSBremFsbG9jKGNwdV9udW0gKiBzaXplb2Yo c3RydWN0IHhlbl9waHlzaWNhbF9jcHVpbmZvKSwKKwkJR0ZQX0tFUk5FTCk7CisJaWYgKCFpbmZv KQorCQlyZXR1cm4gTlVMTDsKKworCW9wLnUucGNwdV9pbmZvLmluZm9fbnVtID0gY3B1X251bTsK Kwlmb3IgKGkgPSAwOyBpIDwgY3B1X251bTsgaSsrKQorCQlpbmZvW2ldLnhlbl9jcHVpZCA9IGk7 CisKKwlzZXRfeGVuX2d1ZXN0X2hhbmRsZShvcC51LnBjcHVfaW5mby5pbmZvLCBpbmZvKTsKKwor CXJldCA9IEhZUEVSVklTT1JfZG9tMF9vcCgmb3ApOworCWlmIChyZXQpIHsKKwkJa2ZyZWUoaW5m byk7CisJCXByaW50ayhLRVJOX1dBUk5JTkcgInhlbl9wY3B1X2luZm9fZmV0Y2g6IEVycm9yIGZl dGNoIHBjcHUgaW5mb1xuIik7CisJCXJldHVybiBOVUxMOworCX0KKworCS8qIHByZXNlbnQgY3B1 cyBpcyBjaGFuZ2VkLCB0aGF0IG1lYW4gaG90cGx1ZyBtYXkgaGFwcGVuICovCisJaWYgKGNwdV9u dW0gIT0gb3AudS5wY3B1X2luZm8ubWF4X3ByZXNlbnQpCisJCXByaW50ayhLRVJOX1dBUk5JTkcg Ik1heCBwcmVzZW50IGNwdXMgY2hhbmdlZCB3aGVuIGZldGNoIGNwdSBpbmZvXG4iKTsKKworCWlm IChwb3NzaWJsZSkKKwkJKnBvc3NpYmxlID0gb3AudS5wY3B1X2luZm8ubWF4X3Bvc3NpYmxlOwor CWlmIChudW0pCisJCSpudW0gPSBjcHVfbnVtOworCisJcmV0dXJuIGluZm87Cit9CisKK3N0YXRp YyBpbmxpbmUgaW50IHNhbWVfcGNwdShzdHJ1Y3QgeGVuX3BoeXNpY2FsX2NwdWluZm8gKmluZm8s CisJCQkgICAgc3RydWN0IHBjcHUgKnBjcHUpCit7CisJcmV0dXJuIChwY3B1LT5hcGljX2lkID09 IGluZm8tPmFwaWNfaWQpICYmCisJCShwY3B1LT54ZW5faWQgPT0gaW5mby0+eGVuX2NwdWlkKTsK K30KKworLyoKKyAqIFJldHVybiAxIGlmIG9ubGluZSBzdGF0dXMgY2hhbmdlZAorICovCitzdGF0 aWMgaW50IHhlbl9wY3B1X29ubGluZV9jaGVjayhzdHJ1Y3QgeGVuX3BoeXNpY2FsX2NwdWluZm8g KmluZm8sCisJCQkJIHN0cnVjdCBwY3B1ICpwY3B1KQoreworCWludCByZXN1bHQgPSAwOworCisJ aWYgKCFzYW1lX3BjcHUoaW5mbywgcGNwdSkpCisJCXJldHVybiAwOworCisJaWYgKHhlbl9wY3B1 X29ubGluZShpbmZvLT5mbGFncykgJiYgIXhlbl9wY3B1X29ubGluZShwY3B1LT5mbGFncykpIHsK KwkJLyogdGhlIHBjcHUgaXMgb25saW5lZCAqLworCQlwY3B1LT5mbGFncyB8PSBYRU5fUENQVV9G TEFHU19PTkxJTkU7CisJCWtvYmplY3RfdWV2ZW50KCZwY3B1LT5zeXNkZXYua29iaiwgS09CSl9P TkxJTkUpOworCQlyYXdfbm90aWZpZXJfY2FsbF9jaGFpbigmeGVuX3BjcHVfY2hhaW4sCisJCQlY RU5fUENQVV9PTkxJTkUsICh2b2lkICopKGxvbmcpcGNwdS0+eGVuX2lkKTsKKwkJcmVzdWx0ID0g MTsKKwl9IGVsc2UgaWYgKCF4ZW5fcGNwdV9vbmxpbmUoaW5mby0+ZmxhZ3MpICYmCisJCSB4ZW5f cGNwdV9vbmxpbmUocGNwdS0+ZmxhZ3MpKSAgeworCQkvKiBUaGUgcGNwdSBpcyBvZmZsaW5lZCBu b3cgKi8KKwkJcGNwdS0+ZmxhZ3MgJj0gflhFTl9QQ1BVX0ZMQUdTX09OTElORTsKKwkJa29iamVj dF91ZXZlbnQoJnBjcHUtPnN5c2Rldi5rb2JqLCBLT0JKX09GRkxJTkUpOworCQlyYXdfbm90aWZp ZXJfY2FsbF9jaGFpbigmeGVuX3BjcHVfY2hhaW4sCisJCQlYRU5fUENQVV9PRkZMSU5FLCAodm9p ZCAqKShsb25nKXBjcHUtPnhlbl9pZCk7CisJCXJlc3VsdCA9IDE7CisJfQorCisJcmV0dXJuIHJl c3VsdDsKK30KKworLyoKKyAqIFN5bmMgZG9tMCdzIHBjcHUgaW5mb3JtYXRpb24gd2l0aCB4ZW4g aHlwZXJ2aXNvcidzCisgKi8KK3N0YXRpYyBpbnQgeGVuX3BjcHVfc3luYyh2b2lkKQoreworCXN0 cnVjdCB4ZW5fcGh5c2ljYWxfY3B1aW5mbyAqaW5mbzsKKwlpbnQgY3B1X251bSwgaSwgcmV0ID0g LTEsIHBvc3NpYmxlLCBwcmVzZW50ID0gMDsKKwlzdHJ1Y3QgbGlzdF9oZWFkICplbGVtLCAqdG1w OworCXN0cnVjdCBwY3B1ICpwY3B1OworCisJaW5mbyA9IHhlbl9wY3B1X2luZm9fZmV0Y2goJmNw dV9udW0sICZwb3NzaWJsZSk7CisJaWYgKCFpbmZvKQorCQlyZXR1cm4gLTE7CisKKwlnZXRfcGNw dV9sb2NrKCk7CisKKwl4ZW5fcGNwdXMucG9zc2libGUgPSBwb3NzaWJsZTsKKworCS8qIENoZWNr IGZvciBjdXJyZW50IGNwdSBsaXN0ICovCisJZm9yIChpID0gMDsgaSA8IGNwdV9udW07IGkrKykg eworCQlpbnQgZm91bmQgPSAwOworCisJCWlmIChpbmZvW2ldLmZsYWdzICYgWEVOX1BDUFVfRkxB R1NfSU5WQUxJRCkKKwkJCWNvbnRpbnVlOworCisJCXByZXNlbnQrKzsKKwkJbGlzdF9mb3JfZWFj aF9lbnRyeShwY3B1LCAmeGVuX3BjcHVzLmxpc3QsIHBjcHVfbGlzdCkgeworCQkJaWYgKHNhbWVf cGNwdSgmaW5mb1tpXSwgcGNwdSkpIHsKKwkJCQl4ZW5fcGNwdV9vbmxpbmVfY2hlY2soJmluZm9b aV0sIHBjcHUpOworCQkJCXBjcHUtPnN0YXR1cyB8PSBQQ1BVX0xPT1BFRDsKKwkJCQlmb3VuZCA9 IDE7CisJCQl9CisJCX0KKwkJaWYgKCFmb3VuZCkgeworCQkJc3RydWN0IHBjcHUgKmNwdTsKKwor CQkJLyoKKwkJCSAqIE5vcm1hbGx5IGEgcGh5c2ljYWwgY3B1IGlzIG9ubGluZWQgaW4gdHdvIHN0 ZXAKKwkJCSAqIEZpcnN0bHksIHRoZSBwaHlzaWNhbCBDUFUgaXMgaG90LWFkZGVkLCBzZWNvbmRs eQorCQkJICogaXQgd2lsbCBiZSB0YWtlIG9ubGluZSB0aHJvdWdoIHN5c2ZzIHdyaXRpbmcKKwkJ CSAqIFNvIGEgaG90LWFkZGVkIENQVSBzaG91bGQgYmUgb2ZmbGluZWQgaW5pdGlhbGx5CisJCQkg Ki8KKwkJCWlmICh4ZW5fcGNwdV9vbmxpbmUoaW5mb1tpXS5mbGFncykpCisJCQkJcHJpbnRrKEtF Uk5fV0FSTklORyAieGVuX3BjcHVfc3luYzoiCisJCQkJCSJBIGhvdGFkZCBjcHUgaXMgb25saW5l ZCBhbHNvXG4iKTsKKworCQkJY3B1ID0geGVuX3BjcHVfYWRkKCZpbmZvW2ldKTsKKwkJCWlmIChj cHUgPT0gTlVMTCkKKwkJCQlnb3RvIGZhaWxlZDsKKwkJCXJhd19ub3RpZmllcl9jYWxsX2NoYWlu KCZ4ZW5fcGNwdV9jaGFpbiwKKwkJCQkJWEVOX1BDUFVfQURELAorCQkJCQkodm9pZCAqKShsb25n KWNwdS0+eGVuX2lkKTsKKwkJCWNwdS0+c3RhdHVzIHw9IFBDUFVfTE9PUEVEOworCQl9CisJfQor CisJbGlzdF9mb3JfZWFjaF9zYWZlKGVsZW0sIHRtcCwgJnhlbl9wY3B1cy5saXN0KSB7CisJCXBj cHUgPSBsaXN0X2VudHJ5KGVsZW0sIHN0cnVjdCBwY3B1LCBwY3B1X2xpc3QpOworCQlpZiAocGNw dS0+c3RhdHVzICYgUENQVV9MT09QRUQpCisJCQlwY3B1LT5zdGF0dXMgJj0gflBDUFVfTE9PUEVE OworCQllbHNlIHsKKwkJCS8qIFRoZSBwY3B1IGRvZXMgbm90IGV4aXN0IGFueSBtb3JlLCByZW1v dmUgaXQgKi8KKwkJCXJhd19ub3RpZmllcl9jYWxsX2NoYWluKCZ4ZW5fcGNwdV9jaGFpbiwKKwkJ CQkJWEVOX1BDUFVfUkVNT1ZFLAorCQkJCQkodm9pZCAqKShsb25nKXBjcHUtPnhlbl9pZCk7CisJ CQl4ZW5fcGNwdV9mcmVlKHBjcHUpOworCQl9CisJfQorCisJeGVuX3BjcHVzLnByZXNlbnQgPSBw cmVzZW50OworCXJldCA9IDA7CitmYWlsZWQ6CisJcHV0X3BjcHVfbG9jaygpOworCWtmcmVlKGlu Zm8pOworCXJldHVybiByZXQ7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IHhlbl9wY3B1X2luZm9f aW5pdCh2b2lkKQoreworCWludCBwb3NzaWJsZSwgY3B1X251bSwgaTsKKwlzdHJ1Y3QgeGVuX3Bo eXNpY2FsX2NwdWluZm8gKmluZm8gPSBOVUxMOworCXN0cnVjdCBsaXN0X2hlYWQgKmVsZW0sICp0 bXA7CisJc3RydWN0IHBjcHUgKnBjcHU7CisKKwlpbmZvID0geGVuX3BjcHVfaW5mb19mZXRjaCgm Y3B1X251bSwgJnBvc3NpYmxlKTsKKwlpZiAoIWluZm8pIHsKKwkJcHJpbnRrKEtFUk5fV0FSTklO RworCQkJInhlbl9wY3B1X2luZm9faW5pdDogRmFpbGVkIHRvIGZldGNoIHBjcHVfaW5mb1xuIik7 CisJCXJldHVybiAtMTsKKwl9CisKKwlnZXRfcGNwdV9sb2NrKCk7CisKKwlJTklUX0xJU1RfSEVB RCgmeGVuX3BjcHVzLmxpc3QpOworCXhlbl9wY3B1cy5wb3NzaWJsZSA9IHBvc3NpYmxlOworCXhl bl9wY3B1cy5wcmVzZW50ID0gMDsKKworCWZvciAoaSA9IDA7IGkgPCBjcHVfbnVtOyBpKyspIHsK KwkJaWYgKGluZm9baV0uZmxhZ3MgJiBYRU5fUENQVV9GTEFHU19JTlZBTElEKQorCQkJY29udGlu dWU7CisJCXBjcHUgPSB4ZW5fcGNwdV9hZGQoJmluZm9baV0pOworCQlpZiAoIXBjcHUpCisJCQln b3RvIGZhaWxlZDsKKwkJeGVuX3BjcHVzLnByZXNlbnQrKzsKKwl9CisKKwlwdXRfcGNwdV9sb2Nr KCk7CisJa2ZyZWUoaW5mbyk7CisKKwlyZXR1cm4gMDsKK2ZhaWxlZDoKKwlsaXN0X2Zvcl9lYWNo X3NhZmUoZWxlbSwgdG1wLCAmeGVuX3BjcHVzLmxpc3QpIHsKKwkJcGNwdSA9IGxpc3RfZW50cnko ZWxlbSwgc3RydWN0IHBjcHUsIHBjcHVfbGlzdCk7CisJCXhlbl9wY3B1X2ZyZWUocGNwdSk7CisJ fQorCXhlbl9wY3B1cy5wb3NzaWJsZSA9IHhlbl9wY3B1cy5wcmVzZW50ID0gMDsKKwlJTklUX0xJ U1RfSEVBRCgmeGVuX3BjcHVzLmxpc3QpOworCXB1dF9wY3B1X2xvY2soKTsKKworCWtmcmVlKGlu Zm8pOworCXJldHVybiAtMTsKK30KKworc3RhdGljIHZvaWQgeGVuX3BjcHVfZHBjKHN0cnVjdCB3 b3JrX3N0cnVjdCAqd29yaykKK3sKKwlpZiAoeGVuX3BjcHVfc3luYygpIDwgMCkKKwkJcHJpbnRr KEtFUk5fV0FSTklORworCQkJInhlbl9wY3B1X2RwYzogRmFpbGVkIHRvIHN5bmMgcGNwdSBpbmZv cm1hdGlvblxuIik7Cit9CitzdGF0aWMgREVDTEFSRV9XT1JLKHhlbl9wY3B1X3dvcmssIHhlbl9w Y3B1X2RwYyk7CisKKy8qCisgKiB0eXBlOiAwIGFkZCwgMSByZW1vdmUKKyAqLworaW50IHhlbl9w Y3B1X2hvdHBsdWcoaW50IHR5cGUsIHVpbnQzMl90IGFwaWNfaWQpCit7CisJc3RydWN0IHBjcHUg KnBjcHU7CisJaW50IGZvdW5kID0gMDsKKworCXhlbl9wY3B1X3N5bmMoKTsKKwlnZXRfcGNwdV9s b2NrKCk7CisJbGlzdF9mb3JfZWFjaF9lbnRyeShwY3B1LCAmeGVuX3BjcHVzLmxpc3QsIHBjcHVf bGlzdCkKKwl7CisJCWlmIChwY3B1LT5hcGljX2lkID09IGFwaWNfaWQpIHsKKwkJCWZvdW5kID0g MTsKKwkJCWJyZWFrOworCQl9CisJfQorCXB1dF9wY3B1X2xvY2soKTsKKworCWlmICghZm91bmQg JiYgKHR5cGUgPT0gSE9UUExVR19UWVBFX0FERCkpCisJCXByaW50ayhLRVJOX1dBUk5JTkcgIlRo ZSBjcHUgaXMgbm90IGFkZGVkIGludG8gWGVuIEhWP1xuIik7CisKKwlpZiAoZm91bmQgJiYgKHR5 cGUgPT0gSE9UUExVR19UWVBFX1JFTU9WRSkpCisJCXByaW50ayhLRVJOX1dBUk5JTkcgIlRoZSBj cHUgc3RpbGwgZXhpdHMgaW4gWGVuIEhWP1xuIik7CisJcmV0dXJuIDA7Cit9CitFWFBPUlRfU1lN Qk9MKHhlbl9wY3B1X2hvdHBsdWcpOworCitzdGF0aWMgaXJxcmV0dXJuX3QgeGVuX3BjcHVfaW50 ZXJydXB0KGludCBpcnEsIHZvaWQgKmRldl9pZCkKK3sKKwlzY2hlZHVsZV93b3JrKCZ4ZW5fcGNw dV93b3JrKTsKKwlyZXR1cm4gSVJRX0hBTkRMRUQ7Cit9CisKK3N0YXRpYyBpbnQgX19pbml0IHhl bl9wY3B1X2luaXQodm9pZCkKK3sKKwlpbnQgZXJyOworCisJaWYgKCF4ZW5faW5pdGlhbF9kb21h aW4oKSkKKwkJcmV0dXJuIDA7CisKKwllcnIgPSBzeXNkZXZfY2xhc3NfcmVnaXN0ZXIoJnhlbl9w Y3B1X3N5c2Rldl9jbGFzcyk7CisJaWYgKGVycikgeworCQlwcmludGsoS0VSTl9XQVJOSU5HCisJ CQkieGVuX3BjcHVfaW5pdDogcmVnaXN0ZXIgeGVuX3BjcHUgc3lzZGV2IEZhaWxlZCFcbiIpOwor CQlyZXR1cm4gZXJyOworCX0KKworCWVyciA9IHhlbl9wY3B1X2luZm9faW5pdCgpOworCWlmICgh ZXJyKQorCQllcnIgPSBiaW5kX3ZpcnFfdG9faXJxaGFuZGxlcihWSVJRX1BDUFVfU1RBVEUsCisJ CQkwLCB4ZW5fcGNwdV9pbnRlcnJ1cHQsIDAsICJwY3B1IiwgTlVMTCk7CisJaWYgKGVyciA8IDAp CisJCXByaW50ayhLRVJOX1dBUk5JTkcgInhlbl9wY3B1X2luaXQ6ICIKKwkJCSJGYWlsZWQgdG8g YmluZCBwY3B1X3N0YXRlIHZpcnFcbiIKKwkJCSJZb3Ugd2lsbCBsb3N0IGxhdGVzdCBpbmZvcm1h dGlvbiEgXG4iKTsKKwlyZXR1cm4gZXJyOworfQorCitzdWJzeXNfaW5pdGNhbGwoeGVuX3BjcHVf aW5pdCk7CmRpZmYgLS1naXQgYS9pbmNsdWRlL3hlbi9pbnRlcmZhY2UvcGxhdGZvcm0uaCBiL2lu Y2x1ZGUveGVuL2ludGVyZmFjZS9wbGF0Zm9ybS5oCmluZGV4IDY3ODNmY2UuLmE5Y2Y0ZTIgMTAw NjQ0Ci0tLSBhL2luY2x1ZGUveGVuL2ludGVyZmFjZS9wbGF0Zm9ybS5oCisrKyBiL2luY2x1ZGUv eGVuL2ludGVyZmFjZS9wbGF0Zm9ybS5oCkBAIC0zMTIsNiArMzEyLDUyIEBAIHN0cnVjdCB4ZW5w Zl9zZXRfcHJvY2Vzc29yX3BtaW5mbyB7CiB0eXBlZGVmIHN0cnVjdCB4ZW5wZl9zZXRfcHJvY2Vz c29yX3BtaW5mbyB4ZW5wZl9zZXRfcHJvY2Vzc29yX3BtaW5mb190OwogREVGSU5FX0dVRVNUX0hB TkRMRV9TVFJVQ1QoeGVucGZfc2V0X3Byb2Nlc3Nvcl9wbWluZm8pOwogCisjZGVmaW5lIFhFTlBG X2dldF9jcHVpbmZvIDU1CitzdHJ1Y3QgeGVuX3BoeXNpY2FsX2NwdWluZm8geworCS8qIElOICov CisJdWludDMyX3QgeGVuX2NwdWlkOworCS8qIE9VVCAqLworCXVpbnQzMl90IGFwaWNfaWQ7CisJ dWludDMyX3QgYWNwaV9pZDsKKyNkZWZpbmUgWEVOX1BDUFVfRkxBR1NfT05MSU5FCTEKKwkvKiBD b3JyZXBvbmRpbmcgeGVuX2NwdWlkIGlzIG5vdCBwcmVzZW50Ki8KKyNkZWZpbmUgWEVOX1BDUFVf RkxBR1NfSU5WQUxJRAkyCisJdWludDMyX3QgZmxhZ3M7CisJdWludDhfdCBwYWRbMTI4XTsKK307 Cit0eXBlZGVmIHN0cnVjdCB4ZW5fcGh5c2ljYWxfY3B1aW5mbyB4ZW5fcGh5c2ljYWxfY3B1aW5m b190OworREVGSU5FX0dVRVNUX0hBTkRMRV9TVFJVQ1QoeGVuX3BoeXNpY2FsX2NwdWluZm8pOwor CitzdHJ1Y3QgeGVucGZfcGNwdV9pbmZvIHsKKwkvKiBPVVQgKi8KKwkvKiBUaGUgbWF4aXVtIGNw dV9pZCB0aGF0IGlzIHByZXNlbnQgKi8KKwl1aW50MzJfdCBtYXhfcHJlc2VudDsKKwkvKiBUaGUg bWF4aXVtIHBvc3NpYmxlIGNwdXMgKi8KKwl1aW50MzJfdCBtYXhfcG9zc2libGU7CisKKwkvKiBJ TiAqLworCXVpbnQzMl90IGluZm9fbnVtOworCUdVRVNUX0hBTkRMRSh4ZW5fcGh5c2ljYWxfY3B1 aW5mbykgaW5mbzsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5wZl9wY3B1X2luZm8geGVucGZfcGNw dV9pbmZvX3Q7CitERUZJTkVfR1VFU1RfSEFORExFX1NUUlVDVCh4ZW5wZl9wY3B1X2luZm8pOwor CitzdHJ1Y3QgeGVucGZfY3B1X29sIHsKKwl1aW50MzJfdCBjcHVpZDsKK307CisKKyNkZWZpbmUg WEVOUEZfcmVzb3VyY2VfaG90cGx1ZyA1Ngorc3RydWN0IHhlbnBmX3Jlc291cmNlX2hvdHBsdWcg eworCXVpbnQzMl90IHN1Yl9jbWQ7CisjZGVmaW5lIFhFTl9DUFVfb25saW5lICAxCisjZGVmaW5l IFhFTl9DUFVfb2ZmbGluZSAyCisJdW5pb24geworCQlzdHJ1Y3QgeGVucGZfY3B1X29sIGNwdV9v bDsKKwkJdWludDhfdCAgICAgICAgICAgIHBhZFs2NF07CisJfSB1OworfTsKKworCiBzdHJ1Y3Qg eGVuX3BsYXRmb3JtX29wIHsKIAl1aW50MzJfdCBjbWQ7CiAJdWludDMyX3QgaW50ZXJmYWNlX3Zl cnNpb247IC8qIFhFTlBGX0lOVEVSRkFDRV9WRVJTSU9OICovCkBAIC0zMjcsNiArMzczLDggQEAg c3RydWN0IHhlbl9wbGF0Zm9ybV9vcCB7CiAJCXN0cnVjdCB4ZW5wZl9jaGFuZ2VfZnJlcSAgICAg ICBjaGFuZ2VfZnJlcTsKIAkJc3RydWN0IHhlbnBmX2dldGlkbGV0aW1lICAgICAgIGdldGlkbGV0 aW1lOwogCQlzdHJ1Y3QgeGVucGZfc2V0X3Byb2Nlc3Nvcl9wbWluZm8gc2V0X3BtaW5mbzsKKwkJ c3RydWN0IHhlbnBmX3BjcHVfaW5mbyAgICAgICAgICBwY3B1X2luZm87CisJCXN0cnVjdCB4ZW5w Zl9yZXNvdXJjZV9ob3RwbHVnICAgcmVzb3VyY2U7CiAJCXVpbnQ4X3QgICAgICAgICAgICAgICAg ICAgICAgICBwYWRbMTI4XTsKIAl9IHU7CiB9OwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vaW50 ZXJmYWNlL3hlbi5oIGIvaW5jbHVkZS94ZW4vaW50ZXJmYWNlL3hlbi5oCmluZGV4IDgxMmZmZDUu LjlmZmFlZTAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUveGVuL2ludGVyZmFjZS94ZW4uaAorKysgYi9p bmNsdWRlL3hlbi9pbnRlcmZhY2UveGVuLmgKQEAgLTc5LDYgKzc5LDcgQEAKICNkZWZpbmUgVklS UV9DT05TT0xFICAgIDIgIC8qIChET00wKSBCeXRlcyByZWNlaXZlZCBvbiBlbWVyZ2VuY3kgY29u c29sZS4gKi8KICNkZWZpbmUgVklSUV9ET01fRVhDICAgIDMgIC8qIChET00wKSBFeGNlcHRpb25h bCBldmVudCBmb3Igc29tZSBkb21haW4uICAgKi8KICNkZWZpbmUgVklSUV9ERUJVR0dFUiAgIDYg IC8qIChET00wKSBBIGRvbWFpbiBoYXMgcGF1c2VkIGZvciBkZWJ1Z2dpbmcuICAgKi8KKyNkZWZp bmUgVklSUV9QQ1BVX1NUQVRFIDkgIC8qIChET00wKSBQQ1BVIHN0YXRlIGNoYW5nZWQgICAgICAg ICAgICAgICAgICAgKi8KIAogLyogQXJjaGl0ZWN0dXJlLXNwZWNpZmljIFZJUlEgZGVmaW5pdGlv bnMuICovCiAjZGVmaW5lIFZJUlFfQVJDSF8wICAgIDE2CmRpZmYgLS1naXQgYS9pbmNsdWRlL3hl bi9wY3B1LmggYi9pbmNsdWRlL3hlbi9wY3B1LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMC4uMzJmY2IwZAotLS0gL2Rldi9udWxsCisrKyBiL2luY2x1ZGUveGVuL3BjcHUuaApA QCAtMCwwICsxLDMwIEBACisjaWZuZGVmIF9YRU5fUENQVV9ICisjZGVmaW5lIF9YRU5fUENQVV9I CisKKyNpbmNsdWRlIDx4ZW4vaW50ZXJmYWNlL3BsYXRmb3JtLmg+CitleHRlcm4gaW50IHhlbl9w Y3B1X2hvdHBsdWcoaW50IHR5cGUsIHVpbnQzMl90IGFwaWNfaWQpOworI2RlZmluZSBYRU5fUENQ VV9PTkxJTkUgICAgIDB4MDEKKyNkZWZpbmUgWEVOX1BDUFVfT0ZGTElORSAgICAweDAyCisjZGVm aW5lIFhFTl9QQ1BVX0FERCAgICAgICAgMHgwNAorI2RlZmluZSBYRU5fUENQVV9SRU1PVkUgICAg IDB4MDgKKworc3RydWN0IHBjcHUgeworCXN0cnVjdCBsaXN0X2hlYWQgcGNwdV9saXN0OworCXN0 cnVjdCBzeXNfZGV2aWNlIHN5c2RldjsKKwl1aW50MzJfdCB4ZW5faWQ7CisJdWludDMyX3QgYXBp Y19pZDsKKwl1aW50MzJfdCBhY3BpX2lkOworCXVpbnQzMl90IGZsYWdzOworI2RlZmluZSBQQ1BV X0xPT1BFRCAweDEwMDAwMDAwCisJdWludDMyX3Qgc3RhdHVzOworfTsKKworc3RhdGljIGlubGlu ZSBpbnQgeGVuX3BjcHVfb25saW5lKHVpbnQzMl90IGZsYWdzKQoreworCXJldHVybiAhIShmbGFn cyAmIFhFTl9QQ1BVX0ZMQUdTX09OTElORSk7Cit9CisKK2V4dGVybiBpbnQgcmVnaXN0ZXJfeGVu X3BjcHVfbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYik7CisKK2V4dGVybiB2b2lk IHVucmVnaXN0ZXJfeGVuX3BjcHVfbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpuYik7 CisjZW5kaWYK --_002_E2263E4A5B2284449EEBD0AAB751098418E5238629PDSMSX501ccrc_ Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xensource.com http://lists.xensource.com/xen-devel --_002_E2263E4A5B2284449EEBD0AAB751098418E5238629PDSMSX501ccrc_--