From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 29022 invoked by alias); 24 Aug 2009 07:46:19 -0000 Received: (qmail 28982 invoked by uid 22791); 24 Aug 2009 07:46:09 -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-px0-f193.google.com (HELO mail-px0-f193.google.com) (209.85.216.193) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 24 Aug 2009 07:45:54 +0000 Received: by pxi31 with SMTP id 31so2530465pxi.24 for ; Mon, 24 Aug 2009 00:45:52 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.248.38 with SMTP id v38mr320363wfh.280.1251099952159; Mon, 24 Aug 2009 00:45:52 -0700 (PDT) In-Reply-To: <4A91CEEC.5000802@vmware.com> References: <4A7B9F49.9030202@vmware.com> <83ws5gm30b.fsf@gnu.org> <4A7C625B.8080005@vmware.com> <4A7F5410.4000400@vmware.com> <4A91CEEC.5000802@vmware.com> From: Hui Zhu Date: Mon, 24 Aug 2009 08:20:00 -0000 Message-ID: Subject: Re: [RFA/RFC] Add dump and load command to process record and replay To: Michael Snyder Cc: Eli Zaretskii , "gdb-patches@sourceware.org" Content-Type: multipart/mixed; boundary=00504502ce543a1f080471de6828 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/msg00380.txt.bz2 --00504502ce543a1f080471de6828 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 41227 On Mon, Aug 24, 2009 at 07:21, Michael Snyder wrote: > Hui Zhu wrote: > >> >> Hi Michael, >> >> I make a new version patch. =A0It has a lot of changes. >> Remove record_core and add a new target record_core for core target to >> make the code more clear. >> Make the load together with record_open. >> >> Please help me review it. > > Hi Hui, > > In this review, I'm going to comment only on the parts of the > patch that relate to the record_core_ops (ie. pushing the > record stratum on top of the core file stratum). > > Those parts of the patch are much improved. =A0I like this > version a lot better. =A0Thanks for reworking it. > Hi Michael, Thanks for your review. I make a new patch that update the memset code to: if (target_read_memory (entry->u.mem.addr, mem, entry->u.mem.le= n)) { record_list->u.mem.mem_entry_not_accessible =3D 1; if (record_debug) warning (_("Process record: error reading memory at " "addr =3D %s len =3D %d."), paddress (gdbarch, entry->u.mem.addr), entry->u.mem.len); } else { if (target_write_memory (entry->u.mem.addr, entry->u.mem.va= l, entry->u.mem.len)) { record_list->u.mem.mem_entry_not_accessible =3D 1; if (record_debug) warning (_("Process record: error writing memory at " "addr =3D %s len =3D %d."), paddress (gdbarch, entry->u.mem.addr), entry->u.mem.len); } else memcpy (entry->u.mem.val, mem, entry->u.mem.len); } Please help me review it. Thanks, Hui --- record.c | 951 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----= ----- 1 file changed, 825 insertions(+), 126 deletions(-) --- a/record.c +++ b/record.c @@ -23,15 +23,23 @@ #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) +#define RECORD_FILE_MAGIC htonl(0x20090726) + /* These are the core struct of record function. An record_entry is a record of the value change of a register @@ -78,9 +86,22 @@ struct record_entry } u; }; +struct record_core_buf_entry +{ + struct record_core_buf_entry *prev; + struct target_section *p; + bfd_byte *buf; +}; + /* This is the debug switch for process record. */ int record_debug =3D 0; +/* Record buf with core target. */ +static gdb_byte *record_core_regbuf =3D NULL; +static struct target_section *record_core_start; +static struct target_section *record_core_end; +static struct record_core_buf_entry *record_core_buf_list =3D NULL; + /* These list is for execution log. */ static struct record_entry record_first; static struct record_entry *record_list =3D &record_first; @@ -94,6 +115,7 @@ static int record_insn_num =3D 0; /* The target_ops of process record. */ static struct target_ops record_ops; +static struct target_ops record_core_ops; /* The beneath function pointers. */ static struct target_ops *record_beneath_to_resume_ops; @@ -169,7 +191,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 +362,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 +408,7 @@ record_message (void *args) record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; @@ -416,13 +438,291 @@ record_gdb_operation_disable_set (void) return old_cleanups; } +static inline void +record_exec_entry (struct regcache *regcache, struct gdbarch *gdbarch, + struct record_entry *entry) +{ + switch (entry->type) + { + case record_reg: /* reg */ + { + gdb_byte reg[MAX_REGISTER_SIZE]; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_reg %s to " + "inferior num =3D %d.\n", + host_address_to_string (entry), + entry->u.reg.num); + + regcache_cooked_read (regcache, entry->u.reg.num, reg); + regcache_cooked_write (regcache, entry->u.reg.num, entry->u.reg.va= l); + memcpy (entry->u.reg.val, reg, MAX_REGISTER_SIZE); + } + break; + + case record_mem: /* mem */ + { + if (!record_list->u.mem.mem_entry_not_accessible) + { + gdb_byte *mem =3D alloca (entry->u.mem.len); + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_mem %s to " + "inferior addr =3D %s len =3D %d.\n", + host_address_to_string (entry), + paddress (gdbarch, entry->u.mem.addr), + record_list->u.mem.len); + + if (target_read_memory (entry->u.mem.addr, mem, entry->u.mem.l= en)) + { + record_list->u.mem.mem_entry_not_accessible =3D 1; + if (record_debug) + warning (_("Process record: error reading memory at " + "addr =3D %s len =3D %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + { + if (target_write_memory (entry->u.mem.addr, entry->u.mem.v= al, + entry->u.mem.len)) + { + record_list->u.mem.mem_entry_not_accessible =3D 1; + if (record_debug) + warning (_("Process record: error writing memory at " + "addr =3D %s len =3D %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + memcpy (entry->u.mem.val, mem, entry->u.mem.len); + } + } + } + break; + } +} + +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 void -record_open (char *name, int from_tty) +record_fd_cleanups (void *recfdp) { - struct target_ops *t; + int recfd =3D *(int *) recfdp; + close (recfd); +} - if (record_debug) - fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); +/* Load the execution log from a file. */ + +static void +record_load (char *name) +{ + int recfd; + uint32_t magic; + struct cleanup *old_cleanups; + struct cleanup *old_cleanups2; + struct record_entry *rec; + int insn_number =3D 0; + + if (!name || (name && !*name)) + return; + + /* Open the load file. */ + recfd =3D open (name, O_RDONLY | O_BINARY); + if (recfd < 0) + error (_("Failed to open '%s' for loading execution records: %s"), + name, strerror (errno)); + old_cleanups =3D make_cleanup (record_fd_cleanups, &recfd); + + /* Check the magic code. */ + record_read_dump (name, recfd, &magic, 4); + if (magic !=3D RECORD_FILE_MAGIC) + error (_("'%s' is not a valid dump of execution records."), name); + + /* 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'."), nam= e); + 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 (name, 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 (name, 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 (name, 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 (name, 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 (name, 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."), name); + 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", name); +} + +static struct target_ops *tmp_to_resume_ops; +static void (*tmp_to_resume) (struct target_ops *, ptid_t, int, + enum target_signal); +static struct target_ops *tmp_to_wait_ops; +static ptid_t (*tmp_to_wait) (struct target_ops *, ptid_t, + struct target_waitstatus *, + int); +static struct target_ops *tmp_to_store_registers_ops; +static void (*tmp_to_store_registers) (struct target_ops *, + struct regcache *, + int regno); +static struct target_ops *tmp_to_xfer_partial_ops; +static LONGEST (*tmp_to_xfer_partial) (struct target_ops *ops, + enum target_object object, + const char *annex, + gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, + LONGEST len); +static int (*tmp_to_insert_breakpoint) (struct gdbarch *, + struct bp_target_info *); +static int (*tmp_to_remove_breakpoint) (struct gdbarch *, + struct bp_target_info *); + +static void +record_core_open_1 (char *name, int from_tty) +{ + struct regcache *regcache =3D get_current_regcache (); + int regnum =3D gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + if (!name || (name && !*name)) + error (_("Argument for gdb record filename required.\n")); + + /* Get record_core_regbuf. */ + target_fetch_registers (regcache, -1); + record_core_regbuf =3D xmalloc (MAX_REGISTER_SIZE * regnum); + for (i =3D 0; i < regnum; i ++) + regcache_raw_collect (regcache, i, + record_core_regbuf + MAX_REGISTER_SIZE * i); + + /* Get record_core_start and record_core_end. */ + if (build_section_table (core_bfd, &record_core_start, &record_core_end)) + { + xfree (record_core_regbuf); + record_core_regbuf =3D NULL; + error (_("\"%s\": Can't find sections: %s"), + bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); + } + + push_target (&record_core_ops); +} + +static void +record_open_1 (char *name, int from_tty) +{ + struct target_ops *t; /* check exec */ if (!target_has_execution) @@ -438,6 +738,28 @@ record_open (char *name, int from_tty) error (_("Process record: the current architecture doesn't support " "record function.")); + if (!tmp_to_resume) + error (_("Process record can't get to_resume.")); + if (!tmp_to_wait) + error (_("Process record can't get to_wait.")); + if (!tmp_to_store_registers) + error (_("Process record can't get to_store_registers.")); + if (!tmp_to_insert_breakpoint) + error (_("Process record can't get to_insert_breakpoint.")); + if (!tmp_to_remove_breakpoint) + error (_("Process record can't get to_remove_breakpoint.")); + + push_target (&record_ops); +} + +static void +record_open (char *name, int from_tty) +{ + struct target_ops *t; + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); + /* Check if record target is already running. */ if (current_target.to_stratum =3D=3D record_stratum) { @@ -447,70 +769,102 @@ record_open (char *name, int from_tty) return; } - /*Reset the beneath function pointers. */ - record_beneath_to_resume =3D NULL; - record_beneath_to_wait =3D NULL; - record_beneath_to_store_registers =3D NULL; - record_beneath_to_xfer_partial =3D NULL; - record_beneath_to_insert_breakpoint =3D NULL; - record_beneath_to_remove_breakpoint =3D NULL; + /* Reset the tmp beneath pointers. */ + tmp_to_resume_ops =3D NULL; + tmp_to_resume =3D NULL; + tmp_to_wait_ops =3D NULL; + tmp_to_wait =3D NULL; + tmp_to_store_registers_ops =3D NULL; + tmp_to_store_registers =3D NULL; + tmp_to_xfer_partial_ops =3D NULL; + tmp_to_xfer_partial =3D NULL; + tmp_to_insert_breakpoint =3D NULL; + tmp_to_remove_breakpoint =3D NULL; /* Set the beneath function pointers. */ for (t =3D current_target.beneath; t !=3D NULL; t =3D t->beneath) { - if (!record_beneath_to_resume) + if (!tmp_to_resume) { - record_beneath_to_resume =3D t->to_resume; - record_beneath_to_resume_ops =3D t; + tmp_to_resume =3D t->to_resume; + tmp_to_resume_ops =3D t; } - if (!record_beneath_to_wait) + if (!tmp_to_wait) { - record_beneath_to_wait =3D t->to_wait; - record_beneath_to_wait_ops =3D t; + tmp_to_wait =3D t->to_wait; + tmp_to_wait_ops =3D t; } - if (!record_beneath_to_store_registers) + if (!tmp_to_store_registers) { - record_beneath_to_store_registers =3D t->to_store_registers; - record_beneath_to_store_registers_ops =3D t; + tmp_to_store_registers =3D t->to_store_registers; + tmp_to_store_registers_ops =3D t; } - if (!record_beneath_to_xfer_partial) + if (!tmp_to_xfer_partial) { - record_beneath_to_xfer_partial =3D t->to_xfer_partial; - record_beneath_to_xfer_partial_ops =3D t; + tmp_to_xfer_partial =3D t->to_xfer_partial; + tmp_to_xfer_partial_ops =3D t; } - if (!record_beneath_to_insert_breakpoint) - record_beneath_to_insert_breakpoint =3D t->to_insert_breakpoint; - if (!record_beneath_to_remove_breakpoint) - record_beneath_to_remove_breakpoint =3D t->to_remove_breakpoint; + if (!tmp_to_insert_breakpoint) + tmp_to_insert_breakpoint =3D t->to_insert_breakpoint; + if (!tmp_to_remove_breakpoint) + tmp_to_remove_breakpoint =3D t->to_remove_breakpoint; } - if (!record_beneath_to_resume) - error (_("Process record can't get to_resume.")); - if (!record_beneath_to_wait) - error (_("Process record can't get to_wait.")); - if (!record_beneath_to_store_registers) - error (_("Process record can't get to_store_registers.")); - if (!record_beneath_to_xfer_partial) + if (!tmp_to_xfer_partial) error (_("Process record can't get to_xfer_partial.")); - if (!record_beneath_to_insert_breakpoint) - error (_("Process record can't get to_insert_breakpoint.")); - if (!record_beneath_to_remove_breakpoint) - error (_("Process record can't get to_remove_breakpoint.")); - push_target (&record_ops); + if (current_target.to_stratum =3D=3D core_stratum) + record_core_open_1 (name, from_tty); + else + record_open_1 (name, from_tty); /* Reset */ record_insn_num =3D 0; record_list =3D &record_first; record_list->next =3D NULL; + + /* Set the tmp beneath pointers to beneath pointers. */ + record_beneath_to_resume_ops =3D tmp_to_resume_ops; + record_beneath_to_resume =3D tmp_to_resume; + record_beneath_to_wait_ops =3D tmp_to_wait_ops; + record_beneath_to_wait =3D tmp_to_wait; + record_beneath_to_store_registers_ops =3D tmp_to_store_registers_ops; + record_beneath_to_store_registers =3D tmp_to_store_registers; + record_beneath_to_xfer_partial_ops =3D tmp_to_xfer_partial_ops; + record_beneath_to_xfer_partial =3D tmp_to_xfer_partial; + record_beneath_to_insert_breakpoint =3D tmp_to_insert_breakpoint; + record_beneath_to_remove_breakpoint =3D tmp_to_remove_breakpoint; + + /* Load if there is argument. */ + record_load (name); } static void record_close (int quitting) { + struct record_core_buf_entry *entry; + if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n"); record_list_release (record_list); + + /* Release record_core_regbuf. */ + if (record_core_regbuf) + { + xfree (record_core_regbuf); + record_core_regbuf =3D NULL; + } + + /* Release record_core_buf_list. */ + if (record_core_buf_list) + { + for (entry =3D record_core_buf_list->prev; entry; entry =3D entry->p= rev) + { + xfree (record_core_buf_list); + record_core_buf_list =3D entry; + } + record_core_buf_list =3D NULL; + } } static int record_resume_step =3D 0; @@ -584,7 +938,7 @@ record_wait (struct target_ops *ops, "record_resume_step =3D %d\n", record_resume_step); - if (!RECORD_IS_REPLAY) + if (!RECORD_IS_REPLAY && ops !=3D &record_core_ops) { if (record_resume_error) { @@ -712,76 +1066,9 @@ record_wait (struct target_ops *ops, break; } - /* Set ptid, register and memory according to record_list. */ - if (record_list->type =3D=3D record_reg) - { - /* reg */ - gdb_byte reg[MAX_REGISTER_SIZE]; - if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, - "Process record: record_reg %s to " - "inferior num =3D %d.\n", - host_address_to_string (record_list), - record_list->u.reg.num); - regcache_cooked_read (regcache, record_list->u.reg.num, reg); - regcache_cooked_write (regcache, record_list->u.reg.num, - record_list->u.reg.val); - memcpy (record_list->u.reg.val, reg, MAX_REGISTER_SIZE); - } - else if (record_list->type =3D=3D record_mem) - { - /* mem */ - /* Nothing to do if the entry is flagged not_accessible. */ - if (!record_list->u.mem.mem_entry_not_accessible) - { - gdb_byte *mem =3D alloca (record_list->u.mem.len); - if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, - "Process record: record_mem %s to " - "inferior addr =3D %s len =3D %d.\n", - host_address_to_string (record_list), - paddress (gdbarch, - record_list->u.mem.addr), - record_list->u.mem.len); + record_exec_entry (regcache, gdbarch, record_list); - if (target_read_memory (record_list->u.mem.addr, mem, - record_list->u.mem.len)) - { - if (execution_direction !=3D EXEC_REVERSE) - error (_("Process record: error reading memory at " - "addr =3D %s len =3D %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - else - /* Read failed -- - flag entry as not_accessible. */ - record_list->u.mem.mem_entry_not_accessible =3D 1; - } - else - { - if (target_write_memory (record_list->u.mem.addr, - record_list->u.mem.val, - record_list->u.mem.len)) - { - if (execution_direction !=3D EXEC_REVERSE) - error (_("Process record: error writing memory at " - "addr =3D %s len =3D %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - else - /* Write failed -- - flag entry as not_accessible. */ - record_list->u.mem.mem_entry_not_accessible =3D 1; - } - else - { - memcpy (record_list->u.mem.val, mem, - record_list->u.mem.len); - } - } - } - } - else + if (record_list->type =3D=3D record_end) { if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, @@ -901,6 +1188,7 @@ record_kill (struct target_ops *ops) fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n"); unpush_target (&record_ops); + target_kill (); } @@ -945,7 +1233,7 @@ record_registers_change (struct regcache record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } @@ -1058,7 +1346,7 @@ record_xfer_partial (struct target_ops * record_list =3D record_arch_list_tail; if (record_insn_num =3D=3D record_insn_max_num && record_insn_max_nu= m) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } @@ -1138,6 +1426,191 @@ init_record_ops (void) } static void +record_core_resume (struct target_ops *ops, ptid_t ptid, int step, + enum target_signal siggnal) +{ + record_resume_step =3D step; + record_resume_siggnal =3D siggnal; +} + +static void +record_core_kill (struct target_ops *ops) +{ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "Process record: record_core_kill\n"); + + unpush_target (&record_core_ops); +} + +static void +record_core_fetch_registers (struct target_ops *ops, + struct regcache *regcache, + int regno) +{ + if (regno < 0) + { + int num =3D gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + for (i =3D 0; i < num; i ++) + regcache_raw_supply (regcache, i, + record_core_regbuf + MAX_REGISTER_SIZE * i); + } + else + regcache_raw_supply (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * regno); +} + +static void +record_core_prepare_to_store (struct regcache *regcache) +{ +} + +static void +record_core_store_registers (struct target_ops *ops, + struct regcache *regcache, + int regno) +{ + if (record_gdb_operation_disable) + regcache_raw_collect (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * regno); + else + error (_("You can't do that without a process to debug.")); +} + +static LONGEST +record_core_xfer_partial (struct target_ops *ops, enum target_object objec= t, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, ULONGEST offset, + LONGEST len) +{ + if (object =3D=3D TARGET_OBJECT_MEMORY) + { + if (record_gdb_operation_disable || !writebuf) + { + struct target_section *p; + for (p =3D record_core_start; p < record_core_end; p++) + { + if (offset >=3D p->addr) + { + struct record_core_buf_entry *entry; + + if (offset >=3D p->endaddr) + continue; + + if (offset + len > p->endaddr) + len =3D p->endaddr - offset; + + offset -=3D p->addr; + + /* Read readbuf or write writebuf p, offset, len. */ + /* Check flags. */ + if (p->the_bfd_section->flags & SEC_CONSTRUCTOR + || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) = =3D=3D 0) + { + if (readbuf) + memset (readbuf, 0, len); + return len; + } + /* Get record_core_buf_entry. */ + for (entry =3D record_core_buf_list; entry; + entry =3D entry->prev) + if (entry->p =3D=3D p) + break; + if (writebuf) + { + if (!entry) + { + /* Add a new entry. */ + entry + =3D (struct record_core_buf_entry *) + xmalloc + (sizeof (struct record_core_buf_entry)); + entry->p =3D p; + if (!bfd_malloc_and_get_section (p->bfd, + p->the_bfd_sec= tion, + &entry->buf)) + { + xfree (entry); + return 0; + } + entry->prev =3D record_core_buf_list; + record_core_buf_list =3D entry; + } + + memcpy (entry->buf + offset, writebuf, (size_t) le= n); + } + else + { + if (!entry) + return record_beneath_to_xfer_partial + (record_beneath_to_xfer_partial_ops, + object, annex, readbuf, writebuf, + offset, len); + + memcpy (readbuf, entry->buf + offset, (size_t) len); + } + + return len; + } + } + + return -1; + } + else + error (_("You can't do that without a process to debug.")); + } + + return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_op= s, + object, annex, readbuf, writebuf, + offset, len); +} + +static int +record_core_insert_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + return 0; +} + +static int +record_core_remove_breakpoint (struct gdbarch *gdbarch, + struct bp_target_info *bp_tgt) +{ + return 0; +} + +int +record_core_has_execution (struct target_ops *ops) +{ + return 1; +} + +static void +init_record_core_ops (void) +{ + record_core_ops.to_shortname =3D "record_core"; + record_core_ops.to_longname =3D "Process record and replay target"; + record_core_ops.to_doc =3D + "Log program while executing and replay execution from log."; + record_core_ops.to_open =3D record_open; + record_core_ops.to_close =3D record_close; + record_core_ops.to_resume =3D record_core_resume; + record_core_ops.to_wait =3D record_wait; + record_core_ops.to_kill =3D record_core_kill; + record_core_ops.to_fetch_registers =3D record_core_fetch_registers; + record_core_ops.to_prepare_to_store =3D record_core_prepare_to_store; + record_core_ops.to_store_registers =3D record_core_store_registers; + record_core_ops.to_xfer_partial =3D record_core_xfer_partial; + record_core_ops.to_insert_breakpoint =3D record_core_insert_breakpoint; + record_core_ops.to_remove_breakpoint =3D record_core_remove_breakpoint; + record_core_ops.to_can_execute_reverse =3D record_can_execute_reverse; + record_core_ops.to_has_execution =3D record_core_has_execution; + record_core_ops.to_stratum =3D record_stratum; + record_core_ops.to_magic =3D OPS_MAGIC; +} + +static void show_record_debug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { @@ -1153,6 +1626,212 @@ cmd_record_start (char *args, int from_t execute_command ("target record", from_tty); } +static void +cmd_record_load (char *args, int from_tty) +{ + char buf[512]; + + snprintf (buf, 512, "target record %s", args); + execute_command (buf, from_tty); +} + +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 (strcmp (current_target.to_shortname, "record") !=3D 0) + error (_("Process record is not started.\n")); + + if (args && *args) + recfilename =3D args; + else + { + /* Default corefile name is "gdb_record.PID". */ + snprintf (recfilename_buffer, 40, "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 (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); +} + /* Truncate the record log from the present point of replay until the end. */ @@ -1185,7 +1864,12 @@ cmd_record_stop (char *args, int from_tt { if (!record_list || !from_tty || query (_("Delete recorded log and " "stop recording?"))) - unpush_target (&record_ops); + { + if (strcmp (current_target.to_shortname, "record") =3D=3D 0) + unpush_target (&record_ops); + else + unpush_target (&record_core_ops); + } } else printf_unfiltered (_("Process record is not started.\n")); @@ -1203,7 +1887,7 @@ set_record_insn_max_num (char *args, int "the first ones?\n")); while (record_insn_num > record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); } } @@ -1243,6 +1927,8 @@ info_record_command (char *args, int fro void _initialize_record (void) { + struct cmd_list_element *c; + /* Init record_first. */ record_first.prev =3D NULL; record_first.next =3D NULL; @@ -1250,6 +1936,8 @@ _initialize_record (void) init_record_ops (); add_target (&record_ops); + init_record_core_ops (); + add_target (&record_core_ops); add_setshow_zinteger_cmd ("record", no_class, &record_debug, _("Set debugging of record/replay feature."), @@ -1259,9 +1947,10 @@ _initialize_record (void) NULL, show_record_debug, &setdebuglist, &showdebuglist); - add_prefix_cmd ("record", class_obscure, cmd_record_start, - _("Abbreviated form of \"target record\" command."), - &record_cmdlist, "record ", 0, &cmdlist); + c =3D add_prefix_cmd ("record", class_obscure, cmd_record_start, + _("Abbreviated form of \"target record\" command."), + &record_cmdlist, "record ", 0, &cmdlist); + set_cmd_completer (c, filename_completer); add_com_alias ("rec", "record", class_obscure, 1); add_prefix_cmd ("record", class_support, set_record_command, _("Set record options"), &set_record_cmdlist, @@ -1276,6 +1965,16 @@ _initialize_record (void) "info record ", 0, &infolist); add_alias_cmd ("rec", "record", class_obscure, 1, &infolist); + 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); + c =3D add_cmd ("dump", class_obscure, cmd_record_dump, + _("Dump the execution records to a file.\n\ +Argument is optional filename. Default filename is 'gdb_record.'."), + &record_cmdlist); + set_cmd_completer (c, filename_completer); add_cmd ("delete", class_obscure, cmd_record_delete, _("Delete the rest of execution log and start recording it anew."), --00504502ce543a1f080471de6828 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_fyqwqobi0 Content-length: 52619 LS0tCiByZWNvcmQuYyB8ICA5NTEgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgODI1IGluc2VydGlvbnMoKyksIDEyNiBkZWxldGlvbnMo LSkKCi0tLSBhL3JlY29yZC5jCisrKyBiL3JlY29yZC5jCkBAIC0yMywxNSAr MjMsMjMgQEAKICNpbmNsdWRlICJnZGJ0aHJlYWQuaCIKICNpbmNsdWRlICJl dmVudC10b3AuaCIKICNpbmNsdWRlICJleGNlcHRpb25zLmgiCisjaW5jbHVk ZSAiY29tcGxldGVyLmgiCisjaW5jbHVkZSAiYXJjaC11dGlscy5oIgorI2lu Y2x1ZGUgImdkYmNvcmUuaCIKKyNpbmNsdWRlICJleGVjLmgiCiAjaW5jbHVk ZSAicmVjb3JkLmgiCiAKKyNpbmNsdWRlIDxieXRlc3dhcC5oPgogI2luY2x1 ZGUgPHNpZ25hbC5oPgorI2luY2x1ZGUgPG5ldGluZXQvaW4uaD4KIAogI2Rl ZmluZSBERUZBVUxUX1JFQ09SRF9JTlNOX01BWF9OVU0JMjAwMDAwCiAKICNk ZWZpbmUgUkVDT1JEX0lTX1JFUExBWSBcCiAgICAgIChyZWNvcmRfbGlzdC0+ bmV4dCB8fCBleGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNfUkVWRVJTRSkK IAorI2RlZmluZSBSRUNPUkRfRklMRV9NQUdJQwlodG9ubCgweDIwMDkwNzI2 KQorCiAvKiBUaGVzZSBhcmUgdGhlIGNvcmUgc3RydWN0IG9mIHJlY29yZCBm dW5jdGlvbi4KIAogICAgQW4gcmVjb3JkX2VudHJ5IGlzIGEgcmVjb3JkIG9m IHRoZSB2YWx1ZSBjaGFuZ2Ugb2YgYSByZWdpc3RlcgpAQCAtNzgsOSArODYs MjIgQEAgc3RydWN0IHJlY29yZF9lbnRyeQogICB9IHU7CiB9OwogCitzdHJ1 Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5Cit7CisgIHN0cnVjdCByZWNvcmRf Y29yZV9idWZfZW50cnkgKnByZXY7CisgIHN0cnVjdCB0YXJnZXRfc2VjdGlv biAqcDsKKyAgYmZkX2J5dGUgKmJ1ZjsKK307CisKIC8qIFRoaXMgaXMgdGhl IGRlYnVnIHN3aXRjaCBmb3IgcHJvY2VzcyByZWNvcmQuICAqLwogaW50IHJl Y29yZF9kZWJ1ZyA9IDA7CiAKKy8qIFJlY29yZCBidWYgd2l0aCBjb3JlIHRh cmdldC4gICovCitzdGF0aWMgZ2RiX2J5dGUgKnJlY29yZF9jb3JlX3JlZ2J1 ZiA9IE5VTEw7CitzdGF0aWMgc3RydWN0IHRhcmdldF9zZWN0aW9uICpyZWNv cmRfY29yZV9zdGFydDsKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X3NlY3Rpb24g KnJlY29yZF9jb3JlX2VuZDsKK3N0YXRpYyBzdHJ1Y3QgcmVjb3JkX2NvcmVf YnVmX2VudHJ5ICpyZWNvcmRfY29yZV9idWZfbGlzdCA9IE5VTEw7CisKIC8q IFRoZXNlIGxpc3QgaXMgZm9yIGV4ZWN1dGlvbiBsb2cuICAqLwogc3RhdGlj IHN0cnVjdCByZWNvcmRfZW50cnkgcmVjb3JkX2ZpcnN0Owogc3RhdGljIHN0 cnVjdCByZWNvcmRfZW50cnkgKnJlY29yZF9saXN0ID0gJnJlY29yZF9maXJz dDsKQEAgLTk0LDYgKzExNSw3IEBAIHN0YXRpYyBpbnQgcmVjb3JkX2luc25f bnVtID0gMDsKIAogLyogVGhlIHRhcmdldF9vcHMgb2YgcHJvY2VzcyByZWNv cmQuICAqLwogc3RhdGljIHN0cnVjdCB0YXJnZXRfb3BzIHJlY29yZF9vcHM7 CitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgcmVjb3JkX2NvcmVfb3BzOwog CiAvKiBUaGUgYmVuZWF0aCBmdW5jdGlvbiBwb2ludGVycy4gICovCiBzdGF0 aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRoX3RvX3Jlc3Vt ZV9vcHM7CkBAIC0xNjksNyArMTkxLDcgQEAgcmVjb3JkX2xpc3RfcmVsZWFz ZV9uZXh0ICh2b2lkKQogfQogCiBzdGF0aWMgdm9pZAotcmVjb3JkX2xpc3Rf cmVsZWFzZV9maXJzdCAodm9pZCkKK3JlY29yZF9saXN0X3JlbGVhc2VfZmly c3RfaW5zbiAodm9pZCkKIHsKICAgc3RydWN0IHJlY29yZF9lbnRyeSAqdG1w ID0gTlVMTDsKICAgZW51bSByZWNvcmRfdHlwZSB0eXBlOwpAQCAtMzQwLDMw ICszNjIsMzAgQEAgcmVjb3JkX2NoZWNrX2luc25fbnVtIChpbnQgc2V0X3Rl cm1pbmFsKQogCSAgICAgIGlmIChxKQogCQlyZWNvcmRfc3RvcF9hdF9saW1p dCA9IDA7CiAJICAgICAgZWxzZQotCQllcnJvciAoXygiUHJvY2VzcyByZWNv cmQ6IGluZmVyaW9yIHByb2dyYW0gc3RvcHBlZC4iKSk7CisJCWVycm9yIChf KCJQcm9jZXNzIHJlY29yZDogc3RvcGVkIGJ5IHVzZXIuIikpOwogCSAgICB9 CiAJfQogICAgIH0KIH0KIAorc3RhdGljIHZvaWQKK3JlY29yZF9hcmNoX2xp c3RfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKK3sKKyAgcmVjb3JkX2xpc3Rf cmVsZWFzZSAocmVjb3JkX2FyY2hfbGlzdF90YWlsKTsKK30KKwogLyogQmVm b3JlIGluZmVyaW9yIHN0ZXAgKHdoZW4gR0RCIHJlY29yZCB0aGUgcnVubmlu ZyBtZXNzYWdlLCBpbmZlcmlvcgogICAgb25seSBjYW4gc3RlcCksIEdEQiB3 aWxsIGNhbGwgdGhpcyBmdW5jdGlvbiB0byByZWNvcmQgdGhlIHZhbHVlcyB0 bwogICAgcmVjb3JkX2xpc3QuICBUaGlzIGZ1bmN0aW9uIHdpbGwgY2FsbCBn ZGJhcmNoX3Byb2Nlc3NfcmVjb3JkIHRvCiAgICByZWNvcmQgdGhlIHJ1bm5p bmcgbWVzc2FnZSBvZiBpbmZlcmlvciBhbmQgc2V0IHRoZW0gdG8KICAgIHJl Y29yZF9hcmNoX2xpc3QsIGFuZCBhZGQgaXQgdG8gcmVjb3JkX2xpc3QuICAq LwogCi1zdGF0aWMgdm9pZAotcmVjb3JkX21lc3NhZ2VfY2xlYW51cHMgKHZv aWQgKmlnbm9yZSkKLXsKLSAgcmVjb3JkX2xpc3RfcmVsZWFzZSAocmVjb3Jk X2FyY2hfbGlzdF90YWlsKTsKLX0KLQogc3RhdGljIGludAogcmVjb3JkX21l c3NhZ2UgKHZvaWQgKmFyZ3MpCiB7CiAgIGludCByZXQ7CiAgIHN0cnVjdCBy ZWdjYWNoZSAqcmVnY2FjaGUgPSBhcmdzOwotICBzdHJ1Y3QgY2xlYW51cCAq b2xkX2NsZWFudXBzID0gbWFrZV9jbGVhbnVwIChyZWNvcmRfbWVzc2FnZV9j bGVhbnVwcywgMCk7CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2xlYW51cHMg PSBtYWtlX2NsZWFudXAgKHJlY29yZF9hcmNoX2xpc3RfY2xlYW51cHMsIDAp OwogCiAgIHJlY29yZF9hcmNoX2xpc3RfaGVhZCA9IE5VTEw7CiAgIHJlY29y ZF9hcmNoX2xpc3RfdGFpbCA9IE5VTEw7CkBAIC0zODYsNyArNDA4LDcgQEAg cmVjb3JkX21lc3NhZ2UgKHZvaWQgKmFyZ3MpCiAgIHJlY29yZF9saXN0ID0g cmVjb3JkX2FyY2hfbGlzdF90YWlsOwogCiAgIGlmIChyZWNvcmRfaW5zbl9u dW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNvcmRfaW5zbl9tYXhf bnVtKQotICAgIHJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3QgKCk7CisgICAg cmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNuICgpOwogICBlbHNlCiAg ICAgcmVjb3JkX2luc25fbnVtKys7CiAKQEAgLTQxNiwxMyArNDM4LDI5MSBA QCByZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlX3NldCAodm9pZCkKICAg cmV0dXJuIG9sZF9jbGVhbnVwczsKIH0KIAorc3RhdGljIGlubGluZSB2b2lk CityZWNvcmRfZXhlY19lbnRyeSAoc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNo ZSwgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsCisgICAgICAgICAgICAgICAg ICAgc3RydWN0IHJlY29yZF9lbnRyeSAqZW50cnkpCit7CisgIHN3aXRjaCAo ZW50cnktPnR5cGUpCisgICAgeworICAgIGNhc2UgcmVjb3JkX3JlZzogLyog cmVnICovCisgICAgICB7CisgICAgICAgIGdkYl9ieXRlIHJlZ1tNQVhfUkVH SVNURVJfU0laRV07CisKKyAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZyA+IDEp CisgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlByb2Nlc3MgcmVjb3Jk OiByZWNvcmRfcmVnICVzIHRvICIKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICJpbmZlcmlvciBudW0gPSAlZC5cbiIsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBob3N0X2FkZHJlc3NfdG9fc3RyaW5nIChlbnRy eSksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5y ZWcubnVtKTsKKworICAgICAgICByZWdjYWNoZV9jb29rZWRfcmVhZCAocmVn Y2FjaGUsIGVudHJ5LT51LnJlZy5udW0sIHJlZyk7CisgICAgICAgIHJlZ2Nh Y2hlX2Nvb2tlZF93cml0ZSAocmVnY2FjaGUsIGVudHJ5LT51LnJlZy5udW0s IGVudHJ5LT51LnJlZy52YWwpOworICAgICAgICBtZW1jcHkgKGVudHJ5LT51 LnJlZy52YWwsIHJlZywgTUFYX1JFR0lTVEVSX1NJWkUpOworICAgICAgfQor ICAgICAgYnJlYWs7CisKKyAgICBjYXNlIHJlY29yZF9tZW06IC8qIG1lbSAq LworICAgICAgeworICAgICAgICBpZiAoIXJlY29yZF9saXN0LT51Lm1lbS5t ZW1fZW50cnlfbm90X2FjY2Vzc2libGUpCisgICAgICAgICAgeworICAgICAg ICAgICAgZ2RiX2J5dGUgKm1lbSA9IGFsbG9jYSAoZW50cnktPnUubWVtLmxl bik7CisKKyAgICAgICAgICAgIGlmIChyZWNvcmRfZGVidWcgPiAxKQorICAg ICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlByb2Nlc3MgcmVj b3JkOiByZWNvcmRfbWVtICVzIHRvICIKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAiaW5mZXJpb3IgYWRkciA9ICVzIGxlbiA9ICVkLlxu IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBob3N0X2Fk ZHJlc3NfdG9fc3RyaW5nIChlbnRyeSksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcGFkZHJlc3MgKGdkYmFyY2gsIGVudHJ5LT51Lm1l bS5hZGRyKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBy ZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKworICAgICAgICAgICAgaWYgKHRh cmdldF9yZWFkX21lbW9yeSAoZW50cnktPnUubWVtLmFkZHIsIG1lbSwgZW50 cnktPnUubWVtLmxlbikpCisgICAgICAgICAgICAgIHsKKyAgICAgICAgICAg ICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3Np YmxlID0gMTsKKyAgICAgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQor ICAgICAgICAgICAgICAgICAgd2FybmluZyAoXygiUHJvY2VzcyByZWNvcmQ6 IGVycm9yIHJlYWRpbmcgbWVtb3J5IGF0ICIKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgImFkZHIgPSAlcyBsZW4gPSAlZC4iKSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRyeS0+ dS5tZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRy eS0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAgfQorICAgICAgICAgICAg ZWxzZQorICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHRh cmdldF93cml0ZV9tZW1vcnkgKGVudHJ5LT51Lm1lbS5hZGRyLCBlbnRyeS0+ dS5tZW0udmFsLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKSkKKyAgICAgICAgICAgICAgICAg IHsKKyAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLm1l bV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9IDE7CisgICAgICAgICAgICAgICAg ICAgIGlmIChyZWNvcmRfZGVidWcpCisgICAgICAgICAgICAgICAgICAgICAg d2FybmluZyAoXygiUHJvY2VzcyByZWNvcmQ6IGVycm9yIHdyaXRpbmcgbWVt b3J5IGF0ICIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJh ZGRyID0gJXMgbGVuID0gJWQuIiksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcGFkZHJlc3MgKGdkYmFyY2gsIGVudHJ5LT51Lm1lbS5hZGRy KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5t ZW0ubGVuKTsKKyAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgICBtZW1jcHkgKGVudHJ5LT51Lm1l bS52YWwsIG1lbSwgZW50cnktPnUubWVtLmxlbik7CisgICAgICAgICAgICAg IH0KKyAgICAgICAgICB9CisgICAgICB9CisgICAgICBicmVhazsKKyAgICB9 Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorcmVjb3JkX3JlYWRfZHVtcCAo Y2hhciAqcmVjZmlsZW5hbWUsIGludCBmaWxkZXMsIHZvaWQgKmJ1Ziwgc2l6 ZV90IG5ieXRlKQoreworICBpZiAocmVhZCAoZmlsZGVzLCBidWYsIG5ieXRl KSAhPSBuYnl0ZSkKKyAgICBlcnJvciAoXygiRmFpbGVkIHRvIHJlYWQgZHVt cCBvZiBleGVjdXRpb24gcmVjb3JkcyBpbiAnJXMnLiIpLAorICAgICAgICAg ICByZWNmaWxlbmFtZSk7Cit9CisKIHN0YXRpYyB2b2lkCi1yZWNvcmRfb3Bl biAoY2hhciAqbmFtZSwgaW50IGZyb21fdHR5KQorcmVjb3JkX2ZkX2NsZWFu dXBzICh2b2lkICpyZWNmZHApCiB7Ci0gIHN0cnVjdCB0YXJnZXRfb3BzICp0 OworICBpbnQgcmVjZmQgPSAqKGludCAqKSByZWNmZHA7CisgIGNsb3NlIChy ZWNmZCk7Cit9CiAKLSAgaWYgKHJlY29yZF9kZWJ1ZykKLSAgICBmcHJpbnRm X3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVj b3JkX29wZW5cbiIpOworLyogTG9hZCB0aGUgZXhlY3V0aW9uIGxvZyBmcm9t IGEgZmlsZS4gICovCisKK3N0YXRpYyB2b2lkCityZWNvcmRfbG9hZCAoY2hh ciAqbmFtZSkKK3sKKyAgaW50IHJlY2ZkOworICB1aW50MzJfdCBtYWdpYzsK KyAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwczsKKyAgc3RydWN0IGNs ZWFudXAgKm9sZF9jbGVhbnVwczI7CisgIHN0cnVjdCByZWNvcmRfZW50cnkg KnJlYzsKKyAgaW50IGluc25fbnVtYmVyID0gMDsKKworICBpZiAoIW5hbWUg fHwgKG5hbWUgJiYgISpuYW1lKSkKKyAgICByZXR1cm47CisKKyAgLyogT3Bl biB0aGUgbG9hZCBmaWxlLiAgKi8KKyAgcmVjZmQgPSBvcGVuIChuYW1lLCBP X1JET05MWSB8IE9fQklOQVJZKTsKKyAgaWYgKHJlY2ZkIDwgMCkKKyAgICBl cnJvciAoXygiRmFpbGVkIHRvIG9wZW4gJyVzJyBmb3IgbG9hZGluZyBleGVj dXRpb24gcmVjb3JkczogJXMiKSwKKyAgICAgICAgICAgbmFtZSwgc3RyZXJy b3IgKGVycm5vKSk7CisgIG9sZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cCAo cmVjb3JkX2ZkX2NsZWFudXBzLCAmcmVjZmQpOworCisgIC8qIENoZWNrIHRo ZSBtYWdpYyBjb2RlLiAgKi8KKyAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwg cmVjZmQsICZtYWdpYywgNCk7CisgIGlmIChtYWdpYyAhPSBSRUNPUkRfRklM RV9NQUdJQykKKyAgICBlcnJvciAoXygiJyVzJyBpcyBub3QgYSB2YWxpZCBk dW1wIG9mIGV4ZWN1dGlvbiByZWNvcmRzLiIpLCBuYW1lKTsKKworICAvKiBM b2FkIHRoZSBlbnRyaWVzIGluIHJlY2ZkIHRvIHRoZSByZWNvcmRfYXJjaF9s aXN0X2hlYWQgYW5kCisgICAgIHJlY29yZF9hcmNoX2xpc3RfdGFpbC4gICov CisgIHJlY29yZF9hcmNoX2xpc3RfaGVhZCA9IE5VTEw7CisgIHJlY29yZF9h cmNoX2xpc3RfdGFpbCA9IE5VTEw7CisgIG9sZF9jbGVhbnVwczIgPSBtYWtl X2NsZWFudXAgKHJlY29yZF9hcmNoX2xpc3RfY2xlYW51cHMsIDApOworCisg IHdoaWxlICgxKQorICAgIHsKKyAgICAgIGludCByZXQ7CisgICAgICB1aW50 OF90IHRtcHU4OworICAgICAgdWludDY0X3QgdG1wdTY0OworCisgICAgICBy ZXQgPSByZWFkIChyZWNmZCwgJnRtcHU4LCAxKTsKKyAgICAgIGlmIChyZXQg PCAwKQorICAgICAgICBlcnJvciAoXygiRmFpbGVkIHRvIHJlYWQgZHVtcCBv ZiBleGVjdXRpb24gcmVjb3JkcyBpbiAnJXMnLiIpLCBuYW1lKTsKKyAgICAg IGlmIChyZXQgPT0gMCkKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIHN3aXRj aCAodG1wdTgpCisgICAgICAgIHsKKyAgICAgICAgY2FzZSByZWNvcmRfcmVn OiAvKiByZWcgKi8KKyAgICAgICAgICByZWMgPSAoc3RydWN0IHJlY29yZF9l bnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRfZW50cnkp KTsKKyAgICAgICAgICByZWMtPnUucmVnLnZhbCA9IChnZGJfYnl0ZSAqKSB4 bWFsbG9jIChNQVhfUkVHSVNURVJfU0laRSk7CisgICAgICAgICAgcmVjLT5w cmV2ID0gTlVMTDsKKyAgICAgICAgICByZWMtPm5leHQgPSBOVUxMOworICAg ICAgICAgIHJlYy0+dHlwZSA9IHJlY29yZF9yZWc7CisKKyAgICAgICAgICAv KiBHZXQgbnVtLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChu YW1lLCByZWNmZCwgJnRtcHU2NCwgOCk7CisgICAgICAgICAgaWYgKEJZVEVf T1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgIHRtcHU2NCA9 IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJlYy0+dS5yZWcubnVt ID0gdG1wdTY0OworCisgICAgICAgICAgLyogR2V0IHZhbC4gICovCisgICAg ICAgICAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwgcmVjZmQsIHJlYy0+dS5y ZWcudmFsLCBNQVhfUkVHSVNURVJfU0laRSk7CisKKyAgICAgICAgICBpZiAo cmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVk IChnZGJfc3RkbG9nLCBfKCJcCitSZWFkaW5nIHJlZ2lzdGVyICVkICgxIHBs dXMgOCBwbHVzICVkIGJ5dGVzKVxuIiksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJlYy0+dS5yZWcubnVtLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBNQVhfUkVHSVNURVJfU0laRSk7CisKKyAgICAg ICAgICByZWNvcmRfYXJjaF9saXN0X2FkZCAocmVjKTsKKyAgICAgICAgICBi cmVhazsKKworICAgICAgICBjYXNlIHJlY29yZF9tZW06IC8qIG1lbSAqLwor ICAgICAgICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxs b2MgKHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkpOworICAgICAgICAg IHJlYy0+cHJldiA9IE5VTEw7CisgICAgICAgICAgcmVjLT5uZXh0ID0gTlVM TDsKKyAgICAgICAgICByZWMtPnR5cGUgPSByZWNvcmRfbWVtOworCisgICAg ICAgICAgLyogR2V0IGFkZHIuICAqLworICAgICAgICAgIHJlY29yZF9yZWFk X2R1bXAgKG5hbWUsIHJlY2ZkLCAmdG1wdTY0LCA4KTsKKyAgICAgICAgICBp ZiAoQllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAgICAgICAg dG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAgcmVjLT51 Lm1lbS5hZGRyID0gdG1wdTY0OworCisgICAgICAgICAgLyogR2V0IGxlbi4g ICovCisgICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwgcmVjZmQs ICZ0bXB1NjQsIDgpOworICAgICAgICAgIGlmIChCWVRFX09SREVSID09IExJ VFRMRV9FTkRJQU4pCisgICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAo dG1wdTY0KTsKKyAgICAgICAgICByZWMtPnUubWVtLmxlbiA9IHRtcHU2NDsK KyAgICAgICAgICByZWMtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJs ZSA9IDA7CisgICAgICAgICAgcmVjLT51Lm1lbS52YWwgPSAoZ2RiX2J5dGUg KikgeG1hbGxvYyAocmVjLT51Lm1lbS5sZW4pOworCisgICAgICAgICAgLyog R2V0IHZhbC4gICovCisgICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAobmFt ZSwgcmVjZmQsIHJlYy0+dS5tZW0udmFsLCByZWMtPnUubWVtLmxlbik7CisK KyAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgZnBy aW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCBfKCJcCitSZWFkaW5nIG1l bW9yeSAlcyAoMSBwbHVzIDggcGx1cyA4IGJ5dGVzIHBsdXMgJWQgYnl0ZXMp XG4iKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBwYWRkcmVzcyAoZ2V0X2N1cnJlbnRfYXJjaCAoKSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjLT51 Lm1lbS5hZGRyKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWMtPnUubWVtLmxlbik7CisKKyAgICAgICAgICByZWNvcmRf YXJjaF9saXN0X2FkZCAocmVjKTsKKyAgICAgICAgICBicmVhazsKKworICAg ICAgICBjYXNlIHJlY29yZF9lbmQ6IC8qIGVuZCAqLworICAgICAgICAgIGlm IChyZWNvcmRfZGVidWcpCisgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVy ZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIF8oIlJlYWRpbmcgcmVjb3JkX2VuZCAoMSBieXRlKVxuIikpOworCisg ICAgICAgICAgcmVjID0gKHN0cnVjdCByZWNvcmRfZW50cnkgKikgeG1hbGxv YyAoc2l6ZW9mIChzdHJ1Y3QgcmVjb3JkX2VudHJ5KSk7CisgICAgICAgICAg cmVjLT5wcmV2ID0gTlVMTDsKKyAgICAgICAgICByZWMtPm5leHQgPSBOVUxM OworICAgICAgICAgIHJlYy0+dHlwZSA9IHJlY29yZF9lbmQ7CisgICAgICAg ICAgcmVjb3JkX2FyY2hfbGlzdF9hZGQgKHJlYyk7CisgICAgICAgICAgaW5z bl9udW1iZXIgKys7CisgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgZGVm YXVsdDoKKyAgICAgICAgICBlcnJvciAoXygiRm9ybWF0IG9mICclcycgaXMg bm90IHJpZ2h0LiIpLCBuYW1lKTsKKyAgICAgICAgICBicmVhazsKKyAgICAg ICAgfQorICAgIH0KKworICBkaXNjYXJkX2NsZWFudXBzIChvbGRfY2xlYW51 cHMyKTsKKworICAvKiBBZGQgcmVjb3JkX2FyY2hfbGlzdF9oZWFkIHRvIHRo ZSBlbmQgb2YgcmVjb3JkIGxpc3QuICAqLworICBmb3IgKHJlYyA9IHJlY29y ZF9saXN0OyByZWMtPm5leHQ7IHJlYyA9IHJlYy0+bmV4dCk7CisgIHJlYy0+ bmV4dCA9IHJlY29yZF9hcmNoX2xpc3RfaGVhZDsKKyAgcmVjb3JkX2FyY2hf bGlzdF9oZWFkLT5wcmV2ID0gcmVjOworCisgIC8qIFVwZGF0ZSByZWNvcmRf aW5zbl9udW0gYW5kIHJlY29yZF9pbnNuX21heF9udW0uICAqLworICByZWNv cmRfaW5zbl9udW0gKz0gaW5zbl9udW1iZXI7CisgIGlmIChyZWNvcmRfaW5z bl9udW0gPiByZWNvcmRfaW5zbl9tYXhfbnVtKQorICAgIHsKKyAgICAgIHJl Y29yZF9pbnNuX21heF9udW0gPSByZWNvcmRfaW5zbl9udW07CisgICAgICB3 YXJuaW5nIChfKCJBdXRvIGluY3JlYXNlIHJlY29yZC9yZXBsYXkgYnVmZmVy IGxpbWl0IHRvICVkLiIpLAorICAgICAgICAgICAgICAgcmVjb3JkX2luc25f bWF4X251bSk7CisgICAgfQorCisgIGRvX2NsZWFudXBzIChvbGRfY2xlYW51 cHMpOworCisgIC8qIFN1Y2NlZWRlZC4gICovCisgIGZwcmludGZfZmlsdGVy ZWQgKGdkYl9zdGRvdXQsICJMb2FkZWQgcmVjZmlsZSAlcy5cbiIsIG5hbWUp OworfQorCitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnRtcF90b19yZXN1 bWVfb3BzOworc3RhdGljIHZvaWQgKCp0bXBfdG9fcmVzdW1lKSAoc3RydWN0 IHRhcmdldF9vcHMgKiwgcHRpZF90LCBpbnQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBlbnVtIHRhcmdldF9zaWduYWwpOworc3RhdGljIHN0 cnVjdCB0YXJnZXRfb3BzICp0bXBfdG9fd2FpdF9vcHM7CitzdGF0aWMgcHRp ZF90ICgqdG1wX3RvX3dhaXQpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqLCBwdGlk X3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgdGFy Z2V0X3dhaXRzdGF0dXMgKiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIGludCk7CitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnRtcF90b19z dG9yZV9yZWdpc3RlcnNfb3BzOworc3RhdGljIHZvaWQgKCp0bXBfdG9fc3Rv cmVfcmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMgKiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCByZWdjYWNo ZSAqLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg aW50IHJlZ25vKTsKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyAqdG1wX3Rv X3hmZXJfcGFydGlhbF9vcHM7CitzdGF0aWMgTE9OR0VTVCAoKnRtcF90b194 ZmVyX3BhcnRpYWwpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW51bSB0YXJnZXRf b2JqZWN0IG9iamVjdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIGNvbnN0IGNoYXIgKmFubmV4LAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgZ2RiX2J5dGUgKnJlYWRidWYsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBn ZGJfYnl0ZSAqd3JpdGVidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBVTE9OR0VTVCBvZmZzZXQsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICBMT05HRVNUIGxlbik7CitzdGF0 aWMgaW50ICgqdG1wX3RvX2luc2VydF9icmVha3BvaW50KSAoc3RydWN0IGdk YmFyY2ggKiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKik7CitzdGF0aWMgaW50ICgq dG1wX3RvX3JlbW92ZV9icmVha3BvaW50KSAoc3RydWN0IGdkYmFyY2ggKiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1 Y3QgYnBfdGFyZ2V0X2luZm8gKik7CisKK3N0YXRpYyB2b2lkCityZWNvcmRf Y29yZV9vcGVuXzEgKGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKK3sKKyAg c3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2Nh Y2hlICgpOworICBpbnQgcmVnbnVtID0gZ2RiYXJjaF9udW1fcmVncyAoZ2V0 X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSk7CisgIGludCBpOworCisgIGlm ICghbmFtZSB8fCAobmFtZSAmJiAhKm5hbWUpKQorICAgIGVycm9yIChfKCJB cmd1bWVudCBmb3IgZ2RiIHJlY29yZCBmaWxlbmFtZSByZXF1aXJlZC5cbiIp KTsKKworICAvKiBHZXQgcmVjb3JkX2NvcmVfcmVnYnVmLiAgKi8KKyAgdGFy Z2V0X2ZldGNoX3JlZ2lzdGVycyAocmVnY2FjaGUsIC0xKTsKKyAgcmVjb3Jk X2NvcmVfcmVnYnVmID0geG1hbGxvYyAoTUFYX1JFR0lTVEVSX1NJWkUgKiBy ZWdudW0pOworICBmb3IgKGkgPSAwOyBpIDwgcmVnbnVtOyBpICsrKQorICAg IHJlZ2NhY2hlX3Jhd19jb2xsZWN0IChyZWdjYWNoZSwgaSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JF R0lTVEVSX1NJWkUgKiBpKTsKKworICAvKiBHZXQgcmVjb3JkX2NvcmVfc3Rh cnQgYW5kIHJlY29yZF9jb3JlX2VuZC4gICovCisgIGlmIChidWlsZF9zZWN0 aW9uX3RhYmxlIChjb3JlX2JmZCwgJnJlY29yZF9jb3JlX3N0YXJ0LCAmcmVj b3JkX2NvcmVfZW5kKSkKKyAgICB7CisgICAgICB4ZnJlZSAocmVjb3JkX2Nv cmVfcmVnYnVmKTsKKyAgICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiA9IE5VTEw7 CisgICAgICBlcnJvciAoXygiXCIlc1wiOiBDYW4ndCBmaW5kIHNlY3Rpb25z OiAlcyIpLAorICAgICAgICAgICAgIGJmZF9nZXRfZmlsZW5hbWUgKGNvcmVf YmZkKSwgYmZkX2Vycm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworICAgIH0K KworICBwdXNoX3RhcmdldCAoJnJlY29yZF9jb3JlX29wcyk7Cit9CisKK3N0 YXRpYyB2b2lkCityZWNvcmRfb3Blbl8xIChjaGFyICpuYW1lLCBpbnQgZnJv bV90dHkpCit7CisgIHN0cnVjdCB0YXJnZXRfb3BzICp0OwogCiAgIC8qIGNo ZWNrIGV4ZWMgKi8KICAgaWYgKCF0YXJnZXRfaGFzX2V4ZWN1dGlvbikKQEAg LTQzOCw2ICs3MzgsMjggQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUsIGlu dCBmcm9tX3R0eSkKICAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IHRo ZSBjdXJyZW50IGFyY2hpdGVjdHVyZSBkb2Vzbid0IHN1cHBvcnQgIgogCSAg ICAgInJlY29yZCBmdW5jdGlvbi4iKSk7CiAKKyAgaWYgKCF0bXBfdG9fcmVz dW1lKQorICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQg dG9fcmVzdW1lLiIpKTsKKyAgaWYgKCF0bXBfdG9fd2FpdCkKKyAgICBlcnJv ciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3dhaXQuIikpOwor ICBpZiAoIXRtcF90b19zdG9yZV9yZWdpc3RlcnMpCisgICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19zdG9yZV9yZWdpc3RlcnMu IikpOworICBpZiAoIXRtcF90b19pbnNlcnRfYnJlYWtwb2ludCkKKyAgICBl cnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2luc2VydF9i cmVha3BvaW50LiIpKTsKKyAgaWYgKCF0bXBfdG9fcmVtb3ZlX2JyZWFrcG9p bnQpCisgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0 b19yZW1vdmVfYnJlYWtwb2ludC4iKSk7CisKKyAgcHVzaF90YXJnZXQgKCZy ZWNvcmRfb3BzKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9vcGVuIChj aGFyICpuYW1lLCBpbnQgZnJvbV90dHkpCit7CisgIHN0cnVjdCB0YXJnZXRf b3BzICp0OworCisgIGlmIChyZWNvcmRfZGVidWcpCisgICAgZnByaW50Zl91 bmZpbHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29y ZF9vcGVuXG4iKTsKKwogICAvKiBDaGVjayBpZiByZWNvcmQgdGFyZ2V0IGlz IGFscmVhZHkgcnVubmluZy4gICovCiAgIGlmIChjdXJyZW50X3RhcmdldC50 b19zdHJhdHVtID09IHJlY29yZF9zdHJhdHVtKQogICAgIHsKQEAgLTQ0Nyw3 MCArNzY5LDEwMiBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFtZSwgaW50IGZy b21fdHR5KQogCXJldHVybjsKICAgICB9CiAKLSAgLypSZXNldCB0aGUgYmVu ZWF0aCBmdW5jdGlvbiBwb2ludGVycy4gICovCi0gIHJlY29yZF9iZW5lYXRo X3RvX3Jlc3VtZSA9IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3dhaXQg PSBOVUxMOwotICByZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMg PSBOVUxMOwotICByZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwgPSBO VUxMOwotICByZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJlYWtwb2ludCA9 IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50 ID0gTlVMTDsKKyAgLyogUmVzZXQgdGhlIHRtcCBiZW5lYXRoIHBvaW50ZXJz LiAgKi8KKyAgdG1wX3RvX3Jlc3VtZV9vcHMgPSBOVUxMOworICB0bXBfdG9f cmVzdW1lID0gTlVMTDsKKyAgdG1wX3RvX3dhaXRfb3BzID0gTlVMTDsKKyAg dG1wX3RvX3dhaXQgPSBOVUxMOworICB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJz X29wcyA9IE5VTEw7CisgIHRtcF90b19zdG9yZV9yZWdpc3RlcnMgPSBOVUxM OworICB0bXBfdG9feGZlcl9wYXJ0aWFsX29wcyA9IE5VTEw7CisgIHRtcF90 b194ZmVyX3BhcnRpYWwgPSBOVUxMOworICB0bXBfdG9faW5zZXJ0X2JyZWFr cG9pbnQgPSBOVUxMOworICB0bXBfdG9fcmVtb3ZlX2JyZWFrcG9pbnQgPSBO VUxMOwogCiAgIC8qIFNldCB0aGUgYmVuZWF0aCBmdW5jdGlvbiBwb2ludGVy cy4gICovCiAgIGZvciAodCA9IGN1cnJlbnRfdGFyZ2V0LmJlbmVhdGg7IHQg IT0gTlVMTDsgdCA9IHQtPmJlbmVhdGgpCiAgICAgewotICAgICAgaWYgKCFy ZWNvcmRfYmVuZWF0aF90b19yZXN1bWUpCisgICAgICBpZiAoIXRtcF90b19y ZXN1bWUpCiAgICAgICAgIHsKLQkgIHJlY29yZF9iZW5lYXRoX3RvX3Jlc3Vt ZSA9IHQtPnRvX3Jlc3VtZTsKLQkgIHJlY29yZF9iZW5lYXRoX3RvX3Jlc3Vt ZV9vcHMgPSB0OworCSAgdG1wX3RvX3Jlc3VtZSA9IHQtPnRvX3Jlc3VtZTsK KwkgIHRtcF90b19yZXN1bWVfb3BzID0gdDsKICAgICAgICAgfQotICAgICAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b193YWl0KQorICAgICAgaWYgKCF0bXBf dG9fd2FpdCkKICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVhdGhfdG9fd2Fp dCA9IHQtPnRvX3dhaXQ7Ci0JICByZWNvcmRfYmVuZWF0aF90b193YWl0X29w cyA9IHQ7CisJICB0bXBfdG9fd2FpdCA9IHQtPnRvX3dhaXQ7CisJICB0bXBf dG9fd2FpdF9vcHMgPSB0OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29y ZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycykKKyAgICAgIGlmICghdG1w X3RvX3N0b3JlX3JlZ2lzdGVycykKICAgICAgICAgewotCSAgcmVjb3JkX2Jl bmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzID0gdC0+dG9fc3RvcmVfcmVnaXN0 ZXJzOwotCSAgcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzX29w cyA9IHQ7CisJICB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJzID0gdC0+dG9fc3Rv cmVfcmVnaXN0ZXJzOworCSAgdG1wX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHMg PSB0OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3Rv X3hmZXJfcGFydGlhbCkKKyAgICAgIGlmICghdG1wX3RvX3hmZXJfcGFydGlh bCkKICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0 aWFsID0gdC0+dG9feGZlcl9wYXJ0aWFsOwotCSAgcmVjb3JkX2JlbmVhdGhf dG9feGZlcl9wYXJ0aWFsX29wcyA9IHQ7CisJICB0bXBfdG9feGZlcl9wYXJ0 aWFsID0gdC0+dG9feGZlcl9wYXJ0aWFsOworCSAgdG1wX3RvX3hmZXJfcGFy dGlhbF9vcHMgPSB0OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29yZF9i ZW5lYXRoX3RvX2luc2VydF9icmVha3BvaW50KQotCXJlY29yZF9iZW5lYXRo X3RvX2luc2VydF9icmVha3BvaW50ID0gdC0+dG9faW5zZXJ0X2JyZWFrcG9p bnQ7Ci0gICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVh a3BvaW50KQotCXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50 ID0gdC0+dG9fcmVtb3ZlX2JyZWFrcG9pbnQ7CisgICAgICBpZiAoIXRtcF90 b19pbnNlcnRfYnJlYWtwb2ludCkKKwl0bXBfdG9faW5zZXJ0X2JyZWFrcG9p bnQgPSB0LT50b19pbnNlcnRfYnJlYWtwb2ludDsKKyAgICAgIGlmICghdG1w X3RvX3JlbW92ZV9icmVha3BvaW50KQorCXRtcF90b19yZW1vdmVfYnJlYWtw b2ludCA9IHQtPnRvX3JlbW92ZV9icmVha3BvaW50OwogICAgIH0KLSAgaWYg KCFyZWNvcmRfYmVuZWF0aF90b19yZXN1bWUpCi0gICAgZXJyb3IgKF8oIlBy b2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19yZXN1bWUuIikpOwotICBpZiAo IXJlY29yZF9iZW5lYXRoX3RvX3dhaXQpCi0gICAgZXJyb3IgKF8oIlByb2Nl c3MgcmVjb3JkIGNhbid0IGdldCB0b193YWl0LiIpKTsKLSAgaWYgKCFyZWNv cmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMpCi0gICAgZXJyb3IgKF8o IlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19zdG9yZV9yZWdpc3RlcnMu IikpOwotICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCkK KyAgaWYgKCF0bXBfdG9feGZlcl9wYXJ0aWFsKQogICAgIGVycm9yIChfKCJQ cm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9feGZlcl9wYXJ0aWFsLiIpKTsK LSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJlYWtwb2ludCkK LSAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2lu c2VydF9icmVha3BvaW50LiIpKTsKLSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90 b19yZW1vdmVfYnJlYWtwb2ludCkKLSAgICBlcnJvciAoXygiUHJvY2VzcyBy ZWNvcmQgY2FuJ3QgZ2V0IHRvX3JlbW92ZV9icmVha3BvaW50LiIpKTsKIAot ICBwdXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOworICBpZiAoY3VycmVudF90 YXJnZXQudG9fc3RyYXR1bSA9PSBjb3JlX3N0cmF0dW0pCisgICAgcmVjb3Jk X2NvcmVfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CisgIGVsc2UKKyAgICBy ZWNvcmRfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CiAKICAgLyogUmVzZXQg Ki8KICAgcmVjb3JkX2luc25fbnVtID0gMDsKICAgcmVjb3JkX2xpc3QgPSAm cmVjb3JkX2ZpcnN0OwogICByZWNvcmRfbGlzdC0+bmV4dCA9IE5VTEw7CisK KyAgLyogU2V0IHRoZSB0bXAgYmVuZWF0aCBwb2ludGVycyB0byBiZW5lYXRo IHBvaW50ZXJzLiAgKi8KKyAgcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1lX29w cyA9IHRtcF90b19yZXN1bWVfb3BzOworICByZWNvcmRfYmVuZWF0aF90b19y ZXN1bWUgPSB0bXBfdG9fcmVzdW1lOworICByZWNvcmRfYmVuZWF0aF90b193 YWl0X29wcyA9IHRtcF90b193YWl0X29wczsKKyAgcmVjb3JkX2JlbmVhdGhf dG9fd2FpdCA9IHRtcF90b193YWl0OworICByZWNvcmRfYmVuZWF0aF90b19z dG9yZV9yZWdpc3RlcnNfb3BzID0gdG1wX3RvX3N0b3JlX3JlZ2lzdGVyc19v cHM7CisgIHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycyA9IHRt cF90b19zdG9yZV9yZWdpc3RlcnM7CisgIHJlY29yZF9iZW5lYXRoX3RvX3hm ZXJfcGFydGlhbF9vcHMgPSB0bXBfdG9feGZlcl9wYXJ0aWFsX29wczsKKyAg cmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsID0gdG1wX3RvX3hmZXJf cGFydGlhbDsKKyAgcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0X2JyZWFrcG9p bnQgPSB0bXBfdG9faW5zZXJ0X2JyZWFrcG9pbnQ7CisgIHJlY29yZF9iZW5l YXRoX3RvX3JlbW92ZV9icmVha3BvaW50ID0gdG1wX3RvX3JlbW92ZV9icmVh a3BvaW50OworCisgIC8qIExvYWQgaWYgdGhlcmUgaXMgYXJndW1lbnQuICAq LworICByZWNvcmRfbG9hZCAobmFtZSk7CiB9CiAKIHN0YXRpYyB2b2lkCiBy ZWNvcmRfY2xvc2UgKGludCBxdWl0dGluZykKIHsKKyAgc3RydWN0IHJlY29y ZF9jb3JlX2J1Zl9lbnRyeSAqZW50cnk7CisKICAgaWYgKHJlY29yZF9kZWJ1 ZykKICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9j ZXNzIHJlY29yZDogcmVjb3JkX2Nsb3NlXG4iKTsKIAogICByZWNvcmRfbGlz dF9yZWxlYXNlIChyZWNvcmRfbGlzdCk7CisKKyAgLyogUmVsZWFzZSByZWNv cmRfY29yZV9yZWdidWYuICAqLworICBpZiAocmVjb3JkX2NvcmVfcmVnYnVm KQorICAgIHsKKyAgICAgIHhmcmVlIChyZWNvcmRfY29yZV9yZWdidWYpOwor ICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmID0gTlVMTDsKKyAgICB9CisKKyAg LyogUmVsZWFzZSByZWNvcmRfY29yZV9idWZfbGlzdC4gICovCisgIGlmIChy ZWNvcmRfY29yZV9idWZfbGlzdCkKKyAgICB7CisgICAgICBmb3IgKGVudHJ5 ID0gcmVjb3JkX2NvcmVfYnVmX2xpc3QtPnByZXY7IGVudHJ5OyBlbnRyeSA9 IGVudHJ5LT5wcmV2KQorICAgICAgICB7CisgICAgICAgICAgeGZyZWUgKHJl Y29yZF9jb3JlX2J1Zl9saXN0KTsKKyAgICAgICAgICByZWNvcmRfY29yZV9i dWZfbGlzdCA9IGVudHJ5OworICAgICAgICB9CisgICAgICByZWNvcmRfY29y ZV9idWZfbGlzdCA9IE5VTEw7CisgICAgfQogfQogCiBzdGF0aWMgaW50IHJl Y29yZF9yZXN1bWVfc3RlcCA9IDA7CkBAIC01ODQsNyArOTM4LDcgQEAgcmVj b3JkX3dhaXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCiAJCQkicmVjb3Jk X3Jlc3VtZV9zdGVwID0gJWRcbiIsCiAJCQlyZWNvcmRfcmVzdW1lX3N0ZXAp OwogCi0gIGlmICghUkVDT1JEX0lTX1JFUExBWSkKKyAgaWYgKCFSRUNPUkRf SVNfUkVQTEFZICYmIG9wcyAhPSAmcmVjb3JkX2NvcmVfb3BzKQogICAgIHsK ICAgICAgIGlmIChyZWNvcmRfcmVzdW1lX2Vycm9yKQogCXsKQEAgLTcxMiw3 NiArMTA2Niw5IEBAIHJlY29yZF93YWl0IChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzLAogCSAgICAgIGJyZWFrOwogCSAgICB9CiAKLQkgIC8qIFNldCBwdGlk LCByZWdpc3RlciBhbmQgbWVtb3J5IGFjY29yZGluZyB0byByZWNvcmRfbGlz dC4gICovCi0JICBpZiAocmVjb3JkX2xpc3QtPnR5cGUgPT0gcmVjb3JkX3Jl ZykKLQkgICAgewotCSAgICAgIC8qIHJlZyAqLwotCSAgICAgIGdkYl9ieXRl IHJlZ1tNQVhfUkVHSVNURVJfU0laRV07Ci0JICAgICAgaWYgKHJlY29yZF9k ZWJ1ZyA+IDEpCi0JCWZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywK LQkJCQkgICAgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfcmVnICVzIHRvICIK LQkJCQkgICAgImluZmVyaW9yIG51bSA9ICVkLlxuIiwKLQkJCQkgICAgaG9z dF9hZGRyZXNzX3RvX3N0cmluZyAocmVjb3JkX2xpc3QpLAotCQkJCSAgICBy ZWNvcmRfbGlzdC0+dS5yZWcubnVtKTsKLQkgICAgICByZWdjYWNoZV9jb29r ZWRfcmVhZCAocmVnY2FjaGUsIHJlY29yZF9saXN0LT51LnJlZy5udW0sIHJl Zyk7Ci0JICAgICAgcmVnY2FjaGVfY29va2VkX3dyaXRlIChyZWdjYWNoZSwg cmVjb3JkX2xpc3QtPnUucmVnLm51bSwKLQkJCQkgICAgIHJlY29yZF9saXN0 LT51LnJlZy52YWwpOwotCSAgICAgIG1lbWNweSAocmVjb3JkX2xpc3QtPnUu cmVnLnZhbCwgcmVnLCBNQVhfUkVHSVNURVJfU0laRSk7Ci0JICAgIH0KLQkg IGVsc2UgaWYgKHJlY29yZF9saXN0LT50eXBlID09IHJlY29yZF9tZW0pCi0J ICAgIHsKLQkgICAgICAvKiBtZW0gKi8KLQkgICAgICAvKiBOb3RoaW5nIHRv IGRvIGlmIHRoZSBlbnRyeSBpcyBmbGFnZ2VkIG5vdF9hY2Nlc3NpYmxlLiAg Ki8KLQkgICAgICBpZiAoIXJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlf bm90X2FjY2Vzc2libGUpCi0JCXsKLQkJICBnZGJfYnl0ZSAqbWVtID0gYWxs b2NhIChyZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKLQkJICBpZiAocmVjb3Jk X2RlYnVnID4gMSkKLQkJICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0 ZGxvZywKLQkJCQkgICAgICAgICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX21l bSAlcyB0byAiCi0JCQkJICAgICAgICAiaW5mZXJpb3IgYWRkciA9ICVzIGxl biA9ICVkLlxuIiwKLQkJCQkgICAgICAgIGhvc3RfYWRkcmVzc190b19zdHJp bmcgKHJlY29yZF9saXN0KSwKLQkJCQkgICAgICAgIHBhZGRyZXNzIChnZGJh cmNoLAotCQkJCQkgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmFkZHIp LAotCQkJCSAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisgICAg ICAgICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCBy ZWNvcmRfbGlzdCk7CiAKLQkJICBpZiAodGFyZ2V0X3JlYWRfbWVtb3J5IChy ZWNvcmRfbGlzdC0+dS5tZW0uYWRkciwgbWVtLAotCQkgICAgICAgICAgICAg ICAgICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pKQotCSAgICAg ICAgICAgIHsKLQkJICAgICAgaWYgKGV4ZWN1dGlvbl9kaXJlY3Rpb24gIT0g RVhFQ19SRVZFUlNFKQotCQkgICAgICAgIGVycm9yIChfKCJQcm9jZXNzIHJl Y29yZDogZXJyb3IgcmVhZGluZyBtZW1vcnkgYXQgIgotCQkJICAgICAgICAg ImFkZHIgPSAlcyBsZW4gPSAlZC4iKSwKLQkJICAgICAgICAgICAgICAgcGFk ZHJlc3MgKGdkYmFyY2gsIHJlY29yZF9saXN0LT51Lm1lbS5hZGRyKSwKLQkJ ICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7Ci0JCSAg ICAgIGVsc2UKLQkJCS8qIFJlYWQgZmFpbGVkIC0tIAotCQkJICAgZmxhZyBl bnRyeSBhcyBub3RfYWNjZXNzaWJsZS4gICovCi0JCSAgICAgICAgcmVjb3Jk X2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9IDE7Ci0J CSAgICB9Ci0JCSAgZWxzZQotCQkgICAgewotCQkgICAgICBpZiAodGFyZ2V0 X3dyaXRlX21lbW9yeSAocmVjb3JkX2xpc3QtPnUubWVtLmFkZHIsCi0JCQkg ICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS52YWws Ci0JCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlz dC0+dS5tZW0ubGVuKSkKLQkgICAgICAgICAgICAgICAgewotCQkJICBpZiAo ZXhlY3V0aW9uX2RpcmVjdGlvbiAhPSBFWEVDX1JFVkVSU0UpCi0JCQkgICAg ZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBlcnJvciB3cml0aW5nIG1lbW9y eSBhdCAiCi0JCQkgICAgICAgICAgICAgImFkZHIgPSAlcyBsZW4gPSAlZC4i KSwKLQkJICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBy ZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCi0JCSAgICAgICAgICAgICAgICAg ICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKLQkJCSAgZWxzZQotCQkJICAg IC8qIFdyaXRlIGZhaWxlZCAtLSAKLQkJCSAgICAgICBmbGFnIGVudHJ5IGFz IG5vdF9hY2Nlc3NpYmxlLiAgKi8KLQkJCSAgICByZWNvcmRfbGlzdC0+dS5t ZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlID0gMTsKLQkJCX0KLQkJICAg ICAgZWxzZQotCQkgICAgICAgIHsKLQkJCSAgbWVtY3B5IChyZWNvcmRfbGlz dC0+dS5tZW0udmFsLCBtZW0sCi0JCQkJICByZWNvcmRfbGlzdC0+dS5tZW0u bGVuKTsKLQkJCX0KLQkJICAgIH0KLQkJfQotCSAgICB9Ci0JICBlbHNlCisJ ICBpZiAocmVjb3JkX2xpc3QtPnR5cGUgPT0gcmVjb3JkX2VuZCkKIAkgICAg ewogCSAgICAgIGlmIChyZWNvcmRfZGVidWcgPiAxKQogCQlmcHJpbnRmX3Vu ZmlsdGVyZWQgKGdkYl9zdGRsb2csCkBAIC05MDEsNiArMTE4OCw3IEBAIHJl Y29yZF9raWxsIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzKQogICAgIGZwcmlu dGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiBy ZWNvcmRfa2lsbFxuIik7CiAKICAgdW5wdXNoX3RhcmdldCAoJnJlY29yZF9v cHMpOworCiAgIHRhcmdldF9raWxsICgpOwogfQogCkBAIC05NDUsNyArMTIz Myw3IEBAIHJlY29yZF9yZWdpc3RlcnNfY2hhbmdlIChzdHJ1Y3QgcmVnY2Fj aGUKICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfYXJjaF9saXN0X3RhaWw7CiAK ICAgaWYgKHJlY29yZF9pbnNuX251bSA9PSByZWNvcmRfaW5zbl9tYXhfbnVt ICYmIHJlY29yZF9pbnNuX21heF9udW0pCi0gICAgcmVjb3JkX2xpc3RfcmVs ZWFzZV9maXJzdCAoKTsKKyAgICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0 X2luc24gKCk7CiAgIGVsc2UKICAgICByZWNvcmRfaW5zbl9udW0rKzsKIH0K QEAgLTEwNTgsNyArMTM0Niw3IEBAIHJlY29yZF94ZmVyX3BhcnRpYWwgKHN0 cnVjdCB0YXJnZXRfb3BzICoKICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3Jk X2FyY2hfbGlzdF90YWlsOwogCiAgICAgICBpZiAocmVjb3JkX2luc25fbnVt ID09IHJlY29yZF9pbnNuX21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4X251 bSkKLQlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworCXJlY29yZF9s aXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAgICAgIGVsc2UKIAlyZWNv cmRfaW5zbl9udW0rKzsKICAgICB9CkBAIC0xMTM4LDYgKzE0MjYsMTkxIEBA IGluaXRfcmVjb3JkX29wcyAodm9pZCkKIH0KIAogc3RhdGljIHZvaWQKK3Jl Y29yZF9jb3JlX3Jlc3VtZSAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywgcHRp ZF90IHB0aWQsIGludCBzdGVwLAorICAgICAgICAgICAgICAgICAgICBlbnVt IHRhcmdldF9zaWduYWwgc2lnZ25hbCkKK3sKKyAgcmVjb3JkX3Jlc3VtZV9z dGVwID0gc3RlcDsKKyAgcmVjb3JkX3Jlc3VtZV9zaWdnbmFsID0gc2lnZ25h bDsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9jb3JlX2tpbGwgKHN0cnVj dCB0YXJnZXRfb3BzICpvcHMpCit7CisgIGlmIChyZWNvcmRfZGVidWcpCisg ICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyBy ZWNvcmQ6IHJlY29yZF9jb3JlX2tpbGxcbiIpOworCisgIHVucHVzaF90YXJn ZXQgKCZyZWNvcmRfY29yZV9vcHMpOworfQorCitzdGF0aWMgdm9pZAorcmVj b3JkX2NvcmVfZmV0Y2hfcmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wcyAq b3BzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBpbnQgcmVnbm8pCit7CisgIGlmIChyZWdubyA8IDApCisgICAgeworICAg ICAgaW50IG51bSA9IGdkYmFyY2hfbnVtX3JlZ3MgKGdldF9yZWdjYWNoZV9h cmNoIChyZWdjYWNoZSkpOworICAgICAgaW50IGk7CisKKyAgICAgIGZvciAo aSA9IDA7IGkgPCBudW07IGkgKyspCisgICAgICAgIHJlZ2NhY2hlX3Jhd19z dXBwbHkgKHJlZ2NhY2hlLCBpLAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0laRSAq IGkpOworICAgIH0KKyAgZWxzZQorICAgIHJlZ2NhY2hlX3Jhd19zdXBwbHkg KHJlZ2NhY2hlLCByZWdubywKKyAgICAgICAgICAgICAgICAgICAgICAgICBy ZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVHSVNURVJfU0laRSAqIHJlZ25v KTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9jb3JlX3ByZXBhcmVfdG9f c3RvcmUgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUpCit7Cit9CisKK3N0 YXRpYyB2b2lkCityZWNvcmRfY29yZV9zdG9yZV9yZWdpc3RlcnMgKHN0cnVj dCB0YXJnZXRfb3BzICpvcHMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGludCByZWdubykKK3sKKyAgaWYgKHJlY29yZF9n ZGJfb3BlcmF0aW9uX2Rpc2FibGUpCisgICAgcmVnY2FjaGVfcmF3X2NvbGxl Y3QgKHJlZ2NhY2hlLCByZWdubywKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JFR0lTVEVSX1NJWkUgKiBy ZWdubyk7CisgIGVsc2UKKyAgICBlcnJvciAoXygiWW91IGNhbid0IGRvIHRo YXQgd2l0aG91dCBhIHByb2Nlc3MgdG8gZGVidWcuIikpOworfQorCitzdGF0 aWMgTE9OR0VTVAorcmVjb3JkX2NvcmVfeGZlcl9wYXJ0aWFsIChzdHJ1Y3Qg dGFyZ2V0X29wcyAqb3BzLCBlbnVtIHRhcmdldF9vYmplY3Qgb2JqZWN0LAor CQkgICAgICAgICAgY29uc3QgY2hhciAqYW5uZXgsIGdkYl9ieXRlICpyZWFk YnVmLAorCQkgICAgICAgICAgY29uc3QgZ2RiX2J5dGUgKndyaXRlYnVmLCBV TE9OR0VTVCBvZmZzZXQsCisgICAgICAgICAgICAgICAgICAgICAgICAgIExP TkdFU1QgbGVuKQoreworICAgaWYgKG9iamVjdCA9PSBUQVJHRVRfT0JKRUNU X01FTU9SWSkKKyAgICAgeworICAgICAgIGlmIChyZWNvcmRfZ2RiX29wZXJh dGlvbl9kaXNhYmxlIHx8ICF3cml0ZWJ1ZikKKyAgICAgICAgIHsKKyAgICAg ICAgICAgc3RydWN0IHRhcmdldF9zZWN0aW9uICpwOworICAgICAgICAgICBm b3IgKHAgPSByZWNvcmRfY29yZV9zdGFydDsgcCA8IHJlY29yZF9jb3JlX2Vu ZDsgcCsrKQorICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgIGlmIChv ZmZzZXQgPj0gcC0+YWRkcikKKyAgICAgICAgICAgICAgICAgeworICAgICAg ICAgICAgICAgICAgIHN0cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkgKmVu dHJ5OworCisgICAgICAgICAgICAgICAgICAgaWYgKG9mZnNldCA+PSBwLT5l bmRhZGRyKQorICAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgICAgICAgICAgICBpZiAob2Zmc2V0ICsgbGVuID4gcC0+ZW5kYWRk cikKKyAgICAgICAgICAgICAgICAgICAgIGxlbiA9IHAtPmVuZGFkZHIgLSBv ZmZzZXQ7CisKKyAgICAgICAgICAgICAgICAgICBvZmZzZXQgLT0gcC0+YWRk cjsKKworICAgICAgICAgICAgICAgICAgIC8qIFJlYWQgcmVhZGJ1ZiBvciB3 cml0ZSB3cml0ZWJ1ZiBwLCBvZmZzZXQsIGxlbi4gICovCisgICAgICAgICAg ICAgICAgICAgLyogQ2hlY2sgZmxhZ3MuICAqLworICAgICAgICAgICAgICAg ICAgIGlmIChwLT50aGVfYmZkX3NlY3Rpb24tPmZsYWdzICYgU0VDX0NPTlNU UlVDVE9SCisgICAgICAgICAgICAgICAgICAgICAgIHx8IChwLT50aGVfYmZk X3NlY3Rpb24tPmZsYWdzICYgU0VDX0hBU19DT05URU5UUykgPT0gMCkKKyAg ICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAg aWYgKHJlYWRidWYpCisgICAgICAgICAgICAgICAgICAgICAgICAgbWVtc2V0 IChyZWFkYnVmLCAwLCBsZW4pOworICAgICAgICAgICAgICAgICAgICAgICBy ZXR1cm4gbGVuOworICAgICAgICAgICAgICAgICAgICAgfQorICAgICAgICAg ICAgICAgICAgIC8qIEdldCByZWNvcmRfY29yZV9idWZfZW50cnkuICAqLwor ICAgICAgICAgICAgICAgICAgIGZvciAoZW50cnkgPSByZWNvcmRfY29yZV9i dWZfbGlzdDsgZW50cnk7CisgICAgICAgICAgICAgICAgICAgICAgICBlbnRy eSA9IGVudHJ5LT5wcmV2KQorICAgICAgICAgICAgICAgICAgICAgaWYgKGVu dHJ5LT5wID09IHApCisgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrOwor ICAgICAgICAgICAgICAgICAgIGlmICh3cml0ZWJ1ZikKKyAgICAgICAgICAg ICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgaWYgKCFlbnRy eSkKKyAgICAgICAgICAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICAvKiBBZGQgYSBuZXcgZW50cnkuICAqLworICAgICAg ICAgICAgICAgICAgICAgICAgICAgZW50cnkKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgPSAoc3RydWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeSAq KQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeG1hbGxvYwor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoc2l6ZW9mIChz dHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5KSk7CisgICAgICAgICAgICAg ICAgICAgICAgICAgICBlbnRyeS0+cCA9IHA7CisgICAgICAgICAgICAgICAg ICAgICAgICAgICBpZiAoIWJmZF9tYWxsb2NfYW5kX2dldF9zZWN0aW9uIChw LT5iZmQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBwLT50aGVfYmZkX3NlY3Rpb24sCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAmZW50cnktPmJ1ZikpCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB4ZnJlZSAoZW50cnkpOworICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiAwOworICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+cHJldiA9IHJl Y29yZF9jb3JlX2J1Zl9saXN0OworICAgICAgICAgICAgICAgICAgICAgICAg ICAgcmVjb3JkX2NvcmVfYnVmX2xpc3QgPSBlbnRyeTsKKyAgICAgICAgICAg ICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICAgICAgICAgIG1l bWNweSAoZW50cnktPmJ1ZiArIG9mZnNldCwgd3JpdGVidWYsIChzaXplX3Qp IGxlbik7CisgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAg ICAgICAgZWxzZQorICAgICAgICAgICAgICAgICAgICAgeworICAgICAgICAg ICAgICAgICAgICAgICBpZiAoIWVudHJ5KQorICAgICAgICAgICAgICAgICAg ICAgICAgIHJldHVybiByZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAocmVjb3JkX2Jl bmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgb2JqZWN0LCBhbm5leCwgcmVhZGJ1Ziwgd3Jp dGVidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9m ZnNldCwgbGVuKTsKKworICAgICAgICAgICAgICAgICAgICAgICBtZW1jcHkg KHJlYWRidWYsIGVudHJ5LT5idWYgKyBvZmZzZXQsIChzaXplX3QpIGxlbik7 CisgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgICAgICAg ICByZXR1cm4gbGVuOworICAgICAgICAgICAgICAgICB9CisgICAgICAgICAg ICAgfQorCisgICAgICAgICAgIHJldHVybiAtMTsKKyAgICAgICAgIH0KKyAg ICAgICBlbHNlCisgICAgICAgICBlcnJvciAoXygiWW91IGNhbid0IGRvIHRo YXQgd2l0aG91dCBhIHByb2Nlc3MgdG8gZGVidWcuIikpOworICAgICB9CisK KyAgcmV0dXJuIHJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCAocmVj b3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0LCBhbm5leCwg cmVhZGJ1Ziwgd3JpdGVidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIG9mZnNldCwgbGVuKTsKK30KKworc3RhdGljIGlu dAorcmVjb3JkX2NvcmVfaW5zZXJ0X2JyZWFrcG9pbnQgKHN0cnVjdCBnZGJh cmNoICpnZGJhcmNoLAorCQkJICAgICAgIHN0cnVjdCBicF90YXJnZXRfaW5m byAqYnBfdGd0KQoreworICByZXR1cm4gMDsKK30KKworc3RhdGljIGludAor cmVjb3JkX2NvcmVfcmVtb3ZlX2JyZWFrcG9pbnQgKHN0cnVjdCBnZGJhcmNo ICpnZGJhcmNoLAorCQkJICAgICAgIHN0cnVjdCBicF90YXJnZXRfaW5mbyAq YnBfdGd0KQoreworICByZXR1cm4gMDsKK30KKworaW50CityZWNvcmRfY29y ZV9oYXNfZXhlY3V0aW9uIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzKQorewor ICByZXR1cm4gMTsKK30KKworc3RhdGljIHZvaWQKK2luaXRfcmVjb3JkX2Nv cmVfb3BzICh2b2lkKQoreworICByZWNvcmRfY29yZV9vcHMudG9fc2hvcnRu YW1lID0gInJlY29yZF9jb3JlIjsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX2xv bmduYW1lID0gIlByb2Nlc3MgcmVjb3JkIGFuZCByZXBsYXkgdGFyZ2V0IjsK KyAgcmVjb3JkX2NvcmVfb3BzLnRvX2RvYyA9CisgICAgIkxvZyBwcm9ncmFt IHdoaWxlIGV4ZWN1dGluZyBhbmQgcmVwbGF5IGV4ZWN1dGlvbiBmcm9tIGxv Zy4iOworICByZWNvcmRfY29yZV9vcHMudG9fb3BlbiA9IHJlY29yZF9vcGVu OworICByZWNvcmRfY29yZV9vcHMudG9fY2xvc2UgPSByZWNvcmRfY2xvc2U7 CisgIHJlY29yZF9jb3JlX29wcy50b19yZXN1bWUgPSByZWNvcmRfY29yZV9y ZXN1bWU7CisgIHJlY29yZF9jb3JlX29wcy50b193YWl0ID0gcmVjb3JkX3dh aXQ7CisgIHJlY29yZF9jb3JlX29wcy50b19raWxsID0gcmVjb3JkX2NvcmVf a2lsbDsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX2ZldGNoX3JlZ2lzdGVycyA9 IHJlY29yZF9jb3JlX2ZldGNoX3JlZ2lzdGVyczsKKyAgcmVjb3JkX2NvcmVf b3BzLnRvX3ByZXBhcmVfdG9fc3RvcmUgPSByZWNvcmRfY29yZV9wcmVwYXJl X3RvX3N0b3JlOworICByZWNvcmRfY29yZV9vcHMudG9fc3RvcmVfcmVnaXN0 ZXJzID0gcmVjb3JkX2NvcmVfc3RvcmVfcmVnaXN0ZXJzOworICByZWNvcmRf Y29yZV9vcHMudG9feGZlcl9wYXJ0aWFsID0gcmVjb3JkX2NvcmVfeGZlcl9w YXJ0aWFsOworICByZWNvcmRfY29yZV9vcHMudG9faW5zZXJ0X2JyZWFrcG9p bnQgPSByZWNvcmRfY29yZV9pbnNlcnRfYnJlYWtwb2ludDsKKyAgcmVjb3Jk X2NvcmVfb3BzLnRvX3JlbW92ZV9icmVha3BvaW50ID0gcmVjb3JkX2NvcmVf cmVtb3ZlX2JyZWFrcG9pbnQ7CisgIHJlY29yZF9jb3JlX29wcy50b19jYW5f ZXhlY3V0ZV9yZXZlcnNlID0gcmVjb3JkX2Nhbl9leGVjdXRlX3JldmVyc2U7 CisgIHJlY29yZF9jb3JlX29wcy50b19oYXNfZXhlY3V0aW9uID0gcmVjb3Jk X2NvcmVfaGFzX2V4ZWN1dGlvbjsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX3N0 cmF0dW0gPSByZWNvcmRfc3RyYXR1bTsKKyAgcmVjb3JkX2NvcmVfb3BzLnRv X21hZ2ljID0gT1BTX01BR0lDOworfQorCitzdGF0aWMgdm9pZAogc2hvd19y ZWNvcmRfZGVidWcgKHN0cnVjdCB1aV9maWxlICpmaWxlLCBpbnQgZnJvbV90 dHksCiAJCSAgIHN0cnVjdCBjbWRfbGlzdF9lbGVtZW50ICpjLCBjb25zdCBj aGFyICp2YWx1ZSkKIHsKQEAgLTExNTMsNiArMTYyNiwyMTIgQEAgY21kX3Jl Y29yZF9zdGFydCAoY2hhciAqYXJncywgaW50IGZyb21fdAogICBleGVjdXRl X2NvbW1hbmQgKCJ0YXJnZXQgcmVjb3JkIiwgZnJvbV90dHkpOwogfQogCitz dGF0aWMgdm9pZAorY21kX3JlY29yZF9sb2FkIChjaGFyICphcmdzLCBpbnQg ZnJvbV90dHkpCit7CisgIGNoYXIgYnVmWzUxMl07CisKKyAgc25wcmludGYg KGJ1ZiwgNTEyLCAidGFyZ2V0IHJlY29yZCAlcyIsIGFyZ3MpOworICBleGVj dXRlX2NvbW1hbmQgKGJ1ZiwgZnJvbV90dHkpOworfQorCitzdGF0aWMgaW5s aW5lIHZvaWQKK3JlY29yZF93cml0ZV9kdW1wIChjaGFyICpyZWNmaWxlbmFt ZSwgaW50IGZpbGRlcywgY29uc3Qgdm9pZCAqYnVmLAorICAgICAgICAgICAg ICAgICAgIHNpemVfdCBuYnl0ZSkKK3sKKyAgaWYgKHdyaXRlIChmaWxkZXMs IGJ1ZiwgbmJ5dGUpICE9IG5ieXRlKQorICAgIGVycm9yIChfKCJGYWlsZWQg dG8gd3JpdGUgZHVtcCBvZiBleGVjdXRpb24gcmVjb3JkcyB0byAnJXMnLiIp LAorICAgICAgICAgICByZWNmaWxlbmFtZSk7Cit9CisKKy8qIFJlY29yZCBs b2cgc2F2ZS1maWxlIGZvcm1hdAorICAgVmVyc2lvbiAxCisKKyAgIEhlYWRl cjoKKyAgICAgNCBieXRlczogbWFnaWMgbnVtYmVyIGh0b25sKDB4MjAwOTA3 MjYpLgorICAgICAgIE5PVEU6IGJlIHN1cmUgdG8gY2hhbmdlIHdoZW5ldmVy IHRoaXMgZmlsZSBmb3JtYXQgY2hhbmdlcyEKKworICAgUmVjb3JkczoKKyAg ICAgcmVjb3JkX2VuZDoKKyAgICAgICAxIGJ5dGU6ICByZWNvcmQgdHlwZSAo cmVjb3JkX2VuZCkuCisgICAgIHJlY29yZF9yZWc6CisgICAgICAgMSBieXRl OiAgcmVjb3JkIHR5cGUgKHJlY29yZF9yZWcpLgorICAgICAgIDggYnl0ZXM6 IHJlZ2lzdGVyIGlkIChuZXR3b3JrIGJ5dGUgb3JkZXIpLgorICAgICAgIE1B WF9SRUdJU1RFUl9TSVpFIGJ5dGVzOiByZWdpc3RlciB2YWx1ZS4KKyAgICAg cmVjb3JkX21lbToKKyAgICAgICAxIGJ5dGU6ICByZWNvcmQgdHlwZSAocmVj b3JkX21lbSkuCisgICAgICAgOCBieXRlczogbWVtb3J5IGFkZHJlc3MgKG5l dHdvcmsgYnl0ZSBvcmRlcikuCisgICAgICAgOCBieXRlczogbWVtb3J5IGxl bmd0aCAobmV0d29yayBieXRlIG9yZGVyKS4KKyAgICAgICBuIGJ5dGVzOiBt ZW1vcnkgdmFsdWUgKG4gPT0gbWVtb3J5IGxlbmd0aCkuCisqLworCisvKiBE dW1wIHRoZSBleGVjdXRpb24gbG9nIHRvIGEgZmlsZS4gICovCisKK3N0YXRp YyB2b2lkCitjbWRfcmVjb3JkX2R1bXAgKGNoYXIgKmFyZ3MsIGludCBmcm9t X3R0eSkKK3sKKyAgY2hhciAqcmVjZmlsZW5hbWUsIHJlY2ZpbGVuYW1lX2J1 ZmZlcls0MF07CisgIGludCByZWNmZDsKKyAgc3RydWN0IHJlY29yZF9lbnRy eSAqY3VyX3JlY29yZF9saXN0OworICB1aW50MzJfdCBtYWdpYzsKKyAgc3Ry dWN0IHJlZ2NhY2hlICpyZWdjYWNoZTsKKyAgc3RydWN0IGdkYmFyY2ggKmdk YmFyY2g7CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2xlYW51cHM7CisgIHN0 cnVjdCBjbGVhbnVwICpzZXRfY2xlYW51cHM7CisKKyAgaWYgKHN0cmNtcCAo Y3VycmVudF90YXJnZXQudG9fc2hvcnRuYW1lLCAicmVjb3JkIikgIT0gMCkK KyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgaXMgbm90IHN0YXJ0ZWQu XG4iKSk7CisKKyAgaWYgKGFyZ3MgJiYgKmFyZ3MpCisgICAgcmVjZmlsZW5h bWUgPSBhcmdzOworICBlbHNlCisgICAgeworICAgICAgLyogRGVmYXVsdCBj b3JlZmlsZSBuYW1lIGlzICJnZGJfcmVjb3JkLlBJRCIuICAqLworICAgICAg c25wcmludGYgKHJlY2ZpbGVuYW1lX2J1ZmZlciwgNDAsICJnZGJfcmVjb3Jk LiVkIiwKKyAgICAgICAgICAgICAgICBQSURHRVQgKGluZmVyaW9yX3B0aWQp KTsKKyAgICAgIHJlY2ZpbGVuYW1lID0gcmVjZmlsZW5hbWVfYnVmZmVyOwor ICAgIH0KKworICAvKiBPcGVuIHRoZSBkdW1wIGZpbGUuICAqLworICBpZiAo cmVjb3JkX2RlYnVnKQorICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0 ZGxvZywKKyAgICAgICAgICAgICAgICAgICAgICAgIF8oIlNhdmluZyByZWNv cmRpbmcgdG8gZmlsZSAnJXMnXG4iKSwKKyAgICAgICAgICAgICAgICAgICAg ICAgIHJlY2ZpbGVuYW1lKTsKKyAgcmVjZmQgPSBvcGVuIChyZWNmaWxlbmFt ZSwgT19XUk9OTFkgfCBPX0NSRUFUIHwgT19UUlVOQyB8IE9fQklOQVJZLAor ICAgICAgICAgICAgICAgIFNfSVJVU1IgfCBTX0lXVVNSKTsKKyAgaWYgKHJl Y2ZkIDwgMCkKKyAgICBlcnJvciAoXygiRmFpbGVkIHRvIG9wZW4gJyVzJyBm b3IgZHVtcCBleGVjdXRpb24gcmVjb3JkczogJXMiKSwKKyAgICAgICAgICAg cmVjZmlsZW5hbWUsIHN0cmVycm9yIChlcnJubykpOworICBvbGRfY2xlYW51 cHMgPSBtYWtlX2NsZWFudXAgKHJlY29yZF9mZF9jbGVhbnVwcywgJnJlY2Zk KTsKKworICAvKiBTYXZlIHRoZSBjdXJyZW50IHJlY29yZCBlbnRyeSB0byAi Y3VyX3JlY29yZF9saXN0Ii4gICovCisgIGN1cl9yZWNvcmRfbGlzdCA9IHJl Y29yZF9saXN0OworCisgIC8qIEdldCB0aGUgdmFsdWVzIG9mIHJlZ2NhY2hl IGFuZCBnZGJhcmNoLiAgKi8KKyAgcmVnY2FjaGUgPSBnZXRfY3VycmVudF9y ZWdjYWNoZSAoKTsKKyAgZ2RiYXJjaCA9IGdldF9yZWdjYWNoZV9hcmNoIChy ZWdjYWNoZSk7CisKKyAgLyogRGlzYWJsZSB0aGUgR0RCIG9wZXJhdGlvbiBy ZWNvcmQuICAqLworICBzZXRfY2xlYW51cHMgPSByZWNvcmRfZ2RiX29wZXJh dGlvbl9kaXNhYmxlX3NldCAoKTsKKworICAvKiBXcml0ZSB0aGUgbWFnaWMg Y29kZS4gICovCisgIG1hZ2ljID0gUkVDT1JEX0ZJTEVfTUFHSUM7CisgIGlm IChyZWNvcmRfZGVidWcpCisgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLCBfKCJcCitXcml0aW5nIDQtYnl0ZSBtYWdpYyBjb29raWUgUkVD T1JEX0ZJTEVfTUFHSUMgKDB4JTA4eClcbiIpLAorICAgICAgICAgICAgICAg ICAgICAgICAgbWFnaWMpOworICByZWNvcmRfd3JpdGVfZHVtcCAocmVjZmls ZW5hbWUsIHJlY2ZkLCAmbWFnaWMsIDQpOworCisgIC8qIFJldmVyc2UgZXhl Y3V0ZSB0byB0aGUgYmVnaW4gb2YgcmVjb3JkIGxpc3QuICAqLworICB3aGls ZSAoMSkKKyAgICB7CisgICAgICAvKiBDaGVjayBmb3IgYmVnaW5uaW5nIGFu ZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAgIGlmIChyZWNvcmRfbGlzdCA9PSAm cmVjb3JkX2ZpcnN0KQorICAgICAgICBicmVhazsKKworICAgICAgcmVjb3Jk X2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNvcmRfbGlzdCk7 CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+cHJldikKKyAgICAgICAgcmVj b3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsKKyAgICB9CisKKyAgLyog RHVtcCB0aGUgZW50cmllcyB0byByZWNmZCBhbmQgZm9yd2FyZCBleGVjdXRl IHRvIHRoZSBlbmQgb2YKKyAgICAgcmVjb3JkIGxpc3QuICAqLworICB3aGls ZSAoMSkKKyAgICB7CisgICAgICAvKiBEdW1wIGVudHJ5LiAgKi8KKyAgICAg IGlmIChyZWNvcmRfbGlzdCAhPSAmcmVjb3JkX2ZpcnN0KQorICAgICAgICB7 CisgICAgICAgICAgdWludDhfdCB0bXB1ODsKKyAgICAgICAgICB1aW50NjRf dCB0bXB1NjQ7CisKKyAgICAgICAgICB0bXB1OCA9IHJlY29yZF9saXN0LT50 eXBlOworICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFt ZSwgcmVjZmQsICZ0bXB1OCwgMSk7CisKKyAgICAgICAgICBzd2l0Y2ggKHJl Y29yZF9saXN0LT50eXBlKQorICAgICAgICAgICAgeworICAgICAgICAgICAg Y2FzZSByZWNvcmRfcmVnOiAvKiByZWcgKi8KKyAgICAgICAgICAgICAgaWYg KHJlY29yZF9kZWJ1ZykKKyAgICAgICAgICAgICAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csIF8oIlwKK1dyaXRpbmcgcmVnaXN0ZXIgJWQg KDEgcGx1cyA4IHBsdXMgJWQgYnl0ZXMpXG4iKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51LnJlZy5udW0s CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNQVhfUkVH SVNURVJfU0laRSk7CisKKyAgICAgICAgICAgICAgdG1wdTY0ID0gcmVjb3Jk X2xpc3QtPnUucmVnLm51bTsKKyAgICAgICAgICAgICAgaWYgKEJZVEVfT1JE RVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgICAgICB0bXB1NjQg PSBic3dhcF82NCAodG1wdTY0KTsKKyAgICAgICAgICAgICAgcmVjb3JkX3dy aXRlX2R1bXAgKHJlY2ZpbGVuYW1lLCByZWNmZCwgJnRtcHU2NCwgOCk7CisK KyAgICAgICAgICAgICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1l LCByZWNmZCwgcmVjb3JkX2xpc3QtPnUucmVnLnZhbCwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIE1BWF9SRUdJU1RFUl9TSVpFKTsKKyAg ICAgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgICAgIGNhc2UgcmVjb3Jk X21lbTogLyogbWVtICovCisgICAgICAgICAgICAgIGlmICghcmVjb3JkX2xp c3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSkKKyAgICAgICAg ICAgICAgICB7CisgICAgICAgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVn KQorICAgICAgICAgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdk Yl9zdGRsb2csIF8oIlwKK1dyaXRpbmcgbWVtb3J5ICVzICgxIHBsdXMgOCBw bHVzIDggYnl0ZXMgcGx1cyAlZCBieXRlcylcbiIpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNo LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUu bWVtLmxlbik7CisKKyAgICAgICAgICAgICAgICAgIHRtcHU2NCA9IHJlY29y ZF9saXN0LT51Lm1lbS5hZGRyOworICAgICAgICAgICAgICAgICAgaWYgKEJZ VEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgICAgICAg ICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAgICAg ICAgICByZWNvcmRfd3JpdGVfZHVtcCAocmVjZmlsZW5hbWUsIHJlY2ZkLCAm dG1wdTY0LCA4KTsKKworICAgICAgICAgICAgICAgICAgdG1wdTY0ID0gcmVj b3JkX2xpc3QtPnUubWVtLmxlbjsKKyAgICAgICAgICAgICAgICAgIGlmIChC WVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAgICAgICAg ICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgICAg ICAgICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1lLCByZWNmZCwg JnRtcHU2NCwgOCk7CisKKyAgICAgICAgICAgICAgICAgIHJlY29yZF93cml0 ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRf bGlzdC0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAgICB9CisgICAgICAg ICAgICAgIGJyZWFrOworCisgICAgICAgICAgICAgIGNhc2UgcmVjb3JkX2Vu ZDoKKyAgICAgICAgICAgICAgICAvKiBGSVhNRTogcmVjb3JkIHRoZSBjb250 ZW50cyBvZiByZWNvcmRfZW5kIHJlYy4gICovCisgICAgICAgICAgICAgICAg aWYgKHJlY29yZF9kZWJ1ZykKKyAgICAgICAgICAgICAgICAgIGZwcmludGZf dW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgXygiV3JpdGluZyByZWNvcmRfZW5kICgxIGJ5 dGUpXG4iKSk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAg ICB9CisgICAgICAgIH0KKworICAgICAgLyogRXhlY3V0ZSBlbnRyeS4gICov CisgICAgICByZWNvcmRfZXhlY19lbnRyeSAocmVnY2FjaGUsIGdkYmFyY2gs IHJlY29yZF9saXN0KTsKKworICAgICAgaWYgKHJlY29yZF9saXN0LT5uZXh0 KQorICAgICAgICByZWNvcmRfbGlzdCA9IHJlY29yZF9saXN0LT5uZXh0Owor ICAgICAgZWxzZQorICAgICAgICBicmVhazsKKyAgICB9CisKKyAgLyogUmV2 ZXJzZSBleGVjdXRlIHRvIGN1cl9yZWNvcmRfbGlzdC4gICovCisgIHdoaWxl ICgxKQorICAgIHsKKyAgICAgIC8qIENoZWNrIGZvciBiZWdpbm5pbmcgYW5k IGVuZCBvZiBsb2cuICAqLworICAgICAgaWYgKHJlY29yZF9saXN0ID09IGN1 cl9yZWNvcmRfbGlzdCkKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIHJlY29y ZF9leGVjX2VudHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3Qp OworCisgICAgICBpZiAocmVjb3JkX2xpc3QtPnByZXYpCisgICAgICAgIHJl Y29yZF9saXN0ID0gcmVjb3JkX2xpc3QtPnByZXY7CisgICAgfQorCisgIGRv X2NsZWFudXBzIChzZXRfY2xlYW51cHMpOworICBkb19jbGVhbnVwcyAob2xk X2NsZWFudXBzKTsKKworICAvKiBTdWNjZWVkZWQuICAqLworICBmcHJpbnRm X2ZpbHRlcmVkIChnZGJfc3Rkb3V0LCBfKCJTYXZlZCBkdW1wIG9mIGV4ZWN1 dGlvbiAiCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInJl Y29yZHMgdG8gYCVzJy5cbiIpLAorICAgICAgICAgICAgICAgICAgICByZWNm aWxlbmFtZSk7Cit9CisKIC8qIFRydW5jYXRlIHRoZSByZWNvcmQgbG9nIGZy b20gdGhlIHByZXNlbnQgcG9pbnQKICAgIG9mIHJlcGxheSB1bnRpbCB0aGUg ZW5kLiAgKi8KIApAQCAtMTE4NSw3ICsxODY0LDEyIEBAIGNtZF9yZWNvcmRf c3RvcCAoY2hhciAqYXJncywgaW50IGZyb21fdHQKICAgICB7CiAgICAgICBp ZiAoIXJlY29yZF9saXN0IHx8ICFmcm9tX3R0eSB8fCBxdWVyeSAoXygiRGVs ZXRlIHJlY29yZGVkIGxvZyBhbmQgIgogCSAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAic3RvcCByZWNvcmRpbmc/IikpKQotCXVu cHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKKyAgICAgICAgeworICAgICAg ICAgIGlmIChzdHJjbXAgKGN1cnJlbnRfdGFyZ2V0LnRvX3Nob3J0bmFtZSwg InJlY29yZCIpID09IDApCisJICAgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRf b3BzKTsKKyAgICAgICAgICBlbHNlCisgICAgICAgICAgICB1bnB1c2hfdGFy Z2V0ICgmcmVjb3JkX2NvcmVfb3BzKTsKKyAgICAgICAgfQogICAgIH0KICAg ZWxzZQogICAgIHByaW50Zl91bmZpbHRlcmVkIChfKCJQcm9jZXNzIHJlY29y ZCBpcyBub3Qgc3RhcnRlZC5cbiIpKTsKQEAgLTEyMDMsNyArMTg4Nyw3IEBA IHNldF9yZWNvcmRfaW5zbl9tYXhfbnVtIChjaGFyICphcmdzLCBpbnQKIAkJ ICAgICAgICAgICAidGhlIGZpcnN0IG9uZXM/XG4iKSk7CiAKICAgICAgIHdo aWxlIChyZWNvcmRfaW5zbl9udW0gPiByZWNvcmRfaW5zbl9tYXhfbnVtKQot CXJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3QgKCk7CisJcmVjb3JkX2xpc3Rf cmVsZWFzZV9maXJzdF9pbnNuICgpOwogICAgIH0KIH0KIApAQCAtMTI0Myw2 ICsxOTI3LDggQEAgaW5mb19yZWNvcmRfY29tbWFuZCAoY2hhciAqYXJncywg aW50IGZybwogdm9pZAogX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogewor ICBzdHJ1Y3QgY21kX2xpc3RfZWxlbWVudCAqYzsKKwogICAvKiBJbml0IHJl Y29yZF9maXJzdC4gICovCiAgIHJlY29yZF9maXJzdC5wcmV2ID0gTlVMTDsK ICAgcmVjb3JkX2ZpcnN0Lm5leHQgPSBOVUxMOwpAQCAtMTI1MCw2ICsxOTM2 LDggQEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogCiAgIGluaXRfcmVj b3JkX29wcyAoKTsKICAgYWRkX3RhcmdldCAoJnJlY29yZF9vcHMpOworICBp bml0X3JlY29yZF9jb3JlX29wcyAoKTsKKyAgYWRkX3RhcmdldCAoJnJlY29y ZF9jb3JlX29wcyk7CiAKICAgYWRkX3NldHNob3dfemludGVnZXJfY21kICgi cmVjb3JkIiwgbm9fY2xhc3MsICZyZWNvcmRfZGVidWcsCiAJCQkgICAgXygi U2V0IGRlYnVnZ2luZyBvZiByZWNvcmQvcmVwbGF5IGZlYXR1cmUuIiksCkBA IC0xMjU5LDkgKzE5NDcsMTAgQEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lk KQogCQkJICAgIE5VTEwsIHNob3dfcmVjb3JkX2RlYnVnLCAmc2V0ZGVidWds aXN0LAogCQkJICAgICZzaG93ZGVidWdsaXN0KTsKIAotICBhZGRfcHJlZml4 X2NtZCAoInJlY29yZCIsIGNsYXNzX29ic2N1cmUsIGNtZF9yZWNvcmRfc3Rh cnQsCi0JCSAgXygiQWJicmV2aWF0ZWQgZm9ybSBvZiBcInRhcmdldCByZWNv cmRcIiBjb21tYW5kLiIpLAotIAkJICAmcmVjb3JkX2NtZGxpc3QsICJyZWNv cmQgIiwgMCwgJmNtZGxpc3QpOworICBjID0gYWRkX3ByZWZpeF9jbWQgKCJy ZWNvcmQiLCBjbGFzc19vYnNjdXJlLCBjbWRfcmVjb3JkX3N0YXJ0LAorCQkg ICAgICBfKCJBYmJyZXZpYXRlZCBmb3JtIG9mIFwidGFyZ2V0IHJlY29yZFwi IGNvbW1hbmQuIiksCisgCQkgICAgICAmcmVjb3JkX2NtZGxpc3QsICJyZWNv cmQgIiwgMCwgJmNtZGxpc3QpOworICBzZXRfY21kX2NvbXBsZXRlciAoYywg ZmlsZW5hbWVfY29tcGxldGVyKTsKICAgYWRkX2NvbV9hbGlhcyAoInJlYyIs ICJyZWNvcmQiLCBjbGFzc19vYnNjdXJlLCAxKTsKICAgYWRkX3ByZWZpeF9j bWQgKCJyZWNvcmQiLCBjbGFzc19zdXBwb3J0LCBzZXRfcmVjb3JkX2NvbW1h bmQsCiAJCSAgXygiU2V0IHJlY29yZCBvcHRpb25zIiksICZzZXRfcmVjb3Jk X2NtZGxpc3QsCkBAIC0xMjc2LDYgKzE5NjUsMTYgQEAgX2luaXRpYWxpemVf cmVjb3JkICh2b2lkKQogCQkgICJpbmZvIHJlY29yZCAiLCAwLCAmaW5mb2xp c3QpOwogICBhZGRfYWxpYXNfY21kICgicmVjIiwgInJlY29yZCIsIGNsYXNz X29ic2N1cmUsIDEsICZpbmZvbGlzdCk7CiAKKyAgYyA9IGFkZF9jbWQgKCJs b2FkIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3JlY29yZF9sb2FkLAorCSAgICAg ICBfKCJMb2FkIHByZXZpb3VzbHkgZHVtcGVkIGV4ZWN1dGlvbiByZWNvcmRz IGZyb20gXAorYSBmaWxlIGdpdmVuIGFzIGFyZ3VtZW50LiIpLAorICAgICAg ICAgICAgICAgJnJlY29yZF9jbWRsaXN0KTsKKyAgc2V0X2NtZF9jb21wbGV0 ZXIgKGMsIGZpbGVuYW1lX2NvbXBsZXRlcik7CisgIGMgPSBhZGRfY21kICgi ZHVtcCIsIGNsYXNzX29ic2N1cmUsIGNtZF9yZWNvcmRfZHVtcCwKKwkgICAg ICAgXygiRHVtcCB0aGUgZXhlY3V0aW9uIHJlY29yZHMgdG8gYSBmaWxlLlxu XAorQXJndW1lbnQgaXMgb3B0aW9uYWwgZmlsZW5hbWUuICBEZWZhdWx0IGZp bGVuYW1lIGlzICdnZGJfcmVjb3JkLjxwcm9jZXNzX2lkPicuIiksCisgICAg ICAgICAgICAgICAmcmVjb3JkX2NtZGxpc3QpOworICBzZXRfY21kX2NvbXBs ZXRlciAoYywgZmlsZW5hbWVfY29tcGxldGVyKTsKIAogICBhZGRfY21kICgi ZGVsZXRlIiwgY2xhc3Nfb2JzY3VyZSwgY21kX3JlY29yZF9kZWxldGUsCiAJ ICAgXygiRGVsZXRlIHRoZSByZXN0IG9mIGV4ZWN1dGlvbiBsb2cgYW5kIHN0 YXJ0IHJlY29yZGluZyBpdCBhbmV3LiIpLAo= --00504502ce543a1f080471de6828--