From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 1364 invoked by alias); 3 Aug 2009 04:12:23 -0000 Received: (qmail 1229 invoked by uid 22791); 3 Aug 2009 04:12:16 -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-pz0-f197.google.com (HELO mail-pz0-f197.google.com) (209.85.222.197) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 03 Aug 2009 04:12:08 +0000 Received: by pzk35 with SMTP id 35so2528227pzk.24 for ; Sun, 02 Aug 2009 21:12:06 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.51.18 with SMTP id y18mr473003wfy.73.1249272726175; Sun, 02 Aug 2009 21:12:06 -0700 (PDT) In-Reply-To: References: <4A749572.7030005@vmware.com> <4A75054C.9030304@vmware.com> From: Hui Zhu Date: Mon, 03 Aug 2009 04:12:00 -0000 Message-ID: Subject: Re: [RFA/RFC] Add dump and load command to process record and replay To: Michael Snyder , Eli Zaretskii Cc: gdb-patches ml Content-Type: multipart/mixed; boundary=000e0cd215a41242f4047034f9e0 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/msg00016.txt.bz2 --000e0cd215a41242f4047034f9e0 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 31896 On Sun, Aug 2, 2009 at 13:58, Hui Zhu wrote: > OK. =A0I will post new patches for them, memory and dump. > > Thanks, > Hui > > On Sun, Aug 2, 2009 at 11:17, Michael Snyder wrote: >> Michael Snyder wrote: >> >>> 3) I don't really understand how core files fit into this, >>> but I'd love to discuss that idea in a separate patch thread. >> >> Oh, sorry -- I see how they're related now. >> Very clever, actually. >> >> I'd still like to see them submitted separately, though, >> because: >> 1) the dump/restore part of the patch is cleaner and >> closer to being acceptable, and can really be used on >> its own, while >> 2) the corefile part of the patch is kind of messy and >> prototype-ish, and I think needs much more discussion and >> cleaning up before it will be ready. >> > Hi Eli and Michael, I make a new patch according to your mail. It depend on patch in http://sourceware.org/ml/gdb-patches/2009-08/msg00015.html Please help me review it. Thanks, Hui 2009-08-03 Hui Zhu Add dump and load command to process record and replay. * record.c (completer.h, arch-utils.h, gdbcore.h, exec.h, byteswap.h, netinet/in.h): Include files. (RECORD_IS_REPLAY): Return true if record_core is true. (RECORD_FILE_MAGIC): New macro. (record_core_buf_entry): New struct. (record_core, record_core_regbuf, record_core_start, record_core_end, record_core_buf_list, record_beneath_to_fetch_registers_ops, record_beneath_to_fetch_registers, record_beneath_to_store_registers_ops, record_beneath_to_store_registers, record_beneath_to_has_execution_ops, record_beneath_to_has_execution, record_beneath_to_prepare_to_store): New variables. (record_list_release_first_insn): Change function record_list_release_first to this name. (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): Add support for target core. (record_open): Add support for target core. (record_close): Add support for target core. (record_kill): Add support for target core. (record_registers_change): Call record_list_release_first_insn. (record_fetch_registers): New function. (record_prepare_to_store): New function. (record_store_registers): Add support for target core. (record_xfer_partial): Add support for target core. (record_has_execution): New function. (init_record_ops): Set record_ops.to_fetch_registers, record_ops.to_prepare_to_store and record_ops.to_has_execution. (cmd_record_fd_cleanups): New function. (cmd_record_dump): New function. (cmd_record_load): New function. (set_record_insn_max_num): Call record_list_release_first_insn. (_initialize_record): Add commands "record dump" and "record load". --- record.c | 587 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++= ++--- 1 file changed, 563 insertions(+), 24 deletions(-) --- a/record.c +++ b/record.c @@ -23,14 +23,22 @@ #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 #include +#include #define DEFAULT_RECORD_INSN_MAX_NUM 200000 #define RECORD_IS_REPLAY \ - (record_list->next || execution_direction =3D=3D EXEC_REVERSE) + (record_list->next || execution_direction =3D=3D EXEC_REVERSE || reco= rd_core) + +#define RECORD_FILE_MAGIC htonl(0x20090726) /* These are the core struct of record function. @@ -76,9 +84,23 @@ 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 with core target. */ +static int record_core =3D 0; +static gdb_byte *record_core_regbuf; +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; @@ -101,6 +123,14 @@ static struct target_ops *record_beneath static ptid_t (*record_beneath_to_wait) (struct target_ops *, ptid_t, struct target_waitstatus *, int); +static struct target_ops *record_beneath_to_fetch_registers_ops; +static void (*record_beneath_to_fetch_registers) (struct target_ops *, + struct regcache *, + int regno); +static struct target_ops *record_beneath_to_store_registers_ops; +static void (*record_beneath_to_store_registers) (struct target_ops *, + struct regcache *, + int regno); static struct target_ops *record_beneath_to_store_registers_ops; static void (*record_beneath_to_store_registers) (struct target_ops *, struct regcache *, @@ -117,6 +147,9 @@ static int (*record_beneath_to_insert_br struct bp_target_info *); static int (*record_beneath_to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *); +static struct target_ops *record_beneath_to_has_execution_ops; +static int (*record_beneath_to_has_execution) (struct target_ops *ops); +static void (*record_beneath_to_prepare_to_store) (struct regcache *regcac= he); static void record_list_release (struct record_entry *rec) @@ -167,7 +200,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; @@ -338,30 +371,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; @@ -384,7 +417,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++; @@ -453,7 +486,8 @@ record_exec_entry (struct regcache *regc if (target_read_memory (entry->u.mem.addr, mem, entry->u.mem.l= en)) { - if (execution_direction =3D=3D EXEC_REVERSE) + if ((execution_direction =3D=3D EXEC_REVERSE && !record_co= re) + || (execution_direction !=3D EXEC_REVERSE && record_co= re)) { record_list->u.mem.mem_entry_not_accessible =3D 1; if (record_debug) @@ -473,7 +507,8 @@ record_exec_entry (struct regcache *regc if (target_write_memory (entry->u.mem.addr, entry->u.mem.v= al, entry->u.mem.len)) { - if (execution_direction =3D=3D EXEC_REVERSE) + if ((execution_direction =3D=3D EXEC_REVERSE && !recor= d_core) + || (execution_direction !=3D EXEC_REVERSE && record_core)) { record_list->u.mem.mem_entry_not_accessible =3D 1; if (record_debug) @@ -505,8 +540,13 @@ record_open (char *name, int from_tty) if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); + if (!strcmp (current_target.to_shortname, "core")) + record_core =3D 1; + else + record_core =3D 0; + /* check exec */ - if (!target_has_execution) + if (!target_has_execution && !record_core) error (_("Process record: the program is not being run.")); if (non_stop) error (_("Process record target can't debug inferior in non-stop mode " @@ -535,6 +575,8 @@ record_open (char *name, int from_tty) record_beneath_to_xfer_partial =3D NULL; record_beneath_to_insert_breakpoint =3D NULL; record_beneath_to_remove_breakpoint =3D NULL; + record_beneath_to_has_execution =3D NULL; + record_beneath_to_prepare_to_store =3D NULL; /* Set the beneath function pointers. */ for (t =3D current_target.beneath; t !=3D NULL; t =3D t->beneath) @@ -549,6 +591,11 @@ record_open (char *name, int from_tty) record_beneath_to_wait =3D t->to_wait; record_beneath_to_wait_ops =3D t; } + if (!record_beneath_to_fetch_registers) + { + record_beneath_to_fetch_registers =3D t->to_fetch_registers; + record_beneath_to_fetch_registers_ops =3D t; + } if (!record_beneath_to_store_registers) { record_beneath_to_store_registers =3D t->to_store_registers; @@ -563,19 +610,51 @@ record_open (char *name, int from_tty) 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 (!record_beneath_to_has_execution) + { + record_beneath_to_has_execution_ops =3D t; + record_beneath_to_has_execution =3D t->to_has_execution; + } + if (!record_beneath_to_prepare_to_store) + record_beneath_to_prepare_to_store =3D t->to_prepare_to_store; } - if (!record_beneath_to_resume) + if (!record_beneath_to_resume && !record_core) error (_("Process record can't get to_resume.")); - if (!record_beneath_to_wait) + if (!record_beneath_to_wait && !record_core) error (_("Process record can't get to_wait.")); - if (!record_beneath_to_store_registers) + if (!record_beneath_to_fetch_registers) + error (_("Process record can't get to_fetch_registers.")); + if (!record_beneath_to_store_registers && !record_core) error (_("Process record can't get to_store_registers.")); if (!record_beneath_to_xfer_partial) error (_("Process record can't get to_xfer_partial.")); - if (!record_beneath_to_insert_breakpoint) + if (!record_beneath_to_insert_breakpoint && !record_core) error (_("Process record can't get to_insert_breakpoint.")); - if (!record_beneath_to_remove_breakpoint) + if (!record_beneath_to_remove_breakpoint && !record_core) error (_("Process record can't get to_remove_breakpoint.")); + if (!record_beneath_to_has_execution && !record_core) + error (_("Process record can't get to_has_execution.")); + if (!record_beneath_to_prepare_to_store && !record_core) + error (_("Process record can't get to_prepare_to_store.")); + + if (record_core) + { + /* Get record_core_regbuf. */ + struct regcache *regcache =3D get_current_regcache (); + int regnum =3D gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + 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)) + error (_("\"%s\": Can't find sections: %s"), + bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); + } push_target (&record_ops); @@ -588,10 +667,26 @@ record_open (char *name, int from_tty) 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. */ + xfree (record_core_regbuf); + + /* 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; @@ -915,7 +1010,9 @@ record_kill (struct target_ops *ops) fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n"); unpush_target (&record_ops); - target_kill (); + + if (!record_core) + target_kill (); } /* Record registers change (by user or by GDB) to list as an instruction. = */ @@ -959,15 +1056,58 @@ 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++; } static void +record_fetch_registers (struct target_ops *ops, struct regcache *regcache, + int regno) +{ + if (record_core) + { + 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 * regn= o); + } + else + record_beneath_to_fetch_registers (record_beneath_to_store_registers_o= ps, + regcache, regno); +} + +static void +record_prepare_to_store (struct regcache *regcache) +{ + if (!record_core) + record_beneath_to_prepare_to_store (regcache); +} + +static void record_store_registers (struct target_ops *ops, struct regcache *regcache, int regno) { + if (record_core) + { + /* Debug with core. */ + if (record_gdb_operation_disable) + regcache_raw_collect (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * reg= no); + else + error (_("You can't do that without a process to debug.")); + + return; + } + if (!record_gdb_operation_disable) { if (RECORD_IS_REPLAY) @@ -1014,6 +1154,7 @@ record_store_registers (struct target_op record_registers_change (regcache, regno); } + record_beneath_to_store_registers (record_beneath_to_store_registers_ops, regcache, regno); } @@ -1029,7 +1170,7 @@ record_xfer_partial (struct target_ops * { if (!record_gdb_operation_disable && (object =3D=3D TARGET_OBJECT_MEMORY - || object =3D=3D TARGET_OBJECT_RAW_MEMORY) && writebuf) + || object =3D=3D TARGET_OBJECT_RAW_MEMORY) && writebuf && !record_core) { if (RECORD_IS_REPLAY) { @@ -1073,11 +1214,91 @@ 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++; } + if (record_core && object =3D=3D TARGET_OBJECT_MEMORY) + { + /* Debug with core. */ + 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 0; + } + else + error (_("You can't do that without a process to debug.")); + + return 0; + } + return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_op= s, object, annex, readbuf, writebuf, offset, len); @@ -1127,6 +1348,15 @@ record_can_execute_reverse (void) return 1; } +int +record_has_execution (struct target_ops *ops) +{ + if (record_core) + return 1; + + return record_beneath_to_has_execution (ops); +} + static void init_record_ops (void) { @@ -1143,11 +1373,14 @@ init_record_ops (void) record_ops.to_mourn_inferior =3D record_mourn_inferior; record_ops.to_kill =3D record_kill; record_ops.to_create_inferior =3D find_default_create_inferior; + record_ops.to_fetch_registers =3D record_fetch_registers; + record_ops.to_prepare_to_store =3D record_prepare_to_store; record_ops.to_store_registers =3D record_store_registers; record_ops.to_xfer_partial =3D record_xfer_partial; record_ops.to_insert_breakpoint =3D record_insert_breakpoint; record_ops.to_remove_breakpoint =3D record_remove_breakpoint; record_ops.to_can_execute_reverse =3D record_can_execute_reverse; + record_ops.to_has_execution =3D record_has_execution; record_ops.to_stratum =3D record_stratum; record_ops.to_magic =3D OPS_MAGIC; } @@ -1168,6 +1401,300 @@ cmd_record_start (char *args, int from_t execute_command ("target record", from_tty); } +static void +cmd_record_fd_cleanups (void *recfdp) +{ + int recfd =3D *(int *) recfdp; + close (recfd); +} + +static inline void +record_read_dump (char *recfilename, int fildes, void *buf, size_t nbyte) +{ + if (read (fildes, buf, nbyte) !=3D nbyte) + error (_("Failed to read dump of execution records in '%s'."), + recfilename); +} + +static inline void +record_write_dump (char *recfilename, int fildes, const void *buf, + size_t nbyte) +{ + if (write (fildes, buf, nbyte) !=3D nbyte) + error (_("Failed to write dump of execution records to '%s'."), + recfilename); +} + +/* 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; + + if (current_target.to_stratum !=3D record_stratum) + error (_("Process record is not started.\n")); + + if (args && *args) + recfilename =3D args; + else + { + /* Default corefile name is "gdb_record.PID". */ + sprintf (recfilename_buffer, "gdb_record.%d", PIDGET (inferior_ptid)= ); + recfilename =3D recfilename_buffer; + } + + /* Open the dump file. */ + recfd =3D open (recfilename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, + S_IRUSR | S_IWUSR); + if (recfd < 0) + error (_("Failed to open '%s' for dump execution records: %s"), + recfilename, strerror (errno)); + old_cleanups =3D make_cleanup (cmd_record_fd_cleanups, &recfd); + + /* 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 (); + + /* Write the magic code. */ + magic =3D RECORD_FILE_MAGIC; + record_write_dump (recfilename, recfd, &magic, 4); + + /* 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; + } + + /* Dump the entries to recfd and forward execute to the end of + record list. */ + while (1) + { + /* Dump entry. */ + if (record_list !=3D &record_first) + { + uint8_t tmpu8; + uint64_t tmpu64; + + tmpu8 =3D record_list->type; + record_write_dump (recfilename, recfd, &tmpu8, 1); + + switch (record_list->type) + { + case record_reg: /* reg */ + tmpu64 =3D record_list->u.reg.num; +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + record_write_dump (recfilename, recfd, &tmpu64, 8); + + record_write_dump (recfilename, recfd, record_list->u.reg.va= l, + MAX_REGISTER_SIZE); + break; + case record_mem: /* mem */ + if (!record_list->u.mem.mem_entry_not_accessible) + { + tmpu64 =3D record_list->u.mem.addr; +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + record_write_dump (recfilename, recfd, &tmpu64, 8); + + tmpu64 =3D record_list->u.mem.len; +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + record_write_dump (recfilename, recfd, &tmpu64, 8); + + record_write_dump (recfilename, recfd, + record_list->u.mem.val, + record_list->u.mem.len); + } + 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 dump of execution " + "records to `%s'.\n"), + recfilename); +} + +/* Load the execution log from a file. */ + +static void +cmd_record_load (char *args, int from_tty) +{ + int recfd; + uint32_t magic; + struct cleanup *old_cleanups; + struct cleanup *old_cleanups2; + struct record_entry *rec; + int insn_number =3D 0; + + if (current_target.to_stratum !=3D record_stratum) + { + cmd_record_start (NULL, from_tty); + printf_unfiltered (_("Auto start process record.\n")); + } + + if (!args || (args && !*args)) + error (_("Argument for filename required.\n")); + + /* Open the load file. */ + recfd =3D open (args, O_RDONLY | O_BINARY); + if (recfd < 0) + error (_("Failed to open '%s' for loading execution records: %s"), + args, strerror (errno)); + old_cleanups =3D make_cleanup (cmd_record_fd_cleanups, &recfd); + + /* Check the magic code. */ + record_read_dump (args, recfd, &magic, 4); + if (magic !=3D RECORD_FILE_MAGIC) + error (_("'%s' is not a valid dump of execution records."), args); + + /* 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; + old_cleanups2 =3D make_cleanup (record_arch_list_cleanups, 0); + + while (1) + { + int ret; + uint8_t tmpu8; + uint64_t tmpu64; + + ret =3D read (recfd, &tmpu8, 1); + if (ret < 0) + error (_("Failed to read dump of execution records in '%s'."), arg= s); + if (ret =3D=3D 0) + break; + + switch (tmpu8) + { + case record_reg: /* reg */ + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_e= ntry)); + rec->u.reg.val =3D (gdb_byte *) xmalloc (MAX_REGISTER_SIZE); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_reg; + /* Get num. */ + record_read_dump (args, recfd, &tmpu64, 8); +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + rec->u.reg.num =3D tmpu64; + /* Get val. */ + record_read_dump (args, recfd, rec->u.reg.val, MAX_REGISTER_SIZE= ); + record_arch_list_add (rec); + break; + case record_mem: /* mem */ + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_e= ntry)); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_mem; + /* Get addr. */ + record_read_dump (args, recfd, &tmpu64, 8); +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + rec->u.mem.addr =3D tmpu64; + /* Get len. */ + record_read_dump (args, recfd, &tmpu64, 8); +#if (BYTE_ORDER =3D=3D LITTLE_ENDIAN) + tmpu64 =3D bswap_64 (tmpu64); +#endif + rec->u.mem.len =3D tmpu64; + rec->u.mem.mem_entry_not_accessible =3D 0; + rec->u.mem.val =3D (gdb_byte *) xmalloc (rec->u.mem.len); + /* Get val. */ + record_read_dump (args, recfd, rec->u.mem.val, rec->u.mem.len); + record_arch_list_add (rec); + break; + + case record_end: /* end */ + rec =3D (struct record_entry *) xmalloc (sizeof (struct record_e= ntry)); + rec->prev =3D NULL; + rec->next =3D NULL; + rec->type =3D record_end; + record_arch_list_add (rec); + insn_number ++; + break; + + default: + error (_("Format of '%s' is not right."), args); + break; + } + } + + discard_cleanups (old_cleanups2); + + /* Add record_arch_list_head to the end of record list. */ + for (rec =3D record_list; rec->next; rec =3D rec->next); + rec->next =3D record_arch_list_head; + record_arch_list_head->prev =3D rec; + + /* Update record_insn_num and record_insn_max_num. */ + record_insn_num +=3D insn_number; + 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); + } + + do_cleanups (old_cleanups); + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, "Loaded recfile %s.\n", args); +} + /* Truncate the record log from the present point of replay until the end. */ @@ -1218,7 +1745,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 (); } } @@ -1258,6 +1785,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; @@ -1291,6 +1820,16 @@ _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); + c =3D add_cmd ("load", class_obscure, cmd_record_load, + _("Load previously dumped execution records from \ +a file given as argument."), + &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."), 2009-08-03 Hui Zhu * gdb.texinfo (Process Record and Replay): Document the "record dump" and "record dump" commands. --- doc/gdb.texinfo | 15 +++++++++++++++ 1 file changed, 15 insertions(+) --- a/doc/gdb.texinfo +++ b/doc/gdb.texinfo @@ -5190,6 +5190,21 @@ 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 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}}, w= here +@var{pid} is is the PID of the inferior process. + +@kindex record load +@kindex rec load +@item record load @var{file} +@itemx rec dump @var{file} +Load previously-dumped execution records from @var{file}. @end table --000e0cd215a41242f4047034f9e0 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_fxwothka0 Content-length: 37373 LS0tCiByZWNvcmQuYyB8ICA1ODcgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tCiAxIGZp bGUgY2hhbmdlZCwgNTYzIGluc2VydGlvbnMoKyksIDI0IGRlbGV0aW9ucygt KQoKLS0tIGEvcmVjb3JkLmMKKysrIGIvcmVjb3JkLmMKQEAgLTIzLDE0ICsy MywyMiBAQAogI2luY2x1ZGUgImdkYnRocmVhZC5oIgogI2luY2x1ZGUgImV2 ZW50LXRvcC5oIgogI2luY2x1ZGUgImV4Y2VwdGlvbnMuaCIKKyNpbmNsdWRl ICJjb21wbGV0ZXIuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5j bHVkZSAiZ2RiY29yZS5oIgorI2luY2x1ZGUgImV4ZWMuaCIKICNpbmNsdWRl ICJyZWNvcmQuaCIKIAorI2luY2x1ZGUgPGJ5dGVzd2FwLmg+CiAjaW5jbHVk ZSA8c2lnbmFsLmg+CisjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgogCiAjZGVm aW5lIERFRkFVTFRfUkVDT1JEX0lOU05fTUFYX05VTQkyMDAwMDAKIAogI2Rl ZmluZSBSRUNPUkRfSVNfUkVQTEFZIFwKLSAgICAgKHJlY29yZF9saXN0LT5u ZXh0IHx8IGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQor ICAgICAocmVjb3JkX2xpc3QtPm5leHQgfHwgZXhlY3V0aW9uX2RpcmVjdGlv biA9PSBFWEVDX1JFVkVSU0UgfHwgcmVjb3JkX2NvcmUpCisKKyNkZWZpbmUg UkVDT1JEX0ZJTEVfTUFHSUMJaHRvbmwoMHgyMDA5MDcyNikKIAogLyogVGhl c2UgYXJlIHRoZSBjb3JlIHN0cnVjdCBvZiByZWNvcmQgZnVuY3Rpb24uCiAK QEAgLTc2LDkgKzg0LDIzIEBAIHN0cnVjdCByZWNvcmRfZW50cnkKICAgfSB1 OwogfTsKIAorc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeQoreworICBz dHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5ICpwcmV2OworICBzdHJ1Y3Qg dGFyZ2V0X3NlY3Rpb24gKnA7CisgIGJmZF9ieXRlICpidWY7Cit9OworCiAv KiBUaGlzIGlzIHRoZSBkZWJ1ZyBzd2l0Y2ggZm9yIHByb2Nlc3MgcmVjb3Jk LiAgKi8KIGludCByZWNvcmRfZGVidWcgPSAwOwogCisvKiBSZWNvcmQgd2l0 aCBjb3JlIHRhcmdldC4gICovCitzdGF0aWMgaW50IHJlY29yZF9jb3JlID0g MDsKK3N0YXRpYyBnZGJfYnl0ZSAqcmVjb3JkX2NvcmVfcmVnYnVmOworc3Rh dGljIHN0cnVjdCB0YXJnZXRfc2VjdGlvbiAqcmVjb3JkX2NvcmVfc3RhcnQ7 CitzdGF0aWMgc3RydWN0IHRhcmdldF9zZWN0aW9uICpyZWNvcmRfY29yZV9l bmQ7CitzdGF0aWMgc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeSAqcmVj b3JkX2NvcmVfYnVmX2xpc3QgPSBOVUxMOworCiAvKiBUaGVzZSBsaXN0IGlz IGZvciBleGVjdXRpb24gbG9nLiAgKi8KIHN0YXRpYyBzdHJ1Y3QgcmVjb3Jk X2VudHJ5IHJlY29yZF9maXJzdDsKIHN0YXRpYyBzdHJ1Y3QgcmVjb3JkX2Vu dHJ5ICpyZWNvcmRfbGlzdCA9ICZyZWNvcmRfZmlyc3Q7CkBAIC0xMDEsNiAr MTIzLDE0IEBAIHN0YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2Jl bmVhdGgKIHN0YXRpYyBwdGlkX3QgKCpyZWNvcmRfYmVuZWF0aF90b193YWl0 KSAoc3RydWN0IHRhcmdldF9vcHMgKiwgcHRpZF90LAogCQkJCQkgc3RydWN0 IHRhcmdldF93YWl0c3RhdHVzICosCiAJCQkJCSBpbnQpOworc3RhdGljIHN0 cnVjdCB0YXJnZXRfb3BzICpyZWNvcmRfYmVuZWF0aF90b19mZXRjaF9yZWdp c3RlcnNfb3BzOworc3RhdGljIHZvaWQgKCpyZWNvcmRfYmVuZWF0aF90b19m ZXRjaF9yZWdpc3RlcnMpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dHJ1Y3QgcmVnY2FjaGUgKiwKKwkJCQkJCSAgaW50IHJlZ25vKTsKK3N0YXRp YyBzdHJ1Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVf cmVnaXN0ZXJzX29wczsKK3N0YXRpYyB2b2lkICgqcmVjb3JkX2JlbmVhdGhf dG9fc3RvcmVfcmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMgKiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc3RydWN0IHJlZ2NhY2hlICosCisJCQkJCQkgIGludCByZWdubyk7CiBz dGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRoX3RvX3N0 b3JlX3JlZ2lzdGVyc19vcHM7CiBzdGF0aWMgdm9pZCAoKnJlY29yZF9iZW5l YXRoX3RvX3N0b3JlX3JlZ2lzdGVycykgKHN0cnVjdCB0YXJnZXRfb3BzICos CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0cnVjdCByZWdjYWNoZSAqLApAQCAtMTE3LDYgKzE0Nyw5IEBA IHN0YXRpYyBpbnQgKCpyZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnIKIAkJ CQkJCSAgIHN0cnVjdCBicF90YXJnZXRfaW5mbyAqKTsKIHN0YXRpYyBpbnQg KCpyZWNvcmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2ludCkgKHN0cnVj dCBnZGJhcmNoICosCiAJCQkJCQkgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8g Kik7CitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRo X3RvX2hhc19leGVjdXRpb25fb3BzOworc3RhdGljIGludCAoKnJlY29yZF9i ZW5lYXRoX3RvX2hhc19leGVjdXRpb24pIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzKTsKK3N0YXRpYyB2b2lkICgqcmVjb3JkX2JlbmVhdGhfdG9fcHJlcGFy ZV90b19zdG9yZSkgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUpOwogCiBz dGF0aWMgdm9pZAogcmVjb3JkX2xpc3RfcmVsZWFzZSAoc3RydWN0IHJlY29y ZF9lbnRyeSAqcmVjKQpAQCAtMTY3LDcgKzIwMCw3IEBAIHJlY29yZF9saXN0 X3JlbGVhc2VfbmV4dCAodm9pZCkKIH0KIAogc3RhdGljIHZvaWQKLXJlY29y ZF9saXN0X3JlbGVhc2VfZmlyc3QgKHZvaWQpCityZWNvcmRfbGlzdF9yZWxl YXNlX2ZpcnN0X2luc24gKHZvaWQpCiB7CiAgIHN0cnVjdCByZWNvcmRfZW50 cnkgKnRtcCA9IE5VTEw7CiAgIGVudW0gcmVjb3JkX3R5cGUgdHlwZTsKQEAg LTMzOCwzMCArMzcxLDMwIEBAIHJlY29yZF9jaGVja19pbnNuX251bSAoaW50 IHNldF90ZXJtaW5hbCkKIAkgICAgICBpZiAocSkKIAkJcmVjb3JkX3N0b3Bf YXRfbGltaXQgPSAwOwogCSAgICAgIGVsc2UKLQkJZXJyb3IgKF8oIlByb2Nl c3MgcmVjb3JkOiBpbmZlcmlvciBwcm9ncmFtIHN0b3BwZWQuIikpOworCQll cnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IHN0b3BlZCBieSB1c2VyLiIpKTsK IAkgICAgfQogCX0KICAgICB9CiB9CiAKK3N0YXRpYyB2b2lkCityZWNvcmRf YXJjaF9saXN0X2NsZWFudXBzICh2b2lkICppZ25vcmUpCit7CisgIHJlY29y ZF9saXN0X3JlbGVhc2UgKHJlY29yZF9hcmNoX2xpc3RfdGFpbCk7Cit9CisK IC8qIEJlZm9yZSBpbmZlcmlvciBzdGVwICh3aGVuIEdEQiByZWNvcmQgdGhl IHJ1bm5pbmcgbWVzc2FnZSwgaW5mZXJpb3IKICAgIG9ubHkgY2FuIHN0ZXAp LCBHREIgd2lsbCBjYWxsIHRoaXMgZnVuY3Rpb24gdG8gcmVjb3JkIHRoZSB2 YWx1ZXMgdG8KICAgIHJlY29yZF9saXN0LiAgVGhpcyBmdW5jdGlvbiB3aWxs IGNhbGwgZ2RiYXJjaF9wcm9jZXNzX3JlY29yZCB0bwogICAgcmVjb3JkIHRo ZSBydW5uaW5nIG1lc3NhZ2Ugb2YgaW5mZXJpb3IgYW5kIHNldCB0aGVtIHRv CiAgICByZWNvcmRfYXJjaF9saXN0LCBhbmQgYWRkIGl0IHRvIHJlY29yZF9s aXN0LiAgKi8KIAotc3RhdGljIHZvaWQKLXJlY29yZF9tZXNzYWdlX2NsZWFu dXBzICh2b2lkICppZ25vcmUpCi17Ci0gIHJlY29yZF9saXN0X3JlbGVhc2Ug KHJlY29yZF9hcmNoX2xpc3RfdGFpbCk7Ci19Ci0KIHN0YXRpYyBpbnQKIHJl Y29yZF9tZXNzYWdlICh2b2lkICphcmdzKQogewogICBpbnQgcmV0OwogICBz dHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlID0gYXJnczsKLSAgc3RydWN0IGNs ZWFudXAgKm9sZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cCAocmVjb3JkX21l c3NhZ2VfY2xlYW51cHMsIDApOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2Ns ZWFudXBzID0gbWFrZV9jbGVhbnVwIChyZWNvcmRfYXJjaF9saXN0X2NsZWFu dXBzLCAwKTsKIAogICByZWNvcmRfYXJjaF9saXN0X2hlYWQgPSBOVUxMOwog ICByZWNvcmRfYXJjaF9saXN0X3RhaWwgPSBOVUxMOwpAQCAtMzg0LDcgKzQx Nyw3IEBAIHJlY29yZF9tZXNzYWdlICh2b2lkICphcmdzKQogICByZWNvcmRf bGlzdCA9IHJlY29yZF9hcmNoX2xpc3RfdGFpbDsKIAogICBpZiAocmVjb3Jk X2luc25fbnVtID09IHJlY29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2lu c25fbWF4X251bSkKLSAgICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgp OworICAgIHJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAg ZWxzZQogICAgIHJlY29yZF9pbnNuX251bSsrOwogCkBAIC00NTMsNyArNDg2 LDggQEAgcmVjb3JkX2V4ZWNfZW50cnkgKHN0cnVjdCByZWdjYWNoZSAqcmVn YwogCiAgICAgICAgICAgICBpZiAodGFyZ2V0X3JlYWRfbWVtb3J5IChlbnRy eS0+dS5tZW0uYWRkciwgbWVtLCBlbnRyeS0+dS5tZW0ubGVuKSkKICAgICAg ICAgICAgICAgewotICAgICAgICAgICAgICAgIGlmIChleGVjdXRpb25fZGly ZWN0aW9uID09IEVYRUNfUkVWRVJTRSkKKyAgICAgICAgICAgICAgICBpZiAo KGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFICYmICFyZWNv cmRfY29yZSkKKyAgICAgICAgICAgICAgICAgICAgfHwgKGV4ZWN1dGlvbl9k aXJlY3Rpb24gIT0gRVhFQ19SRVZFUlNFICYmIHJlY29yZF9jb3JlKSkKICAg ICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgcmVjb3Jk X2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9IDE7CiAg ICAgICAgICAgICAgICAgICAgIGlmIChyZWNvcmRfZGVidWcpCkBAIC00NzMs NyArNTA3LDggQEAgcmVjb3JkX2V4ZWNfZW50cnkgKHN0cnVjdCByZWdjYWNo ZSAqcmVnYwogICAgICAgICAgICAgICAgIGlmICh0YXJnZXRfd3JpdGVfbWVt b3J5IChlbnRyeS0+dS5tZW0uYWRkciwgZW50cnktPnUubWVtLnZhbCwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50cnkt PnUubWVtLmxlbikpCiAgICAgICAgICAgICAgICAgICB7Ci0gICAgICAgICAg ICAgICAgICAgIGlmIChleGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNfUkVW RVJTRSkKKyAgICAgICAgICAgICAgICAgICAgaWYgKChleGVjdXRpb25fZGly ZWN0aW9uID09IEVYRUNfUkVWRVJTRSAmJiAhcmVjb3JkX2NvcmUpCisgICAg ICAgICAgICAgICAgICAgICAgICB8fCAoZXhlY3V0aW9uX2RpcmVjdGlvbiAh PSBFWEVDX1JFVkVSU0UgJiYgcmVjb3JkX2NvcmUpKQogICAgICAgICAgICAg ICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9s aXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUgPSAxOwogICAg ICAgICAgICAgICAgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKQEAgLTUw NSw4ICs1NDAsMTMgQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUsIGludCBm cm9tX3R0eSkKICAgaWYgKHJlY29yZF9kZWJ1ZykKICAgICBmcHJpbnRmX3Vu ZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3Jk X29wZW5cbiIpOwogCisgIGlmICghc3RyY21wIChjdXJyZW50X3RhcmdldC50 b19zaG9ydG5hbWUsICJjb3JlIikpCisgICAgcmVjb3JkX2NvcmUgPSAxOwor ICBlbHNlCisgICAgcmVjb3JkX2NvcmUgPSAwOworCiAgIC8qIGNoZWNrIGV4 ZWMgKi8KLSAgaWYgKCF0YXJnZXRfaGFzX2V4ZWN1dGlvbikKKyAgaWYgKCF0 YXJnZXRfaGFzX2V4ZWN1dGlvbiAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJy b3IgKF8oIlByb2Nlc3MgcmVjb3JkOiB0aGUgcHJvZ3JhbSBpcyBub3QgYmVp bmcgcnVuLiIpKTsKICAgaWYgKG5vbl9zdG9wKQogICAgIGVycm9yIChfKCJQ cm9jZXNzIHJlY29yZCB0YXJnZXQgY2FuJ3QgZGVidWcgaW5mZXJpb3IgaW4g bm9uLXN0b3AgbW9kZSAiCkBAIC01MzUsNiArNTc1LDggQEAgcmVjb3JkX29w ZW4gKGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKICAgcmVjb3JkX2JlbmVh dGhfdG9feGZlcl9wYXJ0aWFsID0gTlVMTDsKICAgcmVjb3JkX2JlbmVhdGhf dG9faW5zZXJ0X2JyZWFrcG9pbnQgPSBOVUxMOwogICByZWNvcmRfYmVuZWF0 aF90b19yZW1vdmVfYnJlYWtwb2ludCA9IE5VTEw7CisgIHJlY29yZF9iZW5l YXRoX3RvX2hhc19leGVjdXRpb24gPSBOVUxMOworICByZWNvcmRfYmVuZWF0 aF90b19wcmVwYXJlX3RvX3N0b3JlID0gTlVMTDsKIAogICAvKiBTZXQgdGhl IGJlbmVhdGggZnVuY3Rpb24gcG9pbnRlcnMuICAqLwogICBmb3IgKHQgPSBj dXJyZW50X3RhcmdldC5iZW5lYXRoOyB0ICE9IE5VTEw7IHQgPSB0LT5iZW5l YXRoKQpAQCAtNTQ5LDYgKzU5MSwxMSBAQCByZWNvcmRfb3BlbiAoY2hhciAq bmFtZSwgaW50IGZyb21fdHR5KQogCSAgcmVjb3JkX2JlbmVhdGhfdG9fd2Fp dCA9IHQtPnRvX3dhaXQ7CiAJICByZWNvcmRfYmVuZWF0aF90b193YWl0X29w cyA9IHQ7CiAgICAgICAgIH0KKyAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhf dG9fZmV0Y2hfcmVnaXN0ZXJzKQorICAgICAgICB7CisJICByZWNvcmRfYmVu ZWF0aF90b19mZXRjaF9yZWdpc3RlcnMgPSB0LT50b19mZXRjaF9yZWdpc3Rl cnM7CisJICByZWNvcmRfYmVuZWF0aF90b19mZXRjaF9yZWdpc3RlcnNfb3Bz ID0gdDsKKyAgICAgICAgfQogICAgICAgaWYgKCFyZWNvcmRfYmVuZWF0aF90 b19zdG9yZV9yZWdpc3RlcnMpCiAgICAgICAgIHsKIAkgIHJlY29yZF9iZW5l YXRoX3RvX3N0b3JlX3JlZ2lzdGVycyA9IHQtPnRvX3N0b3JlX3JlZ2lzdGVy czsKQEAgLTU2MywxOSArNjEwLDUxIEBAIHJlY29yZF9vcGVuIChjaGFyICpu YW1lLCBpbnQgZnJvbV90dHkpCiAJcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0 X2JyZWFrcG9pbnQgPSB0LT50b19pbnNlcnRfYnJlYWtwb2ludDsKICAgICAg IGlmICghcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9pbnQpCiAJ cmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9pbnQgPSB0LT50b19y ZW1vdmVfYnJlYWtwb2ludDsKKyAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhf dG9faGFzX2V4ZWN1dGlvbikKKyAgICAgICAgeworICAgICAgICAgIHJlY29y ZF9iZW5lYXRoX3RvX2hhc19leGVjdXRpb25fb3BzID0gdDsKKwkgIHJlY29y ZF9iZW5lYXRoX3RvX2hhc19leGVjdXRpb24gPSB0LT50b19oYXNfZXhlY3V0 aW9uOworICAgICAgICB9CisgICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3Rv X3ByZXBhcmVfdG9fc3RvcmUpCisJcmVjb3JkX2JlbmVhdGhfdG9fcHJlcGFy ZV90b19zdG9yZSA9IHQtPnRvX3ByZXBhcmVfdG9fc3RvcmU7CiAgICAgfQot ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSkKKyAgaWYgKCFyZWNv cmRfYmVuZWF0aF90b19yZXN1bWUgJiYgIXJlY29yZF9jb3JlKQogICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fcmVzdW1lLiIp KTsKLSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b193YWl0KQorICBpZiAoIXJl Y29yZF9iZW5lYXRoX3RvX3dhaXQgJiYgIXJlY29yZF9jb3JlKQogICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fd2FpdC4iKSk7 Ci0gIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzKQor ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX2ZldGNoX3JlZ2lzdGVycykKKyAg ICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2ZldGNo X3JlZ2lzdGVycy4iKSk7CisgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fc3Rv cmVfcmVnaXN0ZXJzICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJvciAoXygi UHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3N0b3JlX3JlZ2lzdGVycy4i KSk7CiAgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsKQog ICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9feGZl cl9wYXJ0aWFsLiIpKTsKLSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19pbnNl cnRfYnJlYWtwb2ludCkKKyAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19pbnNl cnRfYnJlYWtwb2ludCAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19pbnNlcnRfYnJlYWtwb2lu dC4iKSk7Ci0gIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFr cG9pbnQpCisgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFr cG9pbnQgJiYgIXJlY29yZF9jb3JlKQogICAgIGVycm9yIChfKCJQcm9jZXNz IHJlY29yZCBjYW4ndCBnZXQgdG9fcmVtb3ZlX2JyZWFrcG9pbnQuIikpOwor ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX2hhc19leGVjdXRpb24gJiYgIXJl Y29yZF9jb3JlKQorICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4n dCBnZXQgdG9faGFzX2V4ZWN1dGlvbi4iKSk7CisgIGlmICghcmVjb3JkX2Jl bmVhdGhfdG9fcHJlcGFyZV90b19zdG9yZSAmJiAhcmVjb3JkX2NvcmUpCisg ICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19wcmVw YXJlX3RvX3N0b3JlLiIpKTsKKworICBpZiAocmVjb3JkX2NvcmUpCisgICAg eworICAgICAgLyogR2V0IHJlY29yZF9jb3JlX3JlZ2J1Zi4gICovCisgICAg ICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlID0gZ2V0X2N1cnJlbnRfcmVn Y2FjaGUgKCk7CisgICAgICBpbnQgcmVnbnVtID0gZ2RiYXJjaF9udW1fcmVn cyAoZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSk7CisgICAgICBpbnQg aTsKKworICAgICAgdGFyZ2V0X2ZldGNoX3JlZ2lzdGVycyAocmVnY2FjaGUs IC0xKTsKKyAgICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiA9IHhtYWxsb2MgKE1B WF9SRUdJU1RFUl9TSVpFICogcmVnbnVtKTsKKyAgICAgIGZvciAoaSA9IDA7 IGkgPCByZWdudW07IGkgKyspCisgICAgICAgIHJlZ2NhY2hlX3Jhd19jb2xs ZWN0IChyZWdjYWNoZSwgaSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiArIE1BWF9SRUdJU1RFUl9TSVpFICog aSk7CisKKyAgICAgIC8qIEdldCByZWNvcmRfY29yZV9zdGFydCBhbmQgcmVj b3JkX2NvcmVfZW5kLiAgKi8KKyAgICAgIGlmIChidWlsZF9zZWN0aW9uX3Rh YmxlIChjb3JlX2JmZCwgJnJlY29yZF9jb3JlX3N0YXJ0LCAmcmVjb3JkX2Nv cmVfZW5kKSkKKyAgICAgICAgZXJyb3IgKF8oIlwiJXNcIjogQ2FuJ3QgZmlu ZCBzZWN0aW9uczogJXMiKSwKKyAgICAgICAgICAgICAgIGJmZF9nZXRfZmls ZW5hbWUgKGNvcmVfYmZkKSwgYmZkX2Vycm1zZyAoYmZkX2dldF9lcnJvciAo KSkpOworICAgIH0KIAogICBwdXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOwog CkBAIC01ODgsMTAgKzY2NywyNiBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFt ZSwgaW50IGZyb21fdHR5KQogc3RhdGljIHZvaWQKIHJlY29yZF9jbG9zZSAo aW50IHF1aXR0aW5nKQogeworICBzdHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2Vu dHJ5ICplbnRyeTsKKwogICBpZiAocmVjb3JkX2RlYnVnKQogICAgIGZwcmlu dGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiBy ZWNvcmRfY2xvc2VcbiIpOwogCiAgIHJlY29yZF9saXN0X3JlbGVhc2UgKHJl Y29yZF9saXN0KTsKKworICAvKiBSZWxlYXNlIHJlY29yZF9jb3JlX3JlZ2J1 Zi4gICovCisgIHhmcmVlIChyZWNvcmRfY29yZV9yZWdidWYpOworCisgIC8q IFJlbGVhc2UgcmVjb3JkX2NvcmVfYnVmX2xpc3QuICAqLworICBpZiAocmVj b3JkX2NvcmVfYnVmX2xpc3QpCisgICAgeworICAgICAgZm9yIChlbnRyeSA9 IHJlY29yZF9jb3JlX2J1Zl9saXN0LT5wcmV2OyBlbnRyeTsgZW50cnkgPSBl bnRyeS0+cHJldikKKyAgICAgICAgeworICAgICAgICAgIHhmcmVlIChyZWNv cmRfY29yZV9idWZfbGlzdCk7CisgICAgICAgICAgcmVjb3JkX2NvcmVfYnVm X2xpc3QgPSBlbnRyeTsKKyAgICAgICAgfQorICAgICAgcmVjb3JkX2NvcmVf YnVmX2xpc3QgPSBOVUxMOworICAgIH0KIH0KIAogc3RhdGljIGludCByZWNv cmRfcmVzdW1lX3N0ZXAgPSAwOwpAQCAtOTE1LDcgKzEwMTAsOSBAQCByZWNv cmRfa2lsbCAoc3RydWN0IHRhcmdldF9vcHMgKm9wcykKICAgICBmcHJpbnRm X3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVj b3JkX2tpbGxcbiIpOwogCiAgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfb3Bz KTsKLSAgdGFyZ2V0X2tpbGwgKCk7CisKKyAgaWYgKCFyZWNvcmRfY29yZSkK KyAgICB0YXJnZXRfa2lsbCAoKTsKIH0KIAogLyogUmVjb3JkIHJlZ2lzdGVy cyBjaGFuZ2UgKGJ5IHVzZXIgb3IgYnkgR0RCKSB0byBsaXN0IGFzIGFuIGlu c3RydWN0aW9uLiAgKi8KQEAgLTk1OSwxNSArMTA1Niw1OCBAQCByZWNvcmRf cmVnaXN0ZXJzX2NoYW5nZSAoc3RydWN0IHJlZ2NhY2hlCiAgIHJlY29yZF9s aXN0ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOwogCiAgIGlmIChyZWNvcmRf aW5zbl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNvcmRfaW5z bl9tYXhfbnVtKQotICAgIHJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3QgKCk7 CisgICAgcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNuICgpOwogICBl bHNlCiAgICAgcmVjb3JkX2luc25fbnVtKys7CiB9CiAKIHN0YXRpYyB2b2lk CityZWNvcmRfZmV0Y2hfcmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzLCBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLAorICAgICAgICAgICAg ICAgICAgICAgICAgaW50IHJlZ25vKQoreworICBpZiAocmVjb3JkX2NvcmUp CisgICAgeworICAgICAgaWYgKHJlZ25vIDwgMCkKKyAgICAgICAgeworICAg ICAgICAgIGludCBudW0gPSBnZGJhcmNoX251bV9yZWdzIChnZXRfcmVnY2Fj aGVfYXJjaCAocmVnY2FjaGUpKTsKKyAgICAgICAgICBpbnQgaTsKKworICAg ICAgICAgIGZvciAoaSA9IDA7IGkgPCBudW07IGkgKyspCisgICAgICAgICAg ICByZWdjYWNoZV9yYXdfc3VwcGx5IChyZWdjYWNoZSwgaSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiAr IE1BWF9SRUdJU1RFUl9TSVpFICogaSk7CisgICAgICAgIH0KKyAgICAgIGVs c2UKKyAgICAgICAgcmVnY2FjaGVfcmF3X3N1cHBseSAocmVnY2FjaGUsIHJl Z25vLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfY29y ZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0laRSAqIHJlZ25vKTsKKyAgICB9 CisgIGVsc2UKKyAgICByZWNvcmRfYmVuZWF0aF90b19mZXRjaF9yZWdpc3Rl cnMgKHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHMsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWdjYWNo ZSwgcmVnbm8pOworfQorCitzdGF0aWMgdm9pZAorcmVjb3JkX3ByZXBhcmVf dG9fc3RvcmUgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUpCit7CisgIGlm ICghcmVjb3JkX2NvcmUpCisgICAgcmVjb3JkX2JlbmVhdGhfdG9fcHJlcGFy ZV90b19zdG9yZSAocmVnY2FjaGUpOworfQorCitzdGF0aWMgdm9pZAogcmVj b3JkX3N0b3JlX3JlZ2lzdGVycyAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywg c3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwKICAgICAgICAgICAgICAgICAg ICAgICAgIGludCByZWdubykKIHsKKyAgaWYgKHJlY29yZF9jb3JlKQorICAg IHsKKyAgICAgIC8qIERlYnVnIHdpdGggY29yZS4gICovCisgICAgICBpZiAo cmVjb3JkX2dkYl9vcGVyYXRpb25fZGlzYWJsZSkKKyAgICAgICAgcmVnY2Fj aGVfcmF3X2NvbGxlY3QgKHJlZ2NhY2hlLCByZWdubywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiArIE1BWF9S RUdJU1RFUl9TSVpFICogcmVnbm8pOworICAgICAgZWxzZQorICAgICAgICBl cnJvciAoXygiWW91IGNhbid0IGRvIHRoYXQgd2l0aG91dCBhIHByb2Nlc3Mg dG8gZGVidWcuIikpOworCisgICAgICByZXR1cm47CisgICAgfQorCiAgIGlm ICghcmVjb3JkX2dkYl9vcGVyYXRpb25fZGlzYWJsZSkKICAgICB7CiAgICAg ICBpZiAoUkVDT1JEX0lTX1JFUExBWSkKQEAgLTEwMTQsNiArMTE1NCw3IEBA IHJlY29yZF9zdG9yZV9yZWdpc3RlcnMgKHN0cnVjdCB0YXJnZXRfb3AKIAog ICAgICAgcmVjb3JkX3JlZ2lzdGVyc19jaGFuZ2UgKHJlZ2NhY2hlLCByZWdu byk7CiAgICAgfQorCiAgIHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lz dGVycyAocmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzX29wcywK ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWdjYWNo ZSwgcmVnbm8pOwogfQpAQCAtMTAyOSw3ICsxMTcwLDcgQEAgcmVjb3JkX3hm ZXJfcGFydGlhbCAoc3RydWN0IHRhcmdldF9vcHMgKgogewogICBpZiAoIXJl Y29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGUKICAgICAgICYmIChvYmplY3Qg PT0gVEFSR0VUX09CSkVDVF9NRU1PUlkKLQkgIHx8IG9iamVjdCA9PSBUQVJH RVRfT0JKRUNUX1JBV19NRU1PUlkpICYmIHdyaXRlYnVmKQorCSAgfHwgb2Jq ZWN0ID09IFRBUkdFVF9PQkpFQ1RfUkFXX01FTU9SWSkgJiYgd3JpdGVidWYg JiYgIXJlY29yZF9jb3JlKQogICAgIHsKICAgICAgIGlmIChSRUNPUkRfSVNf UkVQTEFZKQogCXsKQEAgLTEwNzMsMTEgKzEyMTQsOTEgQEAgcmVjb3JkX3hm ZXJfcGFydGlhbCAoc3RydWN0IHRhcmdldF9vcHMgKgogICAgICAgcmVjb3Jk X2xpc3QgPSByZWNvcmRfYXJjaF9saXN0X3RhaWw7CiAKICAgICAgIGlmIChy ZWNvcmRfaW5zbl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNv cmRfaW5zbl9tYXhfbnVtKQotCXJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3Qg KCk7CisJcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNuICgpOwogICAg ICAgZWxzZQogCXJlY29yZF9pbnNuX251bSsrOwogICAgIH0KIAorICAgaWYg KHJlY29yZF9jb3JlICYmIG9iamVjdCA9PSBUQVJHRVRfT0JKRUNUX01FTU9S WSkKKyAgICAgeworICAgICAgIC8qIERlYnVnIHdpdGggY29yZS4gICovCisg ICAgICAgaWYgKHJlY29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGUgfHwgIXdy aXRlYnVmKQorICAgICAgICAgeworICAgICAgICAgICBzdHJ1Y3QgdGFyZ2V0 X3NlY3Rpb24gKnA7CisgICAgICAgICAgIGZvciAocCA9IHJlY29yZF9jb3Jl X3N0YXJ0OyBwIDwgcmVjb3JkX2NvcmVfZW5kOyBwKyspCisgICAgICAgICAg ICAgeworICAgICAgICAgICAgICAgaWYgKG9mZnNldCA+PSBwLT5hZGRyKQor ICAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgc3RydWN0 IHJlY29yZF9jb3JlX2J1Zl9lbnRyeSAqZW50cnk7CisKKyAgICAgICAgICAg ICAgICAgICBpZiAob2Zmc2V0ID49IHAtPmVuZGFkZHIpCisgICAgICAgICAg ICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgICAgICAgIGlm IChvZmZzZXQgKyBsZW4gPiBwLT5lbmRhZGRyKQorICAgICAgICAgICAgICAg ICAgICAgbGVuID0gcC0+ZW5kYWRkciAtIG9mZnNldDsKKworICAgICAgICAg ICAgICAgICAgIG9mZnNldCAtPSBwLT5hZGRyOworCisgICAgICAgICAgICAg ICAgICAgLyogUmVhZCByZWFkYnVmIG9yIHdyaXRlIHdyaXRlYnVmIHAsIG9m ZnNldCwgbGVuLiAgKi8KKyAgICAgICAgICAgICAgICAgICAvKiBDaGVjayBm bGFncy4gICovCisgICAgICAgICAgICAgICAgICAgaWYgKHAtPnRoZV9iZmRf c2VjdGlvbi0+ZmxhZ3MgJiBTRUNfQ09OU1RSVUNUT1IKKyAgICAgICAgICAg ICAgICAgICAgICAgfHwgKHAtPnRoZV9iZmRfc2VjdGlvbi0+ZmxhZ3MgJiBT RUNfSEFTX0NPTlRFTlRTKSA9PSAwKQorICAgICAgICAgICAgICAgICAgICAg eworICAgICAgICAgICAgICAgICAgICAgICBpZiAocmVhZGJ1ZikKKyAgICAg ICAgICAgICAgICAgICAgICAgICBtZW1zZXQgKHJlYWRidWYsIDAsIGxlbik7 CisgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBsZW47CisgICAgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgLyogR2V0IHJl Y29yZF9jb3JlX2J1Zl9lbnRyeS4gICovCisgICAgICAgICAgICAgICAgICAg Zm9yIChlbnRyeSA9IHJlY29yZF9jb3JlX2J1Zl9saXN0OyBlbnRyeTsKKyAg ICAgICAgICAgICAgICAgICAgICAgIGVudHJ5ID0gZW50cnktPnByZXYpCisg ICAgICAgICAgICAgICAgICAgICBpZiAoZW50cnktPnAgPT0gcCkKKyAgICAg ICAgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAg aWYgKHdyaXRlYnVmKQorICAgICAgICAgICAgICAgICAgICAgeworICAgICAg ICAgICAgICAgICAgICAgICBpZiAoIWVudHJ5KQorICAgICAgICAgICAgICAg ICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIEFk ZCBhIG5ldyBlbnRyeS4gICovCisgICAgICAgICAgICAgICAgICAgICAgICAg ICBlbnRyeQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICA9IChzdHJ1 Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5ICopCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB4bWFsbG9jCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIChzaXplb2YgKHN0cnVjdCByZWNvcmRfY29yZV9i dWZfZW50cnkpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5 LT5wID0gcDsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmICghYmZk X21hbGxvY19hbmRfZ2V0X3NlY3Rpb24gKHAtPmJmZCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHAtPnRoZV9iZmRfc2VjdGlvbiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZlbnRy eS0+YnVmKSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeworICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhmcmVlIChlbnRyeSk7Cisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIDA7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgIGVudHJ5LT5wcmV2ID0gcmVjb3JkX2NvcmVfYnVmX2xpc3Q7 CisgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfY29yZV9idWZf bGlzdCA9IGVudHJ5OworICAgICAgICAgICAgICAgICAgICAgICAgIH0KKwor ICAgICAgICAgICAgICAgICAgICAgICAgbWVtY3B5IChlbnRyeS0+YnVmICsg b2Zmc2V0LCB3cml0ZWJ1ZiwgKHNpemVfdCkgbGVuKTsKKyAgICAgICAgICAg ICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICBlbHNlCisgICAgICAg ICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgICAgIGlmICgh ZW50cnkpCisgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHJlY29y ZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIChyZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRp YWxfb3BzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBv YmplY3QsIGFubmV4LCByZWFkYnVmLCB3cml0ZWJ1ZiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgb2Zmc2V0LCBsZW4pOworCisgICAg ICAgICAgICAgICAgICAgICAgIG1lbWNweSAocmVhZGJ1ZiwgZW50cnktPmJ1 ZiArIG9mZnNldCwgKHNpemVfdCkgbGVuKTsKKyAgICAgICAgICAgICAgICAg ICAgIH0KKworICAgICAgICAgICAgICAgICAgIHJldHVybiBsZW47CisgICAg ICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICB9CisKKyAgICAgICAgICAg cmV0dXJuIDA7CisgICAgICAgICB9CisgICAgICAgZWxzZQorICAgICAgICAg ZXJyb3IgKF8oIllvdSBjYW4ndCBkbyB0aGF0IHdpdGhvdXQgYSBwcm9jZXNz IHRvIGRlYnVnLiIpKTsKKworICAgICAgIHJldHVybiAwOworICAgICB9CisK ICAgcmV0dXJuIHJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCAocmVj b3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywKICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0LCBhbm5leCwg cmVhZGJ1Ziwgd3JpdGVidWYsCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIG9mZnNldCwgbGVuKTsKQEAgLTExMjcsNiArMTM0 OCwxNSBAQCByZWNvcmRfY2FuX2V4ZWN1dGVfcmV2ZXJzZSAodm9pZCkKICAg cmV0dXJuIDE7CiB9CiAKK2ludAorcmVjb3JkX2hhc19leGVjdXRpb24gKHN0 cnVjdCB0YXJnZXRfb3BzICpvcHMpCit7CisgIGlmIChyZWNvcmRfY29yZSkK KyAgICByZXR1cm4gMTsKKworICByZXR1cm4gcmVjb3JkX2JlbmVhdGhfdG9f aGFzX2V4ZWN1dGlvbiAob3BzKTsKK30KKwogc3RhdGljIHZvaWQKIGluaXRf cmVjb3JkX29wcyAodm9pZCkKIHsKQEAgLTExNDMsMTEgKzEzNzMsMTQgQEAg aW5pdF9yZWNvcmRfb3BzICh2b2lkKQogICByZWNvcmRfb3BzLnRvX21vdXJu X2luZmVyaW9yID0gcmVjb3JkX21vdXJuX2luZmVyaW9yOwogICByZWNvcmRf b3BzLnRvX2tpbGwgPSByZWNvcmRfa2lsbDsKICAgcmVjb3JkX29wcy50b19j cmVhdGVfaW5mZXJpb3IgPSBmaW5kX2RlZmF1bHRfY3JlYXRlX2luZmVyaW9y OworICByZWNvcmRfb3BzLnRvX2ZldGNoX3JlZ2lzdGVycyA9IHJlY29yZF9m ZXRjaF9yZWdpc3RlcnM7CisgIHJlY29yZF9vcHMudG9fcHJlcGFyZV90b19z dG9yZSA9IHJlY29yZF9wcmVwYXJlX3RvX3N0b3JlOwogICByZWNvcmRfb3Bz LnRvX3N0b3JlX3JlZ2lzdGVycyA9IHJlY29yZF9zdG9yZV9yZWdpc3RlcnM7 CiAgIHJlY29yZF9vcHMudG9feGZlcl9wYXJ0aWFsID0gcmVjb3JkX3hmZXJf cGFydGlhbDsKICAgcmVjb3JkX29wcy50b19pbnNlcnRfYnJlYWtwb2ludCA9 IHJlY29yZF9pbnNlcnRfYnJlYWtwb2ludDsKICAgcmVjb3JkX29wcy50b19y ZW1vdmVfYnJlYWtwb2ludCA9IHJlY29yZF9yZW1vdmVfYnJlYWtwb2ludDsK ICAgcmVjb3JkX29wcy50b19jYW5fZXhlY3V0ZV9yZXZlcnNlID0gcmVjb3Jk X2Nhbl9leGVjdXRlX3JldmVyc2U7CisgIHJlY29yZF9vcHMudG9faGFzX2V4 ZWN1dGlvbiA9IHJlY29yZF9oYXNfZXhlY3V0aW9uOwogICByZWNvcmRfb3Bz LnRvX3N0cmF0dW0gPSByZWNvcmRfc3RyYXR1bTsKICAgcmVjb3JkX29wcy50 b19tYWdpYyA9IE9QU19NQUdJQzsKIH0KQEAgLTExNjgsNiArMTQwMSwzMDAg QEAgY21kX3JlY29yZF9zdGFydCAoY2hhciAqYXJncywgaW50IGZyb21fdAog ICBleGVjdXRlX2NvbW1hbmQgKCJ0YXJnZXQgcmVjb3JkIiwgZnJvbV90dHkp OwogfQogCitzdGF0aWMgdm9pZAorY21kX3JlY29yZF9mZF9jbGVhbnVwcyAo dm9pZCAqcmVjZmRwKQoreworICBpbnQgcmVjZmQgPSAqKGludCAqKSByZWNm ZHA7CisgIGNsb3NlIChyZWNmZCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9p ZAorcmVjb3JkX3JlYWRfZHVtcCAoY2hhciAqcmVjZmlsZW5hbWUsIGludCBm aWxkZXMsIHZvaWQgKmJ1Ziwgc2l6ZV90IG5ieXRlKQoreworICBpZiAocmVh ZCAoZmlsZGVzLCBidWYsIG5ieXRlKSAhPSBuYnl0ZSkKKyAgICBlcnJvciAo XygiRmFpbGVkIHRvIHJlYWQgZHVtcCBvZiBleGVjdXRpb24gcmVjb3JkcyBp biAnJXMnLiIpLAorICAgICAgICAgICByZWNmaWxlbmFtZSk7Cit9CisKK3N0 YXRpYyBpbmxpbmUgdm9pZAorcmVjb3JkX3dyaXRlX2R1bXAgKGNoYXIgKnJl Y2ZpbGVuYW1lLCBpbnQgZmlsZGVzLCBjb25zdCB2b2lkICpidWYsCisgICAg ICAgICAgICAgICAgICAgc2l6ZV90IG5ieXRlKQoreworICBpZiAod3JpdGUg KGZpbGRlcywgYnVmLCBuYnl0ZSkgIT0gbmJ5dGUpCisgICAgZXJyb3IgKF8o IkZhaWxlZCB0byB3cml0ZSBkdW1wIG9mIGV4ZWN1dGlvbiByZWNvcmRzIHRv ICclcycuIiksCisgICAgICAgICAgIHJlY2ZpbGVuYW1lKTsKK30KKworLyog RHVtcCB0aGUgZXhlY3V0aW9uIGxvZyB0byBhIGZpbGUuICAqLworCitzdGF0 aWMgdm9pZAorY21kX3JlY29yZF9kdW1wIChjaGFyICphcmdzLCBpbnQgZnJv bV90dHkpCit7CisgIGNoYXIgKnJlY2ZpbGVuYW1lLCByZWNmaWxlbmFtZV9i dWZmZXJbNDBdOworICBpbnQgcmVjZmQ7CisgIHN0cnVjdCByZWNvcmRfZW50 cnkgKmN1cl9yZWNvcmRfbGlzdDsKKyAgdWludDMyX3QgbWFnaWM7CisgIHN0 cnVjdCByZWdjYWNoZSAqcmVnY2FjaGU7CisgIHN0cnVjdCBnZGJhcmNoICpn ZGJhcmNoOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzOworICBz dHJ1Y3QgY2xlYW51cCAqc2V0X2NsZWFudXBzOworCisgIGlmIChjdXJyZW50 X3RhcmdldC50b19zdHJhdHVtICE9IHJlY29yZF9zdHJhdHVtKQorICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZCBpcyBub3Qgc3RhcnRlZC5cbiIpKTsK KworICBpZiAoYXJncyAmJiAqYXJncykKKyAgICByZWNmaWxlbmFtZSA9IGFy Z3M7CisgIGVsc2UKKyAgICB7CisgICAgICAvKiBEZWZhdWx0IGNvcmVmaWxl IG5hbWUgaXMgImdkYl9yZWNvcmQuUElEIi4gICovCisgICAgICBzcHJpbnRm IChyZWNmaWxlbmFtZV9idWZmZXIsICJnZGJfcmVjb3JkLiVkIiwgUElER0VU IChpbmZlcmlvcl9wdGlkKSk7CisgICAgICByZWNmaWxlbmFtZSA9IHJlY2Zp bGVuYW1lX2J1ZmZlcjsKKyAgICB9CisKKyAgLyogT3BlbiB0aGUgZHVtcCBm aWxlLiAgKi8KKyAgcmVjZmQgPSBvcGVuIChyZWNmaWxlbmFtZSwgT19XUk9O TFkgfCBPX0NSRUFUIHwgT19UUlVOQyB8IE9fQklOQVJZLAorICAgICAgICAg ICAgICAgIFNfSVJVU1IgfCBTX0lXVVNSKTsKKyAgaWYgKHJlY2ZkIDwgMCkK KyAgICBlcnJvciAoXygiRmFpbGVkIHRvIG9wZW4gJyVzJyBmb3IgZHVtcCBl eGVjdXRpb24gcmVjb3JkczogJXMiKSwKKyAgICAgICAgICAgcmVjZmlsZW5h bWUsIHN0cmVycm9yIChlcnJubykpOworICBvbGRfY2xlYW51cHMgPSBtYWtl X2NsZWFudXAgKGNtZF9yZWNvcmRfZmRfY2xlYW51cHMsICZyZWNmZCk7CisK KyAgLyogU2F2ZSB0aGUgY3VycmVudCByZWNvcmQgZW50cnkgdG8gImN1cl9y ZWNvcmRfbGlzdCIuICAqLworICBjdXJfcmVjb3JkX2xpc3QgPSByZWNvcmRf bGlzdDsKKworICAvKiBHZXQgdGhlIHZhbHVlcyBvZiByZWdjYWNoZSBhbmQg Z2RiYXJjaC4gICovCisgIHJlZ2NhY2hlID0gZ2V0X2N1cnJlbnRfcmVnY2Fj aGUgKCk7CisgIGdkYmFyY2ggPSBnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2Fj aGUpOworCisgIC8qIERpc2FibGUgdGhlIEdEQiBvcGVyYXRpb24gcmVjb3Jk LiAgKi8KKyAgc2V0X2NsZWFudXBzID0gcmVjb3JkX2dkYl9vcGVyYXRpb25f ZGlzYWJsZV9zZXQgKCk7CisKKyAgLyogV3JpdGUgdGhlIG1hZ2ljIGNvZGUu ICAqLworICBtYWdpYyA9IFJFQ09SRF9GSUxFX01BR0lDOworICByZWNvcmRf d3JpdGVfZHVtcCAocmVjZmlsZW5hbWUsIHJlY2ZkLCAmbWFnaWMsIDQpOwor CisgIC8qIFJldmVyc2UgZXhlY3V0ZSB0byB0aGUgYmVnaW4gb2YgcmVjb3Jk IGxpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBDaGVj ayBmb3IgYmVnaW5uaW5nIGFuZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAgIGlm IChyZWNvcmRfbGlzdCA9PSAmcmVjb3JkX2ZpcnN0KQorICAgICAgICBicmVh azsKKworICAgICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJh cmNoLCByZWNvcmRfbGlzdCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+ cHJldikKKyAgICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJl djsKKyAgICB9CisKKyAgLyogRHVtcCB0aGUgZW50cmllcyB0byByZWNmZCBh bmQgZm9yd2FyZCBleGVjdXRlIHRvIHRoZSBlbmQgb2YKKyAgICAgcmVjb3Jk IGxpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBEdW1w IGVudHJ5LiAgKi8KKyAgICAgIGlmIChyZWNvcmRfbGlzdCAhPSAmcmVjb3Jk X2ZpcnN0KQorICAgICAgICB7CisgICAgICAgICAgdWludDhfdCB0bXB1ODsK KyAgICAgICAgICB1aW50NjRfdCB0bXB1NjQ7CisKKyAgICAgICAgICB0bXB1 OCA9IHJlY29yZF9saXN0LT50eXBlOworICAgICAgICAgIHJlY29yZF93cml0 ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsICZ0bXB1OCwgMSk7CisKKyAg ICAgICAgICBzd2l0Y2ggKHJlY29yZF9saXN0LT50eXBlKQorICAgICAgICAg ICAgeworICAgICAgICAgICAgY2FzZSByZWNvcmRfcmVnOiAvKiByZWcgKi8K KyAgICAgICAgICAgICAgdG1wdTY0ID0gcmVjb3JkX2xpc3QtPnUucmVnLm51 bTsKKyNpZiAoQllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAg ICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyNlbmRpZgor ICAgICAgICAgICAgICByZWNvcmRfd3JpdGVfZHVtcCAocmVjZmlsZW5hbWUs IHJlY2ZkLCAmdG1wdTY0LCA4KTsKKworICAgICAgICAgICAgICByZWNvcmRf d3JpdGVfZHVtcCAocmVjZmlsZW5hbWUsIHJlY2ZkLCByZWNvcmRfbGlzdC0+ dS5yZWcudmFsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg TUFYX1JFR0lTVEVSX1NJWkUpOworICAgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgICAgIGNhc2UgcmVjb3JkX21lbTogLyogbWVtICovCisgICAgICAg ICAgICAgIGlmICghcmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3Rf YWNjZXNzaWJsZSkKKyAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAg ICAgICB0bXB1NjQgPSByZWNvcmRfbGlzdC0+dS5tZW0uYWRkcjsKKyNpZiAo QllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAgICAgICAgICAg ICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisjZW5kaWYKKyAgICAg ICAgICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwg cmVjZmQsICZ0bXB1NjQsIDgpOworCisgICAgICAgICAgICAgICAgICB0bXB1 NjQgPSByZWNvcmRfbGlzdC0+dS5tZW0ubGVuOworI2lmIChCWVRFX09SREVS ID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAgICAgICAgICB0bXB1NjQg PSBic3dhcF82NCAodG1wdTY0KTsKKyNlbmRpZgorICAgICAgICAgICAgICAg ICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1lLCByZWNmZCwgJnRt cHU2NCwgOCk7CisKKyAgICAgICAgICAgICAgICAgIHJlY29yZF93cml0ZV9k dW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlz dC0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAg IC8qIEV4ZWN1dGUgZW50cnkuICAqLworICAgICAgcmVjb3JkX2V4ZWNfZW50 cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNvcmRfbGlzdCk7CisKKyAgICAg IGlmIChyZWNvcmRfbGlzdC0+bmV4dCkKKyAgICAgICAgcmVjb3JkX2xpc3Qg PSByZWNvcmRfbGlzdC0+bmV4dDsKKyAgICAgIGVsc2UKKyAgICAgICAgYnJl YWs7CisgICAgfQorCisgIC8qIFJldmVyc2UgZXhlY3V0ZSB0byBjdXJfcmVj b3JkX2xpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBD aGVjayBmb3IgYmVnaW5uaW5nIGFuZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAg IGlmIChyZWNvcmRfbGlzdCA9PSBjdXJfcmVjb3JkX2xpc3QpCisgICAgICAg IGJyZWFrOworCisgICAgICByZWNvcmRfZXhlY19lbnRyeSAocmVnY2FjaGUs IGdkYmFyY2gsIHJlY29yZF9saXN0KTsKKworICAgICAgaWYgKHJlY29yZF9s aXN0LT5wcmV2KQorICAgICAgICByZWNvcmRfbGlzdCA9IHJlY29yZF9saXN0 LT5wcmV2OworICAgIH0KKworICBkb19jbGVhbnVwcyAoc2V0X2NsZWFudXBz KTsKKyAgZG9fY2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgLyogU3Vj Y2VlZGVkLiAgKi8KKyAgZnByaW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZG91dCwg XygiU2F2ZWQgZHVtcCBvZiBleGVjdXRpb24gIgorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJyZWNvcmRzIHRvIGAlcycuXG4iKSwKKyAg ICAgICAgICAgICAgICAgICAgcmVjZmlsZW5hbWUpOworfQorCisvKiBMb2Fk IHRoZSBleGVjdXRpb24gbG9nIGZyb20gYSBmaWxlLiAgKi8KKworc3RhdGlj IHZvaWQKK2NtZF9yZWNvcmRfbG9hZCAoY2hhciAqYXJncywgaW50IGZyb21f dHR5KQoreworICBpbnQgcmVjZmQ7CisgIHVpbnQzMl90IG1hZ2ljOworICBz dHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzOworICBzdHJ1Y3QgY2xlYW51 cCAqb2xkX2NsZWFudXBzMjsKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVj OworICBpbnQgaW5zbl9udW1iZXIgPSAwOworCisgIGlmIChjdXJyZW50X3Rh cmdldC50b19zdHJhdHVtICE9IHJlY29yZF9zdHJhdHVtKQorICAgIHsKKyAg ICAgIGNtZF9yZWNvcmRfc3RhcnQgKE5VTEwsIGZyb21fdHR5KTsKKyAgICAg IHByaW50Zl91bmZpbHRlcmVkIChfKCJBdXRvIHN0YXJ0IHByb2Nlc3MgcmVj b3JkLlxuIikpOworICAgIH0KKworICBpZiAoIWFyZ3MgfHwgKGFyZ3MgJiYg ISphcmdzKSkKKyAgICBlcnJvciAoXygiQXJndW1lbnQgZm9yIGZpbGVuYW1l IHJlcXVpcmVkLlxuIikpOworCisgIC8qIE9wZW4gdGhlIGxvYWQgZmlsZS4g ICovCisgIHJlY2ZkID0gb3BlbiAoYXJncywgT19SRE9OTFkgfCBPX0JJTkFS WSk7CisgIGlmIChyZWNmZCA8IDApCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0 byBvcGVuICclcycgZm9yIGxvYWRpbmcgZXhlY3V0aW9uIHJlY29yZHM6ICVz IiksCisgICAgICAgICAgIGFyZ3MsIHN0cmVycm9yIChlcnJubykpOworICBv bGRfY2xlYW51cHMgPSBtYWtlX2NsZWFudXAgKGNtZF9yZWNvcmRfZmRfY2xl YW51cHMsICZyZWNmZCk7CisKKyAgLyogQ2hlY2sgdGhlIG1hZ2ljIGNvZGUu ICAqLworICByZWNvcmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwgJm1hZ2lj LCA0KTsKKyAgaWYgKG1hZ2ljICE9IFJFQ09SRF9GSUxFX01BR0lDKQorICAg IGVycm9yIChfKCInJXMnIGlzIG5vdCBhIHZhbGlkIGR1bXAgb2YgZXhlY3V0 aW9uIHJlY29yZHMuIiksIGFyZ3MpOworCisgIC8qIExvYWQgdGhlIGVudHJp ZXMgaW4gcmVjZmQgdG8gdGhlIHJlY29yZF9hcmNoX2xpc3RfaGVhZCBhbmQK KyAgICAgcmVjb3JkX2FyY2hfbGlzdF90YWlsLiAgKi8KKyAgcmVjb3JkX2Fy Y2hfbGlzdF9oZWFkID0gTlVMTDsKKyAgcmVjb3JkX2FyY2hfbGlzdF90YWls ID0gTlVMTDsKKyAgb2xkX2NsZWFudXBzMiA9IG1ha2VfY2xlYW51cCAocmVj b3JkX2FyY2hfbGlzdF9jbGVhbnVwcywgMCk7CisKKyAgd2hpbGUgKDEpCisg ICAgeworICAgICAgaW50IHJldDsKKyAgICAgIHVpbnQ4X3QgdG1wdTg7Cisg ICAgICB1aW50NjRfdCB0bXB1NjQ7CisKKyAgICAgIHJldCA9IHJlYWQgKHJl Y2ZkLCAmdG1wdTgsIDEpOworICAgICAgaWYgKHJldCA8IDApCisgICAgICAg IGVycm9yIChfKCJGYWlsZWQgdG8gcmVhZCBkdW1wIG9mIGV4ZWN1dGlvbiBy ZWNvcmRzIGluICclcycuIiksIGFyZ3MpOworICAgICAgaWYgKHJldCA9PSAw KQorICAgICAgICBicmVhazsKKworICAgICAgc3dpdGNoICh0bXB1OCkKKyAg ICAgICAgeworICAgICAgICBjYXNlIHJlY29yZF9yZWc6IC8qIHJlZyAqLwor ICAgICAgICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxs b2MgKHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkpOworICAgICAgICAg IHJlYy0+dS5yZWcudmFsID0gKGdkYl9ieXRlICopIHhtYWxsb2MgKE1BWF9S RUdJU1RFUl9TSVpFKTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOwor ICAgICAgICAgIHJlYy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50 eXBlID0gcmVjb3JkX3JlZzsKKyAgICAgICAgICAvKiBHZXQgbnVtLiAgKi8K KyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwgJnRt cHU2NCwgOCk7CisjaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikK KyAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyNlbmRp ZgorICAgICAgICAgIHJlYy0+dS5yZWcubnVtID0gdG1wdTY0OworICAgICAg ICAgIC8qIEdldCB2YWwuICAqLworICAgICAgICAgIHJlY29yZF9yZWFkX2R1 bXAgKGFyZ3MsIHJlY2ZkLCByZWMtPnUucmVnLnZhbCwgTUFYX1JFR0lTVEVS X1NJWkUpOworICAgICAgICAgIHJlY29yZF9hcmNoX2xpc3RfYWRkIChyZWMp OworICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIHJlY29yZF9tZW06 IC8qIG1lbSAqLworICAgICAgICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2Vu dHJ5ICopIHhtYWxsb2MgKHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkp OworICAgICAgICAgIHJlYy0+cHJldiA9IE5VTEw7CisgICAgICAgICAgcmVj LT5uZXh0ID0gTlVMTDsKKyAgICAgICAgICByZWMtPnR5cGUgPSByZWNvcmRf bWVtOworICAgICAgICAgIC8qIEdldCBhZGRyLiAgKi8KKyAgICAgICAgICBy ZWNvcmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwgJnRtcHU2NCwgOCk7Cisj aWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICB0 bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyNlbmRpZgorICAgICAgICAg IHJlYy0+dS5tZW0uYWRkciA9IHRtcHU2NDsKKyAgICAgICAgICAvKiBHZXQg bGVuLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChhcmdzLCBy ZWNmZCwgJnRtcHU2NCwgOCk7CisjaWYgKEJZVEVfT1JERVIgPT0gTElUVExF X0VORElBTikKKyAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0 KTsKKyNlbmRpZgorICAgICAgICAgIHJlYy0+dS5tZW0ubGVuID0gdG1wdTY0 OworICAgICAgICAgIHJlYy0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3Np YmxlID0gMDsKKyAgICAgICAgICByZWMtPnUubWVtLnZhbCA9IChnZGJfYnl0 ZSAqKSB4bWFsbG9jIChyZWMtPnUubWVtLmxlbik7CisgICAgICAgICAgLyog R2V0IHZhbC4gICovCisgICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAoYXJn cywgcmVjZmQsIHJlYy0+dS5tZW0udmFsLCByZWMtPnUubWVtLmxlbik7Cisg ICAgICAgICAgcmVjb3JkX2FyY2hfbGlzdF9hZGQgKHJlYyk7CisgICAgICAg ICAgYnJlYWs7CisKKyAgICAgICAgY2FzZSByZWNvcmRfZW5kOiAvKiBlbmQg Ki8KKyAgICAgICAgICByZWMgPSAoc3RydWN0IHJlY29yZF9lbnRyeSAqKSB4 bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRfZW50cnkpKTsKKyAgICAg ICAgICByZWMtPnByZXYgPSBOVUxMOworICAgICAgICAgIHJlYy0+bmV4dCA9 IE5VTEw7CisgICAgICAgICAgcmVjLT50eXBlID0gcmVjb3JkX2VuZDsKKyAg ICAgICAgICByZWNvcmRfYXJjaF9saXN0X2FkZCAocmVjKTsKKyAgICAgICAg ICBpbnNuX251bWJlciArKzsKKyAgICAgICAgICBicmVhazsKKworICAgICAg ICBkZWZhdWx0OgorICAgICAgICAgIGVycm9yIChfKCJGb3JtYXQgb2YgJyVz JyBpcyBub3QgcmlnaHQuIiksIGFyZ3MpOworICAgICAgICAgIGJyZWFrOwor ICAgICAgICB9CisgICAgfQorCisgIGRpc2NhcmRfY2xlYW51cHMgKG9sZF9j bGVhbnVwczIpOworCisgIC8qIEFkZCByZWNvcmRfYXJjaF9saXN0X2hlYWQg dG8gdGhlIGVuZCBvZiByZWNvcmQgbGlzdC4gICovCisgIGZvciAocmVjID0g cmVjb3JkX2xpc3Q7IHJlYy0+bmV4dDsgcmVjID0gcmVjLT5uZXh0KTsKKyAg cmVjLT5uZXh0ID0gcmVjb3JkX2FyY2hfbGlzdF9oZWFkOworICByZWNvcmRf YXJjaF9saXN0X2hlYWQtPnByZXYgPSByZWM7CisKKyAgLyogVXBkYXRlIHJl Y29yZF9pbnNuX251bSBhbmQgcmVjb3JkX2luc25fbWF4X251bS4gICovCisg IHJlY29yZF9pbnNuX251bSArPSBpbnNuX251bWJlcjsKKyAgaWYgKHJlY29y ZF9pbnNuX251bSA+IHJlY29yZF9pbnNuX21heF9udW0pCisgICAgeworICAg ICAgcmVjb3JkX2luc25fbWF4X251bSA9IHJlY29yZF9pbnNuX251bTsKKyAg ICAgIHdhcm5pbmcgKF8oIkF1dG8gaW5jcmVhc2UgcmVjb3JkL3JlcGxheSBi dWZmZXIgbGltaXQgdG8gJWQuIiksCisgICAgICAgICAgICAgICByZWNvcmRf aW5zbl9tYXhfbnVtKTsKKyAgICB9CisKKyAgZG9fY2xlYW51cHMgKG9sZF9j bGVhbnVwcyk7CisKKyAgLyogU3VjY2VlZGVkLiAgKi8KKyAgZnByaW50Zl9m aWx0ZXJlZCAoZ2RiX3N0ZG91dCwgIkxvYWRlZCByZWNmaWxlICVzLlxuIiwg YXJncyk7Cit9CisKIC8qIFRydW5jYXRlIHRoZSByZWNvcmQgbG9nIGZyb20g dGhlIHByZXNlbnQgcG9pbnQKICAgIG9mIHJlcGxheSB1bnRpbCB0aGUgZW5k LiAgKi8KIApAQCAtMTIxOCw3ICsxNzQ1LDcgQEAgc2V0X3JlY29yZF9pbnNu X21heF9udW0gKGNoYXIgKmFyZ3MsIGludAogCQkgICAgICAgICAgICJ0aGUg Zmlyc3Qgb25lcz9cbiIpKTsKIAogICAgICAgd2hpbGUgKHJlY29yZF9pbnNu X251bSA+IHJlY29yZF9pbnNuX21heF9udW0pCi0JcmVjb3JkX2xpc3RfcmVs ZWFzZV9maXJzdCAoKTsKKwlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0X2lu c24gKCk7CiAgICAgfQogfQogCkBAIC0xMjU4LDYgKzE3ODUsOCBAQCBpbmZv X3JlY29yZF9jb21tYW5kIChjaGFyICphcmdzLCBpbnQgZnJvCiB2b2lkCiBf aW5pdGlhbGl6ZV9yZWNvcmQgKHZvaWQpCiB7CisgIHN0cnVjdCBjbWRfbGlz dF9lbGVtZW50ICpjOworCiAgIC8qIEluaXQgcmVjb3JkX2ZpcnN0LiAgKi8K ICAgcmVjb3JkX2ZpcnN0LnByZXYgPSBOVUxMOwogICByZWNvcmRfZmlyc3Qu bmV4dCA9IE5VTEw7CkBAIC0xMjkxLDYgKzE4MjAsMTYgQEAgX2luaXRpYWxp emVfcmVjb3JkICh2b2lkKQogCQkgICJpbmZvIHJlY29yZCAiLCAwLCAmaW5m b2xpc3QpOwogICBhZGRfYWxpYXNfY21kICgicmVjIiwgInJlY29yZCIsIGNs YXNzX29ic2N1cmUsIDEsICZpbmZvbGlzdCk7CiAKKyAgYyA9IGFkZF9jbWQg KCJkdW1wIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3JlY29yZF9kdW1wLAorCSAg ICAgICBfKCJEdW1wIHRoZSBleGVjdXRpb24gcmVjb3JkcyB0byBhIGZpbGUu XG5cCitBcmd1bWVudCBpcyBvcHRpb25hbCBmaWxlbmFtZS4gIERlZmF1bHQg ZmlsZW5hbWUgaXMgJ2dkYl9yZWNvcmQuPHByb2Nlc3NfaWQ+Jy4iKSwKKyAg ICAgICAgICAgICAgICZyZWNvcmRfY21kbGlzdCk7CisgIHNldF9jbWRfY29t cGxldGVyIChjLCBmaWxlbmFtZV9jb21wbGV0ZXIpOworICBjID0gYWRkX2Nt ZCAoImxvYWQiLCBjbGFzc19vYnNjdXJlLCBjbWRfcmVjb3JkX2xvYWQsCisJ ICAgICAgIF8oIkxvYWQgcHJldmlvdXNseSBkdW1wZWQgZXhlY3V0aW9uIHJl Y29yZHMgZnJvbSBcCithIGZpbGUgZ2l2ZW4gYXMgYXJndW1lbnQuIiksCisg ICAgICAgICAgICAgICAmcmVjb3JkX2NtZGxpc3QpOworICBzZXRfY21kX2Nv bXBsZXRlciAoYywgZmlsZW5hbWVfY29tcGxldGVyKTsKIAogICBhZGRfY21k ICgiZGVsZXRlIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3JlY29yZF9kZWxldGUs CiAJICAgXygiRGVsZXRlIHRoZSByZXN0IG9mIGV4ZWN1dGlvbiBsb2cgYW5k IHN0YXJ0IHJlY29yZGluZyBpdCBhbmV3LiIpLAo= --000e0cd215a41242f4047034f9e0 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_fxwotjef1 Content-length: 1290 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgIDE1ICsrKysrKysrKysrKysrKwog MSBmaWxlIGNoYW5nZWQsIDE1IGluc2VydGlvbnMoKykKCi0tLSBhL2RvYy9n ZGIudGV4aW5mbworKysgYi9kb2MvZ2RiLnRleGluZm8KQEAgLTUxOTAsNiAr NTE5MCwyMSBAQCBXaGVuIHJlY29yZCB0YXJnZXQgcnVucyBpbiByZXBsYXkg bW9kZSAoCiBzdWJzZXF1ZW50IGV4ZWN1dGlvbiBsb2cgYW5kIGJlZ2luIHRv IHJlY29yZCBhIG5ldyBleGVjdXRpb24gbG9nIHN0YXJ0aW5nCiBmcm9tIHRo ZSBjdXJyZW50IGFkZHJlc3MuICBUaGlzIG1lYW5zIHlvdSB3aWxsIGFiYW5k b24gdGhlIHByZXZpb3VzbHkKIHJlY29yZGVkIGBgZnV0dXJlJycgYW5kIGJl Z2luIHJlY29yZGluZyBhIG5ldyBgYGZ1dHVyZScnLgorCitAa2luZGV4IHJl Y29yZCBkdW1wCitAa2luZGV4IHJlYyBkdW1wCitAaXRlbSByZWNvcmQgZHVt cCBbQHZhcntmaWxlfV0KK0BpdGVteCByZWMgZHVtcCBbQHZhcntmaWxlfV0K K0R1bXAgdGhlIGV4ZWN1dGlvbiByZWNvcmRzIG9mIHRoZSBpbmZlcmlvciBw cm9jZXNzIHRvIGEgZmlsZS4gIFRoZSBvcHRpb25hbAorYXJndW1lbnQgQHZh cntmaWxlfSBzcGVjaWZpZXMgdGhlIGZpbGUgbmFtZSB3aGVyZSB0byBwdXQg dGhlIHJlY29yZCBkdW1wLgorSWYgbm90IHNwZWNpZmllZCwgdGhlIGZpbGUg bmFtZSBkZWZhdWx0cyB0byBAZmlsZXtnZGJfcmVjb3JkLkB2YXJ7cGlkfX0s IHdoZXJlCitAdmFye3BpZH0gaXMgaXMgdGhlIFBJRCBvZiB0aGUgaW5mZXJp b3IgcHJvY2Vzcy4KKworQGtpbmRleCByZWNvcmQgbG9hZAorQGtpbmRleCBy ZWMgbG9hZAorQGl0ZW0gcmVjb3JkIGxvYWQgQHZhcntmaWxlfQorQGl0ZW14 IHJlYyBkdW1wIEB2YXJ7ZmlsZX0KK0xvYWQgcHJldmlvdXNseS1kdW1wZWQg ZXhlY3V0aW9uIHJlY29yZHMgZnJvbSBAdmFye2ZpbGV9LgogQGVuZCB0YWJs ZQogCiAK --000e0cd215a41242f4047034f9e0--