From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-io1-xd41.google.com (mail-io1-xd41.google.com [IPv6:2607:f8b0:4864:20::d41]) by sourceware.org (Postfix) with ESMTPS id 2E1A2385BF81 for ; Tue, 14 Jul 2020 15:48:01 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 2E1A2385BF81 Received: by mail-io1-xd41.google.com with SMTP id v8so17783354iox.2 for ; Tue, 14 Jul 2020 08:48:01 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:references:in-reply-to:from:date :message-id:subject:to:cc; bh=j0nuFPTEtOq/ZnWxIrN1fTbD2xS/l++GrpyazMuxXmY=; b=BIjeerJQUjk3cZi5hFnxcjFmKJEJASIVPKR/vQilJsu0IR+zoFBiyi+UXQeG033O50 ePdUbI2cpoF48hfJ0Ro+tw0SrGtV1N+p2RCF7AkdlkhN+tC568UetgRdux+3e2njb4WE Gi7/LmV2/mjWmhkQgBSGl3dZlh+o4IsK+N3ti/s+h+fBEFB0BMdEmOREBF3VsMF37kh0 4OPCbQMNSZcaxcWQdhkqH4n0SGPMDCIfTfSe0bw2xN2mLAOTo1m3XJZ3DUNL7DzcYGGN 41TgzN+Kz2M672T43cHKlYiRHqJ5/Nby/jHH5QJsMzvwUczik1z+eu79LScGCeQjqE5B ZUQw== X-Gm-Message-State: AOAM533MHnyIv7OxNHyMtm99H9aNcv7k7RUWwlVfI2k3D/vCBH7oQg/k DTeWdKFhqV1+HCMoKHApn/ULGyZOSObdZH43o65Psg== X-Google-Smtp-Source: ABdhPJymzcOS2sTIRT2tGHZX3qcwcD5rgAPMC+UBGeoqxZpX6Pd8sOx4GyovZQKR57oFD6bwqvYPPcwSB1h8cFWMnzI= X-Received: by 2002:a02:1107:: with SMTP id 7mr6918948jaf.84.1594741680147; Tue, 14 Jul 2020 08:48:00 -0700 (PDT) MIME-Version: 1.0 References: <87lfl634rs.fsf@tromey.com> <87h7vsqk5h.fsf@tromey.com> <87h7v815n7.fsf@tromey.com> <5eab18a1-c7e9-1a77-7f65-944eea10aa85@simark.ca> <5ccfe911-6049-e8f3-4874-9991b2649512@simark.ca> In-Reply-To: From: Caroline Tice Date: Tue, 14 Jul 2020 08:47:47 -0700 Message-ID: Subject: Re: [PATCH V5] Fix issues with reading rnglists, especially from dwo files, for DWARF v5 To: Simon Marchi Cc: Eric Christopher , Tom Tromey , Caroline Tice via Gdb-patches Content-Type: multipart/mixed; boundary="0000000000005b063c05aa68bbe2" X-Spam-Status: No, score=-19.0 required=5.0 tests=BAYES_00, DKIMWL_WL_MED, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, ENV_AND_HDR_SPF_MATCH, KAM_NUMSUBJECT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, USER_IN_DEF_DKIM_WL, USER_IN_DEF_SPF_WL autolearn=no autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Tue, 14 Jul 2020 15:48:04 -0000 --0000000000005b063c05aa68bbe2 Content-Type: text/plain; charset="UTF-8" "This time for sure!" -- Bullwinkle Moose I think I've got all of your requested changes in now, and I've attached the updated patch. About what you said at the very end of your last message: > I thought that somehow, when reading a CU that uses a DWO, we were creating > a "logical" DIE tree by combining the DW_TAG_skeleton_unit DIE and the > children of the DWO's DW_TAG_compile_unit DIE, and while doing this, > overwriting the DW_TAG_skeleton_unit's DIE to use the DW_TAG_compile_unit > tag instead. Therefore making it appear to the rest of the DWARF reader > as if it was a "standard" DW_TAG_compile_unit DIE. But no, maybe I just dreamed > all of this, or I can't find it anymore. > Actually your first thought was absolutely correct. This is done in cutu_reader::cutu_reader. In my patched read.c this is at line 7244: comp_unit_die = dwo_comp_unit_die; It's 4 lines above the comment: /* Yikes, we couldn't find the rest of the DIE, we only have the stub. A complaint has already been logged. There's not much more we can do except pass on the stub DIE to die_reader_func. We don't want to throw an error on bad debug info. */ > In fact, the reason the code was checking for DW_TAG_compile_unit must be that > in the GCC/pre-standard version, the skeleton DIE in the executable is a > DW_TAG_compile_unit. With DWARF5, we'll see DW_TAG_skeleton_unit here. > > So I believe we should use > > (tag != DW_TAG_compile_unit && tag != DW_TAG_skeleton_unit) > > to cover both versions, GCC pre-standard and DWARF 5. Does that make sense? I agree that we need to check both cases in cu_debug_rnglists_section, because sometimes it gets called before the line above in cutu_reader, and sometimes it gets called after (now that I'm also calling it in dwarf2_rnglists_process). > Wherever we use the logic: > > int need_ranges_base = (die->tag != DW_TAG_compile_unit > && attr->form != DW_FORM_rnglistx); > > we should maybe check for DW_TAG_skeleton_unit as well?" I don't think there's any point in checking for DW_TAG_skeleton_unit in the need_ranges_base checks, because I believe that all of those checks are called after the call to cutu_reader, so we never have a DW_TAG_skeleton_unit by the time we get to those checks. Please review the updated, attached patch and let me know if it is ok now. Thanks! :-) -- Caroline cmtice@google.com gdb/ChangeLog 2020-07-14 Caroline Tice * dwarf2/read.c (RNGLIST_HEADER_SIZE32) New constant definition. (RNGLIST_HEADER_SIZE64): New constant definition. (struct dwop_section_names): Add rnglists_dwo. (dwop_section_names): Add .debug_rnglists.dwo, .zdebug_rnglists.dwo. (struct loclist_header): Rename to 'loclists_rnglists_header'. (struct dwo_sections): Add rnglists field. (read_attribut_reprocess): Add tag parameter. (dwarf2_ranges_read): Add tag parameter & remove forward function decl. (cu_debug_rnglists_section): New function (decl & definition). (dwarf2_locate_dwo_sections): Add code to read rnglists_dwo section. (dwarf2_rnglists_process): Add a dwarf_tag parameter, for the kind of die whose range is being checked; get rnglist section from cu_debug_rnglists_section, to get from either objfile or dwo file as appropriate. Add cases for DW_RLE_base_addressx, DW_RLE_startx_length, DW_RLE_startx_endx. Also, update to only add the base address to DW_RLE_offset_pairs (not to all ranges), moving test inside if-condition and updating complaint message. (dwarf2_ranges_process): Add dwarf tag parameter and pass it to dwarf2_rnglists_process. (dwarf2_ranges_read): Add dwarf tag parameter and pass it to dwarf2_ranges_process. (dwarf2_get_pc_bounds): Check for DW_FORM_rnglistx when setting need_ranges_base and update comment appropriately. Also pass die tag to dwarf2_ranges_read. (dwarf2_record_block_ranges): Check for DW_FORM_rnglistx when setting need_ranges_base and update comment appropriately. Also pass die tag to dwarf2_ranges_process. (read_full_die_1): Add code to read DW_AT_rnglists_base and assign to cu->ranges_base. Also pass die tag to read_attribute_reprocess. (partial_die_info::read): Check for DW_FORM_rnglistx when setting need_ranges_base and update comment appropriately. Also pass die tag to read_attribute_reprocess and dwarf2_ranges_read. (read_loclist_header): Rename function to read_loclists_rnglists_header, and update function comment appropriately. (read_loclist_index): Call read_loclists_rnglists_header instead of read_loclist_header. (read_rnglist_index): New function. (read_attribute_reprocess): Add tag parameter. Add code for DW_FORM_rnglistx, passing tag to read_rnglist_index. (read_attribute_value): Mark DW_FORM_rnglistx with need_reprocess. gdb/testsuite/ChangeLog: 2020-07-14 Caroline Tice * gdb.dwarf2/dw5-rnglist-test.cc: New file. * gdb.dwarf2/dw5-rnglist-test.exp: New file. -- Caroline cmtice@google.com On Sat, Jul 11, 2020 at 10:54 AM Simon Marchi wrote: > > > @@ -1378,12 +1387,13 @@ static void read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu); > > > > static void read_variable (struct die_info *die, struct dwarf2_cu *cu); > > > > -static int dwarf2_ranges_read (unsigned, CORE_ADDR *, CORE_ADDR *, > > - struct dwarf2_cu *, dwarf2_psymtab *); > > - > > /* Return the .debug_loclists section to use for cu. */ > > static struct dwarf2_section_info *cu_debug_loc_section (struct dwarf2_cu *cu); > > > > +/* Return the .debug_rnglists section to use for cu. */ > > +static struct dwarf2_section_info *cu_debug_rnglists_section > > +(struct dwarf2_cu *cu, dwarf_tag tag); > > Indent this last line with two spaces. > > > @@ -13802,17 +13817,33 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu, > > const gdb_byte *buffer; > > CORE_ADDR baseaddr; > > bool overflow = false; > > + ULONGEST addr_index; > > + bool ignore_dwo_unit = false; > > + struct dwarf2_section_info *rnglists_section; > > > > base = cu->base_address; > > > > - per_objfile->per_bfd->rnglists.read (objfile); > > - if (offset >= per_objfile->per_bfd->rnglists.size) > > + /* Make sure we read the .debug_rnglists section from the file that > > + contains the DW_AT_ranges attribute we are reading. Normally that > > + would be the .dwo file, if there is one. However for DW_TAG_compile_unit > > + we always want to read from objfile/linked program (which would be the > > + DW_TAG_skeleton_unit DIE if we're using split dwarf). */ > > + if (tag == DW_TAG_compile_unit) > > + ignore_dwo_unit = true; > > + > > + if (cu->dwo_unit != nullptr && !ignore_dwo_unit) > > + rnglists_section = &cu->dwo_unit->dwo_file->sections.rnglists; > > + else > > + rnglists_section = &per_objfile->per_bfd->rnglists; > > If think you can omit the `ignore_dwo_unit` variable and write this directly, > without loss of readability: > > if (cu->dwo_unit != nullptr && tag != DW_TAG_compile_unit) > > Also, should this use cu_debug_rnglists_section? > > > @@ -19094,13 +19184,65 @@ read_loclist_index (struct dwarf2_cu *cu, ULONGEST loclist_index) > > return bfd_get_64 (abfd, info_ptr) + loclist_base; > > } > > > > +/* Given a DW_FORM_rnglistx value rnglist_index, fetch the offset from the > > rnglist_index -> RNGLIST_INDEX > > > + array of offsets in the .debug_rnglists section. */ > > +static CORE_ADDR > > +read_rnglist_index (struct dwarf2_cu *cu, ULONGEST rnglist_index, > > + dwarf_tag tag) > > +{ > > + struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile; > > + struct objfile *objfile = dwarf2_per_objfile->objfile; > > + bfd *abfd = objfile->obfd; > > + ULONGEST rnglist_header_size = > > + (cu->header.initial_length_size == 4 ? RNGLIST_HEADER_SIZE32 > > + : RNGLIST_HEADER_SIZE64); > > + ULONGEST rnglist_base = > > + (cu->dwo_unit != nullptr) ? rnglist_header_size : cu->ranges_base; > > + ULONGEST start_offset = > > + rnglist_base + rnglist_index * cu->header.offset_size; > > + > > + /* Get rnglists section. */ > > + struct dwarf2_section_info *section = cu_debug_rnglists_section (cu, tag); > > + if (section == nullptr) > > + error (_("Cannot find .debug_rnglists section [in module %s]"), > > + objfile_name (objfile)); > > As of now, cu_debug_rnglists_section can't return nullptr. And I think it should > stay this way, it throws an error if it can't return a valid section. > > > + > > + /* Read the rnglists section content. */ > > + section->read (objfile); > > + if (section->buffer == nullptr) > > + error (_("DW_FORM_rnglistx used without .debug_rnglists section " > > + "[in module %s]"), > > + objfile_name (objfile)); > > Align `objfile_name` with the opening parenthesis. > > > + > > + /* Verify the rnglist header is valid (same as loclist header). */ > > Is this comment accurate? The code validates rnglist_index, not the header, right? > > > + struct loclist_header header; > > Rename this type `loclists_rnglists_header`, to match the function. > > > + read_loclists_rnglists_header (&header, section); > > + if (rnglist_index >= header.offset_entry_count) > > + error (_("DW_FORM_rnglistx index pointing outside of " > > + ".debug_rnglists offset array [in module %s]"), > > + objfile_name (objfile)); > > Same here. > > > + > > + /* Validate that the offset is within the section's range. */ > > + if (start_offset >= section->size) > > Pendantically, I suppose we should verify not only that the start_offset > is within the section's range, but also that there are enough bytes to read? > > For example, if we have a 100 bytes-long section, and start_offset is 99, we > won't be able to read 4 or 8 bytes. > > > + error (_("DW_FORM_rnglistx pointing outside of " > > + ".debug_rnglists section [in module %s]"), > > + objfile_name (objfile)); > > Same here. > > > > @@ -23383,6 +23530,30 @@ cu_debug_loc_section (struct dwarf2_cu *cu) > > : &per_objfile->per_bfd->loc); > > } > > > > +/* Return the .debug_rnglists section to use for CU. */ > > +static struct dwarf2_section_info * > > +cu_debug_rnglists_section (struct dwarf2_cu *cu, dwarf_tag tag) > > +{ > > + if (cu->header.version < 5) > > + error (_(".debug_rnglists section cannot be used in DWARF %d"), > > + cu->header.version); > > + struct dwarf2_per_objfile *dwarf2_per_objfile = cu->per_objfile; > > + > > + /* Make sure we read the .debug_rnglists section from the file that > > + contains the DW_AT_ranges attribute we are reading. Normally that > > + would be the .dwo file, if there is one. However for DW_TAG_compile_unit > > + we always want to read from objfile/linked program (which would be the > > + DW_TAG_skeleton_unit DIE if we're using split dwarf). */ > > + if (cu->dwo_unit != nullptr && tag != DW_TAG_compile_unit) > > + { > > + struct dwo_sections *sections = &cu->dwo_unit->dwo_file->sections; > > + > > + if (sections->rnglists.size > 0) > > + return §ions->rnglists; > > + } > > + return &dwarf2_per_objfile->per_bfd->rnglists; > > I expressed a concern about this earlier: if an attribute in the .dwo is of form > DW_FORM_rnglistx, but for some reason the .dwo has no .debug_rnglist section, what > happens? It seems to me like we're going to return the section from the executable, > which would be wrong. > > Also, I just debugged this function, and saw that it is called in this context: > > #0 cu_debug_rnglists_section (cu=0x615000026c80, tag=DW_TAG_skeleton_unit) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:23557 > #1 0x0000557c4612cde5 in read_rnglist_index (cu=0x615000026c80, rnglist_index=0, tag=DW_TAG_skeleton_unit) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:19205 > #2 0x0000557c4612d66e in read_attribute_reprocess (reader=0x7fffb47cf240, attr=0x621000186198, tag=DW_TAG_skeleton_unit) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:19258 > #3 0x0000557c4612152d in read_full_die_1 (reader=0x7fffb47cf240, diep=0x7fffb47cf280, info_ptr=0x60400001e8c0 "", num_extra_attrs=0) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:18253 > #4 0x0000557c461217d9 in read_full_die (reader=0x7fffb47cf240, diep=0x7fffb47cf280, info_ptr=0x60400001e8a4 "\001") at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:18268 > #5 0x0000557c46094af2 in cutu_reader::cutu_reader (this=0x7fffb47cf240, this_cu=0x621000183910, per_objfile=0x61300000a840, abbrev_table=0x60b00006ff30, existing_cu=0x0, skip_partial=false) at / > home/simark/src/binutils-gdb/gdb/dwarf2/read.c:7202 > #6 0x0000557c4609b0ca in process_psymtab_comp_unit (this_cu=0x621000183910, per_objfile=0x61300000a840, want_partial_unit=false, pretend_language=language_minimal) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:7667 > #7 0x0000557c460a0fd9 in dwarf2_build_psymtabs_hard (per_objfile=0x61300000a840) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:8051 > #8 0x0000557c46086ae3 in dwarf2_build_psymtabs (objfile=0x614000006440) at /home/simark/src/binutils-gdb/gdb/dwarf2/read.c:6106 > > As you can see, tag == DW_TAG_skeleton_unit. > > I thought that somehow, when reading a CU that uses a DWO, we were creating > a "logical" DIE tree by combining the DW_TAG_skeleton_unit DIE and the > children of the DWO's DW_TAG_compile_unit DIE, and while doing this, > overwriting the DW_TAG_skeleton_unit's DIE to use the DW_TAG_compile_unit > tag instead. Therefore making it appear to the rest of the DWARF reader > as if it was a "standard" DW_TAG_compile_unit DIE. But no, maybe I just dreamed > all of this, or I can't find it anymore. > > In fact, the reason the code was checking for DW_TAG_compile_unit must be that > in the GCC/pre-standard version, the skeleton DIE in the executable is a > DW_TAG_compile_unit. With DWARF5, we'll see DW_TAG_skeleton_unit here. > > So I believe we should use > > (tag != DW_TAG_compile_unit && tag != DW_TAG_skeleton_unit) > > to cover both versions, GCC pre-standard and DWARF 5. Does that make sense? > > Wherever we use the logic: > > int need_ranges_base = (die->tag != DW_TAG_compile_unit > && attr->form != DW_FORM_rnglistx); > > we should maybe check for DW_TAG_skeleton_unit as well? > > Simon --0000000000005b063c05aa68bbe2 Content-Type: application/octet-stream; name="v5-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Disposition: attachment; filename="v5-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kcm402d10 RnJvbSA3Mzg5MDFkZmQyOWNiNTQyNDY4NTU3Y2U4MDI0MzFjZGJiYTAxODlkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBDYXJvbGluZSBUaWNlIDxjbXRpY2VAZ29vZ2xlLmNvbT4KRGF0 ZTogV2VkLCAxIEp1bCAyMDIwIDEyOjM5OjA4IC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2NV0gVXBk YXRlIEdEQiB0byBmaXggaXNzdWVzIHdpdGggaGFuZGxpbmcgRFdBUkYgdjUgcm5nbGlzdHMgJgog LmR3byBmaWxlcy4KCldoaWxlIGV4cGVyaW1lbnRpbmcgd2l0aCBHREIgb24gRFdBUkYgNSB3aXRo IHNwbGl0IGRlYnVnIChkd28gZmlsZXMpLApJIGRpc2NvdmVyZWQgdGhhdCBHREIgd2FzIG5vdCBy ZWFkaW5nIHRoZSBybmdsaXN0IGluZGV4CnByb3Blcmx5IChpdCBuZWVkZWQgdG8gYmUgcmVwcm9j ZXNzZWQgaW4gdGhlIHNhbWUgd2F5IHRoZSBsb2NsaXN0CmluZGV4IGRvZXMpLCBhbmQgdGhhdCB0 aGVyZSB3YXMgbm8gY29kZSBmb3IgcmVhZGluZyBybmdsaXN0cyBvdXQgb2YKZHdvIGZpbGVzIGF0 IGFsbC4gIEFsc28sIHRoZSBybmdsaXN0IGFkZHJlc3MgcmVhZGluZyBmdW5jdGlvbgooZHdhcmYy X3JuZ2xpc3RzX3Byb2Nlc3MpIHdhcyBhZGRpbmcgdGhlIGJhc2UgYWRkcmVzcyB0byBhbGwgcm5n bGlzdAplbnRyaWVzLCB3aGVuIGl0J3Mgb25seSBzdXBwb3NlZCB0byBhZGQgaXQgdG8gdGhlIERX X1JMRV9vZmZzZXRfcGFpcgplbnRyaWVzIChodHRwOi8vZHdhcmZzdGQub3JnL2RvYy9EV0FSRjUu cGRmLCBwLiA1MyksIGFuZCB3YXMgbm90CmhhbmRsaW5nIHNldmVyYWwgZW50cnkgdHlwZXMuCgot IEFkZGVkICdyZXByb2Nlc3NpbmcnIGZvciByZWFkaW5nIHJuZ2xpc3QgaW5kZXggKGFzIGlzIGRv bmUgZm9yIGxvY2xpc3QKICBpbmRleCkuCi0gQWRkZWQgY29kZSBmb3IgcmVhZGluZyBybmdsaXN0 cyBvdXQgb2YgLmR3byBmaWxlcy4KLSBBZGRlZCBzZXZlcmFsIG1pc3Npbmcgcm5nbGlzdCBmb3Jt cyB0byBkd2FyZjJfcm5nbGlzdHNfcHJvY2Vzcy4KLSBGaXhlZCBidWcgdGhhdCB3YXMgYWx3YXlh cyBhZGRpbmcgYmFzZSBhZGRyZXNzIGZvciBybmdsaXN0cyAob25seQogIG9uZSBmb3JtIG5lZWRz IHRoYXQpLgotIFVwZGF0ZWQgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgdG8gcmVhZCBybmdsaXN0 IG91dCBvZiBkd28gZmlsZSB3aGVuCiAgYXBwcm9wcmlhdGUuCi0gQWRkZWQgbmV3IGZ1bmN0aW9u cyBjdV9kZWJ1Z19ybmdsaXN0X3NlY3Rpb24gJiByZWFkX3JuZ2xpc3RfaW5kZXguCi0gQWRkZWQg bmV3IHRlc3RjYXNlLCBkdzUtcm5nbGlzdC10ZXN0LntjYyxleHB9Ci0tLQogZ2RiL2R3YXJmMi9y ZWFkLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjYxICsrKysrKysrKysrKysrLS0t LQogZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MgIHwgIDk3ICsr KysrKysKIGdkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10ZXN0LmV4cCB8ICA0 MCArKysKIDMgZmlsZXMgY2hhbmdlZCwgMzUwIGluc2VydGlvbnMoKyksIDQ4IGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlz dC10ZXN0LmNjCiBjcmVhdGUgbW9kZSAxMDA2NDQgZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3 NS1ybmdsaXN0LXRlc3QuZXhwCgpkaWZmIC0tZ2l0IGEvZ2RiL2R3YXJmMi9yZWFkLmMgYi9nZGIv ZHdhcmYyL3JlYWQuYwppbmRleCA1NThmYWQ3NGY4Li4zOWVkNDU1ZGVmIDEwMDY0NAotLS0gYS9n ZGIvZHdhcmYyL3JlYWQuYworKysgYi9nZGIvZHdhcmYyL3JlYWQuYwpAQCAtMTMyLDYgKzEzMiwx MiBAQCBzdGF0aWMgaW50IGR3YXJmMl9sb2NsaXN0X2Jsb2NrX2luZGV4OwogLyogU2l6ZSBvZiAu ZGVidWdfbG9jbGlzdHMgc2VjdGlvbiBoZWFkZXIgZm9yIDY0LWJpdCBEV0FSRiBmb3JtYXQuICAq LwogI2RlZmluZSBMT0NMSVNUX0hFQURFUl9TSVpFNjQgMjAKIAorLyogU2l6ZSBvZiAuZGVidWdf cm5nbGlzdHMgc2VjdGlvbiBoZWFkZXIgZm9yIDMyLWJpdCBEV0FSRiBmb3JtYXQuICAqLworI2Rl ZmluZSBSTkdMSVNUX0hFQURFUl9TSVpFMzIgMTIKKworLyogU2l6ZSBvZiAuZGVidWdfcm5nbGlz dHMgc2VjdGlvbiBoZWFkZXIgZm9yIDY0LWJpdCBEV0FSRiBmb3JtYXQuICAqLworI2RlZmluZSBS TkdMSVNUX0hFQURFUl9TSVpFNjQgMjAKKwogLyogQW4gaW5kZXggaW50byBhIChDKyspIHN5bWJv bCBuYW1lIGNvbXBvbmVudCBpbiBhIHN5bWJvbCBuYW1lIGFzCiAgICByZWNvcmRlZCBpbiB0aGUg bWFwcGVkX2luZGV4J3Mgc3ltYm9sIHRhYmxlLiAgRm9yIGVhY2ggQysrIHN5bWJvbAogICAgaW4g dGhlIHN5bWJvbCB0YWJsZSwgd2UgcmVjb3JkIG9uZSBlbnRyeSBmb3IgdGhlIHN0YXJ0IG9mIGVh Y2gKQEAgLTM0MCw2ICszNDYsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGR3b3Bfc2VjdGlvbl9u YW1lcwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgbG9jbGlzdHNfZHdvOwogICBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgbWFjaW5mb19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2Vj dGlvbl9uYW1lcyBtYWNyb19kd287CisgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9uYW1lcyBybmds aXN0c19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9uYW1lcyBzdHJfZHdvOwogICBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgc3RyX29mZnNldHNfZHdvOwogICBzdHJ1Y3QgZHdhcmYy X3NlY3Rpb25fbmFtZXMgdHlwZXNfZHdvOwpAQCAtMzU1LDYgKzM2Miw3IEBAIGR3b3Bfc2VjdGlv bl9uYW1lcyA9CiAgIHsgIi5kZWJ1Z19sb2NsaXN0cy5kd28iLCAiLnpkZWJ1Z19sb2NsaXN0cy5k d28iIH0sCiAgIHsgIi5kZWJ1Z19tYWNpbmZvLmR3byIsICIuemRlYnVnX21hY2luZm8uZHdvIiB9 LAogICB7ICIuZGVidWdfbWFjcm8uZHdvIiwgIi56ZGVidWdfbWFjcm8uZHdvIiB9LAorICB7ICIu ZGVidWdfcm5nbGlzdHMuZHdvIiwgIi56ZGVidWdfcm5nbGlzdHMuZHdvIiB9LAogICB7ICIuZGVi dWdfc3RyLmR3byIsICIuemRlYnVnX3N0ci5kd28iIH0sCiAgIHsgIi5kZWJ1Z19zdHJfb2Zmc2V0 cy5kd28iLCAiLnpkZWJ1Z19zdHJfb2Zmc2V0cy5kd28iIH0sCiAgIHsgIi5kZWJ1Z190eXBlcy5k d28iLCAiLnpkZWJ1Z190eXBlcy5kd28iIH0sCkBAIC0zNjQsOSArMzcyLDkgQEAgZHdvcF9zZWN0 aW9uX25hbWVzID0KIAogLyogbG9jYWwgZGF0YSB0eXBlcyAqLwogCi0vKiBUaGUgbG9jYXRpb24g bGlzdCBzZWN0aW9uICguZGVidWdfbG9jbGlzdHMpIGJlZ2lucyB3aXRoIGEgaGVhZGVyLAotICAg d2hpY2ggY29udGFpbnMgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbi4gICovCi1zdHJ1Y3QgbG9j bGlzdF9oZWFkZXIKKy8qIFRoZSBsb2NhdGlvbiBsaXN0IGFuZCByYW5nZSBsaXN0IHNlY3Rpb25z ICguZGVidWdfbG9jbGlzdHMgJiAuZGVidWdfcm5nbGlzdHMpCisgICBiZWdpbiB3aXRoIGEgaGVh ZGVyLCAgd2hpY2ggY29udGFpbnMgdGhlIGZvbGxvd2luZyBpbmZvcm1hdGlvbi4gICovCitzdHJ1 Y3QgbG9jbGlzdHNfcm5nbGlzdHNfaGVhZGVyCiB7CiAgIC8qIEEgNC1ieXRlIG9yIDEyLWJ5dGUg bGVuZ3RoIGNvbnRhaW5pbmcgdGhlIGxlbmd0aCBvZiB0aGUKICAgICAgc2V0IG9mIGVudHJpZXMg Zm9yIHRoaXMgY29tcGlsYXRpb24gdW5pdCwgbm90IGluY2x1ZGluZyB0aGUKQEAgLTY1MCw2ICs2 NTgsNyBAQCBzdHJ1Y3QgZHdvX3NlY3Rpb25zCiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZv IGxvY2xpc3RzOwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyBtYWNpbmZvOwogICBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyBtYWNybzsKKyAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2lu Zm8gcm5nbGlzdHM7CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvIHN0cjsKICAgc3RydWN0 IGR3YXJmMl9zZWN0aW9uX2luZm8gc3RyX29mZnNldHM7CiAgIC8qIEluIHRoZSBjYXNlIG9mIGEg dmlydHVhbCBEV08gZmlsZSwgdGhlc2UgdHdvIGFyZSB1bnVzZWQuICAqLwpAQCAtMTI3NCw3ICsx MjgzLDcgQEAgc3RhdGljIGNvbnN0IGdkYl9ieXRlICpyZWFkX2F0dHJpYnV0ZSAoY29uc3Qgc3Ry dWN0IGRpZV9yZWFkZXJfc3BlY3MgKiwKIAkJCQkgICAgICAgY29uc3QgZ2RiX2J5dGUgKiwgYm9v bCAqbmVlZF9yZXByb2Nlc3MpOwogCiBzdGF0aWMgdm9pZCByZWFkX2F0dHJpYnV0ZV9yZXByb2Nl c3MgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCi0JCQkJICAgICAgc3Ry dWN0IGF0dHJpYnV0ZSAqYXR0cik7CisJCQkJICAgICAgc3RydWN0IGF0dHJpYnV0ZSAqYXR0ciwg ZHdhcmZfdGFnIHRhZyk7CiAKIHN0YXRpYyBDT1JFX0FERFIgcmVhZF9hZGRyX2luZGV4IChzdHJ1 Y3QgZHdhcmYyX2N1ICpjdSwgdW5zaWduZWQgaW50IGFkZHJfaW5kZXgpOwogCkBAIC0xMzc4LDEy ICsxMzg3LDEzIEBAIHN0YXRpYyB2b2lkIHJlYWRfY2FsbF9zaXRlX3Njb3BlIChzdHJ1Y3QgZGll X2luZm8gKmRpZSwgc3RydWN0IGR3YXJmMl9jdSAqY3UpOwogCiBzdGF0aWMgdm9pZCByZWFkX3Zh cmlhYmxlIChzdHJ1Y3QgZGllX2luZm8gKmRpZSwgc3RydWN0IGR3YXJmMl9jdSAqY3UpOwogCi1z dGF0aWMgaW50IGR3YXJmMl9yYW5nZXNfcmVhZCAodW5zaWduZWQsIENPUkVfQUREUiAqLCBDT1JF X0FERFIgKiwKLQkJCSAgICAgICBzdHJ1Y3QgZHdhcmYyX2N1ICosIGR3YXJmMl9wc3ltdGFiICop OwotCiAvKiBSZXR1cm4gdGhlIC5kZWJ1Z19sb2NsaXN0cyBzZWN0aW9uIHRvIHVzZSBmb3IgY3Uu ICAqLwogc3RhdGljIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvICpjdV9kZWJ1Z19sb2Nfc2Vj dGlvbiAoc3RydWN0IGR3YXJmMl9jdSAqY3UpOwogCisvKiBSZXR1cm4gdGhlIC5kZWJ1Z19ybmds aXN0cyBzZWN0aW9uIHRvIHVzZSBmb3IgY3UuICAqLworc3RhdGljIHN0cnVjdCBkd2FyZjJfc2Vj dGlvbl9pbmZvICpjdV9kZWJ1Z19ybmdsaXN0c19zZWN0aW9uCisgIChzdHJ1Y3QgZHdhcmYyX2N1 ICpjdSwgZHdhcmZfdGFnIHRhZyk7CisKIC8qIEhvdyBkd2FyZjJfZ2V0X3BjX2JvdW5kcyBjb25z dHJ1Y3RlZCBpdHMgKkxPV1BDIGFuZCAqSElHSFBDIHJldHVybgogICAgdmFsdWVzLiAgS2VlcCB0 aGUgaXRlbXMgb3JkZXJlZCB3aXRoIGluY3JlYXNpbmcgY29uc3RyYWludHMgY29tcGxpYW5jZS4g ICovCiBlbnVtIHBjX2JvdW5kc19raW5kCkBAIC0xMjQ0Nyw2ICsxMjQ1NywxMSBAQCBkd2FyZjJf bG9jYXRlX2R3b19zZWN0aW9ucyAoYmZkICphYmZkLCBhc2VjdGlvbiAqc2VjdHAsIHZvaWQgKmR3 b19zZWN0aW9uc19wdHIpCiAgICAgICBkd29fc2VjdGlvbnMtPm1hY3JvLnMuc2VjdGlvbiA9IHNl Y3RwOwogICAgICAgZHdvX3NlY3Rpb25zLT5tYWNyby5zaXplID0gYmZkX3NlY3Rpb25fc2l6ZSAo c2VjdHApOwogICAgIH0KKyAgZWxzZSBpZiAoc2VjdGlvbl9pc19wIChzZWN0cC0+bmFtZSwgJm5h bWVzLT5ybmdsaXN0c19kd28pKQorICAgIHsKKyAgICAgIGR3b19zZWN0aW9ucy0+cm5nbGlzdHMu cy5zZWN0aW9uID0gc2VjdHA7CisgICAgICBkd29fc2VjdGlvbnMtPnJuZ2xpc3RzLnNpemUgPSBi ZmRfc2VjdGlvbl9zaXplIChzZWN0cCk7CisgICAgfQogICBlbHNlIGlmIChzZWN0aW9uX2lzX3Ag KHNlY3RwLT5uYW1lLCAmbmFtZXMtPnN0cl9kd28pKQogICAgIHsKICAgICAgIGR3b19zZWN0aW9u cy0+c3RyLnMuc2VjdGlvbiA9IHNlY3RwOwpAQCAtMTM3OTEsNyArMTM4MDYsNyBAQCByZWFkX3Zh cmlhYmxlIChzdHJ1Y3QgZGllX2luZm8gKmRpZSwgc3RydWN0IGR3YXJmMl9jdSAqY3UpCiB0ZW1w bGF0ZSA8dHlwZW5hbWUgQ2FsbGJhY2s+CiBzdGF0aWMgYm9vbAogZHdhcmYyX3JuZ2xpc3RzX3By b2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCi0JCQkgQ2FsbGJh Y2sgJiZjYWxsYmFjaykKKwkJCSBkd2FyZl90YWcgdGFnLCBDYWxsYmFjayAmJmNhbGxiYWNrKQog ewogICBkd2FyZjJfcGVyX29iamZpbGUgKnBlcl9vYmpmaWxlID0gY3UtPnBlcl9vYmpmaWxlOwog ICBzdHJ1Y3Qgb2JqZmlsZSAqb2JqZmlsZSA9IHBlcl9vYmpmaWxlLT5vYmpmaWxlOwpAQCAtMTM4 MDEsMTcgKzEzODE2LDIwIEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZz ZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogICBjb25zdCBnZGJfYnl0ZSAqYnVmZmVyOwogICBD T1JFX0FERFIgYmFzZWFkZHI7CiAgIGJvb2wgb3ZlcmZsb3cgPSBmYWxzZTsKKyAgVUxPTkdFU1Qg YWRkcl9pbmRleDsKKyAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gKnJuZ2xpc3RzX3NlY3Rp b247CiAKICAgYmFzZSA9IGN1LT5iYXNlX2FkZHJlc3M7CisgIHJuZ2xpc3RzX3NlY3Rpb24gPSBj dV9kZWJ1Z19ybmdsaXN0c19zZWN0aW9uIChjdSwgdGFnKTsKKyAgcm5nbGlzdHNfc2VjdGlvbi0+ cmVhZCAob2JqZmlsZSk7CiAKLSAgcGVyX29iamZpbGUtPnBlcl9iZmQtPnJuZ2xpc3RzLnJlYWQg KG9iamZpbGUpOwotICBpZiAob2Zmc2V0ID49IHBlcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0 cy5zaXplKQorICBpZiAob2Zmc2V0ID49IHJuZ2xpc3RzX3NlY3Rpb24tPnNpemUpCiAgICAgewog ICAgICAgY29tcGxhaW50IChfKCJPZmZzZXQgJWQgb3V0IG9mIGJvdW5kcyBmb3IgRFdfQVRfcmFu Z2VzIGF0dHJpYnV0ZSIpLAogCQkgb2Zmc2V0KTsKICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9 Ci0gIGJ1ZmZlciA9IHBlcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0cy5idWZmZXIgKyBvZmZz ZXQ7CisgIGJ1ZmZlciA9IHJuZ2xpc3RzX3NlY3Rpb24tPmJ1ZmZlciArIG9mZnNldDsKIAogICBi YXNlYWRkciA9IG9iamZpbGUtPnRleHRfc2VjdGlvbl9vZmZzZXQgKCk7CiAKQEAgLTEzODE5LDgg KzEzODM3LDggQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3Ry dWN0IGR3YXJmMl9jdSAqY3UsCiAgICAgewogICAgICAgLyogSW5pdGlhbGl6ZSBpdCBkdWUgdG8g YSBmYWxzZSBjb21waWxlciB3YXJuaW5nLiAgKi8KICAgICAgIENPUkVfQUREUiByYW5nZV9iZWdp bm5pbmcgPSAwLCByYW5nZV9lbmQgPSAwOwotICAgICAgY29uc3QgZ2RiX2J5dGUgKmJ1Zl9lbmQg PSAocGVyX29iamZpbGUtPnBlcl9iZmQtPnJuZ2xpc3RzLmJ1ZmZlcgotCQkJCSArIHBlcl9vYmpm aWxlLT5wZXJfYmZkLT5ybmdsaXN0cy5zaXplKTsKKyAgICAgIGNvbnN0IGdkYl9ieXRlICpidWZf ZW5kID0gKHJuZ2xpc3RzX3NlY3Rpb24tPmJ1ZmZlcgorCQkJCSArIHJuZ2xpc3RzX3NlY3Rpb24t PnNpemUpOwogICAgICAgdW5zaWduZWQgaW50IGJ5dGVzX3JlYWQ7CiAKICAgICAgIGlmIChidWZm ZXIgPT0gYnVmX2VuZCkKQEAgLTEzODQyLDYgKzEzODYwLDExIEBAIGR3YXJmMl9ybmdsaXN0c19w cm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogCSAgYmFzZSA9 IGN1LT5oZWFkZXIucmVhZF9hZGRyZXNzIChvYmZkLCBidWZmZXIsICZieXRlc19yZWFkKTsKIAkg IGJ1ZmZlciArPSBieXRlc19yZWFkOwogCSAgYnJlYWs7CisgICAgICAgIGNhc2UgRFdfUkxFX2Jh c2VfYWRkcmVzc3g6CisgICAgICAgICAgYWRkcl9pbmRleCA9IHJlYWRfdW5zaWduZWRfbGViMTI4 IChvYmZkLCBidWZmZXIsICZieXRlc19yZWFkKTsKKyAgICAgICAgICBidWZmZXIgKz0gYnl0ZXNf cmVhZDsKKyAgICAgICAgICBiYXNlID0gcmVhZF9hZGRyX2luZGV4IChjdSwgYWRkcl9pbmRleCk7 CisgICAgICAgICAgYnJlYWs7CiAJY2FzZSBEV19STEVfc3RhcnRfbGVuZ3RoOgogCSAgaWYgKGJ1 ZmZlciArIGN1LT5oZWFkZXIuYWRkcl9zaXplID4gYnVmX2VuZCkKIAkgICAgewpAQCAtMTM4NjAs NiArMTM4ODMsMTkgQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwg c3RydWN0IGR3YXJmMl9jdSAqY3UsCiAJICAgICAgYnJlYWs7CiAJICAgIH0KIAkgIGJyZWFrOwor CWNhc2UgRFdfUkxFX3N0YXJ0eF9sZW5ndGg6CisgICAgICAgICAgYWRkcl9pbmRleCA9IHJlYWRf dW5zaWduZWRfbGViMTI4IChvYmZkLCBidWZmZXIsICZieXRlc19yZWFkKTsKKyAgICAgICAgICBi dWZmZXIgKz0gYnl0ZXNfcmVhZDsKKyAgICAgICAgICByYW5nZV9iZWdpbm5pbmcgPSByZWFkX2Fk ZHJfaW5kZXggKGN1LCBhZGRyX2luZGV4KTsKKyAgICAgICAgICBpZiAoYnVmZmVyID4gYnVmX2Vu ZCkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgb3ZlcmZsb3cgPSB0cnVlOworICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICByYW5nZV9lbmQgPSAocmFu Z2VfYmVnaW5uaW5nCisgICAgICAgICAgICAgICAgICAgICAgICsgcmVhZF91bnNpZ25lZF9sZWIx MjggKG9iZmQsIGJ1ZmZlciwgJmJ5dGVzX3JlYWQpKTsKKyAgICAgICAgICBidWZmZXIgKz0gYnl0 ZXNfcmVhZDsKKyAgICAgICAgICBicmVhazsKIAljYXNlIERXX1JMRV9vZmZzZXRfcGFpcjoKIAkg IHJhbmdlX2JlZ2lubmluZyA9IHJlYWRfdW5zaWduZWRfbGViMTI4IChvYmZkLCBidWZmZXIsICZi eXRlc19yZWFkKTsKIAkgIGJ1ZmZlciArPSBieXRlc19yZWFkOwpAQCAtMTM4ODgsNiArMTM5MjQs MTkgQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3 YXJmMl9jdSAqY3UsCiAJICByYW5nZV9lbmQgPSBjdS0+aGVhZGVyLnJlYWRfYWRkcmVzcyAob2Jm ZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CiAJICBidWZmZXIgKz0gYnl0ZXNfcmVhZDsKIAkgIGJy ZWFrOworCWNhc2UgRFdfUkxFX3N0YXJ0eF9lbmR4OgorICAgICAgICAgIGFkZHJfaW5kZXggPSBy ZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAgICAg ICAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgcmFuZ2VfYmVnaW5uaW5nID0gcmVh ZF9hZGRyX2luZGV4IChjdSwgYWRkcl9pbmRleCk7CisgICAgICAgICAgaWYgKGJ1ZmZlciA+IGJ1 Zl9lbmQpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgIG92ZXJmbG93ID0gdHJ1ZTsKKyAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgYWRkcl9pbmRleCA9 IHJlYWRfdW5zaWduZWRfbGViMTI4IChvYmZkLCBidWZmZXIsICZieXRlc19yZWFkKTsKKyAgICAg ICAgICBidWZmZXIgKz0gYnl0ZXNfcmVhZDsKKyAgICAgICAgICByYW5nZV9lbmQgPSByZWFkX2Fk ZHJfaW5kZXggKGN1LCBhZGRyX2luZGV4KTsKKyAgICAgICAgICBicmVhazsKIAlkZWZhdWx0Ogog CSAgY29tcGxhaW50IChfKCJJbnZhbGlkIC5kZWJ1Z19ybmdsaXN0cyBkYXRhIChubyBiYXNlIGFk ZHJlc3MpIikpOwogCSAgcmV0dXJuIGZhbHNlOwpAQCAtMTM4OTcsMTQgKzEzOTQ2LDYgQEAgZHdh cmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAq Y3UsCiAgICAgICBpZiAocmxldCA9PSBEV19STEVfYmFzZV9hZGRyZXNzKQogCWNvbnRpbnVlOwog Ci0gICAgICBpZiAoIWJhc2UuaGFzX3ZhbHVlICgpKQotCXsKLQkgIC8qIFdlIGhhdmUgbm8gdmFs aWQgYmFzZSBhZGRyZXNzIGZvciB0aGUgcmFuZ2VzCi0JICAgICBkYXRhLiAgKi8KLQkgIGNvbXBs YWludCAoXygiSW52YWxpZCAuZGVidWdfcm5nbGlzdHMgZGF0YSAobm8gYmFzZSBhZGRyZXNzKSIp KTsKLQkgIHJldHVybiBmYWxzZTsKLQl9Ci0KICAgICAgIGlmIChyYW5nZV9iZWdpbm5pbmcgPiBy YW5nZV9lbmQpCiAJewogCSAgLyogSW52ZXJ0ZWQgcmFuZ2UgZW50cmllcyBhcmUgaW52YWxpZC4g ICovCkBAIC0xMzkxNiw4ICsxMzk1NywyMCBAQCBkd2FyZjJfcm5nbGlzdHNfcHJvY2VzcyAodW5z aWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKICAgICAgIGlmIChyYW5nZV9iZWdp bm5pbmcgPT0gcmFuZ2VfZW5kKQogCWNvbnRpbnVlOwogCi0gICAgICByYW5nZV9iZWdpbm5pbmcg Kz0gKmJhc2U7Ci0gICAgICByYW5nZV9lbmQgKz0gKmJhc2U7CisgICAgICAvKiBPbmx5IERXX1JM RV9vZmZzZXRfcGFpciBuZWVkcyB0aGUgYmFzZSBhZGRyZXNzIGFkZGVkLiAgKi8KKyAgICAgIGlm IChybGV0ID09IERXX1JMRV9vZmZzZXRfcGFpcikKKwl7CisJICBpZiAoIWJhc2UuaGFzX3ZhbHVl ICgpKQorCSAgICB7CisJICAgICAgLyogV2UgaGF2ZSBubyB2YWxpZCBiYXNlIGFkZHJlc3MgZm9y IHRoZSBEV19STEVfb2Zmc2V0X3BhaXIuICAqLworCSAgICAgIGNvbXBsYWludCAoXygiSW52YWxp ZCAuZGVidWdfcm5nbGlzdHMgZGF0YSAobm8gYmFzZSBhZGRyZXNzIGZvciAiCisJCQkgICAiRFdf UkxFX29mZnNldF9wYWlyKSIpKTsKKwkgICAgICByZXR1cm4gZmFsc2U7CisJICAgIH0KKworCSAg cmFuZ2VfYmVnaW5uaW5nICs9ICpiYXNlOworCSAgcmFuZ2VfZW5kICs9ICpiYXNlOworCX0KIAog ICAgICAgLyogQSBub3QtdW5jb21tb24gY2FzZSBvZiBiYWQgZGVidWcgaW5mby4KIAkgRG9uJ3Qg cG9sbHV0ZSB0aGUgYWRkcm1hcCB3aXRoIGJhZCBkYXRhLiAgKi8KQEAgLTEzOTUwLDcgKzE0MDAz LDcgQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3 YXJmMl9jdSAqY3UsCiAKIHRlbXBsYXRlIDx0eXBlbmFtZSBDYWxsYmFjaz4KIHN0YXRpYyBpbnQK LWR3YXJmMl9yYW5nZXNfcHJvY2VzcyAodW5zaWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1 ICpjdSwKK2R3YXJmMl9yYW5nZXNfcHJvY2VzcyAodW5zaWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdh cmYyX2N1ICpjdSwgZHdhcmZfdGFnIHRhZywKIAkJICAgICAgIENhbGxiYWNrICYmY2FsbGJhY2sp CiB7CiAgIGR3YXJmMl9wZXJfb2JqZmlsZSAqcGVyX29iamZpbGUgPSBjdS0+cGVyX29iamZpbGU7 CkBAIC0xMzk2Niw3ICsxNDAxOSw3IEBAIGR3YXJmMl9yYW5nZXNfcHJvY2VzcyAodW5zaWduZWQg b2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKICAgQ09SRV9BRERSIGJhc2VhZGRyOwogCiAg IGlmIChjdV9oZWFkZXItPnZlcnNpb24gPj0gNSkKLSAgICByZXR1cm4gZHdhcmYyX3JuZ2xpc3Rz X3Byb2Nlc3MgKG9mZnNldCwgY3UsIGNhbGxiYWNrKTsKKyAgICByZXR1cm4gZHdhcmYyX3JuZ2xp c3RzX3Byb2Nlc3MgKG9mZnNldCwgY3UsIHRhZywgY2FsbGJhY2spOwogCiAgIGJhc2UgPSBjdS0+ YmFzZV9hZGRyZXNzOwogCkBAIC0xNDA1Miw3ICsxNDEwNSw3IEBAIGR3YXJmMl9yYW5nZXNfcHJv Y2VzcyAodW5zaWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKIHN0YXRpYyBpbnQK IGR3YXJmMl9yYW5nZXNfcmVhZCAodW5zaWduZWQgb2Zmc2V0LCBDT1JFX0FERFIgKmxvd19yZXR1 cm4sCiAJCSAgICBDT1JFX0FERFIgKmhpZ2hfcmV0dXJuLCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwK LQkJICAgIGR3YXJmMl9wc3ltdGFiICpyYW5nZXNfcHN0KQorCQkgICAgZHdhcmYyX3BzeW10YWIg KnJhbmdlc19wc3QsIGR3YXJmX3RhZyB0YWcpCiB7CiAgIHN0cnVjdCBvYmpmaWxlICpvYmpmaWxl ID0gY3UtPnBlcl9vYmpmaWxlLT5vYmpmaWxlOwogICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCA9 IG9iamZpbGUtPmFyY2ggKCk7CkBAIC0xNDA2Miw3ICsxNDExNSw3IEBAIGR3YXJmMl9yYW5nZXNf cmVhZCAodW5zaWduZWQgb2Zmc2V0LCBDT1JFX0FERFIgKmxvd19yZXR1cm4sCiAgIENPUkVfQURE UiBoaWdoID0gMDsKICAgaW50IHJldHZhbDsKIAotICByZXR2YWwgPSBkd2FyZjJfcmFuZ2VzX3By b2Nlc3MgKG9mZnNldCwgY3UsCisgIHJldHZhbCA9IGR3YXJmMl9yYW5nZXNfcHJvY2VzcyAob2Zm c2V0LCBjdSwgdGFnLAogICAgIFsmXSAoQ09SRV9BRERSIHJhbmdlX2JlZ2lubmluZywgQ09SRV9B RERSIHJhbmdlX2VuZCkKICAgICB7CiAgICAgICBpZiAocmFuZ2VzX3BzdCAhPSBOVUxMKQpAQCAt MTQxNTQsOCArMTQyMDcsMTQgQEAgZHdhcmYyX2dldF9wY19ib3VuZHMgKHN0cnVjdCBkaWVfaW5m byAqZGllLCBDT1JFX0FERFIgKmxvd3BjLAogCXsKIAkgIC8qIERXX0FUX3JuZ2xpc3RzX2Jhc2Ug ZG9lcyBub3QgYXBwbHkgdG8gRElFcyBmcm9tIHRoZSBEV08gc2tlbGV0b24uCiAJICAgICBXZSB0 YWtlIGFkdmFudGFnZSBvZiB0aGUgZmFjdCB0aGF0IERXX0FUX3JhbmdlcyBkb2VzIG5vdCBhcHBl YXIKLQkgICAgIGluIERXX1RBR19jb21waWxlX3VuaXQgb2YgRFdPIGZpbGVzLiAgKi8KLQkgIGlu dCBuZWVkX3Jhbmdlc19iYXNlID0gZGllLT50YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdDsKKwkg ICAgIGluIERXX1RBR19jb21waWxlX3VuaXQgb2YgRFdPIGZpbGVzLgorCisJICAgICBBdHRyaWJ1 dGVzIG9mIHRoZSBmb3JtIERXX0ZPUk1fcm5nbGlzdHggaGF2ZSBhbHJlYWR5IGhhZCB0aGVpcgor CSAgICAgdmFsdWUgY2hhbmdlZCBieSByZWFkX3JuZ2xpc3RfaW5kZXggYW5kIGFscmVhZHkgaW5j bHVkZQorCSAgICAgRFdfQVRfcm5nbGlzdHNfYmFzZSwgc28gZG9uJ3QgbmVlZCB0byBhZGQgdGhl IHJhbmdlcyBiYXNlLAorCSAgICAgZWl0aGVyLiAgKi8KKwkgIGludCBuZWVkX3Jhbmdlc19iYXNl ID0gKGRpZS0+dGFnICE9IERXX1RBR19jb21waWxlX3VuaXQKKwkJCQkgICYmIGF0dHItPmZvcm0g IT0gRFdfRk9STV9ybmdsaXN0eCk7CiAJICB1bnNpZ25lZCBpbnQgcmFuZ2VzX29mZnNldCA9IChE V19VTlNORCAoYXR0cikKIAkJCQkJKyAobmVlZF9yYW5nZXNfYmFzZQogCQkJCQkgICA/IGN1LT5y YW5nZXNfYmFzZQpAQCAtMTQxNjMsNyArMTQyMjIsOCBAQCBkd2FyZjJfZ2V0X3BjX2JvdW5kcyAo c3RydWN0IGRpZV9pbmZvICpkaWUsIENPUkVfQUREUiAqbG93cGMsCiAKIAkgIC8qIFZhbHVlIG9m IHRoZSBEV19BVF9yYW5nZXMgYXR0cmlidXRlIGlzIHRoZSBvZmZzZXQgaW4gdGhlCiAJICAgICAu ZGVidWdfcmFuZ2VzIHNlY3Rpb24uICAqLwotCSAgaWYgKCFkd2FyZjJfcmFuZ2VzX3JlYWQgKHJh bmdlc19vZmZzZXQsICZsb3csICZoaWdoLCBjdSwgcHN0KSkKKwkgIGlmICghZHdhcmYyX3Jhbmdl c19yZWFkIChyYW5nZXNfb2Zmc2V0LCAmbG93LCAmaGlnaCwgY3UsIHBzdCwKKwkJCQkgICBkaWUt PnRhZykpCiAJICAgIHJldHVybiBQQ19CT1VORFNfSU5WQUxJRDsKIAkgIC8qIEZvdW5kIGRpc2Nv bnRpbnVvdXMgcmFuZ2Ugb2YgYWRkcmVzc2VzLiAgKi8KIAkgIHJldCA9IFBDX0JPVU5EU19SQU5H RVM7CkBAIC0xNDMyNSw4ICsxNDM4NSwxNCBAQCBkd2FyZjJfcmVjb3JkX2Jsb2NrX3JhbmdlcyAo c3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBibG9jayAqYmxvY2ssCiAgICAgewogICAgICAg LyogRFdfQVRfcm5nbGlzdHNfYmFzZSBkb2VzIG5vdCBhcHBseSB0byBESUVzIGZyb20gdGhlIERX TyBza2VsZXRvbi4KIAkgV2UgdGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGZhY3QgdGhhdCBEV19BVF9y YW5nZXMgZG9lcyBub3QgYXBwZWFyCi0JIGluIERXX1RBR19jb21waWxlX3VuaXQgb2YgRFdPIGZp bGVzLiAgKi8KLSAgICAgIGludCBuZWVkX3Jhbmdlc19iYXNlID0gZGllLT50YWcgIT0gRFdfVEFH X2NvbXBpbGVfdW5pdDsKKwkgaW4gRFdfVEFHX2NvbXBpbGVfdW5pdCBvZiBEV08gZmlsZXMuCisK KwkgQXR0cmlidXRlcyBvZiB0aGUgZm9ybSBEV19GT1JNX3JuZ2xpc3R4IGhhdmUgYWxyZWFkeSBo YWQgdGhlaXIKKwkgdmFsdWUgY2hhbmdlZCBieSByZWFkX3JuZ2xpc3RfaW5kZXggYW5kIGFscmVh ZHkgaW5jbHVkZQorCSBEV19BVF9ybmdsaXN0c19iYXNlLCBzbyBkb24ndCBuZWVkIHRvIGFkZCB0 aGUgcmFuZ2VzIGJhc2UsCisJIGVpdGhlci4gICovCisgICAgICBpbnQgbmVlZF9yYW5nZXNfYmFz ZSA9IChkaWUtPnRhZyAhPSBEV19UQUdfY29tcGlsZV91bml0CisJCQkgICAgICAmJiBhdHRyLT5m b3JtICE9IERXX0ZPUk1fcm5nbGlzdHgpOwogCiAgICAgICAvKiBUaGUgdmFsdWUgb2YgdGhlIERX X0FUX3JhbmdlcyBhdHRyaWJ1dGUgaXMgdGhlIG9mZnNldCBvZiB0aGUKICAgICAgICAgIGFkZHJl c3MgcmFuZ2UgbGlzdCBpbiB0aGUgLmRlYnVnX3JhbmdlcyBzZWN0aW9uLiAgKi8KQEAgLTE0MzM0 LDcgKzE0NDAwLDcgQEAgZHdhcmYyX3JlY29yZF9ibG9ja19yYW5nZXMgKHN0cnVjdCBkaWVfaW5m byAqZGllLCBzdHJ1Y3QgYmxvY2sgKmJsb2NrLAogCQkJICAgICAgKyAobmVlZF9yYW5nZXNfYmFz ZSA/IGN1LT5yYW5nZXNfYmFzZSA6IDApKTsKIAogICAgICAgc3RkOjp2ZWN0b3I8YmxvY2tyYW5n ZT4gYmxvY2t2ZWM7Ci0gICAgICBkd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKG9mZnNldCwgY3UsCisg ICAgICBkd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKG9mZnNldCwgY3UsIGRpZS0+dGFnLAogCVsmXSAo Q09SRV9BRERSIHN0YXJ0LCBDT1JFX0FERFIgZW5kKQogCXsKIAkgIHN0YXJ0ICs9IGJhc2VhZGRy OwpAQCAtMTgxNTQsOCArMTgyMjAsMTMgQEAgcmVhZF9mdWxsX2RpZV8xIChjb25zdCBzdHJ1Y3Qg ZGllX3JlYWRlcl9zcGVjcyAqcmVhZGVyLAogICBhdXRvIG1heWJlX2FkZHJfYmFzZSA9IGRpZS0+ YWRkcl9iYXNlICgpOwogICBpZiAobWF5YmVfYWRkcl9iYXNlLmhhc192YWx1ZSAoKSkKICAgICBj dS0+YWRkcl9iYXNlID0gKm1heWJlX2FkZHJfYmFzZTsKKworICBhdHRyID0gZGllLT5hdHRyIChE V19BVF9ybmdsaXN0c19iYXNlKTsKKyAgaWYgKGF0dHIgIT0gbnVsbHB0cikKKyAgICBjdS0+cmFu Z2VzX2Jhc2UgPSBEV19VTlNORCAoYXR0cik7CisKICAgZm9yIChpbnQgaW5kZXggOiBpbmRleGVz X3RoYXRfbmVlZF9yZXByb2Nlc3MpCi0gICAgcmVhZF9hdHRyaWJ1dGVfcmVwcm9jZXNzIChyZWFk ZXIsICZkaWUtPmF0dHJzW2luZGV4XSk7CisgICAgcmVhZF9hdHRyaWJ1dGVfcmVwcm9jZXNzIChy ZWFkZXIsICZkaWUtPmF0dHJzW2luZGV4XSwgZGllLT50YWcpOwogICAqZGllcCA9IGRpZTsKICAg cmV0dXJuIGluZm9fcHRyOwogfQpAQCAtMTg1MjQsNyArMTg1OTUsNyBAQCBwYXJ0aWFsX2RpZV9p bmZvOjpyZWFkIChjb25zdCBzdHJ1Y3QgZGllX3JlYWRlcl9zcGVjcyAqcmVhZGVyLAogICAgICAg ICAgYWxyZWFkeSBiZWVuIHJlYWQgYXQgdGhpcyBwb2ludCwgc28gdGhlcmUgaXMgbm8gbmVlZCB0 byB3YWl0IHVudGlsCiAJIHRoZSBsb29wIHRlcm1pbmF0ZXMgdG8gZG8gdGhlIHJlcHJvY2Vzc2lu Zy4gICovCiAgICAgICBpZiAobmVlZF9yZXByb2Nlc3MpCi0JcmVhZF9hdHRyaWJ1dGVfcmVwcm9j ZXNzIChyZWFkZXIsICZhdHRyKTsKKwlyZWFkX2F0dHJpYnV0ZV9yZXByb2Nlc3MgKHJlYWRlciwg JmF0dHIsIHRhZyk7CiAgICAgICAvKiBTdG9yZSB0aGUgZGF0YSBpZiBpdCBpcyBvZiBhbiBhdHRy aWJ1dGUgd2Ugd2FudCB0byBrZWVwIGluIGEKICAgICAgICAgIHBhcnRpYWwgc3ltYm9sIHRhYmxl LiAgKi8KICAgICAgIHN3aXRjaCAoYXR0ci5uYW1lKQpAQCAtMTg2NzAsMTAgKzE4NzQxLDE2IEBA IHBhcnRpYWxfZGllX2luZm86OnJlYWQgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpy ZWFkZXIsCiAKIAljYXNlIERXX0FUX3JhbmdlczoKIAkgIHsKLQkgICAgLyogSXQgd291bGQgYmUg bmljZSB0byByZXVzZSBkd2FyZjJfZ2V0X3BjX2JvdW5kcyBoZXJlLAotCSAgICAgICBidXQgdGhh dCByZXF1aXJlcyBhIGZ1bGwgRElFLCBzbyBpbnN0ZWFkIHdlIGp1c3QKLQkgICAgICAgcmVpbXBs ZW1lbnQgaXQuICAqLwotCSAgICBpbnQgbmVlZF9yYW5nZXNfYmFzZSA9IHRhZyAhPSBEV19UQUdf Y29tcGlsZV91bml0OworCSAgICAvKiBEV19BVF9ybmdsaXN0c19iYXNlIGRvZXMgbm90IGFwcGx5 IHRvIERJRXMgZnJvbSB0aGUgRFdPCisJICAgICAgIHNrZWxldG9uLiAgV2UgdGFrZSBhZHZhbnRh Z2Ugb2YgdGhlIGZhY3QgdGhlIERXX0FUX3JhbmdlcworCSAgICAgICBkb2VzIG5vdCBhcHBlYXIg aW4gRFdfVEFHX2NvbXBpbGVfdW5pdCBvZiBEV08gZmlsZXMuCisKKwkgICAgICAgQXR0cmlidXRl cyBvZiB0aGUgZm9ybSBEV19GT1JNX3JuZ2xpc3R4IGhhdmUgYWxyZWFkeSBoYWQKKyAgICAgICAg ICAgICAgIHRoZWlyIHZhbHVlIGNoYW5nZWQgYnkgcmVhZF9ybmdsaXN0X2luZGV4IGFuZCBhbHJl YWR5CisJICAgICAgIGluY2x1ZGUgRFdfQVRfcm5nbGlzdHNfYmFzZSwgc28gZG9uJ3QgbmVlZCB0 byBhZGQgdGhlIHJhbmdlcworCSAgICAgICBiYXNlLCBlaXRoZXIuICAqLworCSAgICBpbnQgbmVl ZF9yYW5nZXNfYmFzZSA9ICh0YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdAorCQkJCSAgICAmJiBh dHRyLmZvcm0gIT0gRFdfRk9STV9ybmdsaXN0eCk7CiAJICAgIHVuc2lnbmVkIGludCByYW5nZXNf b2Zmc2V0ID0gKERXX1VOU05EICgmYXR0cikKIAkJCQkJICArIChuZWVkX3Jhbmdlc19iYXNlCiAJ CQkJCSAgICAgPyBjdS0+cmFuZ2VzX2Jhc2UKQEAgLTE4NjgyLDcgKzE4NzU5LDcgQEAgcGFydGlh bF9kaWVfaW5mbzo6cmVhZCAoY29uc3Qgc3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwK IAkgICAgLyogVmFsdWUgb2YgdGhlIERXX0FUX3JhbmdlcyBhdHRyaWJ1dGUgaXMgdGhlIG9mZnNl dCBpbiB0aGUKIAkgICAgICAgLmRlYnVnX3JhbmdlcyBzZWN0aW9uLiAgKi8KIAkgICAgaWYgKGR3 YXJmMl9yYW5nZXNfcmVhZCAocmFuZ2VzX29mZnNldCwgJmxvd3BjLCAmaGlnaHBjLCBjdSwKLQkJ CQkgICAgbnVsbHB0cikpCisJCQkJICAgIG51bGxwdHIsIHRhZykpCiAJICAgICAgaGFzX3BjX2lu Zm8gPSAxOwogCSAgfQogCSAgYnJlYWs7CkBAIC0xOTAwNiwxMSArMTkwODMsMTEgQEAgcGFydGlh bF9kaWVfaW5mbzo6Zml4dXAgKHN0cnVjdCBkd2FyZjJfY3UgKmN1KQogICBmaXh1cF9jYWxsZWQg PSAxOwogfQogCi0vKiBSZWFkIHRoZSAuZGVidWdfbG9jbGlzdHMgaGVhZGVyIGNvbnRlbnRzIGZy b20gdGhlIGdpdmVuIFNFQ1RJT04gaW4gdGhlCi0gICBIRUFERVIuICAqLworLyogUmVhZCB0aGUg LmRlYnVnX2xvY2xpc3RzIG9yIC5kZWJ1Z19ybmdsaXN0cyBoZWFkZXIgKHRoZXkgYXJlIHRoZSBz YW1lIGZvcm1hdCkKKyAgIGNvbnRlbnRzIGZyb20gdGhlIGdpdmVuIFNFQ1RJT04gaW4gdGhlIEhF QURFUi4gICovCiBzdGF0aWMgdm9pZAotcmVhZF9sb2NsaXN0X2hlYWRlciAoc3RydWN0IGxvY2xp c3RfaGVhZGVyICpoZWFkZXIsCi0JCSAgICAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvICpz ZWN0aW9uKQorcmVhZF9sb2NsaXN0c19ybmdsaXN0c19oZWFkZXIgKHN0cnVjdCBsb2NsaXN0c19y bmdsaXN0c19oZWFkZXIgKmhlYWRlciwKKwkJCSAgICAgICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25f aW5mbyAqc2VjdGlvbikKIHsKICAgdW5zaWduZWQgaW50IGJ5dGVzX3JlYWQ7CiAgIGJmZCAqYWJm ZCA9IHNlY3Rpb24tPmdldF9iZmRfb3duZXIgKCk7CkBAIC0xOTA2Myw4ICsxOTE0MCw4IEBAIHJl YWRfbG9jbGlzdF9pbmRleCAoc3RydWN0IGR3YXJmMl9jdSAqY3UsIFVMT05HRVNUIGxvY2xpc3Rf aW5kZXgpCiAgIGlmIChzZWN0aW9uLT5idWZmZXIgPT0gTlVMTCkKICAgICBjb21wbGFpbnQgKF8o IkRXX0ZPUk1fbG9jbGlzdHggdXNlZCB3aXRob3V0IC5kZWJ1Z19sb2NsaXN0cyAiCiAJICAgICAg ICAic2VjdGlvbiBbaW4gbW9kdWxlICVzXSIpLCBvYmpmaWxlX25hbWUgKG9iamZpbGUpKTsKLSAg c3RydWN0IGxvY2xpc3RfaGVhZGVyIGhlYWRlcjsKLSAgcmVhZF9sb2NsaXN0X2hlYWRlciAoJmhl YWRlciwgc2VjdGlvbik7CisgIHN0cnVjdCBsb2NsaXN0c19ybmdsaXN0c19oZWFkZXIgaGVhZGVy OworICByZWFkX2xvY2xpc3RzX3JuZ2xpc3RzX2hlYWRlciAoJmhlYWRlciwgc2VjdGlvbik7CiAg IGlmIChsb2NsaXN0X2luZGV4ID49IGhlYWRlci5vZmZzZXRfZW50cnlfY291bnQpCiAgICAgY29t cGxhaW50IChfKCJEV19GT1JNX2xvY2xpc3R4IHBvaW50aW5nIG91dHNpZGUgb2YgIgogCSAgICAg ICAgIi5kZWJ1Z19sb2NsaXN0cyBvZmZzZXQgYXJyYXkgW2luIG1vZHVsZSAlc10iKSwKQEAgLTE5 MDgzLDEzICsxOTE2MCw2OCBAQCByZWFkX2xvY2xpc3RfaW5kZXggKHN0cnVjdCBkd2FyZjJfY3Ug KmN1LCBVTE9OR0VTVCBsb2NsaXN0X2luZGV4KQogICAgIHJldHVybiBiZmRfZ2V0XzY0IChhYmZk LCBpbmZvX3B0cikgKyBsb2NsaXN0X2Jhc2U7CiB9CiAKKy8qIEdpdmVuIGEgRFdfRk9STV9ybmds aXN0eCB2YWx1ZSBSTkdMSVNUX0lOREVYLCBmZXRjaCB0aGUgb2Zmc2V0IGZyb20gdGhlCisgICBh cnJheSBvZiBvZmZzZXRzIGluIHRoZSAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbi4gICovCitzdGF0 aWMgQ09SRV9BRERSCityZWFkX3JuZ2xpc3RfaW5kZXggKHN0cnVjdCBkd2FyZjJfY3UgKmN1LCBV TE9OR0VTVCBybmdsaXN0X2luZGV4LAorCQkgICAgZHdhcmZfdGFnIHRhZykKK3sKKyAgc3RydWN0 IGR3YXJmMl9wZXJfb2JqZmlsZSAqZHdhcmYyX3Blcl9vYmpmaWxlID0gY3UtPnBlcl9vYmpmaWxl OworICBzdHJ1Y3Qgb2JqZmlsZSAqb2JqZmlsZSA9IGR3YXJmMl9wZXJfb2JqZmlsZS0+b2JqZmls ZTsKKyAgYmZkICphYmZkID0gb2JqZmlsZS0+b2JmZDsKKyAgVUxPTkdFU1Qgcm5nbGlzdF9oZWFk ZXJfc2l6ZSA9CisgICAgKGN1LT5oZWFkZXIuaW5pdGlhbF9sZW5ndGhfc2l6ZSA9PSA0ID8gUk5H TElTVF9IRUFERVJfU0laRTMyCisgICAgIDogUk5HTElTVF9IRUFERVJfU0laRTY0KTsKKyAgVUxP TkdFU1Qgcm5nbGlzdF9iYXNlID0KKyAgICAgIChjdS0+ZHdvX3VuaXQgIT0gbnVsbHB0cikgPyBy bmdsaXN0X2hlYWRlcl9zaXplIDogY3UtPnJhbmdlc19iYXNlOworICBVTE9OR0VTVCBzdGFydF9v ZmZzZXQgPQorICAgIHJuZ2xpc3RfYmFzZSArIHJuZ2xpc3RfaW5kZXggKiBjdS0+aGVhZGVyLm9m ZnNldF9zaXplOworCisgIC8qIEdldCBybmdsaXN0cyBzZWN0aW9uLiAgKi8KKyAgc3RydWN0IGR3 YXJmMl9zZWN0aW9uX2luZm8gKnNlY3Rpb24gPSBjdV9kZWJ1Z19ybmdsaXN0c19zZWN0aW9uIChj dSwgdGFnKTsKKworICAvKiBSZWFkIHRoZSBybmdsaXN0cyBzZWN0aW9uIGNvbnRlbnQuICAqLwor ICBzZWN0aW9uLT5yZWFkIChvYmpmaWxlKTsKKyAgaWYgKHNlY3Rpb24tPmJ1ZmZlciA9PSBudWxs cHRyKQorICAgIGVycm9yIChfKCJEV19GT1JNX3JuZ2xpc3R4IHVzZWQgd2l0aG91dCAuZGVidWdf cm5nbGlzdHMgc2VjdGlvbiAiCisJICAgICAiW2luIG1vZHVsZSAlc10iKSwKKwkgICBvYmpmaWxl X25hbWUgKG9iamZpbGUpKTsKKworICAvKiBWZXJpZnkgdGhlIHJuZ2xpc3QgaW5kZXggaXMgdmFs aWQuICAqLworICBzdHJ1Y3QgbG9jbGlzdHNfcm5nbGlzdHNfaGVhZGVyIGhlYWRlcjsKKyAgcmVh ZF9sb2NsaXN0c19ybmdsaXN0c19oZWFkZXIgKCZoZWFkZXIsIHNlY3Rpb24pOworICBpZiAocm5n bGlzdF9pbmRleCA+PSBoZWFkZXIub2Zmc2V0X2VudHJ5X2NvdW50KQorICAgIGVycm9yIChfKCJE V19GT1JNX3JuZ2xpc3R4IGluZGV4IHBvaW50aW5nIG91dHNpZGUgb2YgIgorCSAgICAgIi5kZWJ1 Z19ybmdsaXN0cyBvZmZzZXQgYXJyYXkgW2luIG1vZHVsZSAlc10iKSwKKwkgICBvYmpmaWxlX25h bWUgKG9iamZpbGUpKTsKKworICAvKiBWYWxpZGF0ZSB0aGF0IHRoZSBvZmZzZXQgaXMgd2l0aGlu IHRoZSBzZWN0aW9uJ3MgcmFuZ2UuICAqLworICBpZiAoc3RhcnRfb2Zmc2V0ID49IHNlY3Rpb24t PnNpemUpCisgICAgZXJyb3IgKF8oIkRXX0ZPUk1fcm5nbGlzdHggcG9pbnRpbmcgb3V0c2lkZSBv ZiAiCisgICAgICAgICAgICAgIi5kZWJ1Z19ybmdsaXN0cyBzZWN0aW9uIFtpbiBtb2R1bGUgJXNd IiksCisJICAgb2JqZmlsZV9uYW1lIChvYmpmaWxlKSk7CisKKyAgLyogVmFsaWRhdGUgdGhhdCBy ZWFkaW5nIHdvbid0IGdvIGJleW9uZCB0aGUgZW5kIG9mIHRoZSBzZWN0aW9uLiAgKi8KKyAgaWYg KHN0YXJ0X29mZnNldCArIGN1LT5oZWFkZXIub2Zmc2V0X3NpemUgPiBybmdsaXN0X2Jhc2UgKyBz ZWN0aW9uLT5zaXplKQorICAgIGVycm9yIChfKCJSZWFkaW5nIERXX0ZPUk1fcm5nbGlzdHggaW5k ZXggYmV5b25kIGVuZCBvZiIKKwkgICAgICIuZGVidWdfcm5nbGlzdHMgc2VjdGlvbiBbaW4gbW9k dWxlICVzXSIpLAorCSAgIG9iamZpbGVfbmFtZSAob2JqZmlsZSkpOworCisgIGNvbnN0IGdkYl9i eXRlICppbmZvX3B0ciA9IHNlY3Rpb24tPmJ1ZmZlciArIHN0YXJ0X29mZnNldDsKKworICBpZiAo Y3UtPmhlYWRlci5vZmZzZXRfc2l6ZSA9PSA0KQorICAgIHJldHVybiByZWFkXzRfYnl0ZXMgKGFi ZmQsIGluZm9fcHRyKSArIHJuZ2xpc3RfYmFzZTsKKyAgZWxzZQorICAgIHJldHVybiByZWFkXzhf Ynl0ZXMgKGFiZmQsIGluZm9fcHRyKSArIHJuZ2xpc3RfYmFzZTsKK30KKwogLyogUHJvY2VzcyB0 aGUgYXR0cmlidXRlcyB0aGF0IGhhZCB0byBiZSBza2lwcGVkIGluIHRoZSBmaXJzdCByb3VuZC4g VGhlc2UKICAgIGF0dHJpYnV0ZXMgYXJlIHRoZSBvbmVzIHRoYXQgbmVlZCBzdHJfb2Zmc2V0c19i YXNlIG9yIGFkZHJfYmFzZSBhdHRyaWJ1dGVzLgogICAgVGhleSBjb3VsZCBub3QgaGF2ZSBiZWVu IHByb2Nlc3NlZCBpbiB0aGUgZmlyc3Qgcm91bmQsIGJlY2F1c2UgYXQgdGhlIHRpbWUKICAgIHRo ZSB2YWx1ZXMgb2Ygc3RyX29mZnNldHNfYmFzZSBvciBhZGRyX2Jhc2UgbWF5IG5vdCBoYXZlIGJl ZW4ga25vd24uICAqLwogc3RhdGljIHZvaWQKIHJlYWRfYXR0cmlidXRlX3JlcHJvY2VzcyAoY29u c3Qgc3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwKLQkJCSAgc3RydWN0IGF0dHJpYnV0 ZSAqYXR0cikKKwkJCSAgc3RydWN0IGF0dHJpYnV0ZSAqYXR0ciwgZHdhcmZfdGFnIHRhZykKIHsK ICAgc3RydWN0IGR3YXJmMl9jdSAqY3UgPSByZWFkZXItPmN1OwogICBzd2l0Y2ggKGF0dHItPmZv cm0pCkBAIC0xOTEwMSw2ICsxOTIzMyw5IEBAIHJlYWRfYXR0cmlidXRlX3JlcHJvY2VzcyAoY29u c3Qgc3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwKICAgICAgIGNhc2UgRFdfRk9STV9s b2NsaXN0eDoKIAkgRFdfVU5TTkQgKGF0dHIpID0gcmVhZF9sb2NsaXN0X2luZGV4IChjdSwgRFdf VU5TTkQgKGF0dHIpKTsKIAkgYnJlYWs7CisgICAgICBjYXNlIERXX0ZPUk1fcm5nbGlzdHg6Cisg ICAgICAgIERXX1VOU05EIChhdHRyKSA9IHJlYWRfcm5nbGlzdF9pbmRleCAoY3UsIERXX1VOU05E IChhdHRyKSwgdGFnKTsKKyAgICAgICAgYnJlYWs7CiAgICAgICBjYXNlIERXX0ZPUk1fc3RyeDoK ICAgICAgIGNhc2UgRFdfRk9STV9zdHJ4MToKICAgICAgIGNhc2UgRFdfRk9STV9zdHJ4MjoKQEAg LTE5MjgyLDggKzE5NDE3LDEwIEBAIHJlYWRfYXR0cmlidXRlX3ZhbHVlIChjb25zdCBzdHJ1Y3Qg ZGllX3JlYWRlcl9zcGVjcyAqcmVhZGVyLAogICAgICAgRFdfU05EIChhdHRyKSA9IHJlYWRfc2ln bmVkX2xlYjEyOCAoYWJmZCwgaW5mb19wdHIsICZieXRlc19yZWFkKTsKICAgICAgIGluZm9fcHRy ICs9IGJ5dGVzX3JlYWQ7CiAgICAgICBicmVhazsKLSAgICBjYXNlIERXX0ZPUk1fdWRhdGE6CiAg ICAgY2FzZSBEV19GT1JNX3JuZ2xpc3R4OgorICAgICAgKm5lZWRfcmVwcm9jZXNzID0gdHJ1ZTsK KyAgICAgIC8qIEZBTExUSFJPVUdIICovCisgICAgY2FzZSBEV19GT1JNX3VkYXRhOgogICAgICAg RFdfVU5TTkQgKGF0dHIpID0gcmVhZF91bnNpZ25lZF9sZWIxMjggKGFiZmQsIGluZm9fcHRyLCAm Ynl0ZXNfcmVhZCk7CiAgICAgICBpbmZvX3B0ciArPSBieXRlc19yZWFkOwogICAgICAgYnJlYWs7 CkBAIC0yMzM3Miw2ICsyMzUwOSwzNCBAQCBjdV9kZWJ1Z19sb2Nfc2VjdGlvbiAoc3RydWN0IGR3 YXJmMl9jdSAqY3UpCiAJCQkJICA6ICZwZXJfb2JqZmlsZS0+cGVyX2JmZC0+bG9jKTsKIH0KIAor LyogUmV0dXJuIHRoZSAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbiB0byB1c2UgZm9yIENVLiAgKi8K K3N0YXRpYyBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyAqCitjdV9kZWJ1Z19ybmdsaXN0c19z ZWN0aW9uIChzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwgZHdhcmZfdGFnIHRhZykKK3sKKyAgaWYgKGN1 LT5oZWFkZXIudmVyc2lvbiA8IDUpCisgICAgZXJyb3IgKF8oIi5kZWJ1Z19ybmdsaXN0cyBzZWN0 aW9uIGNhbm5vdCBiZSB1c2VkIGluIERXQVJGICVkIiksCisJICAgY3UtPmhlYWRlci52ZXJzaW9u KTsKKyAgc3RydWN0IGR3YXJmMl9wZXJfb2JqZmlsZSAqZHdhcmYyX3Blcl9vYmpmaWxlID0gY3Ut PnBlcl9vYmpmaWxlOworCisgIC8qIE1ha2Ugc3VyZSB3ZSByZWFkIHRoZSAuZGVidWdfcm5nbGlz dHMgc2VjdGlvbiBmcm9tIHRoZSBmaWxlIHRoYXQKKyAgICAgY29udGFpbnMgdGhlIERXX0FUX3Jh bmdlcyBhdHRyaWJ1dGUgd2UgYXJlIHJlYWRpbmcuICBOb3JtYWxseSB0aGF0CisgICAgIHdvdWxk IGJlIHRoZSAuZHdvIGZpbGUsIGlmIHRoZXJlIGlzIG9uZS4gIEhvd2V2ZXIgZm9yIERXX1RBR19j b21waWxlX3VuaXQKKyAgICAgb3IgRFdfVEFHX3NrZWxldG9uIHVuaXQsIHdlIGFsd2F5cyB3YW50 IHRvIHJlYWQgZnJvbSBvYmpmaWxlL2xpbmtlZAorICAgICBwcm9ncmFtLiAgKi8KKyAgaWYgKGN1 LT5kd29fdW5pdCAhPSBudWxscHRyCisgICAgICAmJiB0YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5p dAorICAgICAgJiYgdGFnICE9IERXX1RBR19za2VsZXRvbl91bml0KQorICAgIHsKKyAgICAgIHN0 cnVjdCBkd29fc2VjdGlvbnMgKnNlY3Rpb25zID0gJmN1LT5kd29fdW5pdC0+ZHdvX2ZpbGUtPnNl Y3Rpb25zOworCisgICAgICBpZiAoc2VjdGlvbnMtPnJuZ2xpc3RzLnNpemUgPiAwKQorCXJldHVy biAmc2VjdGlvbnMtPnJuZ2xpc3RzOworICAgICAgZWxzZQorCWVycm9yIChfKCIuZGVidWdfcm5n bGlzdHMgc2VjdGlvbiBpcyBtaXNzaW5nIGZyb20gLmR3byBmaWxlLiIpKTsKKyAgICB9CisgIHJl dHVybiAmZHdhcmYyX3Blcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0czsKK30KKwogLyogQSBo ZWxwZXIgZnVuY3Rpb24gdGhhdCBmaWxscyBpbiBhIGR3YXJmMl9sb2NsaXN0X2JhdG9uLiAgKi8K IAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2dkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUt cm5nbGlzdC10ZXN0LmNjIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRl c3QuY2MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uODE2OTNmNTY5ZAot LS0gL2Rldi9udWxsCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10 ZXN0LmNjCkBAIC0wLDAgKzEsOTcgQEAKKy8qIFRoaXMgdGVzdGNhc2UgaXMgcGFydCBvZiBHREIs IHRoZSBHTlUgZGVidWdnZXIuCisKKyAgIENvcHlyaWdodCAyMDIwIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbiwgSW5jLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBG cmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2Us IG9yCisgICAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK KyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdh cnJhbnR5IG9mCisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UuICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9y ZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJ ZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisjaW5jbHVk ZSA8aW9zdHJlYW0+CisjaW5jbHVkZSA8dmVjdG9yPgorCitzdHJ1Y3Qgbm9kZSB7CisgIGludCBp ZDsKKyAgbm9kZSAqbGVmdDsKKyAgbm9kZSAqcmlnaHQ7CisgIGJvb2wgdmlzaXRlZDsKK307CisK K25vZGUgIG5vZGVfYXJyYXlbNTBdOwordW5zaWduZWQgaW50IENVUl9JRFggPSAwOworCitub2Rl ICoKK21ha2Vfbm9kZSAoaW50IHZhbCkKK3sKKyAgbm9kZSAqbmV3X25vZGUgPSAmKG5vZGVfYXJy YXlbQ1VSX0lEWCsrXSk7CisgIG5ld19ub2RlLT5sZWZ0ID0gTlVMTDsKKyAgbmV3X25vZGUtPnJp Z2h0ID0gTlVMTDsKKyAgbmV3X25vZGUtPmlkID0gdmFsOworICBuZXdfbm9kZS0+dmlzaXRlZCA9 IGZhbHNlOworCisgIHJldHVybiBuZXdfbm9kZTsKK30KKwordm9pZAordHJlZV9pbnNlcnQgKG5v ZGUgKnJvb3QsIGludCB2YWwpCit7CisgIGlmICh2YWwgPCByb290LT5pZCkKKyAgICB7CisgICAg ICBpZiAocm9vdC0+bGVmdCkKKyAgICAgICAgdHJlZV9pbnNlcnQgKHJvb3QtPmxlZnQsIHZhbCk7 CisgICAgICBlbHNlCisgICAgICAgIHJvb3QtPmxlZnQgPSBtYWtlX25vZGUodmFsKTsKKyAgICB9 CisgIGVsc2UgaWYgKHZhbCA+IHJvb3QtPmlkKQorICAgIHsKKyAgICAgIGlmIChyb290LT5yaWdo dCkKKyAgICAgICAgdHJlZV9pbnNlcnQgKHJvb3QtPnJpZ2h0LCB2YWwpOworICAgICAgZWxzZQor ICAgICAgICByb290LT5yaWdodCA9IG1ha2Vfbm9kZSh2YWwpOworICAgIH0KK30KKwordm9pZAor aW5vcmRlciAobm9kZSAqcm9vdCkKK3sKKyAgc3RkOjp2ZWN0b3I8bm9kZSAqPiB0b2RvOworICB0 b2RvLnB1c2hfYmFjayAocm9vdCk7CisgIHdoaWxlICghdG9kby5lbXB0eSgpKQorICAgIHsKKyAg ICAgIG5vZGUgKmN1cnIgPSB0b2RvLmJhY2soKTsKKyAgICAgIHRvZG8ucG9wX2JhY2soKTsgLyog YnJlYWstaGVyZSAqLworICAgICAgaWYgKGN1cnItPnZpc2l0ZWQpCisgICAgICAgIHN0ZDo6Y291 dCA8PCBjdXJyLT5pZCA8PCAiICI7CisgICAgICBlbHNlCisgICAgICAgIHsKKyAgICAgICAgICBj dXJyLT52aXNpdGVkID0gdHJ1ZTsKKyAgICAgICAgICBpZiAoY3Vyci0+cmlnaHQpCisgICAgICAg ICAgICB0b2RvLnB1c2hfYmFjayAoY3Vyci0+cmlnaHQpOworICAgICAgICAgIHRvZG8ucHVzaF9i YWNrIChjdXJyKTsKKyAgICAgICAgICBpZiAoY3Vyci0+bGVmdCkKKyAgICAgICAgICAgIHRvZG8u cHVzaF9iYWNrIChjdXJyLT5sZWZ0KTsKKyAgICAgICAgfQorICAgIH0KK30KKworaW50CittYWlu IChpbnQgYXJnYywgY2hhciAqKmFyZ3YpCit7CisgIG5vZGUgKnJvb3QgPSBtYWtlX25vZGUgKDM1 KTsKKworICB0cmVlX2luc2VydCAocm9vdCwgMjgpOworICB0cmVlX2luc2VydCAocm9vdCwgMjAp OworICB0cmVlX2luc2VydCAocm9vdCwgNjApOworCisgIGlub3JkZXIgKHJvb3QpOworCisgIHJl dHVybiAwOworfQpkaWZmIC0tZ2l0IGEvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmds aXN0LXRlc3QuZXhwIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3Qu ZXhwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmFmNmMzNGI1ZGQKLS0t IC9kZXYvbnVsbAorKysgYi9nZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjIvZHc1LXJuZ2xpc3QtdGVz dC5leHAKQEAgLTAsMCArMSw0MCBAQAorIyBDb3B5cmlnaHQgMjAyMCBGcmVlIFNvZnR3YXJlIEZv dW5kYXRpb24sIEluYy4KKworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNh biByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorIyBpdCB1bmRlciB0aGUgdGVybXMgb2Yg dGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorIyB0aGUgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBv cgorIyAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIworIyBUaGlzIHByb2dy YW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyMg YnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFu dHkgb2YKKyMgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRh aWxzLgorIworIyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwg c2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKworIyBDaGVjayB0aGF0IEdEQiBj YW4gZmluZCB0aGUgdmFyaWFibGVzIGluIGEgbGV4aWNhbCBibG9jayB3aXRoIGEKKyMgRFdfRk9S TV9ybmdsaXN0eCBEV19BVF9yYW5nZXMgZmllbGQuICBUaGlzIHRlc3QgaXMgaW50ZW5kZWQgZm9y IERXQVJGLTUsCisjIGNvbXBpbGVkIHdpdGggY2xhbmcrKy4KKworc3RhbmRhcmRfdGVzdGZpbGUg LmNjCisKKyMgVGhpcyB0ZXN0IGlzIGludGVuZGVkIGZvciB0YXJnZXRzIHdoaWNoIHN1cHBvcnQg RFdBUkYtNS4KKyMgU2luY2Ugd2UgcGFzcyBhbiBleHBsaWNpdCAtZ2R3YXJmLTUgdG8gdGhlIGNv bXBpbGVyLAorIyB3ZSBsZXQgdGhhdCBiZSB0aGUgdGVzdCBvZiB3aGV0aGVyIHRoZSB0YXJnZXQg c3VwcG9ydHMgaXQuCisKK2lmIHsgW3ByZXBhcmVfZm9yX3Rlc3RpbmcgImZhaWxlZCB0byBwcmVw YXJlIiAiJHt0ZXN0ZmlsZX0iIFwKKyAgICAgICAgICAkc3JjZmlsZSB7ZGVidWcgYysrIGFkZGl0 aW9uYWxfZmxhZ3M9LWdkd2FyZi01IFwKKyAgICAgICAgICAgICAgICAgICAgICAgIGFkZGl0aW9u YWxfZmxhZ3M9LU8wfV0gfSB7CisgICAgcmV0dXJuIC0xCit9CisKK2lmICFbcnVudG9fbWFpbl0g eworICAgIHJldHVybiAtMQorfQorCitnZGJfYnJlYWtwb2ludCBbZ2RiX2dldF9saW5lX251bWJl ciAiYnJlYWstaGVyZSJdCitnZGJfY29udGludWVfdG9fYnJlYWtwb2ludCAiYnJlYWstaGVyZSIg Ii4qIGJyZWFrLWhlcmUgLioiCisKK2dkYl90ZXN0ICJwcmludCBjdXJyIiAiXFxcKG5vZGUgXFxc KlxcXCkgJGhleCA8bm9kZV9hcnJheT4iCitnZGJfdGVzdCAicHJpbnQgKmN1cnIiICI9IHtpZCA9 IDM1LCBsZWZ0ID0gJGhleCA8bm9kZV9hcnJheVxcKyRkZWNpbWFsPiwgcmlnaHQgPSAkaGV4IDxu b2RlX2FycmF5XFwrJGRlY2ltYWw+LCB2aXNpdGVkID0gZmFsc2V9IgotLSAKMi4yNy4wLjM4OS5n YzM4ZDc2NjU4MTYtZ29vZwoK --0000000000005b063c05aa68bbe2--