From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-il1-x144.google.com (mail-il1-x144.google.com [IPv6:2607:f8b0:4864:20::144]) by sourceware.org (Postfix) with ESMTPS id 53FC8386F82D for ; Thu, 9 Jul 2020 15:48:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 53FC8386F82D Received: by mail-il1-x144.google.com with SMTP id t18so2441149ilh.2 for ; Thu, 09 Jul 2020 08:48:57 -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=HGKOQSipwmnd6LhHyruHqihEzw7evloB5yI7qONXZUg=; b=GQ/ti7DWM31KFXmq5rPH/eDTqlf3EDEsg8Fw8u+qmpOXeWQdIR6SeZicLDW++ggQ+Q 9WVuGge8Gzcwm+pGBKePBGJckECtJfyEYIdM4G/OBrFHfs8P4n0INMfknvvDwrohy21x qHcfL+TBwtj46EN+Nsv52nGx1QdhfP12Xvd+GEyNgJT8I6x1bJzqfKQfxWHkNnT1OO57 IpvTKkxU6JSNmJN9gWKxl5CTBfZ+XYBPjNT1CzjqYqDbIuyWmT9bIQoMPA+9aBmAfX1P 5lOIYyxO9eCbDge5ITNGRYkhC8S/rxcH7pTspOcmRM4m0uu60fpx6VqThLReAgM2dDuG /89Q== X-Gm-Message-State: AOAM533WQb11AfR1i50I0t9LmPvDhgqWnkv/LfGCqGjmQ5WkN+tlpXeK KKz27dpTt7jtpW4nXccbhE5Pw2PVAzScSD1OdGpzkirWIrs= X-Google-Smtp-Source: ABdhPJwjd08Xw0jRWx25B0toF01Et8Fc/FEu/f9KHzHAMSOu4lVwo2l+2bd6jpH2kZ5KcsPxm8N/xoojDBeOy9TsVNE= X-Received: by 2002:a92:d807:: with SMTP id y7mr46431290ilm.187.1594309736098; Thu, 09 Jul 2020 08:48:56 -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: <5ccfe911-6049-e8f3-4874-9991b2649512@simark.ca> From: Caroline Tice Date: Thu, 9 Jul 2020 08:48:44 -0700 Message-ID: Subject: Re: [PATCH V4] 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="0000000000007c158605aa042900" X-Spam-Status: No, score=-18.8 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, KAM_SHORT, 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: Thu, 09 Jul 2020 15:48:59 -0000 --0000000000007c158605aa042900 Content-Type: text/plain; charset="UTF-8" I think your description of how ranges work is correct. I've made all your requested changes (I think). Attached is the latest patch for review. :-) -- Caroline cmtice@google.com gdb/ChangeLog: 2020-07-09 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 dwo_sections): Add rnglists field. (read_attribut_reprocess): Add tag parameter. (dwarf2_ranges_read): Add tag parameter. (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; add code to read the rnglist section from the dwo file rather than from the main objfile, if 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_read. (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-09 Caroline Tice * gdb.dwarf2/dw5-rnglist-test.cc: New file. * gdb.dwarf2/dw5-rnglist-test.exp: New file. On Fri, Jul 3, 2020 at 10:11 PM Simon Marchi wrote: > > On 2020-07-03 6:47 p.m., Caroline Tice wrote: > > " > > > > I have made most of your requested changes, which are in the attached > > patch. I disagree with one of your comments, and I had a question > > about another: > > > > First the disagreement. You said: > > > >>> @@ -18684,7 +18764,8 @@ partial_die_info::read (const struct die_reader_specs *reader, > >>> /* It would be nice to reuse dwarf2_get_pc_bounds here, > >>> but that requires a full DIE, so instead we just > >>> reimplement it. */ > >>> - int need_ranges_base = tag != DW_TAG_compile_unit; > >>> + int need_ranges_base = (tag != DW_TAG_compile_unit > >>> + && attr.form != DW_FORM_rnglistx); > >> > >> It looks like this fix is unrelated from the rest of the patch, which deals > >> about reading rnglists from dwo files. It's better to have on fix per patch. > >> So I think this fix would deserve its own patch, with a commit message that > >> clearly explains the issue and the fix. > >> > > This is actually a required fix for dealing with rnglists. Without > > it, when the DW_AT_ranges uses the form > > DW_FORM_rnglistx, the wrong value is calculated and the entire rnglist > > is ignored (if you turn on complaints this will happen). So without > > this fix, I can't test any of the other code for fixing rnglists, with > > or without .dwo files. > > Ah ok, I must have understood it wrong then. I find all of this really confusing. > > I'll summarize what I think I understand, please let me know if I say anything wrong. > We are dealing with two similar ways of dealing with address ranges, one is the > pre-standard GNU version here, which was using DW_AT_GNU_ranges_base: > > https://gcc.gnu.org/wiki/DebugFission > > and the version in DWARF 5. > > In the pre-standard version, only one range section was present, and it was in the > main linked file. DW_AT_ranges attributes in the dwo, the form DW_FORM_sec_offset, > are actually pointing at the section in the main file, at offset > > CU's DW_AT_GNU_ranges_base value (found in the skeleton, in the main file) + DIE's DW_AT_ranges > > If there is a DW_AT_ranges attribute in the skeleton CU, in the main linked file, > then it is absolute, it is _not_ added to the DW_AT_GNU_ranges_base value. Hence > the `needs_range_base` thingy. The `ranges_offset` variable in this function is > the direct offset to the range list to read. > > In DWARF 5, we have a ranges section in the main linked file and one in the dwo. DW_AT_ranges > attributes refer to the ranges section of the file they are in. The DW_AT_rnglists_base > points to the beginning of the range table for that CU. The actual value of DW_AT_ranges > attribute (when using the DW_FORM_rnglistx form) is an index in the offset table. However, > due to the reprocessing you added in this patch, the attribute value is now in fact the > offset with `DW_AT_rnglists_base` already added. And _that's_ the reason why > DW_FORM_rnglistx attributes should not have the range base applied. > > I think the comment above in the code is misleading and needs to be updated, this one: > > /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton. > We take advantage of the fact that DW_AT_ranges does not appear > in DW_TAG_compile_unit of DWO files. */ > > In commit 18a8505e38fc ("Dwarf 5: Handle debug_str_offsets and indexed attributes > that have base offsets."), the it was changed like so: > > - /* DW_AT_ranges_base does not apply to DIEs from the DWO skeleton. > + /* DW_AT_rnglists_base does not apply to DIEs from the DWO skeleton. > > I think it was a wrong change, because it mixes two different things. DW_AT_rnglists_base > is a DWARF 5 thing, and the range base not applying to the values from the skeleton is a > pre-standard thing. I think it should say something like: > > /* DW_AT_GNU_ranges_base does not apply to DIEs from the DWO skeleton. > We take advantage of the fact that DW_AT_ranges does not appear > in DW_TAG_compile_unit of DWO files. > > Attributes of form DW_AT_rnglistx have already had their value changed > by read_rnglist_index and already include DW_AT_rnglists_base, so don't > add the ranges base either. */ > > > > >> I'm also not sure I understand it: when the form is DW_FORM_rnglistx, don't > >> we want to sometimes apply the base coming from DW_AT_rnglists_base? > > > > It all depends on what form is being used. If the DW_AT_ranges is > > using DW_FORM_sec_offset (which is what > > GCC generates), then you do need to add the base value.But if you > > are using the DW_FORM_rnglisx (which is what clang generates), the > > base value has already been considered/incorporated into the attribute > > so adding it in (again) causes the value to be incorrect (again, turn > > on complaints and see what happens if you try to add the base into > > something with DW_FORM_rnglistx). From the DWARF5 spec: "[A] rnglist > > is either represented as: An index into the .debug_rnglists section > > (DW_FORM_rnglistx). The ...operand identifies an offset location > > relative to the base of that section...[or] An offset into the > > .debug_rnglists section (DW_FORM_sec_offset). The operand consists of > > a byte offset from the beginning of the .debug_rnglists section." > > Note the DW_FORM_rnglistx is already relative to the base. > > Ok. What was not clear to me in the first pass was that read_rnglist_index > already has modified the attribute value to include DW_AT_rnglists_base. > > Now, about values of class rnglist and form DW_FORM_sec_offset in DWARF 5. > The spec says this about them: > > - An offset into the .debug_rnglists section (DW_FORM_sec_offset). > The operand consists of a byte offset from the beginning of the > .debug_rnglists section. It is relocatable in a relocatable object file, > and relocated in an executable or shared object file. In the 32-bit > DWARF format, this offset is a 4-byte unsigned value; in the 64-bit > DWARF format, it is an 8-byte unsigned value (see Section 7.4 on > page 196). > > Since it says that the value is already relocated in an executable, does it > mean we should not add the base for these, in DWARF 5? > > > Now, my question: I'm not quite clear as to whether you really want > > me to change the code in > > cu_debug_rnglists_section or not. I wrote the code mostly by copying > > the code for loclists as closely as possible, and making whatever > > changes to that were required to make it correct for rnglists. Is it > > better to have the code more consistent with the loclists code?If > > you really want me to make the changes there you suggest, then I will; > > I think the situation is a bit different than for `cu_debug_loc_section`: > when you have a dwo, I don't think there is the possibility of having an > attribute referring to a location list in the skeleton. So if you have a > dwo, you'll always want the loc section from the dwo. So there, the pattern > > if (there is a dwo) > return the dwo section; > > return the main file section; > > makes more sense. But in the case of range lists, we have attributes > in both the skeleton and the dwo that require range lists, and the right > section to return depends on where the attribute is. That's why, when I > see this pattern: > > if (there is a dwo) > return the dwo section; > > return the main file section; > > that pattern, I find it looks wrong, because the right section to return > does not depend (only) on whether there is dwo. As we saw, it only works > "by chance" because this is only called once for the skeleton (when > reading DW_AT_ranges) and the `cu->dwo_unit` pointer happens not to be set > up yet. It is also one refactor away from breaking, if for some reason we > reorder some code and the `cu->dwo_unit` pointer gets initialized earlier. > > > I just wanted confirmation that you really want that change (i.e. > > adding the dwarf tag and checking vs. DW_TAG_compile_unit, & calling > > it from dwarf2_rnglists_process). > > I think that checking DW_TAG_compile_unit is still a bit of a hack - ideally, > the caller could just tell us if the DIE comes from a dwo or not. But at > least it's logical and based on some DWARF knowledge. It would certainly > require a comment to explain it, because it wouldn't be obvious. > > > @@ -1379,11 +1382,16 @@ 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 *); > > + struct dwarf2_cu *, dwarf2_psymtab *, > > + dwarf_tag); > > This declaration is unneeded and can simply be removed. Could you push an > obvious patch that does this?. > > > > @@ -13917,8 +13969,20 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu, > > if (range_beginning == range_end) > > continue; > > > > - range_beginning += *base; > > - range_end += *base; > > + /* Only DW_RLE_offset_pair needs the base address added. */ > > + if (rlet == DW_RLE_offset_pair) > > + { > > + if (!base.has_value ()) > > + { > > + /* We have no valid base address for the ranges > > + data. */ > > + complaint (_("Invalid .debug_rnglists data (no base address)")); > > The comment fits on a single line. But it can probably be changed to be more > specific to DW_RLE_offset_pair. Maybe the complaint could be more specific too, > and mention DW_RLE_offset_pair. It would be valid to have .debug_rnglists without > a base address (I think?), but here it's invalid because there is not base address > _and_ we have encountered a DW_RLE_offset_pair. > > > @@ -19094,6 +19167,57 @@ 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 > > + array of offsets in the .debug_rnglists section. */ > > +static CORE_ADDR > > +read_rnglist_index (struct dwarf2_cu *cu, ULONGEST rnglist_index) > > +{ > > + 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 ? LOCLIST_HEADER_SIZE32 > > + : LOCLIST_HEADER_SIZE64); > > Should this really refer to loclist header sizes? If they are the same > sizes as range list table headers, I suppose it's just a coincidence. > > > + ULONGEST rnglist_base = > > + (cu->dwo_unit) ? rnglist_header_size : cu->ranges_base; > > cu->dwo_unit != nullptr > > > + ULONGEST start_offset = > > + rnglist_base + rnglist_index * cu->header.offset_size; > > + > > + /* Get rnglists section. */ > > + struct dwarf2_section_info *section = cu_debug_rnglists_section (cu); > > + if (section == nullptr) > > + error (_("Cannot find .debug_rnglists section [in module %s]"), > > + objfile_name(objfile)); > > Space before paren. > > > + > > + /* Read the rnglists section content. */ > > + section->read (objfile); > > + if (section->buffer == NULL) > > In new code, I suggest using nullptr instead of NULL, just for consistency. > > > + error (_("DW_FORM_rnglistx used without .debug_rnglists section " > > + "[in module %s]"), > > + objfile_name (objfile)); > > + > > + /* Verify the rnglist header is valid (same as loclist header). */ > > + struct loclist_header header; > > + read_loclist_header (&header, section); > > Ok well, if we are going to take advantage that they are the same, the name > of the function and types should reflect it. `read_loclist_header` should > become `read_loclists_rnglists_header` (using the plural to match the section > names). > > > + 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)); > > Space before paren. > > > + > > + /* Validate that the offset is within the section's range. */ > > + if (start_offset >= section->size) > > + error (_("DW_FORM_rnglistx pointing outside of " > > + ".debug_rnglists section [in module %s]"), > > + objfile_name(objfile)); > > + > > + const gdb_byte *info_ptr = section->buffer + start_offset; > > + > > + if (cu->header.offset_size == 4) > > + return read_4_bytes (abfd, info_ptr) + rnglist_base; > > + else > > + return read_8_bytes (abfd, info_ptr) + rnglist_base; > > An idea for a subsequent cleanup, we could have a `read_offset` function > that does > > if (cu->header.offset_size == 4) > return read_4_bytes (abfd, info_ptr); > else > return read_8_bytes (abfd, info_ptr); > > There are a few spots that could use it. > > Simon --0000000000007c158605aa042900 Content-Type: application/octet-stream; name="v4-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Disposition: attachment; filename="v4-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kceyuckj0 RnJvbSBmODg5NzJkNzVlYzdkNmI1ZWZjNTk2ZWQ4ZjMxNmQxNDFmYmFmZmZhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBDYXJvbGluZSBUaWNlIDxjbXRpY2VAZ29vZ2xlLmNvbT4KRGF0 ZTogV2VkLCAxIEp1bCAyMDIwIDEyOjM5OjA4IC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2NF0gVXBk YXRlIEdEQiB0byBmaXggaXNzdWVzIHdpdGggaGFuZGxpbmcgRFdBUkYgdjUgcm5nbGlzdHMgJgog LmR3byBmaWxlcy4KCldoaWxlIGV4cGVyaW1lbnRpbmcgd2l0aCBHREIgb24gRFdBUkYgNSB3aXRo IHNwbGl0IGRlYnVnIChkd28gZmlsZXMpLApJIGRpc2NvdmVyZWQgdGhhdCBHREIgd2FzIG5vdCBy ZWFkaW5nIHRoZSBybmdsaXN0IGluZGV4CnByb3Blcmx5IChpdCBuZWVkZWQgdG8gYmUgcmVwcm9j ZXNzZWQgaW4gdGhlIHNhbWUgd2F5IHRoZSBsb2NsaXN0CmluZGV4IGRvZXMpLCBhbmQgdGhhdCB0 aGVyZSB3YXMgbm8gY29kZSBmb3IgcmVhZGluZyBybmdsaXN0cyBvdXQgb2YKZHdvIGZpbGVzIGF0 IGFsbC4gIEFsc28sIHRoZSBybmdsaXN0IGFkZHJlc3MgcmVhZGluZyBmdW5jdGlvbgooZHdhcmYy X3JuZ2xpc3RzX3Byb2Nlc3MpIHdhcyBhZGRpbmcgdGhlIGJhc2UgYWRkcmVzcyB0byBhbGwgcm5n bGlzdAplbnRyaWVzLCB3aGVuIGl0J3Mgb25seSBzdXBwb3NlZCB0byBhZGQgaXQgdG8gdGhlIERX X1JMRV9vZmZzZXRfcGFpcgplbnRyaWVzIChodHRwOi8vZHdhcmZzdGQub3JnL2RvYy9EV0FSRjUu cGRmLCBwLiA1MyksIGFuZCB3YXMgbm90CmhhbmRsaW5nIHNldmVyYWwgZW50cnkgdHlwZXMuCgot IEFkZGVkICdyZXByb2Nlc3NpbmcnIGZvciByZWFkaW5nIHJuZ2xpc3QgaW5kZXggKGFzIGlzIGRv bmUgZm9yIGxvY2xpc3QKICBpbmRleCkuCi0gQWRkZWQgY29kZSBmb3IgcmVhZGluZyBybmdsaXN0 cyBvdXQgb2YgLmR3byBmaWxlcy4KLSBBZGRlZCBzZXZlcmFsIG1pc3Npbmcgcm5nbGlzdCBmb3Jt cyB0byBkd2FyZjJfcm5nbGlzdHNfcHJvY2Vzcy4KLSBGaXhlZCBidWcgdGhhdCB3YXMgYWx3YXlh cyBhZGRpbmcgYmFzZSBhZGRyZXNzIGZvciBybmdsaXN0cyAob25seQogIG9uZSBmb3JtIG5lZWRz IHRoYXQpLgotIFVwZGF0ZWQgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgdG8gcmVhZCBybmdsaXN0 IG91dCBvZiBkd28gZmlsZSB3aGVuCiAgYXBwcm9wcmlhdGUuCi0gQWRkZWQgbmV3IGZ1bmN0aW9u cyBjdV9kZWJ1Z19ybmdsaXN0X3NlY3Rpb24gJiByZWFkX3JuZ2xpc3RfaW5kZXguCi0gQWRkZWQg bmV3IHRlc3RjYXNlLCBkdzUtcm5nbGlzdC10ZXN0LntjYyxleHB9Ci0tLQogZ2RiL2R3YXJmMi9y ZWFkLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjU5ICsrKysrKysrKysrKysrKy0t LQogZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MgIHwgIDk3ICsr KysrKysKIGdkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10ZXN0LmV4cCB8ICA0 MCArKysKIDMgZmlsZXMgY2hhbmdlZCwgMzUyIGluc2VydGlvbnMoKyksIDQ0IGRlbGV0aW9ucygt KQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlz dC10ZXN0LmNjCiBjcmVhdGUgbW9kZSAxMDA2NDQgZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3 NS1ybmdsaXN0LXRlc3QuZXhwCgpkaWZmIC0tZ2l0IGEvZ2RiL2R3YXJmMi9yZWFkLmMgYi9nZGIv ZHdhcmYyL3JlYWQuYwppbmRleCA0MDViNWZiMzM0Li5iMWY1NGZiOGJmIDEwMDY0NAotLS0gYS9n ZGIvZHdhcmYyL3JlYWQuYworKysgYi9nZGIvZHdhcmYyL3JlYWQuYwpAQCAtMTMyLDYgKzEzMiwx MiBAQCBzdGF0aWMgaW50IGR3YXJmMl9sb2NsaXN0X2Jsb2NrX2luZGV4OwogLyogU2l6ZSBvZiAu ZGVidWdfbG9jbGlzdHMgc2VjdGlvbiBoZWFkZXIgZm9yIDY0LWJpdCBEV0FSRiBmb3JtYXQuICAq LwogI2RlZmluZSBMT0NMSVNUX0hFQURFUl9TSVpFNjQgMjAKIAorLyogU2l6ZSBvZiAuZGVidWdf cm5nbGlzdHMgc2VjdGlvbiBoZWFkZXIgZm9yIDMyLWJpdCBEV0FSRiBmb3JtYXQuICAqLworI2Rl ZmluZSBSTkdMSVNUX0hFQURFUl9TSVpFMzIgMTIKKworLyogU2l6ZSBvZiAuZGVidWdfcm5nbGlz dHMgc2VjdGlvbiBoZWFkZXIgZm9yIDY0LWJpdCBEV0FSRiBmb3JtYXQuICAqLworI2RlZmluZSBS TkdMSVNUX0hFQURFUl9TSVpFNjQgMjAKKwogLyogQW4gaW5kZXggaW50byBhIChDKyspIHN5bWJv bCBuYW1lIGNvbXBvbmVudCBpbiBhIHN5bWJvbCBuYW1lIGFzCiAgICByZWNvcmRlZCBpbiB0aGUg bWFwcGVkX2luZGV4J3Mgc3ltYm9sIHRhYmxlLiAgRm9yIGVhY2ggQysrIHN5bWJvbAogICAgaW4g dGhlIHN5bWJvbCB0YWJsZSwgd2UgcmVjb3JkIG9uZSBlbnRyeSBmb3IgdGhlIHN0YXJ0IG9mIGVh Y2gKQEAgLTM0MCw2ICszNDYsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGR3b3Bfc2VjdGlvbl9u YW1lcwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgbG9jbGlzdHNfZHdvOwogICBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgbWFjaW5mb19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2Vj dGlvbl9uYW1lcyBtYWNyb19kd287CisgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9uYW1lcyBybmds aXN0c19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9uYW1lcyBzdHJfZHdvOwogICBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25fbmFtZXMgc3RyX29mZnNldHNfZHdvOwogICBzdHJ1Y3QgZHdhcmYy X3NlY3Rpb25fbmFtZXMgdHlwZXNfZHdvOwpAQCAtMzU1LDYgKzM2Miw3IEBAIGR3b3Bfc2VjdGlv bl9uYW1lcyA9CiAgIHsgIi5kZWJ1Z19sb2NsaXN0cy5kd28iLCAiLnpkZWJ1Z19sb2NsaXN0cy5k d28iIH0sCiAgIHsgIi5kZWJ1Z19tYWNpbmZvLmR3byIsICIuemRlYnVnX21hY2luZm8uZHdvIiB9 LAogICB7ICIuZGVidWdfbWFjcm8uZHdvIiwgIi56ZGVidWdfbWFjcm8uZHdvIiB9LAorICB7ICIu ZGVidWdfcm5nbGlzdHMuZHdvIiwgIi56ZGVidWdfcm5nbGlzdHMuZHdvIiB9LAogICB7ICIuZGVi dWdfc3RyLmR3byIsICIuemRlYnVnX3N0ci5kd28iIH0sCiAgIHsgIi5kZWJ1Z19zdHJfb2Zmc2V0 cy5kd28iLCAiLnpkZWJ1Z19zdHJfb2Zmc2V0cy5kd28iIH0sCiAgIHsgIi5kZWJ1Z190eXBlcy5k d28iLCAiLnpkZWJ1Z190eXBlcy5kd28iIH0sCkBAIC02NTAsNiArNjU4LDcgQEAgc3RydWN0IGR3 b19zZWN0aW9ucwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyBsb2NsaXN0czsKICAgc3Ry dWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gbWFjaW5mbzsKICAgc3RydWN0IGR3YXJmMl9zZWN0aW9u X2luZm8gbWFjcm87CisgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvIHJuZ2xpc3RzOwogICBz dHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyBzdHI7CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9p bmZvIHN0cl9vZmZzZXRzOwogICAvKiBJbiB0aGUgY2FzZSBvZiBhIHZpcnR1YWwgRFdPIGZpbGUs IHRoZXNlIHR3byBhcmUgdW51c2VkLiAgKi8KQEAgLTEyNzQsNyArMTI4Myw3IEBAIHN0YXRpYyBj b25zdCBnZGJfYnl0ZSAqcmVhZF9hdHRyaWJ1dGUgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3Nw ZWNzICosCiAJCQkJICAgICAgIGNvbnN0IGdkYl9ieXRlICosIGJvb2wgKm5lZWRfcmVwcm9jZXNz KTsKIAogc3RhdGljIHZvaWQgcmVhZF9hdHRyaWJ1dGVfcmVwcm9jZXNzIChjb25zdCBzdHJ1Y3Qg ZGllX3JlYWRlcl9zcGVjcyAqcmVhZGVyLAotCQkJCSAgICAgIHN0cnVjdCBhdHRyaWJ1dGUgKmF0 dHIpOworCQkJCSAgICAgIHN0cnVjdCBhdHRyaWJ1dGUgKmF0dHIsIGR3YXJmX3RhZyB0YWcpOwog CiBzdGF0aWMgQ09SRV9BRERSIHJlYWRfYWRkcl9pbmRleCAoc3RydWN0IGR3YXJmMl9jdSAqY3Us IHVuc2lnbmVkIGludCBhZGRyX2luZGV4KTsKIApAQCAtMTM3OCwxMiArMTM4NywxMyBAQCBzdGF0 aWMgdm9pZCByZWFkX2NhbGxfc2l0ZV9zY29wZSAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVj dCBkd2FyZjJfY3UgKmN1KTsKIAogc3RhdGljIHZvaWQgcmVhZF92YXJpYWJsZSAoc3RydWN0IGRp ZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKmN1KTsKIAotc3RhdGljIGludCBkd2FyZjJf cmFuZ2VzX3JlYWQgKHVuc2lnbmVkLCBDT1JFX0FERFIgKiwgQ09SRV9BRERSICosCi0JCQkgICAg ICAgc3RydWN0IGR3YXJmMl9jdSAqLCBkd2FyZjJfcHN5bXRhYiAqKTsKLQogLyogUmV0dXJuIHRo ZSAuZGVidWdfbG9jbGlzdHMgc2VjdGlvbiB0byB1c2UgZm9yIGN1LiAgKi8KIHN0YXRpYyBzdHJ1 Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyAqY3VfZGVidWdfbG9jX3NlY3Rpb24gKHN0cnVjdCBkd2Fy ZjJfY3UgKmN1KTsKIAorLyogUmV0dXJuIHRoZSAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbiB0byB1 c2UgZm9yIGN1LiAgKi8KK3N0YXRpYyBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyAqY3VfZGVi dWdfcm5nbGlzdHNfc2VjdGlvbgorKHN0cnVjdCBkd2FyZjJfY3UgKmN1LCBkd2FyZl90YWcgdGFn KTsKKwogLyogSG93IGR3YXJmMl9nZXRfcGNfYm91bmRzIGNvbnN0cnVjdGVkIGl0cyAqTE9XUEMg YW5kICpISUdIUEMgcmV0dXJuCiAgICB2YWx1ZXMuICBLZWVwIHRoZSBpdGVtcyBvcmRlcmVkIHdp dGggaW5jcmVhc2luZyBjb25zdHJhaW50cyBjb21wbGlhbmNlLiAgKi8KIGVudW0gcGNfYm91bmRz X2tpbmQKQEAgLTEyNDQ4LDYgKzEyNDU4LDExIEBAIGR3YXJmMl9sb2NhdGVfZHdvX3NlY3Rpb25z IChiZmQgKmFiZmQsIGFzZWN0aW9uICpzZWN0cCwgdm9pZCAqZHdvX3NlY3Rpb25zX3B0cikKICAg ICAgIGR3b19zZWN0aW9ucy0+bWFjcm8ucy5zZWN0aW9uID0gc2VjdHA7CiAgICAgICBkd29fc2Vj dGlvbnMtPm1hY3JvLnNpemUgPSBiZmRfc2VjdGlvbl9zaXplIChzZWN0cCk7CiAgICAgfQorICBl bHNlIGlmIChzZWN0aW9uX2lzX3AgKHNlY3RwLT5uYW1lLCAmbmFtZXMtPnJuZ2xpc3RzX2R3bykp CisgICAgeworICAgICAgZHdvX3NlY3Rpb25zLT5ybmdsaXN0cy5zLnNlY3Rpb24gPSBzZWN0cDsK KyAgICAgIGR3b19zZWN0aW9ucy0+cm5nbGlzdHMuc2l6ZSA9IGJmZF9zZWN0aW9uX3NpemUgKHNl Y3RwKTsKKyAgICB9CiAgIGVsc2UgaWYgKHNlY3Rpb25faXNfcCAoc2VjdHAtPm5hbWUsICZuYW1l cy0+c3RyX2R3bykpCiAgICAgewogICAgICAgZHdvX3NlY3Rpb25zLT5zdHIucy5zZWN0aW9uID0g c2VjdHA7CkBAIC0xMzc5Miw3ICsxMzgwNyw3IEBAIHJlYWRfdmFyaWFibGUgKHN0cnVjdCBkaWVf aW5mbyAqZGllLCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSkKIHRlbXBsYXRlIDx0eXBlbmFtZSBDYWxs YmFjaz4KIHN0YXRpYyBib29sCiBkd2FyZjJfcm5nbGlzdHNfcHJvY2VzcyAodW5zaWduZWQgb2Zm c2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKLQkJCSBDYWxsYmFjayAmJmNhbGxiYWNrKQorCQkJ IGR3YXJmX3RhZyB0YWcsIENhbGxiYWNrICYmY2FsbGJhY2spCiB7CiAgIGR3YXJmMl9wZXJfb2Jq ZmlsZSAqcGVyX29iamZpbGUgPSBjdS0+cGVyX29iamZpbGU7CiAgIHN0cnVjdCBvYmpmaWxlICpv YmpmaWxlID0gcGVyX29iamZpbGUtPm9iamZpbGU7CkBAIC0xMzgwMiwxNyArMTM4MTcsMzMgQEAg ZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9j dSAqY3UsCiAgIGNvbnN0IGdkYl9ieXRlICpidWZmZXI7CiAgIENPUkVfQUREUiBiYXNlYWRkcjsK ICAgYm9vbCBvdmVyZmxvdyA9IGZhbHNlOworICBVTE9OR0VTVCBhZGRyX2luZGV4OworICBib29s IGlnbm9yZV9kd29fdW5pdCA9IGZhbHNlOworICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyAq cm5nbGlzdHNfc2VjdGlvbjsKIAogICBiYXNlID0gY3UtPmJhc2VfYWRkcmVzczsKIAotICBwZXJf b2JqZmlsZS0+cGVyX2JmZC0+cm5nbGlzdHMucmVhZCAob2JqZmlsZSk7Ci0gIGlmIChvZmZzZXQg Pj0gcGVyX29iamZpbGUtPnBlcl9iZmQtPnJuZ2xpc3RzLnNpemUpCisgIC8qIE1ha2Ugc3VyZSB3 ZSByZWFkIHRoZSAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbiBmcm9tIHRoZSBmaWxlIHRoYXQKKyAg ICAgY29udGFpbnMgdGhlIERXX0FUX3JhbmdlcyBhdHRyaWJ1dGUgd2UgYXJlIHJlYWRpbmcuICBO b3JtYWxseSB0aGF0CisgICAgIHdvdWxkIGJlIHRoZSAuZHdvIGZpbGUsIGlmIHRoZXJlIGlzIG9u ZS4gIEhvd2V2ZXIgZm9yIERXX1RBR19jb21waWxlX3VuaXQKKyAgICAgd2UgYWx3YXlzIHdhbnQg dG8gcmVhZCBmcm9tIG9iamZpbGUvbGlua2VkIHByb2dyYW0gKHdoaWNoIHdvdWxkIGJlIHRoZQor ICAgICBEV19UQUdfc2tlbGV0b25fdW5pdCBESUUgaWYgd2UncmUgdXNpbmcgc3BsaXQgZHdhcmYp LiAgKi8KKyAgaWYgKHRhZyA9PSBEV19UQUdfY29tcGlsZV91bml0KQorICAgIGlnbm9yZV9kd29f dW5pdCA9IHRydWU7CisKKyAgaWYgKGN1LT5kd29fdW5pdCAhPSBudWxscHRyICYmICFpZ25vcmVf ZHdvX3VuaXQpCisgICAgICBybmdsaXN0c19zZWN0aW9uID0gJmN1LT5kd29fdW5pdC0+ZHdvX2Zp bGUtPnNlY3Rpb25zLnJuZ2xpc3RzOworICBlbHNlCisgICAgICBybmdsaXN0c19zZWN0aW9uID0g JnBlcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0czsKKworICBybmdsaXN0c19zZWN0aW9uLT5y ZWFkIChvYmpmaWxlKTsKKyAgaWYgKG9mZnNldCA+PSBybmdsaXN0c19zZWN0aW9uLT5zaXplKQog ICAgIHsKICAgICAgIGNvbXBsYWludCAoXygiT2Zmc2V0ICVkIG91dCBvZiBib3VuZHMgZm9yIERX X0FUX3JhbmdlcyBhdHRyaWJ1dGUiKSwKIAkJIG9mZnNldCk7CiAgICAgICByZXR1cm4gZmFsc2U7 CiAgICAgfQotICBidWZmZXIgPSBwZXJfb2JqZmlsZS0+cGVyX2JmZC0+cm5nbGlzdHMuYnVmZmVy ICsgb2Zmc2V0OworICBidWZmZXIgPSBybmdsaXN0c19zZWN0aW9uLT5idWZmZXIgKyBvZmZzZXQ7 CiAKICAgYmFzZWFkZHIgPSBvYmpmaWxlLT50ZXh0X3NlY3Rpb25fb2Zmc2V0ICgpOwogCkBAIC0x MzgyMCw4ICsxMzg1MSw4IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZz ZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogICAgIHsKICAgICAgIC8qIEluaXRpYWxpemUgaXQg ZHVlIHRvIGEgZmFsc2UgY29tcGlsZXIgd2FybmluZy4gICovCiAgICAgICBDT1JFX0FERFIgcmFu Z2VfYmVnaW5uaW5nID0gMCwgcmFuZ2VfZW5kID0gMDsKLSAgICAgIGNvbnN0IGdkYl9ieXRlICpi dWZfZW5kID0gKHBlcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0cy5idWZmZXIKLQkJCQkgKyBw ZXJfb2JqZmlsZS0+cGVyX2JmZC0+cm5nbGlzdHMuc2l6ZSk7CisgICAgICBjb25zdCBnZGJfYnl0 ZSAqYnVmX2VuZCA9IChybmdsaXN0c19zZWN0aW9uLT5idWZmZXIKKwkJCQkgKyBybmdsaXN0c19z ZWN0aW9uLT5zaXplKTsKICAgICAgIHVuc2lnbmVkIGludCBieXRlc19yZWFkOwogCiAgICAgICBp ZiAoYnVmZmVyID09IGJ1Zl9lbmQpCkBAIC0xMzg0Myw2ICsxMzg3NCwxMSBAQCBkd2FyZjJfcm5n bGlzdHNfcHJvY2VzcyAodW5zaWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKIAkg IGJhc2UgPSBjdS0+aGVhZGVyLnJlYWRfYWRkcmVzcyAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVh ZCk7CiAJICBidWZmZXIgKz0gYnl0ZXNfcmVhZDsKIAkgIGJyZWFrOworICAgICAgICBjYXNlIERX X1JMRV9iYXNlX2FkZHJlc3N4OgorICAgICAgICAgIGFkZHJfaW5kZXggPSByZWFkX3Vuc2lnbmVk X2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAgICAgICAgYnVmZmVyICs9 IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgYmFzZSA9IHJlYWRfYWRkcl9pbmRleCAoY3UsIGFkZHJf aW5kZXgpOworICAgICAgICAgIGJyZWFrOwogCWNhc2UgRFdfUkxFX3N0YXJ0X2xlbmd0aDoKIAkg IGlmIChidWZmZXIgKyBjdS0+aGVhZGVyLmFkZHJfc2l6ZSA+IGJ1Zl9lbmQpCiAJICAgIHsKQEAg LTEzODYxLDYgKzEzODk3LDE5IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBv ZmZzZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogCSAgICAgIGJyZWFrOwogCSAgICB9CiAJICBi cmVhazsKKwljYXNlIERXX1JMRV9zdGFydHhfbGVuZ3RoOgorICAgICAgICAgIGFkZHJfaW5kZXgg PSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAg ICAgICAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgcmFuZ2VfYmVnaW5uaW5nID0g cmVhZF9hZGRyX2luZGV4IChjdSwgYWRkcl9pbmRleCk7CisgICAgICAgICAgaWYgKGJ1ZmZlciA+ IGJ1Zl9lbmQpCisgICAgICAgICAgICB7CisgICAgICAgICAgICAgIG92ZXJmbG93ID0gdHJ1ZTsK KyAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgcmFuZ2VfZW5k ID0gKHJhbmdlX2JlZ2lubmluZworICAgICAgICAgICAgICAgICAgICAgICArIHJlYWRfdW5zaWdu ZWRfbGViMTI4IChvYmZkLCBidWZmZXIsICZieXRlc19yZWFkKSk7CisgICAgICAgICAgYnVmZmVy ICs9IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgYnJlYWs7CiAJY2FzZSBEV19STEVfb2Zmc2V0X3Bh aXI6CiAJICByYW5nZV9iZWdpbm5pbmcgPSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVm ZmVyLCAmYnl0ZXNfcmVhZCk7CiAJICBidWZmZXIgKz0gYnl0ZXNfcmVhZDsKQEAgLTEzODg5LDYg KzEzOTM4LDE5IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0 cnVjdCBkd2FyZjJfY3UgKmN1LAogCSAgcmFuZ2VfZW5kID0gY3UtPmhlYWRlci5yZWFkX2FkZHJl c3MgKG9iZmQsIGJ1ZmZlciwgJmJ5dGVzX3JlYWQpOwogCSAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7 CiAJICBicmVhazsKKwljYXNlIERXX1JMRV9zdGFydHhfZW5keDoKKyAgICAgICAgICBhZGRyX2lu ZGV4ID0gcmVhZF91bnNpZ25lZF9sZWIxMjggKG9iZmQsIGJ1ZmZlciwgJmJ5dGVzX3JlYWQpOwor ICAgICAgICAgIGJ1ZmZlciArPSBieXRlc19yZWFkOworICAgICAgICAgIHJhbmdlX2JlZ2lubmlu ZyA9IHJlYWRfYWRkcl9pbmRleCAoY3UsIGFkZHJfaW5kZXgpOworICAgICAgICAgIGlmIChidWZm ZXIgPiBidWZfZW5kKQorICAgICAgICAgICAgeworICAgICAgICAgICAgICBvdmVyZmxvdyA9IHRy dWU7CisgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICAgIGFkZHJf aW5kZXggPSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7 CisgICAgICAgICAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgcmFuZ2VfZW5kID0g cmVhZF9hZGRyX2luZGV4IChjdSwgYWRkcl9pbmRleCk7CisgICAgICAgICAgYnJlYWs7CiAJZGVm YXVsdDoKIAkgIGNvbXBsYWludCAoXygiSW52YWxpZCAuZGVidWdfcm5nbGlzdHMgZGF0YSAobm8g YmFzZSBhZGRyZXNzKSIpKTsKIAkgIHJldHVybiBmYWxzZTsKQEAgLTEzODk4LDE0ICsxMzk2MCw2 IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2Fy ZjJfY3UgKmN1LAogICAgICAgaWYgKHJsZXQgPT0gRFdfUkxFX2Jhc2VfYWRkcmVzcykKIAljb250 aW51ZTsKIAotICAgICAgaWYgKCFiYXNlLmhhc192YWx1ZSAoKSkKLQl7Ci0JICAvKiBXZSBoYXZl IG5vIHZhbGlkIGJhc2UgYWRkcmVzcyBmb3IgdGhlIHJhbmdlcwotCSAgICAgZGF0YS4gICovCi0J ICBjb21wbGFpbnQgKF8oIkludmFsaWQgLmRlYnVnX3JuZ2xpc3RzIGRhdGEgKG5vIGJhc2UgYWRk cmVzcykiKSk7Ci0JICByZXR1cm4gZmFsc2U7Ci0JfQotCiAgICAgICBpZiAocmFuZ2VfYmVnaW5u aW5nID4gcmFuZ2VfZW5kKQogCXsKIAkgIC8qIEludmVydGVkIHJhbmdlIGVudHJpZXMgYXJlIGlu dmFsaWQuICAqLwpAQCAtMTM5MTcsOCArMTM5NzEsMjAgQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nl c3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiAgICAgICBpZiAocmFu Z2VfYmVnaW5uaW5nID09IHJhbmdlX2VuZCkKIAljb250aW51ZTsKIAotICAgICAgcmFuZ2VfYmVn aW5uaW5nICs9ICpiYXNlOwotICAgICAgcmFuZ2VfZW5kICs9ICpiYXNlOworICAgICAgLyogT25s eSBEV19STEVfb2Zmc2V0X3BhaXIgbmVlZHMgdGhlIGJhc2UgYWRkcmVzcyBhZGRlZC4gICovCisg ICAgICBpZiAocmxldCA9PSBEV19STEVfb2Zmc2V0X3BhaXIpCisJeworCSAgaWYgKCFiYXNlLmhh c192YWx1ZSAoKSkKKwkgICAgeworCSAgICAgIC8qIFdlIGhhdmUgbm8gdmFsaWQgYmFzZSBhZGRy ZXNzIGZvciB0aGUgRFdfUkxFX29mZnNldF9wYWlyLiAgKi8KKwkgICAgICBjb21wbGFpbnQgKF8o IkludmFsaWQgLmRlYnVnX3JuZ2xpc3RzIGRhdGEgKG5vIGJhc2UgYWRkcmVzcyBmb3IgIgorCQkJ ICAgIkRXX1JMRV9vZmZzZXRfcGFpcikiKSk7CisJICAgICAgcmV0dXJuIGZhbHNlOworCSAgICB9 CisKKwkgIHJhbmdlX2JlZ2lubmluZyArPSAqYmFzZTsKKwkgIHJhbmdlX2VuZCArPSAqYmFzZTsK Kwl9CiAKICAgICAgIC8qIEEgbm90LXVuY29tbW9uIGNhc2Ugb2YgYmFkIGRlYnVnIGluZm8uCiAJ IERvbid0IHBvbGx1dGUgdGhlIGFkZHJtYXAgd2l0aCBiYWQgZGF0YS4gICovCkBAIC0xMzk1MSw3 ICsxNDAxNyw3IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0 cnVjdCBkd2FyZjJfY3UgKmN1LAogCiB0ZW1wbGF0ZSA8dHlwZW5hbWUgQ2FsbGJhY2s+CiBzdGF0 aWMgaW50Ci1kd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3 YXJmMl9jdSAqY3UsCitkd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3Ry dWN0IGR3YXJmMl9jdSAqY3UsIGR3YXJmX3RhZyB0YWcsCiAJCSAgICAgICBDYWxsYmFjayAmJmNh bGxiYWNrKQogewogICBkd2FyZjJfcGVyX29iamZpbGUgKnBlcl9vYmpmaWxlID0gY3UtPnBlcl9v YmpmaWxlOwpAQCAtMTM5NjcsNyArMTQwMzMsNyBAQCBkd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKHVu c2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiAgIENPUkVfQUREUiBiYXNlYWRk cjsKIAogICBpZiAoY3VfaGVhZGVyLT52ZXJzaW9uID49IDUpCi0gICAgcmV0dXJuIGR3YXJmMl9y bmdsaXN0c19wcm9jZXNzIChvZmZzZXQsIGN1LCBjYWxsYmFjayk7CisgICAgcmV0dXJuIGR3YXJm Ml9ybmdsaXN0c19wcm9jZXNzIChvZmZzZXQsIGN1LCB0YWcsIGNhbGxiYWNrKTsKIAogICBiYXNl ID0gY3UtPmJhc2VfYWRkcmVzczsKIApAQCAtMTQwNTMsNyArMTQxMTksNyBAQCBkd2FyZjJfcmFu Z2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiBzdGF0 aWMgaW50CiBkd2FyZjJfcmFuZ2VzX3JlYWQgKHVuc2lnbmVkIG9mZnNldCwgQ09SRV9BRERSICps b3dfcmV0dXJuLAogCQkgICAgQ09SRV9BRERSICpoaWdoX3JldHVybiwgc3RydWN0IGR3YXJmMl9j dSAqY3UsCi0JCSAgICBkd2FyZjJfcHN5bXRhYiAqcmFuZ2VzX3BzdCkKKwkJICAgIGR3YXJmMl9w c3ltdGFiICpyYW5nZXNfcHN0LCBkd2FyZl90YWcgdGFnKQogewogICBzdHJ1Y3Qgb2JqZmlsZSAq b2JqZmlsZSA9IGN1LT5wZXJfb2JqZmlsZS0+b2JqZmlsZTsKICAgc3RydWN0IGdkYmFyY2ggKmdk YmFyY2ggPSBvYmpmaWxlLT5hcmNoICgpOwpAQCAtMTQwNjMsNyArMTQxMjksNyBAQCBkd2FyZjJf cmFuZ2VzX3JlYWQgKHVuc2lnbmVkIG9mZnNldCwgQ09SRV9BRERSICpsb3dfcmV0dXJuLAogICBD T1JFX0FERFIgaGlnaCA9IDA7CiAgIGludCByZXR2YWw7CiAKLSAgcmV0dmFsID0gZHdhcmYyX3Jh bmdlc19wcm9jZXNzIChvZmZzZXQsIGN1LAorICByZXR2YWwgPSBkd2FyZjJfcmFuZ2VzX3Byb2Nl c3MgKG9mZnNldCwgY3UsIHRhZywKICAgICBbJl0gKENPUkVfQUREUiByYW5nZV9iZWdpbm5pbmcs IENPUkVfQUREUiByYW5nZV9lbmQpCiAgICAgewogICAgICAgaWYgKHJhbmdlc19wc3QgIT0gTlVM TCkKQEAgLTE0MTU1LDggKzE0MjIxLDE0IEBAIGR3YXJmMl9nZXRfcGNfYm91bmRzIChzdHJ1Y3Qg ZGllX2luZm8gKmRpZSwgQ09SRV9BRERSICpsb3dwYywKIAl7CiAJICAvKiBEV19BVF9ybmdsaXN0 c19iYXNlIGRvZXMgbm90IGFwcGx5IHRvIERJRXMgZnJvbSB0aGUgRFdPIHNrZWxldG9uLgogCSAg ICAgV2UgdGFrZSBhZHZhbnRhZ2Ugb2YgdGhlIGZhY3QgdGhhdCBEV19BVF9yYW5nZXMgZG9lcyBu b3QgYXBwZWFyCi0JICAgICBpbiBEV19UQUdfY29tcGlsZV91bml0IG9mIERXTyBmaWxlcy4gICov Ci0JICBpbnQgbmVlZF9yYW5nZXNfYmFzZSA9IGRpZS0+dGFnICE9IERXX1RBR19jb21waWxlX3Vu aXQ7CisJICAgICBpbiBEV19UQUdfY29tcGlsZV91bml0IG9mIERXTyBmaWxlcy4KKworCSAgICAg QXR0cmlidXRlcyBvZiB0aGUgZm9ybSBEV19GT1JNX3JuZ2xpc3R4IGhhdmUgYWxyZWFkeSBoYWQg dGhlaXIKKwkgICAgIHZhbHVlIGNoYW5nZWQgYnkgcmVhZF9ybmdsaXN0X2luZGV4IGFuZCBhbHJl YWR5IGluY2x1ZGUKKwkgICAgIERXX0FUX3JuZ2xpc3RzX2Jhc2UsIHNvIGRvbid0IG5lZWQgdG8g YWRkIHRoZSByYW5nZXMgYmFzZSwKKwkgICAgIGVpdGhlci4gICovCisJICBpbnQgbmVlZF9yYW5n ZXNfYmFzZSA9IChkaWUtPnRhZyAhPSBEV19UQUdfY29tcGlsZV91bml0CisJCQkJICAmJiBhdHRy LT5mb3JtICE9IERXX0ZPUk1fcm5nbGlzdHgpOwogCSAgdW5zaWduZWQgaW50IHJhbmdlc19vZmZz ZXQgPSAoRFdfVU5TTkQgKGF0dHIpCiAJCQkJCSsgKG5lZWRfcmFuZ2VzX2Jhc2UKIAkJCQkJICAg PyBjdS0+cmFuZ2VzX2Jhc2UKQEAgLTE0MTY0LDcgKzE0MjM2LDggQEAgZHdhcmYyX2dldF9wY19i b3VuZHMgKHN0cnVjdCBkaWVfaW5mbyAqZGllLCBDT1JFX0FERFIgKmxvd3BjLAogCiAJICAvKiBW YWx1ZSBvZiB0aGUgRFdfQVRfcmFuZ2VzIGF0dHJpYnV0ZSBpcyB0aGUgb2Zmc2V0IGluIHRoZQog CSAgICAgLmRlYnVnX3JhbmdlcyBzZWN0aW9uLiAgKi8KLQkgIGlmICghZHdhcmYyX3Jhbmdlc19y ZWFkIChyYW5nZXNfb2Zmc2V0LCAmbG93LCAmaGlnaCwgY3UsIHBzdCkpCisJICBpZiAoIWR3YXJm Ml9yYW5nZXNfcmVhZCAocmFuZ2VzX29mZnNldCwgJmxvdywgJmhpZ2gsIGN1LCBwc3QsCisJCQkJ ICAgZGllLT50YWcpKQogCSAgICByZXR1cm4gUENfQk9VTkRTX0lOVkFMSUQ7CiAJICAvKiBGb3Vu ZCBkaXNjb250aW51b3VzIHJhbmdlIG9mIGFkZHJlc3Nlcy4gICovCiAJICByZXQgPSBQQ19CT1VO RFNfUkFOR0VTOwpAQCAtMTQzMjYsOCArMTQzOTksMTQgQEAgZHdhcmYyX3JlY29yZF9ibG9ja19y YW5nZXMgKHN0cnVjdCBkaWVfaW5mbyAqZGllLCBzdHJ1Y3QgYmxvY2sgKmJsb2NrLAogICAgIHsK ICAgICAgIC8qIERXX0FUX3JuZ2xpc3RzX2Jhc2UgZG9lcyBub3QgYXBwbHkgdG8gRElFcyBmcm9t IHRoZSBEV08gc2tlbGV0b24uCiAJIFdlIHRha2UgYWR2YW50YWdlIG9mIHRoZSBmYWN0IHRoYXQg RFdfQVRfcmFuZ2VzIGRvZXMgbm90IGFwcGVhcgotCSBpbiBEV19UQUdfY29tcGlsZV91bml0IG9m IERXTyBmaWxlcy4gICovCi0gICAgICBpbnQgbmVlZF9yYW5nZXNfYmFzZSA9IGRpZS0+dGFnICE9 IERXX1RBR19jb21waWxlX3VuaXQ7CisJIGluIERXX1RBR19jb21waWxlX3VuaXQgb2YgRFdPIGZp bGVzLgorCisJIEF0dHJpYnV0ZXMgb2YgdGhlIGZvcm0gRFdfRk9STV9ybmdsaXN0eCBoYXZlIGFs cmVhZHkgaGFkIHRoZWlyCisJIHZhbHVlIGNoYW5nZWQgYnkgcmVhZF9ybmdsaXN0X2luZGV4IGFu ZCBhbHJlYWR5IGluY2x1ZGUKKwkgRFdfQVRfcm5nbGlzdHNfYmFzZSwgc28gZG9uJ3QgbmVlZCB0 byBhZGQgdGhlIHJhbmdlcyBiYXNlLAorCSBlaXRoZXIuICAqLworICAgICAgaW50IG5lZWRfcmFu Z2VzX2Jhc2UgPSAoZGllLT50YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdAorCQkJICAgICAgJiYg YXR0ci0+Zm9ybSAhPSBEV19GT1JNX3JuZ2xpc3R4KTsKIAogICAgICAgLyogVGhlIHZhbHVlIG9m IHRoZSBEV19BVF9yYW5nZXMgYXR0cmlidXRlIGlzIHRoZSBvZmZzZXQgb2YgdGhlCiAgICAgICAg ICBhZGRyZXNzIHJhbmdlIGxpc3QgaW4gdGhlIC5kZWJ1Z19yYW5nZXMgc2VjdGlvbi4gICovCkBA IC0xNDMzNSw3ICsxNDQxNCw3IEBAIGR3YXJmMl9yZWNvcmRfYmxvY2tfcmFuZ2VzIChzdHJ1Y3Qg ZGllX2luZm8gKmRpZSwgc3RydWN0IGJsb2NrICpibG9jaywKIAkJCSAgICAgICsgKG5lZWRfcmFu Z2VzX2Jhc2UgPyBjdS0+cmFuZ2VzX2Jhc2UgOiAwKSk7CiAKICAgICAgIHN0ZDo6dmVjdG9yPGJs b2NrcmFuZ2U+IGJsb2NrdmVjOwotICAgICAgZHdhcmYyX3Jhbmdlc19wcm9jZXNzIChvZmZzZXQs IGN1LAorICAgICAgZHdhcmYyX3Jhbmdlc19wcm9jZXNzIChvZmZzZXQsIGN1LCBkaWUtPnRhZywK IAlbJl0gKENPUkVfQUREUiBzdGFydCwgQ09SRV9BRERSIGVuZCkKIAl7CiAJICBzdGFydCArPSBi YXNlYWRkcjsKQEAgLTE4MTY1LDggKzE4MjQ0LDEzIEBAIHJlYWRfZnVsbF9kaWVfMSAoY29uc3Qg c3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwKICAgYXV0byBtYXliZV9hZGRyX2Jhc2Ug PSBkaWUtPmFkZHJfYmFzZSAoKTsKICAgaWYgKG1heWJlX2FkZHJfYmFzZS5oYXNfdmFsdWUgKCkp CiAgICAgY3UtPmFkZHJfYmFzZSA9ICptYXliZV9hZGRyX2Jhc2U7CisKKyAgYXR0ciA9IGRpZS0+ YXR0ciAoRFdfQVRfcm5nbGlzdHNfYmFzZSk7CisgIGlmIChhdHRyICE9IG51bGxwdHIpCisgICAg Y3UtPnJhbmdlc19iYXNlID0gRFdfVU5TTkQgKGF0dHIpOworCiAgIGZvciAoaW50IGluZGV4IDog aW5kZXhlc190aGF0X25lZWRfcmVwcm9jZXNzKQotICAgIHJlYWRfYXR0cmlidXRlX3JlcHJvY2Vz cyAocmVhZGVyLCAmZGllLT5hdHRyc1tpbmRleF0pOworICAgIHJlYWRfYXR0cmlidXRlX3JlcHJv Y2VzcyAocmVhZGVyLCAmZGllLT5hdHRyc1tpbmRleF0sIGRpZS0+dGFnKTsKICAgKmRpZXAgPSBk aWU7CiAgIHJldHVybiBpbmZvX3B0cjsKIH0KQEAgLTE4NTM1LDcgKzE4NjE5LDcgQEAgcGFydGlh bF9kaWVfaW5mbzo6cmVhZCAoY29uc3Qgc3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwK ICAgICAgICAgIGFscmVhZHkgYmVlbiByZWFkIGF0IHRoaXMgcG9pbnQsIHNvIHRoZXJlIGlzIG5v IG5lZWQgdG8gd2FpdCB1bnRpbAogCSB0aGUgbG9vcCB0ZXJtaW5hdGVzIHRvIGRvIHRoZSByZXBy b2Nlc3NpbmcuICAqLwogICAgICAgaWYgKG5lZWRfcmVwcm9jZXNzKQotCXJlYWRfYXR0cmlidXRl X3JlcHJvY2VzcyAocmVhZGVyLCAmYXR0cik7CisJcmVhZF9hdHRyaWJ1dGVfcmVwcm9jZXNzIChy ZWFkZXIsICZhdHRyLCB0YWcpOwogICAgICAgLyogU3RvcmUgdGhlIGRhdGEgaWYgaXQgaXMgb2Yg YW4gYXR0cmlidXRlIHdlIHdhbnQgdG8ga2VlcCBpbiBhCiAgICAgICAgICBwYXJ0aWFsIHN5bWJv bCB0YWJsZS4gICovCiAgICAgICBzd2l0Y2ggKGF0dHIubmFtZSkKQEAgLTE4NjgxLDEwICsxODc2 NSwxNiBAQCBwYXJ0aWFsX2RpZV9pbmZvOjpyZWFkIChjb25zdCBzdHJ1Y3QgZGllX3JlYWRlcl9z cGVjcyAqcmVhZGVyLAogCiAJY2FzZSBEV19BVF9yYW5nZXM6CiAJICB7Ci0JICAgIC8qIEl0IHdv dWxkIGJlIG5pY2UgdG8gcmV1c2UgZHdhcmYyX2dldF9wY19ib3VuZHMgaGVyZSwKLQkgICAgICAg YnV0IHRoYXQgcmVxdWlyZXMgYSBmdWxsIERJRSwgc28gaW5zdGVhZCB3ZSBqdXN0Ci0JICAgICAg IHJlaW1wbGVtZW50IGl0LiAgKi8KLQkgICAgaW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSB0YWcgIT0g RFdfVEFHX2NvbXBpbGVfdW5pdDsKKwkgICAgLyogRFdfQVRfcm5nbGlzdHNfYmFzZSBkb2VzIG5v dCBhcHBseSB0byBESUVzIGZyb20gdGhlIERXTworCSAgICAgICBza2VsZXRvbi4gIFdlIHRha2Ug YWR2YW50YWdlIG9mIHRoZSBmYWN0IHRoZSBEV19BVF9yYW5nZXMKKwkgICAgICAgZG9lcyBub3Qg YXBwZWFyIGluIERXX1RBR19jb21waWxlX3VuaXQgb2YgRFdPIGZpbGVzLgorCisJICAgICAgIEF0 dHJpYnV0ZXMgb2YgdGhlIGZvcm0gRFdfRk9STV9ybmdsaXN0eCBoYXZlIGFscmVhZHkgaGFkCisg ICAgICAgICAgICAgICB0aGVpciB2YWx1ZSBjaGFuZ2VkIGJ5IHJlYWRfcm5nbGlzdF9pbmRleCBh bmQgYWxyZWFkeQorCSAgICAgICBpbmNsdWRlIERXX0FUX3JuZ2xpc3RzX2Jhc2UsIHNvIGRvbid0 IG5lZWQgdG8gYWRkIHRoZSByYW5nZXMKKwkgICAgICAgYmFzZSwgZWl0aGVyLiAgKi8KKwkgICAg aW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSAodGFnICE9IERXX1RBR19jb21waWxlX3VuaXQKKwkJCQkg ICAgJiYgYXR0ci5mb3JtICE9IERXX0ZPUk1fcm5nbGlzdHgpOwogCSAgICB1bnNpZ25lZCBpbnQg cmFuZ2VzX29mZnNldCA9IChEV19VTlNORCAoJmF0dHIpCiAJCQkJCSAgKyAobmVlZF9yYW5nZXNf YmFzZQogCQkJCQkgICAgID8gY3UtPnJhbmdlc19iYXNlCkBAIC0xODY5Myw3ICsxODc4Myw3IEBA IHBhcnRpYWxfZGllX2luZm86OnJlYWQgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpy ZWFkZXIsCiAJICAgIC8qIFZhbHVlIG9mIHRoZSBEV19BVF9yYW5nZXMgYXR0cmlidXRlIGlzIHRo ZSBvZmZzZXQgaW4gdGhlCiAJICAgICAgIC5kZWJ1Z19yYW5nZXMgc2VjdGlvbi4gICovCiAJICAg IGlmIChkd2FyZjJfcmFuZ2VzX3JlYWQgKHJhbmdlc19vZmZzZXQsICZsb3dwYywgJmhpZ2hwYywg Y3UsCi0JCQkJICAgIG51bGxwdHIpKQorCQkJCSAgICBudWxscHRyLCB0YWcpKQogCSAgICAgIGhh c19wY19pbmZvID0gMTsKIAkgIH0KIAkgIGJyZWFrOwpAQCAtMTkwMTcsMTEgKzE5MTA3LDExIEBA IHBhcnRpYWxfZGllX2luZm86OmZpeHVwIChzdHJ1Y3QgZHdhcmYyX2N1ICpjdSkKICAgZml4dXBf Y2FsbGVkID0gMTsKIH0KIAotLyogUmVhZCB0aGUgLmRlYnVnX2xvY2xpc3RzIGhlYWRlciBjb250 ZW50cyBmcm9tIHRoZSBnaXZlbiBTRUNUSU9OIGluIHRoZQotICAgSEVBREVSLiAgKi8KKy8qIFJl YWQgdGhlIC5kZWJ1Z19sb2NsaXN0cyBvciAuZGVidWdfcm5nbGlzdHMgaGVhZGVyICh0aGV5IGFy ZSB0aGUgc2FtZSBmb3JtYXQpCisgICBjb250ZW50cyBmcm9tIHRoZSBnaXZlbiBTRUNUSU9OIGlu IHRoZSBIRUFERVIuICAqLwogc3RhdGljIHZvaWQKLXJlYWRfbG9jbGlzdF9oZWFkZXIgKHN0cnVj dCBsb2NsaXN0X2hlYWRlciAqaGVhZGVyLAotCQkgICAgICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25f aW5mbyAqc2VjdGlvbikKK3JlYWRfbG9jbGlzdHNfcm5nbGlzdHNfaGVhZGVyIChzdHJ1Y3QgbG9j bGlzdF9oZWFkZXIgKmhlYWRlciwKKwkJCSAgICAgICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5m byAqc2VjdGlvbikKIHsKICAgdW5zaWduZWQgaW50IGJ5dGVzX3JlYWQ7CiAgIGJmZCAqYWJmZCA9 IHNlY3Rpb24tPmdldF9iZmRfb3duZXIgKCk7CkBAIC0xOTA3NSw3ICsxOTE2NSw3IEBAIHJlYWRf bG9jbGlzdF9pbmRleCAoc3RydWN0IGR3YXJmMl9jdSAqY3UsIFVMT05HRVNUIGxvY2xpc3RfaW5k ZXgpCiAgICAgY29tcGxhaW50IChfKCJEV19GT1JNX2xvY2xpc3R4IHVzZWQgd2l0aG91dCAuZGVi dWdfbG9jbGlzdHMgIgogCSAgICAgICAgInNlY3Rpb24gW2luIG1vZHVsZSAlc10iKSwgb2JqZmls ZV9uYW1lIChvYmpmaWxlKSk7CiAgIHN0cnVjdCBsb2NsaXN0X2hlYWRlciBoZWFkZXI7Ci0gIHJl YWRfbG9jbGlzdF9oZWFkZXIgKCZoZWFkZXIsIHNlY3Rpb24pOworICByZWFkX2xvY2xpc3RzX3Ju Z2xpc3RzX2hlYWRlciAoJmhlYWRlciwgc2VjdGlvbik7CiAgIGlmIChsb2NsaXN0X2luZGV4ID49 IGhlYWRlci5vZmZzZXRfZW50cnlfY291bnQpCiAgICAgY29tcGxhaW50IChfKCJEV19GT1JNX2xv Y2xpc3R4IHBvaW50aW5nIG91dHNpZGUgb2YgIgogCSAgICAgICAgIi5kZWJ1Z19sb2NsaXN0cyBv ZmZzZXQgYXJyYXkgW2luIG1vZHVsZSAlc10iKSwKQEAgLTE5MDk0LDEzICsxOTE4NCw2NSBAQCBy ZWFkX2xvY2xpc3RfaW5kZXggKHN0cnVjdCBkd2FyZjJfY3UgKmN1LCBVTE9OR0VTVCBsb2NsaXN0 X2luZGV4KQogICAgIHJldHVybiBiZmRfZ2V0XzY0IChhYmZkLCBpbmZvX3B0cikgKyBsb2NsaXN0 X2Jhc2U7CiB9CiAKKy8qIEdpdmVuIGEgRFdfRk9STV9ybmdsaXN0eCB2YWx1ZSBybmdsaXN0X2lu ZGV4LCBmZXRjaCB0aGUgb2Zmc2V0IGZyb20gdGhlCisgICBhcnJheSBvZiBvZmZzZXRzIGluIHRo ZSAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbi4gICovCitzdGF0aWMgQ09SRV9BRERSCityZWFkX3Ju Z2xpc3RfaW5kZXggKHN0cnVjdCBkd2FyZjJfY3UgKmN1LCBVTE9OR0VTVCBybmdsaXN0X2luZGV4 LAorCQkgICAgZHdhcmZfdGFnIHRhZykKK3sKKyAgc3RydWN0IGR3YXJmMl9wZXJfb2JqZmlsZSAq ZHdhcmYyX3Blcl9vYmpmaWxlID0gY3UtPnBlcl9vYmpmaWxlOworICBzdHJ1Y3Qgb2JqZmlsZSAq b2JqZmlsZSA9IGR3YXJmMl9wZXJfb2JqZmlsZS0+b2JqZmlsZTsKKyAgYmZkICphYmZkID0gb2Jq ZmlsZS0+b2JmZDsKKyAgVUxPTkdFU1Qgcm5nbGlzdF9oZWFkZXJfc2l6ZSA9CisgICAgKGN1LT5o ZWFkZXIuaW5pdGlhbF9sZW5ndGhfc2l6ZSA9PSA0ID8gUk5HTElTVF9IRUFERVJfU0laRTMyCisg ICAgIDogUk5HTElTVF9IRUFERVJfU0laRTY0KTsKKyAgVUxPTkdFU1Qgcm5nbGlzdF9iYXNlID0K KyAgICAgIChjdS0+ZHdvX3VuaXQgIT0gbnVsbHB0cikgPyBybmdsaXN0X2hlYWRlcl9zaXplIDog Y3UtPnJhbmdlc19iYXNlOworICBVTE9OR0VTVCBzdGFydF9vZmZzZXQgPQorICAgIHJuZ2xpc3Rf YmFzZSArIHJuZ2xpc3RfaW5kZXggKiBjdS0+aGVhZGVyLm9mZnNldF9zaXplOworCisgIC8qIEdl dCBybmdsaXN0cyBzZWN0aW9uLiAgKi8KKyAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gKnNl Y3Rpb24gPSBjdV9kZWJ1Z19ybmdsaXN0c19zZWN0aW9uIChjdSwgdGFnKTsKKyAgaWYgKHNlY3Rp b24gPT0gbnVsbHB0cikKKyAgICBlcnJvciAoXygiQ2Fubm90IGZpbmQgLmRlYnVnX3JuZ2xpc3Rz IHNlY3Rpb24gW2luIG1vZHVsZSAlc10iKSwKKwkgICBvYmpmaWxlX25hbWUgKG9iamZpbGUpKTsK KworICAvKiBSZWFkIHRoZSBybmdsaXN0cyBzZWN0aW9uIGNvbnRlbnQuICAqLworICBzZWN0aW9u LT5yZWFkIChvYmpmaWxlKTsKKyAgaWYgKHNlY3Rpb24tPmJ1ZmZlciA9PSBudWxscHRyKQorICAg IGVycm9yIChfKCJEV19GT1JNX3JuZ2xpc3R4IHVzZWQgd2l0aG91dCAuZGVidWdfcm5nbGlzdHMg c2VjdGlvbiAiCisJICAgICAiW2luIG1vZHVsZSAlc10iKSwKKyAgICAgICBvYmpmaWxlX25hbWUg KG9iamZpbGUpKTsKKworICAvKiBWZXJpZnkgdGhlIHJuZ2xpc3QgaGVhZGVyIGlzIHZhbGlkIChz YW1lIGFzIGxvY2xpc3QgaGVhZGVyKS4gICovCisgIHN0cnVjdCBsb2NsaXN0X2hlYWRlciBoZWFk ZXI7CisgIHJlYWRfbG9jbGlzdHNfcm5nbGlzdHNfaGVhZGVyICgmaGVhZGVyLCBzZWN0aW9uKTsK KyAgaWYgKHJuZ2xpc3RfaW5kZXggPj0gaGVhZGVyLm9mZnNldF9lbnRyeV9jb3VudCkKKyAgICBl cnJvciAoXygiRFdfRk9STV9ybmdsaXN0eCBpbmRleCBwb2ludGluZyBvdXRzaWRlIG9mICIKKwkg ICAgICIuZGVidWdfcm5nbGlzdHMgb2Zmc2V0IGFycmF5IFtpbiBtb2R1bGUgJXNdIiksCisJICAg IG9iamZpbGVfbmFtZSAob2JqZmlsZSkpOworCisgIC8qIFZhbGlkYXRlIHRoYXQgdGhlIG9mZnNl dCBpcyB3aXRoaW4gdGhlIHNlY3Rpb24ncyByYW5nZS4gICovCisgIGlmIChzdGFydF9vZmZzZXQg Pj0gc2VjdGlvbi0+c2l6ZSkKKyAgICBlcnJvciAoXygiRFdfRk9STV9ybmdsaXN0eCBwb2ludGlu ZyBvdXRzaWRlIG9mICIKKyAgICAgICAgICAgICAiLmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24gW2lu IG1vZHVsZSAlc10iKSwKKyAgICAgICAgICBvYmpmaWxlX25hbWUgKG9iamZpbGUpKTsKKworICBj b25zdCBnZGJfYnl0ZSAqaW5mb19wdHIgPSBzZWN0aW9uLT5idWZmZXIgKyBzdGFydF9vZmZzZXQ7 CisKKyAgaWYgKGN1LT5oZWFkZXIub2Zmc2V0X3NpemUgPT0gNCkKKyAgICByZXR1cm4gcmVhZF80 X2J5dGVzIChhYmZkLCBpbmZvX3B0cikgKyBybmdsaXN0X2Jhc2U7CisgIGVsc2UKKyAgICByZXR1 cm4gcmVhZF84X2J5dGVzIChhYmZkLCBpbmZvX3B0cikgKyBybmdsaXN0X2Jhc2U7Cit9CisKIC8q IFByb2Nlc3MgdGhlIGF0dHJpYnV0ZXMgdGhhdCBoYWQgdG8gYmUgc2tpcHBlZCBpbiB0aGUgZmly c3Qgcm91bmQuIFRoZXNlCiAgICBhdHRyaWJ1dGVzIGFyZSB0aGUgb25lcyB0aGF0IG5lZWQgc3Ry X29mZnNldHNfYmFzZSBvciBhZGRyX2Jhc2UgYXR0cmlidXRlcy4KICAgIFRoZXkgY291bGQgbm90 IGhhdmUgYmVlbiBwcm9jZXNzZWQgaW4gdGhlIGZpcnN0IHJvdW5kLCBiZWNhdXNlIGF0IHRoZSB0 aW1lCiAgICB0aGUgdmFsdWVzIG9mIHN0cl9vZmZzZXRzX2Jhc2Ugb3IgYWRkcl9iYXNlIG1heSBu b3QgaGF2ZSBiZWVuIGtub3duLiAgKi8KIHN0YXRpYyB2b2lkCiByZWFkX2F0dHJpYnV0ZV9yZXBy b2Nlc3MgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCi0JCQkgIHN0cnVj dCBhdHRyaWJ1dGUgKmF0dHIpCisJCQkgIHN0cnVjdCBhdHRyaWJ1dGUgKmF0dHIsIGR3YXJmX3Rh ZyB0YWcpCiB7CiAgIHN0cnVjdCBkd2FyZjJfY3UgKmN1ID0gcmVhZGVyLT5jdTsKICAgc3dpdGNo IChhdHRyLT5mb3JtKQpAQCAtMTkxMTIsNiArMTkyNTQsOSBAQCByZWFkX2F0dHJpYnV0ZV9yZXBy b2Nlc3MgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCiAgICAgICBjYXNl IERXX0ZPUk1fbG9jbGlzdHg6CiAJIERXX1VOU05EIChhdHRyKSA9IHJlYWRfbG9jbGlzdF9pbmRl eCAoY3UsIERXX1VOU05EIChhdHRyKSk7CiAJIGJyZWFrOworICAgICAgY2FzZSBEV19GT1JNX3Ju Z2xpc3R4OgorICAgICAgICBEV19VTlNORCAoYXR0cikgPSByZWFkX3JuZ2xpc3RfaW5kZXggKGN1 LCBEV19VTlNORCAoYXR0ciksIHRhZyk7CisgICAgICAgIGJyZWFrOwogICAgICAgY2FzZSBEV19G T1JNX3N0cng6CiAgICAgICBjYXNlIERXX0ZPUk1fc3RyeDE6CiAgICAgICBjYXNlIERXX0ZPUk1f c3RyeDI6CkBAIC0xOTI5Myw4ICsxOTQzOCwxMCBAQCByZWFkX2F0dHJpYnV0ZV92YWx1ZSAoY29u c3Qgc3RydWN0IGRpZV9yZWFkZXJfc3BlY3MgKnJlYWRlciwKICAgICAgIERXX1NORCAoYXR0cikg PSByZWFkX3NpZ25lZF9sZWIxMjggKGFiZmQsIGluZm9fcHRyLCAmYnl0ZXNfcmVhZCk7CiAgICAg ICBpbmZvX3B0ciArPSBieXRlc19yZWFkOwogICAgICAgYnJlYWs7Ci0gICAgY2FzZSBEV19GT1JN X3VkYXRhOgogICAgIGNhc2UgRFdfRk9STV9ybmdsaXN0eDoKKyAgICAgICpuZWVkX3JlcHJvY2Vz cyA9IHRydWU7CisgICAgICAvKiBGQUxMVEhST1VHSCAqLworICAgIGNhc2UgRFdfRk9STV91ZGF0 YToKICAgICAgIERXX1VOU05EIChhdHRyKSA9IHJlYWRfdW5zaWduZWRfbGViMTI4IChhYmZkLCBp bmZvX3B0ciwgJmJ5dGVzX3JlYWQpOwogICAgICAgaW5mb19wdHIgKz0gYnl0ZXNfcmVhZDsKICAg ICAgIGJyZWFrOwpAQCAtMjMzODMsNiArMjM1MzAsMzAgQEAgY3VfZGVidWdfbG9jX3NlY3Rpb24g KHN0cnVjdCBkd2FyZjJfY3UgKmN1KQogCQkJCSAgOiAmcGVyX29iamZpbGUtPnBlcl9iZmQtPmxv Yyk7CiB9CiAKKy8qIFJldHVybiB0aGUgLmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24gdG8gdXNlIGZv ciBDVS4gICovCitzdGF0aWMgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gKgorY3VfZGVidWdf cm5nbGlzdHNfc2VjdGlvbiAoc3RydWN0IGR3YXJmMl9jdSAqY3UsIGR3YXJmX3RhZyB0YWcpCit7 CisgIGlmIChjdS0+aGVhZGVyLnZlcnNpb24gPCA1KQorICAgIGVycm9yIChfKCIuZGVidWdfcm5n bGlzdHMgc2VjdGlvbiBjYW5ub3QgYmUgdXNlZCBpbiBEV0FSRiAlZCIpLAorCSAgIGN1LT5oZWFk ZXIudmVyc2lvbik7CisgIHN0cnVjdCBkd2FyZjJfcGVyX29iamZpbGUgKmR3YXJmMl9wZXJfb2Jq ZmlsZSA9IGN1LT5wZXJfb2JqZmlsZTsKKworICAvKiBNYWtlIHN1cmUgd2UgcmVhZCB0aGUgLmRl YnVnX3JuZ2xpc3RzIHNlY3Rpb24gZnJvbSB0aGUgZmlsZSB0aGF0CisgICAgIGNvbnRhaW5zIHRo ZSBEV19BVF9yYW5nZXMgYXR0cmlidXRlIHdlIGFyZSByZWFkaW5nLiAgTm9ybWFsbHkgdGhhdAor ICAgICB3b3VsZCBiZSB0aGUgLmR3byBmaWxlLCBpZiB0aGVyZSBpcyBvbmUuICBIb3dldmVyIGZv ciBEV19UQUdfY29tcGlsZV91bml0CisgICAgIHdlIGFsd2F5cyB3YW50IHRvIHJlYWQgZnJvbSBv YmpmaWxlL2xpbmtlZCBwcm9ncmFtICh3aGljaCB3b3VsZCBiZSB0aGUKKyAgICAgRFdfVEFHX3Nr ZWxldG9uX3VuaXQgRElFIGlmIHdlJ3JlIHVzaW5nIHNwbGl0IGR3YXJmKS4gICovCisgIGlmIChj dS0+ZHdvX3VuaXQgIT0gbnVsbHB0ciAmJiB0YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdCkKKyAg ICB7CisgICAgICBzdHJ1Y3QgZHdvX3NlY3Rpb25zICpzZWN0aW9ucyA9ICZjdS0+ZHdvX3VuaXQt PmR3b19maWxlLT5zZWN0aW9uczsKKworICAgICAgaWYgKHNlY3Rpb25zLT5ybmdsaXN0cy5zaXpl ID4gMCkKKwlyZXR1cm4gJnNlY3Rpb25zLT5ybmdsaXN0czsKKyAgICB9CisgIHJldHVybiAmZHdh cmYyX3Blcl9vYmpmaWxlLT5wZXJfYmZkLT5ybmdsaXN0czsKK30KKwogLyogQSBoZWxwZXIgZnVu Y3Rpb24gdGhhdCBmaWxscyBpbiBhIGR3YXJmMl9sb2NsaXN0X2JhdG9uLiAgKi8KIAogc3RhdGlj IHZvaWQKZGlmZiAtLWdpdCBhL2dkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10 ZXN0LmNjIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMC4uODE2OTNmNTY5ZAotLS0gL2Rldi9u dWxsCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10ZXN0LmNjCkBA IC0wLDAgKzEsOTcgQEAKKy8qIFRoaXMgdGVzdGNhc2UgaXMgcGFydCBvZiBHREIsIHRoZSBHTlUg ZGVidWdnZXIuCisKKyAgIENvcHlyaWdodCAyMDIwIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwg SW5jLgorCisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUg R2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3 YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgICAo YXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHByb2dyYW0gaXMg ZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAgIGJ1dCBX SVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9m CisgICBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxz LgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJh bCBQdWJsaWMgTGljZW5zZQorICAgYWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNl ZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCisjaW5jbHVkZSA8aW9zdHJl YW0+CisjaW5jbHVkZSA8dmVjdG9yPgorCitzdHJ1Y3Qgbm9kZSB7CisgIGludCBpZDsKKyAgbm9k ZSAqbGVmdDsKKyAgbm9kZSAqcmlnaHQ7CisgIGJvb2wgdmlzaXRlZDsKK307CisKK25vZGUgIG5v ZGVfYXJyYXlbNTBdOwordW5zaWduZWQgaW50IENVUl9JRFggPSAwOworCitub2RlICoKK21ha2Vf bm9kZSAoaW50IHZhbCkKK3sKKyAgbm9kZSAqbmV3X25vZGUgPSAmKG5vZGVfYXJyYXlbQ1VSX0lE WCsrXSk7CisgIG5ld19ub2RlLT5sZWZ0ID0gTlVMTDsKKyAgbmV3X25vZGUtPnJpZ2h0ID0gTlVM TDsKKyAgbmV3X25vZGUtPmlkID0gdmFsOworICBuZXdfbm9kZS0+dmlzaXRlZCA9IGZhbHNlOwor CisgIHJldHVybiBuZXdfbm9kZTsKK30KKwordm9pZAordHJlZV9pbnNlcnQgKG5vZGUgKnJvb3Qs IGludCB2YWwpCit7CisgIGlmICh2YWwgPCByb290LT5pZCkKKyAgICB7CisgICAgICBpZiAocm9v dC0+bGVmdCkKKyAgICAgICAgdHJlZV9pbnNlcnQgKHJvb3QtPmxlZnQsIHZhbCk7CisgICAgICBl bHNlCisgICAgICAgIHJvb3QtPmxlZnQgPSBtYWtlX25vZGUodmFsKTsKKyAgICB9CisgIGVsc2Ug aWYgKHZhbCA+IHJvb3QtPmlkKQorICAgIHsKKyAgICAgIGlmIChyb290LT5yaWdodCkKKyAgICAg ICAgdHJlZV9pbnNlcnQgKHJvb3QtPnJpZ2h0LCB2YWwpOworICAgICAgZWxzZQorICAgICAgICBy b290LT5yaWdodCA9IG1ha2Vfbm9kZSh2YWwpOworICAgIH0KK30KKwordm9pZAoraW5vcmRlciAo bm9kZSAqcm9vdCkKK3sKKyAgc3RkOjp2ZWN0b3I8bm9kZSAqPiB0b2RvOworICB0b2RvLnB1c2hf YmFjayAocm9vdCk7CisgIHdoaWxlICghdG9kby5lbXB0eSgpKQorICAgIHsKKyAgICAgIG5vZGUg KmN1cnIgPSB0b2RvLmJhY2soKTsKKyAgICAgIHRvZG8ucG9wX2JhY2soKTsgLyogYnJlYWstaGVy ZSAqLworICAgICAgaWYgKGN1cnItPnZpc2l0ZWQpCisgICAgICAgIHN0ZDo6Y291dCA8PCBjdXJy LT5pZCA8PCAiICI7CisgICAgICBlbHNlCisgICAgICAgIHsKKyAgICAgICAgICBjdXJyLT52aXNp dGVkID0gdHJ1ZTsKKyAgICAgICAgICBpZiAoY3Vyci0+cmlnaHQpCisgICAgICAgICAgICB0b2Rv LnB1c2hfYmFjayAoY3Vyci0+cmlnaHQpOworICAgICAgICAgIHRvZG8ucHVzaF9iYWNrIChjdXJy KTsKKyAgICAgICAgICBpZiAoY3Vyci0+bGVmdCkKKyAgICAgICAgICAgIHRvZG8ucHVzaF9iYWNr IChjdXJyLT5sZWZ0KTsKKyAgICAgICAgfQorICAgIH0KK30KKworaW50CittYWluIChpbnQgYXJn YywgY2hhciAqKmFyZ3YpCit7CisgIG5vZGUgKnJvb3QgPSBtYWtlX25vZGUgKDM1KTsKKworICB0 cmVlX2luc2VydCAocm9vdCwgMjgpOworICB0cmVlX2luc2VydCAocm9vdCwgMjApOworICB0cmVl X2luc2VydCAocm9vdCwgNjApOworCisgIGlub3JkZXIgKHJvb3QpOworCisgIHJldHVybiAwOwor fQpkaWZmIC0tZ2l0IGEvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3Qu ZXhwIGIvZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuZXhwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAuLmFmNmMzNGI1ZGQKLS0tIC9kZXYvbnVs bAorKysgYi9nZGIvdGVzdHN1aXRlL2dkYi5kd2FyZjIvZHc1LXJuZ2xpc3QtdGVzdC5leHAKQEAg LTAsMCArMSw0MCBAQAorIyBDb3B5cmlnaHQgMjAyMCBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24s IEluYy4KKworIyBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3Ry aWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorIyB0aGUgRnJlZSBTb2Z0d2Fy ZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorIyAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorIworIyBUaGlzIHByb2dyYW0gaXMgZGlz dHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyMgYnV0IFdJVEhP VVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyMg TUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2Vl IHRoZQorIyBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIwor IyBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJs aWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRw Oi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4KKworIyBDaGVjayB0aGF0IEdEQiBjYW4gZmluZCB0 aGUgdmFyaWFibGVzIGluIGEgbGV4aWNhbCBibG9jayB3aXRoIGEKKyMgRFdfRk9STV9ybmdsaXN0 eCBEV19BVF9yYW5nZXMgZmllbGQuICBUaGlzIHRlc3QgaXMgaW50ZW5kZWQgZm9yIERXQVJGLTUs CisjIGNvbXBpbGVkIHdpdGggY2xhbmcrKy4KKworc3RhbmRhcmRfdGVzdGZpbGUgLmNjCisKKyMg VGhpcyB0ZXN0IGlzIGludGVuZGVkIGZvciB0YXJnZXRzIHdoaWNoIHN1cHBvcnQgRFdBUkYtNS4K KyMgU2luY2Ugd2UgcGFzcyBhbiBleHBsaWNpdCAtZ2R3YXJmLTUgdG8gdGhlIGNvbXBpbGVyLAor IyB3ZSBsZXQgdGhhdCBiZSB0aGUgdGVzdCBvZiB3aGV0aGVyIHRoZSB0YXJnZXQgc3VwcG9ydHMg aXQuCisKK2lmIHsgW3ByZXBhcmVfZm9yX3Rlc3RpbmcgImZhaWxlZCB0byBwcmVwYXJlIiAiJHt0 ZXN0ZmlsZX0iIFwKKyAgICAgICAgICAkc3JjZmlsZSB7ZGVidWcgYysrIGFkZGl0aW9uYWxfZmxh Z3M9LWdkd2FyZi01IFwKKyAgICAgICAgICAgICAgICAgICAgICAgIGFkZGl0aW9uYWxfZmxhZ3M9 LU8wfV0gfSB7CisgICAgcmV0dXJuIC0xCit9CisKK2lmICFbcnVudG9fbWFpbl0geworICAgIHJl dHVybiAtMQorfQorCitnZGJfYnJlYWtwb2ludCBbZ2RiX2dldF9saW5lX251bWJlciAiYnJlYWst aGVyZSJdCitnZGJfY29udGludWVfdG9fYnJlYWtwb2ludCAiYnJlYWstaGVyZSIgIi4qIGJyZWFr LWhlcmUgLioiCisKK2dkYl90ZXN0ICJwcmludCBjdXJyIiAiXFxcKG5vZGUgXFxcKlxcXCkgJGhl eCA8bm9kZV9hcnJheT4iCitnZGJfdGVzdCAicHJpbnQgKmN1cnIiICI9IHtpZCA9IDM1LCBsZWZ0 ID0gJGhleCA8bm9kZV9hcnJheVxcKyRkZWNpbWFsPiwgcmlnaHQgPSAkaGV4IDxub2RlX2FycmF5 XFwrJGRlY2ltYWw+LCB2aXNpdGVkID0gZmFsc2V9IgotLSAKMi4yNy4wLjM4My5nMDUwMzE5YzJh ZS1nb29nCgo= --0000000000007c158605aa042900--