From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 10324 invoked by alias); 5 Aug 2009 09:21:21 -0000 Received: (qmail 10302 invoked by uid 22791); 5 Aug 2009 09:21:14 -0000 X-SWARE-Spam-Status: No, hits=-1.7 required=5.0 tests=AWL,BAYES_00,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mail-yx0-f184.google.com (HELO mail-yx0-f184.google.com) (209.85.210.184) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 05 Aug 2009 09:21:04 +0000 Received: by yxe14 with SMTP id 14so6015469yxe.12 for ; Wed, 05 Aug 2009 02:21:01 -0700 (PDT) MIME-Version: 1.0 Received: by 10.231.12.5 with SMTP id v5mr2617787ibv.55.1249464061191; Wed, 05 Aug 2009 02:21:01 -0700 (PDT) In-Reply-To: <4A78935B.5030508@vmware.com> References: <4A749572.7030005@vmware.com> <4A75054C.9030304@vmware.com> <83ws5koinl.fsf@gnu.org> <83my6fo2pa.fsf@gnu.org> <4A78935B.5030508@vmware.com> From: Hui Zhu Date: Wed, 05 Aug 2009 09:21: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@sourceware.org" Content-Type: multipart/mixed; boundary=000325574c8686ea1804706185eb 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/msg00069.txt.bz2 --000325574c8686ea1804706185eb Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 37295 On Wed, Aug 5, 2009 at 04:00, Michael Snyder wrote: > Eli Zaretskii wrote: >>> >>> From: Hui Zhu >>> Date: Tue, 4 Aug 2009 10:07:11 +0800 >>> Cc: msnyder@vmware.com, gdb-patches@sourceware.org >>> >>>> By the way, does it make sense to make the dump file portable, so that >>>> another host that supports debugging the same target could then use >>>> it? >>>> >>> Yes, the dump file is portable like core file. >> >> Well, maybe I'm missing something important, but isn't the dump file a >> series of struct's defined as this: >> >> =A0 =A0struct record_entry >> =A0 =A0{ >> =A0 =A0 =A0struct record_entry *prev; >> =A0 =A0 =A0struct record_entry *next; >> =A0 =A0 =A0enum record_type type; >> =A0 =A0 =A0union >> =A0 =A0 =A0{ >> =A0 =A0 =A0 =A0/* reg */ >> =A0 =A0 =A0 =A0struct record_reg_entry reg; >> =A0 =A0 =A0 =A0/* mem */ >> =A0 =A0 =A0 =A0struct record_mem_entry mem; >> =A0 =A0 =A0} u; >> =A0 =A0}; >> >> ? =A0If so, then the dump file uses host's native pointers, so it is not >> portable to a different host. =A0Right? > > No. =A0If you look at the code that dumps the file (and I had > to add a bunch of printfs and stuff to figure it out), you'll > see that the dump file looks like this: > > 4 byte magic number > Series of the following: > 1) 1 byte tag (record_end), or > 2) 1 byte tag (record_rec) followed by > =A0 8 byte number (register id), followed by > =A0 MAX_REGISTER_SIZE byte value (register value): or > 3) 1 byte tag (record_mem) followed by > =A0 8 byte number (memory address) followed by > =A0 8 byte number (memory length) followed by > =A0 N byte buffer (memory value). > > If you look for the #if (BYTE_ORDER =3D=3D BIG_ENDIAN), this is > where Teawater is making the byte orders host-independent. > > I was going to mention the ifdefs eventually. =A0 ;-) > Cool. It's very clear. :) Thanks Michael. I make a new version patch to follow the cvs head. And removed the ifdef. Please help me review it. Thanks, Hui 2009-08-05 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): New function. (record_open): Add support for target core. (record_close): Add support for target core. (record_wait): Call function 'record_exec_entry'. (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 | 731 +++++++++++++++++++++++++++++++++++++++++++++++++++++++---= ----- 1 file changed, 640 insertions(+), 91 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. @@ -78,9 +86,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; @@ -103,6 +125,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 *, @@ -119,6 +149,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) @@ -169,7 +202,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; @@ -340,30 +373,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 +419,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,6 +449,91 @@ 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)) + { + if ((execution_direction =3D=3D EXEC_REVERSE && !record_c= ore) + || (execution_direction !=3D EXEC_REVERSE && record_c= ore)) + { + 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 + error (_("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)) + { + if ((execution_direction =3D=3D EXEC_REVERSE && !reco= rd_core) + || (execution_direction !=3D EXEC_REVERSE && record_core)) + { + 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 + error (_("Process record: error writing memory at " + "addr =3D %s len =3D %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + } + + memcpy (entry->u.mem.val, mem, entry->u.mem.len); + } + } + break; + } +} + static void record_open (char *name, int from_tty) { @@ -424,8 +542,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 " @@ -454,6 +577,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) @@ -468,6 +593,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; @@ -482,19 +612,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); @@ -507,10 +669,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; @@ -712,76 +890,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,7 +1012,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. = */ @@ -945,15 +1058,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) @@ -1000,6 +1156,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); } @@ -1015,7 +1172,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) { @@ -1059,11 +1216,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); @@ -1113,6 +1350,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) { @@ -1129,11 +1375,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; } @@ -1154,6 +1403,294 @@ 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); + 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); + 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); + 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); + 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); + 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); + 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. */ @@ -1204,7 +1741,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 (); } } @@ -1244,6 +1781,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; @@ -1277,6 +1816,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."), --000325574c8686ea1804706185eb 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_fxzuqn170 Content-length: 44722 LS0tCiByZWNvcmQuYyB8ICA3MzEgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgNjQwIGluc2VydGlvbnMoKyksIDkxIGRlbGV0aW9ucygt KQoKLS0tIGEvcmVjb3JkLmMKKysrIGIvcmVjb3JkLmMKQEAgLTIzLDE0ICsy MywyMiBAQAogI2luY2x1ZGUgImdkYnRocmVhZC5oIgogI2luY2x1ZGUgImV2 ZW50LXRvcC5oIgogI2luY2x1ZGUgImV4Y2VwdGlvbnMuaCIKKyNpbmNsdWRl ICJjb21wbGV0ZXIuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5j bHVkZSAiZ2RiY29yZS5oIgorI2luY2x1ZGUgImV4ZWMuaCIKICNpbmNsdWRl ICJyZWNvcmQuaCIKIAorI2luY2x1ZGUgPGJ5dGVzd2FwLmg+CiAjaW5jbHVk ZSA8c2lnbmFsLmg+CisjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgogCiAjZGVm aW5lIERFRkFVTFRfUkVDT1JEX0lOU05fTUFYX05VTQkyMDAwMDAKIAogI2Rl ZmluZSBSRUNPUkRfSVNfUkVQTEFZIFwKLSAgICAgKHJlY29yZF9saXN0LT5u ZXh0IHx8IGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQor ICAgICAocmVjb3JkX2xpc3QtPm5leHQgfHwgZXhlY3V0aW9uX2RpcmVjdGlv biA9PSBFWEVDX1JFVkVSU0UgfHwgcmVjb3JkX2NvcmUpCisKKyNkZWZpbmUg UkVDT1JEX0ZJTEVfTUFHSUMJaHRvbmwoMHgyMDA5MDcyNikKIAogLyogVGhl c2UgYXJlIHRoZSBjb3JlIHN0cnVjdCBvZiByZWNvcmQgZnVuY3Rpb24uCiAK QEAgLTc4LDkgKzg2LDIzIEBAIHN0cnVjdCByZWNvcmRfZW50cnkKICAgfSB1 OwogfTsKIAorc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeQoreworICBz dHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5ICpwcmV2OworICBzdHJ1Y3Qg dGFyZ2V0X3NlY3Rpb24gKnA7CisgIGJmZF9ieXRlICpidWY7Cit9OworCiAv KiBUaGlzIGlzIHRoZSBkZWJ1ZyBzd2l0Y2ggZm9yIHByb2Nlc3MgcmVjb3Jk LiAgKi8KIGludCByZWNvcmRfZGVidWcgPSAwOwogCisvKiBSZWNvcmQgd2l0 aCBjb3JlIHRhcmdldC4gICovCitzdGF0aWMgaW50IHJlY29yZF9jb3JlID0g MDsKK3N0YXRpYyBnZGJfYnl0ZSAqcmVjb3JkX2NvcmVfcmVnYnVmOworc3Rh dGljIHN0cnVjdCB0YXJnZXRfc2VjdGlvbiAqcmVjb3JkX2NvcmVfc3RhcnQ7 CitzdGF0aWMgc3RydWN0IHRhcmdldF9zZWN0aW9uICpyZWNvcmRfY29yZV9l bmQ7CitzdGF0aWMgc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeSAqcmVj b3JkX2NvcmVfYnVmX2xpc3QgPSBOVUxMOworCiAvKiBUaGVzZSBsaXN0IGlz IGZvciBleGVjdXRpb24gbG9nLiAgKi8KIHN0YXRpYyBzdHJ1Y3QgcmVjb3Jk X2VudHJ5IHJlY29yZF9maXJzdDsKIHN0YXRpYyBzdHJ1Y3QgcmVjb3JkX2Vu dHJ5ICpyZWNvcmRfbGlzdCA9ICZyZWNvcmRfZmlyc3Q7CkBAIC0xMDMsNiAr MTI1LDE0IEBAIHN0YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2Jl bmVhdGgKIHN0YXRpYyBwdGlkX3QgKCpyZWNvcmRfYmVuZWF0aF90b193YWl0 KSAoc3RydWN0IHRhcmdldF9vcHMgKiwgcHRpZF90LAogCQkJCQkgc3RydWN0 IHRhcmdldF93YWl0c3RhdHVzICosCiAJCQkJCSBpbnQpOworc3RhdGljIHN0 cnVjdCB0YXJnZXRfb3BzICpyZWNvcmRfYmVuZWF0aF90b19mZXRjaF9yZWdp c3RlcnNfb3BzOworc3RhdGljIHZvaWQgKCpyZWNvcmRfYmVuZWF0aF90b19m ZXRjaF9yZWdpc3RlcnMpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBz dHJ1Y3QgcmVnY2FjaGUgKiwKKwkJCQkJCSAgaW50IHJlZ25vKTsKK3N0YXRp YyBzdHJ1Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVf cmVnaXN0ZXJzX29wczsKK3N0YXRpYyB2b2lkICgqcmVjb3JkX2JlbmVhdGhf dG9fc3RvcmVfcmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMgKiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgc3RydWN0IHJlZ2NhY2hlICosCisJCQkJCQkgIGludCByZWdubyk7CiBz dGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRoX3RvX3N0 b3JlX3JlZ2lzdGVyc19vcHM7CiBzdGF0aWMgdm9pZCAoKnJlY29yZF9iZW5l YXRoX3RvX3N0b3JlX3JlZ2lzdGVycykgKHN0cnVjdCB0YXJnZXRfb3BzICos CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHN0cnVjdCByZWdjYWNoZSAqLApAQCAtMTE5LDYgKzE0OSw5IEBA IHN0YXRpYyBpbnQgKCpyZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnIKIAkJ CQkJCSAgIHN0cnVjdCBicF90YXJnZXRfaW5mbyAqKTsKIHN0YXRpYyBpbnQg KCpyZWNvcmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2ludCkgKHN0cnVj dCBnZGJhcmNoICosCiAJCQkJCQkgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8g Kik7CitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRo X3RvX2hhc19leGVjdXRpb25fb3BzOworc3RhdGljIGludCAoKnJlY29yZF9i ZW5lYXRoX3RvX2hhc19leGVjdXRpb24pIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzKTsKK3N0YXRpYyB2b2lkICgqcmVjb3JkX2JlbmVhdGhfdG9fcHJlcGFy ZV90b19zdG9yZSkgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUpOwogCiBz dGF0aWMgdm9pZAogcmVjb3JkX2xpc3RfcmVsZWFzZSAoc3RydWN0IHJlY29y ZF9lbnRyeSAqcmVjKQpAQCAtMTY5LDcgKzIwMiw3IEBAIHJlY29yZF9saXN0 X3JlbGVhc2VfbmV4dCAodm9pZCkKIH0KIAogc3RhdGljIHZvaWQKLXJlY29y ZF9saXN0X3JlbGVhc2VfZmlyc3QgKHZvaWQpCityZWNvcmRfbGlzdF9yZWxl YXNlX2ZpcnN0X2luc24gKHZvaWQpCiB7CiAgIHN0cnVjdCByZWNvcmRfZW50 cnkgKnRtcCA9IE5VTEw7CiAgIGVudW0gcmVjb3JkX3R5cGUgdHlwZTsKQEAg LTM0MCwzMCArMzczLDMwIEBAIHJlY29yZF9jaGVja19pbnNuX251bSAoaW50 IHNldF90ZXJtaW5hbCkKIAkgICAgICBpZiAocSkKIAkJcmVjb3JkX3N0b3Bf YXRfbGltaXQgPSAwOwogCSAgICAgIGVsc2UKLQkJZXJyb3IgKF8oIlByb2Nl c3MgcmVjb3JkOiBpbmZlcmlvciBwcm9ncmFtIHN0b3BwZWQuIikpOworCQll cnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IHN0b3BlZCBieSB1c2VyLiIpKTsK IAkgICAgfQogCX0KICAgICB9CiB9CiAKK3N0YXRpYyB2b2lkCityZWNvcmRf YXJjaF9saXN0X2NsZWFudXBzICh2b2lkICppZ25vcmUpCit7CisgIHJlY29y ZF9saXN0X3JlbGVhc2UgKHJlY29yZF9hcmNoX2xpc3RfdGFpbCk7Cit9CisK IC8qIEJlZm9yZSBpbmZlcmlvciBzdGVwICh3aGVuIEdEQiByZWNvcmQgdGhl IHJ1bm5pbmcgbWVzc2FnZSwgaW5mZXJpb3IKICAgIG9ubHkgY2FuIHN0ZXAp LCBHREIgd2lsbCBjYWxsIHRoaXMgZnVuY3Rpb24gdG8gcmVjb3JkIHRoZSB2 YWx1ZXMgdG8KICAgIHJlY29yZF9saXN0LiAgVGhpcyBmdW5jdGlvbiB3aWxs IGNhbGwgZ2RiYXJjaF9wcm9jZXNzX3JlY29yZCB0bwogICAgcmVjb3JkIHRo ZSBydW5uaW5nIG1lc3NhZ2Ugb2YgaW5mZXJpb3IgYW5kIHNldCB0aGVtIHRv CiAgICByZWNvcmRfYXJjaF9saXN0LCBhbmQgYWRkIGl0IHRvIHJlY29yZF9s aXN0LiAgKi8KIAotc3RhdGljIHZvaWQKLXJlY29yZF9tZXNzYWdlX2NsZWFu dXBzICh2b2lkICppZ25vcmUpCi17Ci0gIHJlY29yZF9saXN0X3JlbGVhc2Ug KHJlY29yZF9hcmNoX2xpc3RfdGFpbCk7Ci19Ci0KIHN0YXRpYyBpbnQKIHJl Y29yZF9tZXNzYWdlICh2b2lkICphcmdzKQogewogICBpbnQgcmV0OwogICBz dHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlID0gYXJnczsKLSAgc3RydWN0IGNs ZWFudXAgKm9sZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cCAocmVjb3JkX21l c3NhZ2VfY2xlYW51cHMsIDApOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2Ns ZWFudXBzID0gbWFrZV9jbGVhbnVwIChyZWNvcmRfYXJjaF9saXN0X2NsZWFu dXBzLCAwKTsKIAogICByZWNvcmRfYXJjaF9saXN0X2hlYWQgPSBOVUxMOwog ICByZWNvcmRfYXJjaF9saXN0X3RhaWwgPSBOVUxMOwpAQCAtMzg2LDcgKzQx OSw3IEBAIHJlY29yZF9tZXNzYWdlICh2b2lkICphcmdzKQogICByZWNvcmRf bGlzdCA9IHJlY29yZF9hcmNoX2xpc3RfdGFpbDsKIAogICBpZiAocmVjb3Jk X2luc25fbnVtID09IHJlY29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2lu c25fbWF4X251bSkKLSAgICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgp OworICAgIHJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAg ZWxzZQogICAgIHJlY29yZF9pbnNuX251bSsrOwogCkBAIC00MTYsNiArNDQ5 LDkxIEBAIHJlY29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGVfc2V0ICh2b2lk KQogICByZXR1cm4gb2xkX2NsZWFudXBzOwogfQogCitzdGF0aWMgaW5saW5l IHZvaWQKK3JlY29yZF9leGVjX2VudHJ5IChzdHJ1Y3QgcmVnY2FjaGUgKnJl Z2NhY2hlLCBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwKKyAgICAgICAgICAg ICAgICAgICBzdHJ1Y3QgcmVjb3JkX2VudHJ5ICplbnRyeSkKK3sKKyAgc3dp dGNoIChlbnRyeS0+dHlwZSkKKyAgICB7CisgICAgY2FzZSByZWNvcmRfcmVn OiAvKiByZWcgKi8KKyAgICAgIHsKKyAgICAgICAgZ2RiX2J5dGUgcmVnW01B WF9SRUdJU1RFUl9TSVpFXTsKKworICAgICAgICBpZiAocmVjb3JkX2RlYnVn ID4gMSkKKyAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRs b2csCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiUHJvY2VzcyBy ZWNvcmQ6IHJlY29yZF9yZWcgJXMgdG8gIgorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgImluZmVyaW9yIG51bSA9ICVkLlxuIiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGhvc3RfYWRkcmVzc190b19zdHJpbmcg KGVudHJ5KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5 LT51LnJlZy5udW0pOworCisgICAgICAgIHJlZ2NhY2hlX2Nvb2tlZF9yZWFk IChyZWdjYWNoZSwgZW50cnktPnUucmVnLm51bSwgcmVnKTsKKyAgICAgICAg cmVnY2FjaGVfY29va2VkX3dyaXRlIChyZWdjYWNoZSwgZW50cnktPnUucmVn Lm51bSwgZW50cnktPnUucmVnLnZhbCk7CisgICAgICAgIG1lbWNweSAoZW50 cnktPnUucmVnLnZhbCwgcmVnLCBNQVhfUkVHSVNURVJfU0laRSk7CisgICAg ICB9CisgICAgICBicmVhazsKKworICAgIGNhc2UgcmVjb3JkX21lbTogLyog bWVtICovCisgICAgICB7CisgICAgICAgIGlmICghcmVjb3JkX2xpc3QtPnUu bWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSkKKyAgICAgICAgICB7Cisg ICAgICAgICAgICBnZGJfYnl0ZSAqbWVtID0gYWxsb2NhIChlbnRyeS0+dS5t ZW0ubGVuKTsKKworICAgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZyA+IDEp CisgICAgICAgICAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxv ZywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiUHJvY2Vz cyByZWNvcmQ6IHJlY29yZF9tZW0gJXMgdG8gIgorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICJpbmZlcmlvciBhZGRyID0gJXMgbGVuID0g JWQuXG4iLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhv c3RfYWRkcmVzc190b19zdHJpbmcgKGVudHJ5KSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwgZW50cnkt PnUubWVtLmFkZHIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pOworCisgICAgICAgICAgICBp ZiAodGFyZ2V0X3JlYWRfbWVtb3J5IChlbnRyeS0+dS5tZW0uYWRkciwgbWVt LCBlbnRyeS0+dS5tZW0ubGVuKSkKKyAgICAgICAgICAgICAgeworICAgICAg ICAgICAgICAgICBpZiAoKGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19S RVZFUlNFICYmICFyZWNvcmRfY29yZSkKKyAgICAgICAgICAgICAgICAgICAg IHx8IChleGVjdXRpb25fZGlyZWN0aW9uICE9IEVYRUNfUkVWRVJTRSAmJiBy ZWNvcmRfY29yZSkpCisgICAgICAgICAgICAgICAgICB7CisgICAgICAgICAg ICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2Fj Y2Vzc2libGUgPSAxOworICAgICAgICAgICAgICAgICAgICBpZiAocmVjb3Jk X2RlYnVnKQorICAgICAgICAgICAgICAgICAgICAgIHdhcm5pbmcgKF8oIlBy b2Nlc3MgcmVjb3JkOiBlcnJvciByZWFkaW5nIG1lbW9yeSBhdCAiCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiYWRkciA9ICVzIGxlbiA9 ICVkLiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRy ZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZW50cnktPnUubWVtLmxlbik7CisgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAg ICAgICAgICAgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBlcnJvciBy ZWFkaW5nIG1lbW9yeSBhdCAiCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAorICAgICAgICAgICAgICAgICAg ICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciks CisgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKTsK KyAgICAgICAgICAgICAgfQorICAgICAgICAgICAgZWxzZQorICAgICAgICAg ICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHRhcmdldF93cml0ZV9tZW1v cnkgKGVudHJ5LT51Lm1lbS5hZGRyLCBlbnRyeS0+dS5tZW0udmFsLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+ dS5tZW0ubGVuKSkKKyAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAg ICAgICAgICAgIGlmICgoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVDX1JF VkVSU0UgJiYgIXJlY29yZF9jb3JlKQorICAgICAgICAgICAgICAgICAgICAg ICAgIHx8IChleGVjdXRpb25fZGlyZWN0aW9uICE9IEVYRUNfUkVWRVJTRSAm JiByZWNvcmRfY29yZSkpCisgICAgICAgICAgICAgICAgICAgICAgeworICAg ICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLm1lbV9l bnRyeV9ub3RfYWNjZXNzaWJsZSA9IDE7CisgICAgICAgICAgICAgICAgICAg ICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgICAgICAgICAg ICAgICB3YXJuaW5nIChfKCJQcm9jZXNzIHJlY29yZDogZXJyb3Igd3JpdGlu ZyBtZW1vcnkgYXQgIgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJhZGRyID0gJXMgbGVuID0gJWQuIiksCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRy eS0+dS5tZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGVudHJ5LT51Lm1lbS5sZW4pOworICAgICAgICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAg ICAgICAgICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZDogZXJyb3Igd3Jp dGluZyBtZW1vcnkgYXQgIgorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICJhZGRyID0gJXMgbGVuID0gJWQuIiksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0u YWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50cnktPnUu bWVtLmxlbik7CisgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg IH0KKworICAgICAgICAgICAgbWVtY3B5IChlbnRyeS0+dS5tZW0udmFsLCBt ZW0sIGVudHJ5LT51Lm1lbS5sZW4pOworICAgICAgICAgIH0KKyAgICAgIH0K KyAgICAgIGJyZWFrOworICAgIH0KK30KKwogc3RhdGljIHZvaWQKIHJlY29y ZF9vcGVuIChjaGFyICpuYW1lLCBpbnQgZnJvbV90dHkpCiB7CkBAIC00MjQs OCArNTQyLDEzIEBAIHJlY29yZF9vcGVuIChjaGFyICpuYW1lLCBpbnQgZnJv bV90dHkpCiAgIGlmIChyZWNvcmRfZGVidWcpCiAgICAgZnByaW50Zl91bmZp bHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9v cGVuXG4iKTsKIAorICBpZiAoIXN0cmNtcCAoY3VycmVudF90YXJnZXQudG9f c2hvcnRuYW1lLCAiY29yZSIpKQorICAgIHJlY29yZF9jb3JlID0gMTsKKyAg ZWxzZQorICAgIHJlY29yZF9jb3JlID0gMDsKKwogICAvKiBjaGVjayBleGVj ICovCi0gIGlmICghdGFyZ2V0X2hhc19leGVjdXRpb24pCisgIGlmICghdGFy Z2V0X2hhc19leGVjdXRpb24gJiYgIXJlY29yZF9jb3JlKQogICAgIGVycm9y IChfKCJQcm9jZXNzIHJlY29yZDogdGhlIHByb2dyYW0gaXMgbm90IGJlaW5n IHJ1bi4iKSk7CiAgIGlmIChub25fc3RvcCkKICAgICBlcnJvciAoXygiUHJv Y2VzcyByZWNvcmQgdGFyZ2V0IGNhbid0IGRlYnVnIGluZmVyaW9yIGluIG5v bi1zdG9wIG1vZGUgIgpAQCAtNDU0LDYgKzU3Nyw4IEBAIHJlY29yZF9vcGVu IChjaGFyICpuYW1lLCBpbnQgZnJvbV90dHkpCiAgIHJlY29yZF9iZW5lYXRo X3RvX3hmZXJfcGFydGlhbCA9IE5VTEw7CiAgIHJlY29yZF9iZW5lYXRoX3Rv X2luc2VydF9icmVha3BvaW50ID0gTlVMTDsKICAgcmVjb3JkX2JlbmVhdGhf dG9fcmVtb3ZlX2JyZWFrcG9pbnQgPSBOVUxMOworICByZWNvcmRfYmVuZWF0 aF90b19oYXNfZXhlY3V0aW9uID0gTlVMTDsKKyAgcmVjb3JkX2JlbmVhdGhf dG9fcHJlcGFyZV90b19zdG9yZSA9IE5VTEw7CiAKICAgLyogU2V0IHRoZSBi ZW5lYXRoIGZ1bmN0aW9uIHBvaW50ZXJzLiAgKi8KICAgZm9yICh0ID0gY3Vy cmVudF90YXJnZXQuYmVuZWF0aDsgdCAhPSBOVUxMOyB0ID0gdC0+YmVuZWF0 aCkKQEAgLTQ2OCw2ICs1OTMsMTEgQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5h bWUsIGludCBmcm9tX3R0eSkKIAkgIHJlY29yZF9iZW5lYXRoX3RvX3dhaXQg PSB0LT50b193YWl0OwogCSAgcmVjb3JkX2JlbmVhdGhfdG9fd2FpdF9vcHMg PSB0OwogICAgICAgICB9CisgICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3Rv X2ZldGNoX3JlZ2lzdGVycykKKyAgICAgICAgeworCSAgcmVjb3JkX2JlbmVh dGhfdG9fZmV0Y2hfcmVnaXN0ZXJzID0gdC0+dG9fZmV0Y2hfcmVnaXN0ZXJz OworCSAgcmVjb3JkX2JlbmVhdGhfdG9fZmV0Y2hfcmVnaXN0ZXJzX29wcyA9 IHQ7CisgICAgICAgIH0KICAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9f c3RvcmVfcmVnaXN0ZXJzKQogICAgICAgICB7CiAJICByZWNvcmRfYmVuZWF0 aF90b19zdG9yZV9yZWdpc3RlcnMgPSB0LT50b19zdG9yZV9yZWdpc3RlcnM7 CkBAIC00ODIsMTkgKzYxMiw1MSBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFt ZSwgaW50IGZyb21fdHR5KQogCXJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9i cmVha3BvaW50ID0gdC0+dG9faW5zZXJ0X2JyZWFrcG9pbnQ7CiAgICAgICBp ZiAoIXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50KQogCXJl Y29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50ID0gdC0+dG9fcmVt b3ZlX2JyZWFrcG9pbnQ7CisgICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3Rv X2hhc19leGVjdXRpb24pCisgICAgICAgIHsKKyAgICAgICAgICByZWNvcmRf YmVuZWF0aF90b19oYXNfZXhlY3V0aW9uX29wcyA9IHQ7CisJICByZWNvcmRf YmVuZWF0aF90b19oYXNfZXhlY3V0aW9uID0gdC0+dG9faGFzX2V4ZWN1dGlv bjsKKyAgICAgICAgfQorICAgICAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19w cmVwYXJlX3RvX3N0b3JlKQorCXJlY29yZF9iZW5lYXRoX3RvX3ByZXBhcmVf dG9fc3RvcmUgPSB0LT50b19wcmVwYXJlX3RvX3N0b3JlOwogICAgIH0KLSAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b19yZXN1bWUpCisgIGlmICghcmVjb3Jk X2JlbmVhdGhfdG9fcmVzdW1lICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJv ciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3Jlc3VtZS4iKSk7 Ci0gIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fd2FpdCkKKyAgaWYgKCFyZWNv cmRfYmVuZWF0aF90b193YWl0ICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJv ciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3dhaXQuIikpOwot ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycykKKyAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b19mZXRjaF9yZWdpc3RlcnMpCisgICAg ZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19mZXRjaF9y ZWdpc3RlcnMuIikpOworICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3N0b3Jl X3JlZ2lzdGVycyAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJyb3IgKF8oIlBy b2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19zdG9yZV9yZWdpc3RlcnMuIikp OwogICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCkKICAg ICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3hmZXJf cGFydGlhbC4iKSk7Ci0gIGlmICghcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0 X2JyZWFrcG9pbnQpCisgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0 X2JyZWFrcG9pbnQgJiYgIXJlY29yZF9jb3JlKQogICAgIGVycm9yIChfKCJQ cm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9faW5zZXJ0X2JyZWFrcG9pbnQu IikpOwotICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3Bv aW50KQorICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3Bv aW50ICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJvciAoXygiUHJvY2VzcyBy ZWNvcmQgY2FuJ3QgZ2V0IHRvX3JlbW92ZV9icmVha3BvaW50LiIpKTsKKyAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b19oYXNfZXhlY3V0aW9uICYmICFyZWNv cmRfY29yZSkKKyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3Qg Z2V0IHRvX2hhc19leGVjdXRpb24uIikpOworICBpZiAoIXJlY29yZF9iZW5l YXRoX3RvX3ByZXBhcmVfdG9fc3RvcmUgJiYgIXJlY29yZF9jb3JlKQorICAg IGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fcHJlcGFy ZV90b19zdG9yZS4iKSk7CisKKyAgaWYgKHJlY29yZF9jb3JlKQorICAgIHsK KyAgICAgIC8qIEdldCByZWNvcmRfY29yZV9yZWdidWYuICAqLworICAgICAg c3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2Nh Y2hlICgpOworICAgICAgaW50IHJlZ251bSA9IGdkYmFyY2hfbnVtX3JlZ3Mg KGdldF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSkpOworICAgICAgaW50IGk7 CisKKyAgICAgIHRhcmdldF9mZXRjaF9yZWdpc3RlcnMgKHJlZ2NhY2hlLCAt MSk7CisgICAgICByZWNvcmRfY29yZV9yZWdidWYgPSB4bWFsbG9jIChNQVhf UkVHSVNURVJfU0laRSAqIHJlZ251bSk7CisgICAgICBmb3IgKGkgPSAwOyBp IDwgcmVnbnVtOyBpICsrKQorICAgICAgICByZWdjYWNoZV9yYXdfY29sbGVj dCAocmVnY2FjaGUsIGksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0laRSAqIGkp OworCisgICAgICAvKiBHZXQgcmVjb3JkX2NvcmVfc3RhcnQgYW5kIHJlY29y ZF9jb3JlX2VuZC4gICovCisgICAgICBpZiAoYnVpbGRfc2VjdGlvbl90YWJs ZSAoY29yZV9iZmQsICZyZWNvcmRfY29yZV9zdGFydCwgJnJlY29yZF9jb3Jl X2VuZCkpCisgICAgICAgIGVycm9yIChfKCJcIiVzXCI6IENhbid0IGZpbmQg c2VjdGlvbnM6ICVzIiksCisgICAgICAgICAgICAgICBiZmRfZ2V0X2ZpbGVu YW1lIChjb3JlX2JmZCksIGJmZF9lcnJtc2cgKGJmZF9nZXRfZXJyb3IgKCkp KTsKKyAgICB9CiAKICAgcHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKIApA QCAtNTA3LDEwICs2NjksMjYgQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUs IGludCBmcm9tX3R0eSkKIHN0YXRpYyB2b2lkCiByZWNvcmRfY2xvc2UgKGlu dCBxdWl0dGluZykKIHsKKyAgc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRy eSAqZW50cnk7CisKICAgaWYgKHJlY29yZF9kZWJ1ZykKICAgICBmcHJpbnRm X3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVj b3JkX2Nsb3NlXG4iKTsKIAogICByZWNvcmRfbGlzdF9yZWxlYXNlIChyZWNv cmRfbGlzdCk7CisKKyAgLyogUmVsZWFzZSByZWNvcmRfY29yZV9yZWdidWYu ICAqLworICB4ZnJlZSAocmVjb3JkX2NvcmVfcmVnYnVmKTsKKworICAvKiBS ZWxlYXNlIHJlY29yZF9jb3JlX2J1Zl9saXN0LiAgKi8KKyAgaWYgKHJlY29y ZF9jb3JlX2J1Zl9saXN0KQorICAgIHsKKyAgICAgIGZvciAoZW50cnkgPSBy ZWNvcmRfY29yZV9idWZfbGlzdC0+cHJldjsgZW50cnk7IGVudHJ5ID0gZW50 cnktPnByZXYpCisgICAgICAgIHsKKyAgICAgICAgICB4ZnJlZSAocmVjb3Jk X2NvcmVfYnVmX2xpc3QpOworICAgICAgICAgIHJlY29yZF9jb3JlX2J1Zl9s aXN0ID0gZW50cnk7CisgICAgICAgIH0KKyAgICAgIHJlY29yZF9jb3JlX2J1 Zl9saXN0ID0gTlVMTDsKKyAgICB9CiB9CiAKIHN0YXRpYyBpbnQgcmVjb3Jk X3Jlc3VtZV9zdGVwID0gMDsKQEAgLTcxMiw3NiArODkwLDkgQEAgcmVjb3Jk X3dhaXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCiAJICAgICAgYnJlYWs7 CiAJICAgIH0KIAotCSAgLyogU2V0IHB0aWQsIHJlZ2lzdGVyIGFuZCBtZW1v cnkgYWNjb3JkaW5nIHRvIHJlY29yZF9saXN0LiAgKi8KLQkgIGlmIChyZWNv cmRfbGlzdC0+dHlwZSA9PSByZWNvcmRfcmVnKQotCSAgICB7Ci0JICAgICAg LyogcmVnICovCi0JICAgICAgZ2RiX2J5dGUgcmVnW01BWF9SRUdJU1RFUl9T SVpFXTsKLQkgICAgICBpZiAocmVjb3JkX2RlYnVnID4gMSkKLQkJZnByaW50 Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLAotCQkJCSAgICAiUHJvY2VzcyBy ZWNvcmQ6IHJlY29yZF9yZWcgJXMgdG8gIgotCQkJCSAgICAiaW5mZXJpb3Ig bnVtID0gJWQuXG4iLAotCQkJCSAgICBob3N0X2FkZHJlc3NfdG9fc3RyaW5n IChyZWNvcmRfbGlzdCksCi0JCQkJICAgIHJlY29yZF9saXN0LT51LnJlZy5u dW0pOwotCSAgICAgIHJlZ2NhY2hlX2Nvb2tlZF9yZWFkIChyZWdjYWNoZSwg cmVjb3JkX2xpc3QtPnUucmVnLm51bSwgcmVnKTsKLQkgICAgICByZWdjYWNo ZV9jb29rZWRfd3JpdGUgKHJlZ2NhY2hlLCByZWNvcmRfbGlzdC0+dS5yZWcu bnVtLAotCQkJCSAgICAgcmVjb3JkX2xpc3QtPnUucmVnLnZhbCk7Ci0JICAg ICAgbWVtY3B5IChyZWNvcmRfbGlzdC0+dS5yZWcudmFsLCByZWcsIE1BWF9S RUdJU1RFUl9TSVpFKTsKLQkgICAgfQotCSAgZWxzZSBpZiAocmVjb3JkX2xp c3QtPnR5cGUgPT0gcmVjb3JkX21lbSkKLQkgICAgewotCSAgICAgIC8qIG1l bSAqLwotCSAgICAgIC8qIE5vdGhpbmcgdG8gZG8gaWYgdGhlIGVudHJ5IGlz IGZsYWdnZWQgbm90X2FjY2Vzc2libGUuICAqLwotCSAgICAgIGlmICghcmVj b3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSkKLQkJ ewotCQkgIGdkYl9ieXRlICptZW0gPSBhbGxvY2EgKHJlY29yZF9saXN0LT51 Lm1lbS5sZW4pOwotCQkgIGlmIChyZWNvcmRfZGVidWcgPiAxKQotCQkgICAg ZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLAotCQkJCSAgICAgICAg IlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfbWVtICVzIHRvICIKLQkJCQkgICAg ICAgICJpbmZlcmlvciBhZGRyID0gJXMgbGVuID0gJWQuXG4iLAotCQkJCSAg ICAgICAgaG9zdF9hZGRyZXNzX3RvX3N0cmluZyAocmVjb3JkX2xpc3QpLAot CQkJCSAgICAgICAgcGFkZHJlc3MgKGdkYmFyY2gsCi0JCQkJCSAgICAgICAg ICByZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCi0JCQkJICAgICAgICByZWNv cmRfbGlzdC0+dS5tZW0ubGVuKTsKKyAgICAgICAgICByZWNvcmRfZXhlY19l bnRyeSAocmVnY2FjaGUsIGdkYmFyY2gsIHJlY29yZF9saXN0KTsKIAotCQkg IGlmICh0YXJnZXRfcmVhZF9tZW1vcnkgKHJlY29yZF9saXN0LT51Lm1lbS5h ZGRyLCBtZW0sCi0JCSAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3Jk X2xpc3QtPnUubWVtLmxlbikpCi0JICAgICAgICAgICAgewotCQkgICAgICBp ZiAoZXhlY3V0aW9uX2RpcmVjdGlvbiAhPSBFWEVDX1JFVkVSU0UpCi0JCSAg ICAgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBlcnJvciByZWFkaW5n IG1lbW9yeSBhdCAiCi0JCQkgICAgICAgICAiYWRkciA9ICVzIGxlbiA9ICVk LiIpLAotCQkgICAgICAgICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwgcmVj b3JkX2xpc3QtPnUubWVtLmFkZHIpLAotCQkgICAgICAgICAgICAgICByZWNv cmRfbGlzdC0+dS5tZW0ubGVuKTsKLQkJICAgICAgZWxzZQotCQkJLyogUmVh ZCBmYWlsZWQgLS0gCi0JCQkgICBmbGFnIGVudHJ5IGFzIG5vdF9hY2Nlc3Np YmxlLiAgKi8KLQkJICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2Vu dHJ5X25vdF9hY2Nlc3NpYmxlID0gMTsKLQkJICAgIH0KLQkJICBlbHNlCi0J CSAgICB7Ci0JCSAgICAgIGlmICh0YXJnZXRfd3JpdGVfbWVtb3J5IChyZWNv cmRfbGlzdC0+dS5tZW0uYWRkciwKLQkJCSAgICAgICAgICAgICAgICAgICAg ICAgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwKLQkJICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pKQotCSAg ICAgICAgICAgICAgICB7Ci0JCQkgIGlmIChleGVjdXRpb25fZGlyZWN0aW9u ICE9IEVYRUNfUkVWRVJTRSkKLQkJCSAgICBlcnJvciAoXygiUHJvY2VzcyBy ZWNvcmQ6IGVycm9yIHdyaXRpbmcgbWVtb3J5IGF0ICIKLQkJCSAgICAgICAg ICAgICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAotCQkgICAgICAgICAgICAg ICAgICAgcGFkZHJlc3MgKGdkYmFyY2gsIHJlY29yZF9saXN0LT51Lm1lbS5h ZGRyKSwKLQkJICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1l bS5sZW4pOwotCQkJICBlbHNlCi0JCQkgICAgLyogV3JpdGUgZmFpbGVkIC0t IAotCQkJICAgICAgIGZsYWcgZW50cnkgYXMgbm90X2FjY2Vzc2libGUuICAq LwotCQkJICAgIHJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2Fj Y2Vzc2libGUgPSAxOwotCQkJfQotCQkgICAgICBlbHNlCi0JCSAgICAgICAg ewotCQkJICBtZW1jcHkgKHJlY29yZF9saXN0LT51Lm1lbS52YWwsIG1lbSwK LQkJCQkgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pOwotCQkJfQotCQkgICAg fQotCQl9Ci0JICAgIH0KLQkgIGVsc2UKKwkgIGlmIChyZWNvcmRfbGlzdC0+ dHlwZSA9PSByZWNvcmRfZW5kKQogCSAgICB7CiAJICAgICAgaWYgKHJlY29y ZF9kZWJ1ZyA+IDEpCiAJCWZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxv ZywKQEAgLTkwMSw3ICsxMDEyLDkgQEAgcmVjb3JkX2tpbGwgKHN0cnVjdCB0 YXJnZXRfb3BzICpvcHMpCiAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9raWxsXG4iKTsKIAog ICB1bnB1c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7Ci0gIHRhcmdldF9raWxs ICgpOworCisgIGlmICghcmVjb3JkX2NvcmUpCisgICAgdGFyZ2V0X2tpbGwg KCk7CiB9CiAKIC8qIFJlY29yZCByZWdpc3RlcnMgY2hhbmdlIChieSB1c2Vy IG9yIGJ5IEdEQikgdG8gbGlzdCBhcyBhbiBpbnN0cnVjdGlvbi4gICovCkBA IC05NDUsMTUgKzEwNTgsNTggQEAgcmVjb3JkX3JlZ2lzdGVyc19jaGFuZ2Ug KHN0cnVjdCByZWdjYWNoZQogICByZWNvcmRfbGlzdCA9IHJlY29yZF9hcmNo X2xpc3RfdGFpbDsKIAogICBpZiAocmVjb3JkX2luc25fbnVtID09IHJlY29y ZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4X251bSkKLSAgICBy ZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworICAgIHJlY29yZF9saXN0 X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAgZWxzZQogICAgIHJlY29yZF9p bnNuX251bSsrOwogfQogCiBzdGF0aWMgdm9pZAorcmVjb3JkX2ZldGNoX3Jl Z2lzdGVycyAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywgc3RydWN0IHJlZ2Nh Y2hlICpyZWdjYWNoZSwKKyAgICAgICAgICAgICAgICAgICAgICAgIGludCBy ZWdubykKK3sKKyAgaWYgKHJlY29yZF9jb3JlKQorICAgIHsKKyAgICAgIGlm IChyZWdubyA8IDApCisgICAgICAgIHsKKyAgICAgICAgICBpbnQgbnVtID0g Z2RiYXJjaF9udW1fcmVncyAoZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hl KSk7CisgICAgICAgICAgaW50IGk7CisKKyAgICAgICAgICBmb3IgKGkgPSAw OyBpIDwgbnVtOyBpICsrKQorICAgICAgICAgICAgcmVnY2FjaGVfcmF3X3N1 cHBseSAocmVnY2FjaGUsIGksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0la RSAqIGkpOworICAgICAgICB9CisgICAgICBlbHNlCisgICAgICAgIHJlZ2Nh Y2hlX3Jhd19zdXBwbHkgKHJlZ2NhY2hlLCByZWdubywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JF R0lTVEVSX1NJWkUgKiByZWdubyk7CisgICAgfQorICBlbHNlCisgICAgcmVj b3JkX2JlbmVhdGhfdG9fZmV0Y2hfcmVnaXN0ZXJzIChyZWNvcmRfYmVuZWF0 aF90b19zdG9yZV9yZWdpc3RlcnNfb3BzLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVnY2FjaGUsIHJlZ25vKTsKK30KKwor c3RhdGljIHZvaWQKK3JlY29yZF9wcmVwYXJlX3RvX3N0b3JlIChzdHJ1Y3Qg cmVnY2FjaGUgKnJlZ2NhY2hlKQoreworICBpZiAoIXJlY29yZF9jb3JlKQor ICAgIHJlY29yZF9iZW5lYXRoX3RvX3ByZXBhcmVfdG9fc3RvcmUgKHJlZ2Nh Y2hlKTsKK30KKworc3RhdGljIHZvaWQKIHJlY29yZF9zdG9yZV9yZWdpc3Rl cnMgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsIHN0cnVjdCByZWdjYWNoZSAq cmVnY2FjaGUsCiAgICAgICAgICAgICAgICAgICAgICAgICBpbnQgcmVnbm8p CiB7CisgIGlmIChyZWNvcmRfY29yZSkKKyAgICB7CisgICAgICAvKiBEZWJ1 ZyB3aXRoIGNvcmUuICAqLworICAgICAgaWYgKHJlY29yZF9nZGJfb3BlcmF0 aW9uX2Rpc2FibGUpCisgICAgICAgIHJlZ2NhY2hlX3Jhd19jb2xsZWN0IChy ZWdjYWNoZSwgcmVnbm8sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0laRSAqIHJl Z25vKTsKKyAgICAgIGVsc2UKKyAgICAgICAgZXJyb3IgKF8oIllvdSBjYW4n dCBkbyB0aGF0IHdpdGhvdXQgYSBwcm9jZXNzIHRvIGRlYnVnLiIpKTsKKwor ICAgICAgcmV0dXJuOworICAgIH0KKwogICBpZiAoIXJlY29yZF9nZGJfb3Bl cmF0aW9uX2Rpc2FibGUpCiAgICAgewogICAgICAgaWYgKFJFQ09SRF9JU19S RVBMQVkpCkBAIC0xMDAwLDYgKzExNTYsNyBAQCByZWNvcmRfc3RvcmVfcmVn aXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wCiAKICAgICAgIHJlY29yZF9yZWdp c3RlcnNfY2hhbmdlIChyZWdjYWNoZSwgcmVnbm8pOwogICAgIH0KKwogICBy ZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMgKHJlY29yZF9iZW5l YXRoX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHMsCiAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVnY2FjaGUsIHJlZ25vKTsKIH0KQEAg LTEwMTUsNyArMTE3Miw3IEBAIHJlY29yZF94ZmVyX3BhcnRpYWwgKHN0cnVj dCB0YXJnZXRfb3BzICoKIHsKICAgaWYgKCFyZWNvcmRfZ2RiX29wZXJhdGlv bl9kaXNhYmxlCiAgICAgICAmJiAob2JqZWN0ID09IFRBUkdFVF9PQkpFQ1Rf TUVNT1JZCi0JICB8fCBvYmplY3QgPT0gVEFSR0VUX09CSkVDVF9SQVdfTUVN T1JZKSAmJiB3cml0ZWJ1ZikKKwkgIHx8IG9iamVjdCA9PSBUQVJHRVRfT0JK RUNUX1JBV19NRU1PUlkpICYmIHdyaXRlYnVmICYmICFyZWNvcmRfY29yZSkK ICAgICB7CiAgICAgICBpZiAoUkVDT1JEX0lTX1JFUExBWSkKIAl7CkBAIC0x MDU5LDExICsxMjE2LDkxIEBAIHJlY29yZF94ZmVyX3BhcnRpYWwgKHN0cnVj dCB0YXJnZXRfb3BzICoKICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2Fy Y2hfbGlzdF90YWlsOwogCiAgICAgICBpZiAocmVjb3JkX2luc25fbnVtID09 IHJlY29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4X251bSkK LQlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworCXJlY29yZF9saXN0 X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAgICAgIGVsc2UKIAlyZWNvcmRf aW5zbl9udW0rKzsKICAgICB9CiAKKyAgIGlmIChyZWNvcmRfY29yZSAmJiBv YmplY3QgPT0gVEFSR0VUX09CSkVDVF9NRU1PUlkpCisgICAgIHsKKyAgICAg ICAvKiBEZWJ1ZyB3aXRoIGNvcmUuICAqLworICAgICAgIGlmIChyZWNvcmRf Z2RiX29wZXJhdGlvbl9kaXNhYmxlIHx8ICF3cml0ZWJ1ZikKKyAgICAgICAg IHsKKyAgICAgICAgICAgc3RydWN0IHRhcmdldF9zZWN0aW9uICpwOworICAg ICAgICAgICBmb3IgKHAgPSByZWNvcmRfY29yZV9zdGFydDsgcCA8IHJlY29y ZF9jb3JlX2VuZDsgcCsrKQorICAgICAgICAgICAgIHsKKyAgICAgICAgICAg ICAgIGlmIChvZmZzZXQgPj0gcC0+YWRkcikKKyAgICAgICAgICAgICAgICAg eworICAgICAgICAgICAgICAgICAgIHN0cnVjdCByZWNvcmRfY29yZV9idWZf ZW50cnkgKmVudHJ5OworCisgICAgICAgICAgICAgICAgICAgaWYgKG9mZnNl dCA+PSBwLT5lbmRhZGRyKQorICAgICAgICAgICAgICAgICAgICAgY29udGlu dWU7CisKKyAgICAgICAgICAgICAgICAgICBpZiAob2Zmc2V0ICsgbGVuID4g cC0+ZW5kYWRkcikKKyAgICAgICAgICAgICAgICAgICAgIGxlbiA9IHAtPmVu ZGFkZHIgLSBvZmZzZXQ7CisKKyAgICAgICAgICAgICAgICAgICBvZmZzZXQg LT0gcC0+YWRkcjsKKworICAgICAgICAgICAgICAgICAgIC8qIFJlYWQgcmVh ZGJ1ZiBvciB3cml0ZSB3cml0ZWJ1ZiBwLCBvZmZzZXQsIGxlbi4gICovCisg ICAgICAgICAgICAgICAgICAgLyogQ2hlY2sgZmxhZ3MuICAqLworICAgICAg ICAgICAgICAgICAgIGlmIChwLT50aGVfYmZkX3NlY3Rpb24tPmZsYWdzICYg U0VDX0NPTlNUUlVDVE9SCisgICAgICAgICAgICAgICAgICAgICAgIHx8IChw LT50aGVfYmZkX3NlY3Rpb24tPmZsYWdzICYgU0VDX0hBU19DT05URU5UUykg PT0gMCkKKyAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgaWYgKHJlYWRidWYpCisgICAgICAgICAgICAgICAgICAgICAg ICAgbWVtc2V0IChyZWFkYnVmLCAwLCBsZW4pOworICAgICAgICAgICAgICAg ICAgICAgICByZXR1cm4gbGVuOworICAgICAgICAgICAgICAgICAgICAgfQor ICAgICAgICAgICAgICAgICAgIC8qIEdldCByZWNvcmRfY29yZV9idWZfZW50 cnkuICAqLworICAgICAgICAgICAgICAgICAgIGZvciAoZW50cnkgPSByZWNv cmRfY29yZV9idWZfbGlzdDsgZW50cnk7CisgICAgICAgICAgICAgICAgICAg ICAgICBlbnRyeSA9IGVudHJ5LT5wcmV2KQorICAgICAgICAgICAgICAgICAg ICAgaWYgKGVudHJ5LT5wID09IHApCisgICAgICAgICAgICAgICAgICAgICAg IGJyZWFrOworICAgICAgICAgICAgICAgICAgIGlmICh3cml0ZWJ1ZikKKyAg ICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAg aWYgKCFlbnRyeSkKKyAgICAgICAgICAgICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICAvKiBBZGQgYSBuZXcgZW50cnkuICAq LworICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50cnkKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgPSAoc3RydWN0IHJlY29yZF9jb3JlX2J1 Zl9lbnRyeSAqKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg eG1hbGxvYworICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAo c2l6ZW9mIChzdHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5KSk7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+cCA9IHA7CisgICAgICAg ICAgICAgICAgICAgICAgICAgICBpZiAoIWJmZF9tYWxsb2NfYW5kX2dldF9z ZWN0aW9uIChwLT5iZmQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwLT50aGVfYmZkX3Nl Y3Rpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAmZW50cnktPmJ1ZikpCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB4ZnJlZSAoZW50cnkpOworICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+ cHJldiA9IHJlY29yZF9jb3JlX2J1Zl9saXN0OworICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmVjb3JkX2NvcmVfYnVmX2xpc3QgPSBlbnRyeTsKKyAg ICAgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICAg ICAgICAgIG1lbWNweSAoZW50cnktPmJ1ZiArIG9mZnNldCwgd3JpdGVidWYs IChzaXplX3QpIGxlbik7CisgICAgICAgICAgICAgICAgICAgICB9CisgICAg ICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgewor ICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWVudHJ5KQorICAgICAgICAg ICAgICAgICAgICAgICAgIHJldHVybiByZWNvcmRfYmVuZWF0aF90b194ZmVy X3BhcnRpYWwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAo cmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0LCBhbm5leCwgcmVh ZGJ1Ziwgd3JpdGVidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIG9mZnNldCwgbGVuKTsKKworICAgICAgICAgICAgICAgICAgICAg ICBtZW1jcHkgKHJlYWRidWYsIGVudHJ5LT5idWYgKyBvZmZzZXQsIChzaXpl X3QpIGxlbik7CisgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAg ICAgICAgICAgICByZXR1cm4gbGVuOworICAgICAgICAgICAgICAgICB9Cisg ICAgICAgICAgICAgfQorCisgICAgICAgICAgIHJldHVybiAwOworICAgICAg ICAgfQorICAgICAgIGVsc2UKKyAgICAgICAgIGVycm9yIChfKCJZb3UgY2Fu J3QgZG8gdGhhdCB3aXRob3V0IGEgcHJvY2VzcyB0byBkZWJ1Zy4iKSk7CisK KyAgICAgICByZXR1cm4gMDsKKyAgICAgfQorCiAgIHJldHVybiByZWNvcmRf YmVuZWF0aF90b194ZmVyX3BhcnRpYWwgKHJlY29yZF9iZW5lYXRoX3RvX3hm ZXJfcGFydGlhbF9vcHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIG9iamVjdCwgYW5uZXgsIHJlYWRidWYsIHdyaXRlYnVm LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBv ZmZzZXQsIGxlbik7CkBAIC0xMTEzLDYgKzEzNTAsMTUgQEAgcmVjb3JkX2Nh bl9leGVjdXRlX3JldmVyc2UgKHZvaWQpCiAgIHJldHVybiAxOwogfQogCitp bnQKK3JlY29yZF9oYXNfZXhlY3V0aW9uIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzKQoreworICBpZiAocmVjb3JkX2NvcmUpCisgICAgcmV0dXJuIDE7CisK KyAgcmV0dXJuIHJlY29yZF9iZW5lYXRoX3RvX2hhc19leGVjdXRpb24gKG9w cyk7Cit9CisKIHN0YXRpYyB2b2lkCiBpbml0X3JlY29yZF9vcHMgKHZvaWQp CiB7CkBAIC0xMTI5LDExICsxMzc1LDE0IEBAIGluaXRfcmVjb3JkX29wcyAo dm9pZCkKICAgcmVjb3JkX29wcy50b19tb3Vybl9pbmZlcmlvciA9IHJlY29y ZF9tb3Vybl9pbmZlcmlvcjsKICAgcmVjb3JkX29wcy50b19raWxsID0gcmVj b3JkX2tpbGw7CiAgIHJlY29yZF9vcHMudG9fY3JlYXRlX2luZmVyaW9yID0g ZmluZF9kZWZhdWx0X2NyZWF0ZV9pbmZlcmlvcjsKKyAgcmVjb3JkX29wcy50 b19mZXRjaF9yZWdpc3RlcnMgPSByZWNvcmRfZmV0Y2hfcmVnaXN0ZXJzOwor ICByZWNvcmRfb3BzLnRvX3ByZXBhcmVfdG9fc3RvcmUgPSByZWNvcmRfcHJl cGFyZV90b19zdG9yZTsKICAgcmVjb3JkX29wcy50b19zdG9yZV9yZWdpc3Rl cnMgPSByZWNvcmRfc3RvcmVfcmVnaXN0ZXJzOwogICByZWNvcmRfb3BzLnRv X3hmZXJfcGFydGlhbCA9IHJlY29yZF94ZmVyX3BhcnRpYWw7CiAgIHJlY29y ZF9vcHMudG9faW5zZXJ0X2JyZWFrcG9pbnQgPSByZWNvcmRfaW5zZXJ0X2Jy ZWFrcG9pbnQ7CiAgIHJlY29yZF9vcHMudG9fcmVtb3ZlX2JyZWFrcG9pbnQg PSByZWNvcmRfcmVtb3ZlX2JyZWFrcG9pbnQ7CiAgIHJlY29yZF9vcHMudG9f Y2FuX2V4ZWN1dGVfcmV2ZXJzZSA9IHJlY29yZF9jYW5fZXhlY3V0ZV9yZXZl cnNlOworICByZWNvcmRfb3BzLnRvX2hhc19leGVjdXRpb24gPSByZWNvcmRf aGFzX2V4ZWN1dGlvbjsKICAgcmVjb3JkX29wcy50b19zdHJhdHVtID0gcmVj b3JkX3N0cmF0dW07CiAgIHJlY29yZF9vcHMudG9fbWFnaWMgPSBPUFNfTUFH SUM7CiB9CkBAIC0xMTU0LDYgKzE0MDMsMjk0IEBAIGNtZF9yZWNvcmRfc3Rh cnQgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3QKICAgZXhlY3V0ZV9jb21tYW5k ICgidGFyZ2V0IHJlY29yZCIsIGZyb21fdHR5KTsKIH0KIAorc3RhdGljIHZv aWQKK2NtZF9yZWNvcmRfZmRfY2xlYW51cHMgKHZvaWQgKnJlY2ZkcCkKK3sK KyAgaW50IHJlY2ZkID0gKihpbnQgKikgcmVjZmRwOworICBjbG9zZSAocmVj ZmQpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3JlY29yZF9yZWFkX2R1 bXAgKGNoYXIgKnJlY2ZpbGVuYW1lLCBpbnQgZmlsZGVzLCB2b2lkICpidWYs IHNpemVfdCBuYnl0ZSkKK3sKKyAgaWYgKHJlYWQgKGZpbGRlcywgYnVmLCBu Ynl0ZSkgIT0gbmJ5dGUpCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFk IGR1bXAgb2YgZXhlY3V0aW9uIHJlY29yZHMgaW4gJyVzJy4iKSwKKyAgICAg ICAgICAgcmVjZmlsZW5hbWUpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQK K3JlY29yZF93cml0ZV9kdW1wIChjaGFyICpyZWNmaWxlbmFtZSwgaW50IGZp bGRlcywgY29uc3Qgdm9pZCAqYnVmLAorICAgICAgICAgICAgICAgICAgIHNp emVfdCBuYnl0ZSkKK3sKKyAgaWYgKHdyaXRlIChmaWxkZXMsIGJ1ZiwgbmJ5 dGUpICE9IG5ieXRlKQorICAgIGVycm9yIChfKCJGYWlsZWQgdG8gd3JpdGUg ZHVtcCBvZiBleGVjdXRpb24gcmVjb3JkcyB0byAnJXMnLiIpLAorICAgICAg ICAgICByZWNmaWxlbmFtZSk7Cit9CisKKy8qIER1bXAgdGhlIGV4ZWN1dGlv biBsb2cgdG8gYSBmaWxlLiAgKi8KKworc3RhdGljIHZvaWQKK2NtZF9yZWNv cmRfZHVtcCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQoreworICBjaGFy ICpyZWNmaWxlbmFtZSwgcmVjZmlsZW5hbWVfYnVmZmVyWzQwXTsKKyAgaW50 IHJlY2ZkOworICBzdHJ1Y3QgcmVjb3JkX2VudHJ5ICpjdXJfcmVjb3JkX2xp c3Q7CisgIHVpbnQzMl90IG1hZ2ljOworICBzdHJ1Y3QgcmVnY2FjaGUgKnJl Z2NhY2hlOworICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaDsKKyAgc3RydWN0 IGNsZWFudXAgKm9sZF9jbGVhbnVwczsKKyAgc3RydWN0IGNsZWFudXAgKnNl dF9jbGVhbnVwczsKKworICBpZiAoY3VycmVudF90YXJnZXQudG9fc3RyYXR1 bSAhPSByZWNvcmRfc3RyYXR1bSkKKyAgICBlcnJvciAoXygiUHJvY2VzcyBy ZWNvcmQgaXMgbm90IHN0YXJ0ZWQuXG4iKSk7CisKKyAgaWYgKGFyZ3MgJiYg KmFyZ3MpCisgICAgcmVjZmlsZW5hbWUgPSBhcmdzOworICBlbHNlCisgICAg eworICAgICAgLyogRGVmYXVsdCBjb3JlZmlsZSBuYW1lIGlzICJnZGJfcmVj b3JkLlBJRCIuICAqLworICAgICAgc3ByaW50ZiAocmVjZmlsZW5hbWVfYnVm ZmVyLCAiZ2RiX3JlY29yZC4lZCIsIFBJREdFVCAoaW5mZXJpb3JfcHRpZCkp OworICAgICAgcmVjZmlsZW5hbWUgPSByZWNmaWxlbmFtZV9idWZmZXI7Cisg ICAgfQorCisgIC8qIE9wZW4gdGhlIGR1bXAgZmlsZS4gICovCisgIHJlY2Zk ID0gb3BlbiAocmVjZmlsZW5hbWUsIE9fV1JPTkxZIHwgT19DUkVBVCB8IE9f VFJVTkMgfCBPX0JJTkFSWSwKKyAgICAgICAgICAgICAgICBTX0lSVVNSIHwg U19JV1VTUik7CisgIGlmIChyZWNmZCA8IDApCisgICAgZXJyb3IgKF8oIkZh aWxlZCB0byBvcGVuICclcycgZm9yIGR1bXAgZXhlY3V0aW9uIHJlY29yZHM6 ICVzIiksCisgICAgICAgICAgIHJlY2ZpbGVuYW1lLCBzdHJlcnJvciAoZXJy bm8pKTsKKyAgb2xkX2NsZWFudXBzID0gbWFrZV9jbGVhbnVwIChjbWRfcmVj b3JkX2ZkX2NsZWFudXBzLCAmcmVjZmQpOworCisgIC8qIFNhdmUgdGhlIGN1 cnJlbnQgcmVjb3JkIGVudHJ5IHRvICJjdXJfcmVjb3JkX2xpc3QiLiAgKi8K KyAgY3VyX3JlY29yZF9saXN0ID0gcmVjb3JkX2xpc3Q7CisKKyAgLyogR2V0 IHRoZSB2YWx1ZXMgb2YgcmVnY2FjaGUgYW5kIGdkYmFyY2guICAqLworICBy ZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2NhY2hlICgpOworICBnZGJhcmNo ID0gZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKTsKKworICAvKiBEaXNh YmxlIHRoZSBHREIgb3BlcmF0aW9uIHJlY29yZC4gICovCisgIHNldF9jbGVh bnVwcyA9IHJlY29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGVfc2V0ICgpOwor CisgIC8qIFdyaXRlIHRoZSBtYWdpYyBjb2RlLiAgKi8KKyAgbWFnaWMgPSBS RUNPUkRfRklMRV9NQUdJQzsKKyAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2Zp bGVuYW1lLCByZWNmZCwgJm1hZ2ljLCA0KTsKKworICAvKiBSZXZlcnNlIGV4 ZWN1dGUgdG8gdGhlIGJlZ2luIG9mIHJlY29yZCBsaXN0LiAgKi8KKyAgd2hp bGUgKDEpCisgICAgeworICAgICAgLyogQ2hlY2sgZm9yIGJlZ2lubmluZyBh bmQgZW5kIG9mIGxvZy4gICovCisgICAgICBpZiAocmVjb3JkX2xpc3QgPT0g JnJlY29yZF9maXJzdCkKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIHJlY29y ZF9leGVjX2VudHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3Qp OworCisgICAgICBpZiAocmVjb3JkX2xpc3QtPnByZXYpCisgICAgICAgIHJl Y29yZF9saXN0ID0gcmVjb3JkX2xpc3QtPnByZXY7CisgICAgfQorCisgIC8q IER1bXAgdGhlIGVudHJpZXMgdG8gcmVjZmQgYW5kIGZvcndhcmQgZXhlY3V0 ZSB0byB0aGUgZW5kIG9mCisgICAgIHJlY29yZCBsaXN0LiAgKi8KKyAgd2hp bGUgKDEpCisgICAgeworICAgICAgLyogRHVtcCBlbnRyeS4gICovCisgICAg ICBpZiAocmVjb3JkX2xpc3QgIT0gJnJlY29yZF9maXJzdCkKKyAgICAgICAg eworICAgICAgICAgIHVpbnQ4X3QgdG1wdTg7CisgICAgICAgICAgdWludDY0 X3QgdG1wdTY0OworCisgICAgICAgICAgdG1wdTggPSByZWNvcmRfbGlzdC0+ dHlwZTsKKyAgICAgICAgICByZWNvcmRfd3JpdGVfZHVtcCAocmVjZmlsZW5h bWUsIHJlY2ZkLCAmdG1wdTgsIDEpOworCisgICAgICAgICAgc3dpdGNoIChy ZWNvcmRfbGlzdC0+dHlwZSkKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAg IGNhc2UgcmVjb3JkX3JlZzogLyogcmVnICovCisgICAgICAgICAgICAgIHRt cHU2NCA9IHJlY29yZF9saXN0LT51LnJlZy5udW07CisgICAgICAgICAgICAg IGlmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAg ICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAg ICAgIHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsICZ0 bXB1NjQsIDgpOworCisgICAgICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1w IChyZWNmaWxlbmFtZSwgcmVjZmQsIHJlY29yZF9saXN0LT51LnJlZy52YWws CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNQVhfUkVHSVNU RVJfU0laRSk7CisgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAg Y2FzZSByZWNvcmRfbWVtOiAvKiBtZW0gKi8KKyAgICAgICAgICAgICAgaWYg KCFyZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxl KQorICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgIHRtcHU2 NCA9IHJlY29yZF9saXN0LT51Lm1lbS5hZGRyOworICAgICAgICAgICAgICAg ICAgaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAg ICAgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAg ICAgICAgICAgICAgICByZWNvcmRfd3JpdGVfZHVtcCAocmVjZmlsZW5hbWUs IHJlY2ZkLCAmdG1wdTY0LCA4KTsKKworICAgICAgICAgICAgICAgICAgdG1w dTY0ID0gcmVjb3JkX2xpc3QtPnUubWVtLmxlbjsKKyAgICAgICAgICAgICAg ICAgIGlmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAg ICAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAg ICAgICAgICAgICAgICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1l LCByZWNmZCwgJnRtcHU2NCwgOCk7CisKKyAgICAgICAgICAgICAgICAgIHJl Y29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUu bWVtLnZhbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAg ICB9CisKKyAgICAgIC8qIEV4ZWN1dGUgZW50cnkuICAqLworICAgICAgcmVj b3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNvcmRfbGlz dCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+bmV4dCkKKyAgICAgICAg cmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+bmV4dDsKKyAgICAgIGVsc2UK KyAgICAgICAgYnJlYWs7CisgICAgfQorCisgIC8qIFJldmVyc2UgZXhlY3V0 ZSB0byBjdXJfcmVjb3JkX2xpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7 CisgICAgICAvKiBDaGVjayBmb3IgYmVnaW5uaW5nIGFuZCBlbmQgb2YgbG9n LiAgKi8KKyAgICAgIGlmIChyZWNvcmRfbGlzdCA9PSBjdXJfcmVjb3JkX2xp c3QpCisgICAgICAgIGJyZWFrOworCisgICAgICByZWNvcmRfZXhlY19lbnRy eSAocmVnY2FjaGUsIGdkYmFyY2gsIHJlY29yZF9saXN0KTsKKworICAgICAg aWYgKHJlY29yZF9saXN0LT5wcmV2KQorICAgICAgICByZWNvcmRfbGlzdCA9 IHJlY29yZF9saXN0LT5wcmV2OworICAgIH0KKworICBkb19jbGVhbnVwcyAo c2V0X2NsZWFudXBzKTsKKyAgZG9fY2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7 CisKKyAgLyogU3VjY2VlZGVkLiAgKi8KKyAgZnByaW50Zl9maWx0ZXJlZCAo Z2RiX3N0ZG91dCwgXygiU2F2ZWQgZHVtcCBvZiBleGVjdXRpb24gIgorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJyZWNvcmRzIHRvIGAl cycuXG4iKSwKKyAgICAgICAgICAgICAgICAgICAgcmVjZmlsZW5hbWUpOwor fQorCisvKiBMb2FkIHRoZSBleGVjdXRpb24gbG9nIGZyb20gYSBmaWxlLiAg Ki8KKworc3RhdGljIHZvaWQKK2NtZF9yZWNvcmRfbG9hZCAoY2hhciAqYXJn cywgaW50IGZyb21fdHR5KQoreworICBpbnQgcmVjZmQ7CisgIHVpbnQzMl90 IG1hZ2ljOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzOworICBz dHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzMjsKKyAgc3RydWN0IHJlY29y ZF9lbnRyeSAqcmVjOworICBpbnQgaW5zbl9udW1iZXIgPSAwOworCisgIGlm IChjdXJyZW50X3RhcmdldC50b19zdHJhdHVtICE9IHJlY29yZF9zdHJhdHVt KQorICAgIHsKKyAgICAgIGNtZF9yZWNvcmRfc3RhcnQgKE5VTEwsIGZyb21f dHR5KTsKKyAgICAgIHByaW50Zl91bmZpbHRlcmVkIChfKCJBdXRvIHN0YXJ0 IHByb2Nlc3MgcmVjb3JkLlxuIikpOworICAgIH0KKworICBpZiAoIWFyZ3Mg fHwgKGFyZ3MgJiYgISphcmdzKSkKKyAgICBlcnJvciAoXygiQXJndW1lbnQg Zm9yIGZpbGVuYW1lIHJlcXVpcmVkLlxuIikpOworCisgIC8qIE9wZW4gdGhl IGxvYWQgZmlsZS4gICovCisgIHJlY2ZkID0gb3BlbiAoYXJncywgT19SRE9O TFkgfCBPX0JJTkFSWSk7CisgIGlmIChyZWNmZCA8IDApCisgICAgZXJyb3Ig KF8oIkZhaWxlZCB0byBvcGVuICclcycgZm9yIGxvYWRpbmcgZXhlY3V0aW9u IHJlY29yZHM6ICVzIiksCisgICAgICAgICAgIGFyZ3MsIHN0cmVycm9yIChl cnJubykpOworICBvbGRfY2xlYW51cHMgPSBtYWtlX2NsZWFudXAgKGNtZF9y ZWNvcmRfZmRfY2xlYW51cHMsICZyZWNmZCk7CisKKyAgLyogQ2hlY2sgdGhl IG1hZ2ljIGNvZGUuICAqLworICByZWNvcmRfcmVhZF9kdW1wIChhcmdzLCBy ZWNmZCwgJm1hZ2ljLCA0KTsKKyAgaWYgKG1hZ2ljICE9IFJFQ09SRF9GSUxF X01BR0lDKQorICAgIGVycm9yIChfKCInJXMnIGlzIG5vdCBhIHZhbGlkIGR1 bXAgb2YgZXhlY3V0aW9uIHJlY29yZHMuIiksIGFyZ3MpOworCisgIC8qIExv YWQgdGhlIGVudHJpZXMgaW4gcmVjZmQgdG8gdGhlIHJlY29yZF9hcmNoX2xp c3RfaGVhZCBhbmQKKyAgICAgcmVjb3JkX2FyY2hfbGlzdF90YWlsLiAgKi8K KyAgcmVjb3JkX2FyY2hfbGlzdF9oZWFkID0gTlVMTDsKKyAgcmVjb3JkX2Fy Y2hfbGlzdF90YWlsID0gTlVMTDsKKyAgb2xkX2NsZWFudXBzMiA9IG1ha2Vf Y2xlYW51cCAocmVjb3JkX2FyY2hfbGlzdF9jbGVhbnVwcywgMCk7CisKKyAg d2hpbGUgKDEpCisgICAgeworICAgICAgaW50IHJldDsKKyAgICAgIHVpbnQ4 X3QgdG1wdTg7CisgICAgICB1aW50NjRfdCB0bXB1NjQ7CisKKyAgICAgIHJl dCA9IHJlYWQgKHJlY2ZkLCAmdG1wdTgsIDEpOworICAgICAgaWYgKHJldCA8 IDApCisgICAgICAgIGVycm9yIChfKCJGYWlsZWQgdG8gcmVhZCBkdW1wIG9m IGV4ZWN1dGlvbiByZWNvcmRzIGluICclcycuIiksIGFyZ3MpOworICAgICAg aWYgKHJldCA9PSAwKQorICAgICAgICBicmVhazsKKworICAgICAgc3dpdGNo ICh0bXB1OCkKKyAgICAgICAgeworICAgICAgICBjYXNlIHJlY29yZF9yZWc6 IC8qIHJlZyAqLworICAgICAgICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2Vu dHJ5ICopIHhtYWxsb2MgKHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkp OworICAgICAgICAgIHJlYy0+dS5yZWcudmFsID0gKGdkYl9ieXRlICopIHht YWxsb2MgKE1BWF9SRUdJU1RFUl9TSVpFKTsKKyAgICAgICAgICByZWMtPnBy ZXYgPSBOVUxMOworICAgICAgICAgIHJlYy0+bmV4dCA9IE5VTEw7CisgICAg ICAgICAgcmVjLT50eXBlID0gcmVjb3JkX3JlZzsKKyAgICAgICAgICAvKiBH ZXQgbnVtLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChhcmdz LCByZWNmZCwgJnRtcHU2NCwgOCk7CisgICAgICAgICAgaWYgKEJZVEVfT1JE RVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgIHRtcHU2NCA9IGJz d2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJlYy0+dS5yZWcubnVtID0g dG1wdTY0OworICAgICAgICAgIC8qIEdldCB2YWwuICAqLworICAgICAgICAg IHJlY29yZF9yZWFkX2R1bXAgKGFyZ3MsIHJlY2ZkLCByZWMtPnUucmVnLnZh bCwgTUFYX1JFR0lTVEVSX1NJWkUpOworICAgICAgICAgIHJlY29yZF9hcmNo X2xpc3RfYWRkIChyZWMpOworICAgICAgICAgIGJyZWFrOworICAgICAgICBj YXNlIHJlY29yZF9tZW06IC8qIG1lbSAqLworICAgICAgICAgIHJlYyA9IChz dHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2MgKHNpemVvZiAoc3RydWN0 IHJlY29yZF9lbnRyeSkpOworICAgICAgICAgIHJlYy0+cHJldiA9IE5VTEw7 CisgICAgICAgICAgcmVjLT5uZXh0ID0gTlVMTDsKKyAgICAgICAgICByZWMt PnR5cGUgPSByZWNvcmRfbWVtOworICAgICAgICAgIC8qIEdldCBhZGRyLiAg Ki8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwg JnRtcHU2NCwgOCk7CisgICAgICAgICAgaWYgKEJZVEVfT1JERVIgPT0gTElU VExFX0VORElBTikKKyAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0 bXB1NjQpOworICAgICAgICAgIHJlYy0+dS5tZW0uYWRkciA9IHRtcHU2NDsK KyAgICAgICAgICAvKiBHZXQgbGVuLiAgKi8KKyAgICAgICAgICByZWNvcmRf cmVhZF9kdW1wIChhcmdzLCByZWNmZCwgJnRtcHU2NCwgOCk7CisgICAgICAg ICAgaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAg ICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJl Yy0+dS5tZW0ubGVuID0gdG1wdTY0OworICAgICAgICAgIHJlYy0+dS5tZW0u bWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlID0gMDsKKyAgICAgICAgICByZWMt PnUubWVtLnZhbCA9IChnZGJfYnl0ZSAqKSB4bWFsbG9jIChyZWMtPnUubWVt Lmxlbik7CisgICAgICAgICAgLyogR2V0IHZhbC4gICovCisgICAgICAgICAg cmVjb3JkX3JlYWRfZHVtcCAoYXJncywgcmVjZmQsIHJlYy0+dS5tZW0udmFs LCByZWMtPnUubWVtLmxlbik7CisgICAgICAgICAgcmVjb3JkX2FyY2hfbGlz dF9hZGQgKHJlYyk7CisgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgY2Fz ZSByZWNvcmRfZW5kOiAvKiBlbmQgKi8KKyAgICAgICAgICByZWMgPSAoc3Ry dWN0IHJlY29yZF9lbnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCBy ZWNvcmRfZW50cnkpKTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOwor ICAgICAgICAgIHJlYy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50 eXBlID0gcmVjb3JkX2VuZDsKKyAgICAgICAgICByZWNvcmRfYXJjaF9saXN0 X2FkZCAocmVjKTsKKyAgICAgICAgICBpbnNuX251bWJlciArKzsKKyAgICAg ICAgICBicmVhazsKKworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgIGVy cm9yIChfKCJGb3JtYXQgb2YgJyVzJyBpcyBub3QgcmlnaHQuIiksIGFyZ3Mp OworICAgICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorCisgIGRp c2NhcmRfY2xlYW51cHMgKG9sZF9jbGVhbnVwczIpOworCisgIC8qIEFkZCBy ZWNvcmRfYXJjaF9saXN0X2hlYWQgdG8gdGhlIGVuZCBvZiByZWNvcmQgbGlz dC4gICovCisgIGZvciAocmVjID0gcmVjb3JkX2xpc3Q7IHJlYy0+bmV4dDsg cmVjID0gcmVjLT5uZXh0KTsKKyAgcmVjLT5uZXh0ID0gcmVjb3JkX2FyY2hf bGlzdF9oZWFkOworICByZWNvcmRfYXJjaF9saXN0X2hlYWQtPnByZXYgPSBy ZWM7CisKKyAgLyogVXBkYXRlIHJlY29yZF9pbnNuX251bSBhbmQgcmVjb3Jk X2luc25fbWF4X251bS4gICovCisgIHJlY29yZF9pbnNuX251bSArPSBpbnNu X251bWJlcjsKKyAgaWYgKHJlY29yZF9pbnNuX251bSA+IHJlY29yZF9pbnNu X21heF9udW0pCisgICAgeworICAgICAgcmVjb3JkX2luc25fbWF4X251bSA9 IHJlY29yZF9pbnNuX251bTsKKyAgICAgIHdhcm5pbmcgKF8oIkF1dG8gaW5j cmVhc2UgcmVjb3JkL3JlcGxheSBidWZmZXIgbGltaXQgdG8gJWQuIiksCisg ICAgICAgICAgICAgICByZWNvcmRfaW5zbl9tYXhfbnVtKTsKKyAgICB9CisK KyAgZG9fY2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgLyogU3VjY2Vl ZGVkLiAgKi8KKyAgZnByaW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZG91dCwgIkxv YWRlZCByZWNmaWxlICVzLlxuIiwgYXJncyk7Cit9CisKIC8qIFRydW5jYXRl IHRoZSByZWNvcmQgbG9nIGZyb20gdGhlIHByZXNlbnQgcG9pbnQKICAgIG9m IHJlcGxheSB1bnRpbCB0aGUgZW5kLiAgKi8KIApAQCAtMTIwNCw3ICsxNzQx LDcgQEAgc2V0X3JlY29yZF9pbnNuX21heF9udW0gKGNoYXIgKmFyZ3MsIGlu dAogCQkgICAgICAgICAgICJ0aGUgZmlyc3Qgb25lcz9cbiIpKTsKIAogICAg ICAgd2hpbGUgKHJlY29yZF9pbnNuX251bSA+IHJlY29yZF9pbnNuX21heF9u dW0pCi0JcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdCAoKTsKKwlyZWNvcmRf bGlzdF9yZWxlYXNlX2ZpcnN0X2luc24gKCk7CiAgICAgfQogfQogCkBAIC0x MjQ0LDYgKzE3ODEsOCBAQCBpbmZvX3JlY29yZF9jb21tYW5kIChjaGFyICph cmdzLCBpbnQgZnJvCiB2b2lkCiBfaW5pdGlhbGl6ZV9yZWNvcmQgKHZvaWQp CiB7CisgIHN0cnVjdCBjbWRfbGlzdF9lbGVtZW50ICpjOworCiAgIC8qIElu aXQgcmVjb3JkX2ZpcnN0LiAgKi8KICAgcmVjb3JkX2ZpcnN0LnByZXYgPSBO VUxMOwogICByZWNvcmRfZmlyc3QubmV4dCA9IE5VTEw7CkBAIC0xMjc3LDYg KzE4MTYsMTYgQEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogCQkgICJp bmZvIHJlY29yZCAiLCAwLCAmaW5mb2xpc3QpOwogICBhZGRfYWxpYXNfY21k ICgicmVjIiwgInJlY29yZCIsIGNsYXNzX29ic2N1cmUsIDEsICZpbmZvbGlz dCk7CiAKKyAgYyA9IGFkZF9jbWQgKCJkdW1wIiwgY2xhc3Nfb2JzY3VyZSwg Y21kX3JlY29yZF9kdW1wLAorCSAgICAgICBfKCJEdW1wIHRoZSBleGVjdXRp b24gcmVjb3JkcyB0byBhIGZpbGUuXG5cCitBcmd1bWVudCBpcyBvcHRpb25h bCBmaWxlbmFtZS4gIERlZmF1bHQgZmlsZW5hbWUgaXMgJ2dkYl9yZWNvcmQu PHByb2Nlc3NfaWQ+Jy4iKSwKKyAgICAgICAgICAgICAgICZyZWNvcmRfY21k bGlzdCk7CisgIHNldF9jbWRfY29tcGxldGVyIChjLCBmaWxlbmFtZV9jb21w bGV0ZXIpOworICBjID0gYWRkX2NtZCAoImxvYWQiLCBjbGFzc19vYnNjdXJl LCBjbWRfcmVjb3JkX2xvYWQsCisJICAgICAgIF8oIkxvYWQgcHJldmlvdXNs eSBkdW1wZWQgZXhlY3V0aW9uIHJlY29yZHMgZnJvbSBcCithIGZpbGUgZ2l2 ZW4gYXMgYXJndW1lbnQuIiksCisgICAgICAgICAgICAgICAmcmVjb3JkX2Nt ZGxpc3QpOworICBzZXRfY21kX2NvbXBsZXRlciAoYywgZmlsZW5hbWVfY29t cGxldGVyKTsKIAogICBhZGRfY21kICgiZGVsZXRlIiwgY2xhc3Nfb2JzY3Vy ZSwgY21kX3JlY29yZF9kZWxldGUsCiAJICAgXygiRGVsZXRlIHRoZSByZXN0 IG9mIGV4ZWN1dGlvbiBsb2cgYW5kIHN0YXJ0IHJlY29yZGluZyBpdCBhbmV3 LiIpLAo= --000325574c8686ea1804706185eb--