From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:44987) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1evSJC-0000R8-K2 for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:33 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1evSJB-0005mL-Bm for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:30 -0400 Received: from mail-pg0-x244.google.com ([2607:f8b0:400e:c05::244]:37762) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1evSJB-0005m1-44 for qemu-devel@nongnu.org; Mon, 12 Mar 2018 14:36:29 -0400 Received: by mail-pg0-x244.google.com with SMTP id t186so292099pgc.4 for ; Mon, 12 Mar 2018 11:36:29 -0700 (PDT) From: Alexey Gerasimenko Date: Tue, 13 Mar 2018 04:34:15 +1000 Message-Id: In-Reply-To: References: In-Reply-To: References: Subject: [Qemu-devel] [RFC PATCH 30/30] xen/pt: add VC/VC9/MFVC PCIe Extended Capabilities descriptors and sizing 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 Virtual Channel/MFVC capabilities are relatively useless for emulation (passing through accesses to them should be enough in most cases) yet they have hardest format of all PCIe Extended Capabilities, mostly because VC capability format allows the sparse config space layout with gaps between the parts which make up the VC capability. We have the main capability body followed by variable number of entries where each entry may additionally reference the arbitration table outside main capability body. There are no constrains on these arbitration table offsets -- in theory, they may reside outside the VC capability range anywhere in PCIe extended config space. Also, every arbitration table size is not fixed - it depends on current VC/Port Arbitration Select field value. To simplify things, this patch assume that changing VC/Port Arbitration Select value (i.e. resizing arbitration tables) do not cause arbitration table offsets to change. Normally the device must place arbitration tables considering their maximum size, not current one. Maximum arbitration table size depends on VC/Port Arbitration Capability bitmask -- this is what actually used to calculate the arbitration table size. Signed-off-by: Alexey Gerasimenko --- hw/xen/xen_pt_config_init.c | 192 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 192 insertions(+) diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index b03b071b22..ab9c233d84 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -2177,6 +2177,174 @@ static int xen_pt_ext_cap_rebar_size_init(XenPCIPassthroughState *s, return ret; } +/* get VC/VC9/MFVC Extended Capability register group size */ +static uint32_t get_arb_table_len_max(XenPCIPassthroughState *s, + uint32_t max_bit_supported, + uint32_t arb_cap) +{ + int n_bit; + uint32_t table_max_size = 0; + + if (!arb_cap) { + return 0; + } + + for (n_bit = 7; n_bit >= 0 && !(arb_cap & (1 << n_bit)); n_bit--); + + if (n_bit > max_bit_supported) { + XEN_PT_ERR(&s->dev, "Warning: encountered unknown VC arbitration " + "capability supported: 0x%02x\n", (uint8_t) arb_cap); + } + + switch (n_bit) { + case 0: break; + case 1: return 32; + case 2: return 64; + case 3: /*128 too*/ + case 4: return 128; + default: + table_max_size = 8 << n_bit; + } + + return table_max_size; +} + +#define GET_ARB_TABLE_OFFSET(x) (((x) >> 24) * 0x10) +#define GET_VC_ARB_CAPABILITY(x) ((x) & 0xFF) +#define ARB_TABLE_ENTRY_SIZE_BITS(x) (1 << (((x) & PCI_VC_CAP1_ARB_SIZE)\ + >> 10)) +static int xen_pt_ext_cap_vchan_size_init(XenPCIPassthroughState *s, + const XenPTRegGroupInfo *grp_reg, + uint32_t base_offset, + uint32_t *size) +{ + uint32_t header; + uint32_t vc_cap_max_size = PCIE_CONFIG_SPACE_SIZE - base_offset; + uint32_t next_ptr; + uint32_t arb_table_start_max = 0, arb_table_end_max = 0; + uint32_t port_vc_cap1, port_vc_cap2, vc_rsrc_cap; + uint32_t ext_vc_count = 0; + uint32_t arb_table_entry_size; /* in bits */ + const char *cap_name; + int ret; + int i; + + ret = xen_host_pci_get_long(&s->real_device, base_offset, &header); + if (ret) { + goto err_read; + } + + next_ptr = PCI_EXT_CAP_NEXT(header); + + switch (PCI_EXT_CAP_ID(header)) { + case PCI_EXT_CAP_ID_VC: + case PCI_EXT_CAP_ID_VC9: + cap_name = "Virtual Channel"; + break; + case PCI_EXT_CAP_ID_MFVC: + cap_name = "Multi-Function VC"; + break; + default: + XEN_PT_ERR(&s->dev, "Unknown VC Extended Capability ID " + "encountered: 0x%04x\n", PCI_EXT_CAP_ID(header)); + return -1; + } + + if (next_ptr && next_ptr > base_offset) { + vc_cap_max_size = next_ptr - base_offset; + } + + ret = xen_host_pci_get_long(&s->real_device, + base_offset + PCI_VC_PORT_CAP1, + &port_vc_cap1); + if (ret) { + goto err_read; + } + + ret = xen_host_pci_get_long(&s->real_device, + base_offset + PCI_VC_PORT_CAP2, + &port_vc_cap2); + if (ret) { + goto err_read; + } + + ext_vc_count = port_vc_cap1 & PCI_VC_CAP1_EVCC; + + arb_table_start_max = GET_ARB_TABLE_OFFSET(port_vc_cap2); + + /* check arbitration table offset for validity */ + if (arb_table_start_max >= vc_cap_max_size) { + XEN_PT_ERR(&s->dev, "Warning: VC arbitration table offset points " + "outside the expected range: %#04x\n", + (uint16_t) arb_table_start_max); + /* skip this arbitration table */ + arb_table_start_max = 0; + } + + if (arb_table_start_max) { + uint32_t vc_arb_cap = GET_VC_ARB_CAPABILITY(port_vc_cap2); + uint32_t num_phases = get_arb_table_len_max(s, 3, vc_arb_cap); + uint32_t arb_tbl_sz = QEMU_ALIGN_UP(num_phases * 4, 32) / 8; + + arb_table_end_max = base_offset + arb_table_start_max + arb_tbl_sz; + } + + /* get Function/Port Arbitration Table Entry size */ + arb_table_entry_size = ARB_TABLE_ENTRY_SIZE_BITS(port_vc_cap1); + + /* process all VC Resource entries */ + for (i = 0; i < ext_vc_count; i++) { + uint32_t arb_table_offset; + + /* read VC Resource Capability */ + ret = xen_host_pci_get_long(&s->real_device, + base_offset + PCI_VC_RES_CAP + i * PCI_CAP_VC_PER_VC_SIZEOF, + &vc_rsrc_cap); + if (ret) { + goto err_read; + } + + arb_table_offset = GET_ARB_TABLE_OFFSET(vc_rsrc_cap); + + if (arb_table_offset > arb_table_start_max) { + /* check arbitration table offset for validity */ + if (arb_table_offset >= vc_cap_max_size) { + XEN_PT_ERR(&s->dev, "Warning: Port/Function arbitration table " + "offset points outside the expected range: %#04x\n", + (uint16_t) arb_table_offset); + /* skip this arbitration table */ + arb_table_offset = 0; + } else { + arb_table_start_max = arb_table_offset; + } + + if (arb_table_offset) { + uint32_t vc_arb_cap = GET_VC_ARB_CAPABILITY(vc_rsrc_cap); + uint32_t num_phases = get_arb_table_len_max(s, 5, vc_arb_cap); + uint32_t arb_tbl_sz = + QEMU_ALIGN_UP(num_phases * arb_table_entry_size, 32) / 8; + + arb_table_end_max = base_offset + arb_table_offset + arb_tbl_sz; + } + } + } + + if (arb_table_end_max) { + *size = arb_table_end_max - base_offset; + } else { + *size = PCI_CAP_VC_BASE_SIZEOF + + ext_vc_count * PCI_CAP_VC_PER_VC_SIZEOF; + } + + log_pcie_extended_cap(s, cap_name, base_offset, *size); + return 0; + +err_read: + XEN_PT_ERR(&s->dev, "Error while reading VC Extended Capability\n"); + return ret; +} + + static const XenPTRegGroupInfo xen_pt_emu_reg_grps[] = { /* Header Type0 reg group */ { @@ -2515,6 +2683,30 @@ static const XenPTRegGroupInfo xen_pt_emu_reg_grps[] = { .grp_size = 0xFF, .size_init = xen_pt_ext_cap_rebar_size_init, }, + /* Virtual Channel Extended Capability reg group (2) */ + { + .grp_id = PCIE_EXT_CAP_ID(PCI_EXT_CAP_ID_VC), + .grp_type = XEN_PT_GRP_TYPE_EMU, + .grp_size = 0xFF, + .size_init = xen_pt_ext_cap_vchan_size_init, + .emu_regs = xen_pt_ext_cap_emu_reg_dummy, + }, + /* Virtual Channel Extended Capability reg group (9) */ + { + .grp_id = PCIE_EXT_CAP_ID(PCI_EXT_CAP_ID_VC9), + .grp_type = XEN_PT_GRP_TYPE_EMU, + .grp_size = 0xFF, + .size_init = xen_pt_ext_cap_vchan_size_init, + .emu_regs = xen_pt_ext_cap_emu_reg_dummy, + }, + /* Multi-Function Virtual Channel Extended Capability reg group */ + { + .grp_id = PCIE_EXT_CAP_ID(PCI_EXT_CAP_ID_MFVC), + .grp_type = XEN_PT_GRP_TYPE_EMU, + .grp_size = 0xFF, + .size_init = xen_pt_ext_cap_vchan_size_init, + .emu_regs = xen_pt_ext_cap_emu_reg_dummy, + }, { .grp_size = 0, }, -- 2.11.0 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey Gerasimenko Subject: [RFC PATCH 30/30] xen/pt: add VC/VC9/MFVC PCIe Extended Capabilities descriptors and sizing Date: Tue, 13 Mar 2018 04:34:15 +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 1evSJB-0000aa-TA for xen-devel@lists.xenproject.org; Mon, 12 Mar 2018 18:36:29 +0000 Received: by mail-pg0-x243.google.com with SMTP id s13so3960188pgn.12 for ; Mon, 12 Mar 2018 11:36:29 -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 VmlydHVhbCBDaGFubmVsL01GVkMgY2FwYWJpbGl0aWVzIGFyZSByZWxhdGl2ZWx5IHVzZWxlc3Mg Zm9yIGVtdWxhdGlvbgoocGFzc2luZyB0aHJvdWdoIGFjY2Vzc2VzIHRvIHRoZW0gc2hvdWxkIGJl IGVub3VnaCBpbiBtb3N0IGNhc2VzKSB5ZXQgdGhleQpoYXZlIGhhcmRlc3QgZm9ybWF0IG9mIGFs bCBQQ0llIEV4dGVuZGVkIENhcGFiaWxpdGllcywgbW9zdGx5IGJlY2F1c2UKVkMgY2FwYWJpbGl0 eSBmb3JtYXQgYWxsb3dzIHRoZSBzcGFyc2UgY29uZmlnIHNwYWNlIGxheW91dCB3aXRoIGdhcHMK YmV0d2VlbiB0aGUgcGFydHMgd2hpY2ggbWFrZSB1cCB0aGUgVkMgY2FwYWJpbGl0eS4KCldlIGhh dmUgdGhlIG1haW4gY2FwYWJpbGl0eSBib2R5IGZvbGxvd2VkIGJ5IHZhcmlhYmxlIG51bWJlciBv ZiBlbnRyaWVzCndoZXJlIGVhY2ggZW50cnkgbWF5IGFkZGl0aW9uYWxseSByZWZlcmVuY2UgdGhl IGFyYml0cmF0aW9uIHRhYmxlIG91dHNpZGUKbWFpbiBjYXBhYmlsaXR5IGJvZHkuIFRoZXJlIGFy ZSBubyBjb25zdHJhaW5zIG9uIHRoZXNlIGFyYml0cmF0aW9uIHRhYmxlCm9mZnNldHMgLS0gaW4g dGhlb3J5LCB0aGV5IG1heSByZXNpZGUgb3V0c2lkZSB0aGUgVkMgY2FwYWJpbGl0eSByYW5nZQph bnl3aGVyZSBpbiBQQ0llIGV4dGVuZGVkIGNvbmZpZyBzcGFjZS4gQWxzbywgZXZlcnkgYXJiaXRy YXRpb24gdGFibGUgc2l6ZQppcyBub3QgZml4ZWQgLSBpdCBkZXBlbmRzIG9uIGN1cnJlbnQgVkMv UG9ydCBBcmJpdHJhdGlvbiBTZWxlY3QgZmllbGQKdmFsdWUuCgpUbyBzaW1wbGlmeSB0aGluZ3Ms IHRoaXMgcGF0Y2ggYXNzdW1lIHRoYXQgY2hhbmdpbmcgVkMvUG9ydCBBcmJpdHJhdGlvbgpTZWxl Y3QgdmFsdWUgKGkuZS4gcmVzaXppbmcgYXJiaXRyYXRpb24gdGFibGVzKSBkbyBub3QgY2F1c2Ug YXJiaXRyYXRpb24KdGFibGUgb2Zmc2V0cyB0byBjaGFuZ2UuIE5vcm1hbGx5IHRoZSBkZXZpY2Ug bXVzdCBwbGFjZSBhcmJpdHJhdGlvbiB0YWJsZXMKY29uc2lkZXJpbmcgdGhlaXIgbWF4aW11bSBz aXplLCBub3QgY3VycmVudCBvbmUuIE1heGltdW0gYXJiaXRyYXRpb24gdGFibGUKc2l6ZSBkZXBl bmRzIG9uIFZDL1BvcnQgQXJiaXRyYXRpb24gQ2FwYWJpbGl0eSBiaXRtYXNrIC0tIHRoaXMgaXMg d2hhdAphY3R1YWxseSB1c2VkIHRvIGNhbGN1bGF0ZSB0aGUgYXJiaXRyYXRpb24gdGFibGUgc2l6 ZS4KClNpZ25lZC1vZmYtYnk6IEFsZXhleSBHZXJhc2ltZW5rbyA8eDE5MTd4QGdtYWlsLmNvbT4K LS0tCiBody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMgfCAxOTIgKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysKIDEgZmlsZSBjaGFuZ2VkLCAxOTIgaW5zZXJ0aW9u cygrKQoKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYyBiL2h3L3hlbi94 ZW5fcHRfY29uZmlnX2luaXQuYwppbmRleCBiMDNiMDcxYjIyLi5hYjljMjMzZDg0IDEwMDY0NAot LS0gYS9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKKysrIGIvaHcveGVuL3hlbl9wdF9jb25m aWdfaW5pdC5jCkBAIC0yMTc3LDYgKzIxNzcsMTc0IEBAIHN0YXRpYyBpbnQgeGVuX3B0X2V4dF9j YXBfcmViYXJfc2l6ZV9pbml0KFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsCiAgICAgcmV0dXJu IHJldDsKIH0KIAorLyogZ2V0IFZDL1ZDOS9NRlZDIEV4dGVuZGVkIENhcGFiaWxpdHkgcmVnaXN0 ZXIgZ3JvdXAgc2l6ZSAqLworc3RhdGljIHVpbnQzMl90IGdldF9hcmJfdGFibGVfbGVuX21heChY ZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1aW50MzJfdCBtYXhfYml0X3N1cHBvcnRlZCwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgdWludDMyX3QgYXJiX2NhcCkKK3sKKyAgICBpbnQgbl9iaXQ7Cisg ICAgdWludDMyX3QgdGFibGVfbWF4X3NpemUgPSAwOworCisgICAgaWYgKCFhcmJfY2FwKSB7Cisg ICAgICAgIHJldHVybiAwOworICAgIH0KKworICAgIGZvciAobl9iaXQgPSA3OyBuX2JpdCA+PSAw ICYmICEoYXJiX2NhcCAmICgxIDw8IG5fYml0KSk7IG5fYml0LS0pOworCisgICAgaWYgKG5fYml0 ID4gbWF4X2JpdF9zdXBwb3J0ZWQpIHsKKyAgICAgICAgWEVOX1BUX0VSUigmcy0+ZGV2LCAiV2Fy bmluZzogZW5jb3VudGVyZWQgdW5rbm93biBWQyBhcmJpdHJhdGlvbiAiCisgICAgICAgICAgICAg ICAgICAgImNhcGFiaWxpdHkgc3VwcG9ydGVkOiAweCUwMnhcbiIsICh1aW50OF90KSBhcmJfY2Fw KTsKKyAgICB9CisKKyAgICBzd2l0Y2ggKG5fYml0KSB7CisgICAgY2FzZSAwOiBicmVhazsKKyAg ICBjYXNlIDE6IHJldHVybiAzMjsKKyAgICBjYXNlIDI6IHJldHVybiA2NDsKKyAgICBjYXNlIDM6 IC8qMTI4IHRvbyovCisgICAgY2FzZSA0OiByZXR1cm4gMTI4OworICAgIGRlZmF1bHQ6CisgICAg ICAgIHRhYmxlX21heF9zaXplID0gOCA8PCBuX2JpdDsKKyAgICB9CisKKyAgICByZXR1cm4gdGFi bGVfbWF4X3NpemU7Cit9CisKKyNkZWZpbmUgR0VUX0FSQl9UQUJMRV9PRkZTRVQoeCkgICAgICAg ICAgICgoKHgpID4+IDI0KSAqIDB4MTApCisjZGVmaW5lIEdFVF9WQ19BUkJfQ0FQQUJJTElUWSh4 KSAgICAgICAgICAoKHgpICYgMHhGRikKKyNkZWZpbmUgQVJCX1RBQkxFX0VOVFJZX1NJWkVfQklU Uyh4KSAgICAgICgxIDw8ICgoKHgpICYgUENJX1ZDX0NBUDFfQVJCX1NJWkUpXAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPj4gMTApKQorc3RhdGljIGludCB4ZW5f cHRfZXh0X2NhcF92Y2hhbl9zaXplX2luaXQoWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSAqcywKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFhlblBUUmVnR3Jv dXBJbmZvICpncnBfcmVnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdWludDMyX3QgYmFzZV9vZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB1aW50MzJfdCAqc2l6ZSkKK3sKKyAgICB1aW50MzJfdCBoZWFkZXI7CisgICAg dWludDMyX3QgdmNfY2FwX21heF9zaXplID0gUENJRV9DT05GSUdfU1BBQ0VfU0laRSAtIGJhc2Vf b2Zmc2V0OworICAgIHVpbnQzMl90IG5leHRfcHRyOworICAgIHVpbnQzMl90IGFyYl90YWJsZV9z dGFydF9tYXggPSAwLCBhcmJfdGFibGVfZW5kX21heCA9IDA7CisgICAgdWludDMyX3QgcG9ydF92 Y19jYXAxLCBwb3J0X3ZjX2NhcDIsIHZjX3JzcmNfY2FwOworICAgIHVpbnQzMl90IGV4dF92Y19j b3VudCA9IDA7CisgICAgdWludDMyX3QgYXJiX3RhYmxlX2VudHJ5X3NpemU7ICAvKiBpbiBiaXRz ICovCisgICAgY29uc3QgY2hhciAqY2FwX25hbWU7CisgICAgaW50IHJldDsKKyAgICBpbnQgaTsK KworICAgIHJldCA9IHhlbl9ob3N0X3BjaV9nZXRfbG9uZygmcy0+cmVhbF9kZXZpY2UsIGJhc2Vf b2Zmc2V0LCAmaGVhZGVyKTsKKyAgICBpZiAocmV0KSB7CisgICAgICAgIGdvdG8gZXJyX3JlYWQ7 CisgICAgfQorCisgICAgbmV4dF9wdHIgPSBQQ0lfRVhUX0NBUF9ORVhUKGhlYWRlcik7CisKKyAg ICBzd2l0Y2ggKFBDSV9FWFRfQ0FQX0lEKGhlYWRlcikpIHsKKyAgICBjYXNlIFBDSV9FWFRfQ0FQ X0lEX1ZDOgorICAgIGNhc2UgUENJX0VYVF9DQVBfSURfVkM5OgorICAgICAgICBjYXBfbmFtZSA9 ICJWaXJ0dWFsIENoYW5uZWwiOworICAgICAgICBicmVhazsKKyAgICBjYXNlIFBDSV9FWFRfQ0FQ X0lEX01GVkM6CisgICAgICAgIGNhcF9uYW1lID0gIk11bHRpLUZ1bmN0aW9uIFZDIjsKKyAgICAg ICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAgICAgWEVOX1BUX0VSUigmcy0+ZGV2LCAiVW5r bm93biBWQyBFeHRlbmRlZCBDYXBhYmlsaXR5IElEICIKKyAgICAgICAgICAgICAgICAgICAiZW5j b3VudGVyZWQ6IDB4JTA0eFxuIiwgUENJX0VYVF9DQVBfSUQoaGVhZGVyKSk7CisgICAgICAgIHJl dHVybiAtMTsKKyAgICB9CisKKyAgICBpZiAobmV4dF9wdHIgJiYgbmV4dF9wdHIgPiBiYXNlX29m ZnNldCkgeworICAgICAgICB2Y19jYXBfbWF4X3NpemUgPSBuZXh0X3B0ciAtIGJhc2Vfb2Zmc2V0 OworICAgIH0KKworICAgIHJldCA9IHhlbl9ob3N0X3BjaV9nZXRfbG9uZygmcy0+cmVhbF9kZXZp Y2UsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJhc2Vfb2Zmc2V0ICsgUENJX1ZD X1BPUlRfQ0FQMSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnBvcnRfdmNfY2Fw MSk7CisgICAgaWYgKHJldCkgeworICAgICAgICBnb3RvIGVycl9yZWFkOworICAgIH0KKworICAg IHJldCA9IHhlbl9ob3N0X3BjaV9nZXRfbG9uZygmcy0+cmVhbF9kZXZpY2UsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGJhc2Vfb2Zmc2V0ICsgUENJX1ZDX1BPUlRfQ0FQMiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnBvcnRfdmNfY2FwMik7CisgICAgaWYgKHJl dCkgeworICAgICAgICBnb3RvIGVycl9yZWFkOworICAgIH0KKworICAgIGV4dF92Y19jb3VudCA9 IHBvcnRfdmNfY2FwMSAmIFBDSV9WQ19DQVAxX0VWQ0M7CisKKyAgICBhcmJfdGFibGVfc3RhcnRf bWF4ID0gR0VUX0FSQl9UQUJMRV9PRkZTRVQocG9ydF92Y19jYXAyKTsKKworICAgIC8qIGNoZWNr IGFyYml0cmF0aW9uIHRhYmxlIG9mZnNldCBmb3IgdmFsaWRpdHkgKi8KKyAgICBpZiAoYXJiX3Rh YmxlX3N0YXJ0X21heCA+PSB2Y19jYXBfbWF4X3NpemUpIHsKKyAgICAgICAgWEVOX1BUX0VSUigm cy0+ZGV2LCAiV2FybmluZzogVkMgYXJiaXRyYXRpb24gdGFibGUgb2Zmc2V0IHBvaW50cyAiCisg ICAgICAgICAgICAgICAgICAgIm91dHNpZGUgdGhlIGV4cGVjdGVkIHJhbmdlOiAlIzA0eFxuIiwK KyAgICAgICAgICAgICAgICAgICAodWludDE2X3QpIGFyYl90YWJsZV9zdGFydF9tYXgpOworICAg ICAgICAvKiBza2lwIHRoaXMgYXJiaXRyYXRpb24gdGFibGUgKi8KKyAgICAgICAgYXJiX3RhYmxl X3N0YXJ0X21heCA9IDA7CisgICAgfQorCisgICAgaWYgKGFyYl90YWJsZV9zdGFydF9tYXgpIHsK KyAgICAgICAgdWludDMyX3QgdmNfYXJiX2NhcCA9IEdFVF9WQ19BUkJfQ0FQQUJJTElUWShwb3J0 X3ZjX2NhcDIpOworICAgICAgICB1aW50MzJfdCBudW1fcGhhc2VzID0gZ2V0X2FyYl90YWJsZV9s ZW5fbWF4KHMsIDMsIHZjX2FyYl9jYXApOworICAgICAgICB1aW50MzJfdCBhcmJfdGJsX3N6ID0g UUVNVV9BTElHTl9VUChudW1fcGhhc2VzICogNCwgMzIpIC8gODsKKworICAgICAgICBhcmJfdGFi bGVfZW5kX21heCA9IGJhc2Vfb2Zmc2V0ICsgYXJiX3RhYmxlX3N0YXJ0X21heCArIGFyYl90Ymxf c3o7CisgICAgfQorCisgICAgLyogZ2V0IEZ1bmN0aW9uL1BvcnQgQXJiaXRyYXRpb24gVGFibGUg RW50cnkgc2l6ZSAqLworICAgIGFyYl90YWJsZV9lbnRyeV9zaXplID0gQVJCX1RBQkxFX0VOVFJZ X1NJWkVfQklUUyhwb3J0X3ZjX2NhcDEpOworCisgICAgLyogcHJvY2VzcyBhbGwgVkMgUmVzb3Vy Y2UgZW50cmllcyAqLworICAgIGZvciAoaSA9IDA7IGkgPCBleHRfdmNfY291bnQ7IGkrKykgewor ICAgICAgICB1aW50MzJfdCBhcmJfdGFibGVfb2Zmc2V0OworCisgICAgICAgIC8qIHJlYWQgVkMg UmVzb3VyY2UgQ2FwYWJpbGl0eSAqLworICAgICAgICByZXQgPSB4ZW5faG9zdF9wY2lfZ2V0X2xv bmcoJnMtPnJlYWxfZGV2aWNlLAorICAgICAgICAgICAgYmFzZV9vZmZzZXQgKyBQQ0lfVkNfUkVT X0NBUCArIGkgKiBQQ0lfQ0FQX1ZDX1BFUl9WQ19TSVpFT0YsCisgICAgICAgICAgICAmdmNfcnNy Y19jYXApOworICAgICAgICBpZiAocmV0KSB7CisgICAgICAgICAgICBnb3RvIGVycl9yZWFkOwor ICAgICAgICB9CisKKyAgICAgICAgYXJiX3RhYmxlX29mZnNldCA9IEdFVF9BUkJfVEFCTEVfT0ZG U0VUKHZjX3JzcmNfY2FwKTsKKworICAgICAgICBpZiAoYXJiX3RhYmxlX29mZnNldCA+IGFyYl90 YWJsZV9zdGFydF9tYXgpIHsKKyAgICAgICAgICAgIC8qIGNoZWNrIGFyYml0cmF0aW9uIHRhYmxl IG9mZnNldCBmb3IgdmFsaWRpdHkgKi8KKyAgICAgICAgICAgIGlmIChhcmJfdGFibGVfb2Zmc2V0 ID49IHZjX2NhcF9tYXhfc2l6ZSkgeworICAgICAgICAgICAgICAgIFhFTl9QVF9FUlIoJnMtPmRl diwgIldhcm5pbmc6IFBvcnQvRnVuY3Rpb24gYXJiaXRyYXRpb24gdGFibGUgIgorICAgICAgICAg ICAgICAgICAgICAgICAgICAgIm9mZnNldCBwb2ludHMgb3V0c2lkZSB0aGUgZXhwZWN0ZWQgcmFu Z2U6ICUjMDR4XG4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgKHVpbnQxNl90KSBhcmJf dGFibGVfb2Zmc2V0KTsKKyAgICAgICAgICAgICAgICAvKiBza2lwIHRoaXMgYXJiaXRyYXRpb24g dGFibGUgKi8KKyAgICAgICAgICAgICAgICBhcmJfdGFibGVfb2Zmc2V0ID0gMDsKKyAgICAgICAg ICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgYXJiX3RhYmxlX3N0YXJ0X21heCA9IGFyYl90 YWJsZV9vZmZzZXQ7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIGlmIChhcmJfdGFibGVf b2Zmc2V0KSB7CisgICAgICAgICAgICAgICAgdWludDMyX3QgdmNfYXJiX2NhcCA9IEdFVF9WQ19B UkJfQ0FQQUJJTElUWSh2Y19yc3JjX2NhcCk7CisgICAgICAgICAgICAgICAgdWludDMyX3QgbnVt X3BoYXNlcyA9IGdldF9hcmJfdGFibGVfbGVuX21heChzLCA1LCB2Y19hcmJfY2FwKTsKKyAgICAg ICAgICAgICAgICB1aW50MzJfdCBhcmJfdGJsX3N6ID0KKyAgICAgICAgICAgICAgICAgICAgUUVN VV9BTElHTl9VUChudW1fcGhhc2VzICogYXJiX3RhYmxlX2VudHJ5X3NpemUsIDMyKSAvIDg7CisK KyAgICAgICAgICAgICAgICBhcmJfdGFibGVfZW5kX21heCA9IGJhc2Vfb2Zmc2V0ICsgYXJiX3Rh YmxlX29mZnNldCArIGFyYl90Ymxfc3o7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9 CisKKyAgICBpZiAoYXJiX3RhYmxlX2VuZF9tYXgpIHsKKyAgICAgICAgKnNpemUgPSBhcmJfdGFi bGVfZW5kX21heCAtIGJhc2Vfb2Zmc2V0OworICAgIH0gZWxzZSB7CisgICAgICAgICpzaXplID0g UENJX0NBUF9WQ19CQVNFX1NJWkVPRiArCisgICAgICAgICAgICAgICAgZXh0X3ZjX2NvdW50ICog UENJX0NBUF9WQ19QRVJfVkNfU0laRU9GOworICAgIH0KKworICAgIGxvZ19wY2llX2V4dGVuZGVk X2NhcChzLCBjYXBfbmFtZSwgYmFzZV9vZmZzZXQsICpzaXplKTsKKyAgICByZXR1cm4gMDsKKwor ZXJyX3JlYWQ6CisgICAgWEVOX1BUX0VSUigmcy0+ZGV2LCAiRXJyb3Igd2hpbGUgcmVhZGluZyBW QyBFeHRlbmRlZCBDYXBhYmlsaXR5XG4iKTsKKyAgICByZXR1cm4gcmV0OworfQorCisKIHN0YXRp YyBjb25zdCBYZW5QVFJlZ0dyb3VwSW5mbyB4ZW5fcHRfZW11X3JlZ19ncnBzW10gPSB7CiAgICAg LyogSGVhZGVyIFR5cGUwIHJlZyBncm91cCAqLwogICAgIHsKQEAgLTI1MTUsNiArMjY4MywzMCBA QCBzdGF0aWMgY29uc3QgWGVuUFRSZWdHcm91cEluZm8geGVuX3B0X2VtdV9yZWdfZ3Jwc1tdID0g ewogICAgICAgICAuZ3JwX3NpemUgICA9IDB4RkYsCiAgICAgICAgIC5zaXplX2luaXQgID0geGVu X3B0X2V4dF9jYXBfcmViYXJfc2l6ZV9pbml0LAogICAgIH0sCisgICAgLyogVmlydHVhbCBDaGFu bmVsIEV4dGVuZGVkIENhcGFiaWxpdHkgcmVnIGdyb3VwICgyKSAqLworICAgIHsKKyAgICAgICAg LmdycF9pZCAgICAgPSBQQ0lFX0VYVF9DQVBfSUQoUENJX0VYVF9DQVBfSURfVkMpLAorICAgICAg ICAuZ3JwX3R5cGUgICA9IFhFTl9QVF9HUlBfVFlQRV9FTVUsCisgICAgICAgIC5ncnBfc2l6ZSAg ID0gMHhGRiwKKyAgICAgICAgLnNpemVfaW5pdCAgPSB4ZW5fcHRfZXh0X2NhcF92Y2hhbl9zaXpl X2luaXQsCisgICAgICAgIC5lbXVfcmVncyAgID0geGVuX3B0X2V4dF9jYXBfZW11X3JlZ19kdW1t eSwKKyAgICB9LAorICAgIC8qIFZpcnR1YWwgQ2hhbm5lbCBFeHRlbmRlZCBDYXBhYmlsaXR5IHJl ZyBncm91cCAoOSkgKi8KKyAgICB7CisgICAgICAgIC5ncnBfaWQgICAgID0gUENJRV9FWFRfQ0FQ X0lEKFBDSV9FWFRfQ0FQX0lEX1ZDOSksCisgICAgICAgIC5ncnBfdHlwZSAgID0gWEVOX1BUX0dS UF9UWVBFX0VNVSwKKyAgICAgICAgLmdycF9zaXplICAgPSAweEZGLAorICAgICAgICAuc2l6ZV9p bml0ICA9IHhlbl9wdF9leHRfY2FwX3ZjaGFuX3NpemVfaW5pdCwKKyAgICAgICAgLmVtdV9yZWdz ICAgPSB4ZW5fcHRfZXh0X2NhcF9lbXVfcmVnX2R1bW15LAorICAgIH0sCisgICAgLyogTXVsdGkt RnVuY3Rpb24gVmlydHVhbCBDaGFubmVsIEV4dGVuZGVkIENhcGFiaWxpdHkgcmVnIGdyb3VwICov CisgICAgeworICAgICAgICAuZ3JwX2lkICAgICA9IFBDSUVfRVhUX0NBUF9JRChQQ0lfRVhUX0NB UF9JRF9NRlZDKSwKKyAgICAgICAgLmdycF90eXBlICAgPSBYRU5fUFRfR1JQX1RZUEVfRU1VLAor ICAgICAgICAuZ3JwX3NpemUgICA9IDB4RkYsCisgICAgICAgIC5zaXplX2luaXQgID0geGVuX3B0 X2V4dF9jYXBfdmNoYW5fc2l6ZV9pbml0LAorICAgICAgICAuZW11X3JlZ3MgICA9IHhlbl9wdF9l eHRfY2FwX2VtdV9yZWdfZHVtbXksCisgICAgfSwKICAgICB7CiAgICAgICAgIC5ncnBfc2l6ZSA9 IDAsCiAgICAgfSwKLS0gCjIuMTEuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhl bnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5vcmcvbWFpbG1hbi9saXN0aW5m by94ZW4tZGV2ZWw=