From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44717) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1evSIe-0008N6-Sj for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:59 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1evSId-0005Wu-BB for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:56 -0400 Received: from mail-pg0-x231.google.com ([2607:f8b0:400e:c05::231]:40930) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1evSId-0005W7-2G for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:35:55 -0400 Received: by mail-pg0-x231.google.com with SMTP id g8so6863328pgv.7 for ; Mon, 12 Mar 2018 11:35:54 -0700 (PDT) From: Alexey Gerasimenko Date: Tue, 13 Mar 2018 04:34:06 +1000 Message-Id: In-Reply-To: References: In-Reply-To: References: Subject: [Qemu-devel] [RFC PATCH 21/30] xen/pt: Xen PCIe passthrough support for Q35: bypass PCIe topology check List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: xen-devel@lists.xenproject.org Cc: Alexey Gerasimenko , qemu-devel@nongnu.org, Stefano Stabellini , Anthony Perard Compared to legacy i440 system, there are certain difficulties while passing through PCIe devices to guest OSes like Windows 7 and above on platforms with native support of PCIe bus (in our case Q35). This problem is not applicable to older OSes like Windows XP -- PCIe passthrough on such OSes can be used normally as these OSes have no support for PCIe-specific features and treat all PCIe devices as legacy PCI ones. The problem manifests itself as "Code 10" error for a passed thru PCIe device in Windows Device Manager (along with exclamation mark on it). The device with such error do not function no matter the fact that Windows successfully booted while actually using this device, ex. as a primary VGA card with VBE features, LFB, etc. working properly during boot time. It doesn't matter which PCI class the device have -- the problem is common to GPUs, NIC cards, USB controllers, etc. In the same time, all these devices can be passed thru successfully using i440 emulation on same Windows 7+ OSes. The actual root cause of the problem lies in the fact that Windows kernel (PnP manager particularly) while processing StartDevice IRP refuses to continue to start the device and control flow actually doesn't even reach the IRP handler in the device driver at all. The real reason for this typically does not appear at the time PnP manager tries to start the device, but happens much earlier -- during the Windows boot stage, while enumerating devices on a PCI/PCIe bus in the Windows pci.sys driver. There is a set of checks for every discovered device on the PCIe bus. Failing some of them leads to marking the discovered PCIe device as 'invalid' by setting the flag. Later on, StartDevice attempt will fail due to this flag, finally resulting in Code 10 error. The actual check in pci.sys which results in the PCIe device being marked as 'invalid' in our case is a validation of upstream PCIe bus hierarchy to which passed through device belongs. Basically, pci.sys checks if the PCIe device has parent devices, such as PCIe Root Port or upstream PCIe switch. In our case the PCIe device has no parents and resides on bus 0 without eg. corresponding Root Port. Therefore, in order to resolve this problem in a architecturally correct way, we need to introduce to Xen some support of at least trivial non-flat PCI bus hierarchy. In very simplest case - just one virtual Root Port, on secondary bus of which all physical functions of the real passed thru device will reside, eg. GPU and its HDAudio function. This solution is not hard to implement technically, but there are multiple affecting limitations present in Xen (many related to each other) currently: - in many places the code is limited to use bus 0 only. This applicable to both hypervisor and supplemental modules like hvmloader. This limitation is enforced on API level -- many functions and interfaces allow to specify only devfn argument while bus 0 being implied. - lot of code assumes Type0 PCI config space layout only, while we need to handle Type1 PCI devices as well - currently there no way to assign to a guest domain even a simplest linked hierarchy of passed thru PCI devices. In some cases we might need to passthrough a real PCIe Switch/Root Port with his downstream child devices. - in a similar way Xen/hvmloader lacks the concept of IO/MMIO space nesting. Both code which does MMIO hole sizing and code which allocates BARs to MMIO hole have no idea of MMIO ranges nesting and their relations. In case of virtual Root Port we have basically an emulated PCI-PCI bridge with some parts of its MMIO range used for real MMIO ranges of passed through device(s). So, adding to Xen multiple PCI buses support will require a bit of effort and discussions regarding the actual design of the feature. Nevertheless, this task is crucial for PCI/GPU passthrough features of Xen to work properly. To summarize, we need to implement following things in the future: 1) Get rid of PCI bus 0 limitation everywhere. This could've been a simplest of subtasks but in reality this will require to change interfaces as well - AFAIR even adding a PCI device via QMP only allows to specify a device slot while we need to have some way to place the device on an arbitrary bus. 2) Fully or partially emulated PCI-PCI bridge which will provide a secondary bus for PCIe device placement - there might be a possibility to reuse some existing emulation QEMU provides. This also includes Type1 devices support. The task will become more complicated if there arise necessity, for example, to control the PCIe link for a passed through PCIe device. As PT device reset is mandatory in most cases, there might be a chance to encounter a situation when we need to retrain the PCIe link to restore PCIe link speed after the reset. In this case there will be a need to selectively translate accesses to certain registers of emulated PCIe Switch/Root Port to the corresponding physical upstream PCIe Switch/RootPort. This will require some interaction with Dom0, hopefully extending xen-pciback will be enough. 3) The concept of I/O and MMIO ranges nesting, for tasks like sizing MMIO hole or PCI BAR allocation. This one should be pretty simple. The actual implementation still is a matter to discuss of course. In the meantime there can be used a very simple workaround which allows to bypass pci.sys limitation for PCIe topology check - there exist one good exception to "must have upstream PCIe parent" rule of pci.sys. It's chipset-integrated devices. How pci.sys can tell if it deals with a chipset built-in device? It checks one of PCI Express Capability fields in the device PCI conf space. For chipset built-in devices this field will state "root complex integrated device" while in our case for a normal passed thru PCIe device there will be a "PCIe endpoint" type. So that's what the workaround does - it intercepts reading of this particular field for passed through devices and returns the "root complex integrated device" value for PCIe endpoints. This makes pci.sys happy and allows Windows 7 and above to use PT device on PCIe-capable system normally. So far no negative side effects were encountered while using this approach, so it's a good temporary solution until multiple PCI bus support will be added to Xen. Signed-off-by: Alexey Gerasimenko --- hw/xen/xen_pt_config_init.c | 60 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index 02e8c97f3c..91de215407 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -902,6 +902,55 @@ static int xen_pt_linkctrl2_reg_init(XenPCIPassthroughState *s, *data = reg_field; return 0; } +/* initialize PCI Express Capabilities register */ +static int xen_pt_pcie_capabilities_reg_init(XenPCIPassthroughState *s, + XenPTRegInfo *reg, + uint32_t real_offset, + uint32_t *data) +{ + uint8_t dev_type = get_pcie_device_type(s); + uint16_t reg_field; + + if (xen_host_pci_get_word(&s->real_device, + real_offset - reg->offset + PCI_EXP_FLAGS, + ®_field)) { + XEN_PT_ERR(&s->dev, "Error reading PCIe Capabilities reg\n"); + *data = 0; + return 0; + } + + /* + * Q35 workaround for Win7+ pci.sys PCIe topology check. + * As our PT device currently located on a bus 0, fake the + * device/port type field to the "Root Complex integrated device" + * value to bypass the check + */ + switch (dev_type) { + case PCI_EXP_TYPE_ENDPOINT: + case PCI_EXP_TYPE_LEG_END: + XEN_PT_LOG(&s->dev, "Original PCIe Capabilities reg is 0x%04X\n", + reg_field); + reg_field &= ~PCI_EXP_FLAGS_TYPE; + reg_field |= ((PCI_EXP_TYPE_RC_END /*9*/ << 4) & PCI_EXP_FLAGS_TYPE); + XEN_PT_LOG(&s->dev, "Q35 PCIe topology check workaround: " + "faking Capabilities reg to 0x%04X\n", reg_field); + break; + + case PCI_EXP_TYPE_ROOT_PORT: + case PCI_EXP_TYPE_UPSTREAM: + case PCI_EXP_TYPE_DOWNSTREAM: + case PCI_EXP_TYPE_PCI_BRIDGE: + case PCI_EXP_TYPE_PCIE_BRIDGE: + case PCI_EXP_TYPE_RC_END: + case PCI_EXP_TYPE_RC_EC: + default: + /* do nothing, return as is */ + break; + } + + *data = reg_field; + return 0; +} /* PCI Express Capability Structure reg static information table */ static XenPTRegInfo xen_pt_emu_reg_pcie[] = { @@ -916,6 +965,17 @@ static XenPTRegInfo xen_pt_emu_reg_pcie[] = { .u.b.read = xen_pt_byte_reg_read, .u.b.write = xen_pt_byte_reg_write, }, + /* PCI Express Capabilities Register */ + { + .offset = PCI_EXP_FLAGS, + .size = 2, + .init_val = 0x0000, + .ro_mask = 0xFFFF, + .emu_mask = 0xFFFF, + .init = xen_pt_pcie_capabilities_reg_init, + .u.w.read = xen_pt_word_reg_read, + .u.w.write = xen_pt_word_reg_write, + }, /* Device Capabilities reg */ { .offset = PCI_EXP_DEVCAP, -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey Gerasimenko Subject: [RFC PATCH 21/30] xen/pt: Xen PCIe passthrough support for Q35: bypass PCIe topology check Date: Tue, 13 Mar 2018 04:34:06 +1000 Message-ID: References: Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1evSIe-0008Ci-M7 for xen-devel@lists.xenproject.org; Mon, 12 Mar 2018 18:35:56 +0000 Received: by mail-pg0-x231.google.com with SMTP id w17so2797897pgq.8 for ; Mon, 12 Mar 2018 11:35:54 -0700 (PDT) In-Reply-To: In-Reply-To: References: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: xen-devel@lists.xenproject.org Cc: Anthony Perard , Stefano Stabellini , Alexey Gerasimenko , qemu-devel@nongnu.org List-Id: xen-devel@lists.xenproject.org Q29tcGFyZWQgdG8gbGVnYWN5IGk0NDAgc3lzdGVtLCB0aGVyZSBhcmUgY2VydGFpbiBkaWZmaWN1 bHRpZXMgd2hpbGUKcGFzc2luZyB0aHJvdWdoIFBDSWUgZGV2aWNlcyB0byBndWVzdCBPU2VzIGxp a2UgV2luZG93cyA3IGFuZCBhYm92ZQpvbiBwbGF0Zm9ybXMgd2l0aCBuYXRpdmUgc3VwcG9ydCBv ZiBQQ0llIGJ1cyAoaW4gb3VyIGNhc2UgUTM1KS4gVGhpcwpwcm9ibGVtIGlzIG5vdCBhcHBsaWNh YmxlIHRvIG9sZGVyIE9TZXMgbGlrZSBXaW5kb3dzIFhQIC0tIFBDSWUKcGFzc3Rocm91Z2ggb24g c3VjaCBPU2VzIGNhbiBiZSB1c2VkIG5vcm1hbGx5IGFzIHRoZXNlIE9TZXMgaGF2ZQpubyBzdXBw b3J0IGZvciBQQ0llLXNwZWNpZmljIGZlYXR1cmVzIGFuZCB0cmVhdCBhbGwgUENJZSBkZXZpY2Vz IGFzIGxlZ2FjeQpQQ0kgb25lcy4KClRoZSBwcm9ibGVtIG1hbmlmZXN0cyBpdHNlbGYgYXMgIkNv ZGUgMTAiIGVycm9yIGZvciBhIHBhc3NlZCB0aHJ1IFBDSWUKZGV2aWNlIGluIFdpbmRvd3MgRGV2 aWNlIE1hbmFnZXIgKGFsb25nIHdpdGggZXhjbGFtYXRpb24gbWFyayBvbiBpdCkuIFRoZQpkZXZp Y2Ugd2l0aCBzdWNoIGVycm9yIGRvIG5vdCBmdW5jdGlvbiBubyBtYXR0ZXIgdGhlIGZhY3QgdGhh dCBXaW5kb3dzCnN1Y2Nlc3NmdWxseSBib290ZWQgd2hpbGUgYWN0dWFsbHkgdXNpbmcgdGhpcyBk ZXZpY2UsIGV4LiBhcyBhIHByaW1hcnkgVkdBCmNhcmQgd2l0aCBWQkUgZmVhdHVyZXMsIExGQiwg ZXRjLiB3b3JraW5nIHByb3Blcmx5IGR1cmluZyBib290IHRpbWUuCkl0IGRvZXNuJ3QgbWF0dGVy IHdoaWNoIFBDSSBjbGFzcyB0aGUgZGV2aWNlIGhhdmUgLS0gdGhlIHByb2JsZW0gaXMgY29tbW9u CnRvIEdQVXMsIE5JQyBjYXJkcywgVVNCIGNvbnRyb2xsZXJzLCBldGMuIEluIHRoZSBzYW1lIHRp bWUsIGFsbCB0aGVzZQpkZXZpY2VzIGNhbiBiZSBwYXNzZWQgdGhydSBzdWNjZXNzZnVsbHkgdXNp bmcgaTQ0MCBlbXVsYXRpb24gb24gc2FtZQpXaW5kb3dzIDcrIE9TZXMuCgpUaGUgYWN0dWFsIHJv b3QgY2F1c2Ugb2YgdGhlIHByb2JsZW0gbGllcyBpbiB0aGUgZmFjdCB0aGF0IFdpbmRvd3Mga2Vy bmVsCihQblAgbWFuYWdlciBwYXJ0aWN1bGFybHkpIHdoaWxlIHByb2Nlc3NpbmcgU3RhcnREZXZp Y2UgSVJQIHJlZnVzZXMKdG8gY29udGludWUgdG8gc3RhcnQgdGhlIGRldmljZSBhbmQgY29udHJv bCBmbG93IGFjdHVhbGx5IGRvZXNuJ3QgZXZlbgpyZWFjaCB0aGUgSVJQIGhhbmRsZXIgaW4gdGhl IGRldmljZSBkcml2ZXIgYXQgYWxsLiBUaGUgcmVhbCByZWFzb24gZm9yCnRoaXMgdHlwaWNhbGx5 IGRvZXMgbm90IGFwcGVhciBhdCB0aGUgdGltZSBQblAgbWFuYWdlciB0cmllcyB0byBzdGFydCB0 aGUKZGV2aWNlLCBidXQgaGFwcGVucyBtdWNoIGVhcmxpZXIgLS0gZHVyaW5nIHRoZSBXaW5kb3dz IGJvb3Qgc3RhZ2UsIHdoaWxlCmVudW1lcmF0aW5nIGRldmljZXMgb24gYSBQQ0kvUENJZSBidXMg aW4gdGhlIFdpbmRvd3MgcGNpLnN5cyBkcml2ZXIuIFRoZXJlCmlzIGEgc2V0IG9mIGNoZWNrcyBm b3IgZXZlcnkgZGlzY292ZXJlZCBkZXZpY2Ugb24gdGhlIFBDSWUgYnVzLiBGYWlsaW5nCnNvbWUg b2YgdGhlbSBsZWFkcyB0byBtYXJraW5nIHRoZSBkaXNjb3ZlcmVkIFBDSWUgZGV2aWNlIGFzICdp bnZhbGlkJwpieSBzZXR0aW5nIHRoZSBmbGFnLiBMYXRlciBvbiwgU3RhcnREZXZpY2UgYXR0ZW1w dCB3aWxsIGZhaWwgZHVlIHRvIHRoaXMKZmxhZywgZmluYWxseSByZXN1bHRpbmcgaW4gQ29kZSAx MCBlcnJvci4KClRoZSBhY3R1YWwgY2hlY2sgaW4gcGNpLnN5cyB3aGljaCByZXN1bHRzIGluIHRo ZSBQQ0llIGRldmljZSBiZWluZyBtYXJrZWQKYXMgJ2ludmFsaWQnIGluIG91ciBjYXNlIGlzIGEg dmFsaWRhdGlvbiBvZiB1cHN0cmVhbSBQQ0llIGJ1cyBoaWVyYXJjaHkKdG8gd2hpY2ggcGFzc2Vk IHRocm91Z2ggZGV2aWNlIGJlbG9uZ3MuIEJhc2ljYWxseSwgcGNpLnN5cyBjaGVja3MgaWYgdGhl ClBDSWUgZGV2aWNlIGhhcyBwYXJlbnQgZGV2aWNlcywgc3VjaCBhcyBQQ0llIFJvb3QgUG9ydCBv ciB1cHN0cmVhbSBQQ0llCnN3aXRjaC4gSW4gb3VyIGNhc2UgdGhlIFBDSWUgZGV2aWNlIGhhcyBu byBwYXJlbnRzIGFuZCByZXNpZGVzIG9uIGJ1cwowIHdpdGhvdXQgZWcuIGNvcnJlc3BvbmRpbmcg Um9vdCBQb3J0LgoKVGhlcmVmb3JlLCBpbiBvcmRlciB0byByZXNvbHZlIHRoaXMgcHJvYmxlbSBp biBhIGFyY2hpdGVjdHVyYWxseSBjb3JyZWN0CndheSwgd2UgbmVlZCB0byBpbnRyb2R1Y2UgdG8g WGVuIHNvbWUgc3VwcG9ydCBvZiBhdCBsZWFzdCB0cml2aWFsIG5vbi1mbGF0ClBDSSBidXMgaGll cmFyY2h5LiBJbiB2ZXJ5IHNpbXBsZXN0IGNhc2UgLSBqdXN0IG9uZSB2aXJ0dWFsIFJvb3QgUG9y dCwKb24gc2Vjb25kYXJ5IGJ1cyBvZiB3aGljaCBhbGwgcGh5c2ljYWwgZnVuY3Rpb25zIG9mIHRo ZSByZWFsIHBhc3NlZCB0aHJ1CmRldmljZSB3aWxsIHJlc2lkZSwgZWcuIEdQVSBhbmQgaXRzIEhE QXVkaW8gZnVuY3Rpb24uCgpUaGlzIHNvbHV0aW9uIGlzIG5vdCBoYXJkIHRvIGltcGxlbWVudCB0 ZWNobmljYWxseSwgYnV0IHRoZXJlIGFyZSBtdWx0aXBsZQphZmZlY3RpbmcgbGltaXRhdGlvbnMg cHJlc2VudCBpbiBYZW4gKG1hbnkgcmVsYXRlZCB0byBlYWNoIG90aGVyKQpjdXJyZW50bHk6Cgot IGluIG1hbnkgcGxhY2VzIHRoZSBjb2RlIGlzIGxpbWl0ZWQgdG8gdXNlIGJ1cyAwIG9ubHkuIFRo aXMgYXBwbGljYWJsZQogIHRvIGJvdGggaHlwZXJ2aXNvciBhbmQgc3VwcGxlbWVudGFsIG1vZHVs ZXMgbGlrZSBodm1sb2FkZXIuIFRoaXMKICBsaW1pdGF0aW9uIGlzIGVuZm9yY2VkIG9uIEFQSSBs ZXZlbCAtLSBtYW55IGZ1bmN0aW9ucyBhbmQgaW50ZXJmYWNlcwogIGFsbG93IHRvIHNwZWNpZnkg b25seSBkZXZmbiBhcmd1bWVudCB3aGlsZSBidXMgMCBiZWluZyBpbXBsaWVkLgoKLSBsb3Qgb2Yg Y29kZSBhc3N1bWVzIFR5cGUwIFBDSSBjb25maWcgc3BhY2UgbGF5b3V0IG9ubHksIHdoaWxlIHdl IG5lZWQKICB0byBoYW5kbGUgVHlwZTEgUENJIGRldmljZXMgYXMgd2VsbAoKLSBjdXJyZW50bHkg dGhlcmUgbm8gd2F5IHRvIGFzc2lnbiB0byBhIGd1ZXN0IGRvbWFpbiBldmVuIGEgc2ltcGxlc3QK ICBsaW5rZWQgaGllcmFyY2h5IG9mIHBhc3NlZCB0aHJ1IFBDSSBkZXZpY2VzLiBJbiBzb21lIGNh c2VzIHdlIG1pZ2h0IG5lZWQKICB0byBwYXNzdGhyb3VnaCBhIHJlYWwgUENJZSBTd2l0Y2gvUm9v dCBQb3J0IHdpdGggaGlzIGRvd25zdHJlYW0gY2hpbGQKICBkZXZpY2VzLgoKLSBpbiBhIHNpbWls YXIgd2F5IFhlbi9odm1sb2FkZXIgbGFja3MgdGhlIGNvbmNlcHQgb2YgSU8vTU1JTyBzcGFjZQog IG5lc3RpbmcuIEJvdGggY29kZSB3aGljaCBkb2VzIE1NSU8gaG9sZSBzaXppbmcgYW5kIGNvZGUg d2hpY2ggYWxsb2NhdGVzCiAgQkFScyB0byBNTUlPIGhvbGUgaGF2ZSBubyBpZGVhIG9mIE1NSU8g cmFuZ2VzIG5lc3RpbmcgYW5kIHRoZWlyIHJlbGF0aW9ucy4KICBJbiBjYXNlIG9mIHZpcnR1YWwg Um9vdCBQb3J0IHdlIGhhdmUgYmFzaWNhbGx5IGFuIGVtdWxhdGVkIFBDSS1QQ0kgYnJpZGdlCiAg d2l0aCBzb21lIHBhcnRzIG9mIGl0cyBNTUlPIHJhbmdlIHVzZWQgZm9yIHJlYWwgTU1JTyByYW5n ZXMgb2YgcGFzc2VkCiAgdGhyb3VnaCBkZXZpY2UocykuCgpTbywgYWRkaW5nIHRvIFhlbiBtdWx0 aXBsZSBQQ0kgYnVzZXMgc3VwcG9ydCB3aWxsIHJlcXVpcmUgYSBiaXQgb2YgZWZmb3J0CmFuZCBk aXNjdXNzaW9ucyByZWdhcmRpbmcgdGhlIGFjdHVhbCBkZXNpZ24gb2YgdGhlIGZlYXR1cmUuICBO ZXZlcnRoZWxlc3MsCnRoaXMgdGFzayBpcyBjcnVjaWFsIGZvciBQQ0kvR1BVIHBhc3N0aHJvdWdo IGZlYXR1cmVzIG9mIFhlbiB0byB3b3JrCnByb3Blcmx5LgoKVG8gc3VtbWFyaXplLCB3ZSBuZWVk IHRvIGltcGxlbWVudCBmb2xsb3dpbmcgdGhpbmdzIGluIHRoZSBmdXR1cmU6CjEpIEdldCByaWQg b2YgUENJIGJ1cyAwIGxpbWl0YXRpb24gZXZlcnl3aGVyZS4gVGhpcyBjb3VsZCd2ZSBiZWVuCiAg YSBzaW1wbGVzdCBvZiBzdWJ0YXNrcyBidXQgaW4gcmVhbGl0eSB0aGlzIHdpbGwgcmVxdWlyZSB0 byBjaGFuZ2UKICBpbnRlcmZhY2VzIGFzIHdlbGwgLSBBRkFJUiBldmVuIGFkZGluZyBhIFBDSSBk ZXZpY2UgdmlhIFFNUCBvbmx5IGFsbG93cwogIHRvIHNwZWNpZnkgYSBkZXZpY2Ugc2xvdCB3aGls ZSB3ZSBuZWVkIHRvIGhhdmUgc29tZSB3YXkgdG8gcGxhY2UgdGhlCiAgZGV2aWNlIG9uIGFuIGFy Yml0cmFyeSBidXMuCgoyKSBGdWxseSBvciBwYXJ0aWFsbHkgZW11bGF0ZWQgUENJLVBDSSBicmlk Z2Ugd2hpY2ggd2lsbCBwcm92aWRlCiAgYSBzZWNvbmRhcnkgYnVzIGZvciBQQ0llIGRldmljZSBw bGFjZW1lbnQgLSB0aGVyZSBtaWdodCBiZSBhIHBvc3NpYmlsaXR5CiAgdG8gcmV1c2Ugc29tZSBl eGlzdGluZyBlbXVsYXRpb24gUUVNVSBwcm92aWRlcy4gVGhpcyBhbHNvIGluY2x1ZGVzIFR5cGUx CiAgZGV2aWNlcyBzdXBwb3J0LgogIFRoZSB0YXNrIHdpbGwgYmVjb21lIG1vcmUgY29tcGxpY2F0 ZWQgaWYgdGhlcmUgYXJpc2UgbmVjZXNzaXR5LCBmb3IKICBleGFtcGxlLCB0byBjb250cm9sIHRo ZSBQQ0llIGxpbmsgZm9yIGEgcGFzc2VkIHRocm91Z2ggUENJZSBkZXZpY2UuIEFzIFBUCiAgZGV2 aWNlIHJlc2V0IGlzIG1hbmRhdG9yeSBpbiBtb3N0IGNhc2VzLCB0aGVyZSBtaWdodCBiZSBhIGNo YW5jZQogIHRvIGVuY291bnRlciBhIHNpdHVhdGlvbiB3aGVuIHdlIG5lZWQgdG8gcmV0cmFpbiB0 aGUgUENJZSBsaW5rIHRvIHJlc3RvcmUKICBQQ0llIGxpbmsgc3BlZWQgYWZ0ZXIgdGhlIHJlc2V0 LiBJbiB0aGlzIGNhc2UgdGhlcmUgd2lsbCBiZSBhIG5lZWQKICB0byBzZWxlY3RpdmVseSB0cmFu c2xhdGUgYWNjZXNzZXMgdG8gY2VydGFpbiByZWdpc3RlcnMgb2YgZW11bGF0ZWQgUENJZQogIFN3 aXRjaC9Sb290IFBvcnQgdG8gdGhlIGNvcnJlc3BvbmRpbmcgcGh5c2ljYWwgdXBzdHJlYW0gUENJ ZQogIFN3aXRjaC9Sb290UG9ydC4gVGhpcyB3aWxsIHJlcXVpcmUgc29tZSBpbnRlcmFjdGlvbiB3 aXRoIERvbTAsIGhvcGVmdWxseQogIGV4dGVuZGluZyB4ZW4tcGNpYmFjayB3aWxsIGJlIGVub3Vn aC4KCjMpIFRoZSBjb25jZXB0IG9mIEkvTyBhbmQgTU1JTyByYW5nZXMgbmVzdGluZywgZm9yIHRh c2tzIGxpa2Ugc2l6aW5nIE1NSU8KICBob2xlIG9yIFBDSSBCQVIgYWxsb2NhdGlvbi4gVGhpcyBv bmUgc2hvdWxkIGJlIHByZXR0eSBzaW1wbGUuCgpUaGUgYWN0dWFsIGltcGxlbWVudGF0aW9uIHN0 aWxsIGlzIGEgbWF0dGVyIHRvIGRpc2N1c3Mgb2YgY291cnNlLgoKSW4gdGhlIG1lYW50aW1lIHRo ZXJlIGNhbiBiZSB1c2VkIGEgdmVyeSBzaW1wbGUgd29ya2Fyb3VuZCB3aGljaCBhbGxvd3MKdG8g YnlwYXNzIHBjaS5zeXMgbGltaXRhdGlvbiBmb3IgUENJZSB0b3BvbG9neSBjaGVjayAtIHRoZXJl IGV4aXN0IG9uZQpnb29kIGV4Y2VwdGlvbiB0byAibXVzdCBoYXZlIHVwc3RyZWFtIFBDSWUgcGFy ZW50IiBydWxlIG9mIHBjaS5zeXMuIEl0J3MKY2hpcHNldC1pbnRlZ3JhdGVkIGRldmljZXMuIEhv dyBwY2kuc3lzIGNhbiB0ZWxsIGlmIGl0IGRlYWxzIHdpdGgKYSBjaGlwc2V0IGJ1aWx0LWluIGRl dmljZT8gSXQgY2hlY2tzIG9uZSBvZiBQQ0kgRXhwcmVzcyBDYXBhYmlsaXR5IGZpZWxkcwppbiB0 aGUgZGV2aWNlIFBDSSBjb25mIHNwYWNlLiBGb3IgY2hpcHNldCBidWlsdC1pbiBkZXZpY2VzIHRo aXMgZmllbGQgd2lsbApzdGF0ZSAicm9vdCBjb21wbGV4IGludGVncmF0ZWQgZGV2aWNlIiB3aGls ZSBpbiBvdXIgIGNhc2UgZm9yIGEgbm9ybWFsCnBhc3NlZCB0aHJ1IFBDSWUgZGV2aWNlIHRoZXJl IHdpbGwgYmUgYSAiUENJZSBlbmRwb2ludCIgdHlwZS4gU28gdGhhdCdzCndoYXQgdGhlIHdvcmth cm91bmQgZG9lcyAtIGl0IGludGVyY2VwdHMgcmVhZGluZyBvZiB0aGlzIHBhcnRpY3VsYXIgZmll bGQKZm9yIHBhc3NlZCB0aHJvdWdoIGRldmljZXMgYW5kIHJldHVybnMgdGhlICJyb290IGNvbXBs ZXggaW50ZWdyYXRlZApkZXZpY2UiIHZhbHVlIGZvciBQQ0llIGVuZHBvaW50cy4gVGhpcyBtYWtl cyBwY2kuc3lzIGhhcHB5IGFuZCBhbGxvd3MKV2luZG93cyA3IGFuZCBhYm92ZSB0byB1c2UgUFQg ZGV2aWNlIG9uIFBDSWUtY2FwYWJsZSBzeXN0ZW0gbm9ybWFsbHkuClNvIGZhciBubyBuZWdhdGl2 ZSBzaWRlIGVmZmVjdHMgd2VyZSBlbmNvdW50ZXJlZCB3aGlsZSB1c2luZyB0aGlzCmFwcHJvYWNo LCBzbyBpdCdzIGEgZ29vZCB0ZW1wb3Jhcnkgc29sdXRpb24gdW50aWwgbXVsdGlwbGUgUENJIGJ1 cyBzdXBwb3J0CndpbGwgYmUgYWRkZWQgdG8gWGVuLgoKU2lnbmVkLW9mZi1ieTogQWxleGV5IEdl cmFzaW1lbmtvIDx4MTkxN3hAZ21haWwuY29tPgotLS0KIGh3L3hlbi94ZW5fcHRfY29uZmlnX2lu aXQuYyB8IDYwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog MSBmaWxlIGNoYW5nZWQsIDYwIGluc2VydGlvbnMoKykKCmRpZmYgLS1naXQgYS9ody94ZW4veGVu X3B0X2NvbmZpZ19pbml0LmMgYi9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKaW5kZXggMDJl OGM5N2YzYy4uOTFkZTIxNTQwNyAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5p dC5jCisrKyBiL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYwpAQCAtOTAyLDYgKzkwMiw1NSBA QCBzdGF0aWMgaW50IHhlbl9wdF9saW5rY3RybDJfcmVnX2luaXQoWGVuUENJUGFzc3Rocm91Z2hT dGF0ZSAqcywKICAgICAqZGF0YSA9IHJlZ19maWVsZDsKICAgICByZXR1cm4gMDsKIH0KKy8qIGlu aXRpYWxpemUgUENJIEV4cHJlc3MgQ2FwYWJpbGl0aWVzIHJlZ2lzdGVyICovCitzdGF0aWMgaW50 IHhlbl9wdF9wY2llX2NhcGFiaWxpdGllc19yZWdfaW5pdChYZW5QQ0lQYXNzdGhyb3VnaFN0YXRl ICpzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgWGVuUFRS ZWdJbmZvICpyZWcsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB1aW50MzJfdCByZWFsX29mZnNldCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHVpbnQzMl90ICpkYXRhKQoreworICAgIHVpbnQ4X3QgZGV2X3R5cGUgPSBn ZXRfcGNpZV9kZXZpY2VfdHlwZShzKTsKKyAgICB1aW50MTZfdCByZWdfZmllbGQ7CisKKyAgICBp ZiAoeGVuX2hvc3RfcGNpX2dldF93b3JkKCZzLT5yZWFsX2RldmljZSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVhbF9vZmZzZXQgLSByZWctPm9mZnNldCArIFBDSV9FWFBfRkxBR1Ms CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZyZWdfZmllbGQpKSB7CisgICAgICAgIFhF Tl9QVF9FUlIoJnMtPmRldiwgIkVycm9yIHJlYWRpbmcgUENJZSBDYXBhYmlsaXRpZXMgcmVnXG4i KTsKKyAgICAgICAgKmRhdGEgPSAwOworICAgICAgICByZXR1cm4gMDsKKyAgICB9CisKKyAgICAv KgorICAgICAqIFEzNSB3b3JrYXJvdW5kIGZvciBXaW43KyBwY2kuc3lzIFBDSWUgdG9wb2xvZ3kg Y2hlY2suCisgICAgICogQXMgb3VyIFBUIGRldmljZSBjdXJyZW50bHkgbG9jYXRlZCBvbiBhIGJ1 cyAwLCBmYWtlIHRoZQorICAgICAqIGRldmljZS9wb3J0IHR5cGUgZmllbGQgdG8gdGhlICJSb290 IENvbXBsZXggaW50ZWdyYXRlZCBkZXZpY2UiCisgICAgICogdmFsdWUgdG8gYnlwYXNzIHRoZSBj aGVjaworICAgICAqLworICAgIHN3aXRjaCAoZGV2X3R5cGUpIHsKKyAgICBjYXNlIFBDSV9FWFBf VFlQRV9FTkRQT0lOVDoKKyAgICBjYXNlIFBDSV9FWFBfVFlQRV9MRUdfRU5EOgorICAgICAgICBY RU5fUFRfTE9HKCZzLT5kZXYsICJPcmlnaW5hbCBQQ0llIENhcGFiaWxpdGllcyByZWcgaXMgMHgl MDRYXG4iLAorICAgICAgICAgICAgcmVnX2ZpZWxkKTsKKyAgICAgICAgcmVnX2ZpZWxkICY9IH5Q Q0lfRVhQX0ZMQUdTX1RZUEU7CisgICAgICAgIHJlZ19maWVsZCB8PSAoKFBDSV9FWFBfVFlQRV9S Q19FTkQgLyo5Ki8gPDwgNCkgJiBQQ0lfRVhQX0ZMQUdTX1RZUEUpOworICAgICAgICBYRU5fUFRf TE9HKCZzLT5kZXYsICJRMzUgUENJZSB0b3BvbG9neSBjaGVjayB3b3JrYXJvdW5kOiAiCisgICAg ICAgICAgICAgICAgICAgImZha2luZyBDYXBhYmlsaXRpZXMgcmVnIHRvIDB4JTA0WFxuIiwgcmVn X2ZpZWxkKTsKKyAgICAgICAgYnJlYWs7CisKKyAgICBjYXNlIFBDSV9FWFBfVFlQRV9ST09UX1BP UlQ6CisgICAgY2FzZSBQQ0lfRVhQX1RZUEVfVVBTVFJFQU06CisgICAgY2FzZSBQQ0lfRVhQX1RZ UEVfRE9XTlNUUkVBTToKKyAgICBjYXNlIFBDSV9FWFBfVFlQRV9QQ0lfQlJJREdFOgorICAgIGNh c2UgUENJX0VYUF9UWVBFX1BDSUVfQlJJREdFOgorICAgIGNhc2UgUENJX0VYUF9UWVBFX1JDX0VO RDoKKyAgICBjYXNlIFBDSV9FWFBfVFlQRV9SQ19FQzoKKyAgICBkZWZhdWx0OgorICAgICAgICAv KiBkbyBub3RoaW5nLCByZXR1cm4gYXMgaXMgKi8KKyAgICAgICAgYnJlYWs7CisgICAgfQorCisg ICAgKmRhdGEgPSByZWdfZmllbGQ7CisgICAgcmV0dXJuIDA7Cit9CiAKIC8qIFBDSSBFeHByZXNz IENhcGFiaWxpdHkgU3RydWN0dXJlIHJlZyBzdGF0aWMgaW5mb3JtYXRpb24gdGFibGUgKi8KIHN0 YXRpYyBYZW5QVFJlZ0luZm8geGVuX3B0X2VtdV9yZWdfcGNpZVtdID0gewpAQCAtOTE2LDYgKzk2 NSwxNyBAQCBzdGF0aWMgWGVuUFRSZWdJbmZvIHhlbl9wdF9lbXVfcmVnX3BjaWVbXSA9IHsKICAg ICAgICAgLnUuYi5yZWFkICAgPSB4ZW5fcHRfYnl0ZV9yZWdfcmVhZCwKICAgICAgICAgLnUuYi53 cml0ZSAgPSB4ZW5fcHRfYnl0ZV9yZWdfd3JpdGUsCiAgICAgfSwKKyAgICAvKiBQQ0kgRXhwcmVz cyBDYXBhYmlsaXRpZXMgUmVnaXN0ZXIgKi8KKyAgICB7CisgICAgICAgIC5vZmZzZXQgICAgID0g UENJX0VYUF9GTEFHUywKKyAgICAgICAgLnNpemUgICAgICAgPSAyLAorICAgICAgICAuaW5pdF92 YWwgICA9IDB4MDAwMCwKKyAgICAgICAgLnJvX21hc2sgICAgPSAweEZGRkYsCisgICAgICAgIC5l bXVfbWFzayAgID0gMHhGRkZGLAorICAgICAgICAuaW5pdCAgICAgICA9IHhlbl9wdF9wY2llX2Nh cGFiaWxpdGllc19yZWdfaW5pdCwKKyAgICAgICAgLnUudy5yZWFkICAgPSB4ZW5fcHRfd29yZF9y ZWdfcmVhZCwKKyAgICAgICAgLnUudy53cml0ZSAgPSB4ZW5fcHRfd29yZF9yZWdfd3JpdGUsCisg ICAgfSwKICAgICAvKiBEZXZpY2UgQ2FwYWJpbGl0aWVzIHJlZyAqLwogICAgIHsKICAgICAgICAg Lm9mZnNldCAgICAgPSBQQ0lfRVhQX0RFVkNBUCwKLS0gCjIuMTEuMAoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QK WGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5v cmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw=