From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23386 invoked by alias); 29 Aug 2009 15:19:17 -0000 Received: (qmail 23330 invoked by uid 22791); 29 Aug 2009 15:19:05 -0000 X-SWARE-Spam-Status: No, hits=-1.4 required=5.0 tests=AWL,BAYES_00,J_CHICKENPOX_37,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mail-iw0-f183.google.com (HELO mail-iw0-f183.google.com) (209.85.223.183) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 29 Aug 2009 15:18:52 +0000 Received: by iwn13 with SMTP id 13so1181143iwn.12 for ; Sat, 29 Aug 2009 08:18:49 -0700 (PDT) MIME-Version: 1.0 Received: by 10.231.5.200 with SMTP id 8mr2381360ibw.46.1251559129149; Sat, 29 Aug 2009 08:18:49 -0700 (PDT) In-Reply-To: <4A949176.9060604@vmware.com> References: <4A7F5410.4000400@vmware.com> <4A91CEEC.5000802@vmware.com> <4A92D317.9010002@vmware.com> <4A948FF1.6000405@vmware.com> <4A949176.9060604@vmware.com> From: Hui Zhu Date: Sat, 29 Aug 2009 15:53:00 -0000 Message-ID: Subject: Re: [RFA/RFC] Add dump and load command to process record and replay To: Michael Snyder Cc: Eli Zaretskii , "gdb-patches@sourceware.org" Content-Type: multipart/mixed; boundary=00151773d9f24ef1be047249510f X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2009-08/txt/msg00537.txt.bz2 --00151773d9f24ef1be047249510f Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 61571 On Wed, Aug 26, 2009 at 09:35, Michael Snyder wrote: > Michael Snyder wrote: >> >> Hui Zhu wrote: >>> >>> On Tue, Aug 25, 2009 at 01:51, Michael Snyder wrote: >>>> >>>> Have you considered combining this patch with the idea that I >>>> proposed -- storing the record log in the core file? =A0Seems like >>>> that would be very easy now -- gdb already has the core file open, >>>> and there is a global pointer to the BFD. >>>> See gdbcore.h:extern bfd* core_bfd; >>> >>> Cool. =A0If we just want record_core_ops support load, we can remove the >>> cmd "record load". =A0:) >>> >>>> In fact, just for fun, I've merged the two patches in my >>>> local tree. =A0It seems to work quite well. =A0I can just post >>>> it here if you like, or here's a hint to show you how it goes: >>> >>> Why not? =A0Please post it. =A0I can not wait to try it. =A0:) >> >> Great -- attached. > > This is "quick and dirty", by the way. > It's not meant to be finished! > > Hi Michael, I make a new patch that make the patches together. Prec can load the record log from a core file and debug it with core target. To use it, Call "record" after load the gdb_record.xxx file. Please help me review it. Thanks, Hui 2009-08-29 Michael Snyder Hui Zhu Add dump and load command to process record and replay. * record.c (completer.h, arch-utils.h, gdbcore.h, exec.h, elf-bfd.h, gcore.h, byteswap.h, netinet/in.h): Include files. (RECORD_FILE_MAGIC): New macro. (record_core_buf_entry): New struct. (record_core_ops): New target_ops. (record_list_release_first_insn): Change function record_list_release_first to this name. (record_reg_alloc, record_mem_alloc, record_end_alloc): New functions. (record_arch_list_add_reg): Call record_reg_alloc. (record_arch_list_add_mem): Call record_mem_alloc. (record_arch_list_add_end): Call record_end_alloc. (record_arch_list_cleanups): New function. (record_message_cleanups): Removed. (record_message): Change to call record_arch_list_cleanups and record_list_release_first_insn. (record_exec_entry, (bfdcore_read, record_load, record_core_open_1, record_open_1): New function. (record_open): Add support for record_core_ops. (record_close): Add support for record_core_ops. (record_wait): Call function 'record_exec_entry' and add support for target core. (record_registers_change): Call record_list_release_first_insn. (record_core_resume, record_core_resume, record_core_kill, record_core_fetch_registers, record_core_prepare_to_store, record_core_store_registers, record_core_xfer_partial, record_core_insert_breakpoint, record_core_remove_breakpoint, record_core_has_execution, init_record_core_ops, cmd_record_load, bfdcore_write, cmd_record_dump): New function. (cmd_record_stop): Add support for record_core_ops. (set_record_insn_max_num): Call record_list_release_first_insn. (_initialize_record): Add commands "record dump". * gcore.c (create_gcore_bfd): New function, abstracted from gcore_command for export. (write_gcore_file): New function, abstracted from gcore_command for export. (gcore_command): Call helper functions (above). (call_target_sbrk): New function, abstracted from derive_heap_segment. (derive_heap_segment): Call helper function (above). (load_core_segments): New function. (load_corefile): New function. * gcore.h: New file. 2009-08-29 Hui Zhu * gdb.texinfo (Process Record and Replay): Document the "record dump" commands. --- gcore.c | 309 ++++++++++++++---- gcore.h | 23 + record.c | 1072 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----= ----- 3 files changed, 1199 insertions(+), 205 deletions(-) --- a/gcore.c +++ b/gcore.c @@ -25,10 +25,14 @@ #include "gdbcore.h" #include "objfiles.h" #include "symfile.h" - +#include "arch-utils.h" +#include "completer.h" +#include "gcore.h" #include "cli/cli-decode.h" - #include "gdb_assert.h" +#include +#include "regcache.h" +#include "regset.h" /* The largest amount of memory to read from the target at once. We must throttle it to limit the amount of memory used by GDB during @@ -40,45 +44,27 @@ static enum bfd_architecture default_gco static unsigned long default_gcore_mach (void); static int gcore_memory_sections (bfd *); -/* Generate a core file from the inferior process. */ +/* create_gcore_bfd -- helper for gcore_command (exported). */ -static void -gcore_command (char *args, int from_tty) +bfd * +create_gcore_bfd (char *filename) { - struct cleanup *old_chain; - char *corefilename, corefilename_buffer[40]; - asection *note_sec =3D NULL; - bfd *obfd; - void *note_data =3D NULL; - int note_size =3D 0; - - /* No use generating a corefile without a target process. */ - if (!target_has_execution) - noprocess (); - - if (args && *args) - corefilename =3D args; - else - { - /* Default corefile name is "core.PID". */ - sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid)); - corefilename =3D corefilename_buffer; - } - - if (info_verbose) - fprintf_filtered (gdb_stdout, - "Opening corefile '%s' for output.\n", corefilename); - - /* Open the output file. */ - obfd =3D bfd_openw (corefilename, default_gcore_target ()); + bfd *obfd =3D bfd_openw (filename, default_gcore_target ()); if (!obfd) - error (_("Failed to open '%s' for output."), corefilename); - - /* Need a cleanup that will close the file (FIXME: delete it?). */ - old_chain =3D make_cleanup_bfd_close (obfd); - + error (_("Failed to open '%s' for output."), filename); bfd_set_format (obfd, bfd_core); bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ()); + return obfd; +} + +/* write_gcore_file -- helper for gcore_command (exported). */ + +void +write_gcore_file (bfd *obfd) +{ + void *note_data =3D NULL; + int note_size =3D 0; + asection *note_sec =3D NULL; /* An external target method must build the notes section. */ note_data =3D target_make_corefile_notes (obfd, ¬e_size); @@ -107,8 +93,46 @@ gcore_command (char *args, int from_tty) if (note_data !=3D NULL && note_size !=3D 0) { if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_si= ze)) - warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ())); + warning (_("writing note section (%s)"), + bfd_errmsg (bfd_get_error ())); } +} + +/* gcore_command -- implements the 'gcore' command. + Generate a core file from the inferior process. */ + +static void +gcore_command (char *args, int from_tty) +{ + struct cleanup *old_chain; + char *corefilename, corefilename_buffer[40]; + bfd *obfd; + + /* No use generating a corefile without a target process. */ + if (!target_has_execution) + noprocess (); + + if (args && *args) + corefilename =3D args; + else + { + /* Default corefile name is "core.PID". */ + sprintf (corefilename_buffer, "core.%d", PIDGET (inferior_ptid)); + corefilename =3D corefilename_buffer; + } + + if (info_verbose) + fprintf_filtered (gdb_stdout, + "Opening corefile '%s' for output.\n", corefilename); + + /* Open the output file. */ + obfd =3D create_gcore_bfd (corefilename); + + /* Need a cleanup that will close the file (FIXME: delete it?). */ + old_chain =3D make_cleanup_bfd_close (obfd); + + /* Call worker function. */ + write_gcore_file (obfd); /* Succeeded. */ fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename); @@ -212,6 +236,50 @@ derive_stack_segment (bfd_vma *bottom, b return 1; } +/* call_target_sbrk -- + helper function for derive_heap_segment and load_core_segment. */ + +static bfd_vma +call_target_sbrk (int sbrk_arg) +{ + struct objfile *sbrk_objf; + struct gdbarch *gdbarch; + bfd_vma top_of_heap; + struct value *target_sbrk_arg; + struct value *sbrk_fn, *ret; + bfd_vma tmp; + + if (lookup_minimal_symbol ("sbrk", NULL, NULL) !=3D NULL) + { + sbrk_fn =3D find_function_in_inferior ("sbrk", &sbrk_objf); + if (sbrk_fn =3D=3D NULL) + return (bfd_vma) 0; + } + else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) !=3D NULL) + { + sbrk_fn =3D find_function_in_inferior ("_sbrk", &sbrk_objf); + if (sbrk_fn =3D=3D NULL) + return (bfd_vma) 0; + } + else + return (bfd_vma) 0; + + gdbarch =3D get_objfile_arch (sbrk_objf); + target_sbrk_arg =3D value_from_longest (builtin_type (gdbarch)->builtin_= int, + sbrk_arg); + gdb_assert (target_sbrk_arg); + ret =3D call_function_by_hand (sbrk_fn, 1, &target_sbrk_arg); + if (ret =3D=3D NULL) + return (bfd_vma) 0; + + tmp =3D value_as_long (ret); + if ((LONGEST) tmp <=3D 0 || (LONGEST) tmp =3D=3D 0xffffffff) + return (bfd_vma) 0; + + top_of_heap =3D tmp; + return top_of_heap; +} + /* Derive a reasonable heap segment for ABFD by looking at sbrk and the static data sections. Store its limits in *BOTTOM and *TOP. Return non-zero if successful. */ @@ -219,12 +287,10 @@ derive_stack_segment (bfd_vma *bottom, b static int derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top) { - struct objfile *sbrk_objf; struct gdbarch *gdbarch; bfd_vma top_of_data_memory =3D 0; bfd_vma top_of_heap =3D 0; bfd_size_type sec_size; - struct value *zero, *sbrk; bfd_vma sec_vaddr; asection *sec; @@ -259,29 +325,9 @@ derive_heap_segment (bfd *abfd, bfd_vma } } - /* Now get the top-of-heap by calling sbrk in the inferior. */ - if (lookup_minimal_symbol ("sbrk", NULL, NULL) !=3D NULL) - { - sbrk =3D find_function_in_inferior ("sbrk", &sbrk_objf); - if (sbrk =3D=3D NULL) - return 0; - } - else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) !=3D NULL) - { - sbrk =3D find_function_in_inferior ("_sbrk", &sbrk_objf); - if (sbrk =3D=3D NULL) - return 0; - } - else - return 0; - - gdbarch =3D get_objfile_arch (sbrk_objf); - zero =3D value_from_longest (builtin_type (gdbarch)->builtin_int, 0); - gdb_assert (zero); - sbrk =3D call_function_by_hand (sbrk, 1, &zero); - if (sbrk =3D=3D NULL) + top_of_heap =3D call_target_sbrk (0); + if (top_of_heap =3D=3D (bfd_vma) 0) return 0; - top_of_heap =3D value_as_long (sbrk); /* Return results. */ if (top_of_heap > top_of_data_memory) @@ -299,13 +345,15 @@ static void make_output_phdrs (bfd *obfd, asection *osec, void *ignored) { int p_flags =3D 0; - int p_type; + int p_type =3D 0; /* FIXME: these constants may only be applicable for ELF. */ if (strncmp (bfd_section_name (obfd, osec), "load", 4) =3D=3D 0) p_type =3D PT_LOAD; - else + else if (strncmp (bfd_section_name (obfd, osec), "note", 4) =3D=3D 0) p_type =3D PT_NOTE; + else + p_type =3D PT_NULL; p_flags |=3D PF_R; /* Segment is readable. */ if (!(bfd_get_section_flags (obfd, osec) & SEC_READONLY)) @@ -516,6 +564,141 @@ gcore_memory_sections (bfd *obfd) return 1; } +struct load_core_args_params { + int from_tty; + bfd_vma top_of_heap; +}; + +/* load_core_segments -- iterator function for bfd_map_over_sections. */ + +static void +load_core_segment (bfd *abfd, asection *asect, void *arg) +{ + struct load_core_args_params *params =3D arg; + struct cleanup *old_chain; + char *memhunk; + int ret; + + if ((bfd_section_size (abfd, asect) > 0) && + (bfd_get_section_flags (abfd, asect) & SEC_LOAD) && + !(bfd_get_section_flags (abfd, asect) & SEC_READONLY)) + { + if (info_verbose && params->from_tty) + { + printf_filtered (_("Load core section %s"), + bfd_section_name (abfd, asect)); + printf_filtered (_(", vma 0x%08lx to 0x%08lx"), + (unsigned long) bfd_section_vma (abfd, asect), + (unsigned long) bfd_section_vma (abfd, asect) + + (int) bfd_section_size (abfd, asect)); + printf_filtered (_(", size =3D %d"), + (int) bfd_section_size (abfd, asect)); + printf_filtered (_(".\n")); + } + /* Fixme cleanup? */ + memhunk =3D xmalloc (bfd_section_size (abfd, asect)); + bfd_get_section_contents (abfd, asect, memhunk, 0, + bfd_section_size (abfd, asect)); + if ((ret =3D target_write_memory (bfd_section_vma (abfd, asect), + memhunk, + bfd_section_size (abfd, asect))) !=3D 0) + { + print_sys_errmsg ("load_core_segment", ret); + if ((LONGEST) params->top_of_heap < + (LONGEST) bfd_section_vma (abfd, asect) + + (LONGEST) bfd_section_size (abfd, asect)) + { + int increment =3D bfd_section_vma (abfd, asect) + + bfd_section_size (abfd, asect) - params->top_of_heap; + + params->top_of_heap =3D call_target_sbrk (increment); + if (params->top_of_heap =3D=3D 0) + error ("sbrk failed, TOH =3D 0x%08lx", params->top_of_heap); + else + printf_filtered ("Increase TOH to 0x%08lx and retry.\n", + (unsigned long) params->top_of_heap); + if (target_write_memory (bfd_section_vma (abfd, asect), + memhunk, + bfd_section_size (abfd, asect)) !=3D 0) + { + error ("Nope, still failed."); + } + } + } + xfree (memhunk); + } +} + +/* load_corefile -- reads a corefile, copies its memory sections + into target memory, and its registers into target regcache. */ + +bfd * +load_corefile (char *filename, int from_tty) +{ + struct load_core_args_params params; + struct bfd_section *regsect; + const struct regset *regset; + struct regcache *regcache; + struct cleanup *old_chain; + struct gdbarch *gdbarch; + char *scratch_path; + int scratch_chan; + char *contents; + bfd *core_bfd; + int size; + + scratch_chan =3D openp (getenv ("PATH"), OPF_TRY_CWD_FIRST, filename, + O_BINARY | O_RDONLY | O_LARGEFILE, &scratch_path); + if (scratch_chan < 0) + perror_with_name (filename); + + core_bfd =3D bfd_fdopenr (scratch_path, gnutarget, scratch_chan); + old_chain =3D make_cleanup_bfd_close (core_bfd); + if (!core_bfd) + perror_with_name (scratch_path); + + if (!bfd_check_format (core_bfd, bfd_core)) + error (_("\"%s\" is not a core file: %s"), + filename, bfd_errmsg (bfd_get_error ())); + + params.from_tty =3D from_tty; + params.top_of_heap =3D call_target_sbrk (0); + if (params.top_of_heap =3D=3D 0) + error (_("Couldn't get sbrk.")); + + bfd_map_over_sections (core_bfd, load_core_segment, (void *) ¶ms); + /* Now need to get/set registers. */ + regsect =3D bfd_get_section_by_name (core_bfd, ".reg"); + + if (!regsect) + error (_("Couldn't find .reg section.")); + + size =3D bfd_section_size (core_bfd, regsect); + contents =3D alloca (size); + bfd_get_section_contents (core_bfd, regsect, contents, 0, size); + + /* See FIXME kettenis/20031023 comment in corelow.c */ + gdbarch =3D gdbarch_from_bfd (core_bfd); + + if (gdbarch && gdbarch_regset_from_core_section_p (gdbarch)) + { + regset =3D gdbarch_regset_from_core_section (gdbarch, ".reg", size); + if (!regset) + error (_("Failed to allocate regset.")); + + registers_changed (); + regcache =3D get_current_regcache (); + regset->supply_regset (regset, regcache, -1, contents, size); + reinit_frame_cache (); + target_store_registers (regcache, -1); + } + else + error (_("Failed to get regset from core section")); + + discard_cleanups (old_chain); + return core_bfd; +} + /* Provide a prototype to silence -Wmissing-prototypes. */ extern initialize_file_ftype _initialize_gcore; --- /dev/null +++ b/gcore.h @@ -0,0 +1,23 @@ +/* Support for reading/writing gcore files. + + Copyright (C) 2009, Free Software Foundation, Inc. + + This file is part of GDB. + + 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 . = */ + +extern bfd *create_gcore_bfd (char *filename); +extern void write_gcore_file (bfd *obfd); +extern bfd *load_corefile (char *filename, int from_tty); + --- a/record.c +++ b/record.c @@ -23,15 +23,25 @@ #include "gdbthread.h" #include "event-top.h" #include "exceptions.h" +#include "completer.h" +#include "arch-utils.h" +#include "gdbcore.h" +#include "exec.h" #include "record.h" +#include "elf-bfd.h" +#include "gcore.h" +#include #include +#include #define DEFAULT_RECORD_INSN_MAX_NUM 200000 #define RECORD_IS_REPLAY \ (record_list->next || execution_direction =3D=3D EXEC_REVERSE) +#define RECORD_FILE_MAGIC htonl(0x20090829) + /* These are the core struct of record function. An record_entry is a record of the value change of a register @@ -78,9 +88,22 @@ struct record_entry } u; }; +struct record_core_buf_entry +{ + struct record_core_buf_entry *prev; + struct target_section *p; + bfd_byte *buf; +}; + /* This is the debug switch for process record. */ int record_debug =3D 0; +/* Record buf with core target. */ +static gdb_byte *record_core_regbuf =3D NULL; +static struct target_section *record_core_start; +static struct target_section *record_core_end; +static struct record_core_buf_entry *record_core_buf_list =3D NULL; + /* These list is for execution log. */ static struct record_entry record_first; static struct record_entry *record_list =3D &record_first; @@ -94,6 +117,7 @@ static int record_insn_num =3D 0; /* The target_ops of process record. */ static struct target_ops record_ops; +static struct target_ops record_core_ops; /* The beneath function pointers. */ static struct target_ops *record_beneath_to_resume_ops; @@ -169,7 +193,7 @@ record_list_release_next (void) } static void -record_list_release_first (void) +record_list_release_first_insn (void) { struct record_entry *tmp =3D NULL; enum record_type type; @@ -227,6 +251,56 @@ record_arch_list_add (struct record_entr } } +/* Alloc a record_reg record entry. */ + +static inline struct record_entry * +record_reg_alloc (int num) +{ + struct record_entry *rec; + + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->u.reg.val =3D (gdb_byte *) xmalloc (MAX_REGISTER_SIZE); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_reg; + rec->u.reg.num =3D num; + + return rec; +} + +/* Alloc a record_mem record entry. */ + +static inline struct record_entry * +record_mem_alloc (int len) +{ + struct record_entry *rec; + + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->u.mem.val =3D (gdb_byte *) xmalloc (len); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_mem; + rec->u.mem.len =3D len; + rec->u.mem.mem_entry_not_accessible =3D 0; + + return rec; +} + +/* Alloc a record_mem record entry. */ + +static inline struct record_entry * +record_end_alloc (void) +{ + struct record_entry *rec; + + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_end; + + return rec; +} + /* Record the value of a register NUM to record_arch_list. */ int @@ -240,12 +314,7 @@ record_arch_list_add_reg (struct regcach "record list.\n", num); - rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); - rec->u.reg.val =3D (gdb_byte *) xmalloc (MAX_REGISTER_SIZE); - rec->prev =3D NULL; - rec->next =3D NULL; - rec->type =3D record_reg; - rec->u.reg.num =3D num; + rec =3D record_reg_alloc (num); regcache_raw_read (regcache, num, rec->u.reg.val); @@ -271,14 +340,8 @@ record_arch_list_add_mem (CORE_ADDR addr if (!addr) return 0; - rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); - rec->u.mem.val =3D (gdb_byte *) xmalloc (len); - rec->prev =3D NULL; - rec->next =3D NULL; - rec->type =3D record_mem; + rec =3D record_mem_alloc (len); rec->u.mem.addr =3D addr; - rec->u.mem.len =3D len; - rec->u.mem.mem_entry_not_accessible =3D 0; if (target_read_memory (addr, rec->u.mem.val, len)) { @@ -308,10 +371,7 @@ record_arch_list_add_end (void) fprintf_unfiltered (gdb_stdlog, "Process record: add end to arch list.\n"); - rec =3D (struct record_entry *) xmalloc (sizeof (struct record_entry)); - rec->prev =3D NULL; - rec->next =3D NULL; - rec->type =3D record_end; + rec =3D record_end_alloc (); record_arch_list_add (rec); @@ -340,30 +400,30 @@ record_check_insn_num (int set_terminal) if (q) record_stop_at_limit =3D 0; else - error (_("Process record: inferior program stopped.")); + error (_("Process record: stoped by user.")); } } } } +static void +record_arch_list_cleanups (void *ignore) +{ + record_list_release (record_arch_list_tail); +} + /* Before inferior step (when GDB record the running message, inferior only can step), GDB will call this function to record the values to record_list. This function will call gdbarch_process_record to record the running message of inferior and set them to record_arch_list, and add it to record_list. */ -static void -record_message_cleanups (void *ignore) -{ - record_list_release (record_arch_list_tail); -} - static int record_message (void *args) { int ret; struct regcache *regcache =3D args; - struct cleanup *old_cleanups =3D make_cleanup (record_message_cleanups, = 0); + struct cleanup *old_cleanups =3D make_cleanup (record_arch_list_cleanups= , 0); record_arch_list_head =3D NULL; record_arch_list_tail =3D NULL; @@ -386,7 +446,7 @@ record_message (void *args) record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; @@ -416,13 +476,297 @@ record_gdb_operation_disable_set (void) return old_cleanups; } +static inline void +record_exec_entry (struct regcache *regcache, struct gdbarch *gdbarch, + struct record_entry *entry) +{ + switch (entry->type) + { + case record_reg: /* reg */ + { + gdb_byte reg[MAX_REGISTER_SIZE]; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_reg %s to " + "inferior num =3D %d.\n", + host_address_to_string (entry), + entry->u.reg.num); + + regcache_cooked_read (regcache, entry->u.reg.num, reg); + regcache_cooked_write (regcache, entry->u.reg.num, entry->u.reg.va= l); + memcpy (entry->u.reg.val, reg, MAX_REGISTER_SIZE); + } + break; + + case record_mem: /* mem */ + { + if (!record_list->u.mem.mem_entry_not_accessible) + { + gdb_byte *mem =3D alloca (entry->u.mem.len); + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_mem %s to " + "inferior addr =3D %s len =3D %d.\n", + host_address_to_string (entry), + paddress (gdbarch, entry->u.mem.addr), + record_list->u.mem.len); + + if (target_read_memory (entry->u.mem.addr, mem, entry->u.mem.l= en)) + { + record_list->u.mem.mem_entry_not_accessible =3D 1; + if (record_debug) + warning (_("Process record: error reading memory at " + "addr =3D %s len =3D %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + { + if (target_write_memory (entry->u.mem.addr, entry->u.mem.v= al, + entry->u.mem.len)) + { + record_list->u.mem.mem_entry_not_accessible =3D 1; + if (record_debug) + warning (_("Process record: error writing memory at " + "addr =3D %s len =3D %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + memcpy (entry->u.mem.val, mem, entry->u.mem.len); + } + } + } + break; + } +} + +/* Load the execution log from core_bfd. */ + +static int +bfdcore_read (bfd *obfd, asection *osec, void *buf, int len, int *offset) +{ + int ret =3D bfd_get_section_contents (obfd, osec, buf, *offset, len); + + if (ret) + *offset +=3D len; + return ret; +} + static void -record_open (char *name, int from_tty) +record_load (void) { - struct target_ops *t; + uint32_t magic; + struct cleanup *old_cleanups; + struct record_entry *rec; + asection *osec; + int bfd_offset =3D 0; + + /* We load the execution log from the open core bfd, + if there is one. */ + if (core_bfd =3D=3D NULL) + return; + + /* "record_load" just can be called when record list is empty. */ + gdb_assert (record_first.next =3D=3D NULL); if (record_debug) - fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); + fprintf_filtered (gdb_stdlog, + _("Restoring recording from core file.\n")); + + /* Now need to find our special note section. */ + osec =3D bfd_get_section_by_name (core_bfd, "null0"); + printf_filtered ("Find precord section %s.\n", + osec ? "succeeded" : "failed"); + if (!osec) + return; + if (record_debug) + fprintf_filtered (gdb_stdlog, "osec name =3D '%s'\n", + bfd_section_name (core_bfd, osec)); + + /* Check the magic code. */ + if (!bfdcore_read (core_bfd, osec, &magic, sizeof (magic), &bfd_offset)) + error (_("Failed to read 'magic' from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + if (magic !=3D RECORD_FILE_MAGIC) + error (_("Version mis-match or file format error.")); + if (record_debug) + fprintf_filtered (gdb_stdlog, _("\ +Reading 4-byte magic cookie RECORD_FILE_MAGIC (0x%08x)\n"), + magic); + + /* Load the entries in recfd to the record_arch_list_head and + record_arch_list_tail. */ + record_arch_list_head =3D NULL; + record_arch_list_tail =3D NULL; + record_insn_num =3D 0; + old_cleanups =3D make_cleanup (record_arch_list_cleanups, 0); + + while (1) + { + int ret; + uint8_t tmpu8; + uint64_t tmpu64; + + /* FIXME: Check offset for end-of-section. */ + if (!bfdcore_read (core_bfd, osec, &tmpu8, + sizeof (tmpu8), &bfd_offset)) + break; + + switch (tmpu8) + { + case record_reg: /* reg */ + /* Get num to tmpu64. */ + if (!bfdcore_read (core_bfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to read regnum from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + + rec =3D record_reg_alloc ((int) tmpu64); + + /* Get val. */ + if (!bfdcore_read (core_bfd, osec, rec->u.reg.val, + MAX_REGISTER_SIZE, &bfd_offset)) + error (_("Failed to read regval from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Reading register %d (1 plus 8 plus %d bytes)\n"), + rec->u.reg.num, + MAX_REGISTER_SIZE); + break; + + case record_mem: /* mem */ + /* Get len. */ + if (!bfdcore_read (core_bfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to read memlen from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + + rec =3D record_mem_alloc ((int) tmpu64); + + /* Get addr. */ + if (!bfdcore_read (core_bfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to read memaddr from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + rec->u.mem.addr =3D tmpu64; + + /* Get val. */ + if (!bfdcore_read (core_bfd, osec, rec->u.mem.val, + rec->u.mem.len, &bfd_offset)) + error (_("Failed to read memval from core file (%s)"), + bfd_errmsg (bfd_get_error ())); + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Reading memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"), + paddress (get_current_arch (), + rec->u.mem.addr), + rec->u.mem.len); + break; + + case record_end: /* end */ + rec =3D record_end_alloc (); + record_insn_num ++; + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Reading record_end (1 byte)\n")); + break; + + default: + error (_("Format of core file is not right.")); + break; + } + + /* Add rec to record arch list. */ + record_arch_list_add (rec); + } + + discard_cleanups (old_cleanups); + + /* Add record_arch_list_head to the end of record list. */ + record_first.next =3D record_arch_list_head; + record_arch_list_head->prev =3D &record_first; + + /* Update record_insn_max_num. */ + if (record_insn_num > record_insn_max_num) + { + record_insn_max_num =3D record_insn_num; + warning (_("Auto increase record/replay buffer limit to %d."), + record_insn_max_num); + } + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, "Loaded records from core file.\n"); + + print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); +} + +static struct target_ops *tmp_to_resume_ops; +static void (*tmp_to_resume) (struct target_ops *, ptid_t, int, + enum target_signal); +static struct target_ops *tmp_to_wait_ops; +static ptid_t (*tmp_to_wait) (struct target_ops *, ptid_t, + struct target_waitstatus *, + int); +static struct target_ops *tmp_to_store_registers_ops; +static void (*tmp_to_store_registers) (struct target_ops *, + struct regcache *, + int regno); +static struct target_ops *tmp_to_xfer_partial_ops; +static LONGEST (*tmp_to_xfer_partial) (struct target_ops *ops, + enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, + LONGEST len); +static int (*tmp_to_insert_breakpoint) (struct gdbarch *, + struct bp_target_info *); +static int (*tmp_to_remove_breakpoint) (struct gdbarch *, + struct bp_target_info *); + +static void +record_core_open_1 (char *name, int from_tty) +{ + struct regcache *regcache =3D get_current_regcache (); + int regnum =3D gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + /* Get record_core_regbuf. */ + target_fetch_registers (regcache, -1); + record_core_regbuf =3D xmalloc (MAX_REGISTER_SIZE * regnum); + for (i =3D 0; i < regnum; i ++) + regcache_raw_collect (regcache, i, + record_core_regbuf + MAX_REGISTER_SIZE * i); + + /* Get record_core_start and record_core_end. */ + if (build_section_table (core_bfd, &record_core_start, &record_core_end)) + { + xfree (record_core_regbuf); + record_core_regbuf =3D NULL; + error (_("\"%s\": Can't find sections: %s"), + bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); + } + + push_target (&record_core_ops); +} + +static void +record_open_1 (char *name, int from_tty) +{ + struct target_ops *t; /* check exec */ if (!target_has_execution) @@ -438,6 +782,28 @@ record_open (char *name, int from_tty) error (_("Process record: the current architecture doesn't support " "record function.")); + if (!tmp_to_resume) + error (_("Process record can't get to_resume.")); + if (!tmp_to_wait) + error (_("Process record can't get to_wait.")); + if (!tmp_to_store_registers) + error (_("Process record can't get to_store_registers.")); + if (!tmp_to_insert_breakpoint) + error (_("Process record can't get to_insert_breakpoint.")); + if (!tmp_to_remove_breakpoint) + error (_("Process record can't get to_remove_breakpoint.")); + + push_target (&record_ops); +} + +static void +record_open (char *name, int from_tty) +{ + struct target_ops *t; + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); + /* Check if record target is already running. */ if (current_target.to_stratum =3D=3D record_stratum) { @@ -447,70 +813,102 @@ record_open (char *name, int from_tty) return; } - /*Reset the beneath function pointers. */ - record_beneath_to_resume =3D NULL; - record_beneath_to_wait =3D NULL; - record_beneath_to_store_registers =3D NULL; - record_beneath_to_xfer_partial =3D NULL; - record_beneath_to_insert_breakpoint =3D NULL; - record_beneath_to_remove_breakpoint =3D NULL; + /* Reset the tmp beneath pointers. */ + tmp_to_resume_ops =3D NULL; + tmp_to_resume =3D NULL; + tmp_to_wait_ops =3D NULL; + tmp_to_wait =3D NULL; + tmp_to_store_registers_ops =3D NULL; + tmp_to_store_registers =3D NULL; + tmp_to_xfer_partial_ops =3D NULL; + tmp_to_xfer_partial =3D NULL; + tmp_to_insert_breakpoint =3D NULL; + tmp_to_remove_breakpoint =3D NULL; /* Set the beneath function pointers. */ for (t =3D current_target.beneath; t !=3D NULL; t =3D t->beneath) { - if (!record_beneath_to_resume) + if (!tmp_to_resume) { - record_beneath_to_resume =3D t->to_resume; - record_beneath_to_resume_ops =3D t; + tmp_to_resume =3D t->to_resume; + tmp_to_resume_ops =3D t; } - if (!record_beneath_to_wait) + if (!tmp_to_wait) { - record_beneath_to_wait =3D t->to_wait; - record_beneath_to_wait_ops =3D t; + tmp_to_wait =3D t->to_wait; + tmp_to_wait_ops =3D t; } - if (!record_beneath_to_store_registers) + if (!tmp_to_store_registers) { - record_beneath_to_store_registers =3D t->to_store_registers; - record_beneath_to_store_registers_ops =3D t; + tmp_to_store_registers =3D t->to_store_registers; + tmp_to_store_registers_ops =3D t; } - if (!record_beneath_to_xfer_partial) + if (!tmp_to_xfer_partial) { - record_beneath_to_xfer_partial =3D t->to_xfer_partial; - record_beneath_to_xfer_partial_ops =3D t; + tmp_to_xfer_partial =3D t->to_xfer_partial; + tmp_to_xfer_partial_ops =3D t; } - if (!record_beneath_to_insert_breakpoint) - record_beneath_to_insert_breakpoint =3D t->to_insert_breakpoint; - if (!record_beneath_to_remove_breakpoint) - record_beneath_to_remove_breakpoint =3D t->to_remove_breakpoint; + if (!tmp_to_insert_breakpoint) + tmp_to_insert_breakpoint =3D t->to_insert_breakpoint; + if (!tmp_to_remove_breakpoint) + tmp_to_remove_breakpoint =3D t->to_remove_breakpoint; } - if (!record_beneath_to_resume) - error (_("Process record can't get to_resume.")); - if (!record_beneath_to_wait) - error (_("Process record can't get to_wait.")); - if (!record_beneath_to_store_registers) - error (_("Process record can't get to_store_registers.")); - if (!record_beneath_to_xfer_partial) + if (!tmp_to_xfer_partial) error (_("Process record can't get to_xfer_partial.")); - if (!record_beneath_to_insert_breakpoint) - error (_("Process record can't get to_insert_breakpoint.")); - if (!record_beneath_to_remove_breakpoint) - error (_("Process record can't get to_remove_breakpoint.")); - push_target (&record_ops); + if (current_target.to_stratum =3D=3D core_stratum) + record_core_open_1 (name, from_tty); + else + record_open_1 (name, from_tty); /* Reset */ record_insn_num =3D 0; record_list =3D &record_first; record_list->next =3D NULL; + + /* Set the tmp beneath pointers to beneath pointers. */ + record_beneath_to_resume_ops =3D tmp_to_resume_ops; + record_beneath_to_resume =3D tmp_to_resume; + record_beneath_to_wait_ops =3D tmp_to_wait_ops; + record_beneath_to_wait =3D tmp_to_wait; + record_beneath_to_store_registers_ops =3D tmp_to_store_registers_ops; + record_beneath_to_store_registers =3D tmp_to_store_registers; + record_beneath_to_xfer_partial_ops =3D tmp_to_xfer_partial_ops; + record_beneath_to_xfer_partial =3D tmp_to_xfer_partial; + record_beneath_to_insert_breakpoint =3D tmp_to_insert_breakpoint; + record_beneath_to_remove_breakpoint =3D tmp_to_remove_breakpoint; + + if (strcmp (current_target.to_shortname, "record_core") =3D=3D 0) + record_load (); } static void record_close (int quitting) { + struct record_core_buf_entry *entry; + if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n"); record_list_release (record_list); + + /* Release record_core_regbuf. */ + if (record_core_regbuf) + { + xfree (record_core_regbuf); + record_core_regbuf =3D NULL; + } + + /* Release record_core_buf_list. */ + if (record_core_buf_list) + { + for (entry =3D record_core_buf_list->prev; entry; entry =3D entry->p= rev) + { + xfree (record_core_buf_list); + record_core_buf_list =3D entry; + } + record_core_buf_list =3D NULL; + } } static int record_resume_step =3D 0; @@ -584,7 +982,7 @@ record_wait (struct target_ops *ops, "record_resume_step =3D %d\n", record_resume_step); - if (!RECORD_IS_REPLAY) + if (!RECORD_IS_REPLAY && ops !=3D &record_core_ops) { if (record_resume_error) { @@ -712,76 +1110,9 @@ record_wait (struct target_ops *ops, break; } - /* Set ptid, register and memory according to record_list. */ - if (record_list->type =3D=3D record_reg) - { - /* reg */ - gdb_byte reg[MAX_REGISTER_SIZE]; - if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, - "Process record: record_reg %s to " - "inferior num =3D %d.\n", - host_address_to_string (record_list), - record_list->u.reg.num); - regcache_cooked_read (regcache, record_list->u.reg.num, reg); - regcache_cooked_write (regcache, record_list->u.reg.num, - record_list->u.reg.val); - memcpy (record_list->u.reg.val, reg, MAX_REGISTER_SIZE); - } - else if (record_list->type =3D=3D record_mem) - { - /* mem */ - /* Nothing to do if the entry is flagged not_accessible. */ - if (!record_list->u.mem.mem_entry_not_accessible) - { - gdb_byte *mem =3D alloca (record_list->u.mem.len); - if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, - "Process record: record_mem %s to " - "inferior addr =3D %s len =3D %d.\n", - host_address_to_string (record_list), - paddress (gdbarch, - record_list->u.mem.addr), - record_list->u.mem.len); + record_exec_entry (regcache, gdbarch, record_list); - if (target_read_memory (record_list->u.mem.addr, mem, - record_list->u.mem.len)) - { - if (execution_direction !=3D EXEC_REVERSE) - error (_("Process record: error reading memory at " - "addr =3D %s len =3D %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - else - /* Read failed -- - flag entry as not_accessible. */ - record_list->u.mem.mem_entry_not_accessible =3D 1; - } - else - { - if (target_write_memory (record_list->u.mem.addr, - record_list->u.mem.val, - record_list->u.mem.len)) - { - if (execution_direction !=3D EXEC_REVERSE) - error (_("Process record: error writing memory at " - "addr =3D %s len =3D %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - else - /* Write failed -- - flag entry as not_accessible. */ - record_list->u.mem.mem_entry_not_accessible =3D 1; - } - else - { - memcpy (record_list->u.mem.val, mem, - record_list->u.mem.len); - } - } - } - } - else + if (record_list->type =3D=3D record_end) { if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, @@ -901,6 +1232,7 @@ record_kill (struct target_ops *ops) fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n"); unpush_target (&record_ops); + target_kill (); } @@ -945,7 +1277,7 @@ record_registers_change (struct regcache record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } @@ -1058,7 +1390,7 @@ record_xfer_partial (struct target_ops * record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_nu= m) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } @@ -1138,6 +1470,191 @@ init_record_ops (void) } static void +record_core_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_signal siggnal) +{ + record_resume_step =3D step; + record_resume_siggnal =3D siggnal; +} + +static void +record_core_kill (struct target_ops *ops) +{ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "Process record: record_core_kill\n"); + + unpush_target (&record_core_ops); +} + +static void +record_core_fetch_registers (struct target_ops *ops, + struct regcache *regcache, + int regno) +{ + if (regno < 0) + { + int num =3D gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + for (i =3D 0; i < num; i ++) + regcache_raw_supply (regcache, i, + record_core_regbuf + MAX_REGISTER_SIZE * i); + } + else + regcache_raw_supply (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * regno); +} + +static void +record_core_prepare_to_store (struct regcache *regcache) +{ +} + +static void +record_core_store_registers (struct target_ops *ops, + struct regcache *regcache, + int regno) +{ + if (record_gdb_operation_disable) + regcache_raw_collect (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * regno); + else + error (_("You can't do that without a process to debug.")); +} + +static LONGEST +record_core_xfer_partial (struct target_ops *ops, enum target_object objec= t, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST offset, + LONGEST len) +{ + if (object =3D=3D TARGET_OBJECT_MEMORY) + { + if (record_gdb_operation_disable || !writebuf) + { + struct target_section *p; + for (p =3D record_core_start; p < record_core_end; p++) + { + if (offset >=3D p->addr) + { + struct record_core_buf_entry *entry; + + if (offset >=3D p->endaddr) + continue; + + if (offset + len > p->endaddr) + len =3D p->endaddr - offset; + + offset -=3D p->addr; + + /* Read readbuf or write writebuf p, offset, len. */ + /* Check flags. */ + if (p->the_bfd_section->flags & SEC_CONSTRUCTOR + || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) = =3D=3D 0) + { + if (readbuf) + memset (readbuf, 0, len); + return len; + } + /* Get record_core_buf_entry. */ + for (entry =3D record_core_buf_list; entry; + entry =3D entry->prev) + if (entry->p =3D=3D p) + break; + if (writebuf) + { + if (!entry) + { + /* Add a new entry. */ + entry + =3D (struct record_core_buf_entry *) + xmalloc + (sizeof (struct record_core_buf_entry)); + entry->p =3D p; + if (!bfd_malloc_and_get_section (p->bfd, + p->the_bfd_sec= tion, + &entry->buf)) + { + xfree (entry); + return 0; + } + entry->prev =3D record_core_buf_list; + record_core_buf_list =3D entry; + } + + memcpy (entry->buf + offset, writebuf, (size_t) le= n); + } + else + { + if (!entry) + return record_beneath_to_xfer_partial + (record_beneath_to_xfer_partial_ops, + object, annex, readbuf, writebuf, + offset, len); + + memcpy (readbuf, entry->buf + offset, (size_t) len); + } + + return len; + } + } + + return -1; + } + else + error (_("You can't do that without a process to debug.")); + } + + return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_op= s, + object, annex, readbuf, writebuf, + offset, len); +} + +static int +record_core_insert_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + return 0; +} + +static int +record_core_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + return 0; +} + +int +record_core_has_execution (struct target_ops *ops) +{ + return 1; +} + +static void +init_record_core_ops (void) +{ + record_core_ops.to_shortname =3D "record_core"; + record_core_ops.to_longname =3D "Process record and replay target"; + record_core_ops.to_doc =3D + "Log program while executing and replay execution from log."; + record_core_ops.to_open =3D record_open; + record_core_ops.to_close =3D record_close; + record_core_ops.to_resume =3D record_core_resume; + record_core_ops.to_wait =3D record_wait; + record_core_ops.to_kill =3D record_core_kill; + record_core_ops.to_fetch_registers =3D record_core_fetch_registers; + record_core_ops.to_prepare_to_store =3D record_core_prepare_to_store; + record_core_ops.to_store_registers =3D record_core_store_registers; + record_core_ops.to_xfer_partial =3D record_core_xfer_partial; + record_core_ops.to_insert_breakpoint =3D record_core_insert_breakpoint; + record_core_ops.to_remove_breakpoint =3D record_core_remove_breakpoint; + record_core_ops.to_can_execute_reverse =3D record_can_execute_reverse; + record_core_ops.to_has_execution =3D record_core_has_execution; + record_core_ops.to_stratum =3D record_stratum; + record_core_ops.to_magic =3D OPS_MAGIC; +} + +static void show_record_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { @@ -1153,6 +1670,262 @@ cmd_record_start (char *args, int from_t execute_command ("target record", from_tty); } +/* Record log save-file format + Version 1 + + Header: + 4 bytes: magic number htonl(0x20090829). + NOTE: be sure to change whenever this file format changes! + + Records: + record_end: + 1 byte: record type (record_end). + record_reg: + 1 byte: record type (record_reg). + 8 bytes: register id (network byte order). + MAX_REGISTER_SIZE bytes: register value. + record_mem: + 1 byte: record type (record_mem). + 8 bytes: memory length (network byte order). + 8 bytes: memory address (network byte order). + n bytes: memory value (n =3D=3D memory length). +*/ + +/* bfdcore_write -- write bytes into a core file section. */ + +static int +bfdcore_write (bfd *obfd, asection *osec, void *buf, int len, int *offset) +{ + int ret =3D bfd_set_section_contents (obfd, osec, buf, *offset, len); + + if (ret) + *offset +=3D len; + return ret; +} + +/* Dump the execution log to a file. */ + +static void +cmd_record_dump (char *args, int from_tty) +{ + char *recfilename, recfilename_buffer[40]; + int recfd; + struct record_entry *cur_record_list; + uint32_t magic; + struct regcache *regcache; + struct gdbarch *gdbarch; + struct cleanup *old_cleanups; + struct cleanup *set_cleanups; + bfd *obfd; + int dump_size =3D 0; + asection *osec =3D NULL; + int bfd_offset =3D 0; + + if (strcmp (current_target.to_shortname, "record") !=3D 0) + error (_("Process record is not started.\n")); + + if (args && *args) + recfilename =3D args; + else + { + /* Default recfile name is "gdb_record.PID". */ + snprintf (recfilename_buffer, sizeof (recfilename_buffer), + "gdb_record.%d", PIDGET (inferior_ptid)); + recfilename =3D recfilename_buffer; + } + + /* Open the dump file. */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Saving recording to file '%s'\n"), + recfilename); + /* Open the output file. */ + obfd =3D create_gcore_bfd (recfilename); + /* Need a cleanup that will close the file (FIXME: delete it?). */ + old_cleanups =3D make_cleanup_bfd_close (obfd); + + /* Save the current record entry to "cur_record_list". */ + cur_record_list =3D record_list; + + /* Get the values of regcache and gdbarch. */ + regcache =3D get_current_regcache (); + gdbarch =3D get_regcache_arch (regcache); + + /* Disable the GDB operation record. */ + set_cleanups =3D record_gdb_operation_disable_set (); + + /* Reverse execute to the begin of record list. */ + while (1) + { + /* Check for beginning and end of log. */ + if (record_list =3D=3D &record_first) + break; + + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->prev) + record_list =3D record_list->prev; + } + + /* Compute the size needed for the extra bfd section. */ + dump_size =3D 4; /* magic cookie */ + for (record_list =3D &record_first; record_list; + record_list =3D record_list->next) + switch (record_list->type) + { + case record_end: + dump_size +=3D 1; + break; + case record_reg: + dump_size +=3D 1 + 8 + MAX_REGISTER_SIZE; + break; + case record_mem: + dump_size +=3D 1 + 8 + 8 + record_list->u.mem.len; + break; + } + + /* Make the new bfd section. */ + osec =3D bfd_make_section_anyway_with_flags (obfd, "precord", + SEC_HAS_CONTENTS + | SEC_READONLY); + if (osec =3D=3D NULL) + error (_("Failed to create 'precord' section for corefile: %s"), + bfd_errmsg (bfd_get_error ())); + bfd_set_section_size (obfd, osec, dump_size); + bfd_set_section_vma (obfd, osec, 0); + bfd_set_section_alignment (obfd, osec, 0); + bfd_section_lma (obfd, osec) =3D 0; + + /* Save corefile state. */ + write_gcore_file (obfd); + + /* Write out the record log. */ + /* Write the magic code. */ + magic =3D RECORD_FILE_MAGIC; + if (record_debug) + fprintf_filtered (gdb_stdlog, _("\ +Writing 4-byte magic cookie RECORD_FILE_MAGIC (0x%08x)\n"), + magic); + if (!bfdcore_write (obfd, osec, &magic, sizeof (magic), &bfd_offset)) + error (_("Failed to write 'magic' to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + + /* Dump the entries to recfd and forward execute to the end of + record list. */ + record_list =3D &record_first; + while (1) + { + /* Dump entry. */ + if (record_list !=3D &record_first) + { + uint8_t tmpu8; + uint64_t tmpu64; + + tmpu8 =3D record_list->type; + if (!bfdcore_write (obfd, osec, &tmpu8, sizeof (tmpu8), + &bfd_offset)) + error (_("Failed to write 'type' to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + + switch (record_list->type) + { + case record_reg: /* reg */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Writing register %d (1 plus 8 plus %d bytes)\n"), + record_list->u.reg.num, + MAX_REGISTER_SIZE); + + /* Write regnum. */ + tmpu64 =3D record_list->u.reg.num; + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + if (!bfdcore_write (obfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to write regnum to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + + /* Write regval. */ + if (!bfdcore_write (obfd, osec, record_list->u.reg.val, + MAX_REGISTER_SIZE, &bfd_offset)) + error (_("Failed to write regval to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + break; + + case record_mem: /* mem */ + if (!record_list->u.mem.mem_entry_not_accessible) + { + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Writing memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"), + paddress (gdbarch, + record_list->u.mem.addr), + record_list->u.mem.len); + + /* Write memlen. */ + tmpu64 =3D record_list->u.mem.len; + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + if (!bfdcore_write (obfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to write memlen to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + + /* Write memaddr. */ + tmpu64 =3D record_list->u.mem.addr; + if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); + if (!bfdcore_write (obfd, osec, &tmpu64, + sizeof (tmpu64), &bfd_offset)) + error (_("Failed to write memaddr to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + + /* Write memval. */ + if (!bfdcore_write (obfd, osec, record_list->u.mem.val, + record_list->u.mem.len, &bfd_offset)) + error (_("Failed to write memval to %s (%s)"), + recfilename, bfd_errmsg (bfd_get_error ())); + } + break; + + case record_end: + /* FIXME: record the contents of record_end rec. */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Writing record_end (1 byte)\n")); + break; + } + } + + /* Execute entry. */ + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->next) + record_list =3D record_list->next; + else + break; + } + + /* Reverse execute to cur_record_list. */ + while (1) + { + /* Check for beginning and end of log. */ + if (record_list =3D=3D cur_record_list) + break; + + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->prev) + record_list =3D record_list->prev; + } + + do_cleanups (set_cleanups); + do_cleanups (old_cleanups); + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, _("Saved recfile %s.\n"), recfilename); +} + /* Truncate the record log from the present point of replay until the end. */ @@ -1185,7 +1958,12 @@ cmd_record_stop (char *args, int from_tt { if (!record_list || !from_tty || query (_("Delete recorded log and " "stop recording?"))) - unpush_target (&record_ops); + { + if (strcmp (current_target.to_shortname, "record") =3D=3D 0) + unpush_target (&record_ops); + else + unpush_target (&record_core_ops); + } } else printf_unfiltered (_("Process record is not started.\n")); @@ -1203,7 +1981,7 @@ set_record_insn_max_num (char *args, int "the first ones?\n")); while (record_insn_num > record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); } } @@ -1243,6 +2021,8 @@ info_record_command (char *args, int fro void _initialize_record (void) { + struct cmd_list_element *c; + /* Init record_first. */ record_first.prev =3D NULL; record_first.next =3D NULL; @@ -1250,6 +2030,8 @@ _initialize_record (void) init_record_ops (); add_target (&record_ops); + init_record_core_ops (); + add_target (&record_core_ops); add_setshow_zinteger_cmd ("record", no_class, &record_debug, _("Set debugging of record/replay feature."), @@ -1259,9 +2041,10 @@ _initialize_record (void) NULL, show_record_debug, &setdebuglist, &showdebuglist); - add_prefix_cmd ("record", class_obscure, cmd_record_start, - _("Abbreviated form of \"target record\" command."), - &record_cmdlist, "record ", 0, &cmdlist); + c =3D add_prefix_cmd ("record", class_obscure, cmd_record_start, + _("Abbreviated form of \"target record\" command."), + &record_cmdlist, "record ", 0, &cmdlist); + set_cmd_completer (c, filename_completer); add_com_alias ("rec", "record", class_obscure, 1); add_prefix_cmd ("record", class_support, set_record_command, _("Set record options"), &set_record_cmdlist, @@ -1276,6 +2059,11 @@ _initialize_record (void) "info record ", 0, &infolist); add_alias_cmd ("rec", "record", class_obscure, 1, &infolist); + c =3D add_cmd ("dump", class_obscure, cmd_record_dump, + _("Dump the execution records to a file.\n\ +Argument is optional filename. Default filename is 'gdb_record.'."), + &record_cmdlist); + set_cmd_completer (c, filename_completer); add_cmd ("delete", class_obscure, cmd_record_delete, _("Delete the rest of execution log and start recording it anew."), --- doc/gdb.texinfo | 10 ++++++++++ 1 file changed, 10 insertions(+) --- a/doc/gdb.texinfo +++ b/doc/gdb.texinfo @@ -5214,6 +5214,16 @@ When record target runs in replay mode ( subsequent execution log and begin to record a new execution log starting from the current address. This means you will abandon the previously recorded ``future'' and begin recording a new ``future''. + +@kindex record dump +@kindex rec dump +@item record dump [@var{file}] +@itemx rec dump [@var{file}] +Dump the execution records of the inferior process to a core file. +The optional argument @var{file} specifies the file name where to put +the record dump. If not specified, the file name defaults +to @file{gdb_record.@var{pid}}, where @var{pid} is is the PID of the +inferior process. @end table --00151773d9f24ef1be047249510f Content-Type: text/plain; charset=US-ASCII; name="prec-dump.txt" Content-Disposition: attachment; filename="prec-dump.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fyyhyxdx0 Content-length: 76612 LS0tCiBnY29yZS5jICB8ICAzMDkgKysrKysrKysrKysrKystLS0tCiBnY29y ZS5oICB8ICAgMjMgKwogcmVjb3JkLmMgfCAxMDcyICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0t LS0tLQogMyBmaWxlcyBjaGFuZ2VkLCAxMTk5IGluc2VydGlvbnMoKyksIDIw NSBkZWxldGlvbnMoLSkKCi0tLSBhL2djb3JlLmMKKysrIGIvZ2NvcmUuYwpA QCAtMjUsMTAgKzI1LDE0IEBACiAjaW5jbHVkZSAiZ2RiY29yZS5oIgogI2lu Y2x1ZGUgIm9iamZpbGVzLmgiCiAjaW5jbHVkZSAic3ltZmlsZS5oIgotCisj aW5jbHVkZSAiYXJjaC11dGlscy5oIgorI2luY2x1ZGUgImNvbXBsZXRlci5o IgorI2luY2x1ZGUgImdjb3JlLmgiCiAjaW5jbHVkZSAiY2xpL2NsaS1kZWNv ZGUuaCIKLQogI2luY2x1ZGUgImdkYl9hc3NlcnQuaCIKKyNpbmNsdWRlIDxm Y250bC5oPgorI2luY2x1ZGUgInJlZ2NhY2hlLmgiCisjaW5jbHVkZSAicmVn c2V0LmgiCiAKIC8qIFRoZSBsYXJnZXN0IGFtb3VudCBvZiBtZW1vcnkgdG8g cmVhZCBmcm9tIHRoZSB0YXJnZXQgYXQgb25jZS4gIFdlCiAgICBtdXN0IHRo cm90dGxlIGl0IHRvIGxpbWl0IHRoZSBhbW91bnQgb2YgbWVtb3J5IHVzZWQg YnkgR0RCIGR1cmluZwpAQCAtNDAsNDUgKzQ0LDI3IEBAIHN0YXRpYyBlbnVt IGJmZF9hcmNoaXRlY3R1cmUgZGVmYXVsdF9nY28KIHN0YXRpYyB1bnNpZ25l ZCBsb25nIGRlZmF1bHRfZ2NvcmVfbWFjaCAodm9pZCk7CiBzdGF0aWMgaW50 IGdjb3JlX21lbW9yeV9zZWN0aW9ucyAoYmZkICopOwogCi0vKiBHZW5lcmF0 ZSBhIGNvcmUgZmlsZSBmcm9tIHRoZSBpbmZlcmlvciBwcm9jZXNzLiAgKi8K Ky8qIGNyZWF0ZV9nY29yZV9iZmQgLS0gaGVscGVyIGZvciBnY29yZV9jb21t YW5kIChleHBvcnRlZCkuICAqLwogCi1zdGF0aWMgdm9pZAotZ2NvcmVfY29t bWFuZCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQorYmZkICoKK2NyZWF0 ZV9nY29yZV9iZmQgKGNoYXIgKmZpbGVuYW1lKQogewotICBzdHJ1Y3QgY2xl YW51cCAqb2xkX2NoYWluOwotICBjaGFyICpjb3JlZmlsZW5hbWUsIGNvcmVm aWxlbmFtZV9idWZmZXJbNDBdOwotICBhc2VjdGlvbiAqbm90ZV9zZWMgPSBO VUxMOwotICBiZmQgKm9iZmQ7Ci0gIHZvaWQgKm5vdGVfZGF0YSA9IE5VTEw7 Ci0gIGludCBub3RlX3NpemUgPSAwOwotCi0gIC8qIE5vIHVzZSBnZW5lcmF0 aW5nIGEgY29yZWZpbGUgd2l0aG91dCBhIHRhcmdldCBwcm9jZXNzLiAgKi8K LSAgaWYgKCF0YXJnZXRfaGFzX2V4ZWN1dGlvbikKLSAgICBub3Byb2Nlc3Mg KCk7Ci0KLSAgaWYgKGFyZ3MgJiYgKmFyZ3MpCi0gICAgY29yZWZpbGVuYW1l ID0gYXJnczsKLSAgZWxzZQotICAgIHsKLSAgICAgIC8qIERlZmF1bHQgY29y ZWZpbGUgbmFtZSBpcyAiY29yZS5QSUQiLiAgKi8KLSAgICAgIHNwcmludGYg KGNvcmVmaWxlbmFtZV9idWZmZXIsICJjb3JlLiVkIiwgUElER0VUIChpbmZl cmlvcl9wdGlkKSk7Ci0gICAgICBjb3JlZmlsZW5hbWUgPSBjb3JlZmlsZW5h bWVfYnVmZmVyOwotICAgIH0KLQotICBpZiAoaW5mb192ZXJib3NlKQotICAg IGZwcmludGZfZmlsdGVyZWQgKGdkYl9zdGRvdXQsCi0JCSAgICAgICJPcGVu aW5nIGNvcmVmaWxlICclcycgZm9yIG91dHB1dC5cbiIsIGNvcmVmaWxlbmFt ZSk7Ci0KLSAgLyogT3BlbiB0aGUgb3V0cHV0IGZpbGUuICAqLwotICBvYmZk ID0gYmZkX29wZW53IChjb3JlZmlsZW5hbWUsIGRlZmF1bHRfZ2NvcmVfdGFy Z2V0ICgpKTsKKyAgYmZkICpvYmZkID0gYmZkX29wZW53IChmaWxlbmFtZSwg ZGVmYXVsdF9nY29yZV90YXJnZXQgKCkpOwogICBpZiAoIW9iZmQpCi0gICAg ZXJyb3IgKF8oIkZhaWxlZCB0byBvcGVuICclcycgZm9yIG91dHB1dC4iKSwg Y29yZWZpbGVuYW1lKTsKLQotICAvKiBOZWVkIGEgY2xlYW51cCB0aGF0IHdp bGwgY2xvc2UgdGhlIGZpbGUgKEZJWE1FOiBkZWxldGUgaXQ/KS4gICovCi0g IG9sZF9jaGFpbiA9IG1ha2VfY2xlYW51cF9iZmRfY2xvc2UgKG9iZmQpOwot CisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byBvcGVuICclcycgZm9yIG91dHB1 dC4iKSwgZmlsZW5hbWUpOwogICBiZmRfc2V0X2Zvcm1hdCAob2JmZCwgYmZk X2NvcmUpOwogICBiZmRfc2V0X2FyY2hfbWFjaCAob2JmZCwgZGVmYXVsdF9n Y29yZV9hcmNoICgpLCBkZWZhdWx0X2djb3JlX21hY2ggKCkpOworICByZXR1 cm4gb2JmZDsKK30KKworLyogd3JpdGVfZ2NvcmVfZmlsZSAtLSBoZWxwZXIg Zm9yIGdjb3JlX2NvbW1hbmQgKGV4cG9ydGVkKS4gICovCisKK3ZvaWQKK3dy aXRlX2djb3JlX2ZpbGUgKGJmZCAqb2JmZCkKK3sKKyAgdm9pZCAqbm90ZV9k YXRhID0gTlVMTDsKKyAgaW50IG5vdGVfc2l6ZSA9IDA7CisgIGFzZWN0aW9u ICpub3RlX3NlYyA9IE5VTEw7CiAKICAgLyogQW4gZXh0ZXJuYWwgdGFyZ2V0 IG1ldGhvZCBtdXN0IGJ1aWxkIHRoZSBub3RlcyBzZWN0aW9uLiAgKi8KICAg bm90ZV9kYXRhID0gdGFyZ2V0X21ha2VfY29yZWZpbGVfbm90ZXMgKG9iZmQs ICZub3RlX3NpemUpOwpAQCAtMTA3LDggKzkzLDQ2IEBAIGdjb3JlX2NvbW1h bmQgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0eSkKICAgaWYgKG5vdGVfZGF0 YSAhPSBOVUxMICYmIG5vdGVfc2l6ZSAhPSAwKQogICAgIHsKICAgICAgIGlm ICghYmZkX3NldF9zZWN0aW9uX2NvbnRlbnRzIChvYmZkLCBub3RlX3NlYywg bm90ZV9kYXRhLCAwLCBub3RlX3NpemUpKQotCXdhcm5pbmcgKF8oIndyaXRp bmcgbm90ZSBzZWN0aW9uICglcykiKSwgYmZkX2Vycm1zZyAoYmZkX2dldF9l cnJvciAoKSkpOworCXdhcm5pbmcgKF8oIndyaXRpbmcgbm90ZSBzZWN0aW9u ICglcykiKSwKKwkJIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJyb3IgKCkpKTsK ICAgICB9Cit9CisKKy8qIGdjb3JlX2NvbW1hbmQgLS0gaW1wbGVtZW50cyB0 aGUgJ2djb3JlJyBjb21tYW5kLgorICAgR2VuZXJhdGUgYSBjb3JlIGZpbGUg ZnJvbSB0aGUgaW5mZXJpb3IgcHJvY2Vzcy4gICovCisKK3N0YXRpYyB2b2lk CitnY29yZV9jb21tYW5kIChjaGFyICphcmdzLCBpbnQgZnJvbV90dHkpCit7 CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2hhaW47CisgIGNoYXIgKmNvcmVm aWxlbmFtZSwgY29yZWZpbGVuYW1lX2J1ZmZlcls0MF07CisgIGJmZCAqb2Jm ZDsKKworICAvKiBObyB1c2UgZ2VuZXJhdGluZyBhIGNvcmVmaWxlIHdpdGhv dXQgYSB0YXJnZXQgcHJvY2Vzcy4gICovCisgIGlmICghdGFyZ2V0X2hhc19l eGVjdXRpb24pCisgICAgbm9wcm9jZXNzICgpOworCisgIGlmIChhcmdzICYm ICphcmdzKQorICAgIGNvcmVmaWxlbmFtZSA9IGFyZ3M7CisgIGVsc2UKKyAg ICB7CisgICAgICAvKiBEZWZhdWx0IGNvcmVmaWxlIG5hbWUgaXMgImNvcmUu UElEIi4gICovCisgICAgICBzcHJpbnRmIChjb3JlZmlsZW5hbWVfYnVmZmVy LCAiY29yZS4lZCIsIFBJREdFVCAoaW5mZXJpb3JfcHRpZCkpOworICAgICAg Y29yZWZpbGVuYW1lID0gY29yZWZpbGVuYW1lX2J1ZmZlcjsKKyAgICB9CisK KyAgaWYgKGluZm9fdmVyYm9zZSkKKyAgICBmcHJpbnRmX2ZpbHRlcmVkIChn ZGJfc3Rkb3V0LAorCQkgICAgICAiT3BlbmluZyBjb3JlZmlsZSAnJXMnIGZv ciBvdXRwdXQuXG4iLCBjb3JlZmlsZW5hbWUpOworCisgIC8qIE9wZW4gdGhl IG91dHB1dCBmaWxlLiAgKi8KKyAgb2JmZCA9IGNyZWF0ZV9nY29yZV9iZmQg KGNvcmVmaWxlbmFtZSk7CisKKyAgLyogTmVlZCBhIGNsZWFudXAgdGhhdCB3 aWxsIGNsb3NlIHRoZSBmaWxlIChGSVhNRTogZGVsZXRlIGl0PykuICAqLwor ICBvbGRfY2hhaW4gPSBtYWtlX2NsZWFudXBfYmZkX2Nsb3NlIChvYmZkKTsK KworICAvKiBDYWxsIHdvcmtlciBmdW5jdGlvbi4gICovCisgIHdyaXRlX2dj b3JlX2ZpbGUgKG9iZmQpOwogCiAgIC8qIFN1Y2NlZWRlZC4gICovCiAgIGZw cmludGZfZmlsdGVyZWQgKGdkYl9zdGRvdXQsICJTYXZlZCBjb3JlZmlsZSAl c1xuIiwgY29yZWZpbGVuYW1lKTsKQEAgLTIxMiw2ICsyMzYsNTAgQEAgZGVy aXZlX3N0YWNrX3NlZ21lbnQgKGJmZF92bWEgKmJvdHRvbSwgYgogICByZXR1 cm4gMTsKIH0KIAorLyogY2FsbF90YXJnZXRfc2JyayAtLQorICAgaGVscGVy IGZ1bmN0aW9uIGZvciBkZXJpdmVfaGVhcF9zZWdtZW50IGFuZCBsb2FkX2Nv cmVfc2VnbWVudC4gICovCisKK3N0YXRpYyBiZmRfdm1hCitjYWxsX3Rhcmdl dF9zYnJrIChpbnQgc2Jya19hcmcpCit7CisgIHN0cnVjdCBvYmpmaWxlICpz YnJrX29iamY7CisgIHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoOworICBiZmRf dm1hIHRvcF9vZl9oZWFwOworICBzdHJ1Y3QgdmFsdWUgKnRhcmdldF9zYnJr X2FyZzsKKyAgc3RydWN0IHZhbHVlICpzYnJrX2ZuLCAqcmV0OworICBiZmRf dm1hIHRtcDsKKworICBpZiAobG9va3VwX21pbmltYWxfc3ltYm9sICgic2Jy ayIsIE5VTEwsIE5VTEwpICE9IE5VTEwpCisgICAgeworICAgICAgc2Jya19m biA9IGZpbmRfZnVuY3Rpb25faW5faW5mZXJpb3IgKCJzYnJrIiwgJnNicmtf b2JqZik7CisgICAgICBpZiAoc2Jya19mbiA9PSBOVUxMKQorCXJldHVybiAo YmZkX3ZtYSkgMDsKKyAgICB9CisgIGVsc2UgaWYgKGxvb2t1cF9taW5pbWFs X3N5bWJvbCAoIl9zYnJrIiwgTlVMTCwgTlVMTCkgIT0gTlVMTCkKKyAgICB7 CisgICAgICBzYnJrX2ZuID0gZmluZF9mdW5jdGlvbl9pbl9pbmZlcmlvciAo Il9zYnJrIiwgJnNicmtfb2JqZik7CisgICAgICBpZiAoc2Jya19mbiA9PSBO VUxMKQorCXJldHVybiAoYmZkX3ZtYSkgMDsKKyAgICB9CisgIGVsc2UKKyAg ICByZXR1cm4gKGJmZF92bWEpIDA7CisKKyAgZ2RiYXJjaCA9IGdldF9vYmpm aWxlX2FyY2ggKHNicmtfb2JqZik7CisgIHRhcmdldF9zYnJrX2FyZyA9IHZh bHVlX2Zyb21fbG9uZ2VzdCAoYnVpbHRpbl90eXBlIChnZGJhcmNoKS0+YnVp bHRpbl9pbnQsCisJCQkJCXNicmtfYXJnKTsKKyAgZ2RiX2Fzc2VydCAodGFy Z2V0X3NicmtfYXJnKTsKKyAgcmV0ID0gY2FsbF9mdW5jdGlvbl9ieV9oYW5k IChzYnJrX2ZuLCAxLCAmdGFyZ2V0X3NicmtfYXJnKTsKKyAgaWYgKHJldCA9 PSBOVUxMKQorICAgIHJldHVybiAoYmZkX3ZtYSkgMDsKKworICB0bXAgPSB2 YWx1ZV9hc19sb25nIChyZXQpOworICBpZiAoKExPTkdFU1QpIHRtcCA8PSAw IHx8IChMT05HRVNUKSB0bXAgPT0gMHhmZmZmZmZmZikKKyAgICByZXR1cm4g KGJmZF92bWEpIDA7CisKKyAgdG9wX29mX2hlYXAgPSB0bXA7CisgIHJldHVy biB0b3Bfb2ZfaGVhcDsKK30KKwogLyogRGVyaXZlIGEgcmVhc29uYWJsZSBo ZWFwIHNlZ21lbnQgZm9yIEFCRkQgYnkgbG9va2luZyBhdCBzYnJrIGFuZAog ICAgdGhlIHN0YXRpYyBkYXRhIHNlY3Rpb25zLiAgU3RvcmUgaXRzIGxpbWl0 cyBpbiAqQk9UVE9NIGFuZCAqVE9QLgogICAgUmV0dXJuIG5vbi16ZXJvIGlm IHN1Y2Nlc3NmdWwuICAqLwpAQCAtMjE5LDEyICsyODcsMTAgQEAgZGVyaXZl X3N0YWNrX3NlZ21lbnQgKGJmZF92bWEgKmJvdHRvbSwgYgogc3RhdGljIGlu dAogZGVyaXZlX2hlYXBfc2VnbWVudCAoYmZkICphYmZkLCBiZmRfdm1hICpi b3R0b20sIGJmZF92bWEgKnRvcCkKIHsKLSAgc3RydWN0IG9iamZpbGUgKnNi cmtfb2JqZjsKICAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2g7CiAgIGJmZF92 bWEgdG9wX29mX2RhdGFfbWVtb3J5ID0gMDsKICAgYmZkX3ZtYSB0b3Bfb2Zf aGVhcCA9IDA7CiAgIGJmZF9zaXplX3R5cGUgc2VjX3NpemU7Ci0gIHN0cnVj dCB2YWx1ZSAqemVybywgKnNicms7CiAgIGJmZF92bWEgc2VjX3ZhZGRyOwog ICBhc2VjdGlvbiAqc2VjOwogCkBAIC0yNTksMjkgKzMyNSw5IEBAIGRlcml2 ZV9oZWFwX3NlZ21lbnQgKGJmZCAqYWJmZCwgYmZkX3ZtYSAKIAl9CiAgICAg fQogCi0gIC8qIE5vdyBnZXQgdGhlIHRvcC1vZi1oZWFwIGJ5IGNhbGxpbmcg c2JyayBpbiB0aGUgaW5mZXJpb3IuICAqLwotICBpZiAobG9va3VwX21pbmlt YWxfc3ltYm9sICgic2JyayIsIE5VTEwsIE5VTEwpICE9IE5VTEwpCi0gICAg ewotICAgICAgc2JyayA9IGZpbmRfZnVuY3Rpb25faW5faW5mZXJpb3IgKCJz YnJrIiwgJnNicmtfb2JqZik7Ci0gICAgICBpZiAoc2JyayA9PSBOVUxMKQot CXJldHVybiAwOwotICAgIH0KLSAgZWxzZSBpZiAobG9va3VwX21pbmltYWxf c3ltYm9sICgiX3NicmsiLCBOVUxMLCBOVUxMKSAhPSBOVUxMKQotICAgIHsK LSAgICAgIHNicmsgPSBmaW5kX2Z1bmN0aW9uX2luX2luZmVyaW9yICgiX3Ni cmsiLCAmc2Jya19vYmpmKTsKLSAgICAgIGlmIChzYnJrID09IE5VTEwpCi0J cmV0dXJuIDA7Ci0gICAgfQotICBlbHNlCi0gICAgcmV0dXJuIDA7Ci0KLSAg Z2RiYXJjaCA9IGdldF9vYmpmaWxlX2FyY2ggKHNicmtfb2JqZik7Ci0gIHpl cm8gPSB2YWx1ZV9mcm9tX2xvbmdlc3QgKGJ1aWx0aW5fdHlwZSAoZ2RiYXJj aCktPmJ1aWx0aW5faW50LCAwKTsKLSAgZ2RiX2Fzc2VydCAoemVybyk7Ci0g IHNicmsgPSBjYWxsX2Z1bmN0aW9uX2J5X2hhbmQgKHNicmssIDEsICZ6ZXJv KTsKLSAgaWYgKHNicmsgPT0gTlVMTCkKKyAgdG9wX29mX2hlYXAgPSBjYWxs X3RhcmdldF9zYnJrICgwKTsKKyAgaWYgKHRvcF9vZl9oZWFwID09IChiZmRf dm1hKSAwKQogICAgIHJldHVybiAwOwotICB0b3Bfb2ZfaGVhcCA9IHZhbHVl X2FzX2xvbmcgKHNicmspOwogCiAgIC8qIFJldHVybiByZXN1bHRzLiAgKi8K ICAgaWYgKHRvcF9vZl9oZWFwID4gdG9wX29mX2RhdGFfbWVtb3J5KQpAQCAt Mjk5LDEzICszNDUsMTUgQEAgc3RhdGljIHZvaWQKIG1ha2Vfb3V0cHV0X3Bo ZHJzIChiZmQgKm9iZmQsIGFzZWN0aW9uICpvc2VjLCB2b2lkICppZ25vcmVk KQogewogICBpbnQgcF9mbGFncyA9IDA7Ci0gIGludCBwX3R5cGU7CisgIGlu dCBwX3R5cGUgPSAwOwogCiAgIC8qIEZJWE1FOiB0aGVzZSBjb25zdGFudHMg bWF5IG9ubHkgYmUgYXBwbGljYWJsZSBmb3IgRUxGLiAgKi8KICAgaWYgKHN0 cm5jbXAgKGJmZF9zZWN0aW9uX25hbWUgKG9iZmQsIG9zZWMpLCAibG9hZCIs IDQpID09IDApCiAgICAgcF90eXBlID0gUFRfTE9BRDsKLSAgZWxzZQorICBl bHNlIGlmIChzdHJuY21wIChiZmRfc2VjdGlvbl9uYW1lIChvYmZkLCBvc2Vj KSwgIm5vdGUiLCA0KSA9PSAwKQogICAgIHBfdHlwZSA9IFBUX05PVEU7Cisg IGVsc2UKKyAgICBwX3R5cGUgPSBQVF9OVUxMOwogCiAgIHBfZmxhZ3MgfD0g UEZfUjsJLyogU2VnbWVudCBpcyByZWFkYWJsZS4gICovCiAgIGlmICghKGJm ZF9nZXRfc2VjdGlvbl9mbGFncyAob2JmZCwgb3NlYykgJiBTRUNfUkVBRE9O TFkpKQpAQCAtNTE2LDYgKzU2NCwxNDEgQEAgZ2NvcmVfbWVtb3J5X3NlY3Rp b25zIChiZmQgKm9iZmQpCiAgIHJldHVybiAxOwogfQogCitzdHJ1Y3QgbG9h ZF9jb3JlX2FyZ3NfcGFyYW1zIHsKKyAgaW50IGZyb21fdHR5OworICBiZmRf dm1hIHRvcF9vZl9oZWFwOworfTsKKworLyogbG9hZF9jb3JlX3NlZ21lbnRz IC0tIGl0ZXJhdG9yIGZ1bmN0aW9uIGZvciBiZmRfbWFwX292ZXJfc2VjdGlv bnMuICAqLworCitzdGF0aWMgdm9pZAorbG9hZF9jb3JlX3NlZ21lbnQgKGJm ZCAqYWJmZCwgYXNlY3Rpb24gKmFzZWN0LCB2b2lkICphcmcpCit7CisgIHN0 cnVjdCBsb2FkX2NvcmVfYXJnc19wYXJhbXMgKnBhcmFtcyA9IGFyZzsKKyAg c3RydWN0IGNsZWFudXAgKm9sZF9jaGFpbjsKKyAgY2hhciAqbWVtaHVuazsK KyAgaW50IHJldDsKKworICBpZiAoKGJmZF9zZWN0aW9uX3NpemUgKGFiZmQs IGFzZWN0KSA+IDApICYmCisgICAgICAoYmZkX2dldF9zZWN0aW9uX2ZsYWdz IChhYmZkLCBhc2VjdCkgJiBTRUNfTE9BRCkgJiYKKyAgICAgICEoYmZkX2dl dF9zZWN0aW9uX2ZsYWdzIChhYmZkLCBhc2VjdCkgJiBTRUNfUkVBRE9OTFkp KQorICAgIHsKKyAgICAgIGlmIChpbmZvX3ZlcmJvc2UgJiYgcGFyYW1zLT5m cm9tX3R0eSkKKwl7CisJICBwcmludGZfZmlsdGVyZWQgKF8oIkxvYWQgY29y ZSBzZWN0aW9uICVzIiksCisJCQkgICBiZmRfc2VjdGlvbl9uYW1lIChhYmZk LCBhc2VjdCkpOworCSAgcHJpbnRmX2ZpbHRlcmVkIChfKCIsIHZtYSAweCUw OGx4IHRvIDB4JTA4bHgiKSwKKwkJCSAgICh1bnNpZ25lZCBsb25nKSBiZmRf c2VjdGlvbl92bWEgKGFiZmQsIGFzZWN0KSwKKwkJCSAgICh1bnNpZ25lZCBs b25nKSBiZmRfc2VjdGlvbl92bWEgKGFiZmQsIGFzZWN0KSArCisJCQkgICAo aW50KSBiZmRfc2VjdGlvbl9zaXplIChhYmZkLCBhc2VjdCkpOworCSAgcHJp bnRmX2ZpbHRlcmVkIChfKCIsIHNpemUgPSAlZCIpLAorCQkJICAgKGludCkg YmZkX3NlY3Rpb25fc2l6ZSAoYWJmZCwgYXNlY3QpKTsKKwkgIHByaW50Zl9m aWx0ZXJlZCAoXygiLlxuIikpOworCX0KKyAgICAgIC8qIEZpeG1lIGNsZWFu dXA/ICovCisgICAgICBtZW1odW5rID0geG1hbGxvYyAoYmZkX3NlY3Rpb25f c2l6ZSAoYWJmZCwgYXNlY3QpKTsKKyAgICAgIGJmZF9nZXRfc2VjdGlvbl9j b250ZW50cyAoYWJmZCwgYXNlY3QsIG1lbWh1bmssIDAsCisJCQkJYmZkX3Nl Y3Rpb25fc2l6ZSAoYWJmZCwgYXNlY3QpKTsKKyAgICAgIGlmICgocmV0ID0g dGFyZ2V0X3dyaXRlX21lbW9yeSAoYmZkX3NlY3Rpb25fdm1hIChhYmZkLCBh c2VjdCksCisJCQkJICAgICAgbWVtaHVuaywKKwkJCQkgICAgICBiZmRfc2Vj dGlvbl9zaXplIChhYmZkLCBhc2VjdCkpKSAhPSAwKQorCXsKKwkgIHByaW50 X3N5c19lcnJtc2cgKCJsb2FkX2NvcmVfc2VnbWVudCIsIHJldCk7CisJICBp ZiAoKExPTkdFU1QpIHBhcmFtcy0+dG9wX29mX2hlYXAgPAorCSAgICAgIChM T05HRVNUKSBiZmRfc2VjdGlvbl92bWEgKGFiZmQsIGFzZWN0KSArCisJICAg ICAgKExPTkdFU1QpIGJmZF9zZWN0aW9uX3NpemUgKGFiZmQsIGFzZWN0KSkK KwkgICAgeworCSAgICAgIGludCBpbmNyZW1lbnQgPSBiZmRfc2VjdGlvbl92 bWEgKGFiZmQsIGFzZWN0KSArCisJCWJmZF9zZWN0aW9uX3NpemUgKGFiZmQs IGFzZWN0KSAtIHBhcmFtcy0+dG9wX29mX2hlYXA7CisKKwkgICAgICBwYXJh bXMtPnRvcF9vZl9oZWFwID0gY2FsbF90YXJnZXRfc2JyayAoaW5jcmVtZW50 KTsKKwkgICAgICBpZiAocGFyYW1zLT50b3Bfb2ZfaGVhcCA9PSAwKQorCQll cnJvciAoInNicmsgZmFpbGVkLCBUT0ggPSAweCUwOGx4IiwgcGFyYW1zLT50 b3Bfb2ZfaGVhcCk7CisJICAgICAgZWxzZQorCQlwcmludGZfZmlsdGVyZWQg KCJJbmNyZWFzZSBUT0ggdG8gMHglMDhseCBhbmQgcmV0cnkuXG4iLAorCQkJ CSAodW5zaWduZWQgbG9uZykgcGFyYW1zLT50b3Bfb2ZfaGVhcCk7CisJICAg ICAgaWYgKHRhcmdldF93cml0ZV9tZW1vcnkgKGJmZF9zZWN0aW9uX3ZtYSAo YWJmZCwgYXNlY3QpLAorCQkJCSAgICAgICBtZW1odW5rLAorCQkJCSAgICAg ICBiZmRfc2VjdGlvbl9zaXplIChhYmZkLCBhc2VjdCkpICE9IDApCisJCXsK KwkJICBlcnJvciAoIk5vcGUsIHN0aWxsIGZhaWxlZC4iKTsKKwkJfQorCSAg ICB9CisJfQorICAgICAgeGZyZWUgKG1lbWh1bmspOworICAgIH0KK30KKwor LyogbG9hZF9jb3JlZmlsZSAtLSByZWFkcyBhIGNvcmVmaWxlLCBjb3BpZXMg aXRzIG1lbW9yeSBzZWN0aW9ucworICAgaW50byB0YXJnZXQgbWVtb3J5LCBh bmQgaXRzIHJlZ2lzdGVycyBpbnRvIHRhcmdldCByZWdjYWNoZS4gICovCisK K2JmZCAqCitsb2FkX2NvcmVmaWxlIChjaGFyICpmaWxlbmFtZSwgaW50IGZy b21fdHR5KQoreworICBzdHJ1Y3QgbG9hZF9jb3JlX2FyZ3NfcGFyYW1zIHBh cmFtczsKKyAgc3RydWN0IGJmZF9zZWN0aW9uICpyZWdzZWN0OworICBjb25z dCBzdHJ1Y3QgcmVnc2V0ICpyZWdzZXQ7CisgIHN0cnVjdCByZWdjYWNoZSAq cmVnY2FjaGU7CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2hhaW47CisgIHN0 cnVjdCBnZGJhcmNoICpnZGJhcmNoOworICBjaGFyICpzY3JhdGNoX3BhdGg7 CisgIGludCBzY3JhdGNoX2NoYW47CisgIGNoYXIgKmNvbnRlbnRzOworICBi ZmQgKmNvcmVfYmZkOworICBpbnQgc2l6ZTsKKworICBzY3JhdGNoX2NoYW4g PSBvcGVucCAoZ2V0ZW52ICgiUEFUSCIpLCBPUEZfVFJZX0NXRF9GSVJTVCwg ZmlsZW5hbWUsCisJCQlPX0JJTkFSWSB8IE9fUkRPTkxZIHwgT19MQVJHRUZJ TEUsICZzY3JhdGNoX3BhdGgpOworICBpZiAoc2NyYXRjaF9jaGFuIDwgMCkK KyAgICBwZXJyb3Jfd2l0aF9uYW1lIChmaWxlbmFtZSk7CisKKyAgY29yZV9i ZmQgPSBiZmRfZmRvcGVuciAoc2NyYXRjaF9wYXRoLCBnbnV0YXJnZXQsIHNj cmF0Y2hfY2hhbik7CisgIG9sZF9jaGFpbiA9IG1ha2VfY2xlYW51cF9iZmRf Y2xvc2UgKGNvcmVfYmZkKTsKKyAgaWYgKCFjb3JlX2JmZCkKKyAgICBwZXJy b3Jfd2l0aF9uYW1lIChzY3JhdGNoX3BhdGgpOworCisgIGlmICghYmZkX2No ZWNrX2Zvcm1hdCAoY29yZV9iZmQsIGJmZF9jb3JlKSkKKyAgICBlcnJvciAo XygiXCIlc1wiIGlzIG5vdCBhIGNvcmUgZmlsZTogJXMiKSwKKwkgICBmaWxl bmFtZSwgYmZkX2Vycm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworCisgIHBh cmFtcy5mcm9tX3R0eSA9IGZyb21fdHR5OworICBwYXJhbXMudG9wX29mX2hl YXAgPSBjYWxsX3RhcmdldF9zYnJrICgwKTsKKyAgaWYgKHBhcmFtcy50b3Bf b2ZfaGVhcCA9PSAwKQorICAgIGVycm9yIChfKCJDb3VsZG4ndCBnZXQgc2Jy ay4iKSk7CisKKyAgYmZkX21hcF9vdmVyX3NlY3Rpb25zIChjb3JlX2JmZCwg bG9hZF9jb3JlX3NlZ21lbnQsICh2b2lkICopICZwYXJhbXMpOworICAvKiBO b3cgbmVlZCB0byBnZXQvc2V0IHJlZ2lzdGVycy4gICovCisgIHJlZ3NlY3Qg PSBiZmRfZ2V0X3NlY3Rpb25fYnlfbmFtZSAoY29yZV9iZmQsICIucmVnIik7 CisKKyAgaWYgKCFyZWdzZWN0KQorICAgIGVycm9yIChfKCJDb3VsZG4ndCBm aW5kIC5yZWcgc2VjdGlvbi4iKSk7CisKKyAgc2l6ZSA9IGJmZF9zZWN0aW9u X3NpemUgKGNvcmVfYmZkLCByZWdzZWN0KTsKKyAgY29udGVudHMgPSBhbGxv Y2EgKHNpemUpOworICBiZmRfZ2V0X3NlY3Rpb25fY29udGVudHMgKGNvcmVf YmZkLCByZWdzZWN0LCBjb250ZW50cywgMCwgc2l6ZSk7CisKKyAgLyogU2Vl IEZJWE1FIGtldHRlbmlzLzIwMDMxMDIzIGNvbW1lbnQgaW4gY29yZWxvdy5j ICovCisgIGdkYmFyY2ggPSBnZGJhcmNoX2Zyb21fYmZkIChjb3JlX2JmZCk7 CisKKyAgaWYgKGdkYmFyY2ggJiYgZ2RiYXJjaF9yZWdzZXRfZnJvbV9jb3Jl X3NlY3Rpb25fcCAoZ2RiYXJjaCkpCisgICAgeworICAgICAgcmVnc2V0ID0g Z2RiYXJjaF9yZWdzZXRfZnJvbV9jb3JlX3NlY3Rpb24gKGdkYmFyY2gsICIu cmVnIiwgc2l6ZSk7CisgICAgICBpZiAoIXJlZ3NldCkKKwllcnJvciAoXygi RmFpbGVkIHRvIGFsbG9jYXRlIHJlZ3NldC4iKSk7CisKKyAgICAgIHJlZ2lz dGVyc19jaGFuZ2VkICgpOworICAgICAgcmVnY2FjaGUgPSBnZXRfY3VycmVu dF9yZWdjYWNoZSAoKTsKKyAgICAgIHJlZ3NldC0+c3VwcGx5X3JlZ3NldCAo cmVnc2V0LCByZWdjYWNoZSwgLTEsIGNvbnRlbnRzLCBzaXplKTsKKyAgICAg IHJlaW5pdF9mcmFtZV9jYWNoZSAoKTsKKyAgICAgIHRhcmdldF9zdG9yZV9y ZWdpc3RlcnMgKHJlZ2NhY2hlLCAtMSk7CisgICAgfQorICBlbHNlCisgICAg ZXJyb3IgKF8oIkZhaWxlZCB0byBnZXQgcmVnc2V0IGZyb20gY29yZSBzZWN0 aW9uIikpOworCisgIGRpc2NhcmRfY2xlYW51cHMgKG9sZF9jaGFpbik7Cisg IHJldHVybiBjb3JlX2JmZDsKK30KKwogLyogUHJvdmlkZSBhIHByb3RvdHlw ZSB0byBzaWxlbmNlIC1XbWlzc2luZy1wcm90b3R5cGVzLiAgKi8KIGV4dGVy biBpbml0aWFsaXplX2ZpbGVfZnR5cGUgX2luaXRpYWxpemVfZ2NvcmU7CiAK LS0tIC9kZXYvbnVsbAorKysgYi9nY29yZS5oCkBAIC0wLDAgKzEsMjMgQEAK Ky8qIFN1cHBvcnQgZm9yIHJlYWRpbmcvd3JpdGluZyBnY29yZSBmaWxlcy4K KworICAgQ29weXJpZ2h0IChDKSAyMDA5LCBGcmVlIFNvZnR3YXJlIEZvdW5k YXRpb24sIEluYy4KKworICAgVGhpcyBmaWxlIGlzIHBhcnQgb2YgR0RCLgor CisgICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICAgaXQgdW5kZXIgdGhl IHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBw dWJsaXNoZWQgYnkKKyAgIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247 IGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisgICAoYXQg eW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorCisgICBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxs IGJlIHVzZWZ1bCwKKyAgIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0 aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisgICBNRVJDSEFO VEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0Uu ICBTZWUgdGhlCisgICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgorCisgICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg YSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQorICAg YWxvbmcgd2l0aCB0aGlzIHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDov L3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uICAqLworCitleHRlcm4gYmZkICpj cmVhdGVfZ2NvcmVfYmZkIChjaGFyICpmaWxlbmFtZSk7CitleHRlcm4gdm9p ZCB3cml0ZV9nY29yZV9maWxlIChiZmQgKm9iZmQpOworZXh0ZXJuIGJmZCAq bG9hZF9jb3JlZmlsZSAoY2hhciAqZmlsZW5hbWUsIGludCBmcm9tX3R0eSk7 CisKLS0tIGEvcmVjb3JkLmMKKysrIGIvcmVjb3JkLmMKQEAgLTIzLDE1ICsy MywyNSBAQAogI2luY2x1ZGUgImdkYnRocmVhZC5oIgogI2luY2x1ZGUgImV2 ZW50LXRvcC5oIgogI2luY2x1ZGUgImV4Y2VwdGlvbnMuaCIKKyNpbmNsdWRl ICJjb21wbGV0ZXIuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5j bHVkZSAiZ2RiY29yZS5oIgorI2luY2x1ZGUgImV4ZWMuaCIKICNpbmNsdWRl ICJyZWNvcmQuaCIKKyNpbmNsdWRlICJlbGYtYmZkLmgiCisjaW5jbHVkZSAi Z2NvcmUuaCIKIAorI2luY2x1ZGUgPGJ5dGVzd2FwLmg+CiAjaW5jbHVkZSA8 c2lnbmFsLmg+CisjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgogCiAjZGVmaW5l IERFRkFVTFRfUkVDT1JEX0lOU05fTUFYX05VTQkyMDAwMDAKIAogI2RlZmlu ZSBSRUNPUkRfSVNfUkVQTEFZIFwKICAgICAgKHJlY29yZF9saXN0LT5uZXh0 IHx8IGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQogCisj ZGVmaW5lIFJFQ09SRF9GSUxFX01BR0lDCWh0b25sKDB4MjAwOTA4MjkpCisK IC8qIFRoZXNlIGFyZSB0aGUgY29yZSBzdHJ1Y3Qgb2YgcmVjb3JkIGZ1bmN0 aW9uLgogCiAgICBBbiByZWNvcmRfZW50cnkgaXMgYSByZWNvcmQgb2YgdGhl IHZhbHVlIGNoYW5nZSBvZiBhIHJlZ2lzdGVyCkBAIC03OCw5ICs4OCwyMiBA QCBzdHJ1Y3QgcmVjb3JkX2VudHJ5CiAgIH0gdTsKIH07CiAKK3N0cnVjdCBy ZWNvcmRfY29yZV9idWZfZW50cnkKK3sKKyAgc3RydWN0IHJlY29yZF9jb3Jl X2J1Zl9lbnRyeSAqcHJldjsKKyAgc3RydWN0IHRhcmdldF9zZWN0aW9uICpw OworICBiZmRfYnl0ZSAqYnVmOworfTsKKwogLyogVGhpcyBpcyB0aGUgZGVi dWcgc3dpdGNoIGZvciBwcm9jZXNzIHJlY29yZC4gICovCiBpbnQgcmVjb3Jk X2RlYnVnID0gMDsKIAorLyogUmVjb3JkIGJ1ZiB3aXRoIGNvcmUgdGFyZ2V0 LiAgKi8KK3N0YXRpYyBnZGJfYnl0ZSAqcmVjb3JkX2NvcmVfcmVnYnVmID0g TlVMTDsKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X3NlY3Rpb24gKnJlY29yZF9j b3JlX3N0YXJ0Oworc3RhdGljIHN0cnVjdCB0YXJnZXRfc2VjdGlvbiAqcmVj b3JkX2NvcmVfZW5kOworc3RhdGljIHN0cnVjdCByZWNvcmRfY29yZV9idWZf ZW50cnkgKnJlY29yZF9jb3JlX2J1Zl9saXN0ID0gTlVMTDsKKwogLyogVGhl c2UgbGlzdCBpcyBmb3IgZXhlY3V0aW9uIGxvZy4gICovCiBzdGF0aWMgc3Ry dWN0IHJlY29yZF9lbnRyeSByZWNvcmRfZmlyc3Q7CiBzdGF0aWMgc3RydWN0 IHJlY29yZF9lbnRyeSAqcmVjb3JkX2xpc3QgPSAmcmVjb3JkX2ZpcnN0OwpA QCAtOTQsNiArMTE3LDcgQEAgc3RhdGljIGludCByZWNvcmRfaW5zbl9udW0g PSAwOwogCiAvKiBUaGUgdGFyZ2V0X29wcyBvZiBwcm9jZXNzIHJlY29yZC4g ICovCiBzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgcmVjb3JkX29wczsKK3N0 YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyByZWNvcmRfY29yZV9vcHM7CiAKIC8q IFRoZSBiZW5lYXRoIGZ1bmN0aW9uIHBvaW50ZXJzLiAgKi8KIHN0YXRpYyBz dHJ1Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1lX29w czsKQEAgLTE2OSw3ICsxOTMsNyBAQCByZWNvcmRfbGlzdF9yZWxlYXNlX25l eHQgKHZvaWQpCiB9CiAKIHN0YXRpYyB2b2lkCi1yZWNvcmRfbGlzdF9yZWxl YXNlX2ZpcnN0ICh2b2lkKQorcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9p bnNuICh2b2lkKQogewogICBzdHJ1Y3QgcmVjb3JkX2VudHJ5ICp0bXAgPSBO VUxMOwogICBlbnVtIHJlY29yZF90eXBlIHR5cGU7CkBAIC0yMjcsNiArMjUx LDU2IEBAIHJlY29yZF9hcmNoX2xpc3RfYWRkIChzdHJ1Y3QgcmVjb3JkX2Vu dHIKICAgICB9CiB9CiAKKy8qIEFsbG9jIGEgcmVjb3JkX3JlZyByZWNvcmQg ZW50cnkuICovCisKK3N0YXRpYyBpbmxpbmUgc3RydWN0IHJlY29yZF9lbnRy eSAqCityZWNvcmRfcmVnX2FsbG9jIChpbnQgbnVtKQoreworICBzdHJ1Y3Qg cmVjb3JkX2VudHJ5ICpyZWM7CisKKyAgcmVjID0gKHN0cnVjdCByZWNvcmRf ZW50cnkgKikgeG1hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgcmVjb3JkX2VudHJ5 KSk7CisgIHJlYy0+dS5yZWcudmFsID0gKGdkYl9ieXRlICopIHhtYWxsb2Mg KE1BWF9SRUdJU1RFUl9TSVpFKTsKKyAgcmVjLT5wcmV2ID0gTlVMTDsKKyAg cmVjLT5uZXh0ID0gTlVMTDsKKyAgcmVjLT50eXBlID0gcmVjb3JkX3JlZzsK KyAgcmVjLT51LnJlZy5udW0gPSBudW07CisKKyAgcmV0dXJuIHJlYzsKK30K KworLyogQWxsb2MgYSByZWNvcmRfbWVtIHJlY29yZCBlbnRyeS4gKi8KKwor c3RhdGljIGlubGluZSBzdHJ1Y3QgcmVjb3JkX2VudHJ5ICoKK3JlY29yZF9t ZW1fYWxsb2MgKGludCBsZW4pCit7CisgIHN0cnVjdCByZWNvcmRfZW50cnkg KnJlYzsKKworICByZWMgPSAoc3RydWN0IHJlY29yZF9lbnRyeSAqKSB4bWFs bG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRfZW50cnkpKTsKKyAgcmVjLT51 Lm1lbS52YWwgPSAoZ2RiX2J5dGUgKikgeG1hbGxvYyAobGVuKTsKKyAgcmVj LT5wcmV2ID0gTlVMTDsKKyAgcmVjLT5uZXh0ID0gTlVMTDsKKyAgcmVjLT50 eXBlID0gcmVjb3JkX21lbTsKKyAgcmVjLT51Lm1lbS5sZW4gPSBsZW47Cisg IHJlYy0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlID0gMDsKKwor ICByZXR1cm4gcmVjOworfQorCisvKiBBbGxvYyBhIHJlY29yZF9tZW0gcmVj b3JkIGVudHJ5LiAqLworCitzdGF0aWMgaW5saW5lIHN0cnVjdCByZWNvcmRf ZW50cnkgKgorcmVjb3JkX2VuZF9hbGxvYyAodm9pZCkKK3sKKyAgc3RydWN0 IHJlY29yZF9lbnRyeSAqcmVjOworCisgIHJlYyA9IChzdHJ1Y3QgcmVjb3Jk X2VudHJ5ICopIHhtYWxsb2MgKHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRy eSkpOworICByZWMtPnByZXYgPSBOVUxMOworICByZWMtPm5leHQgPSBOVUxM OworICByZWMtPnR5cGUgPSByZWNvcmRfZW5kOworCisgIHJldHVybiByZWM7 Cit9CisKIC8qIFJlY29yZCB0aGUgdmFsdWUgb2YgYSByZWdpc3RlciBOVU0g dG8gcmVjb3JkX2FyY2hfbGlzdC4gICovCiAKIGludApAQCAtMjQwLDEyICsz MTQsNyBAQCByZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHN0cnVjdCByZWdj YWNoCiAJCQkicmVjb3JkIGxpc3QuXG4iLAogCQkJbnVtKTsKIAotICByZWMg PSAoc3RydWN0IHJlY29yZF9lbnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0 cnVjdCByZWNvcmRfZW50cnkpKTsKLSAgcmVjLT51LnJlZy52YWwgPSAoZ2Ri X2J5dGUgKikgeG1hbGxvYyAoTUFYX1JFR0lTVEVSX1NJWkUpOwotICByZWMt PnByZXYgPSBOVUxMOwotICByZWMtPm5leHQgPSBOVUxMOwotICByZWMtPnR5 cGUgPSByZWNvcmRfcmVnOwotICByZWMtPnUucmVnLm51bSA9IG51bTsKKyAg cmVjID0gcmVjb3JkX3JlZ19hbGxvYyAobnVtKTsKIAogICByZWdjYWNoZV9y YXdfcmVhZCAocmVnY2FjaGUsIG51bSwgcmVjLT51LnJlZy52YWwpOwogCkBA IC0yNzEsMTQgKzM0MCw4IEBAIHJlY29yZF9hcmNoX2xpc3RfYWRkX21lbSAo Q09SRV9BRERSIGFkZHIKICAgaWYgKCFhZGRyKQogICAgIHJldHVybiAwOwog Ci0gIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2MgKHNp emVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkpOwotICByZWMtPnUubWVtLnZh bCA9IChnZGJfYnl0ZSAqKSB4bWFsbG9jIChsZW4pOwotICByZWMtPnByZXYg PSBOVUxMOwotICByZWMtPm5leHQgPSBOVUxMOwotICByZWMtPnR5cGUgPSBy ZWNvcmRfbWVtOworICByZWMgPSByZWNvcmRfbWVtX2FsbG9jIChsZW4pOwog ICByZWMtPnUubWVtLmFkZHIgPSBhZGRyOwotICByZWMtPnUubWVtLmxlbiA9 IGxlbjsKLSAgcmVjLT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUg PSAwOwogCiAgIGlmICh0YXJnZXRfcmVhZF9tZW1vcnkgKGFkZHIsIHJlYy0+ dS5tZW0udmFsLCBsZW4pKQogICAgIHsKQEAgLTMwOCwxMCArMzcxLDcgQEAg cmVjb3JkX2FyY2hfbGlzdF9hZGRfZW5kICh2b2lkKQogICAgIGZwcmludGZf dW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKIAkJCSJQcm9jZXNzIHJlY29yZDog YWRkIGVuZCB0byBhcmNoIGxpc3QuXG4iKTsKIAotICByZWMgPSAoc3RydWN0 IHJlY29yZF9lbnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNv cmRfZW50cnkpKTsKLSAgcmVjLT5wcmV2ID0gTlVMTDsKLSAgcmVjLT5uZXh0 ID0gTlVMTDsKLSAgcmVjLT50eXBlID0gcmVjb3JkX2VuZDsKKyAgcmVjID0g cmVjb3JkX2VuZF9hbGxvYyAoKTsKIAogICByZWNvcmRfYXJjaF9saXN0X2Fk ZCAocmVjKTsKIApAQCAtMzQwLDMwICs0MDAsMzAgQEAgcmVjb3JkX2NoZWNr X2luc25fbnVtIChpbnQgc2V0X3Rlcm1pbmFsKQogCSAgICAgIGlmIChxKQog CQlyZWNvcmRfc3RvcF9hdF9saW1pdCA9IDA7CiAJICAgICAgZWxzZQotCQll cnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IGluZmVyaW9yIHByb2dyYW0gc3Rv cHBlZC4iKSk7CisJCWVycm9yIChfKCJQcm9jZXNzIHJlY29yZDogc3RvcGVk IGJ5IHVzZXIuIikpOwogCSAgICB9CiAJfQogICAgIH0KIH0KIAorc3RhdGlj IHZvaWQKK3JlY29yZF9hcmNoX2xpc3RfY2xlYW51cHMgKHZvaWQgKmlnbm9y ZSkKK3sKKyAgcmVjb3JkX2xpc3RfcmVsZWFzZSAocmVjb3JkX2FyY2hfbGlz dF90YWlsKTsKK30KKwogLyogQmVmb3JlIGluZmVyaW9yIHN0ZXAgKHdoZW4g R0RCIHJlY29yZCB0aGUgcnVubmluZyBtZXNzYWdlLCBpbmZlcmlvcgogICAg b25seSBjYW4gc3RlcCksIEdEQiB3aWxsIGNhbGwgdGhpcyBmdW5jdGlvbiB0 byByZWNvcmQgdGhlIHZhbHVlcyB0bwogICAgcmVjb3JkX2xpc3QuICBUaGlz IGZ1bmN0aW9uIHdpbGwgY2FsbCBnZGJhcmNoX3Byb2Nlc3NfcmVjb3JkIHRv CiAgICByZWNvcmQgdGhlIHJ1bm5pbmcgbWVzc2FnZSBvZiBpbmZlcmlvciBh bmQgc2V0IHRoZW0gdG8KICAgIHJlY29yZF9hcmNoX2xpc3QsIGFuZCBhZGQg aXQgdG8gcmVjb3JkX2xpc3QuICAqLwogCi1zdGF0aWMgdm9pZAotcmVjb3Jk X21lc3NhZ2VfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKLXsKLSAgcmVjb3Jk X2xpc3RfcmVsZWFzZSAocmVjb3JkX2FyY2hfbGlzdF90YWlsKTsKLX0KLQog c3RhdGljIGludAogcmVjb3JkX21lc3NhZ2UgKHZvaWQgKmFyZ3MpCiB7CiAg IGludCByZXQ7CiAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUgPSBhcmdz OwotICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzID0gbWFrZV9jbGVh bnVwIChyZWNvcmRfbWVzc2FnZV9jbGVhbnVwcywgMCk7CisgIHN0cnVjdCBj bGVhbnVwICpvbGRfY2xlYW51cHMgPSBtYWtlX2NsZWFudXAgKHJlY29yZF9h cmNoX2xpc3RfY2xlYW51cHMsIDApOwogCiAgIHJlY29yZF9hcmNoX2xpc3Rf aGVhZCA9IE5VTEw7CiAgIHJlY29yZF9hcmNoX2xpc3RfdGFpbCA9IE5VTEw7 CkBAIC0zODYsNyArNDQ2LDcgQEAgcmVjb3JkX21lc3NhZ2UgKHZvaWQgKmFy Z3MpCiAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOwog CiAgIGlmIChyZWNvcmRfaW5zbl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251 bSAmJiByZWNvcmRfaW5zbl9tYXhfbnVtKQotICAgIHJlY29yZF9saXN0X3Jl bGVhc2VfZmlyc3QgKCk7CisgICAgcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJz dF9pbnNuICgpOwogICBlbHNlCiAgICAgcmVjb3JkX2luc25fbnVtKys7CiAK QEAgLTQxNiwxMyArNDc2LDI5NyBAQCByZWNvcmRfZ2RiX29wZXJhdGlvbl9k aXNhYmxlX3NldCAodm9pZCkKICAgcmV0dXJuIG9sZF9jbGVhbnVwczsKIH0K IAorc3RhdGljIGlubGluZSB2b2lkCityZWNvcmRfZXhlY19lbnRyeSAoc3Ry dWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwgc3RydWN0IGdkYmFyY2ggKmdkYmFy Y2gsCisgICAgICAgICAgICAgICAgICAgc3RydWN0IHJlY29yZF9lbnRyeSAq ZW50cnkpCit7CisgIHN3aXRjaCAoZW50cnktPnR5cGUpCisgICAgeworICAg IGNhc2UgcmVjb3JkX3JlZzogLyogcmVnICovCisgICAgICB7CisgICAgICAg IGdkYl9ieXRlIHJlZ1tNQVhfUkVHSVNURVJfU0laRV07CisKKyAgICAgICAg aWYgKHJlY29yZF9kZWJ1ZyA+IDEpCisgICAgICAgICAgZnByaW50Zl91bmZp bHRlcmVkIChnZGJfc3RkbG9nLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfcmVnICVzIHRvICIKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICJpbmZlcmlvciBudW0gPSAl ZC5cbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBob3N0X2Fk ZHJlc3NfdG9fc3RyaW5nIChlbnRyeSksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBlbnRyeS0+dS5yZWcubnVtKTsKKworICAgICAgICByZWdj YWNoZV9jb29rZWRfcmVhZCAocmVnY2FjaGUsIGVudHJ5LT51LnJlZy5udW0s IHJlZyk7CisgICAgICAgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZSAocmVnY2Fj aGUsIGVudHJ5LT51LnJlZy5udW0sIGVudHJ5LT51LnJlZy52YWwpOworICAg ICAgICBtZW1jcHkgKGVudHJ5LT51LnJlZy52YWwsIHJlZywgTUFYX1JFR0lT VEVSX1NJWkUpOworICAgICAgfQorICAgICAgYnJlYWs7CisKKyAgICBjYXNl IHJlY29yZF9tZW06IC8qIG1lbSAqLworICAgICAgeworICAgICAgICBpZiAo IXJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUp CisgICAgICAgICAgeworICAgICAgICAgICAgZ2RiX2J5dGUgKm1lbSA9IGFs bG9jYSAoZW50cnktPnUubWVtLmxlbik7CisKKyAgICAgICAgICAgIGlmIChy ZWNvcmRfZGVidWcgPiAxKQorICAgICAgICAgICAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfbWVtICVzIHRvICIK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiaW5mZXJpb3Ig YWRkciA9ICVzIGxlbiA9ICVkLlxuIiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBob3N0X2FkZHJlc3NfdG9fc3RyaW5nIChlbnRyeSks CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGFkZHJlc3Mg KGdkYmFyY2gsIGVudHJ5LT51Lm1lbS5hZGRyKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsK KworICAgICAgICAgICAgaWYgKHRhcmdldF9yZWFkX21lbW9yeSAoZW50cnkt PnUubWVtLmFkZHIsIG1lbSwgZW50cnktPnUubWVtLmxlbikpCisgICAgICAg ICAgICAgIHsKKyAgICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0u bWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlID0gMTsKKyAgICAgICAgICAgICAg ICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgICAgICAgd2Fybmlu ZyAoXygiUHJvY2VzcyByZWNvcmQ6IGVycm9yIHJlYWRpbmcgbWVtb3J5IGF0 ICIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImFkZHIgPSAlcyBs ZW4gPSAlZC4iKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRy ZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKTsKKyAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICB7Cisg ICAgICAgICAgICAgICAgaWYgKHRhcmdldF93cml0ZV9tZW1vcnkgKGVudHJ5 LT51Lm1lbS5hZGRyLCBlbnRyeS0+dS5tZW0udmFsLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVu KSkKKyAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAg cmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9 IDE7CisgICAgICAgICAgICAgICAgICAgIGlmIChyZWNvcmRfZGVidWcpCisg ICAgICAgICAgICAgICAgICAgICAgd2FybmluZyAoXygiUHJvY2VzcyByZWNv cmQ6IGVycm9yIHdyaXRpbmcgbWVtb3J5IGF0ICIKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJhZGRyID0gJXMgbGVuID0gJWQuIiksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcGFkZHJlc3MgKGdkYmFy Y2gsIGVudHJ5LT51Lm1lbS5hZGRyKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAgICAg ICBtZW1jcHkgKGVudHJ5LT51Lm1lbS52YWwsIG1lbSwgZW50cnktPnUubWVt Lmxlbik7CisgICAgICAgICAgICAgIH0KKyAgICAgICAgICB9CisgICAgICB9 CisgICAgICBicmVhazsKKyAgICB9Cit9CisKKy8qIExvYWQgdGhlIGV4ZWN1 dGlvbiBsb2cgZnJvbSBjb3JlX2JmZC4gICovCisKK3N0YXRpYyBpbnQKK2Jm ZGNvcmVfcmVhZCAoYmZkICpvYmZkLCBhc2VjdGlvbiAqb3NlYywgdm9pZCAq YnVmLCBpbnQgbGVuLCBpbnQgKm9mZnNldCkKK3sKKyAgaW50IHJldCA9IGJm ZF9nZXRfc2VjdGlvbl9jb250ZW50cyAob2JmZCwgb3NlYywgYnVmLCAqb2Zm c2V0LCBsZW4pOworCisgIGlmIChyZXQpCisgICAgKm9mZnNldCArPSBsZW47 CisgIHJldHVybiByZXQ7Cit9CisKIHN0YXRpYyB2b2lkCi1yZWNvcmRfb3Bl biAoY2hhciAqbmFtZSwgaW50IGZyb21fdHR5KQorcmVjb3JkX2xvYWQgKHZv aWQpCiB7Ci0gIHN0cnVjdCB0YXJnZXRfb3BzICp0OworICB1aW50MzJfdCBt YWdpYzsKKyAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwczsKKyAgc3Ry dWN0IHJlY29yZF9lbnRyeSAqcmVjOworICBhc2VjdGlvbiAqb3NlYzsKKyAg aW50IGJmZF9vZmZzZXQgPSAwOworCisgIC8qIFdlIGxvYWQgdGhlIGV4ZWN1 dGlvbiBsb2cgZnJvbSB0aGUgb3BlbiBjb3JlIGJmZCwKKyAgICAgaWYgdGhl cmUgaXMgb25lLiAgKi8KKyAgaWYgKGNvcmVfYmZkID09IE5VTEwpCisgICAg cmV0dXJuOworCisgIC8qICJyZWNvcmRfbG9hZCIganVzdCBjYW4gYmUgY2Fs bGVkIHdoZW4gcmVjb3JkIGxpc3QgaXMgZW1wdHkuICAqLworICBnZGJfYXNz ZXJ0IChyZWNvcmRfZmlyc3QubmV4dCA9PSBOVUxMKTsKIAogICBpZiAocmVj b3JkX2RlYnVnKQotICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxv ZywgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfb3BlblxuIik7CisgICAgZnBy aW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKwkJICAgICAgXygiUmVzdG9y aW5nIHJlY29yZGluZyBmcm9tIGNvcmUgZmlsZS5cbiIpKTsKKworICAvKiBO b3cgbmVlZCB0byBmaW5kIG91ciBzcGVjaWFsIG5vdGUgc2VjdGlvbi4gICov CisgIG9zZWMgPSBiZmRfZ2V0X3NlY3Rpb25fYnlfbmFtZSAoY29yZV9iZmQs ICJudWxsMCIpOworICBwcmludGZfZmlsdGVyZWQgKCJGaW5kIHByZWNvcmQg c2VjdGlvbiAlcy5cbiIsCisJCSAgIG9zZWMgPyAic3VjY2VlZGVkIiA6ICJm YWlsZWQiKTsKKyAgaWYgKCFvc2VjKQorICAgIHJldHVybjsKKyAgaWYgKHJl Y29yZF9kZWJ1ZykKKyAgICBmcHJpbnRmX2ZpbHRlcmVkIChnZGJfc3RkbG9n LCAib3NlYyBuYW1lID0gJyVzJ1xuIiwKKyAgICAgICAgICAgICAgICAgICAg ICBiZmRfc2VjdGlvbl9uYW1lIChjb3JlX2JmZCwgb3NlYykpOworCisgIC8q IENoZWNrIHRoZSBtYWdpYyBjb2RlLiAgKi8KKyAgaWYgKCFiZmRjb3JlX3Jl YWQgKGNvcmVfYmZkLCBvc2VjLCAmbWFnaWMsIHNpemVvZiAobWFnaWMpLCAm YmZkX29mZnNldCkpCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFkICdt YWdpYycgZnJvbSBjb3JlIGZpbGUgKCVzKSIpLAorICAgICAgICAgICBiZmRf ZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7CisgIGlmIChtYWdpYyAhPSBS RUNPUkRfRklMRV9NQUdJQykKKyAgICBlcnJvciAoXygiVmVyc2lvbiBtaXMt bWF0Y2ggb3IgZmlsZSBmb3JtYXQgZXJyb3IuIikpOworICBpZiAocmVjb3Jk X2RlYnVnKQorICAgIGZwcmludGZfZmlsdGVyZWQgKGdkYl9zdGRsb2csIF8o IlwKK1JlYWRpbmcgNC1ieXRlIG1hZ2ljIGNvb2tpZSBSRUNPUkRfRklMRV9N QUdJQyAoMHglMDh4KVxuIiksCisgICAgICAgICAgICAgICAgICAgICAgbWFn aWMpOworCisgIC8qIExvYWQgdGhlIGVudHJpZXMgaW4gcmVjZmQgdG8gdGhl IHJlY29yZF9hcmNoX2xpc3RfaGVhZCBhbmQKKyAgICAgcmVjb3JkX2FyY2hf bGlzdF90YWlsLiAgKi8KKyAgcmVjb3JkX2FyY2hfbGlzdF9oZWFkID0gTlVM TDsKKyAgcmVjb3JkX2FyY2hfbGlzdF90YWlsID0gTlVMTDsKKyAgcmVjb3Jk X2luc25fbnVtID0gMDsKKyAgb2xkX2NsZWFudXBzID0gbWFrZV9jbGVhbnVw IChyZWNvcmRfYXJjaF9saXN0X2NsZWFudXBzLCAwKTsKKworICB3aGlsZSAo MSkKKyAgICB7CisgICAgICBpbnQgcmV0OworICAgICAgdWludDhfdCB0bXB1 ODsKKyAgICAgIHVpbnQ2NF90IHRtcHU2NDsKKworICAgICAgLyogRklYTUU6 IENoZWNrIG9mZnNldCBmb3IgZW5kLW9mLXNlY3Rpb24uICAqLworICAgICAg aWYgKCFiZmRjb3JlX3JlYWQgKGNvcmVfYmZkLCBvc2VjLCAmdG1wdTgsCisg ICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mICh0bXB1OCksICZiZmRf b2Zmc2V0KSkKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIHN3aXRjaCAodG1w dTgpCisgICAgICAgIHsKKyAgICAgICAgY2FzZSByZWNvcmRfcmVnOiAvKiBy ZWcgKi8KKyAgICAgICAgICAvKiBHZXQgbnVtIHRvIHRtcHU2NC4gICovCisg ICAgICAgICAgaWYgKCFiZmRjb3JlX3JlYWQgKGNvcmVfYmZkLCBvc2VjLCAm dG1wdTY0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzaXplb2Yg KHRtcHU2NCksICZiZmRfb2Zmc2V0KSkKKyAgICAgICAgICAgIGVycm9yIChf KCJGYWlsZWQgdG8gcmVhZCByZWdudW0gZnJvbSBjb3JlIGZpbGUgKCVzKSIp LAorICAgICAgICAgICAgICAgICAgIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJy b3IgKCkpKTsKKyAgICAgICAgICBpZiAoQllURV9PUkRFUiA9PSBMSVRUTEVf RU5ESUFOKQorICAgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2 NCk7CisKKyAgICAgICAgICByZWMgPSByZWNvcmRfcmVnX2FsbG9jICgoaW50 KSB0bXB1NjQpOworCisgICAgICAgICAgLyogR2V0IHZhbC4gICovCisgICAg ICAgICAgaWYgKCFiZmRjb3JlX3JlYWQgKGNvcmVfYmZkLCBvc2VjLCByZWMt PnUucmVnLnZhbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTUFY X1JFR0lTVEVSX1NJWkUsICZiZmRfb2Zmc2V0KSkKKyAgICAgICAgICAgIGVy cm9yIChfKCJGYWlsZWQgdG8gcmVhZCByZWd2YWwgZnJvbSAgY29yZSBmaWxl ICglcykiKSwKKyAgICAgICAgICAgICAgICAgICBiZmRfZXJybXNnIChiZmRf Z2V0X2Vycm9yICgpKSk7CisKKyAgICAgICAgICBpZiAocmVjb3JkX2RlYnVn KQorICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9n LCBfKCJcCitSZWFkaW5nIHJlZ2lzdGVyICVkICgxIHBsdXMgOCBwbHVzICVk IGJ5dGVzKVxuIiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlYy0+dS5yZWcubnVtLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBNQVhfUkVHSVNURVJfU0laRSk7CisgICAgICAgICAgYnJlYWs7CisK KyAgICAgICAgY2FzZSByZWNvcmRfbWVtOiAvKiBtZW0gKi8KKyAgICAgICAg ICAvKiBHZXQgbGVuLiAgKi8KKyAgICAgICAgICBpZiAoIWJmZGNvcmVfcmVh ZCAoY29yZV9iZmQsIG9zZWMsICZ0bXB1NjQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHNpemVvZiAodG1wdTY0KSwgJmJmZF9vZmZzZXQpKQor ICAgICAgICAgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFkIG1lbWxlbiBm cm9tIGNvcmUgZmlsZSAoJXMpIiksCisgICAgICAgICAgICAgICAgICAgYmZk X2Vycm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworICAgICAgICAgIGlmIChC WVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAgICB0bXB1 NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKworICAgICAgICAgIHJlYyA9IHJl Y29yZF9tZW1fYWxsb2MgKChpbnQpIHRtcHU2NCk7CisKKyAgICAgICAgICAv KiBHZXQgYWRkci4gICovCisgICAgICAgICAgaWYgKCFiZmRjb3JlX3JlYWQg KGNvcmVfYmZkLCBvc2VjLCAmdG1wdTY0LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBzaXplb2YgKHRtcHU2NCksICZiZmRfb2Zmc2V0KSkKKyAg ICAgICAgICAgIGVycm9yIChfKCJGYWlsZWQgdG8gcmVhZCBtZW1hZGRyIGZy b20gY29yZSBmaWxlICglcykiKSwKKyAgICAgICAgICAgICAgICAgICBiZmRf ZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7CisgICAgICAgICAgaWYgKEJZ VEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgIHRtcHU2 NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJlYy0+dS5tZW0u YWRkciA9IHRtcHU2NDsKKworICAgICAgICAgIC8qIEdldCB2YWwuICAqLwor ICAgICAgICAgIGlmICghYmZkY29yZV9yZWFkIChjb3JlX2JmZCwgb3NlYywg cmVjLT51Lm1lbS52YWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHJlYy0+dS5tZW0ubGVuLCAmYmZkX29mZnNldCkpCisgICAgICAgICAgICBl cnJvciAoXygiRmFpbGVkIHRvIHJlYWQgbWVtdmFsIGZyb20gY29yZSBmaWxl ICglcykiKSwKKyAgICAgICAgICAgICAgICAgICBiZmRfZXJybXNnIChiZmRf Z2V0X2Vycm9yICgpKSk7CisKKyAgICAgICAgICBpZiAocmVjb3JkX2RlYnVn KQorICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9n LCBfKCJcCitSZWFkaW5nIG1lbW9yeSAlcyAoMSBwbHVzIDggcGx1cyA4IGJ5 dGVzIHBsdXMgJWQgYnl0ZXMpXG4iKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBwYWRkcmVzcyAoZ2V0X2N1cnJlbnRfYXJj aCAoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmVjLT51Lm1lbS5hZGRyKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZWMtPnUubWVtLmxlbik7Cisg ICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSByZWNvcmRfZW5kOiAv KiBlbmQgKi8KKyAgICAgICAgICByZWMgPSByZWNvcmRfZW5kX2FsbG9jICgp OworICAgICAgICAgIHJlY29yZF9pbnNuX251bSArKzsKKworICAgICAgICAg IGlmIChyZWNvcmRfZGVidWcpCisgICAgICAgICAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIF8oIlJlYWRpbmcgcmVjb3JkX2VuZCAoMSBieXRlKVxuIikpOwor ICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGRlZmF1bHQ6CisgICAgICAg ICAgZXJyb3IgKF8oIkZvcm1hdCBvZiBjb3JlIGZpbGUgaXMgbm90IHJpZ2h0 LiIpKTsKKyAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorCisgICAgICAv KiBBZGQgcmVjIHRvIHJlY29yZCBhcmNoIGxpc3QuICAqLworICAgICAgcmVj b3JkX2FyY2hfbGlzdF9hZGQgKHJlYyk7CisgICAgfQorCisgIGRpc2NhcmRf Y2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgLyogQWRkIHJlY29yZF9h cmNoX2xpc3RfaGVhZCB0byB0aGUgZW5kIG9mIHJlY29yZCBsaXN0LiAgKi8K KyAgcmVjb3JkX2ZpcnN0Lm5leHQgPSByZWNvcmRfYXJjaF9saXN0X2hlYWQ7 CisgIHJlY29yZF9hcmNoX2xpc3RfaGVhZC0+cHJldiA9ICZyZWNvcmRfZmly c3Q7CisKKyAgLyogVXBkYXRlIHJlY29yZF9pbnNuX21heF9udW0uICAqLwor ICBpZiAocmVjb3JkX2luc25fbnVtID4gcmVjb3JkX2luc25fbWF4X251bSkK KyAgICB7CisgICAgICByZWNvcmRfaW5zbl9tYXhfbnVtID0gcmVjb3JkX2lu c25fbnVtOworICAgICAgd2FybmluZyAoXygiQXV0byBpbmNyZWFzZSByZWNv cmQvcmVwbGF5IGJ1ZmZlciBsaW1pdCB0byAlZC4iKSwKKyAgICAgICAgICAg ICAgIHJlY29yZF9pbnNuX21heF9udW0pOworICAgIH0KKworICAvKiBTdWNj ZWVkZWQuICAqLworICBmcHJpbnRmX2ZpbHRlcmVkIChnZGJfc3Rkb3V0LCAi TG9hZGVkIHJlY29yZHMgZnJvbSBjb3JlIGZpbGUuXG4iKTsKKworICBwcmlu dF9zdGFja19mcmFtZSAoZ2V0X3NlbGVjdGVkX2ZyYW1lIChOVUxMKSwgMSwg U1JDX0FORF9MT0MpOworfQorCitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMg KnRtcF90b19yZXN1bWVfb3BzOworc3RhdGljIHZvaWQgKCp0bXBfdG9fcmVz dW1lKSAoc3RydWN0IHRhcmdldF9vcHMgKiwgcHRpZF90LCBpbnQsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBlbnVtIHRhcmdldF9zaWduYWwp Oworc3RhdGljIHN0cnVjdCB0YXJnZXRfb3BzICp0bXBfdG9fd2FpdF9vcHM7 CitzdGF0aWMgcHRpZF90ICgqdG1wX3RvX3dhaXQpIChzdHJ1Y3QgdGFyZ2V0 X29wcyAqLCBwdGlkX3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBzdHJ1Y3QgdGFyZ2V0X3dhaXRzdGF0dXMgKiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGludCk7CitzdGF0aWMgc3RydWN0IHRhcmdldF9v cHMgKnRtcF90b19zdG9yZV9yZWdpc3RlcnNfb3BzOworc3RhdGljIHZvaWQg KCp0bXBfdG9fc3RvcmVfcmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMg KiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0 cnVjdCByZWdjYWNoZSAqLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgaW50IHJlZ25vKTsKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0 X29wcyAqdG1wX3RvX3hmZXJfcGFydGlhbF9vcHM7CitzdGF0aWMgTE9OR0VT VCAoKnRtcF90b194ZmVyX3BhcnRpYWwpIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ZW51bSB0YXJnZXRfb2JqZWN0IG9iamVjdCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmFubmV4LAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZ2RiX2J5dGUg KnJlYWRidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBjb25zdCBnZGJfYnl0ZSAqd3JpdGVidWYsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBVTE9OR0VTVCBvZmZzZXQsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMT05HRVNU IGxlbik7CitzdGF0aWMgaW50ICgqdG1wX3RvX2luc2VydF9icmVha3BvaW50 KSAoc3RydWN0IGdkYmFyY2ggKiwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKik7Citz dGF0aWMgaW50ICgqdG1wX3RvX3JlbW92ZV9icmVha3BvaW50KSAoc3RydWN0 IGdkYmFyY2ggKiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKik7CisKK3N0YXRpYyB2 b2lkCityZWNvcmRfY29yZV9vcGVuXzEgKGNoYXIgKm5hbWUsIGludCBmcm9t X3R0eSkKK3sKKyAgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF9j dXJyZW50X3JlZ2NhY2hlICgpOworICBpbnQgcmVnbnVtID0gZ2RiYXJjaF9u dW1fcmVncyAoZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSk7CisgIGlu dCBpOworCisgIC8qIEdldCByZWNvcmRfY29yZV9yZWdidWYuICAqLworICB0 YXJnZXRfZmV0Y2hfcmVnaXN0ZXJzIChyZWdjYWNoZSwgLTEpOworICByZWNv cmRfY29yZV9yZWdidWYgPSB4bWFsbG9jIChNQVhfUkVHSVNURVJfU0laRSAq IHJlZ251bSk7CisgIGZvciAoaSA9IDA7IGkgPCByZWdudW07IGkgKyspCisg ICAgcmVnY2FjaGVfcmF3X2NvbGxlY3QgKHJlZ2NhY2hlLCBpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhf UkVHSVNURVJfU0laRSAqIGkpOworCisgIC8qIEdldCByZWNvcmRfY29yZV9z dGFydCBhbmQgcmVjb3JkX2NvcmVfZW5kLiAgKi8KKyAgaWYgKGJ1aWxkX3Nl Y3Rpb25fdGFibGUgKGNvcmVfYmZkLCAmcmVjb3JkX2NvcmVfc3RhcnQsICZy ZWNvcmRfY29yZV9lbmQpKQorICAgIHsKKyAgICAgIHhmcmVlIChyZWNvcmRf Y29yZV9yZWdidWYpOworICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmID0gTlVM TDsKKyAgICAgIGVycm9yIChfKCJcIiVzXCI6IENhbid0IGZpbmQgc2VjdGlv bnM6ICVzIiksCisgICAgICAgICAgICAgYmZkX2dldF9maWxlbmFtZSAoY29y ZV9iZmQpLCBiZmRfZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7CisgICAg fQorCisgIHB1c2hfdGFyZ2V0ICgmcmVjb3JkX2NvcmVfb3BzKTsKK30KKwor c3RhdGljIHZvaWQKK3JlY29yZF9vcGVuXzEgKGNoYXIgKm5hbWUsIGludCBm cm9tX3R0eSkKK3sKKyAgc3RydWN0IHRhcmdldF9vcHMgKnQ7CiAKICAgLyog Y2hlY2sgZXhlYyAqLwogICBpZiAoIXRhcmdldF9oYXNfZXhlY3V0aW9uKQpA QCAtNDM4LDYgKzc4MiwyOCBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFtZSwg aW50IGZyb21fdHR5KQogICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZDog dGhlIGN1cnJlbnQgYXJjaGl0ZWN0dXJlIGRvZXNuJ3Qgc3VwcG9ydCAiCiAJ ICAgICAicmVjb3JkIGZ1bmN0aW9uLiIpKTsKIAorICBpZiAoIXRtcF90b19y ZXN1bWUpCisgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdl dCB0b19yZXN1bWUuIikpOworICBpZiAoIXRtcF90b193YWl0KQorICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fd2FpdC4iKSk7 CisgIGlmICghdG1wX3RvX3N0b3JlX3JlZ2lzdGVycykKKyAgICBlcnJvciAo XygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3N0b3JlX3JlZ2lzdGVy cy4iKSk7CisgIGlmICghdG1wX3RvX2luc2VydF9icmVha3BvaW50KQorICAg IGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9faW5zZXJ0 X2JyZWFrcG9pbnQuIikpOworICBpZiAoIXRtcF90b19yZW1vdmVfYnJlYWtw b2ludCkKKyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0 IHRvX3JlbW92ZV9icmVha3BvaW50LiIpKTsKKworICBwdXNoX3RhcmdldCAo JnJlY29yZF9vcHMpOworfQorCitzdGF0aWMgdm9pZAorcmVjb3JkX29wZW4g KGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKK3sKKyAgc3RydWN0IHRhcmdl dF9vcHMgKnQ7CisKKyAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICBmcHJpbnRm X3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVj b3JkX29wZW5cbiIpOworCiAgIC8qIENoZWNrIGlmIHJlY29yZCB0YXJnZXQg aXMgYWxyZWFkeSBydW5uaW5nLiAgKi8KICAgaWYgKGN1cnJlbnRfdGFyZ2V0 LnRvX3N0cmF0dW0gPT0gcmVjb3JkX3N0cmF0dW0pCiAgICAgewpAQCAtNDQ3 LDcwICs4MTMsMTAyIEBAIHJlY29yZF9vcGVuIChjaGFyICpuYW1lLCBpbnQg ZnJvbV90dHkpCiAJcmV0dXJuOwogICAgIH0KIAotICAvKlJlc2V0IHRoZSBi ZW5lYXRoIGZ1bmN0aW9uIHBvaW50ZXJzLiAgKi8KLSAgcmVjb3JkX2JlbmVh dGhfdG9fcmVzdW1lID0gTlVMTDsKLSAgcmVjb3JkX2JlbmVhdGhfdG9fd2Fp dCA9IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVy cyA9IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCA9 IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9icmVha3BvaW50 ID0gTlVMTDsKLSAgcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9p bnQgPSBOVUxMOworICAvKiBSZXNldCB0aGUgdG1wIGJlbmVhdGggcG9pbnRl cnMuICAqLworICB0bXBfdG9fcmVzdW1lX29wcyA9IE5VTEw7CisgIHRtcF90 b19yZXN1bWUgPSBOVUxMOworICB0bXBfdG9fd2FpdF9vcHMgPSBOVUxMOwor ICB0bXBfdG9fd2FpdCA9IE5VTEw7CisgIHRtcF90b19zdG9yZV9yZWdpc3Rl cnNfb3BzID0gTlVMTDsKKyAgdG1wX3RvX3N0b3JlX3JlZ2lzdGVycyA9IE5V TEw7CisgIHRtcF90b194ZmVyX3BhcnRpYWxfb3BzID0gTlVMTDsKKyAgdG1w X3RvX3hmZXJfcGFydGlhbCA9IE5VTEw7CisgIHRtcF90b19pbnNlcnRfYnJl YWtwb2ludCA9IE5VTEw7CisgIHRtcF90b19yZW1vdmVfYnJlYWtwb2ludCA9 IE5VTEw7CiAKICAgLyogU2V0IHRoZSBiZW5lYXRoIGZ1bmN0aW9uIHBvaW50 ZXJzLiAgKi8KICAgZm9yICh0ID0gY3VycmVudF90YXJnZXQuYmVuZWF0aDsg dCAhPSBOVUxMOyB0ID0gdC0+YmVuZWF0aCkKICAgICB7Ci0gICAgICBpZiAo IXJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSkKKyAgICAgIGlmICghdG1wX3Rv X3Jlc3VtZSkKICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVhdGhfdG9fcmVz dW1lID0gdC0+dG9fcmVzdW1lOwotCSAgcmVjb3JkX2JlbmVhdGhfdG9fcmVz dW1lX29wcyA9IHQ7CisJICB0bXBfdG9fcmVzdW1lID0gdC0+dG9fcmVzdW1l OworCSAgdG1wX3RvX3Jlc3VtZV9vcHMgPSB0OwogICAgICAgICB9Ci0gICAg ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3dhaXQpCisgICAgICBpZiAoIXRt cF90b193YWl0KQogICAgICAgICB7Ci0JICByZWNvcmRfYmVuZWF0aF90b193 YWl0ID0gdC0+dG9fd2FpdDsKLQkgIHJlY29yZF9iZW5lYXRoX3RvX3dhaXRf b3BzID0gdDsKKwkgIHRtcF90b193YWl0ID0gdC0+dG9fd2FpdDsKKwkgIHRt cF90b193YWl0X29wcyA9IHQ7CiAgICAgICAgIH0KLSAgICAgIGlmICghcmVj b3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzKQorICAgICAgaWYgKCF0 bXBfdG9fc3RvcmVfcmVnaXN0ZXJzKQogICAgICAgICB7Ci0JICByZWNvcmRf YmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMgPSB0LT50b19zdG9yZV9yZWdp c3RlcnM7Ci0JICByZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnNf b3BzID0gdDsKKwkgIHRtcF90b19zdG9yZV9yZWdpc3RlcnMgPSB0LT50b19z dG9yZV9yZWdpc3RlcnM7CisJICB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJzX29w cyA9IHQ7CiAgICAgICAgIH0KLSAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhf dG9feGZlcl9wYXJ0aWFsKQorICAgICAgaWYgKCF0bXBfdG9feGZlcl9wYXJ0 aWFsKQogICAgICAgICB7Ci0JICByZWNvcmRfYmVuZWF0aF90b194ZmVyX3Bh cnRpYWwgPSB0LT50b194ZmVyX3BhcnRpYWw7Ci0JICByZWNvcmRfYmVuZWF0 aF90b194ZmVyX3BhcnRpYWxfb3BzID0gdDsKKwkgIHRtcF90b194ZmVyX3Bh cnRpYWwgPSB0LT50b194ZmVyX3BhcnRpYWw7CisJICB0bXBfdG9feGZlcl9w YXJ0aWFsX29wcyA9IHQ7CiAgICAgICAgIH0KLSAgICAgIGlmICghcmVjb3Jk X2JlbmVhdGhfdG9faW5zZXJ0X2JyZWFrcG9pbnQpCi0JcmVjb3JkX2JlbmVh dGhfdG9faW5zZXJ0X2JyZWFrcG9pbnQgPSB0LT50b19pbnNlcnRfYnJlYWtw b2ludDsKLSAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2Jy ZWFrcG9pbnQpCi0JcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9p bnQgPSB0LT50b19yZW1vdmVfYnJlYWtwb2ludDsKKyAgICAgIGlmICghdG1w X3RvX2luc2VydF9icmVha3BvaW50KQorCXRtcF90b19pbnNlcnRfYnJlYWtw b2ludCA9IHQtPnRvX2luc2VydF9icmVha3BvaW50OworICAgICAgaWYgKCF0 bXBfdG9fcmVtb3ZlX2JyZWFrcG9pbnQpCisJdG1wX3RvX3JlbW92ZV9icmVh a3BvaW50ID0gdC0+dG9fcmVtb3ZlX2JyZWFrcG9pbnQ7CiAgICAgfQotICBp ZiAoIXJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSkKLSAgICBlcnJvciAoXygi UHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3Jlc3VtZS4iKSk7Ci0gIGlm ICghcmVjb3JkX2JlbmVhdGhfdG9fd2FpdCkKLSAgICBlcnJvciAoXygiUHJv Y2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3dhaXQuIikpOwotICBpZiAoIXJl Y29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycykKLSAgICBlcnJvciAo XygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3N0b3JlX3JlZ2lzdGVy cy4iKSk7Ci0gIGlmICghcmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFs KQorICBpZiAoIXRtcF90b194ZmVyX3BhcnRpYWwpCiAgICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b194ZmVyX3BhcnRpYWwuIikp OwotICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9icmVha3BvaW50 KQotICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9f aW5zZXJ0X2JyZWFrcG9pbnQuIikpOwotICBpZiAoIXJlY29yZF9iZW5lYXRo X3RvX3JlbW92ZV9icmVha3BvaW50KQotICAgIGVycm9yIChfKCJQcm9jZXNz IHJlY29yZCBjYW4ndCBnZXQgdG9fcmVtb3ZlX2JyZWFrcG9pbnQuIikpOwog Ci0gIHB1c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7CisgIGlmIChjdXJyZW50 X3RhcmdldC50b19zdHJhdHVtID09IGNvcmVfc3RyYXR1bSkKKyAgICByZWNv cmRfY29yZV9vcGVuXzEgKG5hbWUsIGZyb21fdHR5KTsKKyAgZWxzZQorICAg IHJlY29yZF9vcGVuXzEgKG5hbWUsIGZyb21fdHR5KTsKIAogICAvKiBSZXNl dCAqLwogICByZWNvcmRfaW5zbl9udW0gPSAwOwogICByZWNvcmRfbGlzdCA9 ICZyZWNvcmRfZmlyc3Q7CiAgIHJlY29yZF9saXN0LT5uZXh0ID0gTlVMTDsK KworICAvKiBTZXQgdGhlIHRtcCBiZW5lYXRoIHBvaW50ZXJzIHRvIGJlbmVh dGggcG9pbnRlcnMuICAqLworICByZWNvcmRfYmVuZWF0aF90b19yZXN1bWVf b3BzID0gdG1wX3RvX3Jlc3VtZV9vcHM7CisgIHJlY29yZF9iZW5lYXRoX3Rv X3Jlc3VtZSA9IHRtcF90b19yZXN1bWU7CisgIHJlY29yZF9iZW5lYXRoX3Rv X3dhaXRfb3BzID0gdG1wX3RvX3dhaXRfb3BzOworICByZWNvcmRfYmVuZWF0 aF90b193YWl0ID0gdG1wX3RvX3dhaXQ7CisgIHJlY29yZF9iZW5lYXRoX3Rv X3N0b3JlX3JlZ2lzdGVyc19vcHMgPSB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJz X29wczsKKyAgcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzID0g dG1wX3RvX3N0b3JlX3JlZ2lzdGVyczsKKyAgcmVjb3JkX2JlbmVhdGhfdG9f eGZlcl9wYXJ0aWFsX29wcyA9IHRtcF90b194ZmVyX3BhcnRpYWxfb3BzOwor ICByZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwgPSB0bXBfdG9feGZl cl9wYXJ0aWFsOworICByZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJlYWtw b2ludCA9IHRtcF90b19pbnNlcnRfYnJlYWtwb2ludDsKKyAgcmVjb3JkX2Jl bmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9pbnQgPSB0bXBfdG9fcmVtb3ZlX2Jy ZWFrcG9pbnQ7CisKKyAgaWYgKHN0cmNtcCAoY3VycmVudF90YXJnZXQudG9f c2hvcnRuYW1lLCAicmVjb3JkX2NvcmUiKSA9PSAwKQorICAgIHJlY29yZF9s b2FkICgpOwogfQogCiBzdGF0aWMgdm9pZAogcmVjb3JkX2Nsb3NlIChpbnQg cXVpdHRpbmcpCiB7CisgIHN0cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkg KmVudHJ5OworCiAgIGlmIChyZWNvcmRfZGVidWcpCiAgICAgZnByaW50Zl91 bmZpbHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29y ZF9jbG9zZVxuIik7CiAKICAgcmVjb3JkX2xpc3RfcmVsZWFzZSAocmVjb3Jk X2xpc3QpOworCisgIC8qIFJlbGVhc2UgcmVjb3JkX2NvcmVfcmVnYnVmLiAg Ki8KKyAgaWYgKHJlY29yZF9jb3JlX3JlZ2J1ZikKKyAgICB7CisgICAgICB4 ZnJlZSAocmVjb3JkX2NvcmVfcmVnYnVmKTsKKyAgICAgIHJlY29yZF9jb3Jl X3JlZ2J1ZiA9IE5VTEw7CisgICAgfQorCisgIC8qIFJlbGVhc2UgcmVjb3Jk X2NvcmVfYnVmX2xpc3QuICAqLworICBpZiAocmVjb3JkX2NvcmVfYnVmX2xp c3QpCisgICAgeworICAgICAgZm9yIChlbnRyeSA9IHJlY29yZF9jb3JlX2J1 Zl9saXN0LT5wcmV2OyBlbnRyeTsgZW50cnkgPSBlbnRyeS0+cHJldikKKyAg ICAgICAgeworICAgICAgICAgIHhmcmVlIChyZWNvcmRfY29yZV9idWZfbGlz dCk7CisgICAgICAgICAgcmVjb3JkX2NvcmVfYnVmX2xpc3QgPSBlbnRyeTsK KyAgICAgICAgfQorICAgICAgcmVjb3JkX2NvcmVfYnVmX2xpc3QgPSBOVUxM OworICAgIH0KIH0KIAogc3RhdGljIGludCByZWNvcmRfcmVzdW1lX3N0ZXAg PSAwOwpAQCAtNTg0LDcgKzk4Miw3IEBAIHJlY29yZF93YWl0IChzdHJ1Y3Qg dGFyZ2V0X29wcyAqb3BzLAogCQkJInJlY29yZF9yZXN1bWVfc3RlcCA9ICVk XG4iLAogCQkJcmVjb3JkX3Jlc3VtZV9zdGVwKTsKIAotICBpZiAoIVJFQ09S RF9JU19SRVBMQVkpCisgIGlmICghUkVDT1JEX0lTX1JFUExBWSAmJiBvcHMg IT0gJnJlY29yZF9jb3JlX29wcykKICAgICB7CiAgICAgICBpZiAocmVjb3Jk X3Jlc3VtZV9lcnJvcikKIAl7CkBAIC03MTIsNzYgKzExMTAsOSBAQCByZWNv cmRfd2FpdCAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywKIAkgICAgICBicmVh azsKIAkgICAgfQogCi0JICAvKiBTZXQgcHRpZCwgcmVnaXN0ZXIgYW5kIG1l bW9yeSBhY2NvcmRpbmcgdG8gcmVjb3JkX2xpc3QuICAqLwotCSAgaWYgKHJl Y29yZF9saXN0LT50eXBlID09IHJlY29yZF9yZWcpCi0JICAgIHsKLQkgICAg ICAvKiByZWcgKi8KLQkgICAgICBnZGJfYnl0ZSByZWdbTUFYX1JFR0lTVEVS X1NJWkVdOwotCSAgICAgIGlmIChyZWNvcmRfZGVidWcgPiAxKQotCQlmcHJp bnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCi0JCQkJICAgICJQcm9jZXNz IHJlY29yZDogcmVjb3JkX3JlZyAlcyB0byAiCi0JCQkJICAgICJpbmZlcmlv ciBudW0gPSAlZC5cbiIsCi0JCQkJICAgIGhvc3RfYWRkcmVzc190b19zdHJp bmcgKHJlY29yZF9saXN0KSwKLQkJCQkgICAgcmVjb3JkX2xpc3QtPnUucmVn Lm51bSk7Ci0JICAgICAgcmVnY2FjaGVfY29va2VkX3JlYWQgKHJlZ2NhY2hl LCByZWNvcmRfbGlzdC0+dS5yZWcubnVtLCByZWcpOwotCSAgICAgIHJlZ2Nh Y2hlX2Nvb2tlZF93cml0ZSAocmVnY2FjaGUsIHJlY29yZF9saXN0LT51LnJl Zy5udW0sCi0JCQkJICAgICByZWNvcmRfbGlzdC0+dS5yZWcudmFsKTsKLQkg ICAgICBtZW1jcHkgKHJlY29yZF9saXN0LT51LnJlZy52YWwsIHJlZywgTUFY X1JFR0lTVEVSX1NJWkUpOwotCSAgICB9Ci0JICBlbHNlIGlmIChyZWNvcmRf bGlzdC0+dHlwZSA9PSByZWNvcmRfbWVtKQotCSAgICB7Ci0JICAgICAgLyog bWVtICovCi0JICAgICAgLyogTm90aGluZyB0byBkbyBpZiB0aGUgZW50cnkg aXMgZmxhZ2dlZCBub3RfYWNjZXNzaWJsZS4gICovCi0JICAgICAgaWYgKCFy ZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlKQot CQl7Ci0JCSAgZ2RiX2J5dGUgKm1lbSA9IGFsbG9jYSAocmVjb3JkX2xpc3Qt PnUubWVtLmxlbik7Ci0JCSAgaWYgKHJlY29yZF9kZWJ1ZyA+IDEpCi0JCSAg ICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCi0JCQkJICAgICAg ICAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9tZW0gJXMgdG8gIgotCQkJCSAg ICAgICAgImluZmVyaW9yIGFkZHIgPSAlcyBsZW4gPSAlZC5cbiIsCi0JCQkJ ICAgICAgICBob3N0X2FkZHJlc3NfdG9fc3RyaW5nIChyZWNvcmRfbGlzdCks Ci0JCQkJICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwKLQkJCQkJICAgICAg ICAgIHJlY29yZF9saXN0LT51Lm1lbS5hZGRyKSwKLQkJCQkgICAgICAgIHJl Y29yZF9saXN0LT51Lm1lbS5sZW4pOworICAgICAgICAgIHJlY29yZF9leGVj X2VudHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOwogCi0J CSAgaWYgKHRhcmdldF9yZWFkX21lbW9yeSAocmVjb3JkX2xpc3QtPnUubWVt LmFkZHIsIG1lbSwKLQkJICAgICAgICAgICAgICAgICAgICAgICAgICByZWNv cmRfbGlzdC0+dS5tZW0ubGVuKSkKLQkgICAgICAgICAgICB7Ci0JCSAgICAg IGlmIChleGVjdXRpb25fZGlyZWN0aW9uICE9IEVYRUNfUkVWRVJTRSkKLQkJ ICAgICAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IGVycm9yIHJlYWRp bmcgbWVtb3J5IGF0ICIKLQkJCSAgICAgICAgICJhZGRyID0gJXMgbGVuID0g JWQuIiksCi0JCSAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBy ZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCi0JCSAgICAgICAgICAgICAgIHJl Y29yZF9saXN0LT51Lm1lbS5sZW4pOwotCQkgICAgICBlbHNlCi0JCQkvKiBS ZWFkIGZhaWxlZCAtLSAKLQkJCSAgIGZsYWcgZW50cnkgYXMgbm90X2FjY2Vz c2libGUuICAqLwotCQkgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5tZW1f ZW50cnlfbm90X2FjY2Vzc2libGUgPSAxOwotCQkgICAgfQotCQkgIGVsc2UK LQkJICAgIHsKLQkJICAgICAgaWYgKHRhcmdldF93cml0ZV9tZW1vcnkgKHJl Y29yZF9saXN0LT51Lm1lbS5hZGRyLAotCQkJICAgICAgICAgICAgICAgICAg ICAgICByZWNvcmRfbGlzdC0+dS5tZW0udmFsLAotCQkgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbikpCi0J ICAgICAgICAgICAgICAgIHsKLQkJCSAgaWYgKGV4ZWN1dGlvbl9kaXJlY3Rp b24gIT0gRVhFQ19SRVZFUlNFKQotCQkJICAgIGVycm9yIChfKCJQcm9jZXNz IHJlY29yZDogZXJyb3Igd3JpdGluZyBtZW1vcnkgYXQgIgotCQkJICAgICAg ICAgICAgICJhZGRyID0gJXMgbGVuID0gJWQuIiksCi0JCSAgICAgICAgICAg ICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwgcmVjb3JkX2xpc3QtPnUubWVt LmFkZHIpLAotCQkgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUu bWVtLmxlbik7Ci0JCQkgIGVsc2UKLQkJCSAgICAvKiBXcml0ZSBmYWlsZWQg LS0gCi0JCQkgICAgICAgZmxhZyBlbnRyeSBhcyBub3RfYWNjZXNzaWJsZS4g ICovCi0JCQkgICAgcmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3Rf YWNjZXNzaWJsZSA9IDE7Ci0JCQl9Ci0JCSAgICAgIGVsc2UKLQkJICAgICAg ICB7Ci0JCQkgIG1lbWNweSAocmVjb3JkX2xpc3QtPnUubWVtLnZhbCwgbWVt LAotCQkJCSAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7Ci0JCQl9Ci0JCSAg ICB9Ci0JCX0KLQkgICAgfQotCSAgZWxzZQorCSAgaWYgKHJlY29yZF9saXN0 LT50eXBlID09IHJlY29yZF9lbmQpCiAJICAgIHsKIAkgICAgICBpZiAocmVj b3JkX2RlYnVnID4gMSkKIAkJZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3Rk bG9nLApAQCAtOTAxLDYgKzEyMzIsNyBAQCByZWNvcmRfa2lsbCAoc3RydWN0 IHRhcmdldF9vcHMgKm9wcykKICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdk Yl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX2tpbGxcbiIpOwog CiAgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKKwogICB0YXJnZXRf a2lsbCAoKTsKIH0KIApAQCAtOTQ1LDcgKzEyNzcsNyBAQCByZWNvcmRfcmVn aXN0ZXJzX2NoYW5nZSAoc3RydWN0IHJlZ2NhY2hlCiAgIHJlY29yZF9saXN0 ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOwogCiAgIGlmIChyZWNvcmRfaW5z bl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNvcmRfaW5zbl9t YXhfbnVtKQotICAgIHJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3QgKCk7Cisg ICAgcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNuICgpOwogICBlbHNl CiAgICAgcmVjb3JkX2luc25fbnVtKys7CiB9CkBAIC0xMDU4LDcgKzEzOTAs NyBAQCByZWNvcmRfeGZlcl9wYXJ0aWFsIChzdHJ1Y3QgdGFyZ2V0X29wcyAq CiAgICAgICByZWNvcmRfbGlzdCA9IHJlY29yZF9hcmNoX2xpc3RfdGFpbDsK IAogICAgICAgaWYgKHJlY29yZF9pbnNuX251bSA9PSByZWNvcmRfaW5zbl9t YXhfbnVtICYmIHJlY29yZF9pbnNuX21heF9udW0pCi0JcmVjb3JkX2xpc3Rf cmVsZWFzZV9maXJzdCAoKTsKKwlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0 X2luc24gKCk7CiAgICAgICBlbHNlCiAJcmVjb3JkX2luc25fbnVtKys7CiAg ICAgfQpAQCAtMTEzOCw2ICsxNDcwLDE5MSBAQCBpbml0X3JlY29yZF9vcHMg KHZvaWQpCiB9CiAKIHN0YXRpYyB2b2lkCityZWNvcmRfY29yZV9yZXN1bWUg KHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsIHB0aWRfdCBwdGlkLCBpbnQgc3Rl cCwKKyAgICAgICAgICAgICAgICAgICAgZW51bSB0YXJnZXRfc2lnbmFsIHNp Z2duYWwpCit7CisgIHJlY29yZF9yZXN1bWVfc3RlcCA9IHN0ZXA7CisgIHJl Y29yZF9yZXN1bWVfc2lnZ25hbCA9IHNpZ2duYWw7Cit9CisKK3N0YXRpYyB2 b2lkCityZWNvcmRfY29yZV9raWxsIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3Bz KQoreworICBpZiAocmVjb3JkX2RlYnVnKQorICAgIGZwcmludGZfdW5maWx0 ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfY29y ZV9raWxsXG4iKTsKKworICB1bnB1c2hfdGFyZ2V0ICgmcmVjb3JkX2NvcmVf b3BzKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9jb3JlX2ZldGNoX3Jl Z2lzdGVycyAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50IHJlZ25vKQorewor ICBpZiAocmVnbm8gPCAwKQorICAgIHsKKyAgICAgIGludCBudW0gPSBnZGJh cmNoX251bV9yZWdzIChnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpKTsK KyAgICAgIGludCBpOworCisgICAgICBmb3IgKGkgPSAwOyBpIDwgbnVtOyBp ICsrKQorICAgICAgICByZWdjYWNoZV9yYXdfc3VwcGx5IChyZWdjYWNoZSwg aSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVf cmVnYnVmICsgTUFYX1JFR0lTVEVSX1NJWkUgKiBpKTsKKyAgICB9CisgIGVs c2UKKyAgICByZWdjYWNoZV9yYXdfc3VwcGx5IChyZWdjYWNoZSwgcmVnbm8s CisgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVm ICsgTUFYX1JFR0lTVEVSX1NJWkUgKiByZWdubyk7Cit9CisKK3N0YXRpYyB2 b2lkCityZWNvcmRfY29yZV9wcmVwYXJlX3RvX3N0b3JlIChzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlKQoreworfQorCitzdGF0aWMgdm9pZAorcmVjb3Jk X2NvcmVfc3RvcmVfcmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3Bz LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgcmVnY2Fj aGUgKnJlZ2NhY2hlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBp bnQgcmVnbm8pCit7CisgIGlmIChyZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNh YmxlKQorICAgIHJlZ2NhY2hlX3Jhd19jb2xsZWN0IChyZWdjYWNoZSwgcmVn bm8sCisgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9jb3JlX3Jl Z2J1ZiArIE1BWF9SRUdJU1RFUl9TSVpFICogcmVnbm8pOworICBlbHNlCisg ICAgZXJyb3IgKF8oIllvdSBjYW4ndCBkbyB0aGF0IHdpdGhvdXQgYSBwcm9j ZXNzIHRvIGRlYnVnLiIpKTsKK30KKworc3RhdGljIExPTkdFU1QKK3JlY29y ZF9jb3JlX3hmZXJfcGFydGlhbCAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywg ZW51bSB0YXJnZXRfb2JqZWN0IG9iamVjdCwKKwkJICAgICAgICAgIGNvbnN0 IGNoYXIgKmFubmV4LCBnZGJfYnl0ZSAqcmVhZGJ1ZiwKKwkJICAgICAgICAg IGNvbnN0IGdkYl9ieXRlICp3cml0ZWJ1ZiwgVUxPTkdFU1Qgb2Zmc2V0LAor ICAgICAgICAgICAgICAgICAgICAgICAgICBMT05HRVNUIGxlbikKK3sKKyAg IGlmIChvYmplY3QgPT0gVEFSR0VUX09CSkVDVF9NRU1PUlkpCisgICAgIHsK KyAgICAgICBpZiAocmVjb3JkX2dkYl9vcGVyYXRpb25fZGlzYWJsZSB8fCAh d3JpdGVidWYpCisgICAgICAgICB7CisgICAgICAgICAgIHN0cnVjdCB0YXJn ZXRfc2VjdGlvbiAqcDsKKyAgICAgICAgICAgZm9yIChwID0gcmVjb3JkX2Nv cmVfc3RhcnQ7IHAgPCByZWNvcmRfY29yZV9lbmQ7IHArKykKKyAgICAgICAg ICAgICB7CisgICAgICAgICAgICAgICBpZiAob2Zmc2V0ID49IHAtPmFkZHIp CisgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICBzdHJ1 Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5ICplbnRyeTsKKworICAgICAgICAg ICAgICAgICAgIGlmIChvZmZzZXQgPj0gcC0+ZW5kYWRkcikKKyAgICAgICAg ICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICAgICAgICAg aWYgKG9mZnNldCArIGxlbiA+IHAtPmVuZGFkZHIpCisgICAgICAgICAgICAg ICAgICAgICBsZW4gPSBwLT5lbmRhZGRyIC0gb2Zmc2V0OworCisgICAgICAg ICAgICAgICAgICAgb2Zmc2V0IC09IHAtPmFkZHI7CisKKyAgICAgICAgICAg ICAgICAgICAvKiBSZWFkIHJlYWRidWYgb3Igd3JpdGUgd3JpdGVidWYgcCwg b2Zmc2V0LCBsZW4uICAqLworICAgICAgICAgICAgICAgICAgIC8qIENoZWNr IGZsYWdzLiAgKi8KKyAgICAgICAgICAgICAgICAgICBpZiAocC0+dGhlX2Jm ZF9zZWN0aW9uLT5mbGFncyAmIFNFQ19DT05TVFJVQ1RPUgorICAgICAgICAg ICAgICAgICAgICAgICB8fCAocC0+dGhlX2JmZF9zZWN0aW9uLT5mbGFncyAm IFNFQ19IQVNfQ09OVEVOVFMpID09IDApCisgICAgICAgICAgICAgICAgICAg ICB7CisgICAgICAgICAgICAgICAgICAgICAgIGlmIChyZWFkYnVmKQorICAg ICAgICAgICAgICAgICAgICAgICAgIG1lbXNldCAocmVhZGJ1ZiwgMCwgbGVu KTsKKyAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGxlbjsKKyAgICAg ICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAvKiBHZXQg cmVjb3JkX2NvcmVfYnVmX2VudHJ5LiAgKi8KKyAgICAgICAgICAgICAgICAg ICBmb3IgKGVudHJ5ID0gcmVjb3JkX2NvcmVfYnVmX2xpc3Q7IGVudHJ5Owor ICAgICAgICAgICAgICAgICAgICAgICAgZW50cnkgPSBlbnRyeS0+cHJldikK KyAgICAgICAgICAgICAgICAgICAgIGlmIChlbnRyeS0+cCA9PSBwKQorICAg ICAgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICAg ICBpZiAod3JpdGVidWYpCisgICAgICAgICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgICAgICAgIGlmICghZW50cnkpCisgICAgICAgICAgICAg ICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgICAgICAgICAgLyog QWRkIGEgbmV3IGVudHJ5LiAgKi8KKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIGVudHJ5CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgID0gKHN0 cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkgKikKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHhtYWxsb2MKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKHNpemVvZiAoc3RydWN0IHJlY29yZF9jb3Jl X2J1Zl9lbnRyeSkpOworICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50 cnktPnAgPSBwOworICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKCFi ZmRfbWFsbG9jX2FuZF9nZXRfc2VjdGlvbiAocC0+YmZkLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcC0+dGhlX2JmZF9zZWN0aW9uLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJmVu dHJ5LT5idWYpKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeGZyZWUgKGVudHJ5KTsK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gMDsKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICAg ICAgICAgICAgICAgZW50cnktPnByZXYgPSByZWNvcmRfY29yZV9idWZfbGlz dDsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9jb3JlX2J1 Zl9saXN0ID0gZW50cnk7CisgICAgICAgICAgICAgICAgICAgICAgICAgfQor CisgICAgICAgICAgICAgICAgICAgICAgICBtZW1jcHkgKGVudHJ5LT5idWYg KyBvZmZzZXQsIHdyaXRlYnVmLCAoc2l6ZV90KSBsZW4pOworICAgICAgICAg ICAgICAgICAgICAgfQorICAgICAgICAgICAgICAgICAgIGVsc2UKKyAgICAg ICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgaWYg KCFlbnRyeSkKKyAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gcmVj b3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgKHJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFy dGlhbF9vcHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IG9iamVjdCwgYW5uZXgsIHJlYWRidWYsIHdyaXRlYnVmLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBvZmZzZXQsIGxlbik7CisKKyAg ICAgICAgICAgICAgICAgICAgICAgbWVtY3B5IChyZWFkYnVmLCBlbnRyeS0+ YnVmICsgb2Zmc2V0LCAoc2l6ZV90KSBsZW4pOworICAgICAgICAgICAgICAg ICAgICAgfQorCisgICAgICAgICAgICAgICAgICAgcmV0dXJuIGxlbjsKKyAg ICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgIH0KKworICAgICAgICAg ICByZXR1cm4gLTE7CisgICAgICAgICB9CisgICAgICAgZWxzZQorICAgICAg ICAgZXJyb3IgKF8oIllvdSBjYW4ndCBkbyB0aGF0IHdpdGhvdXQgYSBwcm9j ZXNzIHRvIGRlYnVnLiIpKTsKKyAgICAgfQorCisgIHJldHVybiByZWNvcmRf YmVuZWF0aF90b194ZmVyX3BhcnRpYWwgKHJlY29yZF9iZW5lYXRoX3RvX3hm ZXJfcGFydGlhbF9vcHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG9iamVjdCwgYW5uZXgsIHJlYWRidWYsIHdyaXRlYnVm LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBv ZmZzZXQsIGxlbik7Cit9CisKK3N0YXRpYyBpbnQKK3JlY29yZF9jb3JlX2lu c2VydF9icmVha3BvaW50IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwKKwkJ CSAgICAgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKmJwX3RndCkKK3sKKyAg cmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQKK3JlY29yZF9jb3JlX3JlbW92 ZV9icmVha3BvaW50IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwKKwkJCSAg ICAgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKmJwX3RndCkKK3sKKyAgcmV0 dXJuIDA7Cit9CisKK2ludAorcmVjb3JkX2NvcmVfaGFzX2V4ZWN1dGlvbiAo c3RydWN0IHRhcmdldF9vcHMgKm9wcykKK3sKKyAgcmV0dXJuIDE7Cit9CisK K3N0YXRpYyB2b2lkCitpbml0X3JlY29yZF9jb3JlX29wcyAodm9pZCkKK3sK KyAgcmVjb3JkX2NvcmVfb3BzLnRvX3Nob3J0bmFtZSA9ICJyZWNvcmRfY29y ZSI7CisgIHJlY29yZF9jb3JlX29wcy50b19sb25nbmFtZSA9ICJQcm9jZXNz IHJlY29yZCBhbmQgcmVwbGF5IHRhcmdldCI7CisgIHJlY29yZF9jb3JlX29w cy50b19kb2MgPQorICAgICJMb2cgcHJvZ3JhbSB3aGlsZSBleGVjdXRpbmcg YW5kIHJlcGxheSBleGVjdXRpb24gZnJvbSBsb2cuIjsKKyAgcmVjb3JkX2Nv cmVfb3BzLnRvX29wZW4gPSByZWNvcmRfb3BlbjsKKyAgcmVjb3JkX2NvcmVf b3BzLnRvX2Nsb3NlID0gcmVjb3JkX2Nsb3NlOworICByZWNvcmRfY29yZV9v cHMudG9fcmVzdW1lID0gcmVjb3JkX2NvcmVfcmVzdW1lOworICByZWNvcmRf Y29yZV9vcHMudG9fd2FpdCA9IHJlY29yZF93YWl0OworICByZWNvcmRfY29y ZV9vcHMudG9fa2lsbCA9IHJlY29yZF9jb3JlX2tpbGw7CisgIHJlY29yZF9j b3JlX29wcy50b19mZXRjaF9yZWdpc3RlcnMgPSByZWNvcmRfY29yZV9mZXRj aF9yZWdpc3RlcnM7CisgIHJlY29yZF9jb3JlX29wcy50b19wcmVwYXJlX3Rv X3N0b3JlID0gcmVjb3JkX2NvcmVfcHJlcGFyZV90b19zdG9yZTsKKyAgcmVj b3JkX2NvcmVfb3BzLnRvX3N0b3JlX3JlZ2lzdGVycyA9IHJlY29yZF9jb3Jl X3N0b3JlX3JlZ2lzdGVyczsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX3hmZXJf cGFydGlhbCA9IHJlY29yZF9jb3JlX3hmZXJfcGFydGlhbDsKKyAgcmVjb3Jk X2NvcmVfb3BzLnRvX2luc2VydF9icmVha3BvaW50ID0gcmVjb3JkX2NvcmVf aW5zZXJ0X2JyZWFrcG9pbnQ7CisgIHJlY29yZF9jb3JlX29wcy50b19yZW1v dmVfYnJlYWtwb2ludCA9IHJlY29yZF9jb3JlX3JlbW92ZV9icmVha3BvaW50 OworICByZWNvcmRfY29yZV9vcHMudG9fY2FuX2V4ZWN1dGVfcmV2ZXJzZSA9 IHJlY29yZF9jYW5fZXhlY3V0ZV9yZXZlcnNlOworICByZWNvcmRfY29yZV9v cHMudG9faGFzX2V4ZWN1dGlvbiA9IHJlY29yZF9jb3JlX2hhc19leGVjdXRp b247CisgIHJlY29yZF9jb3JlX29wcy50b19zdHJhdHVtID0gcmVjb3JkX3N0 cmF0dW07CisgIHJlY29yZF9jb3JlX29wcy50b19tYWdpYyA9IE9QU19NQUdJ QzsKK30KKworc3RhdGljIHZvaWQKIHNob3dfcmVjb3JkX2RlYnVnIChzdHJ1 Y3QgdWlfZmlsZSAqZmlsZSwgaW50IGZyb21fdHR5LAogCQkgICBzdHJ1Y3Qg Y21kX2xpc3RfZWxlbWVudCAqYywgY29uc3QgY2hhciAqdmFsdWUpCiB7CkBA IC0xMTUzLDYgKzE2NzAsMjYyIEBAIGNtZF9yZWNvcmRfc3RhcnQgKGNoYXIg KmFyZ3MsIGludCBmcm9tX3QKICAgZXhlY3V0ZV9jb21tYW5kICgidGFyZ2V0 IHJlY29yZCIsIGZyb21fdHR5KTsKIH0KIAorLyogUmVjb3JkIGxvZyBzYXZl LWZpbGUgZm9ybWF0CisgICBWZXJzaW9uIDEKKworICAgSGVhZGVyOgorICAg ICA0IGJ5dGVzOiBtYWdpYyBudW1iZXIgaHRvbmwoMHgyMDA5MDgyOSkuCisg ICAgICAgTk9URTogYmUgc3VyZSB0byBjaGFuZ2Ugd2hlbmV2ZXIgdGhpcyBm aWxlIGZvcm1hdCBjaGFuZ2VzIQorCisgICBSZWNvcmRzOgorICAgICByZWNv cmRfZW5kOgorICAgICAgIDEgYnl0ZTogIHJlY29yZCB0eXBlIChyZWNvcmRf ZW5kKS4KKyAgICAgcmVjb3JkX3JlZzoKKyAgICAgICAxIGJ5dGU6ICByZWNv cmQgdHlwZSAocmVjb3JkX3JlZykuCisgICAgICAgOCBieXRlczogcmVnaXN0 ZXIgaWQgKG5ldHdvcmsgYnl0ZSBvcmRlcikuCisgICAgICAgTUFYX1JFR0lT VEVSX1NJWkUgYnl0ZXM6IHJlZ2lzdGVyIHZhbHVlLgorICAgICByZWNvcmRf bWVtOgorICAgICAgIDEgYnl0ZTogIHJlY29yZCB0eXBlIChyZWNvcmRfbWVt KS4KKyAgICAgICA4IGJ5dGVzOiBtZW1vcnkgbGVuZ3RoIChuZXR3b3JrIGJ5 dGUgb3JkZXIpLgorICAgICAgIDggYnl0ZXM6IG1lbW9yeSBhZGRyZXNzIChu ZXR3b3JrIGJ5dGUgb3JkZXIpLgorICAgICAgIG4gYnl0ZXM6IG1lbW9yeSB2 YWx1ZSAobiA9PSBtZW1vcnkgbGVuZ3RoKS4KKyovCisKKy8qIGJmZGNvcmVf d3JpdGUgLS0gd3JpdGUgYnl0ZXMgaW50byBhIGNvcmUgZmlsZSBzZWN0aW9u LiAgKi8KKworc3RhdGljIGludAorYmZkY29yZV93cml0ZSAoYmZkICpvYmZk LCBhc2VjdGlvbiAqb3NlYywgdm9pZCAqYnVmLCBpbnQgbGVuLCBpbnQgKm9m ZnNldCkKK3sKKyAgaW50IHJldCA9IGJmZF9zZXRfc2VjdGlvbl9jb250ZW50 cyAob2JmZCwgb3NlYywgYnVmLCAqb2Zmc2V0LCBsZW4pOworCisgIGlmIChy ZXQpCisgICAgKm9mZnNldCArPSBsZW47CisgIHJldHVybiByZXQ7Cit9CisK Ky8qIER1bXAgdGhlIGV4ZWN1dGlvbiBsb2cgdG8gYSBmaWxlLiAgKi8KKwor c3RhdGljIHZvaWQKK2NtZF9yZWNvcmRfZHVtcCAoY2hhciAqYXJncywgaW50 IGZyb21fdHR5KQoreworICBjaGFyICpyZWNmaWxlbmFtZSwgcmVjZmlsZW5h bWVfYnVmZmVyWzQwXTsKKyAgaW50IHJlY2ZkOworICBzdHJ1Y3QgcmVjb3Jk X2VudHJ5ICpjdXJfcmVjb3JkX2xpc3Q7CisgIHVpbnQzMl90IG1hZ2ljOwor ICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlOworICBzdHJ1Y3QgZ2RiYXJj aCAqZ2RiYXJjaDsKKyAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwczsK KyAgc3RydWN0IGNsZWFudXAgKnNldF9jbGVhbnVwczsKKyAgYmZkICpvYmZk OworICBpbnQgZHVtcF9zaXplID0gMDsKKyAgYXNlY3Rpb24gKm9zZWMgPSBO VUxMOworICBpbnQgYmZkX29mZnNldCA9IDA7CisKKyAgaWYgKHN0cmNtcCAo Y3VycmVudF90YXJnZXQudG9fc2hvcnRuYW1lLCAicmVjb3JkIikgIT0gMCkK KyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgaXMgbm90IHN0YXJ0ZWQu XG4iKSk7CisKKyAgaWYgKGFyZ3MgJiYgKmFyZ3MpCisgICAgcmVjZmlsZW5h bWUgPSBhcmdzOworICBlbHNlCisgICAgeworICAgICAgLyogRGVmYXVsdCBy ZWNmaWxlIG5hbWUgaXMgImdkYl9yZWNvcmQuUElEIi4gICovCisgICAgICBz bnByaW50ZiAocmVjZmlsZW5hbWVfYnVmZmVyLCBzaXplb2YgKHJlY2ZpbGVu YW1lX2J1ZmZlciksCisgICAgICAgICAgICAgICAgImdkYl9yZWNvcmQuJWQi LCBQSURHRVQgKGluZmVyaW9yX3B0aWQpKTsKKyAgICAgIHJlY2ZpbGVuYW1l ID0gcmVjZmlsZW5hbWVfYnVmZmVyOworICAgIH0KKworICAvKiBPcGVuIHRo ZSBkdW1wIGZpbGUuICAqLworICBpZiAocmVjb3JkX2RlYnVnKQorICAgIGZw cmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKyAgICAgICAgICAgICAg ICAgICAgICAgIF8oIlNhdmluZyByZWNvcmRpbmcgdG8gZmlsZSAnJXMnXG4i KSwKKyAgICAgICAgICAgICAgICAgICAgICAgIHJlY2ZpbGVuYW1lKTsKKyAg LyogT3BlbiB0aGUgb3V0cHV0IGZpbGUuICAqLworICBvYmZkID0gY3JlYXRl X2djb3JlX2JmZCAocmVjZmlsZW5hbWUpOworICAvKiBOZWVkIGEgY2xlYW51 cCB0aGF0IHdpbGwgY2xvc2UgdGhlIGZpbGUgKEZJWE1FOiBkZWxldGUgaXQ/ KS4gICovCisgIG9sZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cF9iZmRfY2xv c2UgKG9iZmQpOworCisgIC8qIFNhdmUgdGhlIGN1cnJlbnQgcmVjb3JkIGVu dHJ5IHRvICJjdXJfcmVjb3JkX2xpc3QiLiAgKi8KKyAgY3VyX3JlY29yZF9s aXN0ID0gcmVjb3JkX2xpc3Q7CisKKyAgLyogR2V0IHRoZSB2YWx1ZXMgb2Yg cmVnY2FjaGUgYW5kIGdkYmFyY2guICAqLworICByZWdjYWNoZSA9IGdldF9j dXJyZW50X3JlZ2NhY2hlICgpOworICBnZGJhcmNoID0gZ2V0X3JlZ2NhY2hl X2FyY2ggKHJlZ2NhY2hlKTsKKworICAvKiBEaXNhYmxlIHRoZSBHREIgb3Bl cmF0aW9uIHJlY29yZC4gICovCisgIHNldF9jbGVhbnVwcyA9IHJlY29yZF9n ZGJfb3BlcmF0aW9uX2Rpc2FibGVfc2V0ICgpOworCisgIC8qIFJldmVyc2Ug ZXhlY3V0ZSB0byB0aGUgYmVnaW4gb2YgcmVjb3JkIGxpc3QuICAqLworICB3 aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBDaGVjayBmb3IgYmVnaW5uaW5n IGFuZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAgIGlmIChyZWNvcmRfbGlzdCA9 PSAmcmVjb3JkX2ZpcnN0KQorICAgICAgICBicmVhazsKKworICAgICAgcmVj b3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNvcmRfbGlz dCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+cHJldikKKyAgICAgICAg cmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsKKyAgICB9CisKKyAg LyogQ29tcHV0ZSB0aGUgc2l6ZSBuZWVkZWQgZm9yIHRoZSBleHRyYSBiZmQg c2VjdGlvbi4gICovCisgIGR1bXBfc2l6ZSA9IDQ7CS8qIG1hZ2ljIGNvb2tp ZSAqLworICBmb3IgKHJlY29yZF9saXN0ID0gJnJlY29yZF9maXJzdDsgcmVj b3JkX2xpc3Q7CisgICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+ bmV4dCkKKyAgICBzd2l0Y2ggKHJlY29yZF9saXN0LT50eXBlKQorICAgICAg eworICAgICAgY2FzZSByZWNvcmRfZW5kOgorCWR1bXBfc2l6ZSArPSAxOwor CWJyZWFrOworICAgICAgY2FzZSByZWNvcmRfcmVnOgorCWR1bXBfc2l6ZSAr PSAxICsgOCArIE1BWF9SRUdJU1RFUl9TSVpFOworCWJyZWFrOworICAgICAg Y2FzZSByZWNvcmRfbWVtOgorCWR1bXBfc2l6ZSArPSAxICsgOCArIDggKyBy ZWNvcmRfbGlzdC0+dS5tZW0ubGVuOworCWJyZWFrOworICAgICAgfQorCisg IC8qIE1ha2UgdGhlIG5ldyBiZmQgc2VjdGlvbi4gICovCisgIG9zZWMgPSBi ZmRfbWFrZV9zZWN0aW9uX2FueXdheV93aXRoX2ZsYWdzIChvYmZkLCAicHJl Y29yZCIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBTRUNfSEFTX0NPTlRFTlRTCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IFNFQ19SRUFET05MWSk7Cisg IGlmIChvc2VjID09IE5VTEwpCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byBj cmVhdGUgJ3ByZWNvcmQnIHNlY3Rpb24gZm9yIGNvcmVmaWxlOiAlcyIpLAor ICAgICAgICAgICBiZmRfZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7Cisg IGJmZF9zZXRfc2VjdGlvbl9zaXplIChvYmZkLCBvc2VjLCBkdW1wX3NpemUp OworICBiZmRfc2V0X3NlY3Rpb25fdm1hIChvYmZkLCBvc2VjLCAwKTsKKyAg YmZkX3NldF9zZWN0aW9uX2FsaWdubWVudCAob2JmZCwgb3NlYywgMCk7Cisg IGJmZF9zZWN0aW9uX2xtYSAob2JmZCwgb3NlYykgPSAwOworCisgIC8qIFNh dmUgY29yZWZpbGUgc3RhdGUuICAqLworICB3cml0ZV9nY29yZV9maWxlIChv YmZkKTsKKworICAvKiBXcml0ZSBvdXQgdGhlIHJlY29yZCBsb2cuICAqLwor ICAvKiBXcml0ZSB0aGUgbWFnaWMgY29kZS4gICovCisgIG1hZ2ljID0gUkVD T1JEX0ZJTEVfTUFHSUM7CisgIGlmIChyZWNvcmRfZGVidWcpCisgICAgZnBy aW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZGxvZywgXygiXAorV3JpdGluZyA0LWJ5 dGUgbWFnaWMgY29va2llIFJFQ09SRF9GSUxFX01BR0lDICgweCUwOHgpXG4i KSwKKyAgICAgICAgICAgICAgICAgICAgICBtYWdpYyk7CisgIGlmICghYmZk Y29yZV93cml0ZSAob2JmZCwgb3NlYywgJm1hZ2ljLCBzaXplb2YgKG1hZ2lj KSwgJmJmZF9vZmZzZXQpKQorICAgIGVycm9yIChfKCJGYWlsZWQgdG8gd3Jp dGUgJ21hZ2ljJyB0byAlcyAoJXMpIiksCisgICAgICAgICAgIHJlY2ZpbGVu YW1lLCBiZmRfZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7CisKKyAgLyog RHVtcCB0aGUgZW50cmllcyB0byByZWNmZCBhbmQgZm9yd2FyZCBleGVjdXRl IHRvIHRoZSBlbmQgb2YKKyAgICAgcmVjb3JkIGxpc3QuICAqLworICByZWNv cmRfbGlzdCA9ICZyZWNvcmRfZmlyc3Q7CisgIHdoaWxlICgxKQorICAgIHsK KyAgICAgIC8qIER1bXAgZW50cnkuICAqLworICAgICAgaWYgKHJlY29yZF9s aXN0ICE9ICZyZWNvcmRfZmlyc3QpCisgICAgICAgIHsKKyAgICAgICAgICB1 aW50OF90IHRtcHU4OworICAgICAgICAgIHVpbnQ2NF90IHRtcHU2NDsKKwor ICAgICAgICAgIHRtcHU4ID0gcmVjb3JkX2xpc3QtPnR5cGU7CisgICAgICAg ICAgaWYgKCFiZmRjb3JlX3dyaXRlIChvYmZkLCBvc2VjLCAmdG1wdTgsIHNp emVvZiAodG1wdTgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg JmJmZF9vZmZzZXQpKQorICAgICAgICAgICAgZXJyb3IgKF8oIkZhaWxlZCB0 byB3cml0ZSAndHlwZScgdG8gJXMgKCVzKSIpLAorCSAgICAgICAgICAgcmVj ZmlsZW5hbWUsIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJyb3IgKCkpKTsKKwor ICAgICAgICAgIHN3aXRjaCAocmVjb3JkX2xpc3QtPnR5cGUpCisgICAgICAg ICAgICB7CisgICAgICAgICAgICBjYXNlIHJlY29yZF9yZWc6IC8qIHJlZyAq LworICAgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAg ICAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywgXygiXAor V3JpdGluZyByZWdpc3RlciAlZCAoMSBwbHVzIDggcGx1cyAlZCBieXRlcylc biIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVj b3JkX2xpc3QtPnUucmVnLm51bSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIE1BWF9SRUdJU1RFUl9TSVpFKTsKKworICAgICAgICAg ICAgICAvKiBXcml0ZSByZWdudW0uICAqLworICAgICAgICAgICAgICB0bXB1 NjQgPSByZWNvcmRfbGlzdC0+dS5yZWcubnVtOworICAgICAgICAgICAgICBp ZiAoQllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAgICAgICAg ICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgICAg ICBpZiAoIWJmZGNvcmVfd3JpdGUgKG9iZmQsIG9zZWMsICZ0bXB1NjQsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2l6ZW9mICh0bXB1 NjQpLCAmYmZkX29mZnNldCkpCisgICAgICAgICAgICAgICAgZXJyb3IgKF8o IkZhaWxlZCB0byB3cml0ZSByZWdudW0gdG8gJXMgKCVzKSIpLAorICAgICAg ICAgICAgICByZWNmaWxlbmFtZSwgYmZkX2Vycm1zZyAoYmZkX2dldF9lcnJv ciAoKSkpOworCisgICAgICAgICAgICAgIC8qIFdyaXRlIHJlZ3ZhbC4gICov CisgICAgICAgICAgICAgIGlmICghYmZkY29yZV93cml0ZSAob2JmZCwgb3Nl YywgcmVjb3JkX2xpc3QtPnUucmVnLnZhbCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBNQVhfUkVHSVNURVJfU0laRSwgJmJmZF9vZmZz ZXQpKQorICAgICAgICAgICAgICAgIGVycm9yIChfKCJGYWlsZWQgdG8gd3Jp dGUgcmVndmFsIHRvICVzICglcykiKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgcmVjZmlsZW5hbWUsIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJyb3IgKCkp KTsKKyAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIGNhc2Ug cmVjb3JkX21lbTogLyogbWVtICovCisgICAgICAgICAgICAgIGlmICghcmVj b3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSkKKyAg ICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICBpZiAocmVjb3Jk X2RlYnVnKQorICAgICAgICAgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVy ZWQgKGdkYl9zdGRsb2csIF8oIlwKK1dyaXRpbmcgbWVtb3J5ICVzICgxIHBs dXMgOCBwbHVzIDggYnl0ZXMgcGx1cyAlZCBieXRlcylcbiIpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChn ZGJhcmNoLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xp c3QtPnUubWVtLmxlbik7CisKKyAgICAgICAgICAgICAgICAgIC8qIFdyaXRl IG1lbWxlbi4gICovCisgICAgICAgICAgICAgICAgICB0bXB1NjQgPSByZWNv cmRfbGlzdC0+dS5tZW0ubGVuOworICAgICAgICAgICAgICAgICAgaWYgKEJZ VEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgICAgICAg ICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAgICAg ICAgICBpZiAoIWJmZGNvcmVfd3JpdGUgKG9iZmQsIG9zZWMsICZ0bXB1NjQs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNpemVv ZiAodG1wdTY0KSwgJmJmZF9vZmZzZXQpKQorICAgICAgICAgICAgICAgICAg ICBlcnJvciAoXygiRmFpbGVkIHRvIHdyaXRlIG1lbWxlbiB0byAlcyAoJXMp IiksCisgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNmaWxlbmFtZSwg YmZkX2Vycm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworCisgICAgICAgICAg ICAgICAgICAvKiBXcml0ZSBtZW1hZGRyLiAgKi8KKyAgICAgICAgICAgICAg ICAgIHRtcHU2NCA9IHJlY29yZF9saXN0LT51Lm1lbS5hZGRyOworICAgICAg ICAgICAgICAgICAgaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikK KyAgICAgICAgICAgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2 NCk7CisgICAgICAgICAgICAgICAgICBpZiAoIWJmZGNvcmVfd3JpdGUgKG9i ZmQsIG9zZWMsICZ0bXB1NjQsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHNpemVvZiAodG1wdTY0KSwgJmJmZF9vZmZzZXQpKQor ICAgICAgICAgICAgICAgICAgICBlcnJvciAoXygiRmFpbGVkIHRvIHdyaXRl IG1lbWFkZHIgdG8gJXMgKCVzKSIpLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmVjZmlsZW5hbWUsIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJyb3Ig KCkpKTsKKworICAgICAgICAgICAgICAgICAgLyogV3JpdGUgbWVtdmFsLiAg Ki8KKyAgICAgICAgICAgICAgICAgIGlmICghYmZkY29yZV93cml0ZSAob2Jm ZCwgb3NlYywgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVt LmxlbiwgJmJmZF9vZmZzZXQpKQorICAgICAgICAgICAgICAgICAgICBlcnJv ciAoXygiRmFpbGVkIHRvIHdyaXRlIG1lbXZhbCB0byAlcyAoJXMpIiksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICByZWNmaWxlbmFtZSwgYmZkX2Vy cm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworICAgICAgICAgICAgICAgIH0K KyAgICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgICAgY2FzZSBy ZWNvcmRfZW5kOgorICAgICAgICAgICAgICAgIC8qIEZJWE1FOiByZWNvcmQg dGhlIGNvbnRlbnRzIG9mIHJlY29yZF9lbmQgcmVjLiAgKi8KKyAgICAgICAg ICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgICAgICAg ZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBfKCJXcml0aW5nIHJlY29yZF9l bmQgKDEgYnl0ZSlcbiIpKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAvKiBFeGVjdXRlIGVu dHJ5LiAgKi8KKyAgICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdjYWNoZSwg Z2RiYXJjaCwgcmVjb3JkX2xpc3QpOworCisgICAgICBpZiAocmVjb3JkX2xp c3QtPm5leHQpCisgICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2xpc3Qt Pm5leHQ7CisgICAgICBlbHNlCisgICAgICAgIGJyZWFrOworICAgIH0KKwor ICAvKiBSZXZlcnNlIGV4ZWN1dGUgdG8gY3VyX3JlY29yZF9saXN0LiAgKi8K KyAgd2hpbGUgKDEpCisgICAgeworICAgICAgLyogQ2hlY2sgZm9yIGJlZ2lu bmluZyBhbmQgZW5kIG9mIGxvZy4gICovCisgICAgICBpZiAocmVjb3JkX2xp c3QgPT0gY3VyX3JlY29yZF9saXN0KQorICAgICAgICBicmVhazsKKworICAg ICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNv cmRfbGlzdCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+cHJldikKKyAg ICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsKKyAgICB9 CisKKyAgZG9fY2xlYW51cHMgKHNldF9jbGVhbnVwcyk7CisgIGRvX2NsZWFu dXBzIChvbGRfY2xlYW51cHMpOworCisgIC8qIFN1Y2NlZWRlZC4gICovCisg IGZwcmludGZfZmlsdGVyZWQgKGdkYl9zdGRvdXQsIF8oIlNhdmVkIHJlY2Zp bGUgJXMuXG4iKSwgcmVjZmlsZW5hbWUpOworfQorCiAvKiBUcnVuY2F0ZSB0 aGUgcmVjb3JkIGxvZyBmcm9tIHRoZSBwcmVzZW50IHBvaW50CiAgICBvZiBy ZXBsYXkgdW50aWwgdGhlIGVuZC4gICovCiAKQEAgLTExODUsNyArMTk1OCwx MiBAQCBjbWRfcmVjb3JkX3N0b3AgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0 CiAgICAgewogICAgICAgaWYgKCFyZWNvcmRfbGlzdCB8fCAhZnJvbV90dHkg fHwgcXVlcnkgKF8oIkRlbGV0ZSByZWNvcmRlZCBsb2cgYW5kICIKIAkgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInN0b3AgcmVj b3JkaW5nPyIpKSkKLQl1bnB1c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7Cisg ICAgICAgIHsKKyAgICAgICAgICBpZiAoc3RyY21wIChjdXJyZW50X3Rhcmdl dC50b19zaG9ydG5hbWUsICJyZWNvcmQiKSA9PSAwKQorCSAgICB1bnB1c2hf dGFyZ2V0ICgmcmVjb3JkX29wcyk7CisgICAgICAgICAgZWxzZQorICAgICAg ICAgICAgdW5wdXNoX3RhcmdldCAoJnJlY29yZF9jb3JlX29wcyk7CisgICAg ICAgIH0KICAgICB9CiAgIGVsc2UKICAgICBwcmludGZfdW5maWx0ZXJlZCAo XygiUHJvY2VzcyByZWNvcmQgaXMgbm90IHN0YXJ0ZWQuXG4iKSk7CkBAIC0x MjAzLDcgKzE5ODEsNyBAQCBzZXRfcmVjb3JkX2luc25fbWF4X251bSAoY2hh ciAqYXJncywgaW50CiAJCSAgICAgICAgICAgInRoZSBmaXJzdCBvbmVzP1xu IikpOwogCiAgICAgICB3aGlsZSAocmVjb3JkX2luc25fbnVtID4gcmVjb3Jk X2luc25fbWF4X251bSkKLQlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgp OworCXJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAgICB9 CiB9CiAKQEAgLTEyNDMsNiArMjAyMSw4IEBAIGluZm9fcmVjb3JkX2NvbW1h bmQgKGNoYXIgKmFyZ3MsIGludCBmcm8KIHZvaWQKIF9pbml0aWFsaXplX3Jl Y29yZCAodm9pZCkKIHsKKyAgc3RydWN0IGNtZF9saXN0X2VsZW1lbnQgKmM7 CisKICAgLyogSW5pdCByZWNvcmRfZmlyc3QuICAqLwogICByZWNvcmRfZmly c3QucHJldiA9IE5VTEw7CiAgIHJlY29yZF9maXJzdC5uZXh0ID0gTlVMTDsK QEAgLTEyNTAsNiArMjAzMCw4IEBAIF9pbml0aWFsaXplX3JlY29yZCAodm9p ZCkKIAogICBpbml0X3JlY29yZF9vcHMgKCk7CiAgIGFkZF90YXJnZXQgKCZy ZWNvcmRfb3BzKTsKKyAgaW5pdF9yZWNvcmRfY29yZV9vcHMgKCk7CisgIGFk ZF90YXJnZXQgKCZyZWNvcmRfY29yZV9vcHMpOwogCiAgIGFkZF9zZXRzaG93 X3ppbnRlZ2VyX2NtZCAoInJlY29yZCIsIG5vX2NsYXNzLCAmcmVjb3JkX2Rl YnVnLAogCQkJICAgIF8oIlNldCBkZWJ1Z2dpbmcgb2YgcmVjb3JkL3JlcGxh eSBmZWF0dXJlLiIpLApAQCAtMTI1OSw5ICsyMDQxLDEwIEBAIF9pbml0aWFs aXplX3JlY29yZCAodm9pZCkKIAkJCSAgICBOVUxMLCBzaG93X3JlY29yZF9k ZWJ1ZywgJnNldGRlYnVnbGlzdCwKIAkJCSAgICAmc2hvd2RlYnVnbGlzdCk7 CiAKLSAgYWRkX3ByZWZpeF9jbWQgKCJyZWNvcmQiLCBjbGFzc19vYnNjdXJl LCBjbWRfcmVjb3JkX3N0YXJ0LAotCQkgIF8oIkFiYnJldmlhdGVkIGZvcm0g b2YgXCJ0YXJnZXQgcmVjb3JkXCIgY29tbWFuZC4iKSwKLSAJCSAgJnJlY29y ZF9jbWRsaXN0LCAicmVjb3JkICIsIDAsICZjbWRsaXN0KTsKKyAgYyA9IGFk ZF9wcmVmaXhfY21kICgicmVjb3JkIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3Jl Y29yZF9zdGFydCwKKwkJICAgICAgXygiQWJicmV2aWF0ZWQgZm9ybSBvZiBc InRhcmdldCByZWNvcmRcIiBjb21tYW5kLiIpLAorIAkJICAgICAgJnJlY29y ZF9jbWRsaXN0LCAicmVjb3JkICIsIDAsICZjbWRsaXN0KTsKKyAgc2V0X2Nt ZF9jb21wbGV0ZXIgKGMsIGZpbGVuYW1lX2NvbXBsZXRlcik7CiAgIGFkZF9j b21fYWxpYXMgKCJyZWMiLCAicmVjb3JkIiwgY2xhc3Nfb2JzY3VyZSwgMSk7 CiAgIGFkZF9wcmVmaXhfY21kICgicmVjb3JkIiwgY2xhc3Nfc3VwcG9ydCwg c2V0X3JlY29yZF9jb21tYW5kLAogCQkgIF8oIlNldCByZWNvcmQgb3B0aW9u cyIpLCAmc2V0X3JlY29yZF9jbWRsaXN0LApAQCAtMTI3Niw2ICsyMDU5LDEx IEBAIF9pbml0aWFsaXplX3JlY29yZCAodm9pZCkKIAkJICAiaW5mbyByZWNv cmQgIiwgMCwgJmluZm9saXN0KTsKICAgYWRkX2FsaWFzX2NtZCAoInJlYyIs ICJyZWNvcmQiLCBjbGFzc19vYnNjdXJlLCAxLCAmaW5mb2xpc3QpOwogCisg IGMgPSBhZGRfY21kICgiZHVtcCIsIGNsYXNzX29ic2N1cmUsIGNtZF9yZWNv cmRfZHVtcCwKKwkgICAgICAgXygiRHVtcCB0aGUgZXhlY3V0aW9uIHJlY29y ZHMgdG8gYSBmaWxlLlxuXAorQXJndW1lbnQgaXMgb3B0aW9uYWwgZmlsZW5h bWUuICBEZWZhdWx0IGZpbGVuYW1lIGlzICdnZGJfcmVjb3JkLjxwcm9jZXNz X2lkPicuIiksCisgICAgICAgICAgICAgICAmcmVjb3JkX2NtZGxpc3QpOwor ICBzZXRfY21kX2NvbXBsZXRlciAoYywgZmlsZW5hbWVfY29tcGxldGVyKTsK IAogICBhZGRfY21kICgiZGVsZXRlIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3Jl Y29yZF9kZWxldGUsCiAJICAgXygiRGVsZXRlIHRoZSByZXN0IG9mIGV4ZWN1 dGlvbiBsb2cgYW5kIHN0YXJ0IHJlY29yZGluZyBpdCBhbmV3LiIpLAo= --00151773d9f24ef1be047249510f Content-Type: text/plain; charset=US-ASCII; name="prec-dump-doc.txt" Content-Disposition: attachment; filename="prec-dump-doc.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fyyhyyca1 Content-length: 1078 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgIDEwICsrKysrKysrKysKIDEgZmls ZSBjaGFuZ2VkLCAxMCBpbnNlcnRpb25zKCspCgotLS0gYS9kb2MvZ2RiLnRl eGluZm8KKysrIGIvZG9jL2dkYi50ZXhpbmZvCkBAIC01MjE0LDYgKzUyMTQs MTYgQEAgV2hlbiByZWNvcmQgdGFyZ2V0IHJ1bnMgaW4gcmVwbGF5IG1vZGUg KAogc3Vic2VxdWVudCBleGVjdXRpb24gbG9nIGFuZCBiZWdpbiB0byByZWNv cmQgYSBuZXcgZXhlY3V0aW9uIGxvZyBzdGFydGluZwogZnJvbSB0aGUgY3Vy cmVudCBhZGRyZXNzLiAgVGhpcyBtZWFucyB5b3Ugd2lsbCBhYmFuZG9uIHRo ZSBwcmV2aW91c2x5CiByZWNvcmRlZCBgYGZ1dHVyZScnIGFuZCBiZWdpbiBy ZWNvcmRpbmcgYSBuZXcgYGBmdXR1cmUnJy4KKworQGtpbmRleCByZWNvcmQg ZHVtcAorQGtpbmRleCByZWMgZHVtcAorQGl0ZW0gcmVjb3JkIGR1bXAgW0B2 YXJ7ZmlsZX1dCitAaXRlbXggcmVjIGR1bXAgW0B2YXJ7ZmlsZX1dCitEdW1w IHRoZSBleGVjdXRpb24gcmVjb3JkcyBvZiB0aGUgaW5mZXJpb3IgcHJvY2Vz cyB0byBhIGNvcmUgZmlsZS4KK1RoZSBvcHRpb25hbCBhcmd1bWVudCBAdmFy e2ZpbGV9IHNwZWNpZmllcyB0aGUgZmlsZSBuYW1lIHdoZXJlIHRvIHB1dAor dGhlIHJlY29yZCBkdW1wLiAgSWYgbm90IHNwZWNpZmllZCwgdGhlIGZpbGUg bmFtZSBkZWZhdWx0cwordG8gQGZpbGV7Z2RiX3JlY29yZC5AdmFye3BpZH19 LCB3aGVyZSBAdmFye3BpZH0gaXMgaXMgdGhlIFBJRCBvZiB0aGUKK2luZmVy aW9yIHByb2Nlc3MuCiBAZW5kIHRhYmxlCiAKIAo= --00151773d9f24ef1be047249510f--