From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andy Grover Subject: [PATCH] PVWin: Fix warnings Date: Fri, 02 Nov 2007 11:17:32 -0700 Message-ID: <472B69BC.2080503@groveronline.com> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="------------030407050202080602030606" Return-path: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: xen-devel@lists.xensource.com Cc: James Harper List-Id: xen-devel@lists.xenproject.org This is a multi-part message in MIME format. --------------030407050202080602030606 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit This patch cleans up some 80-odd warnings I was seeing when compiling the xenpci driver, all completely trivial. It also replaces the use of asm for calling cpuid with the __cpuid compiler intrinsic, and modifies calling code accordingly. I'm pretty sure my mailer going to mangle the inline patch (below) so I'm attaching the pristine version. (will try to fix for next time) -- Andy --------- diff -r b26bdba50c41 common/include/evtchn_public.h --- a/common/include/evtchn_public.h Thu Nov 01 16:21:24 2007 -0700 +++ b/common/include/evtchn_public.h Fri Nov 02 09:52:30 2007 -0700 @@ -21,7 +21,7 @@ DEFINE_GUID( GUID_XEN_IFACE_EVTCHN, 0xD2 //{D2D20756-DE69-4447-8A7D-9837197D6166} typedef evtchn_port_t -(*PXEN_EVTCHN_ALLOCUNBOUND)(int Domain); +(*PXEN_EVTCHN_ALLOCUNBOUND)(domid_t Domain); typedef NTSTATUS (*PXEN_EVTCHN_BIND)(evtchn_port_t Port, PKSERVICE_ROUTINE ServiceRoutine, PVOID ServiceContext); diff -r b26bdba50c41 common/include/hypercall.h --- a/common/include/hypercall.h Thu Nov 01 16:21:24 2007 -0700 +++ b/common/include/hypercall.h Fri Nov 02 09:52:30 2007 -0700 @@ -102,7 +102,7 @@ HYPERVISOR_console_io(int cmd, int count } static __inline int -HYPERVISOR_hvm_op(int op, char *arg) +HYPERVISOR_hvm_op(int op, struct xen_hvm_param *arg) { long __res; __asm { diff -r b26bdba50c41 xenpci/evtchn.c --- a/xenpci/evtchn.c Thu Nov 01 16:21:24 2007 -0700 +++ b/xenpci/evtchn.c Fri Nov 02 09:52:30 2007 -0700 @@ -35,7 +35,6 @@ BOOLEAN BOOLEAN EvtChn_InterruptDpc(WDFINTERRUPT Interrupt, WDFOBJECT AssociatedObject) { - int i; int cpu = 0; vcpu_info_t *vcpu_info; unsigned long evt_words, evt_word; @@ -50,7 +49,7 @@ EvtChn_InterruptDpc(WDFINTERRUPT Interru vcpu_info = &shared_info_area->vcpu_info[cpu]; - evt_words = _InterlockedExchange(&vcpu_info->evtchn_pending_sel, 0); + evt_words = _InterlockedExchange((volatile LONG *)&vcpu_info->evtchn_pending_sel, 0); while (_BitScanForward(&evt_word, evt_words)) { @@ -68,7 +67,7 @@ EvtChn_InterruptDpc(WDFINTERRUPT Interru KdPrint((__DRIVER_NAME " Calling Handler for port %d\n", port)); ev_action->ServiceRoutine(NULL, ev_action->ServiceContext); } - _interlockedbittestandreset(&shared_info_area->evtchn_pending[0], port); + _interlockedbittestandreset((volatile LONG *)&shared_info_area->evtchn_pending[0], port); } } KdPrint((__DRIVER_NAME " <-- InterruptDpc\n")); @@ -81,7 +80,6 @@ EvtChn_Interrupt(WDFINTERRUPT Interrupt, { int cpu = 0; vcpu_info_t *vcpu_info; - int i; unsigned long evt_words, evt_word; unsigned long evt_bit; unsigned long port; @@ -96,8 +94,8 @@ EvtChn_Interrupt(WDFINTERRUPT Interrupt, vcpu_info->evtchn_upcall_pending = 0; - evt_words = _InterlockedExchange(&vcpu_info->evtchn_pending_sel, 0); - + evt_words = _InterlockedExchange((volatile LONG *)&vcpu_info->evtchn_pending_sel, 0); + while (_BitScanForward(&evt_word, evt_words)) { evt_words &= ~(1 << evt_word); @@ -114,7 +112,7 @@ EvtChn_Interrupt(WDFINTERRUPT Interrupt, KdPrint((__DRIVER_NAME " Calling Handler for port %d\n", port)); ev_action->ServiceRoutine(NULL, ev_action->ServiceContext); } - _interlockedbittestandreset(&shared_info_area->evtchn_pending[0], port); + _interlockedbittestandreset((volatile LONG *)&shared_info_area->evtchn_pending[0], port); } } @@ -124,7 +122,7 @@ EvtChn_Interrupt(WDFINTERRUPT Interrupt, } evtchn_port_t -EvtChn_AllocUnbound(int Domain) +EvtChn_AllocUnbound(domid_t Domain) { evtchn_alloc_unbound_t op; @@ -178,7 +176,7 @@ EvtChn_Mask(evtchn_port_t Port) { //KdPrint((__DRIVER_NAME " --> EvtChn_Mask\n")); - _interlockedbittestandset(&shared_info_area->evtchn_mask[0], Port); + _interlockedbittestandset((volatile LONG *)&shared_info_area->evtchn_mask[0], Port); //KdPrint((__DRIVER_NAME " <-- EvtChn_Mask\n")); @@ -190,7 +188,7 @@ EvtChn_Unmask(evtchn_port_t Port) { KdPrint((__DRIVER_NAME " --> EvtChn_Unmask\n")); - _interlockedbittestandreset(&shared_info_area->evtchn_mask[0], Port); + _interlockedbittestandreset((volatile LONG *)&shared_info_area->evtchn_mask[0], Port); // should we kick off pending interrupts here too??? KdPrint((__DRIVER_NAME " <-- EvtChn_Unmask\n")); @@ -242,7 +240,7 @@ EvtChn_GetXenStoreRingAddr() xen_store_mfn = (ULONG)hvm_get_parameter(HVM_PARAM_STORE_PFN); pa_xen_store_interface.QuadPart = xen_store_mfn << PAGE_SHIFT; - xen_store_interface = (struct xenstore_domain_interface *)MmMapIoSpace(pa_xen_store_interface, PAGE_SIZE, MmNonCached); + xen_store_interface = MmMapIoSpace(pa_xen_store_interface, PAGE_SIZE, MmNonCached); //KdPrint((__DRIVER_NAME " xen_store_mfn = %08x\n", xen_store_mfn)); //KdPrint((__DRIVER_NAME " xen_store_evtchn = %08x\n", xen_store_evtchn)); @@ -273,6 +271,8 @@ EvtChn_Init() } shared_info_area->vcpu_info[0].evtchn_upcall_pending = 0; shared_info_area->vcpu_info[0].evtchn_pending_sel = 0; + + return STATUS_SUCCESS; } static ev_action_t ev_actions[NR_EVENTS]; diff -r b26bdba50c41 xenpci/gnttbl.c --- a/xenpci/gnttbl.c Thu Nov 01 16:21:24 2007 -0700 +++ b/xenpci/gnttbl.c Fri Nov 02 09:52:30 2007 -0700 @@ -63,7 +63,7 @@ GntTab_Map(unsigned int start_idx, unsig xatp.domid = DOMID_SELF; xatp.idx = i; xatp.space = XENMAPSPACE_grant_table; - xatp.gpfn = (gnttab_table_physical.QuadPart >> PAGE_SHIFT) + i; + xatp.gpfn = (xen_pfn_t)(gnttab_table_physical.QuadPart >> PAGE_SHIFT) + i; if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp)) KdPrint((__DRIVER_NAME " ***ERROR MAPPING FRAME***\n")); } while (i-- > start_idx); @@ -74,11 +74,7 @@ VOID VOID GntTbl_Init() { - struct gnttab_setup_table setup; - unsigned long *frames; int i; - PMDL Mdl; - ULONG ret; KdPrint((__DRIVER_NAME " --> GntTbl_Init\n")); @@ -108,7 +104,7 @@ GntTbl_GrantAccess(domid_t domid, unsign gnttab_table[ref].domid = domid; _WriteBarrier(); readonly *= GTF_readonly; - gnttab_table[ref].flags = GTF_permit_access | readonly; + gnttab_table[ref].flags = GTF_permit_access | (uint16_t)readonly; KdPrint((__DRIVER_NAME " <-- GntTbl_GrantAccess (ref = %d)\n", ref)); @@ -128,7 +124,7 @@ GntTbl_EndAccess(grant_ref_t ref) KdPrint((__DRIVER_NAME "WARNING: g.e. still in use!\n")); return FALSE; } - } while ((nflags = InterlockedCompareExchange16(&gnttab_table[ref].flags, flags, 0)) != flags); + } while ((nflags = InterlockedCompareExchange16((volatile SHORT *)&gnttab_table[ref].flags, flags, 0)) != flags); put_free_entry(ref); return TRUE; diff -r b26bdba50c41 xenpci/xenbus.c --- a/xenpci/xenbus.c Thu Nov 01 16:21:24 2007 -0700 +++ b/xenpci/xenbus.c Fri Nov 02 09:52:30 2007 -0700 @@ -20,6 +20,9 @@ Foundation, Inc., 51 Franklin Street, Fi #include "xenpci.h" #include "io/xs_wire.h" #include + +#pragma warning( disable : 4204 ) +#pragma warning( disable : 4221 ) struct xenbus_req_info { @@ -85,7 +88,7 @@ static int allocate_xenbus_id(void) KdPrint((__DRIVER_NAME " --> allocate_xenbus_id\n")); - while (1) + for (;;) { // spin_lock(&req_lock); if (nr_live_reqs < NR_REQS) @@ -95,6 +98,7 @@ static int allocate_xenbus_id(void) } o_probe = probe; + for (;;) { if (!req_info[o_probe].In_Use) @@ -179,11 +183,11 @@ static void xb_write(int type, int req_i { XENSTORE_RING_IDX prod; int r; - int len = 0; + size_t len = 0; const struct write_req *cur_req; - int req_off; - int total_off; - int this_chunk; + size_t req_off; + size_t total_off; + size_t this_chunk; struct xsd_sockmsg m = {type, req_id, trans_id }; struct write_req header_req = { &m, sizeof(m) }; @@ -347,16 +351,15 @@ char* xenbus_wait_for_value(const char* // else // wait_for_watch(); // } - return NULL; + UNREFERENCED_PARAMETER(path); + UNREFERENCED_PARAMETER(value); + + return NULL; } NTSTATUS XenBus_Init() { - OBJECT_ATTRIBUTES oa; - NTSTATUS status; - int i; - KdPrint((__DRIVER_NAME " --> XenBus_Init\n")); xen_store_evtchn = EvtChn_GetXenStorePort(); @@ -417,6 +420,8 @@ XenBus_Stop() // Does this actually stop the threads??? ZwClose(XenBus_WatchThreadHandle); ZwClose(XenBus_ReadThreadHandle); + + return STATUS_SUCCESS; } char * @@ -424,7 +429,7 @@ XenBus_List(xenbus_transaction_t xbt, co { struct xsd_sockmsg *reply, *repmsg; struct write_req req[] = { { pre, strlen(pre)+1 } }; - int nr_elems, x, i; + ULONG nr_elems, x, i; char **res; char *msg; @@ -488,7 +493,10 @@ XenBus_ReadThreadProc(PVOID StartContext char *payload; char *path, *token; - while(TRUE) { + UNREFERENCED_PARAMETER(StartContext); + + for (;;) + { KeWaitForSingleObject(&XenBus_ReadThreadEvent, Executive, KernelMode, FALSE, NULL); KdPrint((__DRIVER_NAME " ReadThread Woken (Count = %d)\n", ReadThreadWaitCount++)); while (xen_store_interface->rsp_prod != xen_store_interface->rsp_cons) { @@ -553,7 +561,9 @@ XenBus_WatchThreadProc(PVOID StartContex int index; PXENBUS_WATCH_ENTRY entry; - while(TRUE) + UNREFERENCED_PARAMETER(StartContext); + + for (;;) { KeWaitForSingleObject(&XenBus_WatchThreadEvent, Executive, KernelMode, FALSE, NULL); while (XenBus_WatchRingReadIndex != XenBus_WatchRingWriteIndex) @@ -606,7 +616,7 @@ XenBus_AddWatch(xenbus_transaction_t xbt req[0].data = Path; req[0].len = strlen(Path) + 1; - sprintf(Token, "%d", i); + RtlStringCbPrintfA(Token, ARRAY_SIZE(Token), "%d", i); req[1].data = Token; req[1].len = strlen(Token) + 1; @@ -656,7 +666,7 @@ XenBus_RemWatch(xenbus_transaction_t xbt req[0].data = Path; req[0].len = strlen(Path) + 1; - sprintf(Token, "%d", i); + RtlStringCbPrintfA(Token, ARRAY_SIZE(Token), "%d", i); req[1].data = Token; req[1].len = strlen(Token) + 1; @@ -755,6 +765,9 @@ XenBus_Interrupt(PKINTERRUPT Interrupt, KeSetEvent(&XenBus_ReadThreadEvent, 1, FALSE); KdPrint((__DRIVER_NAME " <-- XenBus_Interrupt\n")); + + /* is this right? */ + return TRUE; } char * @@ -764,7 +777,7 @@ XenBus_Printf(xenbus_transaction_t xbt, char buf[1024]; va_start(ap, fmt); - vsprintf(buf, fmt, ap); + RtlStringCbVPrintfA(buf, ARRAY_SIZE(buf), fmt, ap); va_end(ap); return XenBus_Write(xbt, path, buf); } \ No newline at end of file diff -r b26bdba50c41 xenpci/xenpci.c --- a/xenpci/xenpci.c Thu Nov 01 16:21:24 2007 -0700 +++ b/xenpci/xenpci.c Fri Nov 02 09:52:30 2007 -0700 @@ -96,29 +96,6 @@ DriverEntry(PDRIVER_OBJECT DriverObject, return status; } -typedef struct { - unsigned nEAX; - unsigned nEBX; - unsigned nECX; - unsigned nEDX; -} CPUID_Output, *PCPUID_Output; - -static void CPUID(PCPUID_Output pResult, int nFunction) -{ - __asm { - mov eax, nFunction - xor ebx, ebx - xor ecx, ebx - xor edx, ebx - cpuid - mov edi, pResult - mov [edi.nEAX], eax - mov [edi.nEBX], ebx - mov [edi.nECX], ecx - mov [edi.nEDX], edx - } -} - static void WRMSR(unsigned int msr, ULONGLONG val) { ULONG lo, hi; @@ -135,22 +112,22 @@ static int static int get_hypercall_stubs() { - CPUID_Output cpuid_output; + DWORD32 cpuid_output[4]; char xensig[13]; ULONG i; ULONG pages; ULONG msr; - CPUID(&cpuid_output, 0x40000000); - *(ULONG*)(xensig + 0) = cpuid_output.nEBX; - *(ULONG*)(xensig + 4) = cpuid_output.nECX; - *(ULONG*)(xensig + 8) = cpuid_output.nEDX; - xensig[12] = 0; - KdPrint((__DRIVER_NAME " Xen Signature = %s, EAX = 0x%08x\n", xensig, cpuid_output.nEAX)); + __cpuid(cpuid_output, 0x40000000); + *(ULONG*)(xensig + 0) = cpuid_output[1]; + *(ULONG*)(xensig + 4) = cpuid_output[2]; + *(ULONG*)(xensig + 8) = cpuid_output[3]; + xensig[12] = '\0'; + KdPrint((__DRIVER_NAME " Xen Signature = %s, EAX = 0x%08x\n", xensig, cpuid_output[0])); - CPUID(&cpuid_output, 0x40000002); - pages = cpuid_output.nEAX; - msr = cpuid_output.nEBX; + __cpuid(cpuid_output, 0x40000002); + pages = cpuid_output[0]; + msr = cpuid_output[1]; KdPrint((__DRIVER_NAME " Hypercall area is %u pages.\n", pages)); hypercall_stubs = ExAllocatePoolWithTag(NonPagedPool, pages * PAGE_SIZE, XENPCI_POOL_TAG); @@ -261,7 +238,6 @@ XenPCI_AddDevice( WDF_IO_QUEUE_CONFIG ioQConfig; WDF_INTERRUPT_CONFIG interruptConfig; PNP_BUS_INFORMATION busInfo; - WDF_FDO_EVENT_CALLBACKS FdoCallbacks; //PDEVICE_OBJECT pdo; //ULONG propertyAddress, length; @@ -371,7 +347,8 @@ XenPCI_PrepareHardware( NTSTATUS status = STATUS_SUCCESS; PCM_PARTIAL_RESOURCE_DESCRIPTOR descriptor; ULONG i; - PXENPCI_DEVICE_DATA deviceData = GetDeviceData(Device); + + UNREFERENCED_PARAMETER(Device); KdPrint((__DRIVER_NAME " --> EvtDevicePrepareHardware\n")); @@ -457,6 +434,8 @@ XenPCI_ReleaseHardware(WDFDEVICE Device, { UNREFERENCED_PARAMETER(Device); UNREFERENCED_PARAMETER(ResourcesTranslated); + + return STATUS_SUCCESS; } static NTSTATUS @@ -483,13 +462,13 @@ XenPCI_D0EntryPostInterruptsEnabled(WDFD XenPCI_D0EntryPostInterruptsEnabled(WDFDEVICE Device, WDF_POWER_DEVICE_STATE PreviousState) { NTSTATUS status = STATUS_SUCCESS; - OBJECT_ATTRIBUTES oa; + //OBJECT_ATTRIBUTES oa; char *response; char *msgTypes; char **Types; - char *msgInstances; - char **Instances; - int i, j; + //char *msgInstances; + //char **Instances; + int i; char buffer[128]; UNREFERENCED_PARAMETER(Device); @@ -513,7 +492,7 @@ XenPCI_D0EntryPostInterruptsEnabled(WDFD if (!msgTypes) { for (i = 0; Types[i]; i++) { - sprintf(buffer, "device/%s", Types[i]); + RtlStringCbPrintfA(buffer, ARRAY_SIZE(buffer), "device/%s", Types[i]); KdPrint((__DRIVER_NAME " ls device[%d] -> %s\n", i, Types[i])); XenPCI_XenBusWatchHandler(buffer, NULL); ExFreePoolWithTag(Types[i], XENPCI_POOL_TAG); @@ -536,9 +515,12 @@ XenPCI_D0EntryPostInterruptsEnabled(WDFD } static NTSTATUS -XenPCI_D0ExitPreInterruptsDisabled(WDFDEVICE Device, WDF_POWER_DEVICE_STATE TargetState) +XenPCI_D0ExitPreInterruptsDisabled(WDFDEVICE Device, WDF_POWER_DEVICE_STATE TargetState) { NTSTATUS status = STATUS_SUCCESS; + + UNREFERENCED_PARAMETER(Device); + UNREFERENCED_PARAMETER(TargetState); XenBus_Stop(); @@ -586,6 +568,8 @@ XenPCI_InterruptEnable(WDFINTERRUPT Inte shared_info_area->vcpu_info[0].evtchn_upcall_mask = 0; KdPrint((__DRIVER_NAME " <-- EvtInterruptEnable\n")); + + return STATUS_SUCCESS; } static NTSTATUS @@ -599,6 +583,8 @@ XenPCI_InterruptDisable(WDFINTERRUPT Int shared_info_area->vcpu_info[0].evtchn_upcall_mask = 1; KdPrint((__DRIVER_NAME " <-- EvtInterruptDisable\n")); + + return STATUS_SUCCESS; } static NTSTATUS @@ -611,13 +597,14 @@ XenPCI_ChildListCreateDevice(WDFCHILDLIS XEN_IFACE_XENBUS XenBusInterface; XEN_IFACE_XEN XenInterface; XEN_IFACE_GNTTBL GntTblInterface; - UNICODE_STRING DeviceId; DECLARE_UNICODE_STRING_SIZE(buffer, 20); WDF_OBJECT_ATTRIBUTES PdoAttributes; DECLARE_CONST_UNICODE_STRING(DeviceLocation, L"Xen Bus"); WDF_QUERY_INTERFACE_CONFIG qiConfig; - WDF_PDO_EVENT_CALLBACKS PdoCallbacks; PXENPCI_XEN_DEVICE_DATA ChildDeviceData = NULL; + size_t path_len; + + UNREFERENCED_PARAMETER(ChildList); KdPrint((__DRIVER_NAME " --> ChildListCreateDevice\n")); @@ -704,8 +691,12 @@ XenPCI_ChildListCreateDevice(WDFCHILDLIS XenBusInterface.InterfaceHeader.Size = sizeof(XenBusInterface); XenBusInterface.InterfaceHeader.Version = 1; - XenBusInterface.InterfaceHeader.Context = ExAllocatePoolWithTag(NonPagedPool, (strlen(XenIdentificationDesc->Path) + 1), XENPCI_POOL_TAG); - strcpy(XenBusInterface.InterfaceHeader.Context, XenIdentificationDesc->Path); + path_len = strlen(XenIdentificationDesc->Path) + 1; + XenBusInterface.InterfaceHeader.Context = ExAllocatePoolWithTag(NonPagedPool, + path_len, XENPCI_POOL_TAG); + /* TODO: check for alloc fail here */ + RtlStringCbCopyA(XenBusInterface.InterfaceHeader.Context, path_len, + XenIdentificationDesc->Path); XenBusInterface.Read = XenBus_Read; XenBusInterface.Write = XenBus_Write; XenBusInterface.Printf = XenBus_Printf; @@ -765,7 +756,6 @@ XenPCI_XenBusWatchHandler(char *Path, PV XENPCI_IDENTIFICATION_DESCRIPTION description; NTSTATUS status; int i; - char *NamePtr; char **Bits; int Count; WDFCHILDLIST ChildList; @@ -773,8 +763,9 @@ XenPCI_XenBusWatchHandler(char *Path, PV WDFDEVICE ChildDevice; PXENPCI_XEN_DEVICE_DATA ChildDeviceData; - ANSI_STRING AnsiBuf; + + UNREFERENCED_PARAMETER(Data); KdPrint((__DRIVER_NAME " --> HotPlugHandler\n")); @@ -830,8 +821,6 @@ XenPCI_XenBusWatchHandler(char *Path, PV ExFreePoolWithTag(Bits, XENPCI_POOL_TAG); KdPrint((__DRIVER_NAME " <-- HotPlugHandler\n")); - - return status; } static void @@ -840,6 +829,9 @@ XenBus_ShutdownHandler(char *Path, PVOID char *value; xenbus_transaction_t xbt; int retry; + + UNREFERENCED_PARAMETER(Path); + UNREFERENCED_PARAMETER(StartContext); KdPrint((__DRIVER_NAME " --> XenBus_ShutdownHandler\n")); @@ -853,7 +845,7 @@ XenBus_ShutdownHandler(char *Path, PVOID if (value != NULL && strlen(value) != 0) XenBus_Write(XBT_NIL, SHUTDOWN_PATH, ""); - XenBus_EndTransaction(&xbt, 0, &retry); + XenBus_EndTransaction(xbt, 0, &retry); KdPrint((__DRIVER_NAME " <-- XenBus_ShutdownHandler\n")); } @@ -867,8 +859,11 @@ XenPCI_FilterRemoveResourceRequirements( WDFIORESLIST ResourceList; PIO_RESOURCE_DESCRIPTOR Descriptor; - int i, j; + ULONG i; + ULONG j; int offset; + + UNREFERENCED_PARAMETER(Device); KdPrint((__DRIVER_NAME " --> FilterRemoveResourceRequirements\n")); @@ -927,7 +922,10 @@ XenPCI_FilterAddResourceRequirements(WDF WDFIORESLIST ResourceList; PIO_RESOURCE_DESCRIPTOR Descriptor; - int i, j; + ULONG i; + ULONG j; + + UNREFERENCED_PARAMETER(Device); KdPrint((__DRIVER_NAME " --> FilterAddResourceRequirements\n")); @@ -981,6 +979,10 @@ static NTSTATUS static NTSTATUS XenPCI_RemoveAddedResources(WDFDEVICE Device, WDFCMRESLIST ResourcesRaw, WDFCMRESLIST ResourcesTranslated) { + UNREFERENCED_PARAMETER(Device); + UNREFERENCED_PARAMETER(ResourcesRaw); + UNREFERENCED_PARAMETER(ResourcesTranslated); + KdPrint((__DRIVER_NAME " --> RemoveAddedResources\n")); KdPrint((__DRIVER_NAME " <-- RemoveAddedResources\n")); @@ -993,6 +995,8 @@ XenPCI_DeviceResourceRequirementsQuery(W NTSTATUS status; WDFIORESLIST resourceList; IO_RESOURCE_DESCRIPTOR descriptor; + + UNREFERENCED_PARAMETER(Device); KdPrint((__DRIVER_NAME " --> DeviceResourceRequirementsQuery\n")); diff -r b26bdba50c41 xenpci/xenpci.h --- a/xenpci/xenpci.h Thu Nov 01 16:21:24 2007 -0700 +++ b/xenpci/xenpci.h Fri Nov 02 09:52:30 2007 -0700 @@ -193,7 +193,7 @@ NTSTATUS NTSTATUS EvtChn_Notify(evtchn_port_t Port); evtchn_port_t -EvtChn_AllocUnbound(int Domain); +EvtChn_AllocUnbound(domid_t Domain); NTSTATUS EvtChn_Init(); @@ -202,7 +202,7 @@ BOOLEAN BOOLEAN GntTbl_EndAccess(grant_ref_t ref); -NTSTATUS +evtchn_port_t EvtChn_GetXenStorePort(); PVOID EvtChn_GetXenStoreRingAddr(); --------------030407050202080602030606 Content-Type: text/plain; name="pvwin.diff" Content-Transfer-Encoding: base64 Content-Disposition: inline; filename="pvwin.diff" ZGlmZiAtciBiMjZiZGJhNTBjNDEgY29tbW9uL2luY2x1ZGUvZXZ0Y2huX3B1YmxpYy5oCi0t LSBhL2NvbW1vbi9pbmNsdWRlL2V2dGNobl9wdWJsaWMuaAlUaHUgTm92IDAxIDE2OjIxOjI0 IDIwMDcgLTA3MDAKKysrIGIvY29tbW9uL2luY2x1ZGUvZXZ0Y2huX3B1YmxpYy5oCUZyaSBO b3YgMDIgMDk6NTI6MzAgMjAwNyAtMDcwMApAQCAtMjEsNyArMjEsNyBAQCBERUZJTkVfR1VJ RCggR1VJRF9YRU5fSUZBQ0VfRVZUQ0hOLCAweEQyCiAvL3tEMkQyMDc1Ni1ERTY5LTQ0NDct OEE3RC05ODM3MTk3RDYxNjZ9DQogDQogdHlwZWRlZiBldnRjaG5fcG9ydF90DQotKCpQWEVO X0VWVENITl9BTExPQ1VOQk9VTkQpKGludCBEb21haW4pOw0KKygqUFhFTl9FVlRDSE5fQUxM T0NVTkJPVU5EKShkb21pZF90IERvbWFpbik7DQogDQogdHlwZWRlZiBOVFNUQVRVUw0KICgq UFhFTl9FVlRDSE5fQklORCkoZXZ0Y2huX3BvcnRfdCBQb3J0LCBQS1NFUlZJQ0VfUk9VVElO RSBTZXJ2aWNlUm91dGluZSwgUFZPSUQgU2VydmljZUNvbnRleHQpOw0KZGlmZiAtciBiMjZi ZGJhNTBjNDEgY29tbW9uL2luY2x1ZGUvaHlwZXJjYWxsLmgKLS0tIGEvY29tbW9uL2luY2x1 ZGUvaHlwZXJjYWxsLmgJVGh1IE5vdiAwMSAxNjoyMToyNCAyMDA3IC0wNzAwCisrKyBiL2Nv bW1vbi9pbmNsdWRlL2h5cGVyY2FsbC5oCUZyaSBOb3YgMDIgMDk6NTI6MzAgMjAwNyAtMDcw MApAQCAtMTAyLDcgKzEwMiw3IEBAIEhZUEVSVklTT1JfY29uc29sZV9pbyhpbnQgY21kLCBp bnQgY291bnQKIH0NCiANCiBzdGF0aWMgX19pbmxpbmUgaW50DQotSFlQRVJWSVNPUl9odm1f b3AoaW50IG9wLCBjaGFyICphcmcpDQorSFlQRVJWSVNPUl9odm1fb3AoaW50IG9wLCBzdHJ1 Y3QgeGVuX2h2bV9wYXJhbSAqYXJnKQ0KIHsNCiAgIGxvbmcgX19yZXM7DQogICBfX2FzbSB7 DQpkaWZmIC1yIGIyNmJkYmE1MGM0MSB4ZW5wY2kvZXZ0Y2huLmMKLS0tIGEveGVucGNpL2V2 dGNobi5jCVRodSBOb3YgMDEgMTY6MjE6MjQgMjAwNyAtMDcwMAorKysgYi94ZW5wY2kvZXZ0 Y2huLmMJRnJpIE5vdiAwMiAwOTo1MjozMCAyMDA3IC0wNzAwCkBAIC0zNSw3ICszNSw2IEBA IEJPT0xFQU4KIEJPT0xFQU4NCiBFdnRDaG5fSW50ZXJydXB0RHBjKFdERklOVEVSUlVQVCBJ bnRlcnJ1cHQsIFdERk9CSkVDVCBBc3NvY2lhdGVkT2JqZWN0KQ0KIHsNCi0gIGludCBpOw0K ICAgaW50IGNwdSA9IDA7DQogICB2Y3B1X2luZm9fdCAqdmNwdV9pbmZvOw0KICAgdW5zaWdu ZWQgbG9uZyBldnRfd29yZHMsIGV2dF93b3JkOw0KQEAgLTUwLDcgKzQ5LDcgQEAgRXZ0Q2hu X0ludGVycnVwdERwYyhXREZJTlRFUlJVUFQgSW50ZXJydQogDQogICB2Y3B1X2luZm8gPSAm c2hhcmVkX2luZm9fYXJlYS0+dmNwdV9pbmZvW2NwdV07DQogDQotICBldnRfd29yZHMgPSBf SW50ZXJsb2NrZWRFeGNoYW5nZSgmdmNwdV9pbmZvLT5ldnRjaG5fcGVuZGluZ19zZWwsIDAp Ow0KKyAgZXZ0X3dvcmRzID0gX0ludGVybG9ja2VkRXhjaGFuZ2UoKHZvbGF0aWxlIExPTkcg KikmdmNwdV9pbmZvLT5ldnRjaG5fcGVuZGluZ19zZWwsIDApOw0KICAgDQogICB3aGlsZSAo X0JpdFNjYW5Gb3J3YXJkKCZldnRfd29yZCwgZXZ0X3dvcmRzKSkNCiAgIHsNCkBAIC02OCw3 ICs2Nyw3IEBAIEV2dENobl9JbnRlcnJ1cHREcGMoV0RGSU5URVJSVVBUIEludGVycnUKICAg ICAgICAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiICAgICBDYWxsaW5nIEhhbmRsZXIgZm9y IHBvcnQgJWRcbiIsIHBvcnQpKTsNCiAgICAgICAgIGV2X2FjdGlvbi0+U2VydmljZVJvdXRp bmUoTlVMTCwgZXZfYWN0aW9uLT5TZXJ2aWNlQ29udGV4dCk7DQogICAgICAgfQ0KLSAgICAg IF9pbnRlcmxvY2tlZGJpdHRlc3RhbmRyZXNldCgmc2hhcmVkX2luZm9fYXJlYS0+ZXZ0Y2hu X3BlbmRpbmdbMF0sIHBvcnQpOw0KKyAgICAgIF9pbnRlcmxvY2tlZGJpdHRlc3RhbmRyZXNl dCgodm9sYXRpbGUgTE9ORyAqKSZzaGFyZWRfaW5mb19hcmVhLT5ldnRjaG5fcGVuZGluZ1sw XSwgcG9ydCk7DQogICAgIH0NCiAgIH0NCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiA8 LS0gSW50ZXJydXB0RHBjXG4iKSk7DQpAQCAtODEsNyArODAsNiBAQCBFdnRDaG5fSW50ZXJy dXB0KFdERklOVEVSUlVQVCBJbnRlcnJ1cHQsCiB7DQogICBpbnQgY3B1ID0gMDsNCiAgIHZj cHVfaW5mb190ICp2Y3B1X2luZm87DQotICBpbnQgaTsNCiAgIHVuc2lnbmVkIGxvbmcgZXZ0 X3dvcmRzLCBldnRfd29yZDsNCiAgIHVuc2lnbmVkIGxvbmcgZXZ0X2JpdDsNCiAgIHVuc2ln bmVkIGxvbmcgcG9ydDsNCkBAIC05Niw4ICs5NCw4IEBAIEV2dENobl9JbnRlcnJ1cHQoV0RG SU5URVJSVVBUIEludGVycnVwdCwKIA0KICAgdmNwdV9pbmZvLT5ldnRjaG5fdXBjYWxsX3Bl bmRpbmcgPSAwOw0KIA0KLSAgZXZ0X3dvcmRzID0gX0ludGVybG9ja2VkRXhjaGFuZ2UoJnZj cHVfaW5mby0+ZXZ0Y2huX3BlbmRpbmdfc2VsLCAwKTsNCi0gIA0KKyAgZXZ0X3dvcmRzID0g X0ludGVybG9ja2VkRXhjaGFuZ2UoKHZvbGF0aWxlIExPTkcgKikmdmNwdV9pbmZvLT5ldnRj aG5fcGVuZGluZ19zZWwsIDApOw0KKw0KICAgd2hpbGUgKF9CaXRTY2FuRm9yd2FyZCgmZXZ0 X3dvcmQsIGV2dF93b3JkcykpDQogICB7DQogICAgIGV2dF93b3JkcyAmPSB+KDEgPDwgZXZ0 X3dvcmQpOw0KQEAgLTExNCw3ICsxMTIsNyBAQCBFdnRDaG5fSW50ZXJydXB0KFdERklOVEVS UlVQVCBJbnRlcnJ1cHQsCiAgICAgICAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiAgICAg Q2FsbGluZyBIYW5kbGVyIGZvciBwb3J0ICVkXG4iLCBwb3J0KSk7DQogICAgICAgICBldl9h Y3Rpb24tPlNlcnZpY2VSb3V0aW5lKE5VTEwsIGV2X2FjdGlvbi0+U2VydmljZUNvbnRleHQp Ow0KICAgICAgIH0NCi0gICAgICBfaW50ZXJsb2NrZWRiaXR0ZXN0YW5kcmVzZXQoJnNoYXJl ZF9pbmZvX2FyZWEtPmV2dGNobl9wZW5kaW5nWzBdLCBwb3J0KTsNCisgICAgICBfaW50ZXJs b2NrZWRiaXR0ZXN0YW5kcmVzZXQoKHZvbGF0aWxlIExPTkcgKikmc2hhcmVkX2luZm9fYXJl YS0+ZXZ0Y2huX3BlbmRpbmdbMF0sIHBvcnQpOw0KICAgICB9DQogICB9DQogDQpAQCAtMTI0 LDcgKzEyMiw3IEBAIEV2dENobl9JbnRlcnJ1cHQoV0RGSU5URVJSVVBUIEludGVycnVwdCwK IH0NCiANCiBldnRjaG5fcG9ydF90DQotRXZ0Q2huX0FsbG9jVW5ib3VuZChpbnQgRG9tYWlu KQ0KK0V2dENobl9BbGxvY1VuYm91bmQoZG9taWRfdCBEb21haW4pDQogew0KICAgZXZ0Y2hu X2FsbG9jX3VuYm91bmRfdCBvcDsNCiANCkBAIC0xNzgsNyArMTc2LDcgQEAgRXZ0Q2huX01h c2soZXZ0Y2huX3BvcnRfdCBQb3J0KQogew0KICAgLy9LZFByaW50KChfX0RSSVZFUl9OQU1F ICIgLS0+IEV2dENobl9NYXNrXG4iKSk7DQogDQotICBfaW50ZXJsb2NrZWRiaXR0ZXN0YW5k c2V0KCZzaGFyZWRfaW5mb19hcmVhLT5ldnRjaG5fbWFza1swXSwgUG9ydCk7DQorICBfaW50 ZXJsb2NrZWRiaXR0ZXN0YW5kc2V0KCh2b2xhdGlsZSBMT05HICopJnNoYXJlZF9pbmZvX2Fy ZWEtPmV2dGNobl9tYXNrWzBdLCBQb3J0KTsNCiANCiAgIC8vS2RQcmludCgoX19EUklWRVJf TkFNRSAiIDwtLSBFdnRDaG5fTWFza1xuIikpOw0KIA0KQEAgLTE5MCw3ICsxODgsNyBAQCBF dnRDaG5fVW5tYXNrKGV2dGNobl9wb3J0X3QgUG9ydCkKIHsNCiAgIEtkUHJpbnQoKF9fRFJJ VkVSX05BTUUgIiAtLT4gRXZ0Q2huX1VubWFza1xuIikpOw0KIA0KLSAgX2ludGVybG9ja2Vk Yml0dGVzdGFuZHJlc2V0KCZzaGFyZWRfaW5mb19hcmVhLT5ldnRjaG5fbWFza1swXSwgUG9y dCk7DQorICBfaW50ZXJsb2NrZWRiaXR0ZXN0YW5kcmVzZXQoKHZvbGF0aWxlIExPTkcgKikm c2hhcmVkX2luZm9fYXJlYS0+ZXZ0Y2huX21hc2tbMF0sIFBvcnQpOw0KICAgLy8gc2hvdWxk IHdlIGtpY2sgb2ZmIHBlbmRpbmcgaW50ZXJydXB0cyBoZXJlIHRvbz8/Pw0KIA0KICAgS2RQ cmludCgoX19EUklWRVJfTkFNRSAiIDwtLSBFdnRDaG5fVW5tYXNrXG4iKSk7DQpAQCAtMjQy LDcgKzI0MCw3IEBAIEV2dENobl9HZXRYZW5TdG9yZVJpbmdBZGRyKCkKICAgeGVuX3N0b3Jl X21mbiA9IChVTE9ORylodm1fZ2V0X3BhcmFtZXRlcihIVk1fUEFSQU1fU1RPUkVfUEZOKTsN CiANCiAgIHBhX3hlbl9zdG9yZV9pbnRlcmZhY2UuUXVhZFBhcnQgPSB4ZW5fc3RvcmVfbWZu IDw8IFBBR0VfU0hJRlQ7DQotICB4ZW5fc3RvcmVfaW50ZXJmYWNlID0gKHN0cnVjdCB4ZW5z dG9yZV9kb21haW5faW50ZXJmYWNlICopTW1NYXBJb1NwYWNlKHBhX3hlbl9zdG9yZV9pbnRl cmZhY2UsIFBBR0VfU0laRSwgTW1Ob25DYWNoZWQpOw0KKyAgeGVuX3N0b3JlX2ludGVyZmFj ZSA9IE1tTWFwSW9TcGFjZShwYV94ZW5fc3RvcmVfaW50ZXJmYWNlLCBQQUdFX1NJWkUsIE1t Tm9uQ2FjaGVkKTsNCiANCiAgIC8vS2RQcmludCgoX19EUklWRVJfTkFNRSAiIHhlbl9zdG9y ZV9tZm4gPSAlMDh4XG4iLCB4ZW5fc3RvcmVfbWZuKSk7DQogICAvL0tkUHJpbnQoKF9fRFJJ VkVSX05BTUUgIiB4ZW5fc3RvcmVfZXZ0Y2huID0gJTA4eFxuIiwgeGVuX3N0b3JlX2V2dGNo bikpOw0KQEAgLTI3Myw2ICsyNzEsOCBAQCBFdnRDaG5fSW5pdCgpCiAgIH0NCiAgIHNoYXJl ZF9pbmZvX2FyZWEtPnZjcHVfaW5mb1swXS5ldnRjaG5fdXBjYWxsX3BlbmRpbmcgPSAwOw0K ICAgc2hhcmVkX2luZm9fYXJlYS0+dmNwdV9pbmZvWzBdLmV2dGNobl9wZW5kaW5nX3NlbCA9 IDA7DQorDQorICByZXR1cm4gU1RBVFVTX1NVQ0NFU1M7DQogfQ0KIA0KIHN0YXRpYyBldl9h Y3Rpb25fdCBldl9hY3Rpb25zW05SX0VWRU5UU107DQpkaWZmIC1yIGIyNmJkYmE1MGM0MSB4 ZW5wY2kvZ250dGJsLmMKLS0tIGEveGVucGNpL2dudHRibC5jCVRodSBOb3YgMDEgMTY6MjE6 MjQgMjAwNyAtMDcwMAorKysgYi94ZW5wY2kvZ250dGJsLmMJRnJpIE5vdiAwMiAwOTo1Mjoz MCAyMDA3IC0wNzAwCkBAIC02Myw3ICs2Myw3IEBAIEdudFRhYl9NYXAodW5zaWduZWQgaW50 IHN0YXJ0X2lkeCwgdW5zaWcKICAgICB4YXRwLmRvbWlkID0gRE9NSURfU0VMRjsNCiAgICAg eGF0cC5pZHggPSBpOw0KICAgICB4YXRwLnNwYWNlID0gWEVOTUFQU1BBQ0VfZ3JhbnRfdGFi bGU7DQotICAgIHhhdHAuZ3BmbiA9IChnbnR0YWJfdGFibGVfcGh5c2ljYWwuUXVhZFBhcnQg Pj4gUEFHRV9TSElGVCkgKyBpOw0KKyAgICB4YXRwLmdwZm4gPSAoeGVuX3Bmbl90KShnbnR0 YWJfdGFibGVfcGh5c2ljYWwuUXVhZFBhcnQgPj4gUEFHRV9TSElGVCkgKyBpOw0KICAgICBp ZiAoSFlQRVJWSVNPUl9tZW1vcnlfb3AoWEVOTUVNX2FkZF90b19waHlzbWFwLCAmeGF0cCkp DQogICAgICAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiICAgICAqKipFUlJPUiBNQVBQSU5H IEZSQU1FKioqXG4iKSk7DQogICB9IHdoaWxlIChpLS0gPiBzdGFydF9pZHgpOw0KQEAgLTc0 LDExICs3NCw3IEBAIFZPSUQKIFZPSUQNCiBHbnRUYmxfSW5pdCgpDQogew0KLSAgc3RydWN0 IGdudHRhYl9zZXR1cF90YWJsZSBzZXR1cDsNCi0gIHVuc2lnbmVkIGxvbmcgKmZyYW1lczsN CiAgIGludCBpOw0KLSAgUE1ETCBNZGw7DQotICBVTE9ORyByZXQ7DQogDQogICBLZFByaW50 KChfX0RSSVZFUl9OQU1FICIgLS0+IEdudFRibF9Jbml0XG4iKSk7DQogDQpAQCAtMTA4LDcg KzEwNCw3IEBAIEdudFRibF9HcmFudEFjY2Vzcyhkb21pZF90IGRvbWlkLCB1bnNpZ24KICAg Z250dGFiX3RhYmxlW3JlZl0uZG9taWQgPSBkb21pZDsNCiAgIF9Xcml0ZUJhcnJpZXIoKTsN CiAgIHJlYWRvbmx5ICo9IEdURl9yZWFkb25seTsNCi0gIGdudHRhYl90YWJsZVtyZWZdLmZs YWdzID0gR1RGX3Blcm1pdF9hY2Nlc3MgfCByZWFkb25seTsNCisgIGdudHRhYl90YWJsZVty ZWZdLmZsYWdzID0gR1RGX3Blcm1pdF9hY2Nlc3MgfCAodWludDE2X3QpcmVhZG9ubHk7DQog DQogICBLZFByaW50KChfX0RSSVZFUl9OQU1FICIgPC0tIEdudFRibF9HcmFudEFjY2VzcyAo cmVmID0gJWQpXG4iLCByZWYpKTsNCiANCkBAIC0xMjgsNyArMTI0LDcgQEAgR250VGJsX0Vu ZEFjY2VzcyhncmFudF9yZWZfdCByZWYpCiAgICAgICBLZFByaW50KChfX0RSSVZFUl9OQU1F ICJXQVJOSU5HOiBnLmUuIHN0aWxsIGluIHVzZSFcbiIpKTsNCiAgICAgICByZXR1cm4gRkFM U0U7DQogICAgIH0NCi0gIH0gd2hpbGUgKChuZmxhZ3MgPSBJbnRlcmxvY2tlZENvbXBhcmVF eGNoYW5nZTE2KCZnbnR0YWJfdGFibGVbcmVmXS5mbGFncywgZmxhZ3MsIDApKSAhPSBmbGFn cyk7DQorICB9IHdoaWxlICgobmZsYWdzID0gSW50ZXJsb2NrZWRDb21wYXJlRXhjaGFuZ2Ux Nigodm9sYXRpbGUgU0hPUlQgKikmZ250dGFiX3RhYmxlW3JlZl0uZmxhZ3MsIGZsYWdzLCAw KSkgIT0gZmxhZ3MpOw0KIA0KICAgcHV0X2ZyZWVfZW50cnkocmVmKTsNCiAgIHJldHVybiBU UlVFOw0KZGlmZiAtciBiMjZiZGJhNTBjNDEgeGVucGNpL3hlbmJ1cy5jCi0tLSBhL3hlbnBj aS94ZW5idXMuYwlUaHUgTm92IDAxIDE2OjIxOjI0IDIwMDcgLTA3MDAKKysrIGIveGVucGNp L3hlbmJ1cy5jCUZyaSBOb3YgMDIgMDk6NTI6MzAgMjAwNyAtMDcwMApAQCAtMjAsNiArMjAs OSBAQCBGb3VuZGF0aW9uLCBJbmMuLCA1MSBGcmFua2xpbiBTdHJlZXQsIEZpCiAjaW5jbHVk ZSAieGVucGNpLmgiDQogI2luY2x1ZGUgImlvL3hzX3dpcmUuaCINCiAjaW5jbHVkZSA8c3Rk bGliLmg+DQorDQorI3ByYWdtYSB3YXJuaW5nKCBkaXNhYmxlIDogNDIwNCApIA0KKyNwcmFn bWEgd2FybmluZyggZGlzYWJsZSA6IDQyMjEgKSANCiANCiBzdHJ1Y3QgeGVuYnVzX3JlcV9p bmZvDQogew0KQEAgLTg1LDcgKzg4LDcgQEAgc3RhdGljIGludCBhbGxvY2F0ZV94ZW5idXNf aWQodm9pZCkKIA0KICAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiIC0tPiBhbGxvY2F0ZV94 ZW5idXNfaWRcbiIpKTsNCiANCi0gIHdoaWxlICgxKQ0KKyAgZm9yICg7OykNCiAgIHsNCiAv LyAgICBzcGluX2xvY2soJnJlcV9sb2NrKTsNCiAgICAgaWYgKG5yX2xpdmVfcmVxcyA8IE5S X1JFUVMpDQpAQCAtOTUsNiArOTgsNyBAQCBzdGF0aWMgaW50IGFsbG9jYXRlX3hlbmJ1c19p ZCh2b2lkKQogICB9DQogDQogICBvX3Byb2JlID0gcHJvYmU7DQorDQogICBmb3IgKDs7KQ0K ICAgew0KICAgICBpZiAoIXJlcV9pbmZvW29fcHJvYmVdLkluX1VzZSkNCkBAIC0xNzksMTEg KzE4MywxMSBAQCBzdGF0aWMgdm9pZCB4Yl93cml0ZShpbnQgdHlwZSwgaW50IHJlcV9pCiB7 DQogICBYRU5TVE9SRV9SSU5HX0lEWCBwcm9kOw0KICAgaW50IHI7DQotICBpbnQgbGVuID0g MDsNCisgIHNpemVfdCBsZW4gPSAwOw0KICAgY29uc3Qgc3RydWN0IHdyaXRlX3JlcSAqY3Vy X3JlcTsNCi0gIGludCByZXFfb2ZmOw0KLSAgaW50IHRvdGFsX29mZjsNCi0gIGludCB0aGlz X2NodW5rOw0KKyAgc2l6ZV90IHJlcV9vZmY7DQorICBzaXplX3QgdG90YWxfb2ZmOw0KKyAg c2l6ZV90IHRoaXNfY2h1bms7DQogICBzdHJ1Y3QgeHNkX3NvY2ttc2cgbSA9IHt0eXBlLCBy ZXFfaWQsIHRyYW5zX2lkIH07DQogICBzdHJ1Y3Qgd3JpdGVfcmVxIGhlYWRlcl9yZXEgPSB7 ICZtLCBzaXplb2YobSkgfTsNCiANCkBAIC0zNDcsMTYgKzM1MSwxNSBAQCBjaGFyKiB4ZW5i dXNfd2FpdF9mb3JfdmFsdWUoY29uc3QgY2hhciogCiAvLyAgICBlbHNlDQogLy8gICAgICB3 YWl0X2Zvcl93YXRjaCgpOw0KIC8vICAgIH0NCi0gICAgcmV0dXJuIE5VTEw7DQorICBVTlJF RkVSRU5DRURfUEFSQU1FVEVSKHBhdGgpOw0KKyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUih2 YWx1ZSk7DQorDQorICByZXR1cm4gTlVMTDsNCiB9DQogDQogTlRTVEFUVVMNCiBYZW5CdXNf SW5pdCgpDQogew0KLSAgT0JKRUNUX0FUVFJJQlVURVMgb2E7DQotICBOVFNUQVRVUyBzdGF0 dXM7DQotICBpbnQgaTsNCi0NCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiAtLT4gWGVu QnVzX0luaXRcbiIpKTsNCiANCiAgIHhlbl9zdG9yZV9ldnRjaG4gPSBFdnRDaG5fR2V0WGVu U3RvcmVQb3J0KCk7DQpAQCAtNDE3LDYgKzQyMCw4IEBAIFhlbkJ1c19TdG9wKCkKICAgLy8g RG9lcyB0aGlzIGFjdHVhbGx5IHN0b3AgdGhlIHRocmVhZHM/Pz8NCiAgIFp3Q2xvc2UoWGVu QnVzX1dhdGNoVGhyZWFkSGFuZGxlKTsNCiAgIFp3Q2xvc2UoWGVuQnVzX1JlYWRUaHJlYWRI YW5kbGUpOw0KKw0KKyAgcmV0dXJuIFNUQVRVU19TVUNDRVNTOw0KIH0NCiANCiBjaGFyICoN CkBAIC00MjQsNyArNDI5LDcgQEAgWGVuQnVzX0xpc3QoeGVuYnVzX3RyYW5zYWN0aW9uX3Qg eGJ0LCBjbwogew0KICAgc3RydWN0IHhzZF9zb2NrbXNnICpyZXBseSwgKnJlcG1zZzsNCiAg IHN0cnVjdCB3cml0ZV9yZXEgcmVxW10gPSB7IHsgcHJlLCBzdHJsZW4ocHJlKSsxIH0gfTsN Ci0gIGludCBucl9lbGVtcywgeCwgaTsNCisgIFVMT05HIG5yX2VsZW1zLCB4LCBpOw0KICAg Y2hhciAqKnJlczsNCiAgIGNoYXIgKm1zZzsNCiANCkBAIC00ODgsNyArNDkzLDEwIEBAIFhl bkJ1c19SZWFkVGhyZWFkUHJvYyhQVk9JRCBTdGFydENvbnRleHQKICAgY2hhciAqcGF5bG9h ZDsNCiAgIGNoYXIgKnBhdGgsICp0b2tlbjsNCiANCi0gIHdoaWxlKFRSVUUpIHsNCisgIFVO UkVGRVJFTkNFRF9QQVJBTUVURVIoU3RhcnRDb250ZXh0KTsNCisNCisgIGZvciAoOzspDQor ICB7DQogICAgIEtlV2FpdEZvclNpbmdsZU9iamVjdCgmWGVuQnVzX1JlYWRUaHJlYWRFdmVu dCwgRXhlY3V0aXZlLCBLZXJuZWxNb2RlLCBGQUxTRSwgTlVMTCk7DQogICAgIEtkUHJpbnQo KF9fRFJJVkVSX05BTUUgIiAgICAgUmVhZFRocmVhZCBXb2tlbiAoQ291bnQgPSAlZClcbiIs IFJlYWRUaHJlYWRXYWl0Q291bnQrKykpOw0KICAgICB3aGlsZSAoeGVuX3N0b3JlX2ludGVy ZmFjZS0+cnNwX3Byb2QgIT0geGVuX3N0b3JlX2ludGVyZmFjZS0+cnNwX2NvbnMpIHsNCkBA IC01NTMsNyArNTYxLDkgQEAgWGVuQnVzX1dhdGNoVGhyZWFkUHJvYyhQVk9JRCBTdGFydENv bnRleAogICBpbnQgaW5kZXg7DQogICBQWEVOQlVTX1dBVENIX0VOVFJZIGVudHJ5Ow0KIA0K LSAgd2hpbGUoVFJVRSkNCisgIFVOUkVGRVJFTkNFRF9QQVJBTUVURVIoU3RhcnRDb250ZXh0 KTsNCisNCisgIGZvciAoOzspDQogICB7DQogICAgIEtlV2FpdEZvclNpbmdsZU9iamVjdCgm WGVuQnVzX1dhdGNoVGhyZWFkRXZlbnQsIEV4ZWN1dGl2ZSwgS2VybmVsTW9kZSwgRkFMU0Us IE5VTEwpOw0KICAgICB3aGlsZSAoWGVuQnVzX1dhdGNoUmluZ1JlYWRJbmRleCAhPSBYZW5C dXNfV2F0Y2hSaW5nV3JpdGVJbmRleCkNCkBAIC02MDYsNyArNjE2LDcgQEAgWGVuQnVzX0Fk ZFdhdGNoKHhlbmJ1c190cmFuc2FjdGlvbl90IHhidAogICByZXFbMF0uZGF0YSA9IFBhdGg7 DQogICByZXFbMF0ubGVuID0gc3RybGVuKFBhdGgpICsgMTsNCiANCi0gIHNwcmludGYoVG9r ZW4sICIlZCIsIGkpOw0KKyAgUnRsU3RyaW5nQ2JQcmludGZBKFRva2VuLCBBUlJBWV9TSVpF KFRva2VuKSwgIiVkIiwgaSk7DQogICByZXFbMV0uZGF0YSA9IFRva2VuOw0KICAgcmVxWzFd LmxlbiA9IHN0cmxlbihUb2tlbikgKyAxOw0KIA0KQEAgLTY1Niw3ICs2NjYsNyBAQCBYZW5C dXNfUmVtV2F0Y2goeGVuYnVzX3RyYW5zYWN0aW9uX3QgeGJ0CiAgIHJlcVswXS5kYXRhID0g UGF0aDsNCiAgIHJlcVswXS5sZW4gPSBzdHJsZW4oUGF0aCkgKyAxOw0KIA0KLSAgc3ByaW50 ZihUb2tlbiwgIiVkIiwgaSk7DQorICBSdGxTdHJpbmdDYlByaW50ZkEoVG9rZW4sIEFSUkFZ X1NJWkUoVG9rZW4pLCAiJWQiLCBpKTsNCiAgIHJlcVsxXS5kYXRhID0gVG9rZW47DQogICBy ZXFbMV0ubGVuID0gc3RybGVuKFRva2VuKSArIDE7DQogDQpAQCAtNzU1LDYgKzc2NSw5IEBA IFhlbkJ1c19JbnRlcnJ1cHQoUEtJTlRFUlJVUFQgSW50ZXJydXB0LCAKICAgS2VTZXRFdmVu dCgmWGVuQnVzX1JlYWRUaHJlYWRFdmVudCwgMSwgRkFMU0UpOw0KIA0KICAgS2RQcmludCgo X19EUklWRVJfTkFNRSAiIDwtLSBYZW5CdXNfSW50ZXJydXB0XG4iKSk7DQorDQorICAvKiBp cyB0aGlzIHJpZ2h0PyAqLw0KKyAgcmV0dXJuIFRSVUU7DQogfQ0KIA0KIGNoYXIgKg0KQEAg LTc2NCw3ICs3NzcsNyBAQCBYZW5CdXNfUHJpbnRmKHhlbmJ1c190cmFuc2FjdGlvbl90IHhi dCwgCiAgIGNoYXIgYnVmWzEwMjRdOw0KIA0KICAgdmFfc3RhcnQoYXAsIGZtdCk7DQotICB2 c3ByaW50ZihidWYsIGZtdCwgYXApOw0KKyAgUnRsU3RyaW5nQ2JWUHJpbnRmQShidWYsIEFS UkFZX1NJWkUoYnVmKSwgZm10LCBhcCk7DQogICB2YV9lbmQoYXApOw0KICAgcmV0dXJuIFhl bkJ1c19Xcml0ZSh4YnQsIHBhdGgsIGJ1Zik7DQogfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9m IGZpbGUKZGlmZiAtciBiMjZiZGJhNTBjNDEgeGVucGNpL3hlbnBjaS5jCi0tLSBhL3hlbnBj aS94ZW5wY2kuYwlUaHUgTm92IDAxIDE2OjIxOjI0IDIwMDcgLTA3MDAKKysrIGIveGVucGNp L3hlbnBjaS5jCUZyaSBOb3YgMDIgMDk6NTI6MzAgMjAwNyAtMDcwMApAQCAtOTYsMjkgKzk2 LDYgQEAgRHJpdmVyRW50cnkoUERSSVZFUl9PQkpFQ1QgRHJpdmVyT2JqZWN0LAogICByZXR1 cm4gc3RhdHVzOw0KIH0NCiANCi10eXBlZGVmIHN0cnVjdCB7DQotICAgICB1bnNpZ25lZCBu RUFYOw0KLSAgICAgdW5zaWduZWQgbkVCWDsNCi0gICAgIHVuc2lnbmVkIG5FQ1g7DQotICAg ICB1bnNpZ25lZCBuRURYOw0KLX0gQ1BVSURfT3V0cHV0LCAqUENQVUlEX091dHB1dDsNCi0N Ci1zdGF0aWMgdm9pZCBDUFVJRChQQ1BVSURfT3V0cHV0IHBSZXN1bHQsIGludCBuRnVuY3Rp b24pDQotew0KLSAgX19hc20gew0KLSAgICBtb3YgZWF4LCBuRnVuY3Rpb24NCi0gICAgeG9y IGVieCwgZWJ4DQotICAgIHhvciBlY3gsIGVieA0KLSAgICB4b3IgZWR4LCBlYngNCi0gICAg Y3B1aWQNCi0gICAgbW92IGVkaSwgcFJlc3VsdA0KLSAgICBtb3YgW2VkaS5uRUFYXSwgZWF4 DQotICAgIG1vdiBbZWRpLm5FQlhdLCBlYngNCi0gICAgbW92IFtlZGkubkVDWF0sIGVjeA0K LSAgICBtb3YgW2VkaS5uRURYXSwgZWR4DQotICB9DQotfQ0KLQ0KIHN0YXRpYyB2b2lkIFdS TVNSKHVuc2lnbmVkIGludCBtc3IsIFVMT05HTE9ORyB2YWwpDQogew0KICAgVUxPTkcgbG8s IGhpOw0KQEAgLTEzNSwyMiArMTEyLDIyIEBAIHN0YXRpYyBpbnQKIHN0YXRpYyBpbnQNCiBn ZXRfaHlwZXJjYWxsX3N0dWJzKCkNCiB7DQotICBDUFVJRF9PdXRwdXQgY3B1aWRfb3V0cHV0 Ow0KKyAgRFdPUkQzMiBjcHVpZF9vdXRwdXRbNF07DQogICBjaGFyIHhlbnNpZ1sxM107DQog ICBVTE9ORyBpOw0KICAgVUxPTkcgcGFnZXM7DQogICBVTE9ORyBtc3I7ICANCiANCi0gIENQ VUlEKCZjcHVpZF9vdXRwdXQsIDB4NDAwMDAwMDApOw0KLSAgKihVTE9ORyopKHhlbnNpZyAr IDApID0gY3B1aWRfb3V0cHV0Lm5FQlg7DQotICAqKFVMT05HKikoeGVuc2lnICsgNCkgPSBj cHVpZF9vdXRwdXQubkVDWDsNCi0gICooVUxPTkcqKSh4ZW5zaWcgKyA4KSA9IGNwdWlkX291 dHB1dC5uRURYOw0KLSAgeGVuc2lnWzEyXSA9IDA7DQotICBLZFByaW50KChfX0RSSVZFUl9O QU1FICIgWGVuIFNpZ25hdHVyZSA9ICVzLCBFQVggPSAweCUwOHhcbiIsIHhlbnNpZywgY3B1 aWRfb3V0cHV0Lm5FQVgpKTsNCisgIF9fY3B1aWQoY3B1aWRfb3V0cHV0LCAweDQwMDAwMDAw KTsNCisgICooVUxPTkcqKSh4ZW5zaWcgKyAwKSA9IGNwdWlkX291dHB1dFsxXTsNCisgICoo VUxPTkcqKSh4ZW5zaWcgKyA0KSA9IGNwdWlkX291dHB1dFsyXTsNCisgICooVUxPTkcqKSh4 ZW5zaWcgKyA4KSA9IGNwdWlkX291dHB1dFszXTsNCisgIHhlbnNpZ1sxMl0gPSAnXDAnOw0K KyAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiIFhlbiBTaWduYXR1cmUgPSAlcywgRUFYID0g MHglMDh4XG4iLCB4ZW5zaWcsIGNwdWlkX291dHB1dFswXSkpOw0KIA0KLSAgQ1BVSUQoJmNw dWlkX291dHB1dCwgMHg0MDAwMDAwMik7DQotICBwYWdlcyA9IGNwdWlkX291dHB1dC5uRUFY Ow0KLSAgbXNyID0gY3B1aWRfb3V0cHV0Lm5FQlg7DQorICBfX2NwdWlkKGNwdWlkX291dHB1 dCwgMHg0MDAwMDAwMik7DQorICBwYWdlcyA9IGNwdWlkX291dHB1dFswXTsNCisgIG1zciA9 IGNwdWlkX291dHB1dFsxXTsNCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiBIeXBlcmNh bGwgYXJlYSBpcyAldSBwYWdlcy5cbiIsIHBhZ2VzKSk7DQogDQogICBoeXBlcmNhbGxfc3R1 YnMgPSBFeEFsbG9jYXRlUG9vbFdpdGhUYWcoTm9uUGFnZWRQb29sLCBwYWdlcyAqIFBBR0Vf U0laRSwgWEVOUENJX1BPT0xfVEFHKTsNCkBAIC0yNjEsNyArMjM4LDYgQEAgWGVuUENJX0Fk ZERldmljZSgKICAgV0RGX0lPX1FVRVVFX0NPTkZJRyBpb1FDb25maWc7DQogICBXREZfSU5U RVJSVVBUX0NPTkZJRyBpbnRlcnJ1cHRDb25maWc7DQogICBQTlBfQlVTX0lORk9STUFUSU9O IGJ1c0luZm87DQotICBXREZfRkRPX0VWRU5UX0NBTExCQUNLUyBGZG9DYWxsYmFja3M7DQog DQogICAvL1BERVZJQ0VfT0JKRUNUIHBkbzsNCiAgIC8vVUxPTkcgcHJvcGVydHlBZGRyZXNz LCBsZW5ndGg7DQpAQCAtMzcxLDcgKzM0Nyw4IEBAIFhlblBDSV9QcmVwYXJlSGFyZHdhcmUo CiAgIE5UU1RBVFVTIHN0YXR1cyA9IFNUQVRVU19TVUNDRVNTOw0KICAgUENNX1BBUlRJQUxf UkVTT1VSQ0VfREVTQ1JJUFRPUiBkZXNjcmlwdG9yOw0KICAgVUxPTkcgaTsgIA0KLSAgUFhF TlBDSV9ERVZJQ0VfREFUQSBkZXZpY2VEYXRhID0gR2V0RGV2aWNlRGF0YShEZXZpY2UpOw0K Kw0KKyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUihEZXZpY2UpOw0KIA0KICAgS2RQcmludCgo X19EUklWRVJfTkFNRSAiIC0tPiBFdnREZXZpY2VQcmVwYXJlSGFyZHdhcmVcbiIpKTsNCiAN CkBAIC00NTcsNiArNDM0LDggQEAgWGVuUENJX1JlbGVhc2VIYXJkd2FyZShXREZERVZJQ0Ug RGV2aWNlLAogew0KICAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUihEZXZpY2UpOw0KICAgVU5S RUZFUkVOQ0VEX1BBUkFNRVRFUihSZXNvdXJjZXNUcmFuc2xhdGVkKTsNCisNCisgIHJldHVy biBTVEFUVVNfU1VDQ0VTUzsNCiB9DQogDQogc3RhdGljIE5UU1RBVFVTDQpAQCAtNDgzLDEz ICs0NjIsMTMgQEAgWGVuUENJX0QwRW50cnlQb3N0SW50ZXJydXB0c0VuYWJsZWQoV0RGRAog WGVuUENJX0QwRW50cnlQb3N0SW50ZXJydXB0c0VuYWJsZWQoV0RGREVWSUNFICBEZXZpY2Us IFdERl9QT1dFUl9ERVZJQ0VfU1RBVEUgUHJldmlvdXNTdGF0ZSkNCiB7DQogICBOVFNUQVRV UyBzdGF0dXMgPSBTVEFUVVNfU1VDQ0VTUzsNCi0gIE9CSkVDVF9BVFRSSUJVVEVTIG9hOw0K KyAgLy9PQkpFQ1RfQVRUUklCVVRFUyBvYTsNCiAgIGNoYXIgKnJlc3BvbnNlOw0KICAgY2hh ciAqbXNnVHlwZXM7DQogICBjaGFyICoqVHlwZXM7DQotICBjaGFyICptc2dJbnN0YW5jZXM7 DQotICBjaGFyICoqSW5zdGFuY2VzOw0KLSAgaW50IGksIGo7DQorICAvL2NoYXIgKm1zZ0lu c3RhbmNlczsNCisgIC8vY2hhciAqKkluc3RhbmNlczsNCisgIGludCBpOw0KICAgY2hhciBi dWZmZXJbMTI4XTsNCiANCiAgIFVOUkVGRVJFTkNFRF9QQVJBTUVURVIoRGV2aWNlKTsNCkBA IC01MTMsNyArNDkyLDcgQEAgWGVuUENJX0QwRW50cnlQb3N0SW50ZXJydXB0c0VuYWJsZWQo V0RGRAogICBpZiAoIW1zZ1R5cGVzKSB7DQogICAgIGZvciAoaSA9IDA7IFR5cGVzW2ldOyBp KyspDQogICAgIHsNCi0gICAgICBzcHJpbnRmKGJ1ZmZlciwgImRldmljZS8lcyIsIFR5cGVz W2ldKTsNCisgICAgICBSdGxTdHJpbmdDYlByaW50ZkEoYnVmZmVyLCBBUlJBWV9TSVpFKGJ1 ZmZlciksICJkZXZpY2UvJXMiLCBUeXBlc1tpXSk7DQogICAgICAgS2RQcmludCgoX19EUklW RVJfTkFNRSAiICAgICBscyBkZXZpY2VbJWRdIC0+ICVzXG4iLCBpLCBUeXBlc1tpXSkpOw0K ICAgICAgIFhlblBDSV9YZW5CdXNXYXRjaEhhbmRsZXIoYnVmZmVyLCBOVUxMKTsNCiAgICAg ICBFeEZyZWVQb29sV2l0aFRhZyhUeXBlc1tpXSwgWEVOUENJX1BPT0xfVEFHKTsNCkBAIC01 MzYsOSArNTE1LDEyIEBAIFhlblBDSV9EMEVudHJ5UG9zdEludGVycnVwdHNFbmFibGVkKFdE RkQKIH0NCiANCiBzdGF0aWMgTlRTVEFUVVMNCi1YZW5QQ0lfRDBFeGl0UHJlSW50ZXJydXB0 c0Rpc2FibGVkKFdERkRFVklDRSAgRGV2aWNlLCBXREZfUE9XRVJfREVWSUNFX1NUQVRFIFRh cmdldFN0YXRlKQ0KK1hlblBDSV9EMEV4aXRQcmVJbnRlcnJ1cHRzRGlzYWJsZWQoV0RGREVW SUNFIERldmljZSwgV0RGX1BPV0VSX0RFVklDRV9TVEFURSBUYXJnZXRTdGF0ZSkNCiB7DQog ICBOVFNUQVRVUyBzdGF0dXMgPSBTVEFUVVNfU1VDQ0VTUzsNCisNCisgIFVOUkVGRVJFTkNF RF9QQVJBTUVURVIoRGV2aWNlKTsNCisgIFVOUkVGRVJFTkNFRF9QQVJBTUVURVIoVGFyZ2V0 U3RhdGUpOw0KIA0KICAgWGVuQnVzX1N0b3AoKTsNCiANCkBAIC01ODYsNiArNTY4LDggQEAg WGVuUENJX0ludGVycnVwdEVuYWJsZShXREZJTlRFUlJVUFQgSW50ZQogICBzaGFyZWRfaW5m b19hcmVhLT52Y3B1X2luZm9bMF0uZXZ0Y2huX3VwY2FsbF9tYXNrID0gMDsNCiANCiAgIEtk UHJpbnQoKF9fRFJJVkVSX05BTUUgIiA8LS0gRXZ0SW50ZXJydXB0RW5hYmxlXG4iKSk7DQor DQorICByZXR1cm4gU1RBVFVTX1NVQ0NFU1M7DQogfQ0KIA0KIHN0YXRpYyBOVFNUQVRVUw0K QEAgLTU5OSw2ICs1ODMsOCBAQCBYZW5QQ0lfSW50ZXJydXB0RGlzYWJsZShXREZJTlRFUlJV UFQgSW50CiAgIHNoYXJlZF9pbmZvX2FyZWEtPnZjcHVfaW5mb1swXS5ldnRjaG5fdXBjYWxs X21hc2sgPSAxOw0KIA0KICAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiIDwtLSBFdnRJbnRl cnJ1cHREaXNhYmxlXG4iKSk7DQorDQorICByZXR1cm4gU1RBVFVTX1NVQ0NFU1M7DQogfQ0K IA0KIHN0YXRpYyBOVFNUQVRVUw0KQEAgLTYxMSwxMyArNTk3LDE0IEBAIFhlblBDSV9DaGls ZExpc3RDcmVhdGVEZXZpY2UoV0RGQ0hJTERMSVMKICAgWEVOX0lGQUNFX1hFTkJVUyBYZW5C dXNJbnRlcmZhY2U7DQogICBYRU5fSUZBQ0VfWEVOIFhlbkludGVyZmFjZTsNCiAgIFhFTl9J RkFDRV9HTlRUQkwgR250VGJsSW50ZXJmYWNlOw0KLSAgVU5JQ09ERV9TVFJJTkcgRGV2aWNl SWQ7DQogICBERUNMQVJFX1VOSUNPREVfU1RSSU5HX1NJWkUoYnVmZmVyLCAyMCk7DQogICBX REZfT0JKRUNUX0FUVFJJQlVURVMgUGRvQXR0cmlidXRlczsNCiAgIERFQ0xBUkVfQ09OU1Rf VU5JQ09ERV9TVFJJTkcoRGV2aWNlTG9jYXRpb24sIEwiWGVuIEJ1cyIpOw0KICAgV0RGX1FV RVJZX0lOVEVSRkFDRV9DT05GSUcgIHFpQ29uZmlnOw0KLSAgV0RGX1BET19FVkVOVF9DQUxM QkFDS1MgUGRvQ2FsbGJhY2tzOw0KICAgUFhFTlBDSV9YRU5fREVWSUNFX0RBVEEgQ2hpbGRE ZXZpY2VEYXRhID0gTlVMTDsNCisgIHNpemVfdCBwYXRoX2xlbjsNCisNCisgIFVOUkVGRVJF TkNFRF9QQVJBTUVURVIoQ2hpbGRMaXN0KTsNCiANCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05B TUUgIiAtLT4gQ2hpbGRMaXN0Q3JlYXRlRGV2aWNlXG4iKSk7DQogDQpAQCAtNzA0LDggKzY5 MSwxMiBAQCBYZW5QQ0lfQ2hpbGRMaXN0Q3JlYXRlRGV2aWNlKFdERkNISUxETElTCiANCiAg IFhlbkJ1c0ludGVyZmFjZS5JbnRlcmZhY2VIZWFkZXIuU2l6ZSA9IHNpemVvZihYZW5CdXNJ bnRlcmZhY2UpOw0KICAgWGVuQnVzSW50ZXJmYWNlLkludGVyZmFjZUhlYWRlci5WZXJzaW9u ID0gMTsNCi0gIFhlbkJ1c0ludGVyZmFjZS5JbnRlcmZhY2VIZWFkZXIuQ29udGV4dCA9IEV4 QWxsb2NhdGVQb29sV2l0aFRhZyhOb25QYWdlZFBvb2wsIChzdHJsZW4oWGVuSWRlbnRpZmlj YXRpb25EZXNjLT5QYXRoKSArIDEpLCBYRU5QQ0lfUE9PTF9UQUcpOw0KLSAgc3RyY3B5KFhl bkJ1c0ludGVyZmFjZS5JbnRlcmZhY2VIZWFkZXIuQ29udGV4dCwgWGVuSWRlbnRpZmljYXRp b25EZXNjLT5QYXRoKTsNCisgIHBhdGhfbGVuID0gc3RybGVuKFhlbklkZW50aWZpY2F0aW9u RGVzYy0+UGF0aCkgKyAxOw0KKyAgWGVuQnVzSW50ZXJmYWNlLkludGVyZmFjZUhlYWRlci5D b250ZXh0ID0gRXhBbGxvY2F0ZVBvb2xXaXRoVGFnKE5vblBhZ2VkUG9vbCwNCisgICAgcGF0 aF9sZW4sIFhFTlBDSV9QT09MX1RBRyk7DQorICAvKiBUT0RPOiBjaGVjayBmb3IgYWxsb2Mg ZmFpbCBoZXJlICovDQorICBSdGxTdHJpbmdDYkNvcHlBKFhlbkJ1c0ludGVyZmFjZS5JbnRl cmZhY2VIZWFkZXIuQ29udGV4dCwgcGF0aF9sZW4sIA0KKyAgICBYZW5JZGVudGlmaWNhdGlv bkRlc2MtPlBhdGgpOw0KICAgWGVuQnVzSW50ZXJmYWNlLlJlYWQgPSBYZW5CdXNfUmVhZDsN CiAgIFhlbkJ1c0ludGVyZmFjZS5Xcml0ZSA9IFhlbkJ1c19Xcml0ZTsNCiAgIFhlbkJ1c0lu dGVyZmFjZS5QcmludGYgPSBYZW5CdXNfUHJpbnRmOw0KQEAgLTc2NSw3ICs3NTYsNiBAQCBY ZW5QQ0lfWGVuQnVzV2F0Y2hIYW5kbGVyKGNoYXIgKlBhdGgsIFBWCiAgIFhFTlBDSV9JREVO VElGSUNBVElPTl9ERVNDUklQVElPTiBkZXNjcmlwdGlvbjsNCiAgIE5UU1RBVFVTIHN0YXR1 czsNCiAgIGludCBpOw0KLSAgY2hhciAqTmFtZVB0cjsNCiAgIGNoYXIgKipCaXRzOw0KICAg aW50IENvdW50Ow0KICAgV0RGQ0hJTERMSVNUIENoaWxkTGlzdDsNCkBAIC03NzMsOCArNzYz LDkgQEAgWGVuUENJX1hlbkJ1c1dhdGNoSGFuZGxlcihjaGFyICpQYXRoLCBQVgogICBXREZE RVZJQ0UgQ2hpbGREZXZpY2U7DQogICBQWEVOUENJX1hFTl9ERVZJQ0VfREFUQSBDaGlsZERl dmljZURhdGE7DQogDQotICANCiAgIEFOU0lfU1RSSU5HIEFuc2lCdWY7DQorDQorICBVTlJF RkVSRU5DRURfUEFSQU1FVEVSKERhdGEpOw0KIA0KICAgS2RQcmludCgoX19EUklWRVJfTkFN RSAiIC0tPiBIb3RQbHVnSGFuZGxlclxuIikpOw0KIA0KQEAgLTgzMCw4ICs4MjEsNiBAQCBY ZW5QQ0lfWGVuQnVzV2F0Y2hIYW5kbGVyKGNoYXIgKlBhdGgsIFBWCiAgIEV4RnJlZVBvb2xX aXRoVGFnKEJpdHMsIFhFTlBDSV9QT09MX1RBRyk7DQogICANCiAgIEtkUHJpbnQoKF9fRFJJ VkVSX05BTUUgIiA8LS0gSG90UGx1Z0hhbmRsZXJcbiIpKTsgIA0KLQ0KLSAgcmV0dXJuIHN0 YXR1czsNCiB9DQogDQogc3RhdGljIHZvaWQNCkBAIC04NDAsNiArODI5LDkgQEAgWGVuQnVz X1NodXRkb3duSGFuZGxlcihjaGFyICpQYXRoLCBQVk9JRAogICBjaGFyICp2YWx1ZTsNCiAg IHhlbmJ1c190cmFuc2FjdGlvbl90IHhidDsNCiAgIGludCByZXRyeTsNCisNCisgIFVOUkVG RVJFTkNFRF9QQVJBTUVURVIoUGF0aCk7DQorICBVTlJFRkVSRU5DRURfUEFSQU1FVEVSKFN0 YXJ0Q29udGV4dCk7DQogDQogICBLZFByaW50KChfX0RSSVZFUl9OQU1FICIgLS0+IFhlbkJ1 c19TaHV0ZG93bkhhbmRsZXJcbiIpKTsNCiANCkBAIC04NTMsNyArODQ1LDcgQEAgWGVuQnVz X1NodXRkb3duSGFuZGxlcihjaGFyICpQYXRoLCBQVk9JRAogICBpZiAodmFsdWUgIT0gTlVM TCAmJiBzdHJsZW4odmFsdWUpICE9IDApDQogICAgIFhlbkJ1c19Xcml0ZShYQlRfTklMLCBT SFVURE9XTl9QQVRILCAiIik7DQogDQotICBYZW5CdXNfRW5kVHJhbnNhY3Rpb24oJnhidCwg MCwgJnJldHJ5KTsNCisgIFhlbkJ1c19FbmRUcmFuc2FjdGlvbih4YnQsIDAsICZyZXRyeSk7 DQogICANCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiA8LS0gWGVuQnVzX1NodXRkb3du SGFuZGxlclxuIikpOw0KIH0NCkBAIC04NjcsOCArODU5LDExIEBAIFhlblBDSV9GaWx0ZXJS ZW1vdmVSZXNvdXJjZVJlcXVpcmVtZW50cygKICAgV0RGSU9SRVNMSVNUIFJlc291cmNlTGlz dDsNCiAgIFBJT19SRVNPVVJDRV9ERVNDUklQVE9SIERlc2NyaXB0b3I7DQogDQotICBpbnQg aSwgajsNCisgIFVMT05HIGk7DQorICBVTE9ORyBqOw0KICAgaW50IG9mZnNldDsNCisNCisg IFVOUkVGRVJFTkNFRF9QQVJBTUVURVIoRGV2aWNlKTsNCiANCiAgIEtkUHJpbnQoKF9fRFJJ VkVSX05BTUUgIiAtLT4gRmlsdGVyUmVtb3ZlUmVzb3VyY2VSZXF1aXJlbWVudHNcbiIpKTsN CiANCkBAIC05MjcsNyArOTIyLDEwIEBAIFhlblBDSV9GaWx0ZXJBZGRSZXNvdXJjZVJlcXVp cmVtZW50cyhXREYKICAgV0RGSU9SRVNMSVNUIFJlc291cmNlTGlzdDsNCiAgIFBJT19SRVNP VVJDRV9ERVNDUklQVE9SIERlc2NyaXB0b3I7DQogDQotICBpbnQgaSwgajsNCisgIFVMT05H IGk7DQorICBVTE9ORyBqOw0KKw0KKyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUihEZXZpY2Up Ow0KIA0KICAgS2RQcmludCgoX19EUklWRVJfTkFNRSAiIC0tPiBGaWx0ZXJBZGRSZXNvdXJj ZVJlcXVpcmVtZW50c1xuIikpOw0KIA0KQEAgLTk4MSw2ICs5NzksMTAgQEAgc3RhdGljIE5U U1RBVFVTCiBzdGF0aWMgTlRTVEFUVVMNCiBYZW5QQ0lfUmVtb3ZlQWRkZWRSZXNvdXJjZXMo V0RGREVWSUNFIERldmljZSwgV0RGQ01SRVNMSVNUIFJlc291cmNlc1JhdywgV0RGQ01SRVNM SVNUIFJlc291cmNlc1RyYW5zbGF0ZWQpDQogew0KKyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRF UihEZXZpY2UpOw0KKyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUihSZXNvdXJjZXNSYXcpOw0K KyAgVU5SRUZFUkVOQ0VEX1BBUkFNRVRFUihSZXNvdXJjZXNUcmFuc2xhdGVkKTsNCisNCiAg IEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiAtLT4gUmVtb3ZlQWRkZWRSZXNvdXJjZXNcbiIp KTsNCiAgIEtkUHJpbnQoKF9fRFJJVkVSX05BTUUgIiA8LS0gUmVtb3ZlQWRkZWRSZXNvdXJj ZXNcbiIpKTsNCiANCkBAIC05OTMsNiArOTk1LDggQEAgWGVuUENJX0RldmljZVJlc291cmNl UmVxdWlyZW1lbnRzUXVlcnkoVwogICBOVFNUQVRVUyAgc3RhdHVzOw0KICAgV0RGSU9SRVNM SVNUIHJlc291cmNlTGlzdDsNCiAgIElPX1JFU09VUkNFX0RFU0NSSVBUT1IgZGVzY3JpcHRv cjsNCisNCisgIFVOUkVGRVJFTkNFRF9QQVJBTUVURVIoRGV2aWNlKTsNCiANCiAgIEtkUHJp bnQoKF9fRFJJVkVSX05BTUUgIiAtLT4gRGV2aWNlUmVzb3VyY2VSZXF1aXJlbWVudHNRdWVy eVxuIikpOw0KIA0KZGlmZiAtciBiMjZiZGJhNTBjNDEgeGVucGNpL3hlbnBjaS5oCi0tLSBh L3hlbnBjaS94ZW5wY2kuaAlUaHUgTm92IDAxIDE2OjIxOjI0IDIwMDcgLTA3MDAKKysrIGIv eGVucGNpL3hlbnBjaS5oCUZyaSBOb3YgMDIgMDk6NTI6MzAgMjAwNyAtMDcwMApAQCAtMTkz LDcgKzE5Myw3IEBAIE5UU1RBVFVTCiBOVFNUQVRVUw0KIEV2dENobl9Ob3RpZnkoZXZ0Y2hu X3BvcnRfdCBQb3J0KTsNCiBldnRjaG5fcG9ydF90DQotRXZ0Q2huX0FsbG9jVW5ib3VuZChp bnQgRG9tYWluKTsNCitFdnRDaG5fQWxsb2NVbmJvdW5kKGRvbWlkX3QgRG9tYWluKTsNCiBO VFNUQVRVUw0KIEV2dENobl9Jbml0KCk7DQogDQpAQCAtMjAyLDcgKzIwMiw3IEBAIEJPT0xF QU4KIEJPT0xFQU4NCiBHbnRUYmxfRW5kQWNjZXNzKGdyYW50X3JlZl90IHJlZik7DQogDQot TlRTVEFUVVMNCitldnRjaG5fcG9ydF90DQogRXZ0Q2huX0dldFhlblN0b3JlUG9ydCgpOw0K IFBWT0lEDQogRXZ0Q2huX0dldFhlblN0b3JlUmluZ0FkZHIoKTsNCg== --------------030407050202080602030606 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 --------------030407050202080602030606--