From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 4514 invoked by alias); 6 Aug 2009 14:16:59 -0000 Received: (qmail 4440 invoked by uid 22791); 6 Aug 2009 14:16:49 -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 wf-out-1314.google.com (HELO wf-out-1314.google.com) (209.85.200.175) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 06 Aug 2009 14:16:34 +0000 Received: by wf-out-1314.google.com with SMTP id 23so366845wfg.24 for ; Thu, 06 Aug 2009 07:16:30 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.233.9 with SMTP id f9mr1306810wfh.341.1249568190395; Thu, 06 Aug 2009 07:16:30 -0700 (PDT) In-Reply-To: <83ab2docqi.fsf@gnu.org> References: <83ws5koinl.fsf@gnu.org> <83my6fo2pa.fsf@gnu.org> <4A78935B.5030508@vmware.com> <4A79F802.4060102@vmware.com> <83ab2docqi.fsf@gnu.org> From: Hui Zhu Date: Thu, 06 Aug 2009 14:16:00 -0000 Message-ID: Subject: Re: [RFA/RFC] Add dump and load command to process record and replay To: Eli Zaretskii , Michael Snyder Cc: gdb-patches@sourceware.org Content-Type: multipart/mixed; boundary=000e0cd2e2f81c7748047079c401 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/msg00085.txt.bz2 --000e0cd2e2f81c7748047079c401 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 39101 On Thu, Aug 6, 2009 at 11:14, Eli Zaretskii wrote: >> Date: Wed, 05 Aug 2009 14:22:10 -0700 >> From: Michael Snyder >> CC: Eli Zaretskii , >> =A0"gdb-patches@sourceware.org" >> >> Here's a suggested comment to start documenting the file format: >> >> /* Record log save-file format >> =A0 =A0 Version 1 >> >> =A0 =A0 =A0 Header: >> =A0 =A0 =A0 =A0 4 bytes: magic number RECORD_FILE_MAGIC. >> =A0 =A0 =A0 =A0 =A0 NOTE: be sure to change whenever this file format ch= anges! >> >> =A0 =A0 =A0 Records: >> =A0 =A0 =A0 =A0record_end: >> =A0 =A0 =A0 =A0 1 byte: =A0record type (record_end) >> =A0 =A0 =A0 =A0record_reg: >> =A0 =A0 =A0 =A0 1 byte: =A0record type (record_reg) >> =A0 =A0 =A0 =A0 8 bytes: register id >> =A0 =A0 =A0 =A016 bytes: register value >> =A0 =A0 =A0 =A0record_mem: >> =A0 =A0 =A0 =A0 1 byte: =A0record type (record_mem) >> =A0 =A0 =A0 =A0 8 bytes: memory address >> =A0 =A0 =A0 =A0 8 bytes: memory length >> =A0 =A0 =A0 =A0 n bytes: memory value (n =3D=3D memory length) > > This doesn't document the byte order. > I make a new version include byte order. Please help me review it. Thanks, Hui 2009-08-06 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 | 806 +++++++++++++++++++++++++++++++++++++++++++++++++++++++---= ----- 1 file changed, 715 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,369 @@ 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); +} + +/* Record log save-file format + Version 1 + + Header: + 4 bytes: magic number htonl(0x20090726). + NOTE: be sure to change whenever this file format changes! + + Records: + record_end: + 1 byte: record type (record_end). + record_reg: + 1 byte: record type (record_reg). + 8 bytes: register id (network byte order). + MAX_REGISTER_SIZE bytes: register value. + record_mem: + 1 byte: record type (record_mem). + 8 bytes: memory address (network byte order). + 8 bytes: memory length (network byte order). + n bytes: memory value (n =3D=3D memory length). +*/ + +/* 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. */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Saving recording to file '%s'\n"), + recfilename); + 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; + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Writing 4-byte magic cookie RECORD_FILE_MAGIC (0x%08x)\n"), + 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 */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Writing register %d (1 plus 8 plus %d bytes)\n"), + record_list->u.reg.num, + MAX_REGISTER_SIZE); + + 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) + { + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Writing memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"), + paddress (gdbarch, + record_list->u.mem.addr), + record_list->u.mem.len); + + 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; + + case record_end: + /* FIXME: record the contents of record_end rec. */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Writing record_end (1 byte)\n")); + break; + } + } + + /* Execute entry. */ + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->next) + record_list =3D record_list->next; + else + break; + } + + /* Reverse execute to cur_record_list. */ + while (1) + { + /* Check for beginning and end of log. */ + if (record_list =3D=3D cur_record_list) + break; + + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->prev) + record_list =3D record_list->prev; + } + + do_cleanups (set_cleanups); + do_cleanups (old_cleanups); + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, _("Saved 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= ); + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Reading register %d (1 plus 8 plus %d bytes)\n"), + rec->u.reg.num, + 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); + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, _("\ +Reading memory %s (1 plus 8 plus 8 bytes plus %d bytes)\n"), + paddress (get_current_arch (), + rec->u.mem.addr), + rec->u.mem.len); + + record_arch_list_add (rec); + break; + + case record_end: /* end */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, + _("Reading record_end (1 byte)\n")); + + 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 +1816,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 +1856,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 +1891,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."), --000e0cd2e2f81c7748047079c401 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_fy1kloii0 Content-length: 48251 LS0tCiByZWNvcmQuYyB8ICA4MDYgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgNzE1IGluc2VydGlvbnMoKyksIDkxIGRlbGV0aW9ucygt 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 SUM7CiB9CkBAIC0xMTU0LDYgKzE0MDMsMzY5IEBAIGNtZF9yZWNvcmRfc3Rh cnQgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3QKICAgZXhlY3V0ZV9jb21tYW5k ICgidGFyZ2V0IHJlY29yZCIsIGZyb21fdHR5KTsKIH0KIAorc3RhdGljIHZv aWQKK2NtZF9yZWNvcmRfZmRfY2xlYW51cHMgKHZvaWQgKnJlY2ZkcCkKK3sK KyAgaW50IHJlY2ZkID0gKihpbnQgKikgcmVjZmRwOworICBjbG9zZSAocmVj ZmQpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3JlY29yZF9yZWFkX2R1 bXAgKGNoYXIgKnJlY2ZpbGVuYW1lLCBpbnQgZmlsZGVzLCB2b2lkICpidWYs IHNpemVfdCBuYnl0ZSkKK3sKKyAgaWYgKHJlYWQgKGZpbGRlcywgYnVmLCBu Ynl0ZSkgIT0gbmJ5dGUpCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFk IGR1bXAgb2YgZXhlY3V0aW9uIHJlY29yZHMgaW4gJyVzJy4iKSwKKyAgICAg ICAgICAgcmVjZmlsZW5hbWUpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQK K3JlY29yZF93cml0ZV9kdW1wIChjaGFyICpyZWNmaWxlbmFtZSwgaW50IGZp bGRlcywgY29uc3Qgdm9pZCAqYnVmLAorICAgICAgICAgICAgICAgICAgIHNp emVfdCBuYnl0ZSkKK3sKKyAgaWYgKHdyaXRlIChmaWxkZXMsIGJ1ZiwgbmJ5 dGUpICE9IG5ieXRlKQorICAgIGVycm9yIChfKCJGYWlsZWQgdG8gd3JpdGUg ZHVtcCBvZiBleGVjdXRpb24gcmVjb3JkcyB0byAnJXMnLiIpLAorICAgICAg ICAgICByZWNmaWxlbmFtZSk7Cit9CisKKy8qIFJlY29yZCBsb2cgc2F2ZS1m aWxlIGZvcm1hdAorICAgVmVyc2lvbiAxCisKKyAgIEhlYWRlcjoKKyAgICAg NCBieXRlczogbWFnaWMgbnVtYmVyIGh0b25sKDB4MjAwOTA3MjYpLgorICAg ICAgIE5PVEU6IGJlIHN1cmUgdG8gY2hhbmdlIHdoZW5ldmVyIHRoaXMgZmls ZSBmb3JtYXQgY2hhbmdlcyEKKworICAgUmVjb3JkczoKKyAgICAgcmVjb3Jk X2VuZDoKKyAgICAgICAxIGJ5dGU6ICByZWNvcmQgdHlwZSAocmVjb3JkX2Vu ZCkuCisgICAgIHJlY29yZF9yZWc6CisgICAgICAgMSBieXRlOiAgcmVjb3Jk IHR5cGUgKHJlY29yZF9yZWcpLgorICAgICAgIDggYnl0ZXM6IHJlZ2lzdGVy IGlkIChuZXR3b3JrIGJ5dGUgb3JkZXIpLgorICAgICAgIE1BWF9SRUdJU1RF Ul9TSVpFIGJ5dGVzOiByZWdpc3RlciB2YWx1ZS4KKyAgICAgcmVjb3JkX21l bToKKyAgICAgICAxIGJ5dGU6ICByZWNvcmQgdHlwZSAocmVjb3JkX21lbSku CisgICAgICAgOCBieXRlczogbWVtb3J5IGFkZHJlc3MgKG5ldHdvcmsgYnl0 ZSBvcmRlcikuCisgICAgICAgOCBieXRlczogbWVtb3J5IGxlbmd0aCAobmV0 d29yayBieXRlIG9yZGVyKS4KKyAgICAgICBuIGJ5dGVzOiBtZW1vcnkgdmFs dWUgKG4gPT0gbWVtb3J5IGxlbmd0aCkuCisqLworCisvKiBEdW1wIHRoZSBl eGVjdXRpb24gbG9nIHRvIGEgZmlsZS4gICovCisKK3N0YXRpYyB2b2lkCitj bWRfcmVjb3JkX2R1bXAgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0eSkKK3sK KyAgY2hhciAqcmVjZmlsZW5hbWUsIHJlY2ZpbGVuYW1lX2J1ZmZlcls0MF07 CisgIGludCByZWNmZDsKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqY3VyX3Jl Y29yZF9saXN0OworICB1aW50MzJfdCBtYWdpYzsKKyAgc3RydWN0IHJlZ2Nh Y2hlICpyZWdjYWNoZTsKKyAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2g7Cisg IHN0cnVjdCBjbGVhbnVwICpvbGRfY2xlYW51cHM7CisgIHN0cnVjdCBjbGVh bnVwICpzZXRfY2xlYW51cHM7CisKKyAgaWYgKGN1cnJlbnRfdGFyZ2V0LnRv X3N0cmF0dW0gIT0gcmVjb3JkX3N0cmF0dW0pCisgICAgZXJyb3IgKF8oIlBy b2Nlc3MgcmVjb3JkIGlzIG5vdCBzdGFydGVkLlxuIikpOworCisgIGlmIChh cmdzICYmICphcmdzKQorICAgIHJlY2ZpbGVuYW1lID0gYXJnczsKKyAgZWxz ZQorICAgIHsKKyAgICAgIC8qIERlZmF1bHQgY29yZWZpbGUgbmFtZSBpcyAi Z2RiX3JlY29yZC5QSUQiLiAgKi8KKyAgICAgIHNwcmludGYgKHJlY2ZpbGVu YW1lX2J1ZmZlciwgImdkYl9yZWNvcmQuJWQiLCBQSURHRVQgKGluZmVyaW9y X3B0aWQpKTsKKyAgICAgIHJlY2ZpbGVuYW1lID0gcmVjZmlsZW5hbWVfYnVm ZmVyOworICAgIH0KKworICAvKiBPcGVuIHRoZSBkdW1wIGZpbGUuICAqLwor ICBpZiAocmVjb3JkX2RlYnVnKQorICAgIGZwcmludGZfdW5maWx0ZXJlZCAo Z2RiX3N0ZGxvZywKKyAgICAgICAgICAgICAgICAgICAgICAgIF8oIlNhdmlu ZyByZWNvcmRpbmcgdG8gZmlsZSAnJXMnXG4iKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgIHJlY2ZpbGVuYW1lKTsKKyAgcmVjZmQgPSBvcGVuIChyZWNm aWxlbmFtZSwgT19XUk9OTFkgfCBPX0NSRUFUIHwgT19UUlVOQyB8IE9fQklO QVJZLAorICAgICAgICAgICAgICAgIFNfSVJVU1IgfCBTX0lXVVNSKTsKKyAg aWYgKHJlY2ZkIDwgMCkKKyAgICBlcnJvciAoXygiRmFpbGVkIHRvIG9wZW4g JyVzJyBmb3IgZHVtcCBleGVjdXRpb24gcmVjb3JkczogJXMiKSwKKyAgICAg ICAgICAgcmVjZmlsZW5hbWUsIHN0cmVycm9yIChlcnJubykpOworICBvbGRf Y2xlYW51cHMgPSBtYWtlX2NsZWFudXAgKGNtZF9yZWNvcmRfZmRfY2xlYW51 cHMsICZyZWNmZCk7CisKKyAgLyogU2F2ZSB0aGUgY3VycmVudCByZWNvcmQg ZW50cnkgdG8gImN1cl9yZWNvcmRfbGlzdCIuICAqLworICBjdXJfcmVjb3Jk X2xpc3QgPSByZWNvcmRfbGlzdDsKKworICAvKiBHZXQgdGhlIHZhbHVlcyBv ZiByZWdjYWNoZSBhbmQgZ2RiYXJjaC4gICovCisgIHJlZ2NhY2hlID0gZ2V0 X2N1cnJlbnRfcmVnY2FjaGUgKCk7CisgIGdkYmFyY2ggPSBnZXRfcmVnY2Fj aGVfYXJjaCAocmVnY2FjaGUpOworCisgIC8qIERpc2FibGUgdGhlIEdEQiBv cGVyYXRpb24gcmVjb3JkLiAgKi8KKyAgc2V0X2NsZWFudXBzID0gcmVjb3Jk X2dkYl9vcGVyYXRpb25fZGlzYWJsZV9zZXQgKCk7CisKKyAgLyogV3JpdGUg dGhlIG1hZ2ljIGNvZGUuICAqLworICBtYWdpYyA9IFJFQ09SRF9GSUxFX01B R0lDOworICBpZiAocmVjb3JkX2RlYnVnKQorICAgIGZwcmludGZfdW5maWx0 ZXJlZCAoZ2RiX3N0ZGxvZywgXygiXAorV3JpdGluZyA0LWJ5dGUgbWFnaWMg Y29va2llIFJFQ09SRF9GSUxFX01BR0lDICgweCUwOHgpXG4iKSwKKyAgICAg ICAgICAgICAgICAgICAgICAgIG1hZ2ljKTsKKyAgcmVjb3JkX3dyaXRlX2R1 bXAgKHJlY2ZpbGVuYW1lLCByZWNmZCwgJm1hZ2ljLCA0KTsKKworICAvKiBS ZXZlcnNlIGV4ZWN1dGUgdG8gdGhlIGJlZ2luIG9mIHJlY29yZCBsaXN0LiAg Ki8KKyAgd2hpbGUgKDEpCisgICAgeworICAgICAgLyogQ2hlY2sgZm9yIGJl Z2lubmluZyBhbmQgZW5kIG9mIGxvZy4gICovCisgICAgICBpZiAocmVjb3Jk X2xpc3QgPT0gJnJlY29yZF9maXJzdCkKKyAgICAgICAgYnJlYWs7CisKKyAg ICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVj b3JkX2xpc3QpOworCisgICAgICBpZiAocmVjb3JkX2xpc3QtPnByZXYpCisg ICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2xpc3QtPnByZXY7CisgICAg fQorCisgIC8qIER1bXAgdGhlIGVudHJpZXMgdG8gcmVjZmQgYW5kIGZvcndh cmQgZXhlY3V0ZSB0byB0aGUgZW5kIG9mCisgICAgIHJlY29yZCBsaXN0LiAg Ki8KKyAgd2hpbGUgKDEpCisgICAgeworICAgICAgLyogRHVtcCBlbnRyeS4g ICovCisgICAgICBpZiAocmVjb3JkX2xpc3QgIT0gJnJlY29yZF9maXJzdCkK KyAgICAgICAgeworICAgICAgICAgIHVpbnQ4X3QgdG1wdTg7CisgICAgICAg ICAgdWludDY0X3QgdG1wdTY0OworCisgICAgICAgICAgdG1wdTggPSByZWNv cmRfbGlzdC0+dHlwZTsKKyAgICAgICAgICByZWNvcmRfd3JpdGVfZHVtcCAo cmVjZmlsZW5hbWUsIHJlY2ZkLCAmdG1wdTgsIDEpOworCisgICAgICAgICAg c3dpdGNoIChyZWNvcmRfbGlzdC0+dHlwZSkKKyAgICAgICAgICAgIHsKKyAg ICAgICAgICAgIGNhc2UgcmVjb3JkX3JlZzogLyogcmVnICovCisgICAgICAg ICAgICAgIGlmIChyZWNvcmRfZGVidWcpCisgICAgICAgICAgICAgICAgZnBy aW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCBfKCJcCitXcml0aW5nIHJl Z2lzdGVyICVkICgxIHBsdXMgOCBwbHVzICVkIGJ5dGVzKVxuIiksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+ dS5yZWcubnVtLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgTUFYX1JFR0lTVEVSX1NJWkUpOworCisgICAgICAgICAgICAgIHRtcHU2 NCA9IHJlY29yZF9saXN0LT51LnJlZy5udW07CisgICAgICAgICAgICAgIGlm IChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAgICAg ICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAgICAg IHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsICZ0bXB1 NjQsIDgpOworCisgICAgICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1wIChy ZWNmaWxlbmFtZSwgcmVjZmQsIHJlY29yZF9saXN0LT51LnJlZy52YWwsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNQVhfUkVHSVNURVJf U0laRSk7CisgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAgICAgICBj YXNlIHJlY29yZF9tZW06IC8qIG1lbSAqLworICAgICAgICAgICAgICBpZiAo IXJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUp CisgICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgaWYgKHJl Y29yZF9kZWJ1ZykKKyAgICAgICAgICAgICAgICAgICAgZnByaW50Zl91bmZp bHRlcmVkIChnZGJfc3RkbG9nLCBfKCJcCitXcml0aW5nIG1lbW9yeSAlcyAo MSBwbHVzIDggcGx1cyA4IGJ5dGVzIHBsdXMgJWQgYnl0ZXMpXG4iKSwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwYWRkcmVz cyAoZ2RiYXJjaCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmFkZHIpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29y ZF9saXN0LT51Lm1lbS5sZW4pOworCisgICAgICAgICAgICAgICAgICB0bXB1 NjQgPSByZWNvcmRfbGlzdC0+dS5tZW0uYWRkcjsKKyAgICAgICAgICAgICAg ICAgIGlmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAg ICAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAg ICAgICAgICAgICAgICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1l LCByZWNmZCwgJnRtcHU2NCwgOCk7CisKKyAgICAgICAgICAgICAgICAgIHRt cHU2NCA9IHJlY29yZF9saXN0LT51Lm1lbS5sZW47CisgICAgICAgICAgICAg ICAgICBpZiAoQllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAg ICAgICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyAg ICAgICAgICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFt ZSwgcmVjZmQsICZ0bXB1NjQsIDgpOworCisgICAgICAgICAgICAgICAgICBy ZWNvcmRfd3JpdGVfZHVtcCAocmVjZmlsZW5hbWUsIHJlY2ZkLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51 Lm1lbS52YWwsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisgICAgICAgICAgICAgICAg fQorICAgICAgICAgICAgICBicmVhazsKKworICAgICAgICAgICAgICBjYXNl IHJlY29yZF9lbmQ6CisgICAgICAgICAgICAgICAgLyogRklYTUU6IHJlY29y ZCB0aGUgY29udGVudHMgb2YgcmVjb3JkX2VuZCByZWMuICAqLworICAgICAg ICAgICAgICAgIGlmIChyZWNvcmRfZGVidWcpCisgICAgICAgICAgICAgICAg ICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIF8oIldyaXRpbmcgcmVjb3Jk X2VuZCAoMSBieXRlKVxuIikpOworICAgICAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICAgICAgfQorICAgICAgICB9CisKKyAgICAgIC8qIEV4ZWN1dGUg ZW50cnkuICAqLworICAgICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hl LCBnZGJhcmNoLCByZWNvcmRfbGlzdCk7CisKKyAgICAgIGlmIChyZWNvcmRf bGlzdC0+bmV4dCkKKyAgICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlz dC0+bmV4dDsKKyAgICAgIGVsc2UKKyAgICAgICAgYnJlYWs7CisgICAgfQor CisgIC8qIFJldmVyc2UgZXhlY3V0ZSB0byBjdXJfcmVjb3JkX2xpc3QuICAq LworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBDaGVjayBmb3IgYmVn aW5uaW5nIGFuZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAgIGlmIChyZWNvcmRf bGlzdCA9PSBjdXJfcmVjb3JkX2xpc3QpCisgICAgICAgIGJyZWFrOworCisg ICAgICByZWNvcmRfZXhlY19lbnRyeSAocmVnY2FjaGUsIGdkYmFyY2gsIHJl Y29yZF9saXN0KTsKKworICAgICAgaWYgKHJlY29yZF9saXN0LT5wcmV2KQor ICAgICAgICByZWNvcmRfbGlzdCA9IHJlY29yZF9saXN0LT5wcmV2OworICAg IH0KKworICBkb19jbGVhbnVwcyAoc2V0X2NsZWFudXBzKTsKKyAgZG9fY2xl YW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgLyogU3VjY2VlZGVkLiAgKi8K KyAgZnByaW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZG91dCwgXygiU2F2ZWQgZHVt cCBvZiBleGVjdXRpb24gIgorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJyZWNvcmRzIHRvIGAlcycuXG4iKSwKKyAgICAgICAgICAgICAg ICAgICAgcmVjZmlsZW5hbWUpOworfQorCisvKiBMb2FkIHRoZSBleGVjdXRp b24gbG9nIGZyb20gYSBmaWxlLiAgKi8KKworc3RhdGljIHZvaWQKK2NtZF9y ZWNvcmRfbG9hZCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQoreworICBp bnQgcmVjZmQ7CisgIHVpbnQzMl90IG1hZ2ljOworICBzdHJ1Y3QgY2xlYW51 cCAqb2xkX2NsZWFudXBzOworICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFu dXBzMjsKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVjOworICBpbnQgaW5z bl9udW1iZXIgPSAwOworCisgIGlmIChjdXJyZW50X3RhcmdldC50b19zdHJh dHVtICE9IHJlY29yZF9zdHJhdHVtKQorICAgIHsKKyAgICAgIGNtZF9yZWNv cmRfc3RhcnQgKE5VTEwsIGZyb21fdHR5KTsKKyAgICAgIHByaW50Zl91bmZp bHRlcmVkIChfKCJBdXRvIHN0YXJ0IHByb2Nlc3MgcmVjb3JkLlxuIikpOwor ICAgIH0KKworICBpZiAoIWFyZ3MgfHwgKGFyZ3MgJiYgISphcmdzKSkKKyAg ICBlcnJvciAoXygiQXJndW1lbnQgZm9yIGZpbGVuYW1lIHJlcXVpcmVkLlxu IikpOworCisgIC8qIE9wZW4gdGhlIGxvYWQgZmlsZS4gICovCisgIHJlY2Zk ID0gb3BlbiAoYXJncywgT19SRE9OTFkgfCBPX0JJTkFSWSk7CisgIGlmIChy ZWNmZCA8IDApCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byBvcGVuICclcycg Zm9yIGxvYWRpbmcgZXhlY3V0aW9uIHJlY29yZHM6ICVzIiksCisgICAgICAg ICAgIGFyZ3MsIHN0cmVycm9yIChlcnJubykpOworICBvbGRfY2xlYW51cHMg PSBtYWtlX2NsZWFudXAgKGNtZF9yZWNvcmRfZmRfY2xlYW51cHMsICZyZWNm ZCk7CisKKyAgLyogQ2hlY2sgdGhlIG1hZ2ljIGNvZGUuICAqLworICByZWNv cmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwgJm1hZ2ljLCA0KTsKKyAgaWYg KG1hZ2ljICE9IFJFQ09SRF9GSUxFX01BR0lDKQorICAgIGVycm9yIChfKCIn JXMnIGlzIG5vdCBhIHZhbGlkIGR1bXAgb2YgZXhlY3V0aW9uIHJlY29yZHMu IiksIGFyZ3MpOworCisgIC8qIExvYWQgdGhlIGVudHJpZXMgaW4gcmVjZmQg dG8gdGhlIHJlY29yZF9hcmNoX2xpc3RfaGVhZCBhbmQKKyAgICAgcmVjb3Jk X2FyY2hfbGlzdF90YWlsLiAgKi8KKyAgcmVjb3JkX2FyY2hfbGlzdF9oZWFk ID0gTlVMTDsKKyAgcmVjb3JkX2FyY2hfbGlzdF90YWlsID0gTlVMTDsKKyAg b2xkX2NsZWFudXBzMiA9IG1ha2VfY2xlYW51cCAocmVjb3JkX2FyY2hfbGlz dF9jbGVhbnVwcywgMCk7CisKKyAgd2hpbGUgKDEpCisgICAgeworICAgICAg aW50IHJldDsKKyAgICAgIHVpbnQ4X3QgdG1wdTg7CisgICAgICB1aW50NjRf dCB0bXB1NjQ7CisKKyAgICAgIHJldCA9IHJlYWQgKHJlY2ZkLCAmdG1wdTgs IDEpOworICAgICAgaWYgKHJldCA8IDApCisgICAgICAgIGVycm9yIChfKCJG YWlsZWQgdG8gcmVhZCBkdW1wIG9mIGV4ZWN1dGlvbiByZWNvcmRzIGluICcl cycuIiksIGFyZ3MpOworICAgICAgaWYgKHJldCA9PSAwKQorICAgICAgICBi cmVhazsKKworICAgICAgc3dpdGNoICh0bXB1OCkKKyAgICAgICAgeworICAg ICAgICBjYXNlIHJlY29yZF9yZWc6IC8qIHJlZyAqLworICAgICAgICAgIHJl YyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2MgKHNpemVvZiAo c3RydWN0IHJlY29yZF9lbnRyeSkpOworICAgICAgICAgIHJlYy0+dS5yZWcu dmFsID0gKGdkYl9ieXRlICopIHhtYWxsb2MgKE1BWF9SRUdJU1RFUl9TSVpF KTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOworICAgICAgICAgIHJl Yy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50eXBlID0gcmVjb3Jk X3JlZzsKKworICAgICAgICAgIC8qIEdldCBudW0uICAqLworICAgICAgICAg IHJlY29yZF9yZWFkX2R1bXAgKGFyZ3MsIHJlY2ZkLCAmdG1wdTY0LCA4KTsK KyAgICAgICAgICBpZiAoQllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQor ICAgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAg ICAgICAgcmVjLT51LnJlZy5udW0gPSB0bXB1NjQ7CisKKyAgICAgICAgICAv KiBHZXQgdmFsLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChh cmdzLCByZWNmZCwgcmVjLT51LnJlZy52YWwsIE1BWF9SRUdJU1RFUl9TSVpF KTsKKworICAgICAgICAgIGlmIChyZWNvcmRfZGVidWcpCisgICAgICAgICAg ICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csIF8oIlwKK1JlYWRp bmcgcmVnaXN0ZXIgJWQgKDEgcGx1cyA4IHBsdXMgJWQgYnl0ZXMpXG4iKSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjLT51LnJlZy5u dW0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE1BWF9SRUdJ U1RFUl9TSVpFKTsKKworICAgICAgICAgIHJlY29yZF9hcmNoX2xpc3RfYWRk IChyZWMpOworICAgICAgICAgIGJyZWFrOworCisgICAgICAgIGNhc2UgcmVj b3JkX21lbTogLyogbWVtICovCisgICAgICAgICAgcmVjID0gKHN0cnVjdCBy ZWNvcmRfZW50cnkgKikgeG1hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgcmVjb3Jk X2VudHJ5KSk7CisgICAgICAgICAgcmVjLT5wcmV2ID0gTlVMTDsKKyAgICAg ICAgICByZWMtPm5leHQgPSBOVUxMOworICAgICAgICAgIHJlYy0+dHlwZSA9 IHJlY29yZF9tZW07CisKKyAgICAgICAgICAvKiBHZXQgYWRkci4gICovCisg ICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAoYXJncywgcmVjZmQsICZ0bXB1 NjQsIDgpOworICAgICAgICAgIGlmIChCWVRFX09SREVSID09IExJVFRMRV9F TkRJQU4pCisgICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0 KTsKKyAgICAgICAgICByZWMtPnUubWVtLmFkZHIgPSB0bXB1NjQ7CisKKyAg ICAgICAgICAvKiBHZXQgbGVuLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVh ZF9kdW1wIChhcmdzLCByZWNmZCwgJnRtcHU2NCwgOCk7CisgICAgICAgICAg aWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAg IHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJlYy0+ dS5tZW0ubGVuID0gdG1wdTY0OworICAgICAgICAgIHJlYy0+dS5tZW0ubWVt X2VudHJ5X25vdF9hY2Nlc3NpYmxlID0gMDsKKyAgICAgICAgICByZWMtPnUu bWVtLnZhbCA9IChnZGJfYnl0ZSAqKSB4bWFsbG9jIChyZWMtPnUubWVtLmxl bik7CisKKyAgICAgICAgICAvKiBHZXQgdmFsLiAgKi8KKyAgICAgICAgICBy ZWNvcmRfcmVhZF9kdW1wIChhcmdzLCByZWNmZCwgcmVjLT51Lm1lbS52YWws IHJlYy0+dS5tZW0ubGVuKTsKKworICAgICAgICAgIGlmIChyZWNvcmRfZGVi dWcpCisgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRs b2csIF8oIlwKK1JlYWRpbmcgbWVtb3J5ICVzICgxIHBsdXMgOCBwbHVzIDgg Ynl0ZXMgcGx1cyAlZCBieXRlcylcbiIpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZXRfY3VycmVudF9h cmNoICgpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZWMtPnUubWVtLmFkZHIpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlYy0+dS5tZW0ubGVuKTsK KworICAgICAgICAgIHJlY29yZF9hcmNoX2xpc3RfYWRkIChyZWMpOworICAg ICAgICAgIGJyZWFrOworCisgICAgICAgIGNhc2UgcmVjb3JkX2VuZDogLyog ZW5kICovCisgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICAgICAg ICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgXygiUmVhZGluZyByZWNvcmRfZW5k ICgxIGJ5dGUpXG4iKSk7CisKKyAgICAgICAgICByZWMgPSAoc3RydWN0IHJl Y29yZF9lbnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRf ZW50cnkpKTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOworICAgICAg ICAgIHJlYy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50eXBlID0g cmVjb3JkX2VuZDsKKyAgICAgICAgICByZWNvcmRfYXJjaF9saXN0X2FkZCAo cmVjKTsKKyAgICAgICAgICBpbnNuX251bWJlciArKzsKKyAgICAgICAgICBi cmVhazsKKworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgIGVycm9yIChf KCJGb3JtYXQgb2YgJyVzJyBpcyBub3QgcmlnaHQuIiksIGFyZ3MpOworICAg ICAgICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorCisgIGRpc2NhcmRf Y2xlYW51cHMgKG9sZF9jbGVhbnVwczIpOworCisgIC8qIEFkZCByZWNvcmRf YXJjaF9saXN0X2hlYWQgdG8gdGhlIGVuZCBvZiByZWNvcmQgbGlzdC4gICov CisgIGZvciAocmVjID0gcmVjb3JkX2xpc3Q7IHJlYy0+bmV4dDsgcmVjID0g cmVjLT5uZXh0KTsKKyAgcmVjLT5uZXh0ID0gcmVjb3JkX2FyY2hfbGlzdF9o ZWFkOworICByZWNvcmRfYXJjaF9saXN0X2hlYWQtPnByZXYgPSByZWM7CisK KyAgLyogVXBkYXRlIHJlY29yZF9pbnNuX251bSBhbmQgcmVjb3JkX2luc25f bWF4X251bS4gICovCisgIHJlY29yZF9pbnNuX251bSArPSBpbnNuX251bWJl cjsKKyAgaWYgKHJlY29yZF9pbnNuX251bSA+IHJlY29yZF9pbnNuX21heF9u dW0pCisgICAgeworICAgICAgcmVjb3JkX2luc25fbWF4X251bSA9IHJlY29y ZF9pbnNuX251bTsKKyAgICAgIHdhcm5pbmcgKF8oIkF1dG8gaW5jcmVhc2Ug cmVjb3JkL3JlcGxheSBidWZmZXIgbGltaXQgdG8gJWQuIiksCisgICAgICAg ICAgICAgICByZWNvcmRfaW5zbl9tYXhfbnVtKTsKKyAgICB9CisKKyAgZG9f Y2xlYW51cHMgKG9sZF9jbGVhbnVwcyk7CisKKyAgLyogU3VjY2VlZGVkLiAg Ki8KKyAgZnByaW50Zl9maWx0ZXJlZCAoZ2RiX3N0ZG91dCwgIkxvYWRlZCBy ZWNmaWxlICVzLlxuIiwgYXJncyk7Cit9CisKIC8qIFRydW5jYXRlIHRoZSBy ZWNvcmQgbG9nIGZyb20gdGhlIHByZXNlbnQgcG9pbnQKICAgIG9mIHJlcGxh eSB1bnRpbCB0aGUgZW5kLiAgKi8KIApAQCAtMTIwNCw3ICsxODE2LDcgQEAg c2V0X3JlY29yZF9pbnNuX21heF9udW0gKGNoYXIgKmFyZ3MsIGludAogCQkg ICAgICAgICAgICJ0aGUgZmlyc3Qgb25lcz9cbiIpKTsKIAogICAgICAgd2hp bGUgKHJlY29yZF9pbnNuX251bSA+IHJlY29yZF9pbnNuX21heF9udW0pCi0J cmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdCAoKTsKKwlyZWNvcmRfbGlzdF9y ZWxlYXNlX2ZpcnN0X2luc24gKCk7CiAgICAgfQogfQogCkBAIC0xMjQ0LDYg KzE4NTYsOCBAQCBpbmZvX3JlY29yZF9jb21tYW5kIChjaGFyICphcmdzLCBp bnQgZnJvCiB2b2lkCiBfaW5pdGlhbGl6ZV9yZWNvcmQgKHZvaWQpCiB7Cisg IHN0cnVjdCBjbWRfbGlzdF9lbGVtZW50ICpjOworCiAgIC8qIEluaXQgcmVj b3JkX2ZpcnN0LiAgKi8KICAgcmVjb3JkX2ZpcnN0LnByZXYgPSBOVUxMOwog ICByZWNvcmRfZmlyc3QubmV4dCA9IE5VTEw7CkBAIC0xMjc3LDYgKzE4OTEs MTYgQEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogCQkgICJpbmZvIHJl Y29yZCAiLCAwLCAmaW5mb2xpc3QpOwogICBhZGRfYWxpYXNfY21kICgicmVj IiwgInJlY29yZCIsIGNsYXNzX29ic2N1cmUsIDEsICZpbmZvbGlzdCk7CiAK KyAgYyA9IGFkZF9jbWQgKCJkdW1wIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3Jl Y29yZF9kdW1wLAorCSAgICAgICBfKCJEdW1wIHRoZSBleGVjdXRpb24gcmVj b3JkcyB0byBhIGZpbGUuXG5cCitBcmd1bWVudCBpcyBvcHRpb25hbCBmaWxl bmFtZS4gIERlZmF1bHQgZmlsZW5hbWUgaXMgJ2dkYl9yZWNvcmQuPHByb2Nl c3NfaWQ+Jy4iKSwKKyAgICAgICAgICAgICAgICZyZWNvcmRfY21kbGlzdCk7 CisgIHNldF9jbWRfY29tcGxldGVyIChjLCBmaWxlbmFtZV9jb21wbGV0ZXIp OworICBjID0gYWRkX2NtZCAoImxvYWQiLCBjbGFzc19vYnNjdXJlLCBjbWRf cmVjb3JkX2xvYWQsCisJICAgICAgIF8oIkxvYWQgcHJldmlvdXNseSBkdW1w ZWQgZXhlY3V0aW9uIHJlY29yZHMgZnJvbSBcCithIGZpbGUgZ2l2ZW4gYXMg YXJndW1lbnQuIiksCisgICAgICAgICAgICAgICAmcmVjb3JkX2NtZGxpc3Qp OworICBzZXRfY21kX2NvbXBsZXRlciAoYywgZmlsZW5hbWVfY29tcGxldGVy KTsKIAogICBhZGRfY21kICgiZGVsZXRlIiwgY2xhc3Nfb2JzY3VyZSwgY21k X3JlY29yZF9kZWxldGUsCiAJICAgXygiRGVsZXRlIHRoZSByZXN0IG9mIGV4 ZWN1dGlvbiBsb2cgYW5kIHN0YXJ0IHJlY29yZGluZyBpdCBhbmV3LiIpLAo= --000e0cd2e2f81c7748047079c401--