From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-io1-xd43.google.com (mail-io1-xd43.google.com [IPv6:2607:f8b0:4864:20::d43]) by sourceware.org (Postfix) with ESMTPS id A3EE73851C09 for ; Fri, 3 Jul 2020 22:47:29 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org A3EE73851C09 Received: by mail-io1-xd43.google.com with SMTP id a12so33819187ion.13 for ; Fri, 03 Jul 2020 15:47:29 -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=gdgEHViKdRW5Pndalr0LLz6nwpRvzdc9Zv+C+LsE9yo=; b=saiQQuCprOYartyJ1REH5de0wRY9mFmh+Hb6GIwOzW5ITYj5Q8NChuU6iNuQHK5Du+ oI32PhRIdOyq3DT9b+ayxjSkvlcrnxbxOfLmoL+EnW3kuFHR+V0h5LyikQg24Qa37oBW VpXULdax5D/MlvsPjR3hvXtIrdMe2LVXOV58U8TVUFoO0RGsBMq5tGT4YjwS9LiJajI8 iX7RP2fIGMSyRlagu3LQgxkEmz2hLOcVtDz25TOpsAJrAaDeRAVVsOUAmvjCZQ7U7g+5 HSh/8yY6Fzbc32WcUGBUKKiSAKFLxW/bTiowFdM7LapqWCo0tAvPnWrHl9izCTVIk4UZ 5fVw== X-Gm-Message-State: AOAM532JpW5quva08lQXdhaFo9U+rM+DTNkULYXaRwr+l9xH0v2iK2SM I5tIeo0bvnaA8LnIPrsxXeaH7Bdz4diHMPJnd0W/zqAhDXs= X-Google-Smtp-Source: ABdhPJzzWtXjbPpYHxG+pS5QQpKuNTufSGTXi7O4MEBJMsfR+CMgLnIFlVJrF5cDbnEw5bZz2DqLahoRfFlrxiZA99U= X-Received: by 2002:a5e:a60d:: with SMTP id q13mr14190526ioi.199.1593816448582; Fri, 03 Jul 2020 15:47:28 -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> In-Reply-To: From: Caroline Tice Date: Fri, 3 Jul 2020 15:47:17 -0700 Message-ID: Subject: [PATCH V3] 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="00000000000041dcee05a9914f9d" X-Spam-Status: No, score=-24.7 required=5.0 tests=BAYES_00, DKIMWL_WL_MED, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, ENV_AND_HDR_SPF_MATCH, GIT_PATCH_0, 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=ham 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: Fri, 03 Jul 2020 22:47:32 -0000 --00000000000041dcee05a9914f9d Content-Type: text/plain; charset="UTF-8" " 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. > 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. 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 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). The test of your requested changes are in the attached patch. -- Caroline cmtice@google.com 2020-07-03 Caroline Tice * dwarf2/read.c (struct dwop_section_names): Add rnglists_dwo. (dwop_section_names): Add .debug_rnglists.dwo, .zdebug_rnglists.dwo. (struct dwo_sections): Add rnglists field. (dwarf2_ranges_read): Add tag parameter. (cu_debug_rnglist_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). (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. Also pass die tag to dwarf2_ranges_read. (dwarf2_record_block_ranges): Check for DW_FORM_rnglistx when setting need_ranges_base. 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. (partial_die_info::read): Check for DW_FORM_rnglistx when setting need_ranges_base. Also pass die tag to dwarf2_ranges_read. (read_rnglist_index): New function. (read_attribute_reprocess): Add code for DW_FORM_rnglistx. (read_attribute_value): Mark DW_FORM_rnglistx with need_reprocess. gdb/testsuite/ChangeLog entry: 2020-07-03 Caroline Tice * gdb.dwarf2/dw5-rnglist-test.cc: New file. * gdb.dwarf2/dw5-rnglist-test.exp: New file. On Wed, Jul 1, 2020 at 10:41 PM Simon Marchi wrote: > > On 2020-07-01 3:57 p.m., Caroline Tice via Gdb-patches wrote: > > I created the attached patch with git format-patch; I've never used > > that before, so I'm hoping I got it right. :-) > > Very nice, thanks. > > > Please let me know if there's anything else you need/want for approval. > > Thanks for that. I'd appreciate if the commit message contained a bit more > of the rationale for the change (in addition to what you have already put > in there). Basically, what you explained in your first message. > > > @@ -1379,11 +1385,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); > > > > /* 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_rnglist_section > > + (struct dwarf2_cu *cu); > > Nit, this function should probably be called cu_debug_rnglists_section (with an `s` > to rnglists). > > > @@ -13802,17 +13820,36 @@ 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) > > + /* If the DW_AT_ranges attribute was part of a DW_TAG_skeleton_unit that was > > + changed into a DW_TAG_compile_unit after calling read_cutu_die_from_dwo, > > + we want to use the rnglist in the objfile rather than the one in the > > + dwo_unit. */ > > I think that can be explained more simply as: we want to use the .debug_rnglists > section from the file the DW_AT_ranges attribute we're reading came from. If it's > on DW_TAG_compile_unit, it was actually on the DW_TAG_skeleton_unit DIE, in the > objfile / linked program. Otherwise, it was on some other DIE in the dwo. > > > + if (tag == DW_TAG_compile_unit > > + && cu->cu_ranges_from_skeleton) > > I'm wondering if this `cu_ranges_from_skeleton` boolean is really necessary. There > cannot be a DW_AT_ranges attribute on a DW_TAG_compile_unit inside a dwo file (see > DWARF 5, section 3.1.3). So if we're reading a DW_AT_ranges on a DW_TAG_compile_unit, > it's either because: > > - it's a standard non-split DW_TAG_compile_unit > - it's a DW_TAG_skeleton_unit that was transformed into a DW_TAG_compile_unit by > read_cutu_die_from_dwo, as you said (I didn't know it did that) > > In both of these cases, the rnglists section to use should be the one from the objfile, > not the one from the dwo. The DW_TAG_skeleton_unit in the main objfile can have > a DW_AT_ranges attribute, while the associated DW_TAG_compile_unit in the dwo can't. > > So the condition could probably just be: > > if (cu->dwo_unit != nullptr && tag != DW_TAG_compile_unit) > rnglists_section = &cu->dwo_unit->dwo_file->sections.rnglists; > else > rnglists_section = &per_objfile->per_bfd->rnglists; > > If there's a dwo_unit, the DW_TAG_compile_unit (transformed from DW_TAG_skeleton_unit) > will be the only DIE in the CU, so the only one to use the rnglists from the main objfile. > All the conceptual children DIEs contained in the dwo will use the rnglists from the dwo. > > > + ignore_dwo_unit = true; > > + > > + /* Else, if there's a dwo_unit, we want the rnglist from the dwo file. */ > > + if (cu->dwo_unit > > + && cu->dwo_unit->dwo_file->sections.rnglists.size > 0 > > + && !ignore_dwo_unit) > > + rnglists_section = &cu->dwo_unit->dwo_file->sections.rnglists; > > + else > > + rnglists_section = &per_objfile->per_bfd->rnglists; > > I'm not sure the `cu->dwo_unit->dwo_file->sections.rnglists.size > 0` part of the condition > is right. Let's say you have some DIE inside the dwo with a DW_AT_ranges attriute, but the > rnglists section from the dwo is either missing or empty. That code will end up reading the > rnglists from the objfile, which is wrong: a DW_AT_ranges in a dwo always refers to the > rnglists section of the dwo, right? > > It would be a good thing to test for fun, strip the .debug_rnglists.dwo section from the dwo > and see what happens. > > > @@ -13889,7 +13944,20 @@ dwarf2_rnglists_process (unsigned offset, struct dwarf2_cu *cu, > > range_end = cu->header.read_address (obfd, buffer, &bytes_read); > > buffer += bytes_read; > > break; > > - default: > > + case DW_RLE_startx_endx: > > + addr_index = read_unsigned_leb128 (obfd, buffer, &bytes_read); > > + buffer += bytes_read; > > + range_beginning = read_addr_index (cu, addr_index); > > + if (buffer > buf_end) > > + { > > + overflow = true; > > + break; > > + } > > + addr_index = read_unsigned_leb128 (obfd, buffer, &bytes_read); > > + buffer += bytes_read; > > + range_end = read_addr_index (cu, addr_index); > > + break; > > + default: > > Remove the space at the beginning of the line (before the tab). > > > complaint (_("Invalid .debug_rnglists data (no base address)")); > > return false; > > } > > @@ -13917,8 +13985,12 @@ 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) > > + { > > + range_beginning += *base; > > + range_end += *base; > > + } > > That makes sense. The DWARF standard says, about DW_RLE_base_address: > > ...that indicates the applicable base address used by following > DW_RLE_offset_pair entries. > > However, see this check a few lines above: > > if (!base.has_value ()) > { > /* We have no valid base address for the ranges > data. */ > complaint (_("Invalid .debug_rnglists data (no base address)")); > return false; > } > > Should that be moved inside the `if (rlet == DW_RLE_offset_pair)`? It > only matters that we don't have a base if we're going to use it, and that's > if `rlet == DW_RLE_offset_pair`. > > > @@ -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. > > 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? > > > @@ -19094,6 +19175,49 @@ 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); > > + ULONGEST rnglist_base = > > + (cu->dwo_unit) ? rnglist_header_size : cu->ranges_base; > > + > > + struct dwarf2_section_info *section = cu_debug_rnglist_section (cu); > > + if (section == nullptr) > > + error (_("Cannot find .debug_rnglists section [in module %s]"), > > + objfile_name(objfile)); > > + section->read (objfile); > > + if (section->buffer == NULL) > > + error (_("DW_FORM_rnglistx used without .debug_rnglists section " > > + "[in module %s]"), > > + objfile_name (objfile)); > > + struct loclist_header header; > > + read_loclist_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)); > > + if (rnglist_base + rnglist_index * cu->header.offset_size > > + >= 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 + rnglist_base + rnglist_index * cu->header.offset_size; > > Factor out `rnglist_base + rnglist_index * cu->header.offset_size` into > an `offset` variable. > > > + > > + 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; > > Please use some empty lines in the code to separate logical block. I find > it really hard to follow, packed like this. At the very least, after the > `if` statements, put an empty line. Comments that indicate what each block > does at high level are also helpful: > > + /* Get rnglists section. */ > + struct dwarf2_section_info *section = cu_debug_rnglist_section (cu); > + if (section == nullptr) > + error (_("Cannot find .debug_rnglists section [in module %s]"), > + objfile_name(objfile)); > + > + /* Read rnglists section content. */ > + section->read (objfile); > + if (section->buffer == NULL) > + error (_("DW_FORM_rnglistx used without .debug_rnglists section " > + "[in module %s]"), > + objfile_name (objfile)); > + > + /* Validate that the index is with the offset list range. */ > + struct loclist_header header; > + read_loclist_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)); > + > + /* Validate that the offset is in the section's range. */ > + if (rnglist_base + rnglist_index * cu->header.offset_size > + >= 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 + rnglist_base + rnglist_index * cu->header.offset_size; > > > > @@ -23382,6 +23511,25 @@ 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_rnglist_section (struct dwarf2_cu *cu) > > +{ > > + 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; > > + > > + if (cu->dwo_unit) > > When checking pointers, use an explicit ` == nullptr` / ` != nullptr`. > > > + { > > + 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; > > This function is called to get the right rnglists section in the > read_rnglist_index function. I don't understand how this can work. > When there is a dwo, the read_rnglist_index can be used to read a > range list either for the main file (the DW_AT_ranges on the > DW_TAG_skeleton_unit) or for the dwo file (the DW_AT_ranges on a > DW_TAG_lexical_block). > > This function here always return the dwo section if a dwo is > present... which would be wrong for when reading the DW_AT_ranges > on the DW_TAG_skeleton_unit? > > Ok, I debugged GDB to see when this gets called. It works because > when reading the DW_TAG_skeleton_unit, `cu->dwo_unit` is still > NULL... so the first time cu_debug_rnglist_section gets called, it > returns the section in the main file, and the following times, it > returns the section in the dwo file. That seems a bit fragile to > me. For example, if the order of things change, like if we change > GDB to read the ranges lazily later, and `cu->dwo_unit` is not NULL > anymore when reading the DW_AT_ranges on DW_TAG_skeleton_unit, this > will return the wrong section. > > Perhaps a more robust way to decide which section to return would > be to use the same `cu->dwo_unit != nullptr && tag != DW_TAG_compile_unit` > trick from earlier? In fact, perhaps that other spot should call > cu_debug_rnglist_section instead of replicating the logic? > > > static void > > diff --git a/gdb/testsuite/gdb.dwarf2/dw5-rnglist-test.cc b/gdb/testsuite/gdb.dwarf2/dw5-rnglist-test.cc > > new file mode 100644 > > index 0000000000..17f78843d2 > > --- /dev/null > > +++ b/gdb/testsuite/gdb.dwarf2/dw5-rnglist-test.cc > > @@ -0,0 +1,88 @@ > > +/* This testcase is part of GDB, the GNU debugger. > > + > > + Copyright 2020 Free Software Foundation, Inc. > > + > > + This program is free software; you can redistribute it and/or modify > > + it under the terms of the GNU General Public License as published by > > + the Free Software Foundation; either version 3 of the License, or > > + (at your option) any later version. > > + > > + This program is distributed in the hope that it will be useful, > > + but WITHOUT ANY WARRANTY; without even the implied warranty of > > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > + GNU General Public License for more details. > > + > > + You should have received a copy of the GNU General Public License > > + along with this program. If not, see . */ > > + > > +#include > > +#include > > + > > +struct node { > > + int id; > > + node *left; > > + node *right; > > + bool visited; > > +}; > > + > > +node node_array[50]; > > +unsigned int CUR_IDX = 0; > > + > > +node * make_node (int val) > > +{ > > + node *new_node = &(node_array[CUR_IDX++]); > > + new_node->left = NULL; > > + new_node->right = NULL; > > + new_node->id = val; > > + new_node->visited = false; > > + > > + return new_node; > > +} > > + > > +void tree_insert (node *root, int val) > > +{ > > + if (val < root->id) > > + { > > + if (root->left) > > + tree_insert (root->left, val); > > + else > > + root->left = make_node(val); > > + } > > + else if (val > root->id) > > + { > > + if (root->right) > > + tree_insert (root->right, val); > > + else > > + root->right = make_node(val); > > + } > > +} > > + > > +void inorder(node *root) { > > + std::vector todo; > > + todo.push_back(root); > > + while (!todo.empty()){ > > + node *curr = todo.back(); > > + todo.pop_back(); /* break-here */ > > + if (curr->visited) { > > + std::cout << curr->id << " "; > > + } else { > > + curr->visited = true; > > + if (curr->right) { todo.push_back(curr->right); } > > + todo.push_back(curr); > > + if (curr->left) { todo.push_back(curr->left); } > > + } > > + } > > +} > > + > > +int main (int argc, char **argv) > > +{ > > + node *root = make_node (35); > > + > > + tree_insert (root, 28); > > + tree_insert (root, 20); > > + tree_insert (root, 60); > > + > > + inorder (root); > > + > > + return 0; > > +} > > We try to format the test cases using the same style as the rest of the > source code. Could you please update this to follow the same rules? > > Simon --00000000000041dcee05a9914f9d Content-Type: application/octet-stream; name="v3-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Disposition: attachment; filename="v3-0001-Update-GDB-to-fix-issues-with-handling-DWARF-v5-r.patch" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_kc6sszr90 RnJvbSBmNzVmYmZkN2E4MDBjZWE3YTRmMWM1YTQzZDQwOTQ4MDYxYWZkYjgyIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBDYXJvbGluZSBUaWNlIDxjbXRpY2VAZ29vZ2xlLmNvbT4KRGF0 ZTogV2VkLCAxIEp1bCAyMDIwIDEyOjM5OjA4IC0wNzAwClN1YmplY3Q6IFtQQVRDSCB2M10gVXBk YXRlIEdEQiB0byBmaXggaXNzdWVzIHdpdGggaGFuZGxpbmcgRFdBUkYgdjUgcm5nbGlzdHMgJgog LmR3byBmaWxlcy4KCldoaWxlIGV4cGVyaW1lbnRpbmcgd2l0aCBHREIgb24gRFdBUkYgNSB3aXRo IHNwbGl0IGRlYnVnIChkd28gZmlsZXMpLApJIGRpc2NvdmVyZWQgdGhhdCBHREIgd2FzIG5vdCBy ZWFkaW5nIHRoZSBybmdsaXN0IGluZGV4CnByb3Blcmx5IChpdCBuZWVkZWQgdG8gYmUgcmVwcm9j ZXNzZWQgaW4gdGhlIHNhbWUgd2F5IHRoZSBsb2NsaXN0CmluZGV4IGRvZXMpLCBhbmQgdGhhdCB0 aGVyZSB3YXMgbm8gY29kZSBmb3IgcmVhZGluZyBybmdsaXN0cyBvdXQgb2YKZHdvIGZpbGVzIGF0 IGFsbC4gIEFsc28sIHRoZSBybmdsaXN0IGFkZHJlc3MgcmVhZGluZyBmdW5jdGlvbgooZHdhcmYy X3JuZ2xpc3RzX3Byb2Nlc3MpIHdhcyBhZGRpbmcgdGhlIGJhc2UgYWRkcmVzcyB0byBhbGwgcm5n bGlzdAplbnRyaWVzLCB3aGVuIGl0J3Mgb25seSBzdXBwb3NlZCB0byBhZGQgaXQgdG8gdGhlIERX X1JMRV9vZmZzZXRfcGFpcgplbnRyaWVzIChodHRwOi8vZHdhcmZzdGQub3JnL2RvYy9EV0FSRjUu cGRmLCBwLiA1MyksIGFuZCB3YXMgbm90CmhhbmRsaW5nIHNldmVyYWwgZW50cnkgdHlwZXMuCgot IEFkZGVkICdyZXByb2Nlc3NpbmcnIGZvciByZWFkaW5nIHJuZ2xpc3QgaW5kZXggKGFzIGlzIGRv bmUgZm9yIGxvY2xpc3QKICBpbmRleCkuCi0gQWRkZWQgY29kZSBmb3IgcmVhZGluZyBybmdsaXN0 cyBvdXQgb2YgLmR3byBmaWxlcy4KLSBBZGRlZCBzZXZlcmFsIG1pc3Npbmcgcm5nbGlzdCBmb3Jt cyB0byBkd2FyZjJfcm5nbGlzdHNfcHJvY2Vzcy4KLSBGaXhlZCBidWcgdGhhdCB3YXMgYWx3YXlh cyBhZGRpbmcgYmFzZSBhZGRyZXNzIGZvciBybmdsaXN0cyAob25seQogIG9uZSBmb3JtIG5lZWRz IHRoYXQpLgotIFVwZGF0ZWQgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgdG8gcmVhZCBybmdsaXN0 IG91dCBvZiBkd28gZmlsZSB3aGVuCiAgYXBwcm9wcmlhdGUuCi0gQWRkZWQgbmV3IGZ1bmN0aW9u cyBjdV9kZWJ1Z19ybmdsaXN0X3NlY3Rpb24gJiByZWFkX3JuZ2xpc3RfaW5kZXguCi0gQWRkZWQg bmV3IHRlc3RjYXNlLCBkdzUtcm5nbGlzdC10ZXN0LntjYyxleHB9Ci0tLQogZ2RiL2R3YXJmMi9y ZWFkLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgMjA0ICsrKysrKysrKysrKysrKy0t LQogZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MgIHwgIDk3ICsr KysrKysrKwogZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuZXhwIHwg IDQwICsrKysKIDMgZmlsZXMgY2hhbmdlZCwgMzEzIGluc2VydGlvbnMoKyksIDI4IGRlbGV0aW9u cygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGdkYi90ZXN0c3VpdGUvZ2RiLmR3YXJmMi9kdzUtcm5n bGlzdC10ZXN0LmNjCiBjcmVhdGUgbW9kZSAxMDA2NDQgZ2RiL3Rlc3RzdWl0ZS9nZGIuZHdhcmYy L2R3NS1ybmdsaXN0LXRlc3QuZXhwCgpkaWZmIC0tZ2l0IGEvZ2RiL2R3YXJmMi9yZWFkLmMgYi9n ZGIvZHdhcmYyL3JlYWQuYwppbmRleCA0NjIyZDE0YTA1Li4xZDg5YzgxZTBkIDEwMDY0NAotLS0g YS9nZGIvZHdhcmYyL3JlYWQuYworKysgYi9nZGIvZHdhcmYyL3JlYWQuYwpAQCAtMzQwLDYgKzM0 MCw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgZHdvcF9zZWN0aW9uX25hbWVzCiAgIHN0cnVjdCBk d2FyZjJfc2VjdGlvbl9uYW1lcyBsb2NsaXN0c19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlv bl9uYW1lcyBtYWNpbmZvX2R3bzsKICAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX25hbWVzIG1hY3Jv X2R3bzsKKyAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX25hbWVzIHJuZ2xpc3RzX2R3bzsKICAgc3Ry dWN0IGR3YXJmMl9zZWN0aW9uX25hbWVzIHN0cl9kd287CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlv bl9uYW1lcyBzdHJfb2Zmc2V0c19kd287CiAgIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9uYW1lcyB0 eXBlc19kd287CkBAIC0zNTUsNiArMzU2LDcgQEAgZHdvcF9zZWN0aW9uX25hbWVzID0KICAgeyAi LmRlYnVnX2xvY2xpc3RzLmR3byIsICIuemRlYnVnX2xvY2xpc3RzLmR3byIgfSwKICAgeyAiLmRl YnVnX21hY2luZm8uZHdvIiwgIi56ZGVidWdfbWFjaW5mby5kd28iIH0sCiAgIHsgIi5kZWJ1Z19t YWNyby5kd28iLCAiLnpkZWJ1Z19tYWNyby5kd28iIH0sCisgIHsgIi5kZWJ1Z19ybmdsaXN0cy5k d28iLCAiLnpkZWJ1Z19ybmdsaXN0cy5kd28iIH0sCiAgIHsgIi5kZWJ1Z19zdHIuZHdvIiwgIi56 ZGVidWdfc3RyLmR3byIgfSwKICAgeyAiLmRlYnVnX3N0cl9vZmZzZXRzLmR3byIsICIuemRlYnVn X3N0cl9vZmZzZXRzLmR3byIgfSwKICAgeyAiLmRlYnVnX3R5cGVzLmR3byIsICIuemRlYnVnX3R5 cGVzLmR3byIgfSwKQEAgLTY1MCw2ICs2NTIsNyBAQCBzdHJ1Y3QgZHdvX3NlY3Rpb25zCiAgIHN0 cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvIGxvY2xpc3RzOwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rp b25faW5mbyBtYWNpbmZvOwogICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyBtYWNybzsKKyAg c3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gcm5nbGlzdHM7CiAgIHN0cnVjdCBkd2FyZjJfc2Vj dGlvbl9pbmZvIHN0cjsKICAgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gc3RyX29mZnNldHM7 CiAgIC8qIEluIHRoZSBjYXNlIG9mIGEgdmlydHVhbCBEV08gZmlsZSwgdGhlc2UgdHdvIGFyZSB1 bnVzZWQuICAqLwpAQCAtMTM3OSwxMSArMTM4MiwxNiBAQCBzdGF0aWMgdm9pZCByZWFkX2NhbGxf c2l0ZV9zY29wZSAoc3RydWN0IGRpZV9pbmZvICpkaWUsIHN0cnVjdCBkd2FyZjJfY3UgKmN1KTsK IHN0YXRpYyB2b2lkIHJlYWRfdmFyaWFibGUgKHN0cnVjdCBkaWVfaW5mbyAqZGllLCBzdHJ1Y3Qg ZHdhcmYyX2N1ICpjdSk7CiAKIHN0YXRpYyBpbnQgZHdhcmYyX3Jhbmdlc19yZWFkICh1bnNpZ25l ZCwgQ09SRV9BRERSICosIENPUkVfQUREUiAqLAotCQkJICAgICAgIHN0cnVjdCBkd2FyZjJfY3Ug KiwgZHdhcmYyX3BzeW10YWIgKik7CisJCQkgICAgICAgc3RydWN0IGR3YXJmMl9jdSAqLCBkd2Fy ZjJfcHN5bXRhYiAqLAorCQkJICAgICAgIGR3YXJmX3RhZyk7CiAKIC8qIFJldHVybiB0aGUgLmRl YnVnX2xvY2xpc3RzIHNlY3Rpb24gdG8gdXNlIGZvciBjdS4gICovCiBzdGF0aWMgc3RydWN0IGR3 YXJmMl9zZWN0aW9uX2luZm8gKmN1X2RlYnVnX2xvY19zZWN0aW9uIChzdHJ1Y3QgZHdhcmYyX2N1 ICpjdSk7CiAKKy8qIFJldHVybiB0aGUgLmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24gdG8gdXNlIGZv ciBjdS4gICovCitzdGF0aWMgc3RydWN0IGR3YXJmMl9zZWN0aW9uX2luZm8gKmN1X2RlYnVnX3Ju Z2xpc3RzX3NlY3Rpb24KKyAgKHN0cnVjdCBkd2FyZjJfY3UgKmN1KTsKKwogLyogSG93IGR3YXJm Ml9nZXRfcGNfYm91bmRzIGNvbnN0cnVjdGVkIGl0cyAqTE9XUEMgYW5kICpISUdIUEMgcmV0dXJu CiAgICB2YWx1ZXMuICBLZWVwIHRoZSBpdGVtcyBvcmRlcmVkIHdpdGggaW5jcmVhc2luZyBjb25z dHJhaW50cyBjb21wbGlhbmNlLiAgKi8KIGVudW0gcGNfYm91bmRzX2tpbmQKQEAgLTEyNDQ4LDYg KzEyNDU2LDExIEBAIGR3YXJmMl9sb2NhdGVfZHdvX3NlY3Rpb25zIChiZmQgKmFiZmQsIGFzZWN0 aW9uICpzZWN0cCwgdm9pZCAqZHdvX3NlY3Rpb25zX3B0cikKICAgICAgIGR3b19zZWN0aW9ucy0+ bWFjcm8ucy5zZWN0aW9uID0gc2VjdHA7CiAgICAgICBkd29fc2VjdGlvbnMtPm1hY3JvLnNpemUg PSBiZmRfc2VjdGlvbl9zaXplIChzZWN0cCk7CiAgICAgfQorICBlbHNlIGlmIChzZWN0aW9uX2lz X3AgKHNlY3RwLT5uYW1lLCAmbmFtZXMtPnJuZ2xpc3RzX2R3bykpCisgICAgeworICAgICAgZHdv X3NlY3Rpb25zLT5ybmdsaXN0cy5zLnNlY3Rpb24gPSBzZWN0cDsKKyAgICAgIGR3b19zZWN0aW9u cy0+cm5nbGlzdHMuc2l6ZSA9IGJmZF9zZWN0aW9uX3NpemUgKHNlY3RwKTsKKyAgICB9CiAgIGVs c2UgaWYgKHNlY3Rpb25faXNfcCAoc2VjdHAtPm5hbWUsICZuYW1lcy0+c3RyX2R3bykpCiAgICAg ewogICAgICAgZHdvX3NlY3Rpb25zLT5zdHIucy5zZWN0aW9uID0gc2VjdHA7CkBAIC0xMzc5Miw3 ICsxMzgwNSw3IEBAIHJlYWRfdmFyaWFibGUgKHN0cnVjdCBkaWVfaW5mbyAqZGllLCBzdHJ1Y3Qg ZHdhcmYyX2N1ICpjdSkKIHRlbXBsYXRlIDx0eXBlbmFtZSBDYWxsYmFjaz4KIHN0YXRpYyBib29s CiBkd2FyZjJfcm5nbGlzdHNfcHJvY2VzcyAodW5zaWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYy X2N1ICpjdSwKLQkJCSBDYWxsYmFjayAmJmNhbGxiYWNrKQorCQkJIGR3YXJmX3RhZyB0YWcsIENh bGxiYWNrICYmY2FsbGJhY2spCiB7CiAgIGR3YXJmMl9wZXJfb2JqZmlsZSAqcGVyX29iamZpbGUg PSBjdS0+cGVyX29iamZpbGU7CiAgIHN0cnVjdCBvYmpmaWxlICpvYmpmaWxlID0gcGVyX29iamZp bGUtPm9iamZpbGU7CkBAIC0xMzgwMiwxNyArMTM4MTUsMzMgQEAgZHdhcmYyX3JuZ2xpc3RzX3By b2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiAgIGNvbnN0IGdk Yl9ieXRlICpidWZmZXI7CiAgIENPUkVfQUREUiBiYXNlYWRkcjsKICAgYm9vbCBvdmVyZmxvdyA9 IGZhbHNlOworICBVTE9OR0VTVCBhZGRyX2luZGV4OworICBib29sIGlnbm9yZV9kd29fdW5pdCA9 IGZhbHNlOworICBzdHJ1Y3QgZHdhcmYyX3NlY3Rpb25faW5mbyAqcm5nbGlzdHNfc2VjdGlvbjsK IAogICBiYXNlID0gY3UtPmJhc2VfYWRkcmVzczsKIAotICBwZXJfb2JqZmlsZS0+cGVyX2JmZC0+ cm5nbGlzdHMucmVhZCAob2JqZmlsZSk7Ci0gIGlmIChvZmZzZXQgPj0gcGVyX29iamZpbGUtPnBl cl9iZmQtPnJuZ2xpc3RzLnNpemUpCisgIC8qIE1ha2Ugc3VyZSB3ZSByZWFkIHRoZSAuZGVidWdf cm5nbGlzdHMgc2VjdGlvbiBmcm9tIHRoZSBmaWxlIHRoYXQKKyAgICAgY29udGFpbnMgdGhlIERX X0FUX3JhbmdlcyBhdHRyaWJ1dGUgd2UgYXJlIHJlYWRpbmcuICBOb3JtYWxseSB0aGF0CisgICAg IHdvdWxkIGJlIHRoZSAuZHdvIGZpbGUsIGlmIHRoZXJlIGlzIG9uZS4gIEhvd2V2ZXIgZm9yIERX X1RBR19jb21waWxlX3VuaXQKKyAgICAgd2UgYWx3YXlzIHdhbnQgdG8gcmVhZCBmcm9tIG9iamZp bGUvbGlua2VkIHByb2dyYW0gKHdoaWNoIHdvdWxkIGJlIHRoZQorICAgICBEV19UQUdfc2tlbGV0 b25fdW5pdCBESUUgaWYgd2UncmUgdXNpbmcgc3BsaXQgZHdhcmYpLiAgKi8KKyAgaWYgKHRhZyA9 PSBEV19UQUdfY29tcGlsZV91bml0KQorICAgIGlnbm9yZV9kd29fdW5pdCA9IHRydWU7CisKKyAg aWYgKGN1LT5kd29fdW5pdCAhPSBudWxscHRyICYmICFpZ25vcmVfZHdvX3VuaXQpCisgICAgICBy bmdsaXN0c19zZWN0aW9uID0gJmN1LT5kd29fdW5pdC0+ZHdvX2ZpbGUtPnNlY3Rpb25zLnJuZ2xp c3RzOworICBlbHNlCisgICAgICBybmdsaXN0c19zZWN0aW9uID0gJnBlcl9vYmpmaWxlLT5wZXJf YmZkLT5ybmdsaXN0czsKKworICBybmdsaXN0c19zZWN0aW9uLT5yZWFkIChvYmpmaWxlKTsKKyAg aWYgKG9mZnNldCA+PSBybmdsaXN0c19zZWN0aW9uLT5zaXplKQogICAgIHsKICAgICAgIGNvbXBs YWludCAoXygiT2Zmc2V0ICVkIG91dCBvZiBib3VuZHMgZm9yIERXX0FUX3JhbmdlcyBhdHRyaWJ1 dGUiKSwKIAkJIG9mZnNldCk7CiAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgfQotICBidWZmZXIg PSBwZXJfb2JqZmlsZS0+cGVyX2JmZC0+cm5nbGlzdHMuYnVmZmVyICsgb2Zmc2V0OworICBidWZm ZXIgPSBybmdsaXN0c19zZWN0aW9uLT5idWZmZXIgKyBvZmZzZXQ7CiAKICAgYmFzZWFkZHIgPSBv YmpmaWxlLT50ZXh0X3NlY3Rpb25fb2Zmc2V0ICgpOwogCkBAIC0xMzgyMCw4ICsxMzg0OSw4IEBA IGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2FyZjJf Y3UgKmN1LAogICAgIHsKICAgICAgIC8qIEluaXRpYWxpemUgaXQgZHVlIHRvIGEgZmFsc2UgY29t cGlsZXIgd2FybmluZy4gICovCiAgICAgICBDT1JFX0FERFIgcmFuZ2VfYmVnaW5uaW5nID0gMCwg cmFuZ2VfZW5kID0gMDsKLSAgICAgIGNvbnN0IGdkYl9ieXRlICpidWZfZW5kID0gKHBlcl9vYmpm aWxlLT5wZXJfYmZkLT5ybmdsaXN0cy5idWZmZXIKLQkJCQkgKyBwZXJfb2JqZmlsZS0+cGVyX2Jm ZC0+cm5nbGlzdHMuc2l6ZSk7CisgICAgICBjb25zdCBnZGJfYnl0ZSAqYnVmX2VuZCA9IChybmds aXN0c19zZWN0aW9uLT5idWZmZXIKKwkJCQkgKyBybmdsaXN0c19zZWN0aW9uLT5zaXplKTsKICAg ICAgIHVuc2lnbmVkIGludCBieXRlc19yZWFkOwogCiAgICAgICBpZiAoYnVmZmVyID09IGJ1Zl9l bmQpCkBAIC0xMzg0Myw2ICsxMzg3MiwxMSBAQCBkd2FyZjJfcm5nbGlzdHNfcHJvY2VzcyAodW5z aWduZWQgb2Zmc2V0LCBzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwKIAkgIGJhc2UgPSBjdS0+aGVhZGVy LnJlYWRfYWRkcmVzcyAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CiAJICBidWZmZXIgKz0g Ynl0ZXNfcmVhZDsKIAkgIGJyZWFrOworICAgICAgICBjYXNlIERXX1JMRV9iYXNlX2FkZHJlc3N4 OgorICAgICAgICAgIGFkZHJfaW5kZXggPSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVm ZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAgICAgICAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7CisgICAg ICAgICAgYmFzZSA9IHJlYWRfYWRkcl9pbmRleCAoY3UsIGFkZHJfaW5kZXgpOworICAgICAgICAg IGJyZWFrOwogCWNhc2UgRFdfUkxFX3N0YXJ0X2xlbmd0aDoKIAkgIGlmIChidWZmZXIgKyBjdS0+ aGVhZGVyLmFkZHJfc2l6ZSA+IGJ1Zl9lbmQpCiAJICAgIHsKQEAgLTEzODYxLDYgKzEzODk1LDE5 IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2Fy ZjJfY3UgKmN1LAogCSAgICAgIGJyZWFrOwogCSAgICB9CiAJICBicmVhazsKKwljYXNlIERXX1JM RV9zdGFydHhfbGVuZ3RoOgorICAgICAgICAgIGFkZHJfaW5kZXggPSByZWFkX3Vuc2lnbmVkX2xl YjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAgICAgICAgYnVmZmVyICs9IGJ5 dGVzX3JlYWQ7CisgICAgICAgICAgcmFuZ2VfYmVnaW5uaW5nID0gcmVhZF9hZGRyX2luZGV4IChj dSwgYWRkcl9pbmRleCk7CisgICAgICAgICAgaWYgKGJ1ZmZlciA+IGJ1Zl9lbmQpCisgICAgICAg ICAgICB7CisgICAgICAgICAgICAgIG92ZXJmbG93ID0gdHJ1ZTsKKyAgICAgICAgICAgICAgYnJl YWs7CisgICAgICAgICAgICB9CisgICAgICAgICAgcmFuZ2VfZW5kID0gKHJhbmdlX2JlZ2lubmlu ZworICAgICAgICAgICAgICAgICAgICAgICArIHJlYWRfdW5zaWduZWRfbGViMTI4IChvYmZkLCBi dWZmZXIsICZieXRlc19yZWFkKSk7CisgICAgICAgICAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7Cisg ICAgICAgICAgYnJlYWs7CiAJY2FzZSBEV19STEVfb2Zmc2V0X3BhaXI6CiAJICByYW5nZV9iZWdp bm5pbmcgPSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7 CiAJICBidWZmZXIgKz0gYnl0ZXNfcmVhZDsKQEAgLTEzODg5LDYgKzEzOTM2LDE5IEBAIGR3YXJm Ml9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1 LAogCSAgcmFuZ2VfZW5kID0gY3UtPmhlYWRlci5yZWFkX2FkZHJlc3MgKG9iZmQsIGJ1ZmZlciwg JmJ5dGVzX3JlYWQpOwogCSAgYnVmZmVyICs9IGJ5dGVzX3JlYWQ7CiAJICBicmVhazsKKwljYXNl IERXX1JMRV9zdGFydHhfZW5keDoKKyAgICAgICAgICBhZGRyX2luZGV4ID0gcmVhZF91bnNpZ25l ZF9sZWIxMjggKG9iZmQsIGJ1ZmZlciwgJmJ5dGVzX3JlYWQpOworICAgICAgICAgIGJ1ZmZlciAr PSBieXRlc19yZWFkOworICAgICAgICAgIHJhbmdlX2JlZ2lubmluZyA9IHJlYWRfYWRkcl9pbmRl eCAoY3UsIGFkZHJfaW5kZXgpOworICAgICAgICAgIGlmIChidWZmZXIgPiBidWZfZW5kKQorICAg ICAgICAgICAgeworICAgICAgICAgICAgICBvdmVyZmxvdyA9IHRydWU7CisgICAgICAgICAgICAg IGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICAgIGFkZHJfaW5kZXggPSByZWFkX3Vuc2ln bmVkX2xlYjEyOCAob2JmZCwgYnVmZmVyLCAmYnl0ZXNfcmVhZCk7CisgICAgICAgICAgYnVmZmVy ICs9IGJ5dGVzX3JlYWQ7CisgICAgICAgICAgcmFuZ2VfZW5kID0gcmVhZF9hZGRyX2luZGV4IChj dSwgYWRkcl9pbmRleCk7CisgICAgICAgICAgYnJlYWs7CiAJZGVmYXVsdDoKIAkgIGNvbXBsYWlu dCAoXygiSW52YWxpZCAuZGVidWdfcm5nbGlzdHMgZGF0YSAobm8gYmFzZSBhZGRyZXNzKSIpKTsK IAkgIHJldHVybiBmYWxzZTsKQEAgLTEzODk4LDE0ICsxMzk1OCw2IEBAIGR3YXJmMl9ybmdsaXN0 c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQsIHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogICAgICAg aWYgKHJsZXQgPT0gRFdfUkxFX2Jhc2VfYWRkcmVzcykKIAljb250aW51ZTsKIAotICAgICAgaWYg KCFiYXNlLmhhc192YWx1ZSAoKSkKLQl7Ci0JICAvKiBXZSBoYXZlIG5vIHZhbGlkIGJhc2UgYWRk cmVzcyBmb3IgdGhlIHJhbmdlcwotCSAgICAgZGF0YS4gICovCi0JICBjb21wbGFpbnQgKF8oIklu dmFsaWQgLmRlYnVnX3JuZ2xpc3RzIGRhdGEgKG5vIGJhc2UgYWRkcmVzcykiKSk7Ci0JICByZXR1 cm4gZmFsc2U7Ci0JfQotCiAgICAgICBpZiAocmFuZ2VfYmVnaW5uaW5nID4gcmFuZ2VfZW5kKQog CXsKIAkgIC8qIEludmVydGVkIHJhbmdlIGVudHJpZXMgYXJlIGludmFsaWQuICAqLwpAQCAtMTM5 MTcsOCArMTM5NjksMjAgQEAgZHdhcmYyX3JuZ2xpc3RzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNl dCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiAgICAgICBpZiAocmFuZ2VfYmVnaW5uaW5nID09IHJh bmdlX2VuZCkKIAljb250aW51ZTsKIAotICAgICAgcmFuZ2VfYmVnaW5uaW5nICs9ICpiYXNlOwot ICAgICAgcmFuZ2VfZW5kICs9ICpiYXNlOworICAgICAgLyogT25seSBEV19STEVfb2Zmc2V0X3Bh aXIgbmVlZHMgdGhlIGJhc2UgYWRkcmVzcyBhZGRlZC4gICovCisgICAgICBpZiAocmxldCA9PSBE V19STEVfb2Zmc2V0X3BhaXIpCisJeworCSAgaWYgKCFiYXNlLmhhc192YWx1ZSAoKSkKKwkgICAg eworCSAgICAgIC8qIFdlIGhhdmUgbm8gdmFsaWQgYmFzZSBhZGRyZXNzIGZvciB0aGUgcmFuZ2Vz CisJCSBkYXRhLiAgKi8KKwkgICAgICBjb21wbGFpbnQgKF8oIkludmFsaWQgLmRlYnVnX3JuZ2xp c3RzIGRhdGEgKG5vIGJhc2UgYWRkcmVzcykiKSk7CisJICAgICAgcmV0dXJuIGZhbHNlOworCSAg ICB9CisKKwkgIHJhbmdlX2JlZ2lubmluZyArPSAqYmFzZTsKKwkgIHJhbmdlX2VuZCArPSAqYmFz ZTsKKwl9CiAKICAgICAgIC8qIEEgbm90LXVuY29tbW9uIGNhc2Ugb2YgYmFkIGRlYnVnIGluZm8u CiAJIERvbid0IHBvbGx1dGUgdGhlIGFkZHJtYXAgd2l0aCBiYWQgZGF0YS4gICovCkBAIC0xMzk1 MSw3ICsxNDAxNSw3IEBAIGR3YXJmMl9ybmdsaXN0c19wcm9jZXNzICh1bnNpZ25lZCBvZmZzZXQs IHN0cnVjdCBkd2FyZjJfY3UgKmN1LAogCiB0ZW1wbGF0ZSA8dHlwZW5hbWUgQ2FsbGJhY2s+CiBz dGF0aWMgaW50Ci1kd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0 IGR3YXJmMl9jdSAqY3UsCitkd2FyZjJfcmFuZ2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwg c3RydWN0IGR3YXJmMl9jdSAqY3UsIGR3YXJmX3RhZyB0YWcsCiAJCSAgICAgICBDYWxsYmFjayAm JmNhbGxiYWNrKQogewogICBkd2FyZjJfcGVyX29iamZpbGUgKnBlcl9vYmpmaWxlID0gY3UtPnBl cl9vYmpmaWxlOwpAQCAtMTM5NjcsNyArMTQwMzEsNyBAQCBkd2FyZjJfcmFuZ2VzX3Byb2Nlc3Mg KHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiAgIENPUkVfQUREUiBiYXNl YWRkcjsKIAogICBpZiAoY3VfaGVhZGVyLT52ZXJzaW9uID49IDUpCi0gICAgcmV0dXJuIGR3YXJm Ml9ybmdsaXN0c19wcm9jZXNzIChvZmZzZXQsIGN1LCBjYWxsYmFjayk7CisgICAgcmV0dXJuIGR3 YXJmMl9ybmdsaXN0c19wcm9jZXNzIChvZmZzZXQsIGN1LCB0YWcsIGNhbGxiYWNrKTsKIAogICBi YXNlID0gY3UtPmJhc2VfYWRkcmVzczsKIApAQCAtMTQwNTMsNyArMTQxMTcsNyBAQCBkd2FyZjJf cmFuZ2VzX3Byb2Nlc3MgKHVuc2lnbmVkIG9mZnNldCwgc3RydWN0IGR3YXJmMl9jdSAqY3UsCiBz dGF0aWMgaW50CiBkd2FyZjJfcmFuZ2VzX3JlYWQgKHVuc2lnbmVkIG9mZnNldCwgQ09SRV9BRERS ICpsb3dfcmV0dXJuLAogCQkgICAgQ09SRV9BRERSICpoaWdoX3JldHVybiwgc3RydWN0IGR3YXJm Ml9jdSAqY3UsCi0JCSAgICBkd2FyZjJfcHN5bXRhYiAqcmFuZ2VzX3BzdCkKKwkJICAgIGR3YXJm Ml9wc3ltdGFiICpyYW5nZXNfcHN0LCBkd2FyZl90YWcgdGFnKQogewogICBzdHJ1Y3Qgb2JqZmls ZSAqb2JqZmlsZSA9IGN1LT5wZXJfb2JqZmlsZS0+b2JqZmlsZTsKICAgc3RydWN0IGdkYmFyY2gg KmdkYmFyY2ggPSBvYmpmaWxlLT5hcmNoICgpOwpAQCAtMTQwNjMsNyArMTQxMjcsNyBAQCBkd2Fy ZjJfcmFuZ2VzX3JlYWQgKHVuc2lnbmVkIG9mZnNldCwgQ09SRV9BRERSICpsb3dfcmV0dXJuLAog ICBDT1JFX0FERFIgaGlnaCA9IDA7CiAgIGludCByZXR2YWw7CiAKLSAgcmV0dmFsID0gZHdhcmYy X3Jhbmdlc19wcm9jZXNzIChvZmZzZXQsIGN1LAorICByZXR2YWwgPSBkd2FyZjJfcmFuZ2VzX3By b2Nlc3MgKG9mZnNldCwgY3UsIHRhZywKICAgICBbJl0gKENPUkVfQUREUiByYW5nZV9iZWdpbm5p bmcsIENPUkVfQUREUiByYW5nZV9lbmQpCiAgICAgewogICAgICAgaWYgKHJhbmdlc19wc3QgIT0g TlVMTCkKQEAgLTE0MTU2LDcgKzE0MjIwLDggQEAgZHdhcmYyX2dldF9wY19ib3VuZHMgKHN0cnVj dCBkaWVfaW5mbyAqZGllLCBDT1JFX0FERFIgKmxvd3BjLAogCSAgLyogRFdfQVRfcm5nbGlzdHNf YmFzZSBkb2VzIG5vdCBhcHBseSB0byBESUVzIGZyb20gdGhlIERXTyBza2VsZXRvbi4KIAkgICAg IFdlIHRha2UgYWR2YW50YWdlIG9mIHRoZSBmYWN0IHRoYXQgRFdfQVRfcmFuZ2VzIGRvZXMgbm90 IGFwcGVhcgogCSAgICAgaW4gRFdfVEFHX2NvbXBpbGVfdW5pdCBvZiBEV08gZmlsZXMuICAqLwot CSAgaW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSBkaWUtPnRhZyAhPSBEV19UQUdfY29tcGlsZV91bml0 OworCSAgaW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSAoZGllLT50YWcgIT0gRFdfVEFHX2NvbXBpbGVf dW5pdAorCQkJCSAgJiYgYXR0ci0+Zm9ybSAhPSBEV19GT1JNX3JuZ2xpc3R4KTsKIAkgIHVuc2ln bmVkIGludCByYW5nZXNfb2Zmc2V0ID0gKERXX1VOU05EIChhdHRyKQogCQkJCQkrIChuZWVkX3Jh bmdlc19iYXNlCiAJCQkJCSAgID8gY3UtPnJhbmdlc19iYXNlCkBAIC0xNDE2NCw3ICsxNDIyOSw4 IEBAIGR3YXJmMl9nZXRfcGNfYm91bmRzIChzdHJ1Y3QgZGllX2luZm8gKmRpZSwgQ09SRV9BRERS ICpsb3dwYywKIAogCSAgLyogVmFsdWUgb2YgdGhlIERXX0FUX3JhbmdlcyBhdHRyaWJ1dGUgaXMg dGhlIG9mZnNldCBpbiB0aGUKIAkgICAgIC5kZWJ1Z19yYW5nZXMgc2VjdGlvbi4gICovCi0JICBp ZiAoIWR3YXJmMl9yYW5nZXNfcmVhZCAocmFuZ2VzX29mZnNldCwgJmxvdywgJmhpZ2gsIGN1LCBw c3QpKQorCSAgaWYgKCFkd2FyZjJfcmFuZ2VzX3JlYWQgKHJhbmdlc19vZmZzZXQsICZsb3csICZo aWdoLCBjdSwgcHN0LAorCQkJCSAgIGRpZS0+dGFnKSkKIAkgICAgcmV0dXJuIFBDX0JPVU5EU19J TlZBTElEOwogCSAgLyogRm91bmQgZGlzY29udGludW91cyByYW5nZSBvZiBhZGRyZXNzZXMuICAq LwogCSAgcmV0ID0gUENfQk9VTkRTX1JBTkdFUzsKQEAgLTE0MzI3LDcgKzE0MzkzLDggQEAgZHdh cmYyX3JlY29yZF9ibG9ja19yYW5nZXMgKHN0cnVjdCBkaWVfaW5mbyAqZGllLCBzdHJ1Y3QgYmxv Y2sgKmJsb2NrLAogICAgICAgLyogRFdfQVRfcm5nbGlzdHNfYmFzZSBkb2VzIG5vdCBhcHBseSB0 byBESUVzIGZyb20gdGhlIERXTyBza2VsZXRvbi4KIAkgV2UgdGFrZSBhZHZhbnRhZ2Ugb2YgdGhl IGZhY3QgdGhhdCBEV19BVF9yYW5nZXMgZG9lcyBub3QgYXBwZWFyCiAJIGluIERXX1RBR19jb21w aWxlX3VuaXQgb2YgRFdPIGZpbGVzLiAgKi8KLSAgICAgIGludCBuZWVkX3Jhbmdlc19iYXNlID0g ZGllLT50YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdDsKKyAgICAgIGludCBuZWVkX3Jhbmdlc19i YXNlID0gKGRpZS0+dGFnICE9IERXX1RBR19jb21waWxlX3VuaXQKKwkJCSAgICAgICYmIGF0dHIt PmZvcm0gIT0gRFdfRk9STV9ybmdsaXN0eCk7CiAKICAgICAgIC8qIFRoZSB2YWx1ZSBvZiB0aGUg RFdfQVRfcmFuZ2VzIGF0dHJpYnV0ZSBpcyB0aGUgb2Zmc2V0IG9mIHRoZQogICAgICAgICAgYWRk cmVzcyByYW5nZSBsaXN0IGluIHRoZSAuZGVidWdfcmFuZ2VzIHNlY3Rpb24uICAqLwpAQCAtMTQz MzUsNyArMTQ0MDIsNyBAQCBkd2FyZjJfcmVjb3JkX2Jsb2NrX3JhbmdlcyAoc3RydWN0IGRpZV9p bmZvICpkaWUsIHN0cnVjdCBibG9jayAqYmxvY2ssCiAJCQkgICAgICArIChuZWVkX3Jhbmdlc19i YXNlID8gY3UtPnJhbmdlc19iYXNlIDogMCkpOwogCiAgICAgICBzdGQ6OnZlY3RvcjxibG9ja3Jh bmdlPiBibG9ja3ZlYzsKLSAgICAgIGR3YXJmMl9yYW5nZXNfcHJvY2VzcyAob2Zmc2V0LCBjdSwK KyAgICAgIGR3YXJmMl9yYW5nZXNfcHJvY2VzcyAob2Zmc2V0LCBjdSwgZGllLT50YWcsCiAJWyZd IChDT1JFX0FERFIgc3RhcnQsIENPUkVfQUREUiBlbmQpCiAJewogCSAgc3RhcnQgKz0gYmFzZWFk ZHI7CkBAIC0xODE2NSw2ICsxODIzMiwxMSBAQCByZWFkX2Z1bGxfZGllXzEgKGNvbnN0IHN0cnVj dCBkaWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCiAgIGF1dG8gbWF5YmVfYWRkcl9iYXNlID0gZGll LT5hZGRyX2Jhc2UgKCk7CiAgIGlmIChtYXliZV9hZGRyX2Jhc2UuaGFzX3ZhbHVlICgpKQogICAg IGN1LT5hZGRyX2Jhc2UgPSAqbWF5YmVfYWRkcl9iYXNlOworCisgIGF0dHIgPSBkaWUtPmF0dHIg KERXX0FUX3JuZ2xpc3RzX2Jhc2UpOworICBpZiAoYXR0ciAhPSBudWxscHRyKQorICAgIGN1LT5y YW5nZXNfYmFzZSA9IERXX1VOU05EIChhdHRyKTsKKwogICBmb3IgKGludCBpbmRleCA6IGluZGV4 ZXNfdGhhdF9uZWVkX3JlcHJvY2VzcykKICAgICByZWFkX2F0dHJpYnV0ZV9yZXByb2Nlc3MgKHJl YWRlciwgJmRpZS0+YXR0cnNbaW5kZXhdKTsKICAgKmRpZXAgPSBkaWU7CkBAIC0xODY4NCw3ICsx ODc1Niw4IEBAIHBhcnRpYWxfZGllX2luZm86OnJlYWQgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVy X3NwZWNzICpyZWFkZXIsCiAJICAgIC8qIEl0IHdvdWxkIGJlIG5pY2UgdG8gcmV1c2UgZHdhcmYy X2dldF9wY19ib3VuZHMgaGVyZSwKIAkgICAgICAgYnV0IHRoYXQgcmVxdWlyZXMgYSBmdWxsIERJ RSwgc28gaW5zdGVhZCB3ZSBqdXN0CiAJICAgICAgIHJlaW1wbGVtZW50IGl0LiAgKi8KLQkgICAg aW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSB0YWcgIT0gRFdfVEFHX2NvbXBpbGVfdW5pdDsKKwkgICAg aW50IG5lZWRfcmFuZ2VzX2Jhc2UgPSAodGFnICE9IERXX1RBR19jb21waWxlX3VuaXQKKwkJCQkg ICAgJiYgYXR0ci5mb3JtICE9IERXX0ZPUk1fcm5nbGlzdHgpOwogCSAgICB1bnNpZ25lZCBpbnQg cmFuZ2VzX29mZnNldCA9IChEV19VTlNORCAoJmF0dHIpCiAJCQkJCSAgKyAobmVlZF9yYW5nZXNf YmFzZQogCQkJCQkgICAgID8gY3UtPnJhbmdlc19iYXNlCkBAIC0xODY5Myw3ICsxODc2Niw3IEBA IHBhcnRpYWxfZGllX2luZm86OnJlYWQgKGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpy ZWFkZXIsCiAJICAgIC8qIFZhbHVlIG9mIHRoZSBEV19BVF9yYW5nZXMgYXR0cmlidXRlIGlzIHRo ZSBvZmZzZXQgaW4gdGhlCiAJICAgICAgIC5kZWJ1Z19yYW5nZXMgc2VjdGlvbi4gICovCiAJICAg IGlmIChkd2FyZjJfcmFuZ2VzX3JlYWQgKHJhbmdlc19vZmZzZXQsICZsb3dwYywgJmhpZ2hwYywg Y3UsCi0JCQkJICAgIG51bGxwdHIpKQorCQkJCSAgICBudWxscHRyLCB0YWcpKQogCSAgICAgIGhh c19wY19pbmZvID0gMTsKIAkgIH0KIAkgIGJyZWFrOwpAQCAtMTkwOTQsNiArMTkxNjcsNTcgQEAg cmVhZF9sb2NsaXN0X2luZGV4IChzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwgVUxPTkdFU1QgbG9jbGlz dF9pbmRleCkKICAgICByZXR1cm4gYmZkX2dldF82NCAoYWJmZCwgaW5mb19wdHIpICsgbG9jbGlz dF9iYXNlOwogfQogCisvKiBHaXZlbiBhIERXX0ZPUk1fcm5nbGlzdHggdmFsdWUgcm5nbGlzdF9p bmRleCwgZmV0Y2ggdGhlIG9mZnNldCBmcm9tIHRoZQorICAgYXJyYXkgb2Ygb2Zmc2V0cyBpbiB0 aGUgLmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24uICAqLworc3RhdGljIENPUkVfQUREUgorcmVhZF9y bmdsaXN0X2luZGV4IChzdHJ1Y3QgZHdhcmYyX2N1ICpjdSwgVUxPTkdFU1Qgcm5nbGlzdF9pbmRl eCkKK3sKKyAgc3RydWN0IGR3YXJmMl9wZXJfb2JqZmlsZSAqZHdhcmYyX3Blcl9vYmpmaWxlID0g Y3UtPnBlcl9vYmpmaWxlOworICBzdHJ1Y3Qgb2JqZmlsZSAqb2JqZmlsZSA9IGR3YXJmMl9wZXJf b2JqZmlsZS0+b2JqZmlsZTsKKyAgYmZkICphYmZkID0gb2JqZmlsZS0+b2JmZDsKKyAgVUxPTkdF U1Qgcm5nbGlzdF9oZWFkZXJfc2l6ZSA9CisgICAgKGN1LT5oZWFkZXIuaW5pdGlhbF9sZW5ndGhf c2l6ZSA9PSA0ID8gTE9DTElTVF9IRUFERVJfU0laRTMyCisgICAgIDogTE9DTElTVF9IRUFERVJf U0laRTY0KTsKKyAgVUxPTkdFU1Qgcm5nbGlzdF9iYXNlID0KKyAgICAgIChjdS0+ZHdvX3VuaXQp ID8gcm5nbGlzdF9oZWFkZXJfc2l6ZSA6IGN1LT5yYW5nZXNfYmFzZTsKKyAgVUxPTkdFU1Qgc3Rh cnRfb2Zmc2V0ID0KKyAgICBybmdsaXN0X2Jhc2UgKyBybmdsaXN0X2luZGV4ICogY3UtPmhlYWRl ci5vZmZzZXRfc2l6ZTsKKworICAvKiBHZXQgcm5nbGlzdHMgc2VjdGlvbi4gICovCisgIHN0cnVj dCBkd2FyZjJfc2VjdGlvbl9pbmZvICpzZWN0aW9uID0gY3VfZGVidWdfcm5nbGlzdHNfc2VjdGlv biAoY3UpOworICBpZiAoc2VjdGlvbiA9PSBudWxscHRyKQorICAgIGVycm9yIChfKCJDYW5ub3Qg ZmluZCAuZGVidWdfcm5nbGlzdHMgc2VjdGlvbiBbaW4gbW9kdWxlICVzXSIpLAorCSAgIG9iamZp bGVfbmFtZShvYmpmaWxlKSk7CisKKyAgLyogUmVhZCB0aGUgcm5nbGlzdHMgc2VjdGlvbiBjb250 ZW50LiAgKi8KKyAgc2VjdGlvbi0+cmVhZCAob2JqZmlsZSk7CisgIGlmIChzZWN0aW9uLT5idWZm ZXIgPT0gTlVMTCkKKyAgICBlcnJvciAoXygiRFdfRk9STV9ybmdsaXN0eCB1c2VkIHdpdGhvdXQg LmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24gIgorCSAgICAgIltpbiBtb2R1bGUgJXNdIiksCisgICAg ICAgb2JqZmlsZV9uYW1lIChvYmpmaWxlKSk7CisKKyAgLyogVmVyaWZ5IHRoZSBybmdsaXN0IGhl YWRlciBpcyB2YWxpZCAoc2FtZSBhcyBsb2NsaXN0IGhlYWRlcikuICAqLworICBzdHJ1Y3QgbG9j bGlzdF9oZWFkZXIgaGVhZGVyOworICByZWFkX2xvY2xpc3RfaGVhZGVyICgmaGVhZGVyLCBzZWN0 aW9uKTsKKyAgaWYgKHJuZ2xpc3RfaW5kZXggPj0gaGVhZGVyLm9mZnNldF9lbnRyeV9jb3VudCkK KyAgICBlcnJvciAoXygiRFdfRk9STV9ybmdsaXN0eCBpbmRleCBwb2ludGluZyBvdXRzaWRlIG9m ICIKKwkgICAgICIuZGVidWdfcm5nbGlzdHMgb2Zmc2V0IGFycmF5IFtpbiBtb2R1bGUgJXNdIiks CisJICAgIG9iamZpbGVfbmFtZShvYmpmaWxlKSk7CisKKyAgLyogVmFsaWRhdGUgdGhhdCB0aGUg b2Zmc2V0IGlzIHdpdGhpbiB0aGUgc2VjdGlvbidzIHJhbmdlLiAgKi8KKyAgaWYgKHN0YXJ0X29m ZnNldCA+PSBzZWN0aW9uLT5zaXplKQorICAgIGVycm9yIChfKCJEV19GT1JNX3JuZ2xpc3R4IHBv aW50aW5nIG91dHNpZGUgb2YgIgorICAgICAgICAgICAgICIuZGVidWdfcm5nbGlzdHMgc2VjdGlv biBbaW4gbW9kdWxlICVzXSIpLAorICAgICAgICAgIG9iamZpbGVfbmFtZShvYmpmaWxlKSk7CisK KyAgY29uc3QgZ2RiX2J5dGUgKmluZm9fcHRyID0gc2VjdGlvbi0+YnVmZmVyICsgc3RhcnRfb2Zm c2V0OworCisgIGlmIChjdS0+aGVhZGVyLm9mZnNldF9zaXplID09IDQpCisgICAgcmV0dXJuIHJl YWRfNF9ieXRlcyAoYWJmZCwgaW5mb19wdHIpICsgcm5nbGlzdF9iYXNlOworICBlbHNlCisgICAg cmV0dXJuIHJlYWRfOF9ieXRlcyAoYWJmZCwgaW5mb19wdHIpICsgcm5nbGlzdF9iYXNlOworfQor CiAvKiBQcm9jZXNzIHRoZSBhdHRyaWJ1dGVzIHRoYXQgaGFkIHRvIGJlIHNraXBwZWQgaW4gdGhl IGZpcnN0IHJvdW5kLiBUaGVzZQogICAgYXR0cmlidXRlcyBhcmUgdGhlIG9uZXMgdGhhdCBuZWVk IHN0cl9vZmZzZXRzX2Jhc2Ugb3IgYWRkcl9iYXNlIGF0dHJpYnV0ZXMuCiAgICBUaGV5IGNvdWxk IG5vdCBoYXZlIGJlZW4gcHJvY2Vzc2VkIGluIHRoZSBmaXJzdCByb3VuZCwgYmVjYXVzZSBhdCB0 aGUgdGltZQpAQCAtMTkxMTIsNiArMTkyMzYsOSBAQCByZWFkX2F0dHJpYnV0ZV9yZXByb2Nlc3Mg KGNvbnN0IHN0cnVjdCBkaWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCiAgICAgICBjYXNlIERXX0ZP Uk1fbG9jbGlzdHg6CiAJIERXX1VOU05EIChhdHRyKSA9IHJlYWRfbG9jbGlzdF9pbmRleCAoY3Us IERXX1VOU05EIChhdHRyKSk7CiAJIGJyZWFrOworICAgICAgY2FzZSBEV19GT1JNX3JuZ2xpc3R4 OgorICAgICAgICBEV19VTlNORCAoYXR0cikgPSByZWFkX3JuZ2xpc3RfaW5kZXggKGN1LCBEV19V TlNORCAoYXR0cikpOworICAgICAgICBicmVhazsKICAgICAgIGNhc2UgRFdfRk9STV9zdHJ4Ogog ICAgICAgY2FzZSBEV19GT1JNX3N0cngxOgogICAgICAgY2FzZSBEV19GT1JNX3N0cngyOgpAQCAt MTkyOTMsOCArMTk0MjAsMTAgQEAgcmVhZF9hdHRyaWJ1dGVfdmFsdWUgKGNvbnN0IHN0cnVjdCBk aWVfcmVhZGVyX3NwZWNzICpyZWFkZXIsCiAgICAgICBEV19TTkQgKGF0dHIpID0gcmVhZF9zaWdu ZWRfbGViMTI4IChhYmZkLCBpbmZvX3B0ciwgJmJ5dGVzX3JlYWQpOwogICAgICAgaW5mb19wdHIg Kz0gYnl0ZXNfcmVhZDsKICAgICAgIGJyZWFrOwotICAgIGNhc2UgRFdfRk9STV91ZGF0YToKICAg ICBjYXNlIERXX0ZPUk1fcm5nbGlzdHg6CisgICAgICAqbmVlZF9yZXByb2Nlc3MgPSB0cnVlOwor ICAgICAgLyogRkFMTFRIUk9VR0ggKi8KKyAgICBjYXNlIERXX0ZPUk1fdWRhdGE6CiAgICAgICBE V19VTlNORCAoYXR0cikgPSByZWFkX3Vuc2lnbmVkX2xlYjEyOCAoYWJmZCwgaW5mb19wdHIsICZi eXRlc19yZWFkKTsKICAgICAgIGluZm9fcHRyICs9IGJ5dGVzX3JlYWQ7CiAgICAgICBicmVhazsK QEAgLTIzMzgyLDYgKzIzNTExLDI1IEBAIGN1X2RlYnVnX2xvY19zZWN0aW9uIChzdHJ1Y3QgZHdh cmYyX2N1ICpjdSkKIAkJCQkgIDogJnBlcl9vYmpmaWxlLT5wZXJfYmZkLT5sb2MpOwogfQogCisv KiBSZXR1cm4gdGhlIC5kZWJ1Z19ybmdsaXN0cyBzZWN0aW9uIHRvIHVzZSBmb3IgQ1UuICAqLwor c3RhdGljIHN0cnVjdCBkd2FyZjJfc2VjdGlvbl9pbmZvICoKK2N1X2RlYnVnX3JuZ2xpc3RzX3Nl Y3Rpb24gKHN0cnVjdCBkd2FyZjJfY3UgKmN1KQoreworICBpZiAoY3UtPmhlYWRlci52ZXJzaW9u IDwgNSkKKyAgICBlcnJvciAoXygiLmRlYnVnX3JuZ2xpc3RzIHNlY3Rpb24gY2Fubm90IGJlIHVz ZWQgaW4gRFdBUkYgJWQiKSwKKwkgICBjdS0+aGVhZGVyLnZlcnNpb24pOworICBzdHJ1Y3QgZHdh cmYyX3Blcl9vYmpmaWxlICpkd2FyZjJfcGVyX29iamZpbGUgPSBjdS0+cGVyX29iamZpbGU7CisK KyAgaWYgKGN1LT5kd29fdW5pdCAhPSBudWxscHRyKQorICAgIHsKKyAgICAgIHN0cnVjdCBkd29f c2VjdGlvbnMgKnNlY3Rpb25zID0gJmN1LT5kd29fdW5pdC0+ZHdvX2ZpbGUtPnNlY3Rpb25zOwor CisgICAgICBpZiAoc2VjdGlvbnMtPnJuZ2xpc3RzLnNpemUgPiAwKQorCXJldHVybiAmc2VjdGlv bnMtPnJuZ2xpc3RzOworICAgIH0KKyAgcmV0dXJuICZkd2FyZjJfcGVyX29iamZpbGUtPnBlcl9i ZmQtPnJuZ2xpc3RzOworfQorCiAvKiBBIGhlbHBlciBmdW5jdGlvbiB0aGF0IGZpbGxzIGluIGEg ZHdhcmYyX2xvY2xpc3RfYmF0b24uICAqLwogCiBzdGF0aWMgdm9pZApkaWZmIC0tZ2l0IGEvZ2Ri L3Rlc3RzdWl0ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MgYi9nZGIvdGVzdHN1aXRl L2dkYi5kd2FyZjIvZHc1LXJuZ2xpc3QtdGVzdC5jYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwLi44MTY5M2Y1NjlkCi0tLSAvZGV2L251bGwKKysrIGIvZ2RiL3Rlc3RzdWl0 ZS9nZGIuZHdhcmYyL2R3NS1ybmdsaXN0LXRlc3QuY2MKQEAgLTAsMCArMSw5NyBAQAorLyogVGhp cyB0ZXN0Y2FzZSBpcyBwYXJ0IG9mIEdEQiwgdGhlIEdOVSBkZWJ1Z2dlci4KKworICAgQ29weXJp Z2h0IDIwMjAgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyAgIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5 CisgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNl IGFzIHB1Ymxpc2hlZCBieQorICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVy IHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxh dGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9w ZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3 aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBv ciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQgaGF2 ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBh bG9uZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcv bGljZW5zZXMvPi4gICovCisKKyNpbmNsdWRlIDxpb3N0cmVhbT4KKyNpbmNsdWRlIDx2ZWN0b3I+ CisKK3N0cnVjdCBub2RlIHsKKyAgaW50IGlkOworICBub2RlICpsZWZ0OworICBub2RlICpyaWdo dDsKKyAgYm9vbCB2aXNpdGVkOworfTsKKworbm9kZSAgbm9kZV9hcnJheVs1MF07Cit1bnNpZ25l ZCBpbnQgQ1VSX0lEWCA9IDA7CisKK25vZGUgKgorbWFrZV9ub2RlIChpbnQgdmFsKQoreworICBu b2RlICpuZXdfbm9kZSA9ICYobm9kZV9hcnJheVtDVVJfSURYKytdKTsKKyAgbmV3X25vZGUtPmxl ZnQgPSBOVUxMOworICBuZXdfbm9kZS0+cmlnaHQgPSBOVUxMOworICBuZXdfbm9kZS0+aWQgPSB2 YWw7CisgIG5ld19ub2RlLT52aXNpdGVkID0gZmFsc2U7CisKKyAgcmV0dXJuIG5ld19ub2RlOwor fQorCit2b2lkCit0cmVlX2luc2VydCAobm9kZSAqcm9vdCwgaW50IHZhbCkKK3sKKyAgaWYgKHZh bCA8IHJvb3QtPmlkKQorICAgIHsKKyAgICAgIGlmIChyb290LT5sZWZ0KQorICAgICAgICB0cmVl X2luc2VydCAocm9vdC0+bGVmdCwgdmFsKTsKKyAgICAgIGVsc2UKKyAgICAgICAgcm9vdC0+bGVm dCA9IG1ha2Vfbm9kZSh2YWwpOworICAgIH0KKyAgZWxzZSBpZiAodmFsID4gcm9vdC0+aWQpCisg ICAgeworICAgICAgaWYgKHJvb3QtPnJpZ2h0KQorICAgICAgICB0cmVlX2luc2VydCAocm9vdC0+ cmlnaHQsIHZhbCk7CisgICAgICBlbHNlCisgICAgICAgIHJvb3QtPnJpZ2h0ID0gbWFrZV9ub2Rl KHZhbCk7CisgICAgfQorfQorCit2b2lkCitpbm9yZGVyIChub2RlICpyb290KQoreworICBzdGQ6 OnZlY3Rvcjxub2RlICo+IHRvZG87CisgIHRvZG8ucHVzaF9iYWNrIChyb290KTsKKyAgd2hpbGUg KCF0b2RvLmVtcHR5KCkpCisgICAgeworICAgICAgbm9kZSAqY3VyciA9IHRvZG8uYmFjaygpOwor ICAgICAgdG9kby5wb3BfYmFjaygpOyAvKiBicmVhay1oZXJlICovCisgICAgICBpZiAoY3Vyci0+ dmlzaXRlZCkKKyAgICAgICAgc3RkOjpjb3V0IDw8IGN1cnItPmlkIDw8ICIgIjsKKyAgICAgIGVs c2UKKyAgICAgICAgeworICAgICAgICAgIGN1cnItPnZpc2l0ZWQgPSB0cnVlOworICAgICAgICAg IGlmIChjdXJyLT5yaWdodCkKKyAgICAgICAgICAgIHRvZG8ucHVzaF9iYWNrIChjdXJyLT5yaWdo dCk7CisgICAgICAgICAgdG9kby5wdXNoX2JhY2sgKGN1cnIpOworICAgICAgICAgIGlmIChjdXJy LT5sZWZ0KQorICAgICAgICAgICAgdG9kby5wdXNoX2JhY2sgKGN1cnItPmxlZnQpOworICAgICAg ICB9CisgICAgfQorfQorCitpbnQKK21haW4gKGludCBhcmdjLCBjaGFyICoqYXJndikKK3sKKyAg bm9kZSAqcm9vdCA9IG1ha2Vfbm9kZSAoMzUpOworCisgIHRyZWVfaW5zZXJ0IChyb290LCAyOCk7 CisgIHRyZWVfaW5zZXJ0IChyb290LCAyMCk7CisgIHRyZWVfaW5zZXJ0IChyb290LCA2MCk7CisK KyAgaW5vcmRlciAocm9vdCk7CisKKyAgcmV0dXJuIDA7Cit9CmRpZmYgLS1naXQgYS9nZGIvdGVz dHN1aXRlL2dkYi5kd2FyZjIvZHc1LXJuZ2xpc3QtdGVzdC5leHAgYi9nZGIvdGVzdHN1aXRlL2dk Yi5kd2FyZjIvZHc1LXJuZ2xpc3QtdGVzdC5leHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMC4uYWY2YzM0YjVkZAotLS0gL2Rldi9udWxsCisrKyBiL2dkYi90ZXN0c3VpdGUv Z2RiLmR3YXJmMi9kdzUtcm5nbGlzdC10ZXN0LmV4cApAQCAtMCwwICsxLDQwIEBACisjIENvcHly aWdodCAyMDIwIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorCisjIFRoaXMgcHJvZ3Jh bSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5 CisjIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5CisjIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2 ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisjIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisjCisjIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorIyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhv dXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisjIEdOVSBHZW5lcmFsIFB1 YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisjCisjIFlvdSBzaG91bGQgaGF2ZSByZWNl aXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisjIGFsb25nIHdp dGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNl cy8+LgorCisjIENoZWNrIHRoYXQgR0RCIGNhbiBmaW5kIHRoZSB2YXJpYWJsZXMgaW4gYSBsZXhp Y2FsIGJsb2NrIHdpdGggYQorIyBEV19GT1JNX3JuZ2xpc3R4IERXX0FUX3JhbmdlcyBmaWVsZC4g IFRoaXMgdGVzdCBpcyBpbnRlbmRlZCBmb3IgRFdBUkYtNSwKKyMgY29tcGlsZWQgd2l0aCBjbGFu ZysrLgorCitzdGFuZGFyZF90ZXN0ZmlsZSAuY2MKKworIyBUaGlzIHRlc3QgaXMgaW50ZW5kZWQg Zm9yIHRhcmdldHMgd2hpY2ggc3VwcG9ydCBEV0FSRi01LgorIyBTaW5jZSB3ZSBwYXNzIGFuIGV4 cGxpY2l0IC1nZHdhcmYtNSB0byB0aGUgY29tcGlsZXIsCisjIHdlIGxldCB0aGF0IGJlIHRoZSB0 ZXN0IG9mIHdoZXRoZXIgdGhlIHRhcmdldCBzdXBwb3J0cyBpdC4KKworaWYgeyBbcHJlcGFyZV9m b3JfdGVzdGluZyAiZmFpbGVkIHRvIHByZXBhcmUiICIke3Rlc3RmaWxlfSIgXAorICAgICAgICAg ICRzcmNmaWxlIHtkZWJ1ZyBjKysgYWRkaXRpb25hbF9mbGFncz0tZ2R3YXJmLTUgXAorICAgICAg ICAgICAgICAgICAgICAgICAgYWRkaXRpb25hbF9mbGFncz0tTzB9XSB9IHsKKyAgICByZXR1cm4g LTEKK30KKworaWYgIVtydW50b19tYWluXSB7CisgICAgcmV0dXJuIC0xCit9CisKK2dkYl9icmVh a3BvaW50IFtnZGJfZ2V0X2xpbmVfbnVtYmVyICJicmVhay1oZXJlIl0KK2dkYl9jb250aW51ZV90 b19icmVha3BvaW50ICJicmVhay1oZXJlIiAiLiogYnJlYWstaGVyZSAuKiIKKworZ2RiX3Rlc3Qg InByaW50IGN1cnIiICJcXFwobm9kZSBcXFwqXFxcKSAkaGV4IDxub2RlX2FycmF5PiIKK2dkYl90 ZXN0ICJwcmludCAqY3VyciIgIj0ge2lkID0gMzUsIGxlZnQgPSAkaGV4IDxub2RlX2FycmF5XFwr JGRlY2ltYWw+LCByaWdodCA9ICRoZXggPG5vZGVfYXJyYXlcXCskZGVjaW1hbD4sIHZpc2l0ZWQg PSBmYWxzZX0iCi0tIAoyLjI3LjAuMjEyLmdlOGJhMWNjOTg4LWdvb2cKCg== --00000000000041dcee05a9914f9d--