From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:43395) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gUfnw-0005dA-64 for qemu-devel@nongnu.org; Wed, 05 Dec 2018 17:38:05 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gUfnr-0001vG-E4 for qemu-devel@nongnu.org; Wed, 05 Dec 2018 17:38:04 -0500 Received: from userp2120.oracle.com ([156.151.31.85]:54540) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gUfnr-0001rZ-4z for qemu-devel@nongnu.org; Wed, 05 Dec 2018 17:37:59 -0500 From: Liam Merwick Date: Wed, 5 Dec 2018 22:37:25 +0000 Message-Id: <1544049446-6359-3-git-send-email-liam.merwick@oracle.com> In-Reply-To: <1544049446-6359-1-git-send-email-liam.merwick@oracle.com> References: <1544049446-6359-1-git-send-email-liam.merwick@oracle.com> Subject: [Qemu-devel] [RFC 2/3] pc: Read PVH entry point from ELF note in kernel binary List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: pbonzini@redhat.com, ehabkost@redhat.com, rth@twiddle.net, xen-devel@lists.xenproject.org, sgarzare@redhat.com, mst@redhat.com, stefanha@redhat.com, maran.wilson@oracle.com, liam.merwick@oracle.com From: Liam Merwick Add support to read the PVH Entry address from an ELF note in the uncompressed kernel binary (as defined by the x86/HVM direct boot ABI). This 32-bit entry point will be used by QEMU to load the kernel in the guest and jump into the kernel entry point. For now, a call to this function is added in pc_memory_init() to read the address - a future patch will use the entry point. Signed-off-by: Liam Merwick --- hw/i386/pc.c | 272 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++- include/elf.h | 10 +++ 2 files changed, 281 insertions(+), 1 deletion(-) diff --git a/hw/i386/pc.c b/hw/i386/pc.c index f095725dbab2..056aa46d99b9 100644 --- a/hw/i386/pc.c +++ b/hw/i386/pc.c @@ -109,6 +109,9 @@ static struct e820_entry *e820_table; static unsigned e820_entries; struct hpet_fw_config hpet_cfg = {.count = UINT8_MAX}; +/* Physical Address of PVH entry point read from kernel ELF NOTE */ +static size_t pvh_start_addr; + void gsi_handler(void *opaque, int n, int level) { GSIState *s = opaque; @@ -834,6 +837,267 @@ struct setup_data { uint8_t data[0]; } __attribute__((packed)); +/* + * Search through the ELF Notes for an entry with the given + * ELF Note type + */ +static void *get_elf_note_type(void *ehdr, void *phdr, bool elf_is64, + size_t elf_note_type) +{ + void *nhdr = NULL; + size_t nhdr_size = elf_is64 ? sizeof(Elf64_Nhdr) : sizeof(Elf32_Nhdr); + size_t elf_note_entry_sz = 0; + size_t phdr_off; + size_t phdr_align; + size_t phdr_memsz; + size_t nhdr_namesz; + size_t nhdr_descsz; + size_t note_type; + + phdr_off = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_offset : ((Elf32_Phdr *)phdr)->p_offset; + phdr_align = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_align : ((Elf32_Phdr *)phdr)->p_align; + phdr_memsz = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_memsz : ((Elf32_Phdr *)phdr)->p_memsz; + + nhdr = ehdr + phdr_off; + note_type = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_type : ((Elf32_Nhdr *)nhdr)->n_type; + nhdr_namesz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_namesz : ((Elf32_Nhdr *)nhdr)->n_namesz; + nhdr_descsz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_descsz : ((Elf32_Nhdr *)nhdr)->n_descsz; + + while (note_type != elf_note_type) { + elf_note_entry_sz = nhdr_size + + QEMU_ALIGN_UP(nhdr_namesz, phdr_align) + + QEMU_ALIGN_UP(nhdr_descsz, phdr_align); + + /* + * Verify that we haven't exceeded the end of the ELF Note section. + * If we have, then there is no note of the given type present + * in the ELF Notes. + */ + if (phdr_off + phdr_memsz < ((nhdr - ehdr) + elf_note_entry_sz)) { + error_report("Note type (0x%lx) not found in ELF Note section", + elf_note_type); + return NULL; + } + + /* skip to the next ELF Note entry */ + nhdr += elf_note_entry_sz; + note_type = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_type : ((Elf32_Nhdr *)nhdr)->n_type; + nhdr_namesz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_namesz : ((Elf32_Nhdr *)nhdr)->n_namesz; + nhdr_descsz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_descsz : ((Elf32_Nhdr *)nhdr)->n_descsz; + } + + return nhdr; +} + +/* + * The entry point into the kernel for PVH boot is different from + * the native entry point. The PVH entry is defined by the x86/HVM + * direct boot ABI and is available in an ELFNOTE in the kernel binary. + * This function reads the ELF headers of the binary specified on the + * command line by -kernel (path contained in 'filename') and discovers + * the PVH entry address from the appropriate ELF Note. + * + * The address of the PVH entry point is saved to the 'pvh_start_addr' + * global variable. The ELF class of the binary is returned via 'elfclass' + * (although the entry point is 32-bit, the kernel binary can be either + * 32-bit or 64-bit). + */ +static bool read_pvh_start_addr_elf_note(const char *filename, + unsigned char *elfclass) +{ + void *ehdr = NULL; /* Cast to Elf64_Ehdr or Elf32_Ehdr */ + void *phdr = NULL; /* Cast to Elf64_Phdr or Elf32_Phdr */ + void *nhdr = NULL; /* Cast to Elf64_Nhdr or Elf32_Nhdr */ + struct stat statbuf; + size_t ehdr_size; + size_t phdr_size; + size_t nhdr_size; + size_t elf_note_data_addr; + /* Ehdr fields */ + size_t ehdr_poff; + /* Phdr fields */ + size_t phdr_off; + size_t phdr_align; + size_t phdr_memsz; + size_t phdr_type; + /* Nhdr fields */ + size_t nhdr_namesz; + size_t nhdr_descsz; + bool elf_is64; + FILE *file; + union { + Elf32_Ehdr h32; + Elf64_Ehdr h64; + } elf_header; + Error *err = NULL; + + pvh_start_addr = 0; + + if (filename == NULL) { + return false; + } + + file = fopen(filename, "rb"); + if (file == NULL) { + error_report("fopen(%s) failed", filename); + return false; + } + + if (fstat(fileno(file), &statbuf) < 0) { + error_report("fstat() failed on file (%s)", filename); + return false; + } + + load_elf_hdr(filename, &elf_header, &elf_is64, &err); + if (err) { + error_free(err); + fclose(file); + return false; + } + + *elfclass = elf_is64 ? + elf_header.h64.e_ident[EI_CLASS] : elf_header.h32.e_ident[EI_CLASS]; + if (*elfclass == ELFCLASSNONE) { + error_report("kernel binary (%s) is ELFCLASSNONE", filename); + fclose(file); + return false; + } + + ehdr_size = elf_is64 ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr); + phdr_size = elf_is64 ? sizeof(Elf64_Phdr) : sizeof(Elf32_Phdr); + nhdr_size = elf_is64 ? sizeof(Elf64_Nhdr) : sizeof(Elf32_Nhdr); + + /* We have already validated the ELF header when calling elf_load_hdr() */ + + ehdr = mmap(0, statbuf.st_size, + PROT_READ | PROT_WRITE, MAP_PRIVATE, fileno(file), 0); + if (ehdr == MAP_FAILED) { + error_report("Failed to mmap kernel binary (%s)", filename); + goto done; + } + + /* + * Search through the program execution header for the + * ELF Note section. + */ + + ehdr_poff = elf_is64 ? + ((Elf64_Ehdr *)(ehdr))->e_phoff : ((Elf32_Ehdr *)(ehdr))->e_phoff; + if (statbuf.st_size < (ehdr_size + ehdr_poff)) { + error_report("ELF NOTE section exceeds file (%s) size", + filename); + goto done; + } + + phdr = ehdr + ehdr_poff; + phdr_type = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_type : ((Elf32_Phdr *)phdr)->p_type; + while (phdr != NULL && phdr_type != PT_NOTE) { + if (statbuf.st_size < ((phdr - ehdr) + phdr_size)) { + error_report("ELF Program headers in file (%s) too short", + filename); + goto done; + } + phdr += phdr_size; + phdr_type = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_type : ((Elf32_Phdr *)phdr)->p_type; + } + + phdr_off = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_offset : ((Elf32_Phdr *)phdr)->p_offset; + phdr_align = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_align : ((Elf32_Phdr *)phdr)->p_align; + phdr_memsz = elf_is64 ? + ((Elf64_Phdr *)phdr)->p_memsz : ((Elf32_Phdr *)phdr)->p_memsz; + + /* + * check that the start of the ELF Note section is within the bounds + * of the kernel ELF binary + */ + if (statbuf.st_size < (ehdr_poff + phdr_size + phdr_off)) { + error_report("Start of ELF note section outside of file (%s) bounds", + filename); + goto done; + } + /* + * check that the end of the ELF Note section is within the bounds + * of the kernel ELF binary + */ + if (statbuf.st_size < (phdr_off + phdr_memsz)) { + error_report("End of ELF note section outside of file (%s) bounds", + filename); + goto done; + } + + /* + * Search through the ELF Notes for an entry with the + * Physical Address (PA) of the PVH entry point. + */ + nhdr = get_elf_note_type(ehdr, phdr, elf_is64, XEN_ELFNOTE_PHYS32_ENTRY); + if (nhdr == NULL) { + error_report("No PVH Entry details in kernel (%s) ELF Note section", + filename); + goto done; + } + + /* + * Verify that the returned ELF Note header doesn't exceed the + * end of the kernel file + */ + if (statbuf.st_size < ((nhdr - ehdr))) { + error_report("ELF Nhdr offset (0x%lx) exceeds file (%s) bounds (%ld)", + (nhdr - ehdr), filename, statbuf.st_size); + goto done; + } + + nhdr_namesz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_namesz : ((Elf32_Nhdr *)nhdr)->n_namesz; + nhdr_descsz = elf_is64 ? + ((Elf64_Nhdr *)nhdr)->n_descsz : ((Elf32_Nhdr *)nhdr)->n_descsz; + + /* + * Verify that the ELF Note contents don't exceed the end of the + * kernel file + */ + if (statbuf.st_size < ((nhdr - ehdr)) + nhdr_size + + QEMU_ALIGN_UP(nhdr_namesz, phdr_align) + + QEMU_ALIGN_UP(nhdr_descsz, phdr_align)) { + error_report("ELF Nhdr contents (0x%lx) exceeds file bounds (%ld)", + (nhdr - ehdr) + nhdr_size + QEMU_ALIGN_UP(nhdr_namesz, phdr_align) + + QEMU_ALIGN_UP(nhdr_descsz, phdr_align), statbuf.st_size); + goto done; + } + + elf_note_data_addr = + (size_t)nhdr + nhdr_size + QEMU_ALIGN_UP(nhdr_namesz, phdr_align); + + pvh_start_addr = *(size_t *)elf_note_data_addr; + + /* + * Verify that the PVH Entry point address does not exceed the + * bounds of the kernel file. + */ + if (statbuf.st_size < pvh_start_addr) { + error_report("PVH ELF note addr (0x%lx) exceeds file (%s) bounds (%ld)", + (elf_note_data_addr - (size_t)ehdr), filename, statbuf.st_size); + pvh_start_addr = 0; + goto done; + } + +done: + (void) munmap(ehdr, statbuf.st_size); + return pvh_start_addr != 0; +} + static void load_linux(PCMachineState *pcms, FWCfgState *fw_cfg) { @@ -1334,9 +1598,11 @@ void pc_memory_init(PCMachineState *pcms, int linux_boot, i; MemoryRegion *ram, *option_rom_mr; MemoryRegion *ram_below_4g, *ram_above_4g; - FWCfgState *fw_cfg; + FWCfgState *fw_cfg = NULL; + unsigned char class = ELFCLASSNONE; MachineState *machine = MACHINE(pcms); PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms); + const char *kernel_filename = machine->kernel_filename; assert(machine->ram_size == pcms->below_4g_mem_size + pcms->above_4g_mem_size); @@ -1418,6 +1684,10 @@ void pc_memory_init(PCMachineState *pcms, &machine->device_memory->mr); } + if (linux_boot) { + read_pvh_start_addr_elf_note(kernel_filename, &class); + } + /* Initialize PC system firmware */ pc_system_firmware_init(rom_memory, !pcmc->pci_enabled); diff --git a/include/elf.h b/include/elf.h index c151164b63da..1f82c7a7124b 100644 --- a/include/elf.h +++ b/include/elf.h @@ -1585,6 +1585,16 @@ typedef struct elf64_shdr { #define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */ #define NT_ARM_SYSTEM_CALL 0x404 /* ARM system call number */ +/* + * Physical entry point into the kernel. + * + * 32bit entry point into the kernel. When requested to launch the + * guest kernel, use this entry point to launch the guest in 32-bit + * protected mode with paging disabled. + * + * [ Corresponding definition in Linux kernel: include/xen/interface/elfnote.h ] + */ +#define XEN_ELFNOTE_PHYS32_ENTRY 18 /* 0x12 */ /* Note header in a PT_NOTE section */ typedef struct elf32_note { -- 1.8.3.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Liam Merwick Subject: [RFC 2/3] pc: Read PVH entry point from ELF note in kernel binary Date: Wed, 5 Dec 2018 22:37:25 +0000 Message-ID: <1544049446-6359-3-git-send-email-liam.merwick@oracle.com> References: <1544049446-6359-1-git-send-email-liam.merwick@oracle.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1gUfnr-0005dg-Gz for xen-devel@lists.xenproject.org; Wed, 05 Dec 2018 22:37:59 +0000 In-Reply-To: <1544049446-6359-1-git-send-email-liam.merwick@oracle.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: liam.merwick@oracle.com, ehabkost@redhat.com, mst@redhat.com, maran.wilson@oracle.com, stefanha@redhat.com, xen-devel@lists.xenproject.org, pbonzini@redhat.com, rth@twiddle.net, sgarzare@redhat.com List-Id: xen-devel@lists.xenproject.org RnJvbTogTGlhbSBNZXJ3aWNrIDxMaWFtLk1lcndpY2tAb3JhY2xlLmNvbT4KCkFkZCBzdXBwb3J0 IHRvIHJlYWQgdGhlIFBWSCBFbnRyeSBhZGRyZXNzIGZyb20gYW4gRUxGIG5vdGUgaW4gdGhlCnVu Y29tcHJlc3NlZCBrZXJuZWwgYmluYXJ5IChhcyBkZWZpbmVkIGJ5IHRoZSB4ODYvSFZNIGRpcmVj dCBib290IEFCSSkuClRoaXMgMzItYml0IGVudHJ5IHBvaW50IHdpbGwgYmUgdXNlZCBieSBRRU1V IHRvIGxvYWQgdGhlIGtlcm5lbCBpbiB0aGUKZ3Vlc3QgYW5kIGp1bXAgaW50byB0aGUga2VybmVs IGVudHJ5IHBvaW50LgoKRm9yIG5vdywgYSBjYWxsIHRvIHRoaXMgZnVuY3Rpb24gaXMgYWRkZWQg aW4gcGNfbWVtb3J5X2luaXQoKSB0byByZWFkIHRoZQphZGRyZXNzIC0gYSBmdXR1cmUgcGF0Y2gg d2lsbCB1c2UgdGhlIGVudHJ5IHBvaW50LgoKU2lnbmVkLW9mZi1ieTogTGlhbSBNZXJ3aWNrIDxM aWFtLk1lcndpY2tAb3JhY2xlLmNvbT4KLS0tCiBody9pMzg2L3BjLmMgIHwgMjcyICsrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIGluY2x1 ZGUvZWxmLmggfCAgMTAgKysrCiAyIGZpbGVzIGNoYW5nZWQsIDI4MSBpbnNlcnRpb25zKCspLCAx IGRlbGV0aW9uKC0pCgpkaWZmIC0tZ2l0IGEvaHcvaTM4Ni9wYy5jIGIvaHcvaTM4Ni9wYy5jCmlu ZGV4IGYwOTU3MjVkYmFiMi4uMDU2YWE0NmQ5OWI5IDEwMDY0NAotLS0gYS9ody9pMzg2L3BjLmMK KysrIGIvaHcvaTM4Ni9wYy5jCkBAIC0xMDksNiArMTA5LDkgQEAgc3RhdGljIHN0cnVjdCBlODIw X2VudHJ5ICplODIwX3RhYmxlOwogc3RhdGljIHVuc2lnbmVkIGU4MjBfZW50cmllczsKIHN0cnVj dCBocGV0X2Z3X2NvbmZpZyBocGV0X2NmZyA9IHsuY291bnQgPSBVSU5UOF9NQVh9OwogCisvKiBQ aHlzaWNhbCBBZGRyZXNzIG9mIFBWSCBlbnRyeSBwb2ludCByZWFkIGZyb20ga2VybmVsIEVMRiBO T1RFICovCitzdGF0aWMgc2l6ZV90IHB2aF9zdGFydF9hZGRyOworCiB2b2lkIGdzaV9oYW5kbGVy KHZvaWQgKm9wYXF1ZSwgaW50IG4sIGludCBsZXZlbCkKIHsKICAgICBHU0lTdGF0ZSAqcyA9IG9w YXF1ZTsKQEAgLTgzNCw2ICs4MzcsMjY3IEBAIHN0cnVjdCBzZXR1cF9kYXRhIHsKICAgICB1aW50 OF90IGRhdGFbMF07CiB9IF9fYXR0cmlidXRlX18oKHBhY2tlZCkpOwogCisvKgorICogU2VhcmNo IHRocm91Z2ggdGhlIEVMRiBOb3RlcyBmb3IgYW4gZW50cnkgd2l0aCB0aGUgZ2l2ZW4KKyAqIEVM RiBOb3RlIHR5cGUKKyAqLworc3RhdGljIHZvaWQgKmdldF9lbGZfbm90ZV90eXBlKHZvaWQgKmVo ZHIsIHZvaWQgKnBoZHIsIGJvb2wgZWxmX2lzNjQsCisgICAgc2l6ZV90IGVsZl9ub3RlX3R5cGUp Cit7CisgICAgdm9pZCAqbmhkciA9IE5VTEw7CisgICAgc2l6ZV90IG5oZHJfc2l6ZSA9IGVsZl9p czY0ID8gc2l6ZW9mKEVsZjY0X05oZHIpIDogc2l6ZW9mKEVsZjMyX05oZHIpOworICAgIHNpemVf dCBlbGZfbm90ZV9lbnRyeV9zeiA9IDA7CisgICAgc2l6ZV90IHBoZHJfb2ZmOworICAgIHNpemVf dCBwaGRyX2FsaWduOworICAgIHNpemVfdCBwaGRyX21lbXN6OworICAgIHNpemVfdCBuaGRyX25h bWVzejsKKyAgICBzaXplX3Qgbmhkcl9kZXNjc3o7CisgICAgc2l6ZV90IG5vdGVfdHlwZTsKKwor ICAgIHBoZHJfb2ZmID0gZWxmX2lzNjQgPworICAgICAgICAoKEVsZjY0X1BoZHIgKilwaGRyKS0+ cF9vZmZzZXQgOiAoKEVsZjMyX1BoZHIgKilwaGRyKS0+cF9vZmZzZXQ7CisgICAgcGhkcl9hbGln biA9IGVsZl9pczY0ID8KKyAgICAgICAgKChFbGY2NF9QaGRyICopcGhkciktPnBfYWxpZ24gOiAo KEVsZjMyX1BoZHIgKilwaGRyKS0+cF9hbGlnbjsKKyAgICBwaGRyX21lbXN6ID0gZWxmX2lzNjQg PworICAgICAgICAoKEVsZjY0X1BoZHIgKilwaGRyKS0+cF9tZW1zeiA6ICgoRWxmMzJfUGhkciAq KXBoZHIpLT5wX21lbXN6OworCisgICAgbmhkciA9IGVoZHIgKyBwaGRyX29mZjsKKyAgICBub3Rl X3R5cGUgPSBlbGZfaXM2NCA/CisgICAgICAgICgoRWxmNjRfTmhkciAqKW5oZHIpLT5uX3R5cGUg OiAoKEVsZjMyX05oZHIgKiluaGRyKS0+bl90eXBlOworICAgIG5oZHJfbmFtZXN6ID0gZWxmX2lz NjQgPworICAgICAgICAoKEVsZjY0X05oZHIgKiluaGRyKS0+bl9uYW1lc3ogOiAoKEVsZjMyX05o ZHIgKiluaGRyKS0+bl9uYW1lc3o7CisgICAgbmhkcl9kZXNjc3ogPSBlbGZfaXM2NCA/CisgICAg ICAgICgoRWxmNjRfTmhkciAqKW5oZHIpLT5uX2Rlc2NzeiA6ICgoRWxmMzJfTmhkciAqKW5oZHIp LT5uX2Rlc2NzejsKKworICAgIHdoaWxlIChub3RlX3R5cGUgIT0gZWxmX25vdGVfdHlwZSkgewor ICAgICAgICBlbGZfbm90ZV9lbnRyeV9zeiA9IG5oZHJfc2l6ZSArCisgICAgICAgICAgICBRRU1V X0FMSUdOX1VQKG5oZHJfbmFtZXN6LCBwaGRyX2FsaWduKSArCisgICAgICAgICAgICBRRU1VX0FM SUdOX1VQKG5oZHJfZGVzY3N6LCBwaGRyX2FsaWduKTsKKworICAgICAgICAvKgorICAgICAgICAg KiBWZXJpZnkgdGhhdCB3ZSBoYXZlbid0IGV4Y2VlZGVkIHRoZSBlbmQgb2YgdGhlIEVMRiBOb3Rl IHNlY3Rpb24uCisgICAgICAgICAqIElmIHdlIGhhdmUsIHRoZW4gdGhlcmUgaXMgbm8gbm90ZSBv ZiB0aGUgZ2l2ZW4gdHlwZSBwcmVzZW50CisgICAgICAgICAqIGluIHRoZSBFTEYgTm90ZXMuCisg ICAgICAgICAqLworICAgICAgICBpZiAocGhkcl9vZmYgKyBwaGRyX21lbXN6IDwgKChuaGRyIC0g ZWhkcikgKyBlbGZfbm90ZV9lbnRyeV9zeikpIHsKKyAgICAgICAgICAgIGVycm9yX3JlcG9ydCgi Tm90ZSB0eXBlICgweCVseCkgbm90IGZvdW5kIGluIEVMRiBOb3RlIHNlY3Rpb24iLAorICAgICAg ICAgICAgICAgIGVsZl9ub3RlX3R5cGUpOworICAgICAgICAgICAgcmV0dXJuIE5VTEw7CisgICAg ICAgIH0KKworICAgICAgICAvKiBza2lwIHRvIHRoZSBuZXh0IEVMRiBOb3RlIGVudHJ5ICovCisg ICAgICAgIG5oZHIgKz0gZWxmX25vdGVfZW50cnlfc3o7CisgICAgICAgIG5vdGVfdHlwZSA9IGVs Zl9pczY0ID8KKyAgICAgICAgICAgICgoRWxmNjRfTmhkciAqKW5oZHIpLT5uX3R5cGUgOiAoKEVs ZjMyX05oZHIgKiluaGRyKS0+bl90eXBlOworICAgICAgICBuaGRyX25hbWVzeiA9IGVsZl9pczY0 ID8KKyAgICAgICAgICAgICgoRWxmNjRfTmhkciAqKW5oZHIpLT5uX25hbWVzeiA6ICgoRWxmMzJf TmhkciAqKW5oZHIpLT5uX25hbWVzejsKKyAgICAgICAgbmhkcl9kZXNjc3ogPSBlbGZfaXM2NCA/ CisgICAgICAgICAgICAoKEVsZjY0X05oZHIgKiluaGRyKS0+bl9kZXNjc3ogOiAoKEVsZjMyX05o ZHIgKiluaGRyKS0+bl9kZXNjc3o7CisgICAgfQorCisgICAgcmV0dXJuIG5oZHI7Cit9CisKKy8q CisgKiBUaGUgZW50cnkgcG9pbnQgaW50byB0aGUga2VybmVsIGZvciBQVkggYm9vdCBpcyBkaWZm ZXJlbnQgZnJvbQorICogdGhlIG5hdGl2ZSBlbnRyeSBwb2ludC4gIFRoZSBQVkggZW50cnkgaXMg ZGVmaW5lZCBieSB0aGUgeDg2L0hWTQorICogZGlyZWN0IGJvb3QgQUJJIGFuZCBpcyBhdmFpbGFi bGUgaW4gYW4gRUxGTk9URSBpbiB0aGUga2VybmVsIGJpbmFyeS4KKyAqIFRoaXMgZnVuY3Rpb24g cmVhZHMgdGhlIEVMRiBoZWFkZXJzIG9mIHRoZSBiaW5hcnkgc3BlY2lmaWVkIG9uIHRoZQorICog Y29tbWFuZCBsaW5lIGJ5IC1rZXJuZWwgKHBhdGggY29udGFpbmVkIGluICdmaWxlbmFtZScpIGFu ZCBkaXNjb3ZlcnMKKyAqIHRoZSBQVkggZW50cnkgYWRkcmVzcyBmcm9tIHRoZSBhcHByb3ByaWF0 ZSBFTEYgTm90ZS4KKyAqCisgKiBUaGUgYWRkcmVzcyBvZiB0aGUgUFZIIGVudHJ5IHBvaW50IGlz IHNhdmVkIHRvIHRoZSAncHZoX3N0YXJ0X2FkZHInCisgKiBnbG9iYWwgdmFyaWFibGUuIFRoZSBF TEYgY2xhc3Mgb2YgdGhlIGJpbmFyeSBpcyByZXR1cm5lZCB2aWEgJ2VsZmNsYXNzJworICogKGFs dGhvdWdoIHRoZSBlbnRyeSBwb2ludCBpcyAzMi1iaXQsIHRoZSBrZXJuZWwgYmluYXJ5IGNhbiBi ZSBlaXRoZXIKKyAqIDMyLWJpdCBvciA2NC1iaXQpLgorICovCitzdGF0aWMgYm9vbCByZWFkX3B2 aF9zdGFydF9hZGRyX2VsZl9ub3RlKGNvbnN0IGNoYXIgKmZpbGVuYW1lLAorICAgIHVuc2lnbmVk IGNoYXIgKmVsZmNsYXNzKQoreworICAgIHZvaWQgKmVoZHIgPSBOVUxMOyAvKiBDYXN0IHRvIEVs ZjY0X0VoZHIgb3IgRWxmMzJfRWhkciAqLworICAgIHZvaWQgKnBoZHIgPSBOVUxMOyAvKiBDYXN0 IHRvIEVsZjY0X1BoZHIgb3IgRWxmMzJfUGhkciAqLworICAgIHZvaWQgKm5oZHIgPSBOVUxMOyAv KiBDYXN0IHRvIEVsZjY0X05oZHIgb3IgRWxmMzJfTmhkciAqLworICAgIHN0cnVjdCBzdGF0IHN0 YXRidWY7CisgICAgc2l6ZV90IGVoZHJfc2l6ZTsKKyAgICBzaXplX3QgcGhkcl9zaXplOworICAg IHNpemVfdCBuaGRyX3NpemU7CisgICAgc2l6ZV90IGVsZl9ub3RlX2RhdGFfYWRkcjsKKyAgICAv KiBFaGRyIGZpZWxkcyAqLworICAgIHNpemVfdCBlaGRyX3BvZmY7CisgICAgLyogUGhkciBmaWVs ZHMgKi8KKyAgICBzaXplX3QgcGhkcl9vZmY7CisgICAgc2l6ZV90IHBoZHJfYWxpZ247CisgICAg c2l6ZV90IHBoZHJfbWVtc3o7CisgICAgc2l6ZV90IHBoZHJfdHlwZTsKKyAgICAvKiBOaGRyIGZp ZWxkcyAqLworICAgIHNpemVfdCBuaGRyX25hbWVzejsKKyAgICBzaXplX3Qgbmhkcl9kZXNjc3o7 CisgICAgYm9vbCBlbGZfaXM2NDsKKyAgICBGSUxFICpmaWxlOworICAgIHVuaW9uIHsKKyAgICAg ICAgRWxmMzJfRWhkciBoMzI7CisgICAgICAgIEVsZjY0X0VoZHIgaDY0OworICAgIH0gZWxmX2hl YWRlcjsKKyAgICBFcnJvciAqZXJyID0gTlVMTDsKKworICAgIHB2aF9zdGFydF9hZGRyID0gMDsK KworICAgIGlmIChmaWxlbmFtZSA9PSBOVUxMKSB7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAg ICB9CisKKyAgICBmaWxlID0gZm9wZW4oZmlsZW5hbWUsICJyYiIpOworICAgIGlmIChmaWxlID09 IE5VTEwpIHsKKyAgICAgICAgZXJyb3JfcmVwb3J0KCJmb3BlbiglcykgZmFpbGVkIiwgZmlsZW5h bWUpOworICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgfQorCisgICAgaWYgKGZzdGF0KGZpbGVu byhmaWxlKSwgJnN0YXRidWYpIDwgMCkgeworICAgICAgICBlcnJvcl9yZXBvcnQoImZzdGF0KCkg ZmFpbGVkIG9uIGZpbGUgKCVzKSIsIGZpbGVuYW1lKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwor ICAgIH0KKworICAgIGxvYWRfZWxmX2hkcihmaWxlbmFtZSwgJmVsZl9oZWFkZXIsICZlbGZfaXM2 NCwgJmVycik7CisgICAgaWYgKGVycikgeworICAgICAgICBlcnJvcl9mcmVlKGVycik7CisgICAg ICAgIGZjbG9zZShmaWxlKTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgICpl bGZjbGFzcyA9IGVsZl9pczY0ID8KKyAgICAgICAgZWxmX2hlYWRlci5oNjQuZV9pZGVudFtFSV9D TEFTU10gOiBlbGZfaGVhZGVyLmgzMi5lX2lkZW50W0VJX0NMQVNTXTsKKyAgICBpZiAoKmVsZmNs YXNzID09IEVMRkNMQVNTTk9ORSkgeworICAgICAgICBlcnJvcl9yZXBvcnQoImtlcm5lbCBiaW5h cnkgKCVzKSBpcyBFTEZDTEFTU05PTkUiLCBmaWxlbmFtZSk7CisgICAgICAgIGZjbG9zZShmaWxl KTsKKyAgICAgICAgcmV0dXJuIGZhbHNlOworICAgIH0KKworICAgIGVoZHJfc2l6ZSA9IGVsZl9p czY0ID8gc2l6ZW9mKEVsZjY0X0VoZHIpIDogc2l6ZW9mKEVsZjMyX0VoZHIpOworICAgIHBoZHJf c2l6ZSA9IGVsZl9pczY0ID8gc2l6ZW9mKEVsZjY0X1BoZHIpIDogc2l6ZW9mKEVsZjMyX1BoZHIp OworICAgIG5oZHJfc2l6ZSA9IGVsZl9pczY0ID8gc2l6ZW9mKEVsZjY0X05oZHIpIDogc2l6ZW9m KEVsZjMyX05oZHIpOworCisgICAgLyogV2UgaGF2ZSBhbHJlYWR5IHZhbGlkYXRlZCB0aGUgRUxG IGhlYWRlciB3aGVuIGNhbGxpbmcgZWxmX2xvYWRfaGRyKCkgKi8KKworICAgIGVoZHIgPSBtbWFw KDAsIHN0YXRidWYuc3Rfc2l6ZSwKKyAgICAgICAgUFJPVF9SRUFEIHwgUFJPVF9XUklURSwgTUFQ X1BSSVZBVEUsIGZpbGVubyhmaWxlKSwgMCk7CisgICAgaWYgKGVoZHIgPT0gTUFQX0ZBSUxFRCkg eworICAgICAgICBlcnJvcl9yZXBvcnQoIkZhaWxlZCB0byBtbWFwIGtlcm5lbCBiaW5hcnkgKCVz KSIsIGZpbGVuYW1lKTsKKyAgICAgICAgZ290byBkb25lOworICAgIH0KKworICAgIC8qCisgICAg ICogU2VhcmNoIHRocm91Z2ggdGhlIHByb2dyYW0gZXhlY3V0aW9uIGhlYWRlciBmb3IgdGhlCisg ICAgICogRUxGIE5vdGUgc2VjdGlvbi4KKyAgICAgKi8KKworICAgIGVoZHJfcG9mZiA9IGVsZl9p czY0ID8KKyAgICAgICAgKChFbGY2NF9FaGRyICopKGVoZHIpKS0+ZV9waG9mZiA6ICgoRWxmMzJf RWhkciAqKShlaGRyKSktPmVfcGhvZmY7CisgICAgaWYgKHN0YXRidWYuc3Rfc2l6ZSA8IChlaGRy X3NpemUgKyBlaGRyX3BvZmYpKSB7CisgICAgICAgIGVycm9yX3JlcG9ydCgiRUxGIE5PVEUgc2Vj dGlvbiBleGNlZWRzIGZpbGUgKCVzKSBzaXplIiwKKyAgICAgICAgICAgIGZpbGVuYW1lKTsKKyAg ICAgICAgZ290byBkb25lOworICAgIH0KKworICAgIHBoZHIgPSBlaGRyICsgZWhkcl9wb2ZmOwor ICAgIHBoZHJfdHlwZSA9IGVsZl9pczY0ID8KKyAgICAgICAgKChFbGY2NF9QaGRyICopcGhkcikt PnBfdHlwZSA6ICgoRWxmMzJfUGhkciAqKXBoZHIpLT5wX3R5cGU7CisgICAgd2hpbGUgKHBoZHIg IT0gTlVMTCAmJiBwaGRyX3R5cGUgIT0gUFRfTk9URSkgeworICAgICAgICBpZiAoc3RhdGJ1Zi5z dF9zaXplIDwgKChwaGRyIC0gZWhkcikgKyBwaGRyX3NpemUpKSB7CisgICAgICAgICAgICBlcnJv cl9yZXBvcnQoIkVMRiBQcm9ncmFtIGhlYWRlcnMgaW4gZmlsZSAoJXMpIHRvbyBzaG9ydCIsCisg ICAgICAgICAgICAgICAgZmlsZW5hbWUpOworICAgICAgICAgICAgZ290byBkb25lOworICAgICAg ICB9CisgICAgICAgIHBoZHIgKz0gcGhkcl9zaXplOworICAgICAgICBwaGRyX3R5cGUgPSBlbGZf aXM2NCA/CisgICAgICAgICAgICAoKEVsZjY0X1BoZHIgKilwaGRyKS0+cF90eXBlIDogKChFbGYz Ml9QaGRyICopcGhkciktPnBfdHlwZTsKKyAgICB9CisKKyAgICBwaGRyX29mZiA9IGVsZl9pczY0 ID8KKyAgICAgICAgKChFbGY2NF9QaGRyICopcGhkciktPnBfb2Zmc2V0IDogKChFbGYzMl9QaGRy ICopcGhkciktPnBfb2Zmc2V0OworICAgIHBoZHJfYWxpZ24gPSBlbGZfaXM2NCA/CisgICAgICAg ICgoRWxmNjRfUGhkciAqKXBoZHIpLT5wX2FsaWduIDogKChFbGYzMl9QaGRyICopcGhkciktPnBf YWxpZ247CisgICAgcGhkcl9tZW1zeiA9IGVsZl9pczY0ID8KKyAgICAgICAgKChFbGY2NF9QaGRy ICopcGhkciktPnBfbWVtc3ogOiAoKEVsZjMyX1BoZHIgKilwaGRyKS0+cF9tZW1zejsKKworICAg IC8qCisgICAgICogY2hlY2sgdGhhdCB0aGUgc3RhcnQgb2YgdGhlIEVMRiBOb3RlIHNlY3Rpb24g aXMgd2l0aGluIHRoZSBib3VuZHMKKyAgICAgKiBvZiB0aGUga2VybmVsIEVMRiBiaW5hcnkKKyAg ICAgKi8KKyAgICBpZiAoc3RhdGJ1Zi5zdF9zaXplIDwgKGVoZHJfcG9mZiArIHBoZHJfc2l6ZSAr IHBoZHJfb2ZmKSkgeworICAgICAgICBlcnJvcl9yZXBvcnQoIlN0YXJ0IG9mIEVMRiBub3RlIHNl Y3Rpb24gb3V0c2lkZSBvZiBmaWxlICglcykgYm91bmRzIiwKKyAgICAgICAgICAgIGZpbGVuYW1l KTsKKyAgICAgICAgZ290byBkb25lOworICAgIH0KKyAgICAvKgorICAgICAqIGNoZWNrIHRoYXQg dGhlIGVuZCBvZiB0aGUgRUxGIE5vdGUgc2VjdGlvbiBpcyB3aXRoaW4gdGhlIGJvdW5kcworICAg ICAqIG9mIHRoZSBrZXJuZWwgRUxGIGJpbmFyeQorICAgICAqLworICAgIGlmIChzdGF0YnVmLnN0 X3NpemUgPCAocGhkcl9vZmYgKyBwaGRyX21lbXN6KSkgeworICAgICAgICBlcnJvcl9yZXBvcnQo IkVuZCBvZiBFTEYgbm90ZSBzZWN0aW9uIG91dHNpZGUgb2YgZmlsZSAoJXMpIGJvdW5kcyIsCisg ICAgICAgICAgICBmaWxlbmFtZSk7CisgICAgICAgIGdvdG8gZG9uZTsKKyAgICB9CisKKyAgICAv KgorICAgICAqIFNlYXJjaCB0aHJvdWdoIHRoZSBFTEYgTm90ZXMgZm9yIGFuIGVudHJ5IHdpdGgg dGhlCisgICAgICogUGh5c2ljYWwgQWRkcmVzcyAoUEEpIG9mIHRoZSBQVkggZW50cnkgcG9pbnQu CisgICAgICovCisgICAgbmhkciA9IGdldF9lbGZfbm90ZV90eXBlKGVoZHIsIHBoZHIsIGVsZl9p czY0LCBYRU5fRUxGTk9URV9QSFlTMzJfRU5UUlkpOworICAgIGlmIChuaGRyID09IE5VTEwpIHsK KyAgICAgICAgZXJyb3JfcmVwb3J0KCJObyBQVkggRW50cnkgZGV0YWlscyBpbiBrZXJuZWwgKCVz KSBFTEYgTm90ZSBzZWN0aW9uIiwKKyAgICAgICAgICAgIGZpbGVuYW1lKTsKKyAgICAgICAgZ290 byBkb25lOworICAgIH0KKworICAgIC8qCisgICAgICogVmVyaWZ5IHRoYXQgdGhlIHJldHVybmVk IEVMRiBOb3RlIGhlYWRlciBkb2Vzbid0IGV4Y2VlZCB0aGUKKyAgICAgKiBlbmQgb2YgdGhlIGtl cm5lbCBmaWxlCisgICAgICovCisgICAgaWYgKHN0YXRidWYuc3Rfc2l6ZSA8ICgobmhkciAtIGVo ZHIpKSkgeworICAgICAgICBlcnJvcl9yZXBvcnQoIkVMRiBOaGRyIG9mZnNldCAoMHglbHgpIGV4 Y2VlZHMgZmlsZSAoJXMpIGJvdW5kcyAoJWxkKSIsCisgICAgICAgICAgICAobmhkciAtIGVoZHIp LCBmaWxlbmFtZSwgc3RhdGJ1Zi5zdF9zaXplKTsKKyAgICAgICAgZ290byBkb25lOworICAgIH0K KworICAgIG5oZHJfbmFtZXN6ID0gZWxmX2lzNjQgPworICAgICAgICAoKEVsZjY0X05oZHIgKilu aGRyKS0+bl9uYW1lc3ogOiAoKEVsZjMyX05oZHIgKiluaGRyKS0+bl9uYW1lc3o7CisgICAgbmhk cl9kZXNjc3ogPSBlbGZfaXM2NCA/CisgICAgICAgICgoRWxmNjRfTmhkciAqKW5oZHIpLT5uX2Rl c2NzeiA6ICgoRWxmMzJfTmhkciAqKW5oZHIpLT5uX2Rlc2NzejsKKworICAgIC8qCisgICAgICog VmVyaWZ5IHRoYXQgdGhlIEVMRiBOb3RlIGNvbnRlbnRzIGRvbid0IGV4Y2VlZCB0aGUgZW5kIG9m IHRoZQorICAgICAqIGtlcm5lbCBmaWxlCisgICAgICovCisgICAgaWYgKHN0YXRidWYuc3Rfc2l6 ZSA8ICgobmhkciAtIGVoZHIpKSArIG5oZHJfc2l6ZSArCisgICAgICAgIFFFTVVfQUxJR05fVVAo bmhkcl9uYW1lc3osIHBoZHJfYWxpZ24pICsKKyAgICAgICAgUUVNVV9BTElHTl9VUChuaGRyX2Rl c2NzeiwgcGhkcl9hbGlnbikpIHsKKyAgICAgICAgZXJyb3JfcmVwb3J0KCJFTEYgTmhkciBjb250 ZW50cyAoMHglbHgpIGV4Y2VlZHMgZmlsZSBib3VuZHMgKCVsZCkiLAorICAgICAgICAgICAgKG5o ZHIgLSBlaGRyKSArIG5oZHJfc2l6ZSArIFFFTVVfQUxJR05fVVAobmhkcl9uYW1lc3osIHBoZHJf YWxpZ24pICsKKyAgICAgICAgICAgIFFFTVVfQUxJR05fVVAobmhkcl9kZXNjc3osIHBoZHJfYWxp Z24pLCBzdGF0YnVmLnN0X3NpemUpOworICAgICAgICBnb3RvIGRvbmU7CisgICAgfQorCisgICAg ZWxmX25vdGVfZGF0YV9hZGRyID0KKyAgICAgICAgKHNpemVfdCluaGRyICsgbmhkcl9zaXplICsg UUVNVV9BTElHTl9VUChuaGRyX25hbWVzeiwgcGhkcl9hbGlnbik7CisKKyAgICBwdmhfc3RhcnRf YWRkciA9ICooc2l6ZV90ICopZWxmX25vdGVfZGF0YV9hZGRyOworCisgICAgLyoKKyAgICAgKiBW ZXJpZnkgdGhhdCB0aGUgUFZIIEVudHJ5IHBvaW50IGFkZHJlc3MgZG9lcyBub3QgZXhjZWVkIHRo ZQorICAgICAqIGJvdW5kcyBvZiB0aGUga2VybmVsIGZpbGUuCisgICAgICovCisgICAgaWYgKHN0 YXRidWYuc3Rfc2l6ZSA8IHB2aF9zdGFydF9hZGRyKSB7CisgICAgICAgIGVycm9yX3JlcG9ydCgi UFZIIEVMRiBub3RlIGFkZHIgKDB4JWx4KSBleGNlZWRzIGZpbGUgKCVzKSBib3VuZHMgKCVsZCki LAorICAgICAgICAgICAgKGVsZl9ub3RlX2RhdGFfYWRkciAtIChzaXplX3QpZWhkciksIGZpbGVu YW1lLCBzdGF0YnVmLnN0X3NpemUpOworICAgICAgICBwdmhfc3RhcnRfYWRkciA9IDA7CisgICAg ICAgIGdvdG8gZG9uZTsKKyAgICB9CisKK2RvbmU6CisgICAgKHZvaWQpIG11bm1hcChlaGRyLCBz dGF0YnVmLnN0X3NpemUpOworICAgIHJldHVybiBwdmhfc3RhcnRfYWRkciAhPSAwOworfQorCiBz dGF0aWMgdm9pZCBsb2FkX2xpbnV4KFBDTWFjaGluZVN0YXRlICpwY21zLAogICAgICAgICAgICAg ICAgICAgICAgICBGV0NmZ1N0YXRlICpmd19jZmcpCiB7CkBAIC0xMzM0LDkgKzE1OTgsMTEgQEAg dm9pZCBwY19tZW1vcnlfaW5pdChQQ01hY2hpbmVTdGF0ZSAqcGNtcywKICAgICBpbnQgbGludXhf Ym9vdCwgaTsKICAgICBNZW1vcnlSZWdpb24gKnJhbSwgKm9wdGlvbl9yb21fbXI7CiAgICAgTWVt b3J5UmVnaW9uICpyYW1fYmVsb3dfNGcsICpyYW1fYWJvdmVfNGc7Ci0gICAgRldDZmdTdGF0ZSAq ZndfY2ZnOworICAgIEZXQ2ZnU3RhdGUgKmZ3X2NmZyA9IE5VTEw7CisgICAgdW5zaWduZWQgY2hh ciBjbGFzcyA9IEVMRkNMQVNTTk9ORTsKICAgICBNYWNoaW5lU3RhdGUgKm1hY2hpbmUgPSBNQUNI SU5FKHBjbXMpOwogICAgIFBDTWFjaGluZUNsYXNzICpwY21jID0gUENfTUFDSElORV9HRVRfQ0xB U1MocGNtcyk7CisgICAgY29uc3QgY2hhciAqa2VybmVsX2ZpbGVuYW1lID0gbWFjaGluZS0+a2Vy bmVsX2ZpbGVuYW1lOwogCiAgICAgYXNzZXJ0KG1hY2hpbmUtPnJhbV9zaXplID09IHBjbXMtPmJl bG93XzRnX21lbV9zaXplICsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGNtcy0+ YWJvdmVfNGdfbWVtX3NpemUpOwpAQCAtMTQxOCw2ICsxNjg0LDEwIEBAIHZvaWQgcGNfbWVtb3J5 X2luaXQoUENNYWNoaW5lU3RhdGUgKnBjbXMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAmbWFjaGluZS0+ZGV2aWNlX21lbW9yeS0+bXIpOwogICAgIH0KIAorICAgIGlmIChs aW51eF9ib290KSB7CisgICAgICAgIHJlYWRfcHZoX3N0YXJ0X2FkZHJfZWxmX25vdGUoa2VybmVs X2ZpbGVuYW1lLCAmY2xhc3MpOworICAgIH0KKwogICAgIC8qIEluaXRpYWxpemUgUEMgc3lzdGVt IGZpcm13YXJlICovCiAgICAgcGNfc3lzdGVtX2Zpcm13YXJlX2luaXQocm9tX21lbW9yeSwgIXBj bWMtPnBjaV9lbmFibGVkKTsKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9lbGYuaCBiL2luY2x1ZGUv ZWxmLmgKaW5kZXggYzE1MTE2NGI2M2RhLi4xZjgyYzdhNzEyNGIgMTAwNjQ0Ci0tLSBhL2luY2x1 ZGUvZWxmLmgKKysrIGIvaW5jbHVkZS9lbGYuaApAQCAtMTU4NSw2ICsxNTg1LDE2IEBAIHR5cGVk ZWYgc3RydWN0IGVsZjY0X3NoZHIgewogI2RlZmluZSBOVF9BUk1fSFdfV0FUQ0ggMHg0MDMgICAg ICAgICAgIC8qIEFSTSBoYXJkd2FyZSB3YXRjaHBvaW50IHJlZ2lzdGVycyAqLwogI2RlZmluZSBO VF9BUk1fU1lTVEVNX0NBTEwgICAgICAweDQwNCAgIC8qIEFSTSBzeXN0ZW0gY2FsbCBudW1iZXIg Ki8KIAorLyoKKyAqIFBoeXNpY2FsIGVudHJ5IHBvaW50IGludG8gdGhlIGtlcm5lbC4KKyAqCisg KiAzMmJpdCBlbnRyeSBwb2ludCBpbnRvIHRoZSBrZXJuZWwuIFdoZW4gcmVxdWVzdGVkIHRvIGxh dW5jaCB0aGUKKyAqIGd1ZXN0IGtlcm5lbCwgdXNlIHRoaXMgZW50cnkgcG9pbnQgdG8gbGF1bmNo IHRoZSBndWVzdCBpbiAzMi1iaXQKKyAqIHByb3RlY3RlZCBtb2RlIHdpdGggcGFnaW5nIGRpc2Fi bGVkLgorICoKKyAqIFsgQ29ycmVzcG9uZGluZyBkZWZpbml0aW9uIGluIExpbnV4IGtlcm5lbDog aW5jbHVkZS94ZW4vaW50ZXJmYWNlL2VsZm5vdGUuaCBdCisgKi8KKyNkZWZpbmUgWEVOX0VMRk5P VEVfUEhZUzMyX0VOVFJZICAgIDE4ICAvKiAweDEyICovCiAKIC8qIE5vdGUgaGVhZGVyIGluIGEg UFRfTk9URSBzZWN0aW9uICovCiB0eXBlZGVmIHN0cnVjdCBlbGYzMl9ub3RlIHsKLS0gCjEuOC4z LjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4t ZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczov L2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs