From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:46987) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gJTuf-0007Lg-9w for qemu-devel@nongnu.org; Sun, 04 Nov 2018 20:42:48 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gJTua-0002kP-C6 for qemu-devel@nongnu.org; Sun, 04 Nov 2018 20:42:45 -0500 From: Samuel Ortiz Date: Mon, 5 Nov 2018 02:40:30 +0100 Message-Id: <20181105014047.26447-8-sameo@linux.intel.com> In-Reply-To: <20181105014047.26447-1-sameo@linux.intel.com> References: <20181105014047.26447-1-sameo@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Subject: [Qemu-devel] [PATCH v5 07/24] hw: acpi: Generalize AML build routines List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: Shannon Zhao , Stefano Stabellini , Anthony Perard , Richard Henderson , Marcel Apfelbaum , xen-devel@lists.xenproject.org, Paolo Bonzini , "Michael S. Tsirkin" , Igor Mammedov , qemu-arm@nongnu.org, Peter Maydell , Eduardo Habkost , Yang Zhong From: Yang Zhong Most of the AML build routines under acpi-build are not even architecture specific. They can be moved to the more generic hw/acpi folder where they could be shared across machine types and architectures. Reviewed-by: Philippe Mathieu-Daudé Tested-by: Philippe Mathieu-Daudé Signed-off-by: Yang Zhong --- include/hw/acpi/aml-build.h | 25 ++ hw/acpi/aml-build.c | 498 ++++++++++++++++++++++++++++++++++ hw/arm/virt-acpi-build.c | 4 +- hw/i386/acpi-build.c | 518 +----------------------------------- 4 files changed, 528 insertions(+), 517 deletions(-) diff --git a/include/hw/acpi/aml-build.h b/include/hw/acpi/aml-build.h index a2ef8b6f31..4f678c45a5 100644 --- a/include/hw/acpi/aml-build.h +++ b/include/hw/acpi/aml-build.h @@ -3,6 +3,7 @@ #include "hw/acpi/acpi-defs.h" #include "hw/acpi/bios-linker-loader.h" +#include "hw/pci/pcie_host.h" /* Reserve RAM space for tables: add another order of magnitude. */ #define ACPI_BUILD_TABLE_MAX_SIZE 0x200000 @@ -223,6 +224,21 @@ struct AcpiBuildTables { BIOSLinker *linker; } AcpiBuildTables; +typedef struct AcpiMcfgInfo { + uint64_t mcfg_base; + uint32_t mcfg_size; +} AcpiMcfgInfo; + +typedef struct CrsRangeEntry { + uint64_t base; + uint64_t limit; +} CrsRangeEntry; + +typedef struct CrsRangeSet { + GPtrArray *io_ranges; + GPtrArray *mem_ranges; + GPtrArray *mem_64bit_ranges; +} CrsRangeSet; /** * init_aml_allocator: * @@ -389,6 +405,15 @@ void acpi_align_size(GArray *blob, unsigned align); void acpi_add_table(GArray *table_offsets, GArray *table_data); void acpi_build_tables_init(AcpiBuildTables *tables); void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre); +Aml *build_osc_method(void); +void build_mcfg(GArray *table_data, BIOSLinker *linker, AcpiMcfgInfo *info); +Aml *build_gsi_link_dev(const char *name, uint8_t uid, uint8_t gsi); +Aml *build_prt(bool is_pci0_prt); +void crs_range_set_init(CrsRangeSet *range_set); +Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set); +void crs_replace_with_free_ranges(GPtrArray *ranges, + uint64_t start, uint64_t end); +void crs_range_set_free(CrsRangeSet *range_set); void build_rsdp_rsdt(GArray *table_data, BIOSLinker *linker, unsigned rsdt_tbl_offset); diff --git a/hw/acpi/aml-build.c b/hw/acpi/aml-build.c index 8c2388274c..d3242c6b31 100644 --- a/hw/acpi/aml-build.c +++ b/hw/acpi/aml-build.c @@ -25,6 +25,10 @@ #include "qemu/bswap.h" #include "qemu/bitops.h" #include "sysemu/numa.h" +#include "hw/pci/pci.h" +#include "hw/pci/pci_bus.h" +#include "qemu/range.h" +#include "hw/pci/pci_bridge.h" static GArray *build_alloc_array(void) { @@ -1597,6 +1601,500 @@ void acpi_build_tables_cleanup(AcpiBuildTables *tables, bool mfre) g_array_free(tables->vmgenid, mfre); } +static void crs_range_insert(GPtrArray *ranges, uint64_t base, uint64_t limit) +{ + CrsRangeEntry *entry; + + entry = g_malloc(sizeof(*entry)); + entry->base = base; + entry->limit = limit; + + g_ptr_array_add(ranges, entry); +} + +static void crs_range_free(gpointer data) +{ + CrsRangeEntry *entry = (CrsRangeEntry *)data; + g_free(entry); +} + +void crs_range_set_init(CrsRangeSet *range_set) +{ + range_set->io_ranges = g_ptr_array_new_with_free_func(crs_range_free); + range_set->mem_ranges = g_ptr_array_new_with_free_func(crs_range_free); + range_set->mem_64bit_ranges = + g_ptr_array_new_with_free_func(crs_range_free); +} + +void crs_range_set_free(CrsRangeSet *range_set) +{ + g_ptr_array_free(range_set->io_ranges, true); + g_ptr_array_free(range_set->mem_ranges, true); + g_ptr_array_free(range_set->mem_64bit_ranges, true); +} + +static gint crs_range_compare(gconstpointer a, gconstpointer b) +{ + CrsRangeEntry *entry_a = *(CrsRangeEntry **)a; + CrsRangeEntry *entry_b = *(CrsRangeEntry **)b; + + return (int64_t)entry_a->base - (int64_t)entry_b->base; +} + +/* + * crs_replace_with_free_ranges - given the 'used' ranges within [start - end] + * interval, computes the 'free' ranges from the same interval. + * Example: If the input array is { [a1 - a2],[b1 - b2] }, the function + * will return { [base - a1], [a2 - b1], [b2 - limit] }. + */ +void crs_replace_with_free_ranges(GPtrArray *ranges, + uint64_t start, uint64_t end) +{ + GPtrArray *free_ranges = g_ptr_array_new(); + uint64_t free_base = start; + int i; + + g_ptr_array_sort(ranges, crs_range_compare); + for (i = 0; i < ranges->len; i++) { + CrsRangeEntry *used = g_ptr_array_index(ranges, i); + + if (free_base < used->base) { + crs_range_insert(free_ranges, free_base, used->base - 1); + } + + free_base = used->limit + 1; + } + + if (free_base < end) { + crs_range_insert(free_ranges, free_base, end); + } + + g_ptr_array_set_size(ranges, 0); + for (i = 0; i < free_ranges->len; i++) { + g_ptr_array_add(ranges, g_ptr_array_index(free_ranges, i)); + } + + g_ptr_array_free(free_ranges, true); +} + +/* + * crs_range_merge - merges adjacent ranges in the given array. + * Array elements are deleted and replaced with the merged ranges. + */ +static void crs_range_merge(GPtrArray *range) +{ + GPtrArray *tmp = g_ptr_array_new_with_free_func(crs_range_free); + CrsRangeEntry *entry; + uint64_t range_base, range_limit; + int i; + + if (!range->len) { + return; + } + + g_ptr_array_sort(range, crs_range_compare); + + entry = g_ptr_array_index(range, 0); + range_base = entry->base; + range_limit = entry->limit; + for (i = 1; i < range->len; i++) { + entry = g_ptr_array_index(range, i); + if (entry->base - 1 == range_limit) { + range_limit = entry->limit; + } else { + crs_range_insert(tmp, range_base, range_limit); + range_base = entry->base; + range_limit = entry->limit; + } + } + crs_range_insert(tmp, range_base, range_limit); + + g_ptr_array_set_size(range, 0); + for (i = 0; i < tmp->len; i++) { + entry = g_ptr_array_index(tmp, i); + crs_range_insert(range, entry->base, entry->limit); + } + g_ptr_array_free(tmp, true); +} + +Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set) +{ + Aml *crs = aml_resource_template(); + CrsRangeSet temp_range_set; + CrsRangeEntry *entry; + uint8_t max_bus = pci_bus_num(host->bus); + uint8_t type; + int devfn; + int i; + + crs_range_set_init(&temp_range_set); + for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) { + uint64_t range_base, range_limit; + PCIDevice *dev = host->bus->devices[devfn]; + + if (!dev) { + continue; + } + + for (i = 0; i < PCI_NUM_REGIONS; i++) { + PCIIORegion *r = &dev->io_regions[i]; + + range_base = r->addr; + range_limit = r->addr + r->size - 1; + + /* + * Work-around for old bioses + * that do not support multiple root buses + */ + if (!range_base || range_base > range_limit) { + continue; + } + + if (r->type & PCI_BASE_ADDRESS_SPACE_IO) { + crs_range_insert(temp_range_set.io_ranges, + range_base, range_limit); + } else { /* "memory" */ + crs_range_insert(temp_range_set.mem_ranges, + range_base, range_limit); + } + } + + type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION; + if (type == PCI_HEADER_TYPE_BRIDGE) { + uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS]; + if (subordinate > max_bus) { + max_bus = subordinate; + } + + range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO); + range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO); + + /* + * Work-around for old bioses + * that do not support multiple root buses + */ + if (range_base && range_base <= range_limit) { + crs_range_insert(temp_range_set.io_ranges, + range_base, range_limit); + } + + range_base = + pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); + range_limit = + pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); + + /* + * Work-around for old bioses + * that do not support multiple root buses + */ + if (range_base && range_base <= range_limit) { + uint64_t length = range_limit - range_base + 1; + if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { + crs_range_insert(temp_range_set.mem_ranges, + range_base, range_limit); + } else { + crs_range_insert(temp_range_set.mem_64bit_ranges, + range_base, range_limit); + } + } + + range_base = + pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); + range_limit = + pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); + + /* + * Work-around for old bioses + * that do not support multiple root buses + */ + if (range_base && range_base <= range_limit) { + uint64_t length = range_limit - range_base + 1; + if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { + crs_range_insert(temp_range_set.mem_ranges, + range_base, range_limit); + } else { + crs_range_insert(temp_range_set.mem_64bit_ranges, + range_base, range_limit); + } + } + } + } + + crs_range_merge(temp_range_set.io_ranges); + for (i = 0; i < temp_range_set.io_ranges->len; i++) { + entry = g_ptr_array_index(temp_range_set.io_ranges, i); + aml_append(crs, + aml_word_io(AML_MIN_FIXED, AML_MAX_FIXED, + AML_POS_DECODE, AML_ENTIRE_RANGE, + 0, entry->base, entry->limit, 0, + entry->limit - entry->base + 1)); + crs_range_insert(range_set->io_ranges, entry->base, entry->limit); + } + + crs_range_merge(temp_range_set.mem_ranges); + for (i = 0; i < temp_range_set.mem_ranges->len; i++) { + entry = g_ptr_array_index(temp_range_set.mem_ranges, i); + aml_append(crs, + aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED, + AML_MAX_FIXED, AML_NON_CACHEABLE, + AML_READ_WRITE, + 0, entry->base, entry->limit, 0, + entry->limit - entry->base + 1)); + crs_range_insert(range_set->mem_ranges, entry->base, entry->limit); + } + + crs_range_merge(temp_range_set.mem_64bit_ranges); + for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) { + entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i); + aml_append(crs, + aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED, + AML_MAX_FIXED, AML_NON_CACHEABLE, + AML_READ_WRITE, + 0, entry->base, entry->limit, 0, + entry->limit - entry->base + 1)); + crs_range_insert(range_set->mem_64bit_ranges, + entry->base, entry->limit); + } + + crs_range_set_free(&temp_range_set); + + aml_append(crs, + aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE, + 0, + pci_bus_num(host->bus), + max_bus, + 0, + max_bus - pci_bus_num(host->bus) + 1)); + + return crs; +} + +Aml *build_osc_method(void) +{ + Aml *if_ctx; + Aml *if_ctx2; + Aml *else_ctx; + Aml *method; + Aml *a_cwd1 = aml_name("CDW1"); + Aml *a_ctrl = aml_local(0); + + method = aml_method("_OSC", 4, AML_NOTSERIALIZED); + aml_append(method, aml_create_dword_field(aml_arg(3), aml_int(0), "CDW1")); + + if_ctx = aml_if(aml_equal( + aml_arg(0), aml_touuid("33DB4D5B-1FF7-401C-9657-7441C03DD766"))); + aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(4), "CDW2")); + aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(8), "CDW3")); + + aml_append(if_ctx, aml_store(aml_name("CDW3"), a_ctrl)); + + /* + * Always allow native PME, AER (no dependencies) + * Allow SHPC (PCI bridges can have SHPC controller) + */ + aml_append(if_ctx, aml_and(a_ctrl, aml_int(0x1F), a_ctrl)); + + if_ctx2 = aml_if(aml_lnot(aml_equal(aml_arg(1), aml_int(1)))); + /* Unknown revision */ + aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x08), a_cwd1)); + aml_append(if_ctx, if_ctx2); + + if_ctx2 = aml_if(aml_lnot(aml_equal(aml_name("CDW3"), a_ctrl))); + /* Capabilities bits were masked */ + aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x10), a_cwd1)); + aml_append(if_ctx, if_ctx2); + + /* Update DWORD3 in the buffer */ + aml_append(if_ctx, aml_store(a_ctrl, aml_name("CDW3"))); + aml_append(method, if_ctx); + + else_ctx = aml_else(); + /* Unrecognized UUID */ + aml_append(else_ctx, aml_or(a_cwd1, aml_int(4), a_cwd1)); + aml_append(method, else_ctx); + + aml_append(method, aml_return(aml_arg(3))); + return method; +} + +void +build_mcfg(GArray *table_data, BIOSLinker *linker, AcpiMcfgInfo *info) +{ + AcpiTableMcfg *mcfg; + const char *sig; + int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]); + + mcfg = acpi_data_push(table_data, len); + mcfg->allocation[0].address = cpu_to_le64(info->mcfg_base); + /* Only a single allocation so no need to play with segments */ + mcfg->allocation[0].pci_segment = cpu_to_le16(0); + mcfg->allocation[0].start_bus_number = 0; + mcfg->allocation[0].end_bus_number = PCIE_MMCFG_BUS(info->mcfg_size - 1); + + /* MCFG is used for ECAM which can be enabled or disabled by guest. + * To avoid table size changes (which create migration issues), + * always create the table even if there are no allocations, + * but set the signature to a reserved value in this case. + * ACPI spec requires OSPMs to ignore such tables. + */ + if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) { + /* Reserved signature: ignored by OSPM */ + sig = "QEMU"; + } else { + sig = "MCFG"; + } + build_header(linker, table_data, (void *)mcfg, sig, len, 1, NULL, NULL); +} + +Aml *build_gsi_link_dev(const char *name, uint8_t uid, uint8_t gsi) +{ + Aml *dev; + Aml *crs; + Aml *method; + uint32_t irqs; + + dev = aml_device("%s", name); + aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0C0F"))); + aml_append(dev, aml_name_decl("_UID", aml_int(uid))); + + crs = aml_resource_template(); + irqs = gsi; + aml_append(crs, aml_interrupt(AML_CONSUMER, AML_LEVEL, AML_ACTIVE_HIGH, + AML_SHARED, &irqs, 1)); + aml_append(dev, aml_name_decl("_PRS", crs)); + + aml_append(dev, aml_name_decl("_CRS", crs)); + + /* + * _DIS can be no-op because the interrupt cannot be disabled. + */ + method = aml_method("_DIS", 0, AML_NOTSERIALIZED); + aml_append(dev, method); + + method = aml_method("_SRS", 1, AML_NOTSERIALIZED); + aml_append(dev, method); + + return dev; +} + +/** + * build_prt_entry: + * @link_name: link name for PCI route entry + * + * build AML package containing a PCI route entry for @link_name + */ +static Aml *build_prt_entry(const char *link_name) +{ + Aml *a_zero = aml_int(0); + Aml *pkg = aml_package(4); + aml_append(pkg, a_zero); + aml_append(pkg, a_zero); + aml_append(pkg, aml_name("%s", link_name)); + aml_append(pkg, a_zero); + return pkg; +} + +/* + * initialize_route - Initialize the interrupt routing rule + * through a specific LINK: + * if (lnk_idx == idx) + * route using link 'link_name' + */ +static Aml *initialize_route(Aml *route, const char *link_name, + Aml *lnk_idx, int idx) +{ + Aml *if_ctx = aml_if(aml_equal(lnk_idx, aml_int(idx))); + Aml *pkg = build_prt_entry(link_name); + + aml_append(if_ctx, aml_store(pkg, route)); + + return if_ctx; +} + +/* + * build_prt - Define interrupt rounting rules + * + * Returns an array of 128 routes, one for each device, + * based on device location. + * The main goal is to equaly distribute the interrupts + * over the 4 existing ACPI links (works only for i440fx). + * The hash function is (slot + pin) & 3 -> "LNK[D|A|B|C]". + * + */ +Aml *build_prt(bool is_pci0_prt) +{ + Aml *method, *while_ctx, *pin, *res; + + method = aml_method("_PRT", 0, AML_NOTSERIALIZED); + res = aml_local(0); + pin = aml_local(1); + aml_append(method, aml_store(aml_package(128), res)); + aml_append(method, aml_store(aml_int(0), pin)); + + /* while (pin < 128) */ + while_ctx = aml_while(aml_lless(pin, aml_int(128))); + { + Aml *slot = aml_local(2); + Aml *lnk_idx = aml_local(3); + Aml *route = aml_local(4); + + /* slot = pin >> 2 */ + aml_append(while_ctx, + aml_store(aml_shiftright(pin, aml_int(2), NULL), slot)); + /* lnk_idx = (slot + pin) & 3 */ + aml_append(while_ctx, + aml_store(aml_and(aml_add(pin, slot, NULL), aml_int(3), NULL), + lnk_idx)); + + /* route[2] = "LNK[D|A|B|C]", selection based on pin % 3 */ + aml_append(while_ctx, initialize_route(route, "LNKD", lnk_idx, 0)); + if (is_pci0_prt) { + Aml *if_device_1, *if_pin_4, *else_pin_4; + + /* device 1 is the power-management device, needs SCI */ + if_device_1 = aml_if(aml_equal(lnk_idx, aml_int(1))); + { + if_pin_4 = aml_if(aml_equal(pin, aml_int(4))); + { + aml_append(if_pin_4, + aml_store(build_prt_entry("LNKS"), route)); + } + aml_append(if_device_1, if_pin_4); + else_pin_4 = aml_else(); + { + aml_append(else_pin_4, + aml_store(build_prt_entry("LNKA"), route)); + } + aml_append(if_device_1, else_pin_4); + } + aml_append(while_ctx, if_device_1); + } else { + aml_append(while_ctx, initialize_route(route, "LNKA", lnk_idx, 1)); + } + aml_append(while_ctx, initialize_route(route, "LNKB", lnk_idx, 2)); + aml_append(while_ctx, initialize_route(route, "LNKC", lnk_idx, 3)); + + /* route[0] = 0x[slot]FFFF */ + aml_append(while_ctx, + aml_store(aml_or(aml_shiftleft(slot, aml_int(16)), aml_int(0xFFFF), + NULL), + aml_index(route, aml_int(0)))); + /* route[1] = pin & 3 */ + aml_append(while_ctx, + aml_store(aml_and(pin, aml_int(3), NULL), + aml_index(route, aml_int(1)))); + /* res[pin] = route */ + aml_append(while_ctx, aml_store(route, aml_index(res, pin))); + /* pin++ */ + aml_append(while_ctx, aml_increment(pin)); + } + aml_append(method, while_ctx); + /* return res*/ + aml_append(method, aml_return(res)); + + return method; +} + /* Build rsdt table */ void build_rsdt(GArray *table_data, BIOSLinker *linker, GArray *table_offsets, diff --git a/hw/arm/virt-acpi-build.c b/hw/arm/virt-acpi-build.c index 261363e20c..c9b4916ba7 100644 --- a/hw/arm/virt-acpi-build.c +++ b/hw/arm/virt-acpi-build.c @@ -545,7 +545,7 @@ build_srat(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms) } static void -build_mcfg(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms) +virt_build_mcfg(GArray *table_data, BIOSLinker *linker, VirtMachineState *vms) { AcpiTableMcfg *mcfg; const MemMapEntry *memmap = vms->memmap; @@ -790,7 +790,7 @@ void virt_acpi_build(VirtMachineState *vms, AcpiBuildTables *tables) build_gtdt(tables_blob, tables->linker, vms); acpi_add_table(table_offsets, tables_blob); - build_mcfg(tables_blob, tables->linker, vms); + virt_build_mcfg(tables_blob, tables->linker, vms); acpi_add_table(table_offsets, tables_blob); build_spcr(tables_blob, tables->linker, vms); diff --git a/hw/i386/acpi-build.c b/hw/i386/acpi-build.c index cfc2444d0d..996d8a11dc 100644 --- a/hw/i386/acpi-build.c +++ b/hw/i386/acpi-build.c @@ -27,7 +27,6 @@ #include "qemu-common.h" #include "qemu/bitmap.h" #include "qemu/error-report.h" -#include "hw/pci/pci.h" #include "qom/cpu.h" #include "target/i386/cpu.h" #include "hw/misc/pvpanic.h" @@ -53,7 +52,6 @@ #include "hw/acpi/piix4.h" #include "hw/acpi/pcihp.h" #include "hw/i386/ich9.h" -#include "hw/pci/pci_bus.h" #include "hw/pci-host/q35.h" #include "hw/i386/x86-iommu.h" @@ -86,11 +84,6 @@ /* Default IOAPIC ID */ #define ACPI_BUILD_IOAPIC_ID 0x0 -typedef struct AcpiMcfgInfo { - uint64_t mcfg_base; - uint32_t mcfg_size; -} AcpiMcfgInfo; - typedef struct AcpiPmInfo { bool s3_disabled; bool s4_disabled; @@ -567,403 +560,6 @@ static void build_append_pci_bus_devices(Aml *parent_scope, PCIBus *bus, qobject_unref(bsel); } -/** - * build_prt_entry: - * @link_name: link name for PCI route entry - * - * build AML package containing a PCI route entry for @link_name - */ -static Aml *build_prt_entry(const char *link_name) -{ - Aml *a_zero = aml_int(0); - Aml *pkg = aml_package(4); - aml_append(pkg, a_zero); - aml_append(pkg, a_zero); - aml_append(pkg, aml_name("%s", link_name)); - aml_append(pkg, a_zero); - return pkg; -} - -/* - * initialize_route - Initialize the interrupt routing rule - * through a specific LINK: - * if (lnk_idx == idx) - * route using link 'link_name' - */ -static Aml *initialize_route(Aml *route, const char *link_name, - Aml *lnk_idx, int idx) -{ - Aml *if_ctx = aml_if(aml_equal(lnk_idx, aml_int(idx))); - Aml *pkg = build_prt_entry(link_name); - - aml_append(if_ctx, aml_store(pkg, route)); - - return if_ctx; -} - -/* - * build_prt - Define interrupt rounting rules - * - * Returns an array of 128 routes, one for each device, - * based on device location. - * The main goal is to equaly distribute the interrupts - * over the 4 existing ACPI links (works only for i440fx). - * The hash function is (slot + pin) & 3 -> "LNK[D|A|B|C]". - * - */ -static Aml *build_prt(bool is_pci0_prt) -{ - Aml *method, *while_ctx, *pin, *res; - - method = aml_method("_PRT", 0, AML_NOTSERIALIZED); - res = aml_local(0); - pin = aml_local(1); - aml_append(method, aml_store(aml_package(128), res)); - aml_append(method, aml_store(aml_int(0), pin)); - - /* while (pin < 128) */ - while_ctx = aml_while(aml_lless(pin, aml_int(128))); - { - Aml *slot = aml_local(2); - Aml *lnk_idx = aml_local(3); - Aml *route = aml_local(4); - - /* slot = pin >> 2 */ - aml_append(while_ctx, - aml_store(aml_shiftright(pin, aml_int(2), NULL), slot)); - /* lnk_idx = (slot + pin) & 3 */ - aml_append(while_ctx, - aml_store(aml_and(aml_add(pin, slot, NULL), aml_int(3), NULL), - lnk_idx)); - - /* route[2] = "LNK[D|A|B|C]", selection based on pin % 3 */ - aml_append(while_ctx, initialize_route(route, "LNKD", lnk_idx, 0)); - if (is_pci0_prt) { - Aml *if_device_1, *if_pin_4, *else_pin_4; - - /* device 1 is the power-management device, needs SCI */ - if_device_1 = aml_if(aml_equal(lnk_idx, aml_int(1))); - { - if_pin_4 = aml_if(aml_equal(pin, aml_int(4))); - { - aml_append(if_pin_4, - aml_store(build_prt_entry("LNKS"), route)); - } - aml_append(if_device_1, if_pin_4); - else_pin_4 = aml_else(); - { - aml_append(else_pin_4, - aml_store(build_prt_entry("LNKA"), route)); - } - aml_append(if_device_1, else_pin_4); - } - aml_append(while_ctx, if_device_1); - } else { - aml_append(while_ctx, initialize_route(route, "LNKA", lnk_idx, 1)); - } - aml_append(while_ctx, initialize_route(route, "LNKB", lnk_idx, 2)); - aml_append(while_ctx, initialize_route(route, "LNKC", lnk_idx, 3)); - - /* route[0] = 0x[slot]FFFF */ - aml_append(while_ctx, - aml_store(aml_or(aml_shiftleft(slot, aml_int(16)), aml_int(0xFFFF), - NULL), - aml_index(route, aml_int(0)))); - /* route[1] = pin & 3 */ - aml_append(while_ctx, - aml_store(aml_and(pin, aml_int(3), NULL), - aml_index(route, aml_int(1)))); - /* res[pin] = route */ - aml_append(while_ctx, aml_store(route, aml_index(res, pin))); - /* pin++ */ - aml_append(while_ctx, aml_increment(pin)); - } - aml_append(method, while_ctx); - /* return res*/ - aml_append(method, aml_return(res)); - - return method; -} - -typedef struct CrsRangeEntry { - uint64_t base; - uint64_t limit; -} CrsRangeEntry; - -static void crs_range_insert(GPtrArray *ranges, uint64_t base, uint64_t limit) -{ - CrsRangeEntry *entry; - - entry = g_malloc(sizeof(*entry)); - entry->base = base; - entry->limit = limit; - - g_ptr_array_add(ranges, entry); -} - -static void crs_range_free(gpointer data) -{ - CrsRangeEntry *entry = (CrsRangeEntry *)data; - g_free(entry); -} - -typedef struct CrsRangeSet { - GPtrArray *io_ranges; - GPtrArray *mem_ranges; - GPtrArray *mem_64bit_ranges; - } CrsRangeSet; - -static void crs_range_set_init(CrsRangeSet *range_set) -{ - range_set->io_ranges = g_ptr_array_new_with_free_func(crs_range_free); - range_set->mem_ranges = g_ptr_array_new_with_free_func(crs_range_free); - range_set->mem_64bit_ranges = - g_ptr_array_new_with_free_func(crs_range_free); -} - -static void crs_range_set_free(CrsRangeSet *range_set) -{ - g_ptr_array_free(range_set->io_ranges, true); - g_ptr_array_free(range_set->mem_ranges, true); - g_ptr_array_free(range_set->mem_64bit_ranges, true); -} - -static gint crs_range_compare(gconstpointer a, gconstpointer b) -{ - CrsRangeEntry *entry_a = *(CrsRangeEntry **)a; - CrsRangeEntry *entry_b = *(CrsRangeEntry **)b; - - return (int64_t)entry_a->base - (int64_t)entry_b->base; -} - -/* - * crs_replace_with_free_ranges - given the 'used' ranges within [start - end] - * interval, computes the 'free' ranges from the same interval. - * Example: If the input array is { [a1 - a2],[b1 - b2] }, the function - * will return { [base - a1], [a2 - b1], [b2 - limit] }. - */ -static void crs_replace_with_free_ranges(GPtrArray *ranges, - uint64_t start, uint64_t end) -{ - GPtrArray *free_ranges = g_ptr_array_new(); - uint64_t free_base = start; - int i; - - g_ptr_array_sort(ranges, crs_range_compare); - for (i = 0; i < ranges->len; i++) { - CrsRangeEntry *used = g_ptr_array_index(ranges, i); - - if (free_base < used->base) { - crs_range_insert(free_ranges, free_base, used->base - 1); - } - - free_base = used->limit + 1; - } - - if (free_base < end) { - crs_range_insert(free_ranges, free_base, end); - } - - g_ptr_array_set_size(ranges, 0); - for (i = 0; i < free_ranges->len; i++) { - g_ptr_array_add(ranges, g_ptr_array_index(free_ranges, i)); - } - - g_ptr_array_free(free_ranges, true); -} - -/* - * crs_range_merge - merges adjacent ranges in the given array. - * Array elements are deleted and replaced with the merged ranges. - */ -static void crs_range_merge(GPtrArray *range) -{ - GPtrArray *tmp = g_ptr_array_new_with_free_func(crs_range_free); - CrsRangeEntry *entry; - uint64_t range_base, range_limit; - int i; - - if (!range->len) { - return; - } - - g_ptr_array_sort(range, crs_range_compare); - - entry = g_ptr_array_index(range, 0); - range_base = entry->base; - range_limit = entry->limit; - for (i = 1; i < range->len; i++) { - entry = g_ptr_array_index(range, i); - if (entry->base - 1 == range_limit) { - range_limit = entry->limit; - } else { - crs_range_insert(tmp, range_base, range_limit); - range_base = entry->base; - range_limit = entry->limit; - } - } - crs_range_insert(tmp, range_base, range_limit); - - g_ptr_array_set_size(range, 0); - for (i = 0; i < tmp->len; i++) { - entry = g_ptr_array_index(tmp, i); - crs_range_insert(range, entry->base, entry->limit); - } - g_ptr_array_free(tmp, true); -} - -static Aml *build_crs(PCIHostState *host, CrsRangeSet *range_set) -{ - Aml *crs = aml_resource_template(); - CrsRangeSet temp_range_set; - CrsRangeEntry *entry; - uint8_t max_bus = pci_bus_num(host->bus); - uint8_t type; - int devfn; - int i; - - crs_range_set_init(&temp_range_set); - for (devfn = 0; devfn < ARRAY_SIZE(host->bus->devices); devfn++) { - uint64_t range_base, range_limit; - PCIDevice *dev = host->bus->devices[devfn]; - - if (!dev) { - continue; - } - - for (i = 0; i < PCI_NUM_REGIONS; i++) { - PCIIORegion *r = &dev->io_regions[i]; - - range_base = r->addr; - range_limit = r->addr + r->size - 1; - - /* - * Work-around for old bioses - * that do not support multiple root buses - */ - if (!range_base || range_base > range_limit) { - continue; - } - - if (r->type & PCI_BASE_ADDRESS_SPACE_IO) { - crs_range_insert(temp_range_set.io_ranges, - range_base, range_limit); - } else { /* "memory" */ - crs_range_insert(temp_range_set.mem_ranges, - range_base, range_limit); - } - } - - type = dev->config[PCI_HEADER_TYPE] & ~PCI_HEADER_TYPE_MULTI_FUNCTION; - if (type == PCI_HEADER_TYPE_BRIDGE) { - uint8_t subordinate = dev->config[PCI_SUBORDINATE_BUS]; - if (subordinate > max_bus) { - max_bus = subordinate; - } - - range_base = pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_IO); - range_limit = pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_IO); - - /* - * Work-around for old bioses - * that do not support multiple root buses - */ - if (range_base && range_base <= range_limit) { - crs_range_insert(temp_range_set.io_ranges, - range_base, range_limit); - } - - range_base = - pci_bridge_get_base(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); - range_limit = - pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_SPACE_MEMORY); - - /* - * Work-around for old bioses - * that do not support multiple root buses - */ - if (range_base && range_base <= range_limit) { - uint64_t length = range_limit - range_base + 1; - if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { - crs_range_insert(temp_range_set.mem_ranges, - range_base, range_limit); - } else { - crs_range_insert(temp_range_set.mem_64bit_ranges, - range_base, range_limit); - } - } - - range_base = - pci_bridge_get_base(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); - range_limit = - pci_bridge_get_limit(dev, PCI_BASE_ADDRESS_MEM_PREFETCH); - - /* - * Work-around for old bioses - * that do not support multiple root buses - */ - if (range_base && range_base <= range_limit) { - uint64_t length = range_limit - range_base + 1; - if (range_limit <= UINT32_MAX && length <= UINT32_MAX) { - crs_range_insert(temp_range_set.mem_ranges, - range_base, range_limit); - } else { - crs_range_insert(temp_range_set.mem_64bit_ranges, - range_base, range_limit); - } - } - } - } - - crs_range_merge(temp_range_set.io_ranges); - for (i = 0; i < temp_range_set.io_ranges->len; i++) { - entry = g_ptr_array_index(temp_range_set.io_ranges, i); - aml_append(crs, - aml_word_io(AML_MIN_FIXED, AML_MAX_FIXED, - AML_POS_DECODE, AML_ENTIRE_RANGE, - 0, entry->base, entry->limit, 0, - entry->limit - entry->base + 1)); - crs_range_insert(range_set->io_ranges, entry->base, entry->limit); - } - - crs_range_merge(temp_range_set.mem_ranges); - for (i = 0; i < temp_range_set.mem_ranges->len; i++) { - entry = g_ptr_array_index(temp_range_set.mem_ranges, i); - aml_append(crs, - aml_dword_memory(AML_POS_DECODE, AML_MIN_FIXED, - AML_MAX_FIXED, AML_NON_CACHEABLE, - AML_READ_WRITE, - 0, entry->base, entry->limit, 0, - entry->limit - entry->base + 1)); - crs_range_insert(range_set->mem_ranges, entry->base, entry->limit); - } - - crs_range_merge(temp_range_set.mem_64bit_ranges); - for (i = 0; i < temp_range_set.mem_64bit_ranges->len; i++) { - entry = g_ptr_array_index(temp_range_set.mem_64bit_ranges, i); - aml_append(crs, - aml_qword_memory(AML_POS_DECODE, AML_MIN_FIXED, - AML_MAX_FIXED, AML_NON_CACHEABLE, - AML_READ_WRITE, - 0, entry->base, entry->limit, 0, - entry->limit - entry->base + 1)); - crs_range_insert(range_set->mem_64bit_ranges, - entry->base, entry->limit); - } - - crs_range_set_free(&temp_range_set); - - aml_append(crs, - aml_word_bus_number(AML_MIN_FIXED, AML_MAX_FIXED, AML_POS_DECODE, - 0, - pci_bus_num(host->bus), - max_bus, - 0, - max_bus - pci_bus_num(host->bus) + 1)); - - return crs; -} - static void build_hpet_aml(Aml *table) { Aml *crs; @@ -1334,37 +930,6 @@ static Aml *build_link_dev(const char *name, uint8_t uid, Aml *reg) return dev; } -static Aml *build_gsi_link_dev(const char *name, uint8_t uid, uint8_t gsi) -{ - Aml *dev; - Aml *crs; - Aml *method; - uint32_t irqs; - - dev = aml_device("%s", name); - aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0C0F"))); - aml_append(dev, aml_name_decl("_UID", aml_int(uid))); - - crs = aml_resource_template(); - irqs = gsi; - aml_append(crs, aml_interrupt(AML_CONSUMER, AML_LEVEL, AML_ACTIVE_HIGH, - AML_SHARED, &irqs, 1)); - aml_append(dev, aml_name_decl("_PRS", crs)); - - aml_append(dev, aml_name_decl("_CRS", crs)); - - /* - * _DIS can be no-op because the interrupt cannot be disabled. - */ - method = aml_method("_DIS", 0, AML_NOTSERIALIZED); - aml_append(dev, method); - - method = aml_method("_SRS", 1, AML_NOTSERIALIZED); - aml_append(dev, method); - - return dev; -} - /* _CRS method - get current settings */ static Aml *build_iqcr_method(bool is_piix4) { @@ -1728,54 +1293,6 @@ static void build_piix4_pci_hotplug(Aml *table) aml_append(table, scope); } -static Aml *build_q35_osc_method(void) -{ - Aml *if_ctx; - Aml *if_ctx2; - Aml *else_ctx; - Aml *method; - Aml *a_cwd1 = aml_name("CDW1"); - Aml *a_ctrl = aml_local(0); - - method = aml_method("_OSC", 4, AML_NOTSERIALIZED); - aml_append(method, aml_create_dword_field(aml_arg(3), aml_int(0), "CDW1")); - - if_ctx = aml_if(aml_equal( - aml_arg(0), aml_touuid("33DB4D5B-1FF7-401C-9657-7441C03DD766"))); - aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(4), "CDW2")); - aml_append(if_ctx, aml_create_dword_field(aml_arg(3), aml_int(8), "CDW3")); - - aml_append(if_ctx, aml_store(aml_name("CDW3"), a_ctrl)); - - /* - * Always allow native PME, AER (no dependencies) - * Allow SHPC (PCI bridges can have SHPC controller) - */ - aml_append(if_ctx, aml_and(a_ctrl, aml_int(0x1F), a_ctrl)); - - if_ctx2 = aml_if(aml_lnot(aml_equal(aml_arg(1), aml_int(1)))); - /* Unknown revision */ - aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x08), a_cwd1)); - aml_append(if_ctx, if_ctx2); - - if_ctx2 = aml_if(aml_lnot(aml_equal(aml_name("CDW3"), a_ctrl))); - /* Capabilities bits were masked */ - aml_append(if_ctx2, aml_or(a_cwd1, aml_int(0x10), a_cwd1)); - aml_append(if_ctx, if_ctx2); - - /* Update DWORD3 in the buffer */ - aml_append(if_ctx, aml_store(a_ctrl, aml_name("CDW3"))); - aml_append(method, if_ctx); - - else_ctx = aml_else(); - /* Unrecognized UUID */ - aml_append(else_ctx, aml_or(a_cwd1, aml_int(4), a_cwd1)); - aml_append(method, else_ctx); - - aml_append(method, aml_return(aml_arg(3))); - return method; -} - static void build_dsdt(GArray *table_data, BIOSLinker *linker, AcpiPmInfo *pm, AcpiMiscInfo *misc, @@ -1818,7 +1335,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker, aml_append(dev, aml_name_decl("_CID", aml_eisaid("PNP0A03"))); aml_append(dev, aml_name_decl("_ADR", aml_int(0))); aml_append(dev, aml_name_decl("_UID", aml_int(1))); - aml_append(dev, build_q35_osc_method()); + aml_append(dev, build_osc_method()); aml_append(sb_scope, dev); aml_append(dsdt, sb_scope); @@ -1883,7 +1400,7 @@ build_dsdt(GArray *table_data, BIOSLinker *linker, aml_append(dev, aml_name_decl("_HID", aml_eisaid("PNP0A03"))); aml_append(dev, aml_name_decl("_BBN", aml_int(bus_num))); if (pci_bus_is_express(bus)) { - aml_append(dev, build_q35_osc_method()); + aml_append(dev, build_osc_method()); } if (numa_node != NUMA_NODE_UNASSIGNED) { @@ -2370,35 +1887,6 @@ build_srat(GArray *table_data, BIOSLinker *linker, table_data->len - srat_start, 1, NULL, NULL); } -static void -build_mcfg_q35(GArray *table_data, BIOSLinker *linker, AcpiMcfgInfo *info) -{ - AcpiTableMcfg *mcfg; - const char *sig; - int len = sizeof(*mcfg) + 1 * sizeof(mcfg->allocation[0]); - - mcfg = acpi_data_push(table_data, len); - mcfg->allocation[0].address = cpu_to_le64(info->mcfg_base); - /* Only a single allocation so no need to play with segments */ - mcfg->allocation[0].pci_segment = cpu_to_le16(0); - mcfg->allocation[0].start_bus_number = 0; - mcfg->allocation[0].end_bus_number = PCIE_MMCFG_BUS(info->mcfg_size - 1); - - /* MCFG is used for ECAM which can be enabled or disabled by guest. - * To avoid table size changes (which create migration issues), - * always create the table even if there are no allocations, - * but set the signature to a reserved value in this case. - * ACPI spec requires OSPMs to ignore such tables. - */ - if (info->mcfg_base == PCIE_BASE_ADDR_UNMAPPED) { - /* Reserved signature: ignored by OSPM */ - sig = "QEMU"; - } else { - sig = "MCFG"; - } - build_header(linker, table_data, (void *)mcfg, sig, len, 1, NULL, NULL); -} - /* * VT-d spec 8.1 DMA Remapping Reporting Structure * (version Oct. 2014 or later) @@ -2626,7 +2114,7 @@ void acpi_build(AcpiBuildTables *tables, } if (acpi_get_mcfg(&mcfg)) { acpi_add_table(table_offsets, tables_blob); - build_mcfg_q35(tables_blob, tables->linker, &mcfg); + build_mcfg(tables_blob, tables->linker, &mcfg); } if (x86_iommu_get_default()) { IommuType IOMMUType = x86_iommu_get_type(); -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Samuel Ortiz Subject: [PATCH v5 07/24] hw: acpi: Generalize AML build routines Date: Mon, 5 Nov 2018 02:40:30 +0100 Message-ID: <20181105014047.26447-8-sameo@linux.intel.com> References: <20181105014047.26447-1-sameo@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1gJTuD-0003eV-0n for xen-devel@lists.xenproject.org; Mon, 05 Nov 2018 01:42:17 +0000 In-Reply-To: <20181105014047.26447-1-sameo@linux.intel.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: Yang Zhong , Peter Maydell , Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , Shannon Zhao , Igor Mammedov , qemu-arm@nongnu.org, Marcel Apfelbaum , Paolo Bonzini , Anthony Perard , xen-devel@lists.xenproject.org, Richard Henderson List-Id: xen-devel@lists.xenproject.org RnJvbTogWWFuZyBaaG9uZyA8eWFuZy56aG9uZ0BpbnRlbC5jb20+CgpNb3N0IG9mIHRoZSBBTUwg YnVpbGQgcm91dGluZXMgdW5kZXIgYWNwaS1idWlsZCBhcmUgbm90IGV2ZW4KYXJjaGl0ZWN0dXJl IHNwZWNpZmljLiBUaGV5IGNhbiBiZSBtb3ZlZCB0byB0aGUgbW9yZSBnZW5lcmljIGh3L2FjcGkK Zm9sZGVyIHdoZXJlIHRoZXkgY291bGQgYmUgc2hhcmVkIGFjcm9zcyBtYWNoaW5lIHR5cGVzIGFu ZAphcmNoaXRlY3R1cmVzLgoKUmV2aWV3ZWQtYnk6IFBoaWxpcHBlIE1hdGhpZXUtRGF1ZMOpIDxw aGlsbWRAcmVkaGF0LmNvbT4KVGVzdGVkLWJ5OiBQaGlsaXBwZSBNYXRoaWV1LURhdWTDqSA8cGhp bG1kQHJlZGhhdC5jb20+ClNpZ25lZC1vZmYtYnk6IFlhbmcgWmhvbmcgPHlhbmcuemhvbmdAaW50 ZWwuY29tPgotLS0KIGluY2x1ZGUvaHcvYWNwaS9hbWwtYnVpbGQuaCB8ICAyNSArKwogaHcvYWNw aS9hbWwtYnVpbGQuYyAgICAgICAgIHwgNDk4ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysKIGh3L2FybS92aXJ0LWFjcGktYnVpbGQuYyAgICB8ICAgNCArLQogaHcvaTM4Ni9hY3Bp LWJ1aWxkLmMgICAgICAgIHwgNTE4ICstLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQogNCBmaWxlcyBjaGFuZ2VkLCA1MjggaW5zZXJ0aW9ucygrKSwgNTE3IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL2luY2x1ZGUvaHcvYWNwaS9hbWwtYnVpbGQuaCBiL2luY2x1ZGUvaHcvYWNw aS9hbWwtYnVpbGQuaAppbmRleCBhMmVmOGI2ZjMxLi40ZjY3OGM0NWE1IDEwMDY0NAotLS0gYS9p bmNsdWRlL2h3L2FjcGkvYW1sLWJ1aWxkLmgKKysrIGIvaW5jbHVkZS9ody9hY3BpL2FtbC1idWls ZC5oCkBAIC0zLDYgKzMsNyBAQAogCiAjaW5jbHVkZSAiaHcvYWNwaS9hY3BpLWRlZnMuaCIKICNp bmNsdWRlICJody9hY3BpL2Jpb3MtbGlua2VyLWxvYWRlci5oIgorI2luY2x1ZGUgImh3L3BjaS9w Y2llX2hvc3QuaCIKIAogLyogUmVzZXJ2ZSBSQU0gc3BhY2UgZm9yIHRhYmxlczogYWRkIGFub3Ro ZXIgb3JkZXIgb2YgbWFnbml0dWRlLiAqLwogI2RlZmluZSBBQ1BJX0JVSUxEX1RBQkxFX01BWF9T SVpFICAgICAgICAgMHgyMDAwMDAKQEAgLTIyMyw2ICsyMjQsMjEgQEAgc3RydWN0IEFjcGlCdWls ZFRhYmxlcyB7CiAgICAgQklPU0xpbmtlciAqbGlua2VyOwogfSBBY3BpQnVpbGRUYWJsZXM7CiAK K3R5cGVkZWYgc3RydWN0IEFjcGlNY2ZnSW5mbyB7CisgICAgdWludDY0X3QgbWNmZ19iYXNlOwor ICAgIHVpbnQzMl90IG1jZmdfc2l6ZTsKK30gQWNwaU1jZmdJbmZvOworCit0eXBlZGVmIHN0cnVj dCBDcnNSYW5nZUVudHJ5IHsKKyAgICB1aW50NjRfdCBiYXNlOworICAgIHVpbnQ2NF90IGxpbWl0 OworfSBDcnNSYW5nZUVudHJ5OworCit0eXBlZGVmIHN0cnVjdCBDcnNSYW5nZVNldCB7CisgICAg R1B0ckFycmF5ICppb19yYW5nZXM7CisgICAgR1B0ckFycmF5ICptZW1fcmFuZ2VzOworICAgIEdQ dHJBcnJheSAqbWVtXzY0Yml0X3JhbmdlczsKK30gQ3JzUmFuZ2VTZXQ7CiAvKioKICAqIGluaXRf YW1sX2FsbG9jYXRvcjoKICAqCkBAIC0zODksNiArNDA1LDE1IEBAIHZvaWQgYWNwaV9hbGlnbl9z aXplKEdBcnJheSAqYmxvYiwgdW5zaWduZWQgYWxpZ24pOwogdm9pZCBhY3BpX2FkZF90YWJsZShH QXJyYXkgKnRhYmxlX29mZnNldHMsIEdBcnJheSAqdGFibGVfZGF0YSk7CiB2b2lkIGFjcGlfYnVp bGRfdGFibGVzX2luaXQoQWNwaUJ1aWxkVGFibGVzICp0YWJsZXMpOwogdm9pZCBhY3BpX2J1aWxk X3RhYmxlc19jbGVhbnVwKEFjcGlCdWlsZFRhYmxlcyAqdGFibGVzLCBib29sIG1mcmUpOworQW1s ICpidWlsZF9vc2NfbWV0aG9kKHZvaWQpOwordm9pZCBidWlsZF9tY2ZnKEdBcnJheSAqdGFibGVf ZGF0YSwgQklPU0xpbmtlciAqbGlua2VyLCBBY3BpTWNmZ0luZm8gKmluZm8pOworQW1sICpidWls ZF9nc2lfbGlua19kZXYoY29uc3QgY2hhciAqbmFtZSwgdWludDhfdCB1aWQsIHVpbnQ4X3QgZ3Np KTsKK0FtbCAqYnVpbGRfcHJ0KGJvb2wgaXNfcGNpMF9wcnQpOwordm9pZCBjcnNfcmFuZ2Vfc2V0 X2luaXQoQ3JzUmFuZ2VTZXQgKnJhbmdlX3NldCk7CitBbWwgKmJ1aWxkX2NycyhQQ0lIb3N0U3Rh dGUgKmhvc3QsIENyc1JhbmdlU2V0ICpyYW5nZV9zZXQpOwordm9pZCBjcnNfcmVwbGFjZV93aXRo X2ZyZWVfcmFuZ2VzKEdQdHJBcnJheSAqcmFuZ2VzLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHVpbnQ2NF90IHN0YXJ0LCB1aW50NjRfdCBlbmQpOwordm9pZCBjcnNfcmFuZ2Vf c2V0X2ZyZWUoQ3JzUmFuZ2VTZXQgKnJhbmdlX3NldCk7CiB2b2lkCiBidWlsZF9yc2RwX3JzZHQo R0FycmF5ICp0YWJsZV9kYXRhLAogICAgICAgICAgICAgICAgIEJJT1NMaW5rZXIgKmxpbmtlciwg dW5zaWduZWQgcnNkdF90Ymxfb2Zmc2V0KTsKZGlmZiAtLWdpdCBhL2h3L2FjcGkvYW1sLWJ1aWxk LmMgYi9ody9hY3BpL2FtbC1idWlsZC5jCmluZGV4IDhjMjM4ODI3NGMuLmQzMjQyYzZiMzEgMTAw NjQ0Ci0tLSBhL2h3L2FjcGkvYW1sLWJ1aWxkLmMKKysrIGIvaHcvYWNwaS9hbWwtYnVpbGQuYwpA QCAtMjUsNiArMjUsMTAgQEAKICNpbmNsdWRlICJxZW11L2Jzd2FwLmgiCiAjaW5jbHVkZSAicWVt dS9iaXRvcHMuaCIKICNpbmNsdWRlICJzeXNlbXUvbnVtYS5oIgorI2luY2x1ZGUgImh3L3BjaS9w Y2kuaCIKKyNpbmNsdWRlICJody9wY2kvcGNpX2J1cy5oIgorI2luY2x1ZGUgInFlbXUvcmFuZ2Uu aCIKKyNpbmNsdWRlICJody9wY2kvcGNpX2JyaWRnZS5oIgogCiBzdGF0aWMgR0FycmF5ICpidWls ZF9hbGxvY19hcnJheSh2b2lkKQogewpAQCAtMTU5Nyw2ICsxNjAxLDUwMCBAQCB2b2lkIGFjcGlf YnVpbGRfdGFibGVzX2NsZWFudXAoQWNwaUJ1aWxkVGFibGVzICp0YWJsZXMsIGJvb2wgbWZyZSkK ICAgICBnX2FycmF5X2ZyZWUodGFibGVzLT52bWdlbmlkLCBtZnJlKTsKIH0KIAorc3RhdGljIHZv aWQgY3JzX3JhbmdlX2luc2VydChHUHRyQXJyYXkgKnJhbmdlcywgdWludDY0X3QgYmFzZSwgdWlu dDY0X3QgbGltaXQpCit7CisgICAgQ3JzUmFuZ2VFbnRyeSAqZW50cnk7CisKKyAgICBlbnRyeSA9 IGdfbWFsbG9jKHNpemVvZigqZW50cnkpKTsKKyAgICBlbnRyeS0+YmFzZSA9IGJhc2U7CisgICAg ZW50cnktPmxpbWl0ID0gbGltaXQ7CisKKyAgICBnX3B0cl9hcnJheV9hZGQocmFuZ2VzLCBlbnRy eSk7Cit9CisKK3N0YXRpYyB2b2lkIGNyc19yYW5nZV9mcmVlKGdwb2ludGVyIGRhdGEpCit7Cisg ICAgQ3JzUmFuZ2VFbnRyeSAqZW50cnkgPSAoQ3JzUmFuZ2VFbnRyeSAqKWRhdGE7CisgICAgZ19m cmVlKGVudHJ5KTsKK30KKwordm9pZCBjcnNfcmFuZ2Vfc2V0X2luaXQoQ3JzUmFuZ2VTZXQgKnJh bmdlX3NldCkKK3sKKyAgICByYW5nZV9zZXQtPmlvX3JhbmdlcyA9IGdfcHRyX2FycmF5X25ld193 aXRoX2ZyZWVfZnVuYyhjcnNfcmFuZ2VfZnJlZSk7CisgICAgcmFuZ2Vfc2V0LT5tZW1fcmFuZ2Vz ID0gZ19wdHJfYXJyYXlfbmV3X3dpdGhfZnJlZV9mdW5jKGNyc19yYW5nZV9mcmVlKTsKKyAgICBy YW5nZV9zZXQtPm1lbV82NGJpdF9yYW5nZXMgPQorICAgICAgICAgICAgZ19wdHJfYXJyYXlfbmV3 X3dpdGhfZnJlZV9mdW5jKGNyc19yYW5nZV9mcmVlKTsKK30KKwordm9pZCBjcnNfcmFuZ2Vfc2V0 X2ZyZWUoQ3JzUmFuZ2VTZXQgKnJhbmdlX3NldCkKK3sKKyAgICBnX3B0cl9hcnJheV9mcmVlKHJh bmdlX3NldC0+aW9fcmFuZ2VzLCB0cnVlKTsKKyAgICBnX3B0cl9hcnJheV9mcmVlKHJhbmdlX3Nl dC0+bWVtX3JhbmdlcywgdHJ1ZSk7CisgICAgZ19wdHJfYXJyYXlfZnJlZShyYW5nZV9zZXQtPm1l bV82NGJpdF9yYW5nZXMsIHRydWUpOworfQorCitzdGF0aWMgZ2ludCBjcnNfcmFuZ2VfY29tcGFy ZShnY29uc3Rwb2ludGVyIGEsIGdjb25zdHBvaW50ZXIgYikKK3sKKyAgICAgQ3JzUmFuZ2VFbnRy eSAqZW50cnlfYSA9ICooQ3JzUmFuZ2VFbnRyeSAqKilhOworICAgICBDcnNSYW5nZUVudHJ5ICpl bnRyeV9iID0gKihDcnNSYW5nZUVudHJ5ICoqKWI7CisKKyAgICAgcmV0dXJuIChpbnQ2NF90KWVu dHJ5X2EtPmJhc2UgLSAoaW50NjRfdCllbnRyeV9iLT5iYXNlOworfQorCisvKgorICogY3JzX3Jl cGxhY2Vfd2l0aF9mcmVlX3JhbmdlcyAtIGdpdmVuIHRoZSAndXNlZCcgcmFuZ2VzIHdpdGhpbiBb c3RhcnQgLSBlbmRdCisgKiBpbnRlcnZhbCwgY29tcHV0ZXMgdGhlICdmcmVlJyByYW5nZXMgZnJv bSB0aGUgc2FtZSBpbnRlcnZhbC4KKyAqIEV4YW1wbGU6IElmIHRoZSBpbnB1dCBhcnJheSBpcyB7 IFthMSAtIGEyXSxbYjEgLSBiMl0gfSwgdGhlIGZ1bmN0aW9uCisgKiB3aWxsIHJldHVybiB7IFti YXNlIC0gYTFdLCBbYTIgLSBiMV0sIFtiMiAtIGxpbWl0XSB9LgorICovCit2b2lkIGNyc19yZXBs YWNlX3dpdGhfZnJlZV9yYW5nZXMoR1B0ckFycmF5ICpyYW5nZXMsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQ2NF90IHN0YXJ0LCB1aW50NjRfdCBlbmQpCit7 CisgICAgR1B0ckFycmF5ICpmcmVlX3JhbmdlcyA9IGdfcHRyX2FycmF5X25ldygpOworICAgIHVp bnQ2NF90IGZyZWVfYmFzZSA9IHN0YXJ0OworICAgIGludCBpOworCisgICAgZ19wdHJfYXJyYXlf c29ydChyYW5nZXMsIGNyc19yYW5nZV9jb21wYXJlKTsKKyAgICBmb3IgKGkgPSAwOyBpIDwgcmFu Z2VzLT5sZW47IGkrKykgeworICAgICAgICBDcnNSYW5nZUVudHJ5ICp1c2VkID0gZ19wdHJfYXJy YXlfaW5kZXgocmFuZ2VzLCBpKTsKKworICAgICAgICBpZiAoZnJlZV9iYXNlIDwgdXNlZC0+YmFz ZSkgeworICAgICAgICAgICAgY3JzX3JhbmdlX2luc2VydChmcmVlX3JhbmdlcywgZnJlZV9iYXNl LCB1c2VkLT5iYXNlIC0gMSk7CisgICAgICAgIH0KKworICAgICAgICBmcmVlX2Jhc2UgPSB1c2Vk LT5saW1pdCArIDE7CisgICAgfQorCisgICAgaWYgKGZyZWVfYmFzZSA8IGVuZCkgeworICAgICAg ICBjcnNfcmFuZ2VfaW5zZXJ0KGZyZWVfcmFuZ2VzLCBmcmVlX2Jhc2UsIGVuZCk7CisgICAgfQor CisgICAgZ19wdHJfYXJyYXlfc2V0X3NpemUocmFuZ2VzLCAwKTsKKyAgICBmb3IgKGkgPSAwOyBp IDwgZnJlZV9yYW5nZXMtPmxlbjsgaSsrKSB7CisgICAgICAgIGdfcHRyX2FycmF5X2FkZChyYW5n ZXMsIGdfcHRyX2FycmF5X2luZGV4KGZyZWVfcmFuZ2VzLCBpKSk7CisgICAgfQorCisgICAgZ19w dHJfYXJyYXlfZnJlZShmcmVlX3JhbmdlcywgdHJ1ZSk7Cit9CisKKy8qCisgKiBjcnNfcmFuZ2Vf bWVyZ2UgLSBtZXJnZXMgYWRqYWNlbnQgcmFuZ2VzIGluIHRoZSBnaXZlbiBhcnJheS4KKyAqIEFy cmF5IGVsZW1lbnRzIGFyZSBkZWxldGVkIGFuZCByZXBsYWNlZCB3aXRoIHRoZSBtZXJnZWQgcmFu Z2VzLgorICovCitzdGF0aWMgdm9pZCBjcnNfcmFuZ2VfbWVyZ2UoR1B0ckFycmF5ICpyYW5nZSkK K3sKKyAgICBHUHRyQXJyYXkgKnRtcCA9ICBnX3B0cl9hcnJheV9uZXdfd2l0aF9mcmVlX2Z1bmMo Y3JzX3JhbmdlX2ZyZWUpOworICAgIENyc1JhbmdlRW50cnkgKmVudHJ5OworICAgIHVpbnQ2NF90 IHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0OworICAgIGludCBpOworCisgICAgaWYgKCFyYW5nZS0+ bGVuKSB7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBnX3B0cl9hcnJheV9zb3J0KHJh bmdlLCBjcnNfcmFuZ2VfY29tcGFyZSk7CisKKyAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4 KHJhbmdlLCAwKTsKKyAgICByYW5nZV9iYXNlID0gZW50cnktPmJhc2U7CisgICAgcmFuZ2VfbGlt aXQgPSBlbnRyeS0+bGltaXQ7CisgICAgZm9yIChpID0gMTsgaSA8IHJhbmdlLT5sZW47IGkrKykg eworICAgICAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4KHJhbmdlLCBpKTsKKyAgICAgICAg aWYgKGVudHJ5LT5iYXNlIC0gMSA9PSByYW5nZV9saW1pdCkgeworICAgICAgICAgICAgcmFuZ2Vf bGltaXQgPSBlbnRyeS0+bGltaXQ7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBjcnNf cmFuZ2VfaW5zZXJ0KHRtcCwgcmFuZ2VfYmFzZSwgcmFuZ2VfbGltaXQpOworICAgICAgICAgICAg cmFuZ2VfYmFzZSA9IGVudHJ5LT5iYXNlOworICAgICAgICAgICAgcmFuZ2VfbGltaXQgPSBlbnRy eS0+bGltaXQ7CisgICAgICAgIH0KKyAgICB9CisgICAgY3JzX3JhbmdlX2luc2VydCh0bXAsIHJh bmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsKKworICAgIGdfcHRyX2FycmF5X3NldF9zaXplKHJhbmdl LCAwKTsKKyAgICBmb3IgKGkgPSAwOyBpIDwgdG1wLT5sZW47IGkrKykgeworICAgICAgICBlbnRy eSA9IGdfcHRyX2FycmF5X2luZGV4KHRtcCwgaSk7CisgICAgICAgIGNyc19yYW5nZV9pbnNlcnQo cmFuZ2UsIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGltaXQpOworICAgIH0KKyAgICBnX3B0cl9hcnJh eV9mcmVlKHRtcCwgdHJ1ZSk7Cit9CisKK0FtbCAqYnVpbGRfY3JzKFBDSUhvc3RTdGF0ZSAqaG9z dCwgQ3JzUmFuZ2VTZXQgKnJhbmdlX3NldCkKK3sKKyAgICBBbWwgKmNycyA9IGFtbF9yZXNvdXJj ZV90ZW1wbGF0ZSgpOworICAgIENyc1JhbmdlU2V0IHRlbXBfcmFuZ2Vfc2V0OworICAgIENyc1Jh bmdlRW50cnkgKmVudHJ5OworICAgIHVpbnQ4X3QgbWF4X2J1cyA9IHBjaV9idXNfbnVtKGhvc3Qt PmJ1cyk7CisgICAgdWludDhfdCB0eXBlOworICAgIGludCBkZXZmbjsKKyAgICBpbnQgaTsKKwor ICAgIGNyc19yYW5nZV9zZXRfaW5pdCgmdGVtcF9yYW5nZV9zZXQpOworICAgIGZvciAoZGV2Zm4g PSAwOyBkZXZmbiA8IEFSUkFZX1NJWkUoaG9zdC0+YnVzLT5kZXZpY2VzKTsgZGV2Zm4rKykgewor ICAgICAgICB1aW50NjRfdCByYW5nZV9iYXNlLCByYW5nZV9saW1pdDsKKyAgICAgICAgUENJRGV2 aWNlICpkZXYgPSBob3N0LT5idXMtPmRldmljZXNbZGV2Zm5dOworCisgICAgICAgIGlmICghZGV2 KSB7CisgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgfQorCisgICAgICAgIGZvciAoaSA9 IDA7IGkgPCBQQ0lfTlVNX1JFR0lPTlM7IGkrKykgeworICAgICAgICAgICAgUENJSU9SZWdpb24g KnIgPSAmZGV2LT5pb19yZWdpb25zW2ldOworCisgICAgICAgICAgICByYW5nZV9iYXNlID0gci0+ YWRkcjsKKyAgICAgICAgICAgIHJhbmdlX2xpbWl0ID0gci0+YWRkciArIHItPnNpemUgLSAxOwor CisgICAgICAgICAgICAvKgorICAgICAgICAgICAgICogV29yay1hcm91bmQgZm9yIG9sZCBiaW9z ZXMKKyAgICAgICAgICAgICAqIHRoYXQgZG8gbm90IHN1cHBvcnQgbXVsdGlwbGUgcm9vdCBidXNl cworICAgICAgICAgICAgICovCisgICAgICAgICAgICBpZiAoIXJhbmdlX2Jhc2UgfHwgcmFuZ2Vf YmFzZSA+IHJhbmdlX2xpbWl0KSB7CisgICAgICAgICAgICAgICAgY29udGludWU7CisgICAgICAg ICAgICB9CisKKyAgICAgICAgICAgIGlmIChyLT50eXBlICYgUENJX0JBU0VfQUREUkVTU19TUEFD RV9JTykgeworICAgICAgICAgICAgICAgIGNyc19yYW5nZV9pbnNlcnQodGVtcF9yYW5nZV9zZXQu aW9fcmFuZ2VzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmFuZ2VfYmFzZSwg cmFuZ2VfbGltaXQpOworICAgICAgICAgICAgfSBlbHNlIHsgLyogIm1lbW9yeSIgKi8KKyAgICAg ICAgICAgICAgICBjcnNfcmFuZ2VfaW5zZXJ0KHRlbXBfcmFuZ2Vfc2V0Lm1lbV9yYW5nZXMsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5nZV9iYXNlLCByYW5nZV9saW1pdCk7 CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgICB0eXBlID0gZGV2LT5jb25maWdb UENJX0hFQURFUl9UWVBFXSAmIH5QQ0lfSEVBREVSX1RZUEVfTVVMVElfRlVOQ1RJT047CisgICAg ICAgIGlmICh0eXBlID09IFBDSV9IRUFERVJfVFlQRV9CUklER0UpIHsKKyAgICAgICAgICAgIHVp bnQ4X3Qgc3Vib3JkaW5hdGUgPSBkZXYtPmNvbmZpZ1tQQ0lfU1VCT1JESU5BVEVfQlVTXTsKKyAg ICAgICAgICAgIGlmIChzdWJvcmRpbmF0ZSA+IG1heF9idXMpIHsKKyAgICAgICAgICAgICAgICBt YXhfYnVzID0gc3Vib3JkaW5hdGU7CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIHJhbmdl X2Jhc2UgPSBwY2lfYnJpZGdlX2dldF9iYXNlKGRldiwgUENJX0JBU0VfQUREUkVTU19TUEFDRV9J Tyk7CisgICAgICAgICAgICByYW5nZV9saW1pdCA9IHBjaV9icmlkZ2VfZ2V0X2xpbWl0KGRldiwg UENJX0JBU0VfQUREUkVTU19TUEFDRV9JTyk7CisKKyAgICAgICAgICAgIC8qCisgICAgICAgICAg ICAgKiBXb3JrLWFyb3VuZCBmb3Igb2xkIGJpb3NlcworICAgICAgICAgICAgICogdGhhdCBkbyBu b3Qgc3VwcG9ydCBtdWx0aXBsZSByb290IGJ1c2VzCisgICAgICAgICAgICAgKi8KKyAgICAgICAg ICAgIGlmIChyYW5nZV9iYXNlICYmIHJhbmdlX2Jhc2UgPD0gcmFuZ2VfbGltaXQpIHsKKyAgICAg ICAgICAgICAgICBjcnNfcmFuZ2VfaW5zZXJ0KHRlbXBfcmFuZ2Vfc2V0LmlvX3JhbmdlcywKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsK KyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgcmFuZ2VfYmFzZSA9CisgICAgICAgICAgICAg ICAgcGNpX2JyaWRnZV9nZXRfYmFzZShkZXYsIFBDSV9CQVNFX0FERFJFU1NfU1BBQ0VfTUVNT1JZ KTsKKyAgICAgICAgICAgIHJhbmdlX2xpbWl0ID0KKyAgICAgICAgICAgICAgICBwY2lfYnJpZGdl X2dldF9saW1pdChkZXYsIFBDSV9CQVNFX0FERFJFU1NfU1BBQ0VfTUVNT1JZKTsKKworICAgICAg ICAgICAgLyoKKyAgICAgICAgICAgICAqIFdvcmstYXJvdW5kIGZvciBvbGQgYmlvc2VzCisgICAg ICAgICAgICAgKiB0aGF0IGRvIG5vdCBzdXBwb3J0IG11bHRpcGxlIHJvb3QgYnVzZXMKKyAgICAg ICAgICAgICAqLworICAgICAgICAgICAgaWYgKHJhbmdlX2Jhc2UgJiYgcmFuZ2VfYmFzZSA8PSBy YW5nZV9saW1pdCkgeworICAgICAgICAgICAgICAgIHVpbnQ2NF90IGxlbmd0aCA9IHJhbmdlX2xp bWl0IC0gcmFuZ2VfYmFzZSArIDE7CisgICAgICAgICAgICAgICAgaWYgKHJhbmdlX2xpbWl0IDw9 IFVJTlQzMl9NQVggJiYgbGVuZ3RoIDw9IFVJTlQzMl9NQVgpICB7CisgICAgICAgICAgICAgICAg ICAgIGNyc19yYW5nZV9pbnNlcnQodGVtcF9yYW5nZV9zZXQubWVtX3JhbmdlcywKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5nZV9iYXNlLCByYW5nZV9saW1pdCk7Cisg ICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgY3JzX3JhbmdlX2lu c2VydCh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsKKyAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIHJhbmdlX2Jhc2UgPQorICAgICAg ICAgICAgICAgIHBjaV9icmlkZ2VfZ2V0X2Jhc2UoZGV2LCBQQ0lfQkFTRV9BRERSRVNTX01FTV9Q UkVGRVRDSCk7CisgICAgICAgICAgICByYW5nZV9saW1pdCA9CisgICAgICAgICAgICAgICAgcGNp X2JyaWRnZV9nZXRfbGltaXQoZGV2LCBQQ0lfQkFTRV9BRERSRVNTX01FTV9QUkVGRVRDSCk7CisK KyAgICAgICAgICAgIC8qCisgICAgICAgICAgICAgKiBXb3JrLWFyb3VuZCBmb3Igb2xkIGJpb3Nl cworICAgICAgICAgICAgICogdGhhdCBkbyBub3Qgc3VwcG9ydCBtdWx0aXBsZSByb290IGJ1c2Vz CisgICAgICAgICAgICAgKi8KKyAgICAgICAgICAgIGlmIChyYW5nZV9iYXNlICYmIHJhbmdlX2Jh c2UgPD0gcmFuZ2VfbGltaXQpIHsKKyAgICAgICAgICAgICAgICB1aW50NjRfdCBsZW5ndGggPSBy YW5nZV9saW1pdCAtIHJhbmdlX2Jhc2UgKyAxOworICAgICAgICAgICAgICAgIGlmIChyYW5nZV9s aW1pdCA8PSBVSU5UMzJfTUFYICYmIGxlbmd0aCA8PSBVSU5UMzJfTUFYKSB7CisgICAgICAgICAg ICAgICAgICAgIGNyc19yYW5nZV9pbnNlcnQodGVtcF9yYW5nZV9zZXQubWVtX3JhbmdlcywKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5nZV9iYXNlLCByYW5nZV9saW1p dCk7CisgICAgICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICAgICAgY3JzX3Jh bmdlX2luc2VydCh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsKKyAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICBjcnNf cmFuZ2VfbWVyZ2UodGVtcF9yYW5nZV9zZXQuaW9fcmFuZ2VzKTsKKyAgICBmb3IgKGkgPSAwOyBp IDwgdGVtcF9yYW5nZV9zZXQuaW9fcmFuZ2VzLT5sZW47IGkrKykgeworICAgICAgICBlbnRyeSA9 IGdfcHRyX2FycmF5X2luZGV4KHRlbXBfcmFuZ2Vfc2V0LmlvX3JhbmdlcywgaSk7CisgICAgICAg IGFtbF9hcHBlbmQoY3JzLAorICAgICAgICAgICAgICAgICAgIGFtbF93b3JkX2lvKEFNTF9NSU5f RklYRUQsIEFNTF9NQVhfRklYRUQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQU1M X1BPU19ERUNPREUsIEFNTF9FTlRJUkVfUkFOR0UsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgMCwgZW50cnktPmJhc2UsIGVudHJ5LT5saW1pdCwgMCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBlbnRyeS0+bGltaXQgLSBlbnRyeS0+YmFzZSArIDEpKTsKKyAgICAgICAg Y3JzX3JhbmdlX2luc2VydChyYW5nZV9zZXQtPmlvX3JhbmdlcywgZW50cnktPmJhc2UsIGVudHJ5 LT5saW1pdCk7CisgICAgfQorCisgICAgY3JzX3JhbmdlX21lcmdlKHRlbXBfcmFuZ2Vfc2V0Lm1l bV9yYW5nZXMpOworICAgIGZvciAoaSA9IDA7IGkgPCB0ZW1wX3JhbmdlX3NldC5tZW1fcmFuZ2Vz LT5sZW47IGkrKykgeworICAgICAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4KHRlbXBfcmFu Z2Vfc2V0Lm1lbV9yYW5nZXMsIGkpOworICAgICAgICBhbWxfYXBwZW5kKGNycywKKyAgICAgICAg ICAgICAgICAgICBhbWxfZHdvcmRfbWVtb3J5KEFNTF9QT1NfREVDT0RFLCBBTUxfTUlOX0ZJWEVE LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQU1MX01BWF9GSVhFRCwgQU1M X05PTl9DQUNIRUFCTEUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBBTUxf UkVBRF9XUklURSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAsIGVudHJ5 LT5iYXNlLCBlbnRyeS0+bGltaXQsIDAsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBlbnRyeS0+bGltaXQgLSBlbnRyeS0+YmFzZSArIDEpKTsKKyAgICAgICAgY3JzX3Jhbmdl X2luc2VydChyYW5nZV9zZXQtPm1lbV9yYW5nZXMsIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGltaXQp OworICAgIH0KKworICAgIGNyc19yYW5nZV9tZXJnZSh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRf cmFuZ2VzKTsKKyAgICBmb3IgKGkgPSAwOyBpIDwgdGVtcF9yYW5nZV9zZXQubWVtXzY0Yml0X3Jh bmdlcy0+bGVuOyBpKyspIHsKKyAgICAgICAgZW50cnkgPSBnX3B0cl9hcnJheV9pbmRleCh0ZW1w X3JhbmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzLCBpKTsKKyAgICAgICAgYW1sX2FwcGVuZChjcnMs CisgICAgICAgICAgICAgICAgICAgYW1sX3F3b3JkX21lbW9yeShBTUxfUE9TX0RFQ09ERSwgQU1M X01JTl9GSVhFRCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFNTF9NQVhf RklYRUQsIEFNTF9OT05fQ0FDSEVBQkxFLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgQU1MX1JFQURfV1JJVEUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAwLCBlbnRyeS0+YmFzZSwgZW50cnktPmxpbWl0LCAwLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZW50cnktPmxpbWl0IC0gZW50cnktPmJhc2UgKyAxKSk7CisgICAgICAg IGNyc19yYW5nZV9pbnNlcnQocmFuZ2Vfc2V0LT5tZW1fNjRiaXRfcmFuZ2VzLAorICAgICAgICAg ICAgICAgICAgICAgICAgIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGltaXQpOworICAgIH0KKworICAg IGNyc19yYW5nZV9zZXRfZnJlZSgmdGVtcF9yYW5nZV9zZXQpOworCisgICAgYW1sX2FwcGVuZChj cnMsCisgICAgICAgIGFtbF93b3JkX2J1c19udW1iZXIoQU1MX01JTl9GSVhFRCwgQU1MX01BWF9G SVhFRCwgQU1MX1BPU19ERUNPREUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgMCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICBwY2lfYnVzX251bShob3N0LT5idXMpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG1heF9idXMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgMCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBtYXhfYnVzIC0gcGNpX2J1c19udW0o aG9zdC0+YnVzKSArIDEpKTsKKworICAgIHJldHVybiBjcnM7Cit9CisKK0FtbCAqYnVpbGRfb3Nj X21ldGhvZCh2b2lkKQoreworICAgIEFtbCAqaWZfY3R4OworICAgIEFtbCAqaWZfY3R4MjsKKyAg ICBBbWwgKmVsc2VfY3R4OworICAgIEFtbCAqbWV0aG9kOworICAgIEFtbCAqYV9jd2QxID0gYW1s X25hbWUoIkNEVzEiKTsKKyAgICBBbWwgKmFfY3RybCA9IGFtbF9sb2NhbCgwKTsKKworICAgIG1l dGhvZCA9IGFtbF9tZXRob2QoIl9PU0MiLCA0LCBBTUxfTk9UU0VSSUFMSVpFRCk7CisgICAgYW1s X2FwcGVuZChtZXRob2QsIGFtbF9jcmVhdGVfZHdvcmRfZmllbGQoYW1sX2FyZygzKSwgYW1sX2lu dCgwKSwgIkNEVzEiKSk7CisKKyAgICBpZl9jdHggPSBhbWxfaWYoYW1sX2VxdWFsKAorICAgICAg ICBhbWxfYXJnKDApLCBhbWxfdG91dWlkKCIzM0RCNEQ1Qi0xRkY3LTQwMUMtOTY1Ny03NDQxQzAz REQ3NjYiKSkpOworICAgIGFtbF9hcHBlbmQoaWZfY3R4LCBhbWxfY3JlYXRlX2R3b3JkX2ZpZWxk KGFtbF9hcmcoMyksIGFtbF9pbnQoNCksICJDRFcyIikpOworICAgIGFtbF9hcHBlbmQoaWZfY3R4 LCBhbWxfY3JlYXRlX2R3b3JkX2ZpZWxkKGFtbF9hcmcoMyksIGFtbF9pbnQoOCksICJDRFczIikp OworCisgICAgYW1sX2FwcGVuZChpZl9jdHgsIGFtbF9zdG9yZShhbWxfbmFtZSgiQ0RXMyIpLCBh X2N0cmwpKTsKKworICAgIC8qCisgICAgICogQWx3YXlzIGFsbG93IG5hdGl2ZSBQTUUsIEFFUiAo bm8gZGVwZW5kZW5jaWVzKQorICAgICAqIEFsbG93IFNIUEMgKFBDSSBicmlkZ2VzIGNhbiBoYXZl IFNIUEMgY29udHJvbGxlcikKKyAgICAgKi8KKyAgICBhbWxfYXBwZW5kKGlmX2N0eCwgYW1sX2Fu ZChhX2N0cmwsIGFtbF9pbnQoMHgxRiksIGFfY3RybCkpOworCisgICAgaWZfY3R4MiA9IGFtbF9p ZihhbWxfbG5vdChhbWxfZXF1YWwoYW1sX2FyZygxKSwgYW1sX2ludCgxKSkpKTsKKyAgICAvKiBV bmtub3duIHJldmlzaW9uICovCisgICAgYW1sX2FwcGVuZChpZl9jdHgyLCBhbWxfb3IoYV9jd2Qx LCBhbWxfaW50KDB4MDgpLCBhX2N3ZDEpKTsKKyAgICBhbWxfYXBwZW5kKGlmX2N0eCwgaWZfY3R4 Mik7CisKKyAgICBpZl9jdHgyID0gYW1sX2lmKGFtbF9sbm90KGFtbF9lcXVhbChhbWxfbmFtZSgi Q0RXMyIpLCBhX2N0cmwpKSk7CisgICAgLyogQ2FwYWJpbGl0aWVzIGJpdHMgd2VyZSBtYXNrZWQg Ki8KKyAgICBhbWxfYXBwZW5kKGlmX2N0eDIsIGFtbF9vcihhX2N3ZDEsIGFtbF9pbnQoMHgxMCks IGFfY3dkMSkpOworICAgIGFtbF9hcHBlbmQoaWZfY3R4LCBpZl9jdHgyKTsKKworICAgIC8qIFVw ZGF0ZSBEV09SRDMgaW4gdGhlIGJ1ZmZlciAqLworICAgIGFtbF9hcHBlbmQoaWZfY3R4LCBhbWxf c3RvcmUoYV9jdHJsLCBhbWxfbmFtZSgiQ0RXMyIpKSk7CisgICAgYW1sX2FwcGVuZChtZXRob2Qs IGlmX2N0eCk7CisKKyAgICBlbHNlX2N0eCA9IGFtbF9lbHNlKCk7CisgICAgLyogVW5yZWNvZ25p emVkIFVVSUQgKi8KKyAgICBhbWxfYXBwZW5kKGVsc2VfY3R4LCBhbWxfb3IoYV9jd2QxLCBhbWxf aW50KDQpLCBhX2N3ZDEpKTsKKyAgICBhbWxfYXBwZW5kKG1ldGhvZCwgZWxzZV9jdHgpOworCisg ICAgYW1sX2FwcGVuZChtZXRob2QsIGFtbF9yZXR1cm4oYW1sX2FyZygzKSkpOworICAgIHJldHVy biBtZXRob2Q7Cit9CisKK3ZvaWQKK2J1aWxkX21jZmcoR0FycmF5ICp0YWJsZV9kYXRhLCBCSU9T TGlua2VyICpsaW5rZXIsIEFjcGlNY2ZnSW5mbyAqaW5mbykKK3sKKyAgICBBY3BpVGFibGVNY2Zn ICptY2ZnOworICAgIGNvbnN0IGNoYXIgKnNpZzsKKyAgICBpbnQgbGVuID0gc2l6ZW9mKCptY2Zn KSArIDEgKiBzaXplb2YobWNmZy0+YWxsb2NhdGlvblswXSk7CisKKyAgICBtY2ZnID0gYWNwaV9k YXRhX3B1c2godGFibGVfZGF0YSwgbGVuKTsKKyAgICBtY2ZnLT5hbGxvY2F0aW9uWzBdLmFkZHJl c3MgPSBjcHVfdG9fbGU2NChpbmZvLT5tY2ZnX2Jhc2UpOworICAgIC8qIE9ubHkgYSBzaW5nbGUg YWxsb2NhdGlvbiBzbyBubyBuZWVkIHRvIHBsYXkgd2l0aCBzZWdtZW50cyAqLworICAgIG1jZmct PmFsbG9jYXRpb25bMF0ucGNpX3NlZ21lbnQgPSBjcHVfdG9fbGUxNigwKTsKKyAgICBtY2ZnLT5h bGxvY2F0aW9uWzBdLnN0YXJ0X2J1c19udW1iZXIgPSAwOworICAgIG1jZmctPmFsbG9jYXRpb25b MF0uZW5kX2J1c19udW1iZXIgPSBQQ0lFX01NQ0ZHX0JVUyhpbmZvLT5tY2ZnX3NpemUgLSAxKTsK KworICAgIC8qIE1DRkcgaXMgdXNlZCBmb3IgRUNBTSB3aGljaCBjYW4gYmUgZW5hYmxlZCBvciBk aXNhYmxlZCBieSBndWVzdC4KKyAgICAgKiBUbyBhdm9pZCB0YWJsZSBzaXplIGNoYW5nZXMgKHdo aWNoIGNyZWF0ZSBtaWdyYXRpb24gaXNzdWVzKSwKKyAgICAgKiBhbHdheXMgY3JlYXRlIHRoZSB0 YWJsZSBldmVuIGlmIHRoZXJlIGFyZSBubyBhbGxvY2F0aW9ucywKKyAgICAgKiBidXQgc2V0IHRo ZSBzaWduYXR1cmUgdG8gYSByZXNlcnZlZCB2YWx1ZSBpbiB0aGlzIGNhc2UuCisgICAgICogQUNQ SSBzcGVjIHJlcXVpcmVzIE9TUE1zIHRvIGlnbm9yZSBzdWNoIHRhYmxlcy4KKyAgICAgKi8KKyAg ICBpZiAoaW5mby0+bWNmZ19iYXNlID09IFBDSUVfQkFTRV9BRERSX1VOTUFQUEVEKSB7CisgICAg ICAgIC8qIFJlc2VydmVkIHNpZ25hdHVyZTogaWdub3JlZCBieSBPU1BNICovCisgICAgICAgIHNp ZyA9ICJRRU1VIjsKKyAgICB9IGVsc2UgeworICAgICAgICBzaWcgPSAiTUNGRyI7CisgICAgfQor ICAgIGJ1aWxkX2hlYWRlcihsaW5rZXIsIHRhYmxlX2RhdGEsICh2b2lkICopbWNmZywgc2lnLCBs ZW4sIDEsIE5VTEwsIE5VTEwpOworfQorCitBbWwgKmJ1aWxkX2dzaV9saW5rX2Rldihjb25zdCBj aGFyICpuYW1lLCB1aW50OF90IHVpZCwgdWludDhfdCBnc2kpCit7CisgICAgQW1sICpkZXY7Cisg ICAgQW1sICpjcnM7CisgICAgQW1sICptZXRob2Q7CisgICAgdWludDMyX3QgaXJxczsKKworICAg IGRldiA9IGFtbF9kZXZpY2UoIiVzIiwgbmFtZSk7CisgICAgYW1sX2FwcGVuZChkZXYsIGFtbF9u YW1lX2RlY2woIl9ISUQiLCBhbWxfZWlzYWlkKCJQTlAwQzBGIikpKTsKKyAgICBhbWxfYXBwZW5k KGRldiwgYW1sX25hbWVfZGVjbCgiX1VJRCIsIGFtbF9pbnQodWlkKSkpOworCisgICAgY3JzID0g YW1sX3Jlc291cmNlX3RlbXBsYXRlKCk7CisgICAgaXJxcyA9IGdzaTsKKyAgICBhbWxfYXBwZW5k KGNycywgYW1sX2ludGVycnVwdChBTUxfQ09OU1VNRVIsIEFNTF9MRVZFTCwgQU1MX0FDVElWRV9I SUdILAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFNTF9TSEFSRUQsICZpcnFz LCAxKSk7CisgICAgYW1sX2FwcGVuZChkZXYsIGFtbF9uYW1lX2RlY2woIl9QUlMiLCBjcnMpKTsK KworICAgIGFtbF9hcHBlbmQoZGV2LCBhbWxfbmFtZV9kZWNsKCJfQ1JTIiwgY3JzKSk7CisKKyAg ICAvKgorICAgICAqIF9ESVMgY2FuIGJlIG5vLW9wIGJlY2F1c2UgdGhlIGludGVycnVwdCBjYW5u b3QgYmUgZGlzYWJsZWQuCisgICAgICovCisgICAgbWV0aG9kID0gYW1sX21ldGhvZCgiX0RJUyIs IDAsIEFNTF9OT1RTRVJJQUxJWkVEKTsKKyAgICBhbWxfYXBwZW5kKGRldiwgbWV0aG9kKTsKKwor ICAgIG1ldGhvZCA9IGFtbF9tZXRob2QoIl9TUlMiLCAxLCBBTUxfTk9UU0VSSUFMSVpFRCk7Cisg ICAgYW1sX2FwcGVuZChkZXYsIG1ldGhvZCk7CisKKyAgICByZXR1cm4gZGV2OworfQorCisvKioK KyAqIGJ1aWxkX3BydF9lbnRyeToKKyAqIEBsaW5rX25hbWU6IGxpbmsgbmFtZSBmb3IgUENJIHJv dXRlIGVudHJ5CisgKgorICogYnVpbGQgQU1MIHBhY2thZ2UgY29udGFpbmluZyBhIFBDSSByb3V0 ZSBlbnRyeSBmb3IgQGxpbmtfbmFtZQorICovCitzdGF0aWMgQW1sICpidWlsZF9wcnRfZW50cnko Y29uc3QgY2hhciAqbGlua19uYW1lKQoreworICAgIEFtbCAqYV96ZXJvID0gYW1sX2ludCgwKTsK KyAgICBBbWwgKnBrZyA9IGFtbF9wYWNrYWdlKDQpOworICAgIGFtbF9hcHBlbmQocGtnLCBhX3pl cm8pOworICAgIGFtbF9hcHBlbmQocGtnLCBhX3plcm8pOworICAgIGFtbF9hcHBlbmQocGtnLCBh bWxfbmFtZSgiJXMiLCBsaW5rX25hbWUpKTsKKyAgICBhbWxfYXBwZW5kKHBrZywgYV96ZXJvKTsK KyAgICByZXR1cm4gcGtnOworfQorCisvKgorICogaW5pdGlhbGl6ZV9yb3V0ZSAtIEluaXRpYWxp emUgdGhlIGludGVycnVwdCByb3V0aW5nIHJ1bGUKKyAqIHRocm91Z2ggYSBzcGVjaWZpYyBMSU5L OgorICogIGlmIChsbmtfaWR4ID09IGlkeCkKKyAqICAgICAgcm91dGUgdXNpbmcgbGluayAnbGlu a19uYW1lJworICovCitzdGF0aWMgQW1sICppbml0aWFsaXplX3JvdXRlKEFtbCAqcm91dGUsIGNv bnN0IGNoYXIgKmxpbmtfbmFtZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQW1sICps bmtfaWR4LCBpbnQgaWR4KQoreworICAgIEFtbCAqaWZfY3R4ID0gYW1sX2lmKGFtbF9lcXVhbChs bmtfaWR4LCBhbWxfaW50KGlkeCkpKTsKKyAgICBBbWwgKnBrZyA9IGJ1aWxkX3BydF9lbnRyeShs aW5rX25hbWUpOworCisgICAgYW1sX2FwcGVuZChpZl9jdHgsIGFtbF9zdG9yZShwa2csIHJvdXRl KSk7CisKKyAgICByZXR1cm4gaWZfY3R4OworfQorCisvKgorICogYnVpbGRfcHJ0IC0gRGVmaW5l IGludGVycnVwdCByb3VudGluZyBydWxlcworICoKKyAqIFJldHVybnMgYW4gYXJyYXkgb2YgMTI4 IHJvdXRlcywgb25lIGZvciBlYWNoIGRldmljZSwKKyAqIGJhc2VkIG9uIGRldmljZSBsb2NhdGlv bi4KKyAqIFRoZSBtYWluIGdvYWwgaXMgdG8gZXF1YWx5IGRpc3RyaWJ1dGUgdGhlIGludGVycnVw dHMKKyAqIG92ZXIgdGhlIDQgZXhpc3RpbmcgQUNQSSBsaW5rcyAod29ya3Mgb25seSBmb3IgaTQ0 MGZ4KS4KKyAqIFRoZSBoYXNoIGZ1bmN0aW9uIGlzICAoc2xvdCArIHBpbikgJiAzIC0+ICJMTktb RHxBfEJ8Q10iLgorICoKKyAqLworQW1sICpidWlsZF9wcnQoYm9vbCBpc19wY2kwX3BydCkKK3sK KyAgICBBbWwgKm1ldGhvZCwgKndoaWxlX2N0eCwgKnBpbiwgKnJlczsKKworICAgIG1ldGhvZCA9 IGFtbF9tZXRob2QoIl9QUlQiLCAwLCBBTUxfTk9UU0VSSUFMSVpFRCk7CisgICAgcmVzID0gYW1s X2xvY2FsKDApOworICAgIHBpbiA9IGFtbF9sb2NhbCgxKTsKKyAgICBhbWxfYXBwZW5kKG1ldGhv ZCwgYW1sX3N0b3JlKGFtbF9wYWNrYWdlKDEyOCksIHJlcykpOworICAgIGFtbF9hcHBlbmQobWV0 aG9kLCBhbWxfc3RvcmUoYW1sX2ludCgwKSwgcGluKSk7CisKKyAgICAvKiB3aGlsZSAocGluIDwg MTI4KSAqLworICAgIHdoaWxlX2N0eCA9IGFtbF93aGlsZShhbWxfbGxlc3MocGluLCBhbWxfaW50 KDEyOCkpKTsKKyAgICB7CisgICAgICAgIEFtbCAqc2xvdCA9IGFtbF9sb2NhbCgyKTsKKyAgICAg ICAgQW1sICpsbmtfaWR4ID0gYW1sX2xvY2FsKDMpOworICAgICAgICBBbWwgKnJvdXRlID0gYW1s X2xvY2FsKDQpOworCisgICAgICAgIC8qIHNsb3QgPSBwaW4gPj4gMiAqLworICAgICAgICBhbWxf YXBwZW5kKHdoaWxlX2N0eCwKKyAgICAgICAgICAgICAgICAgICBhbWxfc3RvcmUoYW1sX3NoaWZ0 cmlnaHQocGluLCBhbWxfaW50KDIpLCBOVUxMKSwgc2xvdCkpOworICAgICAgICAvKiBsbmtfaWR4 ID0gKHNsb3QgKyBwaW4pICYgMyAqLworICAgICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwKKyAg ICAgICAgICAgIGFtbF9zdG9yZShhbWxfYW5kKGFtbF9hZGQocGluLCBzbG90LCBOVUxMKSwgYW1s X2ludCgzKSwgTlVMTCksCisgICAgICAgICAgICAgICAgICAgICAgbG5rX2lkeCkpOworCisgICAg ICAgIC8qIHJvdXRlWzJdID0gIkxOS1tEfEF8QnxDXSIsIHNlbGVjdGlvbiBiYXNlZCBvbiBwaW4g JSAzICAqLworICAgICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwgaW5pdGlhbGl6ZV9yb3V0ZShy b3V0ZSwgIkxOS0QiLCBsbmtfaWR4LCAwKSk7CisgICAgICAgIGlmIChpc19wY2kwX3BydCkgewor ICAgICAgICAgICAgQW1sICppZl9kZXZpY2VfMSwgKmlmX3Bpbl80LCAqZWxzZV9waW5fNDsKKwor ICAgICAgICAgICAgLyogZGV2aWNlIDEgaXMgdGhlIHBvd2VyLW1hbmFnZW1lbnQgZGV2aWNlLCBu ZWVkcyBTQ0kgKi8KKyAgICAgICAgICAgIGlmX2RldmljZV8xID0gYW1sX2lmKGFtbF9lcXVhbChs bmtfaWR4LCBhbWxfaW50KDEpKSk7CisgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWZf cGluXzQgPSBhbWxfaWYoYW1sX2VxdWFsKHBpbiwgYW1sX2ludCg0KSkpOworICAgICAgICAgICAg ICAgIHsKKyAgICAgICAgICAgICAgICAgICAgYW1sX2FwcGVuZChpZl9waW5fNCwKKyAgICAgICAg ICAgICAgICAgICAgICAgIGFtbF9zdG9yZShidWlsZF9wcnRfZW50cnkoIkxOS1MiKSwgcm91dGUp KTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgYW1sX2FwcGVuZChpZl9kZXZp Y2VfMSwgaWZfcGluXzQpOworICAgICAgICAgICAgICAgIGVsc2VfcGluXzQgPSBhbWxfZWxzZSgp OworICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgYW1sX2FwcGVuZChlbHNl X3Bpbl80LAorICAgICAgICAgICAgICAgICAgICAgICAgYW1sX3N0b3JlKGJ1aWxkX3BydF9lbnRy eSgiTE5LQSIpLCByb3V0ZSkpOworICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICBh bWxfYXBwZW5kKGlmX2RldmljZV8xLCBlbHNlX3Bpbl80KTsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgICAgIGFtbF9hcHBlbmQod2hpbGVfY3R4LCBpZl9kZXZpY2VfMSk7CisgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwgaW5pdGlhbGl6ZV9yb3V0ZShy b3V0ZSwgIkxOS0EiLCBsbmtfaWR4LCAxKSk7CisgICAgICAgIH0KKyAgICAgICAgYW1sX2FwcGVu ZCh3aGlsZV9jdHgsIGluaXRpYWxpemVfcm91dGUocm91dGUsICJMTktCIiwgbG5rX2lkeCwgMikp OworICAgICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwgaW5pdGlhbGl6ZV9yb3V0ZShyb3V0ZSwg IkxOS0MiLCBsbmtfaWR4LCAzKSk7CisKKyAgICAgICAgLyogcm91dGVbMF0gPSAweFtzbG90XUZG RkYgKi8KKyAgICAgICAgYW1sX2FwcGVuZCh3aGlsZV9jdHgsCisgICAgICAgICAgICBhbWxfc3Rv cmUoYW1sX29yKGFtbF9zaGlmdGxlZnQoc2xvdCwgYW1sX2ludCgxNikpLCBhbWxfaW50KDB4RkZG RiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE5VTEwpLAorICAgICAgICAgICAgICAg ICAgICAgIGFtbF9pbmRleChyb3V0ZSwgYW1sX2ludCgwKSkpKTsKKyAgICAgICAgLyogcm91dGVb MV0gPSBwaW4gJiAzICovCisgICAgICAgIGFtbF9hcHBlbmQod2hpbGVfY3R4LAorICAgICAgICAg ICAgYW1sX3N0b3JlKGFtbF9hbmQocGluLCBhbWxfaW50KDMpLCBOVUxMKSwKKyAgICAgICAgICAg ICAgICAgICAgICBhbWxfaW5kZXgocm91dGUsIGFtbF9pbnQoMSkpKSk7CisgICAgICAgIC8qIHJl c1twaW5dID0gcm91dGUgKi8KKyAgICAgICAgYW1sX2FwcGVuZCh3aGlsZV9jdHgsIGFtbF9zdG9y ZShyb3V0ZSwgYW1sX2luZGV4KHJlcywgcGluKSkpOworICAgICAgICAvKiBwaW4rKyAqLworICAg ICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwgYW1sX2luY3JlbWVudChwaW4pKTsKKyAgICB9Cisg ICAgYW1sX2FwcGVuZChtZXRob2QsIHdoaWxlX2N0eCk7CisgICAgLyogcmV0dXJuIHJlcyovCisg ICAgYW1sX2FwcGVuZChtZXRob2QsIGFtbF9yZXR1cm4ocmVzKSk7CisKKyAgICByZXR1cm4gbWV0 aG9kOworfQorCiAvKiBCdWlsZCByc2R0IHRhYmxlICovCiB2b2lkCiBidWlsZF9yc2R0KEdBcnJh eSAqdGFibGVfZGF0YSwgQklPU0xpbmtlciAqbGlua2VyLCBHQXJyYXkgKnRhYmxlX29mZnNldHMs CmRpZmYgLS1naXQgYS9ody9hcm0vdmlydC1hY3BpLWJ1aWxkLmMgYi9ody9hcm0vdmlydC1hY3Bp LWJ1aWxkLmMKaW5kZXggMjYxMzYzZTIwYy4uYzliNDkxNmJhNyAxMDA2NDQKLS0tIGEvaHcvYXJt L3ZpcnQtYWNwaS1idWlsZC5jCisrKyBiL2h3L2FybS92aXJ0LWFjcGktYnVpbGQuYwpAQCAtNTQ1 LDcgKzU0NSw3IEBAIGJ1aWxkX3NyYXQoR0FycmF5ICp0YWJsZV9kYXRhLCBCSU9TTGlua2VyICps aW5rZXIsIFZpcnRNYWNoaW5lU3RhdGUgKnZtcykKIH0KIAogc3RhdGljIHZvaWQKLWJ1aWxkX21j ZmcoR0FycmF5ICp0YWJsZV9kYXRhLCBCSU9TTGlua2VyICpsaW5rZXIsIFZpcnRNYWNoaW5lU3Rh dGUgKnZtcykKK3ZpcnRfYnVpbGRfbWNmZyhHQXJyYXkgKnRhYmxlX2RhdGEsIEJJT1NMaW5rZXIg KmxpbmtlciwgVmlydE1hY2hpbmVTdGF0ZSAqdm1zKQogewogICAgIEFjcGlUYWJsZU1jZmcgKm1j Zmc7CiAgICAgY29uc3QgTWVtTWFwRW50cnkgKm1lbW1hcCA9IHZtcy0+bWVtbWFwOwpAQCAtNzkw LDcgKzc5MCw3IEBAIHZvaWQgdmlydF9hY3BpX2J1aWxkKFZpcnRNYWNoaW5lU3RhdGUgKnZtcywg QWNwaUJ1aWxkVGFibGVzICp0YWJsZXMpCiAgICAgYnVpbGRfZ3RkdCh0YWJsZXNfYmxvYiwgdGFi bGVzLT5saW5rZXIsIHZtcyk7CiAKICAgICBhY3BpX2FkZF90YWJsZSh0YWJsZV9vZmZzZXRzLCB0 YWJsZXNfYmxvYik7Ci0gICAgYnVpbGRfbWNmZyh0YWJsZXNfYmxvYiwgdGFibGVzLT5saW5rZXIs IHZtcyk7CisgICAgdmlydF9idWlsZF9tY2ZnKHRhYmxlc19ibG9iLCB0YWJsZXMtPmxpbmtlciwg dm1zKTsKIAogICAgIGFjcGlfYWRkX3RhYmxlKHRhYmxlX29mZnNldHMsIHRhYmxlc19ibG9iKTsK ICAgICBidWlsZF9zcGNyKHRhYmxlc19ibG9iLCB0YWJsZXMtPmxpbmtlciwgdm1zKTsKZGlmZiAt LWdpdCBhL2h3L2kzODYvYWNwaS1idWlsZC5jIGIvaHcvaTM4Ni9hY3BpLWJ1aWxkLmMKaW5kZXgg Y2ZjMjQ0NGQwZC4uOTk2ZDhhMTFkYyAxMDA2NDQKLS0tIGEvaHcvaTM4Ni9hY3BpLWJ1aWxkLmMK KysrIGIvaHcvaTM4Ni9hY3BpLWJ1aWxkLmMKQEAgLTI3LDcgKzI3LDYgQEAKICNpbmNsdWRlICJx ZW11LWNvbW1vbi5oIgogI2luY2x1ZGUgInFlbXUvYml0bWFwLmgiCiAjaW5jbHVkZSAicWVtdS9l cnJvci1yZXBvcnQuaCIKLSNpbmNsdWRlICJody9wY2kvcGNpLmgiCiAjaW5jbHVkZSAicW9tL2Nw dS5oIgogI2luY2x1ZGUgInRhcmdldC9pMzg2L2NwdS5oIgogI2luY2x1ZGUgImh3L21pc2MvcHZw YW5pYy5oIgpAQCAtNTMsNyArNTIsNiBAQAogI2luY2x1ZGUgImh3L2FjcGkvcGlpeDQuaCIKICNp bmNsdWRlICJody9hY3BpL3BjaWhwLmgiCiAjaW5jbHVkZSAiaHcvaTM4Ni9pY2g5LmgiCi0jaW5j bHVkZSAiaHcvcGNpL3BjaV9idXMuaCIKICNpbmNsdWRlICJody9wY2ktaG9zdC9xMzUuaCIKICNp bmNsdWRlICJody9pMzg2L3g4Ni1pb21tdS5oIgogCkBAIC04NiwxMSArODQsNiBAQAogLyogRGVm YXVsdCBJT0FQSUMgSUQgKi8KICNkZWZpbmUgQUNQSV9CVUlMRF9JT0FQSUNfSUQgMHgwCiAKLXR5 cGVkZWYgc3RydWN0IEFjcGlNY2ZnSW5mbyB7Ci0gICAgdWludDY0X3QgbWNmZ19iYXNlOwotICAg IHVpbnQzMl90IG1jZmdfc2l6ZTsKLX0gQWNwaU1jZmdJbmZvOwotCiB0eXBlZGVmIHN0cnVjdCBB Y3BpUG1JbmZvIHsKICAgICBib29sIHMzX2Rpc2FibGVkOwogICAgIGJvb2wgczRfZGlzYWJsZWQ7 CkBAIC01NjcsNDAzICs1NjAsNiBAQCBzdGF0aWMgdm9pZCBidWlsZF9hcHBlbmRfcGNpX2J1c19k ZXZpY2VzKEFtbCAqcGFyZW50X3Njb3BlLCBQQ0lCdXMgKmJ1cywKICAgICBxb2JqZWN0X3VucmVm KGJzZWwpOwogfQogCi0vKioKLSAqIGJ1aWxkX3BydF9lbnRyeToKLSAqIEBsaW5rX25hbWU6IGxp bmsgbmFtZSBmb3IgUENJIHJvdXRlIGVudHJ5Ci0gKgotICogYnVpbGQgQU1MIHBhY2thZ2UgY29u dGFpbmluZyBhIFBDSSByb3V0ZSBlbnRyeSBmb3IgQGxpbmtfbmFtZQotICovCi1zdGF0aWMgQW1s ICpidWlsZF9wcnRfZW50cnkoY29uc3QgY2hhciAqbGlua19uYW1lKQotewotICAgIEFtbCAqYV96 ZXJvID0gYW1sX2ludCgwKTsKLSAgICBBbWwgKnBrZyA9IGFtbF9wYWNrYWdlKDQpOwotICAgIGFt bF9hcHBlbmQocGtnLCBhX3plcm8pOwotICAgIGFtbF9hcHBlbmQocGtnLCBhX3plcm8pOwotICAg IGFtbF9hcHBlbmQocGtnLCBhbWxfbmFtZSgiJXMiLCBsaW5rX25hbWUpKTsKLSAgICBhbWxfYXBw ZW5kKHBrZywgYV96ZXJvKTsKLSAgICByZXR1cm4gcGtnOwotfQotCi0vKgotICogaW5pdGlhbGl6 ZV9yb3V0ZSAtIEluaXRpYWxpemUgdGhlIGludGVycnVwdCByb3V0aW5nIHJ1bGUKLSAqIHRocm91 Z2ggYSBzcGVjaWZpYyBMSU5LOgotICogIGlmIChsbmtfaWR4ID09IGlkeCkKLSAqICAgICAgcm91 dGUgdXNpbmcgbGluayAnbGlua19uYW1lJwotICovCi1zdGF0aWMgQW1sICppbml0aWFsaXplX3Jv dXRlKEFtbCAqcm91dGUsIGNvbnN0IGNoYXIgKmxpbmtfbmFtZSwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgQW1sICpsbmtfaWR4LCBpbnQgaWR4KQotewotICAgIEFtbCAqaWZfY3R4ID0g YW1sX2lmKGFtbF9lcXVhbChsbmtfaWR4LCBhbWxfaW50KGlkeCkpKTsKLSAgICBBbWwgKnBrZyA9 IGJ1aWxkX3BydF9lbnRyeShsaW5rX25hbWUpOwotCi0gICAgYW1sX2FwcGVuZChpZl9jdHgsIGFt bF9zdG9yZShwa2csIHJvdXRlKSk7Ci0KLSAgICByZXR1cm4gaWZfY3R4OwotfQotCi0vKgotICog YnVpbGRfcHJ0IC0gRGVmaW5lIGludGVycnVwdCByb3VudGluZyBydWxlcwotICoKLSAqIFJldHVy bnMgYW4gYXJyYXkgb2YgMTI4IHJvdXRlcywgb25lIGZvciBlYWNoIGRldmljZSwKLSAqIGJhc2Vk IG9uIGRldmljZSBsb2NhdGlvbi4KLSAqIFRoZSBtYWluIGdvYWwgaXMgdG8gZXF1YWx5IGRpc3Ry aWJ1dGUgdGhlIGludGVycnVwdHMKLSAqIG92ZXIgdGhlIDQgZXhpc3RpbmcgQUNQSSBsaW5rcyAo d29ya3Mgb25seSBmb3IgaTQ0MGZ4KS4KLSAqIFRoZSBoYXNoIGZ1bmN0aW9uIGlzICAoc2xvdCAr IHBpbikgJiAzIC0+ICJMTktbRHxBfEJ8Q10iLgotICoKLSAqLwotc3RhdGljIEFtbCAqYnVpbGRf cHJ0KGJvb2wgaXNfcGNpMF9wcnQpCi17Ci0gICAgQW1sICptZXRob2QsICp3aGlsZV9jdHgsICpw aW4sICpyZXM7Ci0KLSAgICBtZXRob2QgPSBhbWxfbWV0aG9kKCJfUFJUIiwgMCwgQU1MX05PVFNF UklBTElaRUQpOwotICAgIHJlcyA9IGFtbF9sb2NhbCgwKTsKLSAgICBwaW4gPSBhbWxfbG9jYWwo MSk7Ci0gICAgYW1sX2FwcGVuZChtZXRob2QsIGFtbF9zdG9yZShhbWxfcGFja2FnZSgxMjgpLCBy ZXMpKTsKLSAgICBhbWxfYXBwZW5kKG1ldGhvZCwgYW1sX3N0b3JlKGFtbF9pbnQoMCksIHBpbikp OwotCi0gICAgLyogd2hpbGUgKHBpbiA8IDEyOCkgKi8KLSAgICB3aGlsZV9jdHggPSBhbWxfd2hp bGUoYW1sX2xsZXNzKHBpbiwgYW1sX2ludCgxMjgpKSk7Ci0gICAgewotICAgICAgICBBbWwgKnNs b3QgPSBhbWxfbG9jYWwoMik7Ci0gICAgICAgIEFtbCAqbG5rX2lkeCA9IGFtbF9sb2NhbCgzKTsK LSAgICAgICAgQW1sICpyb3V0ZSA9IGFtbF9sb2NhbCg0KTsKLQotICAgICAgICAvKiBzbG90ID0g cGluID4+IDIgKi8KLSAgICAgICAgYW1sX2FwcGVuZCh3aGlsZV9jdHgsCi0gICAgICAgICAgICAg ICAgICAgYW1sX3N0b3JlKGFtbF9zaGlmdHJpZ2h0KHBpbiwgYW1sX2ludCgyKSwgTlVMTCksIHNs b3QpKTsKLSAgICAgICAgLyogbG5rX2lkeCA9IChzbG90ICsgcGluKSAmIDMgKi8KLSAgICAgICAg YW1sX2FwcGVuZCh3aGlsZV9jdHgsCi0gICAgICAgICAgICBhbWxfc3RvcmUoYW1sX2FuZChhbWxf YWRkKHBpbiwgc2xvdCwgTlVMTCksIGFtbF9pbnQoMyksIE5VTEwpLAotICAgICAgICAgICAgICAg ICAgICAgIGxua19pZHgpKTsKLQotICAgICAgICAvKiByb3V0ZVsyXSA9ICJMTktbRHxBfEJ8Q10i LCBzZWxlY3Rpb24gYmFzZWQgb24gcGluICUgMyAgKi8KLSAgICAgICAgYW1sX2FwcGVuZCh3aGls ZV9jdHgsIGluaXRpYWxpemVfcm91dGUocm91dGUsICJMTktEIiwgbG5rX2lkeCwgMCkpOwotICAg ICAgICBpZiAoaXNfcGNpMF9wcnQpIHsKLSAgICAgICAgICAgIEFtbCAqaWZfZGV2aWNlXzEsICpp Zl9waW5fNCwgKmVsc2VfcGluXzQ7Ci0KLSAgICAgICAgICAgIC8qIGRldmljZSAxIGlzIHRoZSBw b3dlci1tYW5hZ2VtZW50IGRldmljZSwgbmVlZHMgU0NJICovCi0gICAgICAgICAgICBpZl9kZXZp Y2VfMSA9IGFtbF9pZihhbWxfZXF1YWwobG5rX2lkeCwgYW1sX2ludCgxKSkpOwotICAgICAgICAg ICAgewotICAgICAgICAgICAgICAgIGlmX3Bpbl80ID0gYW1sX2lmKGFtbF9lcXVhbChwaW4sIGFt bF9pbnQoNCkpKTsKLSAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAgICAgICAgICAgIGFtbF9h cHBlbmQoaWZfcGluXzQsCi0gICAgICAgICAgICAgICAgICAgICAgICBhbWxfc3RvcmUoYnVpbGRf cHJ0X2VudHJ5KCJMTktTIiksIHJvdXRlKSk7Ci0gICAgICAgICAgICAgICAgfQotICAgICAgICAg ICAgICAgIGFtbF9hcHBlbmQoaWZfZGV2aWNlXzEsIGlmX3Bpbl80KTsKLSAgICAgICAgICAgICAg ICBlbHNlX3Bpbl80ID0gYW1sX2Vsc2UoKTsKLSAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAg ICAgICAgICAgIGFtbF9hcHBlbmQoZWxzZV9waW5fNCwKLSAgICAgICAgICAgICAgICAgICAgICAg IGFtbF9zdG9yZShidWlsZF9wcnRfZW50cnkoIkxOS0EiKSwgcm91dGUpKTsKLSAgICAgICAgICAg ICAgICB9Ci0gICAgICAgICAgICAgICAgYW1sX2FwcGVuZChpZl9kZXZpY2VfMSwgZWxzZV9waW5f NCk7Ci0gICAgICAgICAgICB9Ci0gICAgICAgICAgICBhbWxfYXBwZW5kKHdoaWxlX2N0eCwgaWZf ZGV2aWNlXzEpOwotICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgYW1sX2FwcGVuZCh3aGls ZV9jdHgsIGluaXRpYWxpemVfcm91dGUocm91dGUsICJMTktBIiwgbG5rX2lkeCwgMSkpOwotICAg ICAgICB9Ci0gICAgICAgIGFtbF9hcHBlbmQod2hpbGVfY3R4LCBpbml0aWFsaXplX3JvdXRlKHJv dXRlLCAiTE5LQiIsIGxua19pZHgsIDIpKTsKLSAgICAgICAgYW1sX2FwcGVuZCh3aGlsZV9jdHgs IGluaXRpYWxpemVfcm91dGUocm91dGUsICJMTktDIiwgbG5rX2lkeCwgMykpOwotCi0gICAgICAg IC8qIHJvdXRlWzBdID0gMHhbc2xvdF1GRkZGICovCi0gICAgICAgIGFtbF9hcHBlbmQod2hpbGVf Y3R4LAotICAgICAgICAgICAgYW1sX3N0b3JlKGFtbF9vcihhbWxfc2hpZnRsZWZ0KHNsb3QsIGFt bF9pbnQoMTYpKSwgYW1sX2ludCgweEZGRkYpLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBOVUxMKSwKLSAgICAgICAgICAgICAgICAgICAgICBhbWxfaW5kZXgocm91dGUsIGFtbF9pbnQo MCkpKSk7Ci0gICAgICAgIC8qIHJvdXRlWzFdID0gcGluICYgMyAqLwotICAgICAgICBhbWxfYXBw ZW5kKHdoaWxlX2N0eCwKLSAgICAgICAgICAgIGFtbF9zdG9yZShhbWxfYW5kKHBpbiwgYW1sX2lu dCgzKSwgTlVMTCksCi0gICAgICAgICAgICAgICAgICAgICAgYW1sX2luZGV4KHJvdXRlLCBhbWxf aW50KDEpKSkpOwotICAgICAgICAvKiByZXNbcGluXSA9IHJvdXRlICovCi0gICAgICAgIGFtbF9h cHBlbmQod2hpbGVfY3R4LCBhbWxfc3RvcmUocm91dGUsIGFtbF9pbmRleChyZXMsIHBpbikpKTsK LSAgICAgICAgLyogcGluKysgKi8KLSAgICAgICAgYW1sX2FwcGVuZCh3aGlsZV9jdHgsIGFtbF9p bmNyZW1lbnQocGluKSk7Ci0gICAgfQotICAgIGFtbF9hcHBlbmQobWV0aG9kLCB3aGlsZV9jdHgp OwotICAgIC8qIHJldHVybiByZXMqLwotICAgIGFtbF9hcHBlbmQobWV0aG9kLCBhbWxfcmV0dXJu KHJlcykpOwotCi0gICAgcmV0dXJuIG1ldGhvZDsKLX0KLQotdHlwZWRlZiBzdHJ1Y3QgQ3JzUmFu Z2VFbnRyeSB7Ci0gICAgdWludDY0X3QgYmFzZTsKLSAgICB1aW50NjRfdCBsaW1pdDsKLX0gQ3Jz UmFuZ2VFbnRyeTsKLQotc3RhdGljIHZvaWQgY3JzX3JhbmdlX2luc2VydChHUHRyQXJyYXkgKnJh bmdlcywgdWludDY0X3QgYmFzZSwgdWludDY0X3QgbGltaXQpCi17Ci0gICAgQ3JzUmFuZ2VFbnRy eSAqZW50cnk7Ci0KLSAgICBlbnRyeSA9IGdfbWFsbG9jKHNpemVvZigqZW50cnkpKTsKLSAgICBl bnRyeS0+YmFzZSA9IGJhc2U7Ci0gICAgZW50cnktPmxpbWl0ID0gbGltaXQ7Ci0KLSAgICBnX3B0 cl9hcnJheV9hZGQocmFuZ2VzLCBlbnRyeSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGNyc19yYW5nZV9m cmVlKGdwb2ludGVyIGRhdGEpCi17Ci0gICAgQ3JzUmFuZ2VFbnRyeSAqZW50cnkgPSAoQ3JzUmFu Z2VFbnRyeSAqKWRhdGE7Ci0gICAgZ19mcmVlKGVudHJ5KTsKLX0KLQotdHlwZWRlZiBzdHJ1Y3Qg Q3JzUmFuZ2VTZXQgewotICAgIEdQdHJBcnJheSAqaW9fcmFuZ2VzOwotICAgIEdQdHJBcnJheSAq bWVtX3JhbmdlczsKLSAgICBHUHRyQXJyYXkgKm1lbV82NGJpdF9yYW5nZXM7Ci0gfSBDcnNSYW5n ZVNldDsKLQotc3RhdGljIHZvaWQgY3JzX3JhbmdlX3NldF9pbml0KENyc1JhbmdlU2V0ICpyYW5n ZV9zZXQpCi17Ci0gICAgcmFuZ2Vfc2V0LT5pb19yYW5nZXMgPSBnX3B0cl9hcnJheV9uZXdfd2l0 aF9mcmVlX2Z1bmMoY3JzX3JhbmdlX2ZyZWUpOwotICAgIHJhbmdlX3NldC0+bWVtX3JhbmdlcyA9 IGdfcHRyX2FycmF5X25ld193aXRoX2ZyZWVfZnVuYyhjcnNfcmFuZ2VfZnJlZSk7Ci0gICAgcmFu Z2Vfc2V0LT5tZW1fNjRiaXRfcmFuZ2VzID0KLSAgICAgICAgICAgIGdfcHRyX2FycmF5X25ld193 aXRoX2ZyZWVfZnVuYyhjcnNfcmFuZ2VfZnJlZSk7Ci19Ci0KLXN0YXRpYyB2b2lkIGNyc19yYW5n ZV9zZXRfZnJlZShDcnNSYW5nZVNldCAqcmFuZ2Vfc2V0KQotewotICAgIGdfcHRyX2FycmF5X2Zy ZWUocmFuZ2Vfc2V0LT5pb19yYW5nZXMsIHRydWUpOwotICAgIGdfcHRyX2FycmF5X2ZyZWUocmFu Z2Vfc2V0LT5tZW1fcmFuZ2VzLCB0cnVlKTsKLSAgICBnX3B0cl9hcnJheV9mcmVlKHJhbmdlX3Nl dC0+bWVtXzY0Yml0X3JhbmdlcywgdHJ1ZSk7Ci19Ci0KLXN0YXRpYyBnaW50IGNyc19yYW5nZV9j b21wYXJlKGdjb25zdHBvaW50ZXIgYSwgZ2NvbnN0cG9pbnRlciBiKQotewotICAgICBDcnNSYW5n ZUVudHJ5ICplbnRyeV9hID0gKihDcnNSYW5nZUVudHJ5ICoqKWE7Ci0gICAgIENyc1JhbmdlRW50 cnkgKmVudHJ5X2IgPSAqKENyc1JhbmdlRW50cnkgKiopYjsKLQotICAgICByZXR1cm4gKGludDY0 X3QpZW50cnlfYS0+YmFzZSAtIChpbnQ2NF90KWVudHJ5X2ItPmJhc2U7Ci19Ci0KLS8qCi0gKiBj cnNfcmVwbGFjZV93aXRoX2ZyZWVfcmFuZ2VzIC0gZ2l2ZW4gdGhlICd1c2VkJyByYW5nZXMgd2l0 aGluIFtzdGFydCAtIGVuZF0KLSAqIGludGVydmFsLCBjb21wdXRlcyB0aGUgJ2ZyZWUnIHJhbmdl cyBmcm9tIHRoZSBzYW1lIGludGVydmFsLgotICogRXhhbXBsZTogSWYgdGhlIGlucHV0IGFycmF5 IGlzIHsgW2ExIC0gYTJdLFtiMSAtIGIyXSB9LCB0aGUgZnVuY3Rpb24KLSAqIHdpbGwgcmV0dXJu IHsgW2Jhc2UgLSBhMV0sIFthMiAtIGIxXSwgW2IyIC0gbGltaXRdIH0uCi0gKi8KLXN0YXRpYyB2 b2lkIGNyc19yZXBsYWNlX3dpdGhfZnJlZV9yYW5nZXMoR1B0ckFycmF5ICpyYW5nZXMsCi0gICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQ2NF90IHN0YXJ0LCB1aW50 NjRfdCBlbmQpCi17Ci0gICAgR1B0ckFycmF5ICpmcmVlX3JhbmdlcyA9IGdfcHRyX2FycmF5X25l dygpOwotICAgIHVpbnQ2NF90IGZyZWVfYmFzZSA9IHN0YXJ0OwotICAgIGludCBpOwotCi0gICAg Z19wdHJfYXJyYXlfc29ydChyYW5nZXMsIGNyc19yYW5nZV9jb21wYXJlKTsKLSAgICBmb3IgKGkg PSAwOyBpIDwgcmFuZ2VzLT5sZW47IGkrKykgewotICAgICAgICBDcnNSYW5nZUVudHJ5ICp1c2Vk ID0gZ19wdHJfYXJyYXlfaW5kZXgocmFuZ2VzLCBpKTsKLQotICAgICAgICBpZiAoZnJlZV9iYXNl IDwgdXNlZC0+YmFzZSkgewotICAgICAgICAgICAgY3JzX3JhbmdlX2luc2VydChmcmVlX3Jhbmdl cywgZnJlZV9iYXNlLCB1c2VkLT5iYXNlIC0gMSk7Ci0gICAgICAgIH0KLQotICAgICAgICBmcmVl X2Jhc2UgPSB1c2VkLT5saW1pdCArIDE7Ci0gICAgfQotCi0gICAgaWYgKGZyZWVfYmFzZSA8IGVu ZCkgewotICAgICAgICBjcnNfcmFuZ2VfaW5zZXJ0KGZyZWVfcmFuZ2VzLCBmcmVlX2Jhc2UsIGVu ZCk7Ci0gICAgfQotCi0gICAgZ19wdHJfYXJyYXlfc2V0X3NpemUocmFuZ2VzLCAwKTsKLSAgICBm b3IgKGkgPSAwOyBpIDwgZnJlZV9yYW5nZXMtPmxlbjsgaSsrKSB7Ci0gICAgICAgIGdfcHRyX2Fy cmF5X2FkZChyYW5nZXMsIGdfcHRyX2FycmF5X2luZGV4KGZyZWVfcmFuZ2VzLCBpKSk7Ci0gICAg fQotCi0gICAgZ19wdHJfYXJyYXlfZnJlZShmcmVlX3JhbmdlcywgdHJ1ZSk7Ci19Ci0KLS8qCi0g KiBjcnNfcmFuZ2VfbWVyZ2UgLSBtZXJnZXMgYWRqYWNlbnQgcmFuZ2VzIGluIHRoZSBnaXZlbiBh cnJheS4KLSAqIEFycmF5IGVsZW1lbnRzIGFyZSBkZWxldGVkIGFuZCByZXBsYWNlZCB3aXRoIHRo ZSBtZXJnZWQgcmFuZ2VzLgotICovCi1zdGF0aWMgdm9pZCBjcnNfcmFuZ2VfbWVyZ2UoR1B0ckFy cmF5ICpyYW5nZSkKLXsKLSAgICBHUHRyQXJyYXkgKnRtcCA9ICBnX3B0cl9hcnJheV9uZXdfd2l0 aF9mcmVlX2Z1bmMoY3JzX3JhbmdlX2ZyZWUpOwotICAgIENyc1JhbmdlRW50cnkgKmVudHJ5Owot ICAgIHVpbnQ2NF90IHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0OwotICAgIGludCBpOwotCi0gICAg aWYgKCFyYW5nZS0+bGVuKSB7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICBnX3B0cl9h cnJheV9zb3J0KHJhbmdlLCBjcnNfcmFuZ2VfY29tcGFyZSk7Ci0KLSAgICBlbnRyeSA9IGdfcHRy X2FycmF5X2luZGV4KHJhbmdlLCAwKTsKLSAgICByYW5nZV9iYXNlID0gZW50cnktPmJhc2U7Ci0g ICAgcmFuZ2VfbGltaXQgPSBlbnRyeS0+bGltaXQ7Ci0gICAgZm9yIChpID0gMTsgaSA8IHJhbmdl LT5sZW47IGkrKykgewotICAgICAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4KHJhbmdlLCBp KTsKLSAgICAgICAgaWYgKGVudHJ5LT5iYXNlIC0gMSA9PSByYW5nZV9saW1pdCkgewotICAgICAg ICAgICAgcmFuZ2VfbGltaXQgPSBlbnRyeS0+bGltaXQ7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAg ICAgICAgICBjcnNfcmFuZ2VfaW5zZXJ0KHRtcCwgcmFuZ2VfYmFzZSwgcmFuZ2VfbGltaXQpOwot ICAgICAgICAgICAgcmFuZ2VfYmFzZSA9IGVudHJ5LT5iYXNlOwotICAgICAgICAgICAgcmFuZ2Vf bGltaXQgPSBlbnRyeS0+bGltaXQ7Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgY3JzX3JhbmdlX2lu c2VydCh0bXAsIHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsKLQotICAgIGdfcHRyX2FycmF5X3Nl dF9zaXplKHJhbmdlLCAwKTsKLSAgICBmb3IgKGkgPSAwOyBpIDwgdG1wLT5sZW47IGkrKykgewot ICAgICAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4KHRtcCwgaSk7Ci0gICAgICAgIGNyc19y YW5nZV9pbnNlcnQocmFuZ2UsIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGltaXQpOwotICAgIH0KLSAg ICBnX3B0cl9hcnJheV9mcmVlKHRtcCwgdHJ1ZSk7Ci19Ci0KLXN0YXRpYyBBbWwgKmJ1aWxkX2Ny cyhQQ0lIb3N0U3RhdGUgKmhvc3QsIENyc1JhbmdlU2V0ICpyYW5nZV9zZXQpCi17Ci0gICAgQW1s ICpjcnMgPSBhbWxfcmVzb3VyY2VfdGVtcGxhdGUoKTsKLSAgICBDcnNSYW5nZVNldCB0ZW1wX3Jh bmdlX3NldDsKLSAgICBDcnNSYW5nZUVudHJ5ICplbnRyeTsKLSAgICB1aW50OF90IG1heF9idXMg PSBwY2lfYnVzX251bShob3N0LT5idXMpOwotICAgIHVpbnQ4X3QgdHlwZTsKLSAgICBpbnQgZGV2 Zm47Ci0gICAgaW50IGk7Ci0KLSAgICBjcnNfcmFuZ2Vfc2V0X2luaXQoJnRlbXBfcmFuZ2Vfc2V0 KTsKLSAgICBmb3IgKGRldmZuID0gMDsgZGV2Zm4gPCBBUlJBWV9TSVpFKGhvc3QtPmJ1cy0+ZGV2 aWNlcyk7IGRldmZuKyspIHsKLSAgICAgICAgdWludDY0X3QgcmFuZ2VfYmFzZSwgcmFuZ2VfbGlt aXQ7Ci0gICAgICAgIFBDSURldmljZSAqZGV2ID0gaG9zdC0+YnVzLT5kZXZpY2VzW2RldmZuXTsK LQotICAgICAgICBpZiAoIWRldikgewotICAgICAgICAgICAgY29udGludWU7Ci0gICAgICAgIH0K LQotICAgICAgICBmb3IgKGkgPSAwOyBpIDwgUENJX05VTV9SRUdJT05TOyBpKyspIHsKLSAgICAg ICAgICAgIFBDSUlPUmVnaW9uICpyID0gJmRldi0+aW9fcmVnaW9uc1tpXTsKLQotICAgICAgICAg ICAgcmFuZ2VfYmFzZSA9IHItPmFkZHI7Ci0gICAgICAgICAgICByYW5nZV9saW1pdCA9IHItPmFk ZHIgKyByLT5zaXplIC0gMTsKLQotICAgICAgICAgICAgLyoKLSAgICAgICAgICAgICAqIFdvcmst YXJvdW5kIGZvciBvbGQgYmlvc2VzCi0gICAgICAgICAgICAgKiB0aGF0IGRvIG5vdCBzdXBwb3J0 IG11bHRpcGxlIHJvb3QgYnVzZXMKLSAgICAgICAgICAgICAqLwotICAgICAgICAgICAgaWYgKCFy YW5nZV9iYXNlIHx8IHJhbmdlX2Jhc2UgPiByYW5nZV9saW1pdCkgewotICAgICAgICAgICAgICAg IGNvbnRpbnVlOwotICAgICAgICAgICAgfQotCi0gICAgICAgICAgICBpZiAoci0+dHlwZSAmIFBD SV9CQVNFX0FERFJFU1NfU1BBQ0VfSU8pIHsKLSAgICAgICAgICAgICAgICBjcnNfcmFuZ2VfaW5z ZXJ0KHRlbXBfcmFuZ2Vfc2V0LmlvX3JhbmdlcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHJhbmdlX2Jhc2UsIHJhbmdlX2xpbWl0KTsKLSAgICAgICAgICAgIH0gZWxzZSB7IC8q ICJtZW1vcnkiICovCi0gICAgICAgICAgICAgICAgY3JzX3JhbmdlX2luc2VydCh0ZW1wX3Jhbmdl X3NldC5tZW1fcmFuZ2VzLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmFuZ2Vf YmFzZSwgcmFuZ2VfbGltaXQpOwotICAgICAgICAgICAgfQotICAgICAgICB9Ci0KLSAgICAgICAg dHlwZSA9IGRldi0+Y29uZmlnW1BDSV9IRUFERVJfVFlQRV0gJiB+UENJX0hFQURFUl9UWVBFX01V TFRJX0ZVTkNUSU9OOwotICAgICAgICBpZiAodHlwZSA9PSBQQ0lfSEVBREVSX1RZUEVfQlJJREdF KSB7Ci0gICAgICAgICAgICB1aW50OF90IHN1Ym9yZGluYXRlID0gZGV2LT5jb25maWdbUENJX1NV Qk9SRElOQVRFX0JVU107Ci0gICAgICAgICAgICBpZiAoc3Vib3JkaW5hdGUgPiBtYXhfYnVzKSB7 Ci0gICAgICAgICAgICAgICAgbWF4X2J1cyA9IHN1Ym9yZGluYXRlOwotICAgICAgICAgICAgfQot Ci0gICAgICAgICAgICByYW5nZV9iYXNlID0gcGNpX2JyaWRnZV9nZXRfYmFzZShkZXYsIFBDSV9C QVNFX0FERFJFU1NfU1BBQ0VfSU8pOwotICAgICAgICAgICAgcmFuZ2VfbGltaXQgPSBwY2lfYnJp ZGdlX2dldF9saW1pdChkZXYsIFBDSV9CQVNFX0FERFJFU1NfU1BBQ0VfSU8pOwotCi0gICAgICAg ICAgICAvKgotICAgICAgICAgICAgICogV29yay1hcm91bmQgZm9yIG9sZCBiaW9zZXMKLSAgICAg ICAgICAgICAqIHRoYXQgZG8gbm90IHN1cHBvcnQgbXVsdGlwbGUgcm9vdCBidXNlcwotICAgICAg ICAgICAgICovCi0gICAgICAgICAgICBpZiAocmFuZ2VfYmFzZSAmJiByYW5nZV9iYXNlIDw9IHJh bmdlX2xpbWl0KSB7Ci0gICAgICAgICAgICAgICAgY3JzX3JhbmdlX2luc2VydCh0ZW1wX3Jhbmdl X3NldC5pb19yYW5nZXMsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5nZV9i YXNlLCByYW5nZV9saW1pdCk7Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIHJhbmdlX2Jh c2UgPQotICAgICAgICAgICAgICAgIHBjaV9icmlkZ2VfZ2V0X2Jhc2UoZGV2LCBQQ0lfQkFTRV9B RERSRVNTX1NQQUNFX01FTU9SWSk7Ci0gICAgICAgICAgICByYW5nZV9saW1pdCA9Ci0gICAgICAg ICAgICAgICAgcGNpX2JyaWRnZV9nZXRfbGltaXQoZGV2LCBQQ0lfQkFTRV9BRERSRVNTX1NQQUNF X01FTU9SWSk7Ci0KLSAgICAgICAgICAgIC8qCi0gICAgICAgICAgICAgKiBXb3JrLWFyb3VuZCBm b3Igb2xkIGJpb3NlcwotICAgICAgICAgICAgICogdGhhdCBkbyBub3Qgc3VwcG9ydCBtdWx0aXBs ZSByb290IGJ1c2VzCi0gICAgICAgICAgICAgKi8KLSAgICAgICAgICAgIGlmIChyYW5nZV9iYXNl ICYmIHJhbmdlX2Jhc2UgPD0gcmFuZ2VfbGltaXQpIHsKLSAgICAgICAgICAgICAgICB1aW50NjRf dCBsZW5ndGggPSByYW5nZV9saW1pdCAtIHJhbmdlX2Jhc2UgKyAxOwotICAgICAgICAgICAgICAg IGlmIChyYW5nZV9saW1pdCA8PSBVSU5UMzJfTUFYICYmIGxlbmd0aCA8PSBVSU5UMzJfTUFYKSB7 Ci0gICAgICAgICAgICAgICAgICAgIGNyc19yYW5nZV9pbnNlcnQodGVtcF9yYW5nZV9zZXQubWVt X3JhbmdlcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5nZV9iYXNl LCByYW5nZV9saW1pdCk7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAgICAgICAg ICAgICAgY3JzX3JhbmdlX2luc2VydCh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzLAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJhbmdlX2Jhc2UsIHJhbmdlX2xp bWl0KTsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICB9Ci0KLSAgICAgICAgICAgIHJh bmdlX2Jhc2UgPQotICAgICAgICAgICAgICAgIHBjaV9icmlkZ2VfZ2V0X2Jhc2UoZGV2LCBQQ0lf QkFTRV9BRERSRVNTX01FTV9QUkVGRVRDSCk7Ci0gICAgICAgICAgICByYW5nZV9saW1pdCA9Ci0g ICAgICAgICAgICAgICAgcGNpX2JyaWRnZV9nZXRfbGltaXQoZGV2LCBQQ0lfQkFTRV9BRERSRVNT X01FTV9QUkVGRVRDSCk7Ci0KLSAgICAgICAgICAgIC8qCi0gICAgICAgICAgICAgKiBXb3JrLWFy b3VuZCBmb3Igb2xkIGJpb3NlcwotICAgICAgICAgICAgICogdGhhdCBkbyBub3Qgc3VwcG9ydCBt dWx0aXBsZSByb290IGJ1c2VzCi0gICAgICAgICAgICAgKi8KLSAgICAgICAgICAgIGlmIChyYW5n ZV9iYXNlICYmIHJhbmdlX2Jhc2UgPD0gcmFuZ2VfbGltaXQpIHsKLSAgICAgICAgICAgICAgICB1 aW50NjRfdCBsZW5ndGggPSByYW5nZV9saW1pdCAtIHJhbmdlX2Jhc2UgKyAxOwotICAgICAgICAg ICAgICAgIGlmIChyYW5nZV9saW1pdCA8PSBVSU5UMzJfTUFYICYmIGxlbmd0aCA8PSBVSU5UMzJf TUFYKSB7Ci0gICAgICAgICAgICAgICAgICAgIGNyc19yYW5nZV9pbnNlcnQodGVtcF9yYW5nZV9z ZXQubWVtX3JhbmdlcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByYW5n ZV9iYXNlLCByYW5nZV9saW1pdCk7Ci0gICAgICAgICAgICAgICAgfSBlbHNlIHsKLSAgICAgICAg ICAgICAgICAgICAgY3JzX3JhbmdlX2luc2VydCh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRfcmFu Z2VzLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJhbmdlX2Jhc2UsIHJh bmdlX2xpbWl0KTsKLSAgICAgICAgICAgICAgICB9Ci0gICAgICAgICAgICB9Ci0gICAgICAgIH0K LSAgICB9Ci0KLSAgICBjcnNfcmFuZ2VfbWVyZ2UodGVtcF9yYW5nZV9zZXQuaW9fcmFuZ2VzKTsK LSAgICBmb3IgKGkgPSAwOyBpIDwgdGVtcF9yYW5nZV9zZXQuaW9fcmFuZ2VzLT5sZW47IGkrKykg ewotICAgICAgICBlbnRyeSA9IGdfcHRyX2FycmF5X2luZGV4KHRlbXBfcmFuZ2Vfc2V0LmlvX3Jh bmdlcywgaSk7Ci0gICAgICAgIGFtbF9hcHBlbmQoY3JzLAotICAgICAgICAgICAgICAgICAgIGFt bF93b3JkX2lvKEFNTF9NSU5fRklYRUQsIEFNTF9NQVhfRklYRUQsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgQU1MX1BPU19ERUNPREUsIEFNTF9FTlRJUkVfUkFOR0UsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgMCwgZW50cnktPmJhc2UsIGVudHJ5LT5saW1pdCwgMCwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+bGltaXQgLSBlbnRyeS0+YmFz ZSArIDEpKTsKLSAgICAgICAgY3JzX3JhbmdlX2luc2VydChyYW5nZV9zZXQtPmlvX3Jhbmdlcywg ZW50cnktPmJhc2UsIGVudHJ5LT5saW1pdCk7Ci0gICAgfQotCi0gICAgY3JzX3JhbmdlX21lcmdl KHRlbXBfcmFuZ2Vfc2V0Lm1lbV9yYW5nZXMpOwotICAgIGZvciAoaSA9IDA7IGkgPCB0ZW1wX3Jh bmdlX3NldC5tZW1fcmFuZ2VzLT5sZW47IGkrKykgewotICAgICAgICBlbnRyeSA9IGdfcHRyX2Fy cmF5X2luZGV4KHRlbXBfcmFuZ2Vfc2V0Lm1lbV9yYW5nZXMsIGkpOwotICAgICAgICBhbWxfYXBw ZW5kKGNycywKLSAgICAgICAgICAgICAgICAgICBhbWxfZHdvcmRfbWVtb3J5KEFNTF9QT1NfREVD T0RFLCBBTUxfTUlOX0ZJWEVELAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg QU1MX01BWF9GSVhFRCwgQU1MX05PTl9DQUNIRUFCTEUsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBBTUxfUkVBRF9XUklURSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIDAsIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGltaXQsIDAsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+bGltaXQgLSBlbnRyeS0+YmFzZSArIDEpKTsK LSAgICAgICAgY3JzX3JhbmdlX2luc2VydChyYW5nZV9zZXQtPm1lbV9yYW5nZXMsIGVudHJ5LT5i YXNlLCBlbnRyeS0+bGltaXQpOwotICAgIH0KLQotICAgIGNyc19yYW5nZV9tZXJnZSh0ZW1wX3Jh bmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzKTsKLSAgICBmb3IgKGkgPSAwOyBpIDwgdGVtcF9yYW5n ZV9zZXQubWVtXzY0Yml0X3Jhbmdlcy0+bGVuOyBpKyspIHsKLSAgICAgICAgZW50cnkgPSBnX3B0 cl9hcnJheV9pbmRleCh0ZW1wX3JhbmdlX3NldC5tZW1fNjRiaXRfcmFuZ2VzLCBpKTsKLSAgICAg ICAgYW1sX2FwcGVuZChjcnMsCi0gICAgICAgICAgICAgICAgICAgYW1sX3F3b3JkX21lbW9yeShB TUxfUE9TX0RFQ09ERSwgQU1MX01JTl9GSVhFRCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIEFNTF9NQVhfRklYRUQsIEFNTF9OT05fQ0FDSEVBQkxFLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgQU1MX1JFQURfV1JJVEUsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAwLCBlbnRyeS0+YmFzZSwgZW50cnktPmxpbWl0LCAwLAotICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50cnktPmxpbWl0IC0gZW50cnktPmJh c2UgKyAxKSk7Ci0gICAgICAgIGNyc19yYW5nZV9pbnNlcnQocmFuZ2Vfc2V0LT5tZW1fNjRiaXRf cmFuZ2VzLAotICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5LT5iYXNlLCBlbnRyeS0+bGlt aXQpOwotICAgIH0KLQotICAgIGNyc19yYW5nZV9zZXRfZnJlZSgmdGVtcF9yYW5nZV9zZXQpOwot Ci0gICAgYW1sX2FwcGVuZChjcnMsCi0gICAgICAgIGFtbF93b3JkX2J1c19udW1iZXIoQU1MX01J Tl9GSVhFRCwgQU1MX01BWF9GSVhFRCwgQU1MX1BPU19ERUNPREUsCi0gICAgICAgICAgICAgICAg ICAgICAgICAgICAgMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBwY2lfYnVzX251bSho b3N0LT5idXMpLAotICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1heF9idXMsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgMCwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICBtYXhf YnVzIC0gcGNpX2J1c19udW0oaG9zdC0+YnVzKSArIDEpKTsKLQotICAgIHJldHVybiBjcnM7Ci19 Ci0KIHN0YXRpYyB2b2lkIGJ1aWxkX2hwZXRfYW1sKEFtbCAqdGFibGUpCiB7CiAgICAgQW1sICpj cnM7CkBAIC0xMzM0LDM3ICs5MzAsNiBAQCBzdGF0aWMgQW1sICpidWlsZF9saW5rX2Rldihjb25z dCBjaGFyICpuYW1lLCB1aW50OF90IHVpZCwgQW1sICpyZWcpCiAgICAgcmV0dXJuIGRldjsKICB9 CiAKLXN0YXRpYyBBbWwgKmJ1aWxkX2dzaV9saW5rX2Rldihjb25zdCBjaGFyICpuYW1lLCB1aW50 OF90IHVpZCwgdWludDhfdCBnc2kpCi17Ci0gICAgQW1sICpkZXY7Ci0gICAgQW1sICpjcnM7Ci0g ICAgQW1sICptZXRob2Q7Ci0gICAgdWludDMyX3QgaXJxczsKLQotICAgIGRldiA9IGFtbF9kZXZp Y2UoIiVzIiwgbmFtZSk7Ci0gICAgYW1sX2FwcGVuZChkZXYsIGFtbF9uYW1lX2RlY2woIl9ISUQi LCBhbWxfZWlzYWlkKCJQTlAwQzBGIikpKTsKLSAgICBhbWxfYXBwZW5kKGRldiwgYW1sX25hbWVf ZGVjbCgiX1VJRCIsIGFtbF9pbnQodWlkKSkpOwotCi0gICAgY3JzID0gYW1sX3Jlc291cmNlX3Rl bXBsYXRlKCk7Ci0gICAgaXJxcyA9IGdzaTsKLSAgICBhbWxfYXBwZW5kKGNycywgYW1sX2ludGVy cnVwdChBTUxfQ09OU1VNRVIsIEFNTF9MRVZFTCwgQU1MX0FDVElWRV9ISUdILAotICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIEFNTF9TSEFSRUQsICZpcnFzLCAxKSk7Ci0gICAgYW1s X2FwcGVuZChkZXYsIGFtbF9uYW1lX2RlY2woIl9QUlMiLCBjcnMpKTsKLQotICAgIGFtbF9hcHBl bmQoZGV2LCBhbWxfbmFtZV9kZWNsKCJfQ1JTIiwgY3JzKSk7Ci0KLSAgICAvKgotICAgICAqIF9E SVMgY2FuIGJlIG5vLW9wIGJlY2F1c2UgdGhlIGludGVycnVwdCBjYW5ub3QgYmUgZGlzYWJsZWQu Ci0gICAgICovCi0gICAgbWV0aG9kID0gYW1sX21ldGhvZCgiX0RJUyIsIDAsIEFNTF9OT1RTRVJJ QUxJWkVEKTsKLSAgICBhbWxfYXBwZW5kKGRldiwgbWV0aG9kKTsKLQotICAgIG1ldGhvZCA9IGFt bF9tZXRob2QoIl9TUlMiLCAxLCBBTUxfTk9UU0VSSUFMSVpFRCk7Ci0gICAgYW1sX2FwcGVuZChk ZXYsIG1ldGhvZCk7Ci0KLSAgICByZXR1cm4gZGV2OwotfQotCiAvKiBfQ1JTIG1ldGhvZCAtIGdl dCBjdXJyZW50IHNldHRpbmdzICovCiBzdGF0aWMgQW1sICpidWlsZF9pcWNyX21ldGhvZChib29s IGlzX3BpaXg0KQogewpAQCAtMTcyOCw1NCArMTI5Myw2IEBAIHN0YXRpYyB2b2lkIGJ1aWxkX3Bp aXg0X3BjaV9ob3RwbHVnKEFtbCAqdGFibGUpCiAgICAgYW1sX2FwcGVuZCh0YWJsZSwgc2NvcGUp OwogfQogCi1zdGF0aWMgQW1sICpidWlsZF9xMzVfb3NjX21ldGhvZCh2b2lkKQotewotICAgIEFt bCAqaWZfY3R4OwotICAgIEFtbCAqaWZfY3R4MjsKLSAgICBBbWwgKmVsc2VfY3R4OwotICAgIEFt bCAqbWV0aG9kOwotICAgIEFtbCAqYV9jd2QxID0gYW1sX25hbWUoIkNEVzEiKTsKLSAgICBBbWwg KmFfY3RybCA9IGFtbF9sb2NhbCgwKTsKLQotICAgIG1ldGhvZCA9IGFtbF9tZXRob2QoIl9PU0Mi LCA0LCBBTUxfTk9UU0VSSUFMSVpFRCk7Ci0gICAgYW1sX2FwcGVuZChtZXRob2QsIGFtbF9jcmVh dGVfZHdvcmRfZmllbGQoYW1sX2FyZygzKSwgYW1sX2ludCgwKSwgIkNEVzEiKSk7Ci0KLSAgICBp Zl9jdHggPSBhbWxfaWYoYW1sX2VxdWFsKAotICAgICAgICBhbWxfYXJnKDApLCBhbWxfdG91dWlk KCIzM0RCNEQ1Qi0xRkY3LTQwMUMtOTY1Ny03NDQxQzAzREQ3NjYiKSkpOwotICAgIGFtbF9hcHBl bmQoaWZfY3R4LCBhbWxfY3JlYXRlX2R3b3JkX2ZpZWxkKGFtbF9hcmcoMyksIGFtbF9pbnQoNCks ICJDRFcyIikpOwotICAgIGFtbF9hcHBlbmQoaWZfY3R4LCBhbWxfY3JlYXRlX2R3b3JkX2ZpZWxk KGFtbF9hcmcoMyksIGFtbF9pbnQoOCksICJDRFczIikpOwotCi0gICAgYW1sX2FwcGVuZChpZl9j dHgsIGFtbF9zdG9yZShhbWxfbmFtZSgiQ0RXMyIpLCBhX2N0cmwpKTsKLQotICAgIC8qCi0gICAg ICogQWx3YXlzIGFsbG93IG5hdGl2ZSBQTUUsIEFFUiAobm8gZGVwZW5kZW5jaWVzKQotICAgICAq IEFsbG93IFNIUEMgKFBDSSBicmlkZ2VzIGNhbiBoYXZlIFNIUEMgY29udHJvbGxlcikKLSAgICAg Ki8KLSAgICBhbWxfYXBwZW5kKGlmX2N0eCwgYW1sX2FuZChhX2N0cmwsIGFtbF9pbnQoMHgxRiks IGFfY3RybCkpOwotCi0gICAgaWZfY3R4MiA9IGFtbF9pZihhbWxfbG5vdChhbWxfZXF1YWwoYW1s X2FyZygxKSwgYW1sX2ludCgxKSkpKTsKLSAgICAvKiBVbmtub3duIHJldmlzaW9uICovCi0gICAg YW1sX2FwcGVuZChpZl9jdHgyLCBhbWxfb3IoYV9jd2QxLCBhbWxfaW50KDB4MDgpLCBhX2N3ZDEp KTsKLSAgICBhbWxfYXBwZW5kKGlmX2N0eCwgaWZfY3R4Mik7Ci0KLSAgICBpZl9jdHgyID0gYW1s X2lmKGFtbF9sbm90KGFtbF9lcXVhbChhbWxfbmFtZSgiQ0RXMyIpLCBhX2N0cmwpKSk7Ci0gICAg LyogQ2FwYWJpbGl0aWVzIGJpdHMgd2VyZSBtYXNrZWQgKi8KLSAgICBhbWxfYXBwZW5kKGlmX2N0 eDIsIGFtbF9vcihhX2N3ZDEsIGFtbF9pbnQoMHgxMCksIGFfY3dkMSkpOwotICAgIGFtbF9hcHBl bmQoaWZfY3R4LCBpZl9jdHgyKTsKLQotICAgIC8qIFVwZGF0ZSBEV09SRDMgaW4gdGhlIGJ1ZmZl ciAqLwotICAgIGFtbF9hcHBlbmQoaWZfY3R4LCBhbWxfc3RvcmUoYV9jdHJsLCBhbWxfbmFtZSgi Q0RXMyIpKSk7Ci0gICAgYW1sX2FwcGVuZChtZXRob2QsIGlmX2N0eCk7Ci0KLSAgICBlbHNlX2N0 eCA9IGFtbF9lbHNlKCk7Ci0gICAgLyogVW5yZWNvZ25pemVkIFVVSUQgKi8KLSAgICBhbWxfYXBw ZW5kKGVsc2VfY3R4LCBhbWxfb3IoYV9jd2QxLCBhbWxfaW50KDQpLCBhX2N3ZDEpKTsKLSAgICBh bWxfYXBwZW5kKG1ldGhvZCwgZWxzZV9jdHgpOwotCi0gICAgYW1sX2FwcGVuZChtZXRob2QsIGFt bF9yZXR1cm4oYW1sX2FyZygzKSkpOwotICAgIHJldHVybiBtZXRob2Q7Ci19Ci0KIHN0YXRpYyB2 b2lkCiBidWlsZF9kc2R0KEdBcnJheSAqdGFibGVfZGF0YSwgQklPU0xpbmtlciAqbGlua2VyLAog ICAgICAgICAgICBBY3BpUG1JbmZvICpwbSwgQWNwaU1pc2NJbmZvICptaXNjLApAQCAtMTgxOCw3 ICsxMzM1LDcgQEAgYnVpbGRfZHNkdChHQXJyYXkgKnRhYmxlX2RhdGEsIEJJT1NMaW5rZXIgKmxp bmtlciwKICAgICAgICAgYW1sX2FwcGVuZChkZXYsIGFtbF9uYW1lX2RlY2woIl9DSUQiLCBhbWxf ZWlzYWlkKCJQTlAwQTAzIikpKTsKICAgICAgICAgYW1sX2FwcGVuZChkZXYsIGFtbF9uYW1lX2Rl Y2woIl9BRFIiLCBhbWxfaW50KDApKSk7CiAgICAgICAgIGFtbF9hcHBlbmQoZGV2LCBhbWxfbmFt ZV9kZWNsKCJfVUlEIiwgYW1sX2ludCgxKSkpOwotICAgICAgICBhbWxfYXBwZW5kKGRldiwgYnVp bGRfcTM1X29zY19tZXRob2QoKSk7CisgICAgICAgIGFtbF9hcHBlbmQoZGV2LCBidWlsZF9vc2Nf bWV0aG9kKCkpOwogICAgICAgICBhbWxfYXBwZW5kKHNiX3Njb3BlLCBkZXYpOwogICAgICAgICBh bWxfYXBwZW5kKGRzZHQsIHNiX3Njb3BlKTsKIApAQCAtMTg4Myw3ICsxNDAwLDcgQEAgYnVpbGRf ZHNkdChHQXJyYXkgKnRhYmxlX2RhdGEsIEJJT1NMaW5rZXIgKmxpbmtlciwKICAgICAgICAgICAg IGFtbF9hcHBlbmQoZGV2LCBhbWxfbmFtZV9kZWNsKCJfSElEIiwgYW1sX2Vpc2FpZCgiUE5QMEEw MyIpKSk7CiAgICAgICAgICAgICBhbWxfYXBwZW5kKGRldiwgYW1sX25hbWVfZGVjbCgiX0JCTiIs IGFtbF9pbnQoYnVzX251bSkpKTsKICAgICAgICAgICAgIGlmIChwY2lfYnVzX2lzX2V4cHJlc3Mo YnVzKSkgewotICAgICAgICAgICAgICAgIGFtbF9hcHBlbmQoZGV2LCBidWlsZF9xMzVfb3NjX21l dGhvZCgpKTsKKyAgICAgICAgICAgICAgICBhbWxfYXBwZW5kKGRldiwgYnVpbGRfb3NjX21ldGhv ZCgpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAgaWYgKG51bWFfbm9kZSAhPSBOVU1B X05PREVfVU5BU1NJR05FRCkgewpAQCAtMjM3MCwzNSArMTg4Nyw2IEBAIGJ1aWxkX3NyYXQoR0Fy cmF5ICp0YWJsZV9kYXRhLCBCSU9TTGlua2VyICpsaW5rZXIsCiAgICAgICAgICAgICAgICAgIHRh YmxlX2RhdGEtPmxlbiAtIHNyYXRfc3RhcnQsIDEsIE5VTEwsIE5VTEwpOwogfQogCi1zdGF0aWMg dm9pZAotYnVpbGRfbWNmZ19xMzUoR0FycmF5ICp0YWJsZV9kYXRhLCBCSU9TTGlua2VyICpsaW5r ZXIsIEFjcGlNY2ZnSW5mbyAqaW5mbykKLXsKLSAgICBBY3BpVGFibGVNY2ZnICptY2ZnOwotICAg IGNvbnN0IGNoYXIgKnNpZzsKLSAgICBpbnQgbGVuID0gc2l6ZW9mKCptY2ZnKSArIDEgKiBzaXpl b2YobWNmZy0+YWxsb2NhdGlvblswXSk7Ci0KLSAgICBtY2ZnID0gYWNwaV9kYXRhX3B1c2godGFi bGVfZGF0YSwgbGVuKTsKLSAgICBtY2ZnLT5hbGxvY2F0aW9uWzBdLmFkZHJlc3MgPSBjcHVfdG9f bGU2NChpbmZvLT5tY2ZnX2Jhc2UpOwotICAgIC8qIE9ubHkgYSBzaW5nbGUgYWxsb2NhdGlvbiBz byBubyBuZWVkIHRvIHBsYXkgd2l0aCBzZWdtZW50cyAqLwotICAgIG1jZmctPmFsbG9jYXRpb25b MF0ucGNpX3NlZ21lbnQgPSBjcHVfdG9fbGUxNigwKTsKLSAgICBtY2ZnLT5hbGxvY2F0aW9uWzBd LnN0YXJ0X2J1c19udW1iZXIgPSAwOwotICAgIG1jZmctPmFsbG9jYXRpb25bMF0uZW5kX2J1c19u dW1iZXIgPSBQQ0lFX01NQ0ZHX0JVUyhpbmZvLT5tY2ZnX3NpemUgLSAxKTsKLQotICAgIC8qIE1D RkcgaXMgdXNlZCBmb3IgRUNBTSB3aGljaCBjYW4gYmUgZW5hYmxlZCBvciBkaXNhYmxlZCBieSBn dWVzdC4KLSAgICAgKiBUbyBhdm9pZCB0YWJsZSBzaXplIGNoYW5nZXMgKHdoaWNoIGNyZWF0ZSBt aWdyYXRpb24gaXNzdWVzKSwKLSAgICAgKiBhbHdheXMgY3JlYXRlIHRoZSB0YWJsZSBldmVuIGlm IHRoZXJlIGFyZSBubyBhbGxvY2F0aW9ucywKLSAgICAgKiBidXQgc2V0IHRoZSBzaWduYXR1cmUg dG8gYSByZXNlcnZlZCB2YWx1ZSBpbiB0aGlzIGNhc2UuCi0gICAgICogQUNQSSBzcGVjIHJlcXVp cmVzIE9TUE1zIHRvIGlnbm9yZSBzdWNoIHRhYmxlcy4KLSAgICAgKi8KLSAgICBpZiAoaW5mby0+ bWNmZ19iYXNlID09IFBDSUVfQkFTRV9BRERSX1VOTUFQUEVEKSB7Ci0gICAgICAgIC8qIFJlc2Vy dmVkIHNpZ25hdHVyZTogaWdub3JlZCBieSBPU1BNICovCi0gICAgICAgIHNpZyA9ICJRRU1VIjsK LSAgICB9IGVsc2UgewotICAgICAgICBzaWcgPSAiTUNGRyI7Ci0gICAgfQotICAgIGJ1aWxkX2hl YWRlcihsaW5rZXIsIHRhYmxlX2RhdGEsICh2b2lkICopbWNmZywgc2lnLCBsZW4sIDEsIE5VTEws IE5VTEwpOwotfQotCiAvKgogICogVlQtZCBzcGVjIDguMSBETUEgUmVtYXBwaW5nIFJlcG9ydGlu ZyBTdHJ1Y3R1cmUKICAqICh2ZXJzaW9uIE9jdC4gMjAxNCBvciBsYXRlcikKQEAgLTI2MjYsNyAr MjExNCw3IEBAIHZvaWQgYWNwaV9idWlsZChBY3BpQnVpbGRUYWJsZXMgKnRhYmxlcywKICAgICB9 CiAgICAgaWYgKGFjcGlfZ2V0X21jZmcoJm1jZmcpKSB7CiAgICAgICAgIGFjcGlfYWRkX3RhYmxl KHRhYmxlX29mZnNldHMsIHRhYmxlc19ibG9iKTsKLSAgICAgICAgYnVpbGRfbWNmZ19xMzUodGFi bGVzX2Jsb2IsIHRhYmxlcy0+bGlua2VyLCAmbWNmZyk7CisgICAgICAgIGJ1aWxkX21jZmcodGFi bGVzX2Jsb2IsIHRhYmxlcy0+bGlua2VyLCAmbWNmZyk7CiAgICAgfQogICAgIGlmICh4ODZfaW9t bXVfZ2V0X2RlZmF1bHQoKSkgewogICAgICAgICBJb21tdVR5cGUgSU9NTVVUeXBlID0geDg2X2lv bW11X2dldF90eXBlKCk7Ci0tIAoyLjE5LjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0 cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlz dGluZm8veGVuLWRldmVs