From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from list by lists.gnu.org with archive (Exim 4.71) id 1abny2-0000sJ-Pi for mharc-grub-devel@gnu.org; Fri, 04 Mar 2016 06:32:22 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:56742) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1abjaj-0001Ij-0t for grub-devel@gnu.org; Fri, 04 Mar 2016 01:52:03 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1abjae-0004pz-Qx for grub-devel@gnu.org; Fri, 04 Mar 2016 01:52:00 -0500 Received: from mx2.suse.de ([195.135.220.15]:60372) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1abjae-0004pv-Fb for grub-devel@gnu.org; Fri, 04 Mar 2016 01:51:56 -0500 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay1.suse.de (charybdis-ext.suse.de [195.135.220.254]) by mx2.suse.de (Postfix) with ESMTP id 4AF51ABB0; Fri, 4 Mar 2016 06:51:54 +0000 (UTC) Subject: Re: [GRUB2 PATCH v3 4/4] multiboot2: Add support for relocatable images To: Daniel Kiper , xen-devel@lists.xenproject.org, grub-devel@gnu.org References: <1456937500-7855-1-git-send-email-daniel.kiper@oracle.com> <1456937500-7855-5-git-send-email-daniel.kiper@oracle.com> From: Juergen Gross Message-ID: <56D93088.6090806@suse.com> Date: Fri, 4 Mar 2016 07:51:52 +0100 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.6.0 MIME-Version: 1.0 In-Reply-To: <1456937500-7855-5-git-send-email-daniel.kiper@oracle.com> Content-Type: text/plain; charset=windows-1252 Content-Transfer-Encoding: 7bit X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x (no timestamps) [generic] X-Received-From: 195.135.220.15 X-Mailman-Approved-At: Fri, 04 Mar 2016 06:32:21 -0500 Cc: eric.snowberg@oracle.com, arvidjaar@gmail.com, andrew.cooper3@citrix.com, stefano.stabellini@eu.citrix.com, cardoe@cardoe.com, pgnet.dev@gmail.com, roy.franz@linaro.org, ning.sun@intel.com, david.vrabel@citrix.com, jbeulich@suse.com, phcoder@gmail.com, qiaowei.ren@intel.com, richard.l.maliszewski@intel.com, gang.wei@intel.com, fu.wei@linaro.org, seth.goldberg@oracle.com X-BeenThere: grub-devel@gnu.org X-Mailman-Version: 2.1.14 Precedence: list Reply-To: The development of GNU GRUB List-Id: The development of GNU GRUB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 04 Mar 2016 06:52:03 -0000 On 02/03/16 17:51, Daniel Kiper wrote: > Currently multiboot2 protocol loads image exactly at address specified in > ELF or multiboot2 header. This solution works quite well on legacy BIOS > platforms. It is possible because memory regions are placed at predictable > addresses (though I was not able to find any spec which says that it is > strong requirement, so, it looks that it is just a goodwill of hardware > designers). However, EFI platforms are more volatile. Even if required > memory regions live at specific addresses then they are sometimes simply > not free (e.g. used by boot/runtime services on Dell PowerEdge R820 and > OVMF). This means that you are not able to simply set up final image > destination on build time. You have to provide method to relocate image > contents to real load address which is usually different than load address > specified in ELF and multiboot2 headers. > > This patch provides all needed machinery to do self relocation in image code. > First of all GRUB2 reads min_addr (min. load addr), max_addr (max. load addr), > align (required image alignment), preference (it says which memory regions are > preferred by image, e.g. none, low, high) from multiboot_header_tag_relocatable > header tag contained in binary. Later loader tries to fulfill request (not only > that one) and if it succeeds then it informs image about real load address via > multiboot_tag_base_addr tag. At this stage GRUB2 role is finished. Starting > from now executable must cope with relocations itself using whole static > and dynamic knowledge provided by boot loader. > > This patch does not provide functionality which could do relocations using > ELF relocation data. However, I was asked by Konrad Rzeszutek Wilk and Vladimir > 'phcoder' Serbinenko to investigate that thing. It looks that relevant machinery > could be added to existing code (including this patch) without huge effort. > Additionally, ELF relocation could live in parallel with self relocation provided > by this patch. However, during research I realized that first of all we should > establish the details how ELF relocatable image should look like and how it should > be build. At least to build proper test/example files. > > As I saw multiboot2 protocol is able to consume ET_EXEC and ET_DYN ELF files. > Potentially we can use ET_DYN file type. It can be build with gcc/ld -pie option. > However, it contains a lot of unneeded stuff (e.g. INTERP, DYNAMIC, GNU_EH_FRAME > program headers) and it could be quite difficult to drop them (Hmmm... Is it > possible to build it properly with custom ld script?). So, I have checked ET_EXEC > file type. Sadly in this case linker by default resolves all local symbol relocations > and removes relocation related sections. Fortunately it is possible to leave them > as is with simple -q/--emit-relocs ld option. However, output file is quite fragile > and any operation on it should be done with great care (e.g. strip should be called > with --strip-unneeded option). So, this solution is not perfect too. It means that > maybe we should look for better solution. However, I think that we should not use > any custom tools and focus on functionalities provided by compiler and binutils. > In this context ld scripts looks quite promising but maybe you have better solutions. > So, what do you think about that? > > This patch was tested with Xen image which uses that functionality. However, this Xen > feature is still under development and new patchset will be released in about 3-4 weeks. > > Signed-off-by: Daniel Kiper > --- > v3 - suggestions/fixes: > - reduce number of casts > (suggested by Konrad Rzeszutek Wilk), > - remove unneeded space at the end of line > (suggested by Konrad Rzeszutek Wilk), > - improve commit message > (suggested by Konrad Rzeszutek Wilk). > --- > grub-core/loader/i386/multiboot_mbi.c | 6 ++- > grub-core/loader/multiboot.c | 12 ++++-- > grub-core/loader/multiboot_elfxx.c | 28 ++++++++++---- > grub-core/loader/multiboot_mbi2.c | 65 ++++++++++++++++++++++++++++++--- > include/grub/multiboot.h | 4 +- > include/multiboot2.h | 24 ++++++++++++ > 6 files changed, 120 insertions(+), 19 deletions(-) > > diff --git a/grub-core/loader/i386/multiboot_mbi.c b/grub-core/loader/i386/multiboot_mbi.c > index f60b702..4fc83ed 100644 > --- a/grub-core/loader/i386/multiboot_mbi.c > +++ b/grub-core/loader/i386/multiboot_mbi.c > @@ -72,7 +72,8 @@ load_kernel (grub_file_t file, const char *filename, > grub_err_t err; > if (grub_multiboot_quirks & GRUB_MULTIBOOT_QUIRK_BAD_KLUDGE) > { > - err = grub_multiboot_load_elf (file, filename, buffer); > + err = grub_multiboot_load_elf (file, filename, buffer, 0, 0, 0, 0, > + GRUB_RELOCATOR_PREFERENCE_NONE, NULL, 0); Uuh, really? You are adding 7 parameters for the relocatable case. Wouldn't it make more sense to have some kind of structure containing the data you need for relocatable images and pass the pointer to that structure or NULL in the case of non-relocatable images (or have a default structure for the non-relocatable case)? Juergen > if (err == GRUB_ERR_NONE) { > return GRUB_ERR_NONE; > } > @@ -121,7 +122,8 @@ load_kernel (grub_file_t file, const char *filename, > return GRUB_ERR_NONE; > } > > - return grub_multiboot_load_elf (file, filename, buffer); > + return grub_multiboot_load_elf (file, filename, buffer, 0, 0, 0, 0, > + GRUB_RELOCATOR_PREFERENCE_NONE, NULL, 0); > } > > static struct multiboot_header * > diff --git a/grub-core/loader/multiboot.c b/grub-core/loader/multiboot.c > index 18038fd..c0f51b6 100644 > --- a/grub-core/loader/multiboot.c > +++ b/grub-core/loader/multiboot.c > @@ -208,12 +208,18 @@ static grub_uint64_t highest_load; > /* Load ELF32 or ELF64. */ > grub_err_t > grub_multiboot_load_elf (grub_file_t file, const char *filename, > - void *buffer) > + void *buffer, int relocatable, grub_uint32_t min_addr, > + grub_uint32_t max_addr, grub_size_t align, grub_uint32_t preference, > + grub_uint32_t *base_addr, int avoid_efi_boot_services) > { > if (grub_multiboot_is_elf32 (buffer)) > - return grub_multiboot_load_elf32 (file, filename, buffer); > + return grub_multiboot_load_elf32 (file, filename, buffer, relocatable, > + min_addr, max_addr, align, preference, > + base_addr, avoid_efi_boot_services); > else if (grub_multiboot_is_elf64 (buffer)) > - return grub_multiboot_load_elf64 (file, filename, buffer); > + return grub_multiboot_load_elf64 (file, filename, buffer, relocatable, > + min_addr, max_addr, align, preference, > + base_addr, avoid_efi_boot_services); > > return grub_error (GRUB_ERR_UNKNOWN_OS, N_("invalid arch-dependent ELF magic")); > } > diff --git a/grub-core/loader/multiboot_elfxx.c b/grub-core/loader/multiboot_elfxx.c > index e3a39b6..0c01569 100644 > --- a/grub-core/loader/multiboot_elfxx.c > +++ b/grub-core/loader/multiboot_elfxx.c > @@ -51,7 +51,10 @@ CONCAT(grub_multiboot_is_elf, XX) (void *buffer) > } > > static grub_err_t > -CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, void *buffer) > +CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, > + void *buffer, int relocatable, grub_uint32_t min_addr, > + grub_uint32_t max_addr, grub_size_t align, grub_uint32_t preference, > + grub_uint32_t *base_addr, int avoid_efi_boot_services) > { > Elf_Ehdr *ehdr = (Elf_Ehdr *) buffer; > char *phdr_base; > @@ -89,19 +92,30 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, voi > if (phdr(i)->p_paddr + phdr(i)->p_memsz > highest_load) > highest_load = phdr(i)->p_paddr + phdr(i)->p_memsz; > > - grub_dprintf ("multiboot_loader", "segment %d: paddr=0x%lx, memsz=0x%lx, vaddr=0x%lx\n", > - i, (long) phdr(i)->p_paddr, (long) phdr(i)->p_memsz, (long) phdr(i)->p_vaddr); > + grub_dprintf ("multiboot_loader", "segment %d: paddr=0x%lx, memsz=0x%lx, vaddr=0x%lx," > + "align=0x%lx, relocatable=%d, avoid_efi_boot_services=%d\n", i, > + (long) phdr(i)->p_paddr, (long) phdr(i)->p_memsz, (long) phdr(i)->p_vaddr, > + (long) align, relocatable, avoid_efi_boot_services); > > { > grub_relocator_chunk_t ch; > - err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, > - &ch, phdr(i)->p_paddr, > - phdr(i)->p_memsz); > + > + if (relocatable) > + err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch, > + min_addr, max_addr - phdr(i)->p_memsz, > + phdr(i)->p_memsz, align ? align : 1, > + preference, avoid_efi_boot_services); > + else > + err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, > + &ch, phdr(i)->p_paddr, > + phdr(i)->p_memsz); > if (err) > { > grub_dprintf ("multiboot_loader", "Error loading phdr %d\n", i); > return err; > } > + if (base_addr) > + *base_addr = get_physical_target_address (ch); > source = get_virtual_current_address (ch); > } > > @@ -208,7 +222,7 @@ CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, voi > + 1, sh->sh_size, > sh->sh_addralign, > GRUB_RELOCATOR_PREFERENCE_NONE, > - 0); > + avoid_efi_boot_services); > if (err) > { > grub_dprintf ("multiboot_loader", "Error loading shdr %d\n", i); > diff --git a/grub-core/loader/multiboot_mbi2.c b/grub-core/loader/multiboot_mbi2.c > index ce68f48..03725a1 100644 > --- a/grub-core/loader/multiboot_mbi2.c > +++ b/grub-core/loader/multiboot_mbi2.c > @@ -68,6 +68,7 @@ static grub_size_t elf_sec_num, elf_sec_entsize; > static unsigned elf_sec_shstrndx; > static void *elf_sections; > static int keep_bs = 0; > +static grub_uint32_t base_addr = 0; > > void > grub_multiboot_add_elfsyms (grub_size_t num, grub_size_t entsize, > @@ -107,11 +108,14 @@ grub_multiboot_load (grub_file_t file, const char *filename) > grub_err_t err; > struct multiboot_header_tag *tag; > struct multiboot_header_tag_address *addr_tag = NULL; > - int entry_specified = 0, efi_entry_specified = 0; > + struct multiboot_header_tag_relocatable *rel_tag; > + int entry_specified = 0, efi_entry_specified = 0, relocatable = 0; > grub_addr_t entry = 0, efi_entry = 0; > - grub_uint32_t console_required = 0; > + grub_uint32_t console_required = 0, min_addr = 0; > + grub_uint32_t max_addr = 0, preference = GRUB_RELOCATOR_PREFERENCE_NONE; > struct multiboot_header_tag_framebuffer *fbtag = NULL; > int accepted_consoles = GRUB_MULTIBOOT_CONSOLE_EGA_TEXT; > + grub_size_t align = 0; > > buffer = grub_malloc (MULTIBOOT_SEARCH); > if (!buffer) > @@ -174,6 +178,7 @@ grub_multiboot_load (grub_file_t file, const char *filename) > case MULTIBOOT_TAG_TYPE_EFI_BS: > case MULTIBOOT_TAG_TYPE_EFI32_IH: > case MULTIBOOT_TAG_TYPE_EFI64_IH: > + case MULTIBOOT_TAG_TYPE_BASE_ADDR: > break; > > default: > @@ -215,6 +220,27 @@ grub_multiboot_load (grub_file_t file, const char *filename) > accepted_consoles |= GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER; > break; > > + case MULTIBOOT_HEADER_TAG_RELOCATABLE: > + relocatable = 1; > + rel_tag = (struct multiboot_header_tag_relocatable *) tag; > + min_addr = rel_tag->min_addr; > + max_addr = rel_tag->max_addr; > + align = rel_tag->align; > + switch (rel_tag->preference) > + { > + case MULTIBOOT_LOAD_PREFERENCE_LOW: > + preference = GRUB_RELOCATOR_PREFERENCE_LOW; > + break; > + > + case MULTIBOOT_LOAD_PREFERENCE_HIGH: > + preference = GRUB_RELOCATOR_PREFERENCE_HIGH; > + break; > + > + default: > + preference = GRUB_RELOCATOR_PREFERENCE_NONE; > + } > + break; > + > /* GRUB always page-aligns modules. */ > case MULTIBOOT_HEADER_TAG_MODULE_ALIGN: > break; > @@ -260,15 +286,22 @@ grub_multiboot_load (grub_file_t file, const char *filename) > else > code_size = load_size; > > - err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, > - &ch, load_addr, > - code_size); > + if (relocatable) > + err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch, > + min_addr, max_addr - code_size, > + code_size, align ? align : 1, > + preference, keep_bs); > + else > + err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, > + &ch, load_addr, > + code_size); > if (err) > { > grub_dprintf ("multiboot_loader", "Error loading aout kludge\n"); > grub_free (buffer); > return err; > } > + base_addr = get_physical_target_address (ch); > source = get_virtual_current_address (ch); > > if ((grub_file_seek (file, offset)) == (grub_off_t) -1) > @@ -290,7 +323,9 @@ grub_multiboot_load (grub_file_t file, const char *filename) > } > else > { > - err = grub_multiboot_load_elf (file, filename, buffer); > + err = grub_multiboot_load_elf (file, filename, buffer, > + relocatable, min_addr, max_addr, > + align, preference, &base_addr, keep_bs); > if (err) > { > grub_free (buffer); > @@ -303,6 +338,14 @@ grub_multiboot_load (grub_file_t file, const char *filename) > else if (entry_specified) > grub_multiboot_payload_eip = entry; > > + if (relocatable) > + { > + if (base_addr > min_addr) > + grub_multiboot_payload_eip += base_addr - min_addr; > + else > + grub_multiboot_payload_eip -= min_addr - base_addr; > + } > + > if (fbtag) > err = grub_multiboot_set_console (GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER, > accepted_consoles, > @@ -409,6 +452,7 @@ grub_multiboot_get_mbi_size (void) > + grub_get_multiboot_mmap_count () > * sizeof (struct multiboot_mmap_entry)), MULTIBOOT_TAG_ALIGN) > + ALIGN_UP (sizeof (struct multiboot_tag_framebuffer), MULTIBOOT_TAG_ALIGN) > + + ALIGN_UP (sizeof (struct multiboot_tag_base_addr), MULTIBOOT_TAG_ALIGN) > #ifdef GRUB_MACHINE_EFI > #ifdef __i386__ > + ALIGN_UP (sizeof (struct multiboot_tag_efi32), MULTIBOOT_TAG_ALIGN) > @@ -698,6 +742,15 @@ grub_multiboot_make_mbi (grub_uint32_t *target) > ptrorig += (2 * sizeof (grub_uint32_t)) / sizeof (grub_properly_aligned_t); > > { > + struct multiboot_tag_base_addr *tag = (struct multiboot_tag_base_addr *) ptrorig; > + tag->type = MULTIBOOT_TAG_TYPE_BASE_ADDR; > + tag->size = sizeof (struct multiboot_tag_base_addr); > + tag->base_addr = base_addr; > + ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN) > + / sizeof (grub_properly_aligned_t); > + } > + > + { > struct multiboot_tag_string *tag = (struct multiboot_tag_string *) ptrorig; > tag->type = MULTIBOOT_TAG_TYPE_CMDLINE; > tag->size = sizeof (struct multiboot_tag_string) + cmdline_size; > diff --git a/include/grub/multiboot.h b/include/grub/multiboot.h > index e13c084..ec322b0 100644 > --- a/include/grub/multiboot.h > +++ b/include/grub/multiboot.h > @@ -94,7 +94,9 @@ grub_multiboot_load (grub_file_t file, const char *filename); > /* Load ELF32 or ELF64. */ > grub_err_t > grub_multiboot_load_elf (grub_file_t file, const char *filename, > - void *buffer); > + void *buffer, int relocatable, grub_uint32_t min_addr, > + grub_uint32_t max_addr, grub_size_t align, grub_uint32_t preference, > + grub_uint32_t *base_addr, int avoid_efi_boot_services); > extern grub_size_t grub_multiboot_pure_size; > extern grub_size_t grub_multiboot_alloc_mbi; > extern grub_uint32_t grub_multiboot_payload_eip; > diff --git a/include/multiboot2.h b/include/multiboot2.h > index 36a174f..c09bdbc 100644 > --- a/include/multiboot2.h > +++ b/include/multiboot2.h > @@ -62,6 +62,7 @@ > #define MULTIBOOT_TAG_TYPE_EFI_BS 18 > #define MULTIBOOT_TAG_TYPE_EFI32_IH 19 > #define MULTIBOOT_TAG_TYPE_EFI64_IH 20 > +#define MULTIBOOT_TAG_TYPE_BASE_ADDR 21 > > #define MULTIBOOT_HEADER_TAG_END 0 > #define MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST 1 > @@ -72,11 +73,16 @@ > #define MULTIBOOT_HEADER_TAG_MODULE_ALIGN 6 > #define MULTIBOOT_HEADER_TAG_EFI_BS 7 > #define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64 9 > +#define MULTIBOOT_HEADER_TAG_RELOCATABLE 10 > > #define MULTIBOOT_ARCHITECTURE_I386 0 > #define MULTIBOOT_ARCHITECTURE_MIPS32 4 > #define MULTIBOOT_HEADER_TAG_OPTIONAL 1 > > +#define MULTIBOOT_LOAD_PREFERENCE_NONE 0 > +#define MULTIBOOT_LOAD_PREFERENCE_LOW 1 > +#define MULTIBOOT_LOAD_PREFERENCE_HIGH 2 > + > #define MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED 1 > #define MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED 2 > > @@ -161,6 +167,17 @@ struct multiboot_header_tag_module_align > multiboot_uint32_t size; > }; > > +struct multiboot_header_tag_relocatable > +{ > + multiboot_uint16_t type; > + multiboot_uint16_t flags; > + multiboot_uint32_t size; > + multiboot_uint32_t min_addr; > + multiboot_uint32_t max_addr; > + multiboot_uint32_t align; > + multiboot_uint32_t preference; > +}; > + > struct multiboot_color > { > multiboot_uint8_t red; > @@ -387,6 +404,13 @@ struct multiboot_tag_efi64_ih > multiboot_uint64_t pointer; > }; > > +struct multiboot_tag_base_addr > +{ > + multiboot_uint32_t type; > + multiboot_uint32_t size; > + multiboot_uint32_t base_addr; > +}; > + > #endif /* ! ASM_FILE */ > > #endif /* ! MULTIBOOT_HEADER */ > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Juergen Gross Subject: Re: [GRUB2 PATCH v3 4/4] multiboot2: Add support for relocatable images Date: Fri, 4 Mar 2016 07:51:52 +0100 Message-ID: <56D93088.6090806@suse.com> References: <1456937500-7855-1-git-send-email-daniel.kiper@oracle.com> <1456937500-7855-5-git-send-email-daniel.kiper@oracle.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xen.org with esmtp (Exim 4.84) (envelope-from ) id 1abjaf-0005Ph-8L for xen-devel@lists.xenproject.org; Fri, 04 Mar 2016 06:51:57 +0000 In-Reply-To: <1456937500-7855-5-git-send-email-daniel.kiper@oracle.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Daniel Kiper , xen-devel@lists.xenproject.org, grub-devel@gnu.org Cc: eric.snowberg@oracle.com, arvidjaar@gmail.com, andrew.cooper3@citrix.com, stefano.stabellini@eu.citrix.com, cardoe@cardoe.com, pgnet.dev@gmail.com, roy.franz@linaro.org, ning.sun@intel.com, david.vrabel@citrix.com, jbeulich@suse.com, phcoder@gmail.com, qiaowei.ren@intel.com, richard.l.maliszewski@intel.com, gang.wei@intel.com, fu.wei@linaro.org, seth.goldberg@oracle.com List-Id: xen-devel@lists.xenproject.org T24gMDIvMDMvMTYgMTc6NTEsIERhbmllbCBLaXBlciB3cm90ZToKPiBDdXJyZW50bHkgbXVsdGli b290MiBwcm90b2NvbCBsb2FkcyBpbWFnZSBleGFjdGx5IGF0IGFkZHJlc3Mgc3BlY2lmaWVkIGlu Cj4gRUxGIG9yIG11bHRpYm9vdDIgaGVhZGVyLiBUaGlzIHNvbHV0aW9uIHdvcmtzIHF1aXRlIHdl bGwgb24gbGVnYWN5IEJJT1MKPiBwbGF0Zm9ybXMuIEl0IGlzIHBvc3NpYmxlIGJlY2F1c2UgbWVt b3J5IHJlZ2lvbnMgYXJlIHBsYWNlZCBhdCBwcmVkaWN0YWJsZQo+IGFkZHJlc3NlcyAodGhvdWdo IEkgd2FzIG5vdCBhYmxlIHRvIGZpbmQgYW55IHNwZWMgd2hpY2ggc2F5cyB0aGF0IGl0IGlzCj4g c3Ryb25nIHJlcXVpcmVtZW50LCBzbywgaXQgbG9va3MgdGhhdCBpdCBpcyBqdXN0IGEgZ29vZHdp bGwgb2YgaGFyZHdhcmUKPiBkZXNpZ25lcnMpLiBIb3dldmVyLCBFRkkgcGxhdGZvcm1zIGFyZSBt b3JlIHZvbGF0aWxlLiBFdmVuIGlmIHJlcXVpcmVkCj4gbWVtb3J5IHJlZ2lvbnMgbGl2ZSBhdCBz cGVjaWZpYyBhZGRyZXNzZXMgdGhlbiB0aGV5IGFyZSBzb21ldGltZXMgc2ltcGx5Cj4gbm90IGZy ZWUgKGUuZy4gdXNlZCBieSBib290L3J1bnRpbWUgc2VydmljZXMgb24gRGVsbCBQb3dlckVkZ2Ug UjgyMCBhbmQKPiBPVk1GKS4gVGhpcyBtZWFucyB0aGF0IHlvdSBhcmUgbm90IGFibGUgdG8gc2lt cGx5IHNldCB1cCBmaW5hbCBpbWFnZQo+IGRlc3RpbmF0aW9uIG9uIGJ1aWxkIHRpbWUuIFlvdSBo YXZlIHRvIHByb3ZpZGUgbWV0aG9kIHRvIHJlbG9jYXRlIGltYWdlCj4gY29udGVudHMgdG8gcmVh bCBsb2FkIGFkZHJlc3Mgd2hpY2ggaXMgdXN1YWxseSBkaWZmZXJlbnQgdGhhbiBsb2FkIGFkZHJl c3MKPiBzcGVjaWZpZWQgaW4gRUxGIGFuZCBtdWx0aWJvb3QyIGhlYWRlcnMuCj4gCj4gVGhpcyBw YXRjaCBwcm92aWRlcyBhbGwgbmVlZGVkIG1hY2hpbmVyeSB0byBkbyBzZWxmIHJlbG9jYXRpb24g aW4gaW1hZ2UgY29kZS4KPiBGaXJzdCBvZiBhbGwgR1JVQjIgcmVhZHMgbWluX2FkZHIgKG1pbi4g bG9hZCBhZGRyKSwgbWF4X2FkZHIgKG1heC4gbG9hZCBhZGRyKSwKPiBhbGlnbiAocmVxdWlyZWQg aW1hZ2UgYWxpZ25tZW50KSwgcHJlZmVyZW5jZSAoaXQgc2F5cyB3aGljaCBtZW1vcnkgcmVnaW9u cyBhcmUKPiBwcmVmZXJyZWQgYnkgaW1hZ2UsIGUuZy4gbm9uZSwgbG93LCBoaWdoKSBmcm9tIG11 bHRpYm9vdF9oZWFkZXJfdGFnX3JlbG9jYXRhYmxlCj4gaGVhZGVyIHRhZyBjb250YWluZWQgaW4g YmluYXJ5LiBMYXRlciBsb2FkZXIgdHJpZXMgdG8gZnVsZmlsbCByZXF1ZXN0IChub3Qgb25seQo+ IHRoYXQgb25lKSBhbmQgaWYgaXQgc3VjY2VlZHMgdGhlbiBpdCBpbmZvcm1zIGltYWdlIGFib3V0 IHJlYWwgbG9hZCBhZGRyZXNzIHZpYQo+IG11bHRpYm9vdF90YWdfYmFzZV9hZGRyIHRhZy4gQXQg dGhpcyBzdGFnZSBHUlVCMiByb2xlIGlzIGZpbmlzaGVkLiBTdGFydGluZwo+IGZyb20gbm93IGV4 ZWN1dGFibGUgbXVzdCBjb3BlIHdpdGggcmVsb2NhdGlvbnMgaXRzZWxmIHVzaW5nIHdob2xlIHN0 YXRpYwo+IGFuZCBkeW5hbWljIGtub3dsZWRnZSBwcm92aWRlZCBieSBib290IGxvYWRlci4KPiAK PiBUaGlzIHBhdGNoIGRvZXMgbm90IHByb3ZpZGUgZnVuY3Rpb25hbGl0eSB3aGljaCBjb3VsZCBk byByZWxvY2F0aW9ucyB1c2luZwo+IEVMRiByZWxvY2F0aW9uIGRhdGEuIEhvd2V2ZXIsIEkgd2Fz IGFza2VkIGJ5IEtvbnJhZCBSemVzenV0ZWsgV2lsayBhbmQgVmxhZGltaXIKPiAncGhjb2Rlcicg U2VyYmluZW5rbyB0byBpbnZlc3RpZ2F0ZSB0aGF0IHRoaW5nLiBJdCBsb29rcyB0aGF0IHJlbGV2 YW50IG1hY2hpbmVyeQo+IGNvdWxkIGJlIGFkZGVkIHRvIGV4aXN0aW5nIGNvZGUgKGluY2x1ZGlu ZyB0aGlzIHBhdGNoKSB3aXRob3V0IGh1Z2UgZWZmb3J0Lgo+IEFkZGl0aW9uYWxseSwgRUxGIHJl bG9jYXRpb24gY291bGQgbGl2ZSBpbiBwYXJhbGxlbCB3aXRoIHNlbGYgcmVsb2NhdGlvbiBwcm92 aWRlZAo+IGJ5IHRoaXMgcGF0Y2guIEhvd2V2ZXIsIGR1cmluZyByZXNlYXJjaCBJIHJlYWxpemVk IHRoYXQgZmlyc3Qgb2YgYWxsIHdlIHNob3VsZAo+IGVzdGFibGlzaCB0aGUgZGV0YWlscyBob3cg RUxGIHJlbG9jYXRhYmxlIGltYWdlIHNob3VsZCBsb29rIGxpa2UgYW5kIGhvdyBpdCBzaG91bGQK PiBiZSBidWlsZC4gQXQgbGVhc3QgdG8gYnVpbGQgcHJvcGVyIHRlc3QvZXhhbXBsZSBmaWxlcy4K PiAKPiBBcyBJIHNhdyBtdWx0aWJvb3QyIHByb3RvY29sIGlzIGFibGUgdG8gY29uc3VtZSBFVF9F WEVDIGFuZCBFVF9EWU4gRUxGIGZpbGVzLgo+IFBvdGVudGlhbGx5IHdlIGNhbiB1c2UgRVRfRFlO IGZpbGUgdHlwZS4gSXQgY2FuIGJlIGJ1aWxkIHdpdGggZ2NjL2xkIC1waWUgb3B0aW9uLgo+IEhv d2V2ZXIsIGl0IGNvbnRhaW5zIGEgbG90IG9mIHVubmVlZGVkIHN0dWZmIChlLmcuIElOVEVSUCwg RFlOQU1JQywgR05VX0VIX0ZSQU1FCj4gcHJvZ3JhbSBoZWFkZXJzKSBhbmQgaXQgY291bGQgYmUg cXVpdGUgZGlmZmljdWx0IHRvIGRyb3AgdGhlbSAoSG1tbS4uLiBJcyBpdAo+IHBvc3NpYmxlIHRv IGJ1aWxkIGl0IHByb3Blcmx5IHdpdGggY3VzdG9tIGxkIHNjcmlwdD8pLiBTbywgSSBoYXZlIGNo ZWNrZWQgRVRfRVhFQwo+IGZpbGUgdHlwZS4gU2FkbHkgaW4gdGhpcyBjYXNlIGxpbmtlciBieSBk ZWZhdWx0IHJlc29sdmVzIGFsbCBsb2NhbCBzeW1ib2wgcmVsb2NhdGlvbnMKPiBhbmQgcmVtb3Zl cyByZWxvY2F0aW9uIHJlbGF0ZWQgc2VjdGlvbnMuIEZvcnR1bmF0ZWx5IGl0IGlzIHBvc3NpYmxl IHRvIGxlYXZlIHRoZW0KPiBhcyBpcyB3aXRoIHNpbXBsZSAtcS8tLWVtaXQtcmVsb2NzIGxkIG9w dGlvbi4gSG93ZXZlciwgb3V0cHV0IGZpbGUgaXMgcXVpdGUgZnJhZ2lsZQo+IGFuZCBhbnkgb3Bl cmF0aW9uIG9uIGl0IHNob3VsZCBiZSBkb25lIHdpdGggZ3JlYXQgY2FyZSAoZS5nLiBzdHJpcCBz aG91bGQgYmUgY2FsbGVkCj4gd2l0aCAtLXN0cmlwLXVubmVlZGVkIG9wdGlvbikuIFNvLCB0aGlz IHNvbHV0aW9uIGlzIG5vdCBwZXJmZWN0IHRvby4gSXQgbWVhbnMgdGhhdAo+IG1heWJlIHdlIHNo b3VsZCBsb29rIGZvciBiZXR0ZXIgc29sdXRpb24uIEhvd2V2ZXIsIEkgdGhpbmsgdGhhdCB3ZSBz aG91bGQgbm90IHVzZQo+IGFueSBjdXN0b20gdG9vbHMgYW5kIGZvY3VzIG9uIGZ1bmN0aW9uYWxp dGllcyBwcm92aWRlZCBieSBjb21waWxlciBhbmQgYmludXRpbHMuCj4gSW4gdGhpcyBjb250ZXh0 IGxkIHNjcmlwdHMgbG9va3MgcXVpdGUgcHJvbWlzaW5nIGJ1dCBtYXliZSB5b3UgaGF2ZSBiZXR0 ZXIgc29sdXRpb25zLgo+IFNvLCB3aGF0IGRvIHlvdSB0aGluayBhYm91dCB0aGF0Pwo+IAo+IFRo aXMgcGF0Y2ggd2FzIHRlc3RlZCB3aXRoIFhlbiBpbWFnZSB3aGljaCB1c2VzIHRoYXQgZnVuY3Rp b25hbGl0eS4gSG93ZXZlciwgdGhpcyBYZW4KPiBmZWF0dXJlIGlzIHN0aWxsIHVuZGVyIGRldmVs b3BtZW50IGFuZCBuZXcgcGF0Y2hzZXQgd2lsbCBiZSByZWxlYXNlZCBpbiBhYm91dCAzLTQgd2Vl a3MuCj4gCj4gU2lnbmVkLW9mZi1ieTogRGFuaWVsIEtpcGVyIDxkYW5pZWwua2lwZXJAb3JhY2xl LmNvbT4KPiAtLS0KPiB2MyAtIHN1Z2dlc3Rpb25zL2ZpeGVzOgo+ICAgIC0gcmVkdWNlIG51bWJl ciBvZiBjYXN0cwo+ICAgICAgKHN1Z2dlc3RlZCBieSBLb25yYWQgUnplc3p1dGVrIFdpbGspLAo+ ICAgIC0gcmVtb3ZlIHVubmVlZGVkIHNwYWNlIGF0IHRoZSBlbmQgb2YgbGluZQo+ICAgICAgKHN1 Z2dlc3RlZCBieSBLb25yYWQgUnplc3p1dGVrIFdpbGspLAo+ICAgIC0gaW1wcm92ZSBjb21taXQg bWVzc2FnZQo+ICAgICAgKHN1Z2dlc3RlZCBieSBLb25yYWQgUnplc3p1dGVrIFdpbGspLgo+IC0t LQo+ICBncnViLWNvcmUvbG9hZGVyL2kzODYvbXVsdGlib290X21iaS5jIHwgICAgNiArKy0KPiAg Z3J1Yi1jb3JlL2xvYWRlci9tdWx0aWJvb3QuYyAgICAgICAgICB8ICAgMTIgKysrKy0tCj4gIGdy dWItY29yZS9sb2FkZXIvbXVsdGlib290X2VsZnh4LmMgICAgfCAgIDI4ICsrKysrKysrKystLS0t Cj4gIGdydWItY29yZS9sb2FkZXIvbXVsdGlib290X21iaTIuYyAgICAgfCAgIDY1ICsrKysrKysr KysrKysrKysrKysrKysrKysrKysrKy0tLQo+ICBpbmNsdWRlL2dydWIvbXVsdGlib290LmggICAg ICAgICAgICAgIHwgICAgNCArLQo+ICBpbmNsdWRlL211bHRpYm9vdDIuaCAgICAgICAgICAgICAg ICAgIHwgICAyNCArKysrKysrKysrKysKPiAgNiBmaWxlcyBjaGFuZ2VkLCAxMjAgaW5zZXJ0aW9u cygrKSwgMTkgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2dydWItY29yZS9sb2FkZXIv aTM4Ni9tdWx0aWJvb3RfbWJpLmMgYi9ncnViLWNvcmUvbG9hZGVyL2kzODYvbXVsdGlib290X21i aS5jCj4gaW5kZXggZjYwYjcwMi4uNGZjODNlZCAxMDA2NDQKPiAtLS0gYS9ncnViLWNvcmUvbG9h ZGVyL2kzODYvbXVsdGlib290X21iaS5jCj4gKysrIGIvZ3J1Yi1jb3JlL2xvYWRlci9pMzg2L211 bHRpYm9vdF9tYmkuYwo+IEBAIC03Miw3ICs3Miw4IEBAIGxvYWRfa2VybmVsIChncnViX2ZpbGVf dCBmaWxlLCBjb25zdCBjaGFyICpmaWxlbmFtZSwKPiAgICBncnViX2Vycl90IGVycjsKPiAgICBp ZiAoZ3J1Yl9tdWx0aWJvb3RfcXVpcmtzICYgR1JVQl9NVUxUSUJPT1RfUVVJUktfQkFEX0tMVURH RSkKPiAgICAgIHsKPiAtICAgICAgZXJyID0gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYgKGZpbGUs IGZpbGVuYW1lLCBidWZmZXIpOwo+ICsgICAgICBlcnIgPSBncnViX211bHRpYm9vdF9sb2FkX2Vs ZiAoZmlsZSwgZmlsZW5hbWUsIGJ1ZmZlciwgMCwgMCwgMCwgMCwKPiArCQkJCSAgICAgR1JVQl9S RUxPQ0FUT1JfUFJFRkVSRU5DRV9OT05FLCBOVUxMLCAwKTsKClV1aCwgcmVhbGx5PyBZb3UgYXJl IGFkZGluZyA3IHBhcmFtZXRlcnMgZm9yIHRoZSByZWxvY2F0YWJsZSBjYXNlLgpXb3VsZG4ndCBp dCBtYWtlIG1vcmUgc2Vuc2UgdG8gaGF2ZSBzb21lIGtpbmQgb2Ygc3RydWN0dXJlIGNvbnRhaW5p bmcKdGhlIGRhdGEgeW91IG5lZWQgZm9yIHJlbG9jYXRhYmxlIGltYWdlcyBhbmQgcGFzcyB0aGUg cG9pbnRlciB0byB0aGF0CnN0cnVjdHVyZSBvciBOVUxMIGluIHRoZSBjYXNlIG9mIG5vbi1yZWxv Y2F0YWJsZSBpbWFnZXMgKG9yIGhhdmUgYQpkZWZhdWx0IHN0cnVjdHVyZSBmb3IgdGhlIG5vbi1y ZWxvY2F0YWJsZSBjYXNlKT8KCgpKdWVyZ2VuCgo+ICAgICAgICBpZiAoZXJyID09IEdSVUJfRVJS X05PTkUpIHsKPiAgCXJldHVybiBHUlVCX0VSUl9OT05FOwo+ICAgICAgICB9Cj4gQEAgLTEyMSw3 ICsxMjIsOCBAQCBsb2FkX2tlcm5lbCAoZ3J1Yl9maWxlX3QgZmlsZSwgY29uc3QgY2hhciAqZmls ZW5hbWUsCj4gICAgICAgIHJldHVybiBHUlVCX0VSUl9OT05FOwo+ICAgICAgfQo+ICAKPiAtICBy ZXR1cm4gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYgKGZpbGUsIGZpbGVuYW1lLCBidWZmZXIpOwo+ ICsgIHJldHVybiBncnViX211bHRpYm9vdF9sb2FkX2VsZiAoZmlsZSwgZmlsZW5hbWUsIGJ1ZmZl ciwgMCwgMCwgMCwgMCwKPiArCQkJCSAgR1JVQl9SRUxPQ0FUT1JfUFJFRkVSRU5DRV9OT05FLCBO VUxMLCAwKTsKPiAgfQo+ICAKPiAgc3RhdGljIHN0cnVjdCBtdWx0aWJvb3RfaGVhZGVyICoKPiBk aWZmIC0tZ2l0IGEvZ3J1Yi1jb3JlL2xvYWRlci9tdWx0aWJvb3QuYyBiL2dydWItY29yZS9sb2Fk ZXIvbXVsdGlib290LmMKPiBpbmRleCAxODAzOGZkLi5jMGY1MWI2IDEwMDY0NAo+IC0tLSBhL2dy dWItY29yZS9sb2FkZXIvbXVsdGlib290LmMKPiArKysgYi9ncnViLWNvcmUvbG9hZGVyL211bHRp Ym9vdC5jCj4gQEAgLTIwOCwxMiArMjA4LDE4IEBAIHN0YXRpYyBncnViX3VpbnQ2NF90IGhpZ2hl c3RfbG9hZDsKPiAgLyogTG9hZCBFTEYzMiBvciBFTEY2NC4gICovCj4gIGdydWJfZXJyX3QKPiAg Z3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYgKGdydWJfZmlsZV90IGZpbGUsIGNvbnN0IGNoYXIgKmZp bGVuYW1lLAo+IC0JCQkgdm9pZCAqYnVmZmVyKQo+ICsJCQkgdm9pZCAqYnVmZmVyLCBpbnQgcmVs b2NhdGFibGUsIGdydWJfdWludDMyX3QgbWluX2FkZHIsCj4gKwkJCSBncnViX3VpbnQzMl90IG1h eF9hZGRyLCBncnViX3NpemVfdCBhbGlnbiwgZ3J1Yl91aW50MzJfdCBwcmVmZXJlbmNlLAo+ICsJ CQkgZ3J1Yl91aW50MzJfdCAqYmFzZV9hZGRyLCBpbnQgYXZvaWRfZWZpX2Jvb3Rfc2VydmljZXMp Cj4gIHsKPiAgICBpZiAoZ3J1Yl9tdWx0aWJvb3RfaXNfZWxmMzIgKGJ1ZmZlcikpCj4gLSAgICBy ZXR1cm4gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYzMiAoZmlsZSwgZmlsZW5hbWUsIGJ1ZmZlcik7 Cj4gKyAgICByZXR1cm4gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYzMiAoZmlsZSwgZmlsZW5hbWUs IGJ1ZmZlciwgcmVsb2NhdGFibGUsCj4gKwkJCQkgICAgICBtaW5fYWRkciwgbWF4X2FkZHIsIGFs aWduLCBwcmVmZXJlbmNlLAo+ICsJCQkJICAgICAgYmFzZV9hZGRyLCBhdm9pZF9lZmlfYm9vdF9z ZXJ2aWNlcyk7Cj4gICAgZWxzZSBpZiAoZ3J1Yl9tdWx0aWJvb3RfaXNfZWxmNjQgKGJ1ZmZlcikp Cj4gLSAgICByZXR1cm4gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGY2NCAoZmlsZSwgZmlsZW5hbWUs IGJ1ZmZlcik7Cj4gKyAgICByZXR1cm4gZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGY2NCAoZmlsZSwg ZmlsZW5hbWUsIGJ1ZmZlciwgcmVsb2NhdGFibGUsCj4gKwkJCQkgICAgICBtaW5fYWRkciwgbWF4 X2FkZHIsIGFsaWduLCBwcmVmZXJlbmNlLAo+ICsJCQkJICAgICAgYmFzZV9hZGRyLCBhdm9pZF9l ZmlfYm9vdF9zZXJ2aWNlcyk7Cj4gIAo+ICAgIHJldHVybiBncnViX2Vycm9yIChHUlVCX0VSUl9V TktOT1dOX09TLCBOXygiaW52YWxpZCBhcmNoLWRlcGVuZGVudCBFTEYgbWFnaWMiKSk7Cj4gIH0K PiBkaWZmIC0tZ2l0IGEvZ3J1Yi1jb3JlL2xvYWRlci9tdWx0aWJvb3RfZWxmeHguYyBiL2dydWIt Y29yZS9sb2FkZXIvbXVsdGlib290X2VsZnh4LmMKPiBpbmRleCBlM2EzOWI2Li4wYzAxNTY5IDEw MDY0NAo+IC0tLSBhL2dydWItY29yZS9sb2FkZXIvbXVsdGlib290X2VsZnh4LmMKPiArKysgYi9n cnViLWNvcmUvbG9hZGVyL211bHRpYm9vdF9lbGZ4eC5jCj4gQEAgLTUxLDcgKzUxLDEwIEBAIENP TkNBVChncnViX211bHRpYm9vdF9pc19lbGYsIFhYKSAodm9pZCAqYnVmZmVyKQo+ICB9Cj4gIAo+ ICBzdGF0aWMgZ3J1Yl9lcnJfdAo+IC1DT05DQVQoZ3J1Yl9tdWx0aWJvb3RfbG9hZF9lbGYsIFhY KSAoZ3J1Yl9maWxlX3QgZmlsZSwgY29uc3QgY2hhciAqZmlsZW5hbWUsIHZvaWQgKmJ1ZmZlcikK PiArQ09OQ0FUKGdydWJfbXVsdGlib290X2xvYWRfZWxmLCBYWCkgKGdydWJfZmlsZV90IGZpbGUs IGNvbnN0IGNoYXIgKmZpbGVuYW1lLAo+ICsJCQkJICAgICB2b2lkICpidWZmZXIsIGludCByZWxv Y2F0YWJsZSwgZ3J1Yl91aW50MzJfdCBtaW5fYWRkciwKPiArCQkJCSAgICAgZ3J1Yl91aW50MzJf dCBtYXhfYWRkciwgZ3J1Yl9zaXplX3QgYWxpZ24sIGdydWJfdWludDMyX3QgcHJlZmVyZW5jZSwK PiArCQkJCSAgICAgZ3J1Yl91aW50MzJfdCAqYmFzZV9hZGRyLCBpbnQgYXZvaWRfZWZpX2Jvb3Rf c2VydmljZXMpCj4gIHsKPiAgICBFbGZfRWhkciAqZWhkciA9IChFbGZfRWhkciAqKSBidWZmZXI7 Cj4gICAgY2hhciAqcGhkcl9iYXNlOwo+IEBAIC04OSwxOSArOTIsMzAgQEAgQ09OQ0FUKGdydWJf bXVsdGlib290X2xvYWRfZWxmLCBYWCkgKGdydWJfZmlsZV90IGZpbGUsIGNvbnN0IGNoYXIgKmZp bGVuYW1lLCB2b2kKPiAgCSAgaWYgKHBoZHIoaSktPnBfcGFkZHIgKyBwaGRyKGkpLT5wX21lbXN6 ID4gaGlnaGVzdF9sb2FkKQo+ICAJICAgIGhpZ2hlc3RfbG9hZCA9IHBoZHIoaSktPnBfcGFkZHIg KyBwaGRyKGkpLT5wX21lbXN6Owo+ICAKPiAtCSAgZ3J1Yl9kcHJpbnRmICgibXVsdGlib290X2xv YWRlciIsICJzZWdtZW50ICVkOiBwYWRkcj0weCVseCwgbWVtc3o9MHglbHgsIHZhZGRyPTB4JWx4 XG4iLAo+IC0JCQlpLCAobG9uZykgcGhkcihpKS0+cF9wYWRkciwgKGxvbmcpIHBoZHIoaSktPnBf bWVtc3osIChsb25nKSBwaGRyKGkpLT5wX3ZhZGRyKTsKPiArCSAgZ3J1Yl9kcHJpbnRmICgibXVs dGlib290X2xvYWRlciIsICJzZWdtZW50ICVkOiBwYWRkcj0weCVseCwgbWVtc3o9MHglbHgsIHZh ZGRyPTB4JWx4LCIKPiArCQkJImFsaWduPTB4JWx4LCByZWxvY2F0YWJsZT0lZCwgYXZvaWRfZWZp X2Jvb3Rfc2VydmljZXM9JWRcbiIsIGksCj4gKwkJCShsb25nKSBwaGRyKGkpLT5wX3BhZGRyLCAo bG9uZykgcGhkcihpKS0+cF9tZW1zeiwgKGxvbmcpIHBoZHIoaSktPnBfdmFkZHIsCj4gKwkJCShs b25nKSBhbGlnbiwgcmVsb2NhdGFibGUsIGF2b2lkX2VmaV9ib290X3NlcnZpY2VzKTsKPiAgCj4g IAkgIHsKPiAgCSAgICBncnViX3JlbG9jYXRvcl9jaHVua190IGNoOwo+IC0JICAgIGVyciA9IGdy dWJfcmVsb2NhdG9yX2FsbG9jX2NodW5rX2FkZHIgKGdydWJfbXVsdGlib290X3JlbG9jYXRvciwg Cj4gLQkJCQkJCSAgICZjaCwgcGhkcihpKS0+cF9wYWRkciwKPiAtCQkJCQkJICAgcGhkcihpKS0+ cF9tZW1zeik7Cj4gKwo+ICsJICAgIGlmIChyZWxvY2F0YWJsZSkKPiArCSAgICAgIGVyciA9IGdy dWJfcmVsb2NhdG9yX2FsbG9jX2NodW5rX2FsaWduIChncnViX211bHRpYm9vdF9yZWxvY2F0b3Is ICZjaCwKPiArCQkJCQkJICAgICAgbWluX2FkZHIsIG1heF9hZGRyIC0gcGhkcihpKS0+cF9tZW1z eiwKPiArCQkJCQkJICAgICAgcGhkcihpKS0+cF9tZW1zeiwgYWxpZ24gPyBhbGlnbiA6IDEsCj4g KwkJCQkJCSAgICAgIHByZWZlcmVuY2UsIGF2b2lkX2VmaV9ib290X3NlcnZpY2VzKTsKPiArCSAg ICBlbHNlCj4gKwkgICAgICBlcnIgPSBncnViX3JlbG9jYXRvcl9hbGxvY19jaHVua19hZGRyIChn cnViX211bHRpYm9vdF9yZWxvY2F0b3IsCj4gKwkJCQkJCSAgICAgJmNoLCBwaGRyKGkpLT5wX3Bh ZGRyLAo+ICsJCQkJCQkgICAgIHBoZHIoaSktPnBfbWVtc3opOwo+ICAJICAgIGlmIChlcnIpCj4g IAkgICAgICB7Cj4gIAkJZ3J1Yl9kcHJpbnRmICgibXVsdGlib290X2xvYWRlciIsICJFcnJvciBs b2FkaW5nIHBoZHIgJWRcbiIsIGkpOwo+ICAJCXJldHVybiBlcnI7Cj4gIAkgICAgICB9Cj4gKwkg ICAgaWYgKGJhc2VfYWRkcikKPiArCSAgICAgICpiYXNlX2FkZHIgPSBnZXRfcGh5c2ljYWxfdGFy Z2V0X2FkZHJlc3MgKGNoKTsKPiAgCSAgICBzb3VyY2UgPSBnZXRfdmlydHVhbF9jdXJyZW50X2Fk ZHJlc3MgKGNoKTsKPiAgCSAgfQo+ICAKPiBAQCAtMjA4LDcgKzIyMiw3IEBAIENPTkNBVChncnVi X211bHRpYm9vdF9sb2FkX2VsZiwgWFgpIChncnViX2ZpbGVfdCBmaWxlLCBjb25zdCBjaGFyICpm aWxlbmFtZSwgdm9pCj4gIAkJCQkJCSAgICArIDEsIHNoLT5zaF9zaXplLAo+ICAJCQkJCQkgICAg c2gtPnNoX2FkZHJhbGlnbiwKPiAgCQkJCQkJICAgIEdSVUJfUkVMT0NBVE9SX1BSRUZFUkVOQ0Vf Tk9ORSwKPiAtCQkJCQkJICAgIDApOwo+ICsJCQkJCQkgICAgYXZvaWRfZWZpX2Jvb3Rfc2Vydmlj ZXMpOwo+ICAJICAgIGlmIChlcnIpCj4gIAkgICAgICB7Cj4gIAkJZ3J1Yl9kcHJpbnRmICgibXVs dGlib290X2xvYWRlciIsICJFcnJvciBsb2FkaW5nIHNoZHIgJWRcbiIsIGkpOwo+IGRpZmYgLS1n aXQgYS9ncnViLWNvcmUvbG9hZGVyL211bHRpYm9vdF9tYmkyLmMgYi9ncnViLWNvcmUvbG9hZGVy L211bHRpYm9vdF9tYmkyLmMKPiBpbmRleCBjZTY4ZjQ4Li4wMzcyNWExIDEwMDY0NAo+IC0tLSBh L2dydWItY29yZS9sb2FkZXIvbXVsdGlib290X21iaTIuYwo+ICsrKyBiL2dydWItY29yZS9sb2Fk ZXIvbXVsdGlib290X21iaTIuYwo+IEBAIC02OCw2ICs2OCw3IEBAIHN0YXRpYyBncnViX3NpemVf dCBlbGZfc2VjX251bSwgZWxmX3NlY19lbnRzaXplOwo+ICBzdGF0aWMgdW5zaWduZWQgZWxmX3Nl Y19zaHN0cm5keDsKPiAgc3RhdGljIHZvaWQgKmVsZl9zZWN0aW9uczsKPiAgc3RhdGljIGludCBr ZWVwX2JzID0gMDsKPiArc3RhdGljIGdydWJfdWludDMyX3QgYmFzZV9hZGRyID0gMDsKPiAgCj4g IHZvaWQKPiAgZ3J1Yl9tdWx0aWJvb3RfYWRkX2VsZnN5bXMgKGdydWJfc2l6ZV90IG51bSwgZ3J1 Yl9zaXplX3QgZW50c2l6ZSwKPiBAQCAtMTA3LDExICsxMDgsMTQgQEAgZ3J1Yl9tdWx0aWJvb3Rf bG9hZCAoZ3J1Yl9maWxlX3QgZmlsZSwgY29uc3QgY2hhciAqZmlsZW5hbWUpCj4gICAgZ3J1Yl9l cnJfdCBlcnI7Cj4gICAgc3RydWN0IG11bHRpYm9vdF9oZWFkZXJfdGFnICp0YWc7Cj4gICAgc3Ry dWN0IG11bHRpYm9vdF9oZWFkZXJfdGFnX2FkZHJlc3MgKmFkZHJfdGFnID0gTlVMTDsKPiAtICBp bnQgZW50cnlfc3BlY2lmaWVkID0gMCwgZWZpX2VudHJ5X3NwZWNpZmllZCA9IDA7Cj4gKyAgc3Ry dWN0IG11bHRpYm9vdF9oZWFkZXJfdGFnX3JlbG9jYXRhYmxlICpyZWxfdGFnOwo+ICsgIGludCBl bnRyeV9zcGVjaWZpZWQgPSAwLCBlZmlfZW50cnlfc3BlY2lmaWVkID0gMCwgcmVsb2NhdGFibGUg PSAwOwo+ICAgIGdydWJfYWRkcl90IGVudHJ5ID0gMCwgZWZpX2VudHJ5ID0gMDsKPiAtICBncnVi X3VpbnQzMl90IGNvbnNvbGVfcmVxdWlyZWQgPSAwOwo+ICsgIGdydWJfdWludDMyX3QgY29uc29s ZV9yZXF1aXJlZCA9IDAsIG1pbl9hZGRyID0gMDsKPiArICBncnViX3VpbnQzMl90IG1heF9hZGRy ID0gMCwgcHJlZmVyZW5jZSA9IEdSVUJfUkVMT0NBVE9SX1BSRUZFUkVOQ0VfTk9ORTsKPiAgICBz dHJ1Y3QgbXVsdGlib290X2hlYWRlcl90YWdfZnJhbWVidWZmZXIgKmZidGFnID0gTlVMTDsKPiAg ICBpbnQgYWNjZXB0ZWRfY29uc29sZXMgPSBHUlVCX01VTFRJQk9PVF9DT05TT0xFX0VHQV9URVhU Owo+ICsgIGdydWJfc2l6ZV90IGFsaWduID0gMDsKPiAgCj4gICAgYnVmZmVyID0gZ3J1Yl9tYWxs b2MgKE1VTFRJQk9PVF9TRUFSQ0gpOwo+ICAgIGlmICghYnVmZmVyKQo+IEBAIC0xNzQsNiArMTc4 LDcgQEAgZ3J1Yl9tdWx0aWJvb3RfbG9hZCAoZ3J1Yl9maWxlX3QgZmlsZSwgY29uc3QgY2hhciAq ZmlsZW5hbWUpCj4gIAkgICAgICBjYXNlIE1VTFRJQk9PVF9UQUdfVFlQRV9FRklfQlM6Cj4gIAkg ICAgICBjYXNlIE1VTFRJQk9PVF9UQUdfVFlQRV9FRkkzMl9JSDoKPiAgCSAgICAgIGNhc2UgTVVM VElCT09UX1RBR19UWVBFX0VGSTY0X0lIOgo+ICsJICAgICAgY2FzZSBNVUxUSUJPT1RfVEFHX1RZ UEVfQkFTRV9BRERSOgo+ICAJCWJyZWFrOwo+ICAKPiAgCSAgICAgIGRlZmF1bHQ6Cj4gQEAgLTIx NSw2ICsyMjAsMjcgQEAgZ3J1Yl9tdWx0aWJvb3RfbG9hZCAoZ3J1Yl9maWxlX3QgZmlsZSwgY29u c3QgY2hhciAqZmlsZW5hbWUpCj4gIAlhY2NlcHRlZF9jb25zb2xlcyB8PSBHUlVCX01VTFRJQk9P VF9DT05TT0xFX0ZSQU1FQlVGRkVSOwo+ICAJYnJlYWs7Cj4gIAo+ICsgICAgICBjYXNlIE1VTFRJ Qk9PVF9IRUFERVJfVEFHX1JFTE9DQVRBQkxFOgo+ICsJcmVsb2NhdGFibGUgPSAxOwo+ICsJcmVs X3RhZyA9IChzdHJ1Y3QgbXVsdGlib290X2hlYWRlcl90YWdfcmVsb2NhdGFibGUgKikgdGFnOwo+ ICsJbWluX2FkZHIgPSByZWxfdGFnLT5taW5fYWRkcjsKPiArCW1heF9hZGRyID0gcmVsX3RhZy0+ bWF4X2FkZHI7Cj4gKwlhbGlnbiA9IHJlbF90YWctPmFsaWduOwo+ICsJc3dpdGNoIChyZWxfdGFn LT5wcmVmZXJlbmNlKQo+ICsJICB7Cj4gKwkgIGNhc2UgTVVMVElCT09UX0xPQURfUFJFRkVSRU5D RV9MT1c6Cj4gKwkgICAgcHJlZmVyZW5jZSA9IEdSVUJfUkVMT0NBVE9SX1BSRUZFUkVOQ0VfTE9X Owo+ICsJICAgIGJyZWFrOwo+ICsKPiArCSAgY2FzZSBNVUxUSUJPT1RfTE9BRF9QUkVGRVJFTkNF X0hJR0g6Cj4gKwkgICAgcHJlZmVyZW5jZSA9IEdSVUJfUkVMT0NBVE9SX1BSRUZFUkVOQ0VfSElH SDsKPiArCSAgICBicmVhazsKPiArCj4gKwkgIGRlZmF1bHQ6Cj4gKwkgICAgcHJlZmVyZW5jZSA9 IEdSVUJfUkVMT0NBVE9SX1BSRUZFUkVOQ0VfTk9ORTsKPiArCSAgfQo+ICsJYnJlYWs7Cj4gKwo+ ICAJLyogR1JVQiBhbHdheXMgcGFnZS1hbGlnbnMgbW9kdWxlcy4gICovCj4gICAgICAgIGNhc2Ug TVVMVElCT09UX0hFQURFUl9UQUdfTU9EVUxFX0FMSUdOOgo+ICAJYnJlYWs7Cj4gQEAgLTI2MCwx NSArMjg2LDIyIEBAIGdydWJfbXVsdGlib290X2xvYWQgKGdydWJfZmlsZV90IGZpbGUsIGNvbnN0 IGNoYXIgKmZpbGVuYW1lKQo+ICAgICAgICBlbHNlCj4gIAljb2RlX3NpemUgPSBsb2FkX3NpemU7 Cj4gIAo+IC0gICAgICBlcnIgPSBncnViX3JlbG9jYXRvcl9hbGxvY19jaHVua19hZGRyIChncnVi X211bHRpYm9vdF9yZWxvY2F0b3IsIAo+IC0JCQkJCSAgICAgJmNoLCBsb2FkX2FkZHIsCj4gLQkJ CQkJICAgICBjb2RlX3NpemUpOwo+ICsgICAgICBpZiAocmVsb2NhdGFibGUpCj4gKwllcnIgPSBn cnViX3JlbG9jYXRvcl9hbGxvY19jaHVua19hbGlnbiAoZ3J1Yl9tdWx0aWJvb3RfcmVsb2NhdG9y LCAmY2gsCj4gKwkJCQkJCW1pbl9hZGRyLCBtYXhfYWRkciAtIGNvZGVfc2l6ZSwKPiArCQkJCQkJ Y29kZV9zaXplLCBhbGlnbiA/IGFsaWduIDogMSwKPiArCQkJCQkJcHJlZmVyZW5jZSwga2VlcF9i cyk7Cj4gKyAgICAgIGVsc2UKPiArCWVyciA9IGdydWJfcmVsb2NhdG9yX2FsbG9jX2NodW5rX2Fk ZHIgKGdydWJfbXVsdGlib290X3JlbG9jYXRvciwKPiArCQkJCQkgICAgICAgJmNoLCBsb2FkX2Fk ZHIsCj4gKwkJCQkJICAgICAgIGNvZGVfc2l6ZSk7Cj4gICAgICAgIGlmIChlcnIpCj4gIAl7Cj4g IAkgIGdydWJfZHByaW50ZiAoIm11bHRpYm9vdF9sb2FkZXIiLCAiRXJyb3IgbG9hZGluZyBhb3V0 IGtsdWRnZVxuIik7Cj4gIAkgIGdydWJfZnJlZSAoYnVmZmVyKTsKPiAgCSAgcmV0dXJuIGVycjsK PiAgCX0KPiArICAgICAgYmFzZV9hZGRyID0gZ2V0X3BoeXNpY2FsX3RhcmdldF9hZGRyZXNzIChj aCk7Cj4gICAgICAgIHNvdXJjZSA9IGdldF92aXJ0dWFsX2N1cnJlbnRfYWRkcmVzcyAoY2gpOwo+ ICAKPiAgICAgICAgaWYgKChncnViX2ZpbGVfc2VlayAoZmlsZSwgb2Zmc2V0KSkgPT0gKGdydWJf b2ZmX3QpIC0xKQo+IEBAIC0yOTAsNyArMzIzLDkgQEAgZ3J1Yl9tdWx0aWJvb3RfbG9hZCAoZ3J1 Yl9maWxlX3QgZmlsZSwgY29uc3QgY2hhciAqZmlsZW5hbWUpCj4gICAgICB9Cj4gICAgZWxzZQo+ ICAgICAgewo+IC0gICAgICBlcnIgPSBncnViX211bHRpYm9vdF9sb2FkX2VsZiAoZmlsZSwgZmls ZW5hbWUsIGJ1ZmZlcik7Cj4gKyAgICAgIGVyciA9IGdydWJfbXVsdGlib290X2xvYWRfZWxmIChm aWxlLCBmaWxlbmFtZSwgYnVmZmVyLAo+ICsJCQkJICAgICByZWxvY2F0YWJsZSwgbWluX2FkZHIs IG1heF9hZGRyLAo+ICsJCQkJICAgICBhbGlnbiwgcHJlZmVyZW5jZSwgJmJhc2VfYWRkciwga2Vl cF9icyk7Cj4gICAgICAgIGlmIChlcnIpCj4gIAl7Cj4gIAkgIGdydWJfZnJlZSAoYnVmZmVyKTsK PiBAQCAtMzAzLDYgKzMzOCwxNCBAQCBncnViX211bHRpYm9vdF9sb2FkIChncnViX2ZpbGVfdCBm aWxlLCBjb25zdCBjaGFyICpmaWxlbmFtZSkKPiAgICBlbHNlIGlmIChlbnRyeV9zcGVjaWZpZWQp Cj4gICAgICBncnViX211bHRpYm9vdF9wYXlsb2FkX2VpcCA9IGVudHJ5Owo+ICAKPiArICBpZiAo cmVsb2NhdGFibGUpCj4gKyAgICB7Cj4gKyAgICAgIGlmIChiYXNlX2FkZHIgPiBtaW5fYWRkcikK PiArCWdydWJfbXVsdGlib290X3BheWxvYWRfZWlwICs9IGJhc2VfYWRkciAtIG1pbl9hZGRyOwo+ ICsgICAgICBlbHNlCj4gKwlncnViX211bHRpYm9vdF9wYXlsb2FkX2VpcCAtPSBtaW5fYWRkciAt IGJhc2VfYWRkcjsKPiArICAgIH0KPiArCj4gICAgaWYgKGZidGFnKQo+ICAgICAgZXJyID0gZ3J1 Yl9tdWx0aWJvb3Rfc2V0X2NvbnNvbGUgKEdSVUJfTVVMVElCT09UX0NPTlNPTEVfRlJBTUVCVUZG RVIsCj4gIAkJCQkgICAgICBhY2NlcHRlZF9jb25zb2xlcywKPiBAQCAtNDA5LDYgKzQ1Miw3IEBA IGdydWJfbXVsdGlib290X2dldF9tYmlfc2l6ZSAodm9pZCkKPiAgCQkgKyBncnViX2dldF9tdWx0 aWJvb3RfbW1hcF9jb3VudCAoKQo+ICAJCSAqIHNpemVvZiAoc3RydWN0IG11bHRpYm9vdF9tbWFw X2VudHJ5KSksIE1VTFRJQk9PVF9UQUdfQUxJR04pCj4gICAgICArIEFMSUdOX1VQIChzaXplb2Yg KHN0cnVjdCBtdWx0aWJvb3RfdGFnX2ZyYW1lYnVmZmVyKSwgTVVMVElCT09UX1RBR19BTElHTikK PiArICAgICsgQUxJR05fVVAgKHNpemVvZiAoc3RydWN0IG11bHRpYm9vdF90YWdfYmFzZV9hZGRy KSwgTVVMVElCT09UX1RBR19BTElHTikKPiAgI2lmZGVmIEdSVUJfTUFDSElORV9FRkkKPiAgI2lm ZGVmIF9faTM4Nl9fCj4gICAgICArIEFMSUdOX1VQIChzaXplb2YgKHN0cnVjdCBtdWx0aWJvb3Rf dGFnX2VmaTMyKSwgTVVMVElCT09UX1RBR19BTElHTikKPiBAQCAtNjk4LDYgKzc0MiwxNSBAQCBn cnViX211bHRpYm9vdF9tYWtlX21iaSAoZ3J1Yl91aW50MzJfdCAqdGFyZ2V0KQo+ICAgIHB0cm9y aWcgKz0gKDIgKiBzaXplb2YgKGdydWJfdWludDMyX3QpKSAvIHNpemVvZiAoZ3J1Yl9wcm9wZXJs eV9hbGlnbmVkX3QpOwo+ICAKPiAgICB7Cj4gKyAgICBzdHJ1Y3QgbXVsdGlib290X3RhZ19iYXNl X2FkZHIgKnRhZyA9IChzdHJ1Y3QgbXVsdGlib290X3RhZ19iYXNlX2FkZHIgKikgcHRyb3JpZzsK PiArICAgIHRhZy0+dHlwZSA9IE1VTFRJQk9PVF9UQUdfVFlQRV9CQVNFX0FERFI7Cj4gKyAgICB0 YWctPnNpemUgPSBzaXplb2YgKHN0cnVjdCBtdWx0aWJvb3RfdGFnX2Jhc2VfYWRkcik7Cj4gKyAg ICB0YWctPmJhc2VfYWRkciA9IGJhc2VfYWRkcjsKPiArICAgIHB0cm9yaWcgKz0gQUxJR05fVVAg KHRhZy0+c2l6ZSwgTVVMVElCT09UX1RBR19BTElHTikKPiArICAgICAgIC8gc2l6ZW9mIChncnVi X3Byb3Blcmx5X2FsaWduZWRfdCk7Cj4gKyAgfQo+ICsKPiArICB7Cj4gICAgICBzdHJ1Y3QgbXVs dGlib290X3RhZ19zdHJpbmcgKnRhZyA9IChzdHJ1Y3QgbXVsdGlib290X3RhZ19zdHJpbmcgKikg cHRyb3JpZzsKPiAgICAgIHRhZy0+dHlwZSA9IE1VTFRJQk9PVF9UQUdfVFlQRV9DTURMSU5FOwo+ ICAgICAgdGFnLT5zaXplID0gc2l6ZW9mIChzdHJ1Y3QgbXVsdGlib290X3RhZ19zdHJpbmcpICsg Y21kbGluZV9zaXplOyAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9ncnViL211bHRpYm9vdC5oIGIv aW5jbHVkZS9ncnViL211bHRpYm9vdC5oCj4gaW5kZXggZTEzYzA4NC4uZWMzMjJiMCAxMDA2NDQK PiAtLS0gYS9pbmNsdWRlL2dydWIvbXVsdGlib290LmgKPiArKysgYi9pbmNsdWRlL2dydWIvbXVs dGlib290LmgKPiBAQCAtOTQsNyArOTQsOSBAQCBncnViX211bHRpYm9vdF9sb2FkIChncnViX2Zp bGVfdCBmaWxlLCBjb25zdCBjaGFyICpmaWxlbmFtZSk7Cj4gIC8qIExvYWQgRUxGMzIgb3IgRUxG NjQuICAqLwo+ICBncnViX2Vycl90Cj4gIGdydWJfbXVsdGlib290X2xvYWRfZWxmIChncnViX2Zp bGVfdCBmaWxlLCBjb25zdCBjaGFyICpmaWxlbmFtZSwKPiAtCQkJIHZvaWQgKmJ1ZmZlcik7Cj4g KwkJCSB2b2lkICpidWZmZXIsIGludCByZWxvY2F0YWJsZSwgZ3J1Yl91aW50MzJfdCBtaW5fYWRk ciwKPiArCQkJIGdydWJfdWludDMyX3QgbWF4X2FkZHIsIGdydWJfc2l6ZV90IGFsaWduLCBncnVi X3VpbnQzMl90IHByZWZlcmVuY2UsCj4gKwkJCSBncnViX3VpbnQzMl90ICpiYXNlX2FkZHIsIGlu dCBhdm9pZF9lZmlfYm9vdF9zZXJ2aWNlcyk7Cj4gIGV4dGVybiBncnViX3NpemVfdCBncnViX211 bHRpYm9vdF9wdXJlX3NpemU7Cj4gIGV4dGVybiBncnViX3NpemVfdCBncnViX211bHRpYm9vdF9h bGxvY19tYmk7Cj4gIGV4dGVybiBncnViX3VpbnQzMl90IGdydWJfbXVsdGlib290X3BheWxvYWRf ZWlwOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL211bHRpYm9vdDIuaCBiL2luY2x1ZGUvbXVsdGli b290Mi5oCj4gaW5kZXggMzZhMTc0Zi4uYzA5YmRiYyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL211 bHRpYm9vdDIuaAo+ICsrKyBiL2luY2x1ZGUvbXVsdGlib290Mi5oCj4gQEAgLTYyLDYgKzYyLDcg QEAKPiAgI2RlZmluZSBNVUxUSUJPT1RfVEFHX1RZUEVfRUZJX0JTICAgICAgICAgICAgMTgKPiAg I2RlZmluZSBNVUxUSUJPT1RfVEFHX1RZUEVfRUZJMzJfSUggICAgICAgICAgMTkKPiAgI2RlZmlu ZSBNVUxUSUJPT1RfVEFHX1RZUEVfRUZJNjRfSUggICAgICAgICAgMjAKPiArI2RlZmluZSBNVUxU SUJPT1RfVEFHX1RZUEVfQkFTRV9BRERSICAgICAgICAgMjEKPiAgCj4gICNkZWZpbmUgTVVMVElC T09UX0hFQURFUl9UQUdfRU5EICAwCj4gICNkZWZpbmUgTVVMVElCT09UX0hFQURFUl9UQUdfSU5G T1JNQVRJT05fUkVRVUVTVCAgMQo+IEBAIC03MiwxMSArNzMsMTYgQEAKPiAgI2RlZmluZSBNVUxU SUJPT1RfSEVBREVSX1RBR19NT0RVTEVfQUxJR04gIDYKPiAgI2RlZmluZSBNVUxUSUJPT1RfSEVB REVSX1RBR19FRklfQlMgIDcKPiAgI2RlZmluZSBNVUxUSUJPT1RfSEVBREVSX1RBR19FTlRSWV9B RERSRVNTX0VGSTY0ICA5Cj4gKyNkZWZpbmUgTVVMVElCT09UX0hFQURFUl9UQUdfUkVMT0NBVEFC TEUgIDEwCj4gIAo+ICAjZGVmaW5lIE1VTFRJQk9PVF9BUkNISVRFQ1RVUkVfSTM4NiAgMAo+ICAj ZGVmaW5lIE1VTFRJQk9PVF9BUkNISVRFQ1RVUkVfTUlQUzMyICA0Cj4gICNkZWZpbmUgTVVMVElC T09UX0hFQURFUl9UQUdfT1BUSU9OQUwgMQo+ICAKPiArI2RlZmluZSBNVUxUSUJPT1RfTE9BRF9Q UkVGRVJFTkNFX05PTkUgMAo+ICsjZGVmaW5lIE1VTFRJQk9PVF9MT0FEX1BSRUZFUkVOQ0VfTE9X IDEKPiArI2RlZmluZSBNVUxUSUJPT1RfTE9BRF9QUkVGRVJFTkNFX0hJR0ggMgo+ICsKPiAgI2Rl ZmluZSBNVUxUSUJPT1RfQ09OU09MRV9GTEFHU19DT05TT0xFX1JFUVVJUkVEIDEKPiAgI2RlZmlu ZSBNVUxUSUJPT1RfQ09OU09MRV9GTEFHU19FR0FfVEVYVF9TVVBQT1JURUQgMgo+ICAKPiBAQCAt MTYxLDYgKzE2NywxNyBAQCBzdHJ1Y3QgbXVsdGlib290X2hlYWRlcl90YWdfbW9kdWxlX2FsaWdu Cj4gICAgbXVsdGlib290X3VpbnQzMl90IHNpemU7Cj4gIH07Cj4gIAo+ICtzdHJ1Y3QgbXVsdGli b290X2hlYWRlcl90YWdfcmVsb2NhdGFibGUKPiArewo+ICsgIG11bHRpYm9vdF91aW50MTZfdCB0 eXBlOwo+ICsgIG11bHRpYm9vdF91aW50MTZfdCBmbGFnczsKPiArICBtdWx0aWJvb3RfdWludDMy X3Qgc2l6ZTsKPiArICBtdWx0aWJvb3RfdWludDMyX3QgbWluX2FkZHI7Cj4gKyAgbXVsdGlib290 X3VpbnQzMl90IG1heF9hZGRyOwo+ICsgIG11bHRpYm9vdF91aW50MzJfdCBhbGlnbjsKPiArICBt dWx0aWJvb3RfdWludDMyX3QgcHJlZmVyZW5jZTsKPiArfTsKPiArCj4gIHN0cnVjdCBtdWx0aWJv b3RfY29sb3IKPiAgewo+ICAgIG11bHRpYm9vdF91aW50OF90IHJlZDsKPiBAQCAtMzg3LDYgKzQw NCwxMyBAQCBzdHJ1Y3QgbXVsdGlib290X3RhZ19lZmk2NF9paAo+ICAgIG11bHRpYm9vdF91aW50 NjRfdCBwb2ludGVyOwo+ICB9Owo+ICAKPiArc3RydWN0IG11bHRpYm9vdF90YWdfYmFzZV9hZGRy Cj4gK3sKPiArICBtdWx0aWJvb3RfdWludDMyX3QgdHlwZTsKPiArICBtdWx0aWJvb3RfdWludDMy X3Qgc2l6ZTsKPiArICBtdWx0aWJvb3RfdWludDMyX3QgYmFzZV9hZGRyOwo+ICt9Owo+ICsKPiAg I2VuZGlmIC8qICEgQVNNX0ZJTEUgKi8KPiAgCj4gICNlbmRpZiAvKiAhIE1VTFRJQk9PVF9IRUFE RVIgKi8KPiAKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f XwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0dHA6Ly9s aXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=