From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26098 invoked by alias); 22 Aug 2009 17:35:01 -0000 Received: (qmail 26069 invoked by uid 22791); 22 Aug 2009 17:34:53 -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-pz0-f198.google.com (HELO mail-pz0-f198.google.com) (209.85.222.198) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 22 Aug 2009 17:34:42 +0000 Received: by pzk36 with SMTP id 36so359262pzk.12 for ; Sat, 22 Aug 2009 10:34:40 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.4.17 with SMTP id 17mr155857wfd.85.1250962480095; Sat, 22 Aug 2009 10:34:40 -0700 (PDT) In-Reply-To: <4A7F5410.4000400@vmware.com> References: <4A7B99B3.40407@vmware.com> <4A7B9F49.9030202@vmware.com> <83ws5gm30b.fsf@gnu.org> <4A7C625B.8080005@vmware.com> <4A7F5410.4000400@vmware.com> From: Hui Zhu Date: Sat, 22 Aug 2009 17:39: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=00504502bfe940e2800471be6642 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/msg00352.txt.bz2 --00504502bfe940e2800471be6642 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: quoted-printable Content-length: 44421 On Mon, Aug 10, 2009 at 06:56, Michael Snyder wrote: > Hui Zhu wrote: >> >> I think give him a query is very clear. >> >> When he load, if there are some record log, it will query to user. =A0He >> must choice remove the old record log or keep them. =A0He already know >> what will happen. > > This is my opinion. =A0The default should be to remove the old log > (not to query). =A0I think this will be both the most common case > and the safest. =A0We can maybe add a command option for those who > wish not to do that. > > Anyone else have an opinion? > >> On Sat, Aug 8, 2009 at 01:20, Michael Snyder wrote: >>> >>> Eli Zaretskii wrote: >>>>> >>>>> From: Hui Zhu >>>>> Date: Fri, 7 Aug 2009 11:34:20 +0800 >>>>> Cc: Eli Zaretskii , "gdb-patches@sourceware.org" >>>>> >>>>> >>>>> I think a warning is clear to most of people. >>>>> >>>>> And when he get this warning. =A0He can delete the record list and lo= ad >>>>> again. =A0He will lost nothing. >>>>> >>>>> If we delete the old record list, maybe he still need old record. =A0= He >>>>> will lost something. >>>> >>>> Instead of a warning, how about asking the user whether to discard the >>>> old records or keep them? >>> >>> My concern is, in most cases keeping them will be the wrong thing to do. >>> It will be very easy to create an internally inconsistent state, and >>> rather unlikely to create one that is *not* internally inconsistant. >>> >>> Think about it -- we will be concatenating two independent sets of >>> state changes, with no way of knowing that the actual machine state >>> at the end of one is the same as the machine state at the beginning >>> of the other. =A0When these are then replayed, their effect may have >>> little or nothing to do with what the real machine would actually do. >>> >>> To actually get this right, you would have to be *sure* that your >>> target machine is in the exact same state "now" (ie. when you do >>> the load command) as it was at the *beginning* of the previous >>> recording/debugging session. >>> >>> I would rather either make this a separate, "expert mode" >>> command, or better still, leave it for a future patch to extend >>> the basic (and safe) patch that we first accept. >>> >>> >>> >> > > Hi Michael, I make a new version patch. It 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. Thanks, Hui 2009-08-23 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_FILE_MAGIC): New macro. (record_core_buf_entry): New struct. (record_core_ops): New target_ops. (record_list_release_first_insn): Change function record_list_release_first to this name. (record_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, (record_read_dump, record_fd_cleanups, record_load, record_core_open_1, record_open_1): New function. (record_open): Add support for record_core_ops. (record_close): Add support for record_core_ops. (record_wait): Call function 'record_exec_entry' and add support for target core. (record_registers_change): Call record_list_release_first_insn. (record_core_resume, record_core_resume, record_core_kill, record_core_fetch_registers, record_core_prepare_to_store, record_core_store_registers, record_core_xfer_partial, record_core_insert_breakpoint, record_core_remove_breakpoint, record_core_has_execution, init_record_core_ops, cmd_record_load, record_write_dump, cmd_record_dump): New function. (cmd_record_stop): Add support for record_core_ops. (set_record_insn_max_num): Call record_list_release_first_insn. (_initialize_record): Add commands "record dump" and "record load". --- record.c | 970 ++++++++++++++++++++++++++++++++++++++++++++++++++++++----= ----- 1 file changed, 844 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,309 @@ 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, int core) +{ + 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 && !core) + || (execution_direction !=3D EXEC_REVERSE && core)) + { + 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 && !core) + || (execution_direction !=3D EXEC_REVERSE && 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 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 +756,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 +787,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 +956,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 +1084,10 @@ 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, + (ops =3D=3D &record_core_ops) ? 1 : 0); - 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 +1207,7 @@ record_kill (struct target_ops *ops) fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n"); unpush_target (&record_ops); + target_kill (); } @@ -945,7 +1252,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 +1365,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 +1445,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 +1645,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, 0); + + 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, 0); + + 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, 0); + + 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 +1883,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 +1906,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 +1946,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 +1955,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 +1966,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 +1984,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."), --00504502bfe940e2800471be6642 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_fyomqk4s0 Content-length: 53998 LS0tCiByZWNvcmQuYyB8ICA5NzAgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgODQ0IGluc2VydGlvbnMoKyksIDEyNiBkZWxldGlvbnMo 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 ICAgcmVjb3JkX2luc25fbnVtKys7CiAKQEAgLTQxNiwxMyArNDM4LDMwOSBA QCByZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlX3NldCAodm9pZCkKICAg cmV0dXJuIG9sZF9jbGVhbnVwczsKIH0KIAorc3RhdGljIGlubGluZSB2b2lk CityZWNvcmRfZXhlY19lbnRyeSAoc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNo ZSwgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsCisgICAgICAgICAgICAgICAg ICAgc3RydWN0IHJlY29yZF9lbnRyeSAqZW50cnksIGludCBjb3JlKQorewor ICBzd2l0Y2ggKGVudHJ5LT50eXBlKQorICAgIHsKKyAgICBjYXNlIHJlY29y ZF9yZWc6IC8qIHJlZyAqLworICAgICAgeworICAgICAgICBnZGJfYnl0ZSBy ZWdbTUFYX1JFR0lTVEVSX1NJWkVdOworCisgICAgICAgIGlmIChyZWNvcmRf ZGVidWcgPiAxKQorICAgICAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2Ri X3N0ZGxvZywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJQcm9j ZXNzIHJlY29yZDogcmVjb3JkX3JlZyAlcyB0byAiCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAiaW5mZXJpb3IgbnVtID0gJWQuXG4iLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaG9zdF9hZGRyZXNzX3RvX3N0 cmluZyAoZW50cnkpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ZW50cnktPnUucmVnLm51bSk7CisKKyAgICAgICAgcmVnY2FjaGVfY29va2Vk X3JlYWQgKHJlZ2NhY2hlLCBlbnRyeS0+dS5yZWcubnVtLCByZWcpOworICAg ICAgICByZWdjYWNoZV9jb29rZWRfd3JpdGUgKHJlZ2NhY2hlLCBlbnRyeS0+ dS5yZWcubnVtLCBlbnRyeS0+dS5yZWcudmFsKTsKKyAgICAgICAgbWVtY3B5 IChlbnRyeS0+dS5yZWcudmFsLCByZWcsIE1BWF9SRUdJU1RFUl9TSVpFKTsK KyAgICAgIH0KKyAgICAgIGJyZWFrOworCisgICAgY2FzZSByZWNvcmRfbWVt OiAvKiBtZW0gKi8KKyAgICAgIHsKKyAgICAgICAgaWYgKCFyZWNvcmRfbGlz dC0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxlKQorICAgICAgICAg IHsKKyAgICAgICAgICAgIGdkYl9ieXRlICptZW0gPSBhbGxvY2EgKGVudHJ5 LT51Lm1lbS5sZW4pOworCisgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVn ID4gMSkKKyAgICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJQ cm9jZXNzIHJlY29yZDogcmVjb3JkX21lbSAlcyB0byAiCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgImluZmVyaW9yIGFkZHIgPSAlcyBs ZW4gPSAlZC5cbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgaG9zdF9hZGRyZXNzX3RvX3N0cmluZyAoZW50cnkpLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBl bnRyeS0+dS5tZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisKKyAgICAgICAg ICAgIGlmICh0YXJnZXRfcmVhZF9tZW1vcnkgKGVudHJ5LT51Lm1lbS5hZGRy LCBtZW0sIGVudHJ5LT51Lm1lbS5sZW4pKQorICAgICAgICAgICAgICB7Cisg ICAgICAgICAgICAgICAgIGlmICgoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBF WEVDX1JFVkVSU0UgJiYgIWNvcmUpCisgICAgICAgICAgICAgICAgICAgICB8 fCAoZXhlY3V0aW9uX2RpcmVjdGlvbiAhPSBFWEVDX1JFVkVSU0UgJiYgY29y ZSkpCisgICAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAg IHJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUg PSAxOworICAgICAgICAgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQor ICAgICAgICAgICAgICAgICAgICAgIHdhcm5pbmcgKF8oIlByb2Nlc3MgcmVj b3JkOiBlcnJvciByZWFkaW5nIG1lbW9yeSBhdCAiCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJh cmNoLCBlbnRyeS0+dS5tZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZW50cnktPnUubWVtLmxlbik7CisgICAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAg ICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBlcnJvciByZWFkaW5nIG1l bW9yeSBhdCAiCisgICAgICAgICAgICAgICAgICAgICAgICAgICAiYWRkciA9 ICVzIGxlbiA9ICVkLiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgIHBh ZGRyZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciksCisgICAgICAg ICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKTsKKyAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICB7Cisg ICAgICAgICAgICAgICAgaWYgKHRhcmdldF93cml0ZV9tZW1vcnkgKGVudHJ5 LT51Lm1lbS5hZGRyLCBlbnRyeS0+dS5tZW0udmFsLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVu KSkKKyAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAg IGlmICgoZXhlY3V0aW9uX2RpcmVjdGlvbiA9PSBFWEVDX1JFVkVSU0UgJiYg IWNvcmUpCisgICAgICAgICAgICAgICAgICAgICAgICAgfHwgKGV4ZWN1dGlv bl9kaXJlY3Rpb24gIT0gRVhFQ19SRVZFUlNFICYmIGNvcmUpKQorICAgICAg ICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgIHJl Y29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUgPSAx OworICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZykK KyAgICAgICAgICAgICAgICAgICAgICAgICAgd2FybmluZyAoXygiUHJvY2Vz cyByZWNvcmQ6IGVycm9yIHdyaXRpbmcgbWVtb3J5IGF0ICIKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiYWRkciA9ICVzIGxlbiA9 ICVkLiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBw YWRkcmVzcyAoZ2RiYXJjaCwgZW50cnktPnUubWVtLmFkZHIpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVu KTsKKyAgICAgICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAg ICAgIGVsc2UKKyAgICAgICAgICAgICAgICAgICAgICBlcnJvciAoXygiUHJv Y2VzcyByZWNvcmQ6IGVycm9yIHdyaXRpbmcgbWVtb3J5IGF0ICIKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiYWRkciA9ICVzIGxlbiA9ICVk LiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwYWRkcmVzcyAo Z2RiYXJjaCwgZW50cnktPnUubWVtLmFkZHIpLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgIGVudHJ5LT51Lm1lbS5sZW4pOworICAgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgIG1lbWNw eSAoZW50cnktPnUubWVtLnZhbCwgbWVtLCBlbnRyeS0+dS5tZW0ubGVuKTsK KyAgICAgICAgICB9CisgICAgICB9CisgICAgICBicmVhazsKKyAgICB9Cit9 CisKK3N0YXRpYyBpbmxpbmUgdm9pZAorcmVjb3JkX3JlYWRfZHVtcCAoY2hh ciAqcmVjZmlsZW5hbWUsIGludCBmaWxkZXMsIHZvaWQgKmJ1Ziwgc2l6ZV90 IG5ieXRlKQoreworICBpZiAocmVhZCAoZmlsZGVzLCBidWYsIG5ieXRlKSAh PSBuYnl0ZSkKKyAgICBlcnJvciAoXygiRmFpbGVkIHRvIHJlYWQgZHVtcCBv ZiBleGVjdXRpb24gcmVjb3JkcyBpbiAnJXMnLiIpLAorICAgICAgICAgICBy ZWNmaWxlbmFtZSk7Cit9CisKIHN0YXRpYyB2b2lkCi1yZWNvcmRfb3BlbiAo Y2hhciAqbmFtZSwgaW50IGZyb21fdHR5KQorcmVjb3JkX2ZkX2NsZWFudXBz ICh2b2lkICpyZWNmZHApCiB7Ci0gIHN0cnVjdCB0YXJnZXRfb3BzICp0Owor ICBpbnQgcmVjZmQgPSAqKGludCAqKSByZWNmZHA7CisgIGNsb3NlIChyZWNm ZCk7Cit9CiAKLSAgaWYgKHJlY29yZF9kZWJ1ZykKLSAgICBmcHJpbnRmX3Vu ZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNzIHJlY29yZDogcmVjb3Jk X29wZW5cbiIpOworLyogTG9hZCB0aGUgZXhlY3V0aW9uIGxvZyBmcm9tIGEg ZmlsZS4gICovCisKK3N0YXRpYyB2b2lkCityZWNvcmRfbG9hZCAoY2hhciAq bmFtZSkKK3sKKyAgaW50IHJlY2ZkOworICB1aW50MzJfdCBtYWdpYzsKKyAg c3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwczsKKyAgc3RydWN0IGNsZWFu dXAgKm9sZF9jbGVhbnVwczI7CisgIHN0cnVjdCByZWNvcmRfZW50cnkgKnJl YzsKKyAgaW50IGluc25fbnVtYmVyID0gMDsKKworICBpZiAoIW5hbWUgfHwg KG5hbWUgJiYgISpuYW1lKSkKKyAgICByZXR1cm47CisKKyAgLyogT3BlbiB0 aGUgbG9hZCBmaWxlLiAgKi8KKyAgcmVjZmQgPSBvcGVuIChuYW1lLCBPX1JE T05MWSB8IE9fQklOQVJZKTsKKyAgaWYgKHJlY2ZkIDwgMCkKKyAgICBlcnJv ciAoXygiRmFpbGVkIHRvIG9wZW4gJyVzJyBmb3IgbG9hZGluZyBleGVjdXRp b24gcmVjb3JkczogJXMiKSwKKyAgICAgICAgICAgbmFtZSwgc3RyZXJyb3Ig KGVycm5vKSk7CisgIG9sZF9jbGVhbnVwcyA9IG1ha2VfY2xlYW51cCAocmVj b3JkX2ZkX2NsZWFudXBzLCAmcmVjZmQpOworCisgIC8qIENoZWNrIHRoZSBt YWdpYyBjb2RlLiAgKi8KKyAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwgcmVj ZmQsICZtYWdpYywgNCk7CisgIGlmIChtYWdpYyAhPSBSRUNPUkRfRklMRV9N QUdJQykKKyAgICBlcnJvciAoXygiJyVzJyBpcyBub3QgYSB2YWxpZCBkdW1w IG9mIGV4ZWN1dGlvbiByZWNvcmRzLiIpLCBuYW1lKTsKKworICAvKiBMb2Fk IHRoZSBlbnRyaWVzIGluIHJlY2ZkIHRvIHRoZSByZWNvcmRfYXJjaF9saXN0 X2hlYWQgYW5kCisgICAgIHJlY29yZF9hcmNoX2xpc3RfdGFpbC4gICovCisg IHJlY29yZF9hcmNoX2xpc3RfaGVhZCA9IE5VTEw7CisgIHJlY29yZF9hcmNo X2xpc3RfdGFpbCA9IE5VTEw7CisgIG9sZF9jbGVhbnVwczIgPSBtYWtlX2Ns ZWFudXAgKHJlY29yZF9hcmNoX2xpc3RfY2xlYW51cHMsIDApOworCisgIHdo aWxlICgxKQorICAgIHsKKyAgICAgIGludCByZXQ7CisgICAgICB1aW50OF90 IHRtcHU4OworICAgICAgdWludDY0X3QgdG1wdTY0OworCisgICAgICByZXQg PSByZWFkIChyZWNmZCwgJnRtcHU4LCAxKTsKKyAgICAgIGlmIChyZXQgPCAw KQorICAgICAgICBlcnJvciAoXygiRmFpbGVkIHRvIHJlYWQgZHVtcCBvZiBl eGVjdXRpb24gcmVjb3JkcyBpbiAnJXMnLiIpLCBuYW1lKTsKKyAgICAgIGlm IChyZXQgPT0gMCkKKyAgICAgICAgYnJlYWs7CisKKyAgICAgIHN3aXRjaCAo dG1wdTgpCisgICAgICAgIHsKKyAgICAgICAgY2FzZSByZWNvcmRfcmVnOiAv KiByZWcgKi8KKyAgICAgICAgICByZWMgPSAoc3RydWN0IHJlY29yZF9lbnRy eSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRfZW50cnkpKTsK KyAgICAgICAgICByZWMtPnUucmVnLnZhbCA9IChnZGJfYnl0ZSAqKSB4bWFs bG9jIChNQVhfUkVHSVNURVJfU0laRSk7CisgICAgICAgICAgcmVjLT5wcmV2 ID0gTlVMTDsKKyAgICAgICAgICByZWMtPm5leHQgPSBOVUxMOworICAgICAg ICAgIHJlYy0+dHlwZSA9IHJlY29yZF9yZWc7CisKKyAgICAgICAgICAvKiBH ZXQgbnVtLiAgKi8KKyAgICAgICAgICByZWNvcmRfcmVhZF9kdW1wIChuYW1l LCByZWNmZCwgJnRtcHU2NCwgOCk7CisgICAgICAgICAgaWYgKEJZVEVfT1JE RVIgPT0gTElUVExFX0VORElBTikKKyAgICAgICAgICAgIHRtcHU2NCA9IGJz d2FwXzY0ICh0bXB1NjQpOworICAgICAgICAgIHJlYy0+dS5yZWcubnVtID0g dG1wdTY0OworCisgICAgICAgICAgLyogR2V0IHZhbC4gICovCisgICAgICAg ICAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwgcmVjZmQsIHJlYy0+dS5yZWcu dmFsLCBNQVhfUkVHSVNURVJfU0laRSk7CisKKyAgICAgICAgICBpZiAocmVj b3JkX2RlYnVnKQorICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChn ZGJfc3RkbG9nLCBfKCJcCitSZWFkaW5nIHJlZ2lzdGVyICVkICgxIHBsdXMg OCBwbHVzICVkIGJ5dGVzKVxuIiksCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHJlYy0+dS5yZWcubnVtLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBNQVhfUkVHSVNURVJfU0laRSk7CisKKyAgICAgICAg ICByZWNvcmRfYXJjaF9saXN0X2FkZCAocmVjKTsKKyAgICAgICAgICBicmVh azsKKworICAgICAgICBjYXNlIHJlY29yZF9tZW06IC8qIG1lbSAqLworICAg ICAgICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2Mg KHNpemVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkpOworICAgICAgICAgIHJl Yy0+cHJldiA9IE5VTEw7CisgICAgICAgICAgcmVjLT5uZXh0ID0gTlVMTDsK KyAgICAgICAgICByZWMtPnR5cGUgPSByZWNvcmRfbWVtOworCisgICAgICAg ICAgLyogR2V0IGFkZHIuICAqLworICAgICAgICAgIHJlY29yZF9yZWFkX2R1 bXAgKG5hbWUsIHJlY2ZkLCAmdG1wdTY0LCA4KTsKKyAgICAgICAgICBpZiAo QllURV9PUkRFUiA9PSBMSVRUTEVfRU5ESUFOKQorICAgICAgICAgICAgdG1w dTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisgICAgICAgICAgcmVjLT51Lm1l bS5hZGRyID0gdG1wdTY0OworCisgICAgICAgICAgLyogR2V0IGxlbi4gICov CisgICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwgcmVjZmQsICZ0 bXB1NjQsIDgpOworICAgICAgICAgIGlmIChCWVRFX09SREVSID09IExJVFRM RV9FTkRJQU4pCisgICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1w dTY0KTsKKyAgICAgICAgICByZWMtPnUubWVtLmxlbiA9IHRtcHU2NDsKKyAg ICAgICAgICByZWMtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9 IDA7CisgICAgICAgICAgcmVjLT51Lm1lbS52YWwgPSAoZ2RiX2J5dGUgKikg eG1hbGxvYyAocmVjLT51Lm1lbS5sZW4pOworCisgICAgICAgICAgLyogR2V0 IHZhbC4gICovCisgICAgICAgICAgcmVjb3JkX3JlYWRfZHVtcCAobmFtZSwg cmVjZmQsIHJlYy0+dS5tZW0udmFsLCByZWMtPnUubWVtLmxlbik7CisKKyAg ICAgICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgZnByaW50 Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCBfKCJcCitSZWFkaW5nIG1lbW9y eSAlcyAoMSBwbHVzIDggcGx1cyA4IGJ5dGVzIHBsdXMgJWQgYnl0ZXMpXG4i KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBw YWRkcmVzcyAoZ2V0X2N1cnJlbnRfYXJjaCAoKSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjLT51Lm1l bS5hZGRyKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICByZWMtPnUubWVtLmxlbik7CisKKyAgICAgICAgICByZWNvcmRfYXJj aF9saXN0X2FkZCAocmVjKTsKKyAgICAgICAgICBicmVhazsKKworICAgICAg ICBjYXNlIHJlY29yZF9lbmQ6IC8qIGVuZCAqLworICAgICAgICAgIGlmIChy ZWNvcmRfZGVidWcpCisgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQg KGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IF8oIlJlYWRpbmcgcmVjb3JkX2VuZCAoMSBieXRlKVxuIikpOworCisgICAg ICAgICAgcmVjID0gKHN0cnVjdCByZWNvcmRfZW50cnkgKikgeG1hbGxvYyAo c2l6ZW9mIChzdHJ1Y3QgcmVjb3JkX2VudHJ5KSk7CisgICAgICAgICAgcmVj LT5wcmV2ID0gTlVMTDsKKyAgICAgICAgICByZWMtPm5leHQgPSBOVUxMOwor ICAgICAgICAgIHJlYy0+dHlwZSA9IHJlY29yZF9lbmQ7CisgICAgICAgICAg cmVjb3JkX2FyY2hfbGlzdF9hZGQgKHJlYyk7CisgICAgICAgICAgaW5zbl9u dW1iZXIgKys7CisgICAgICAgICAgYnJlYWs7CisKKyAgICAgICAgZGVmYXVs dDoKKyAgICAgICAgICBlcnJvciAoXygiRm9ybWF0IG9mICclcycgaXMgbm90 IHJpZ2h0LiIpLCBuYW1lKTsKKyAgICAgICAgICBicmVhazsKKyAgICAgICAg fQorICAgIH0KKworICBkaXNjYXJkX2NsZWFudXBzIChvbGRfY2xlYW51cHMy KTsKKworICAvKiBBZGQgcmVjb3JkX2FyY2hfbGlzdF9oZWFkIHRvIHRoZSBl bmQgb2YgcmVjb3JkIGxpc3QuICAqLworICBmb3IgKHJlYyA9IHJlY29yZF9s aXN0OyByZWMtPm5leHQ7IHJlYyA9IHJlYy0+bmV4dCk7CisgIHJlYy0+bmV4 dCA9IHJlY29yZF9hcmNoX2xpc3RfaGVhZDsKKyAgcmVjb3JkX2FyY2hfbGlz dF9oZWFkLT5wcmV2ID0gcmVjOworCisgIC8qIFVwZGF0ZSByZWNvcmRfaW5z bl9udW0gYW5kIHJlY29yZF9pbnNuX21heF9udW0uICAqLworICByZWNvcmRf aW5zbl9udW0gKz0gaW5zbl9udW1iZXI7CisgIGlmIChyZWNvcmRfaW5zbl9u dW0gPiByZWNvcmRfaW5zbl9tYXhfbnVtKQorICAgIHsKKyAgICAgIHJlY29y ZF9pbnNuX21heF9udW0gPSByZWNvcmRfaW5zbl9udW07CisgICAgICB3YXJu aW5nIChfKCJBdXRvIGluY3JlYXNlIHJlY29yZC9yZXBsYXkgYnVmZmVyIGxp bWl0IHRvICVkLiIpLAorICAgICAgICAgICAgICAgcmVjb3JkX2luc25fbWF4 X251bSk7CisgICAgfQorCisgIGRvX2NsZWFudXBzIChvbGRfY2xlYW51cHMp OworCisgIC8qIFN1Y2NlZWRlZC4gICovCisgIGZwcmludGZfZmlsdGVyZWQg KGdkYl9zdGRvdXQsICJMb2FkZWQgcmVjZmlsZSAlcy5cbiIsIG5hbWUpOwor fQorCitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnRtcF90b19yZXN1bWVf b3BzOworc3RhdGljIHZvaWQgKCp0bXBfdG9fcmVzdW1lKSAoc3RydWN0IHRh cmdldF9vcHMgKiwgcHRpZF90LCBpbnQsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBlbnVtIHRhcmdldF9zaWduYWwpOworc3RhdGljIHN0cnVj dCB0YXJnZXRfb3BzICp0bXBfdG9fd2FpdF9vcHM7CitzdGF0aWMgcHRpZF90 ICgqdG1wX3RvX3dhaXQpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqLCBwdGlkX3Qs CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgdGFyZ2V0 X3dhaXRzdGF0dXMgKiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGludCk7CitzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnRtcF90b19zdG9y ZV9yZWdpc3RlcnNfb3BzOworc3RhdGljIHZvaWQgKCp0bXBfdG9fc3RvcmVf cmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMgKiwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCByZWdjYWNoZSAq LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50 IHJlZ25vKTsKK3N0YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyAqdG1wX3RvX3hm ZXJfcGFydGlhbF9vcHM7CitzdGF0aWMgTE9OR0VTVCAoKnRtcF90b194ZmVy X3BhcnRpYWwpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZW51bSB0YXJnZXRfb2Jq ZWN0IG9iamVjdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGNvbnN0IGNoYXIgKmFubmV4LAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZ2RiX2J5dGUgKnJlYWRidWYsCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBnZGJf Ynl0ZSAqd3JpdGVidWYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBVTE9OR0VTVCBvZmZzZXQsCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBMT05HRVNUIGxlbik7CitzdGF0aWMg aW50ICgqdG1wX3RvX2luc2VydF9icmVha3BvaW50KSAoc3RydWN0IGdkYmFy Y2ggKiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKik7CitzdGF0aWMgaW50ICgqdG1w X3RvX3JlbW92ZV9icmVha3BvaW50KSAoc3RydWN0IGdkYmFyY2ggKiwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qg YnBfdGFyZ2V0X2luZm8gKik7CisKK3N0YXRpYyB2b2lkCityZWNvcmRfY29y ZV9vcGVuXzEgKGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKK3sKKyAgc3Ry dWN0IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2NhY2hl ICgpOworICBpbnQgcmVnbnVtID0gZ2RiYXJjaF9udW1fcmVncyAoZ2V0X3Jl Z2NhY2hlX2FyY2ggKHJlZ2NhY2hlKSk7CisgIGludCBpOworCisgIGlmICgh bmFtZSB8fCAobmFtZSAmJiAhKm5hbWUpKQorICAgIGVycm9yIChfKCJBcmd1 bWVudCBmb3IgZ2RiIHJlY29yZCBmaWxlbmFtZSByZXF1aXJlZC5cbiIpKTsK KworICAvKiBHZXQgcmVjb3JkX2NvcmVfcmVnYnVmLiAgKi8KKyAgdGFyZ2V0 X2ZldGNoX3JlZ2lzdGVycyAocmVnY2FjaGUsIC0xKTsKKyAgcmVjb3JkX2Nv cmVfcmVnYnVmID0geG1hbGxvYyAoTUFYX1JFR0lTVEVSX1NJWkUgKiByZWdu dW0pOworICBmb3IgKGkgPSAwOyBpIDwgcmVnbnVtOyBpICsrKQorICAgIHJl Z2NhY2hlX3Jhd19jb2xsZWN0IChyZWdjYWNoZSwgaSwKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JFR0lT VEVSX1NJWkUgKiBpKTsKKworICAvKiBHZXQgcmVjb3JkX2NvcmVfc3RhcnQg YW5kIHJlY29yZF9jb3JlX2VuZC4gICovCisgIGlmIChidWlsZF9zZWN0aW9u X3RhYmxlIChjb3JlX2JmZCwgJnJlY29yZF9jb3JlX3N0YXJ0LCAmcmVjb3Jk X2NvcmVfZW5kKSkKKyAgICB7CisgICAgICB4ZnJlZSAocmVjb3JkX2NvcmVf cmVnYnVmKTsKKyAgICAgIHJlY29yZF9jb3JlX3JlZ2J1ZiA9IE5VTEw7Cisg ICAgICBlcnJvciAoXygiXCIlc1wiOiBDYW4ndCBmaW5kIHNlY3Rpb25zOiAl cyIpLAorICAgICAgICAgICAgIGJmZF9nZXRfZmlsZW5hbWUgKGNvcmVfYmZk KSwgYmZkX2Vycm1zZyAoYmZkX2dldF9lcnJvciAoKSkpOworICAgIH0KKwor ICBwdXNoX3RhcmdldCAoJnJlY29yZF9jb3JlX29wcyk7Cit9CisKK3N0YXRp YyB2b2lkCityZWNvcmRfb3Blbl8xIChjaGFyICpuYW1lLCBpbnQgZnJvbV90 dHkpCit7CisgIHN0cnVjdCB0YXJnZXRfb3BzICp0OwogCiAgIC8qIGNoZWNr IGV4ZWMgKi8KICAgaWYgKCF0YXJnZXRfaGFzX2V4ZWN1dGlvbikKQEAgLTQz OCw2ICs3NTYsMjggQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUsIGludCBm cm9tX3R0eSkKICAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IHRoZSBj dXJyZW50IGFyY2hpdGVjdHVyZSBkb2Vzbid0IHN1cHBvcnQgIgogCSAgICAg InJlY29yZCBmdW5jdGlvbi4iKSk7CiAKKyAgaWYgKCF0bXBfdG9fcmVzdW1l KQorICAgIGVycm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9f cmVzdW1lLiIpKTsKKyAgaWYgKCF0bXBfdG9fd2FpdCkKKyAgICBlcnJvciAo XygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3dhaXQuIikpOworICBp ZiAoIXRtcF90b19zdG9yZV9yZWdpc3RlcnMpCisgICAgZXJyb3IgKF8oIlBy b2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19zdG9yZV9yZWdpc3RlcnMuIikp OworICBpZiAoIXRtcF90b19pbnNlcnRfYnJlYWtwb2ludCkKKyAgICBlcnJv ciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2luc2VydF9icmVh a3BvaW50LiIpKTsKKyAgaWYgKCF0bXBfdG9fcmVtb3ZlX2JyZWFrcG9pbnQp CisgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19y ZW1vdmVfYnJlYWtwb2ludC4iKSk7CisKKyAgcHVzaF90YXJnZXQgKCZyZWNv cmRfb3BzKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9vcGVuIChjaGFy ICpuYW1lLCBpbnQgZnJvbV90dHkpCit7CisgIHN0cnVjdCB0YXJnZXRfb3Bz ICp0OworCisgIGlmIChyZWNvcmRfZGVidWcpCisgICAgZnByaW50Zl91bmZp bHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9v cGVuXG4iKTsKKwogICAvKiBDaGVjayBpZiByZWNvcmQgdGFyZ2V0IGlzIGFs cmVhZHkgcnVubmluZy4gICovCiAgIGlmIChjdXJyZW50X3RhcmdldC50b19z dHJhdHVtID09IHJlY29yZF9zdHJhdHVtKQogICAgIHsKQEAgLTQ0Nyw3MCAr Nzg3LDEwMiBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFtZSwgaW50IGZyb21f dHR5KQogCXJldHVybjsKICAgICB9CiAKLSAgLypSZXNldCB0aGUgYmVuZWF0 aCBmdW5jdGlvbiBwb2ludGVycy4gICovCi0gIHJlY29yZF9iZW5lYXRoX3Rv X3Jlc3VtZSA9IE5VTEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3dhaXQgPSBO VUxMOwotICByZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMgPSBO VUxMOwotICByZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwgPSBOVUxM OwotICByZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJlYWtwb2ludCA9IE5V TEw7Ci0gIHJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50ID0g TlVMTDsKKyAgLyogUmVzZXQgdGhlIHRtcCBiZW5lYXRoIHBvaW50ZXJzLiAg Ki8KKyAgdG1wX3RvX3Jlc3VtZV9vcHMgPSBOVUxMOworICB0bXBfdG9fcmVz dW1lID0gTlVMTDsKKyAgdG1wX3RvX3dhaXRfb3BzID0gTlVMTDsKKyAgdG1w X3RvX3dhaXQgPSBOVUxMOworICB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJzX29w cyA9IE5VTEw7CisgIHRtcF90b19zdG9yZV9yZWdpc3RlcnMgPSBOVUxMOwor ICB0bXBfdG9feGZlcl9wYXJ0aWFsX29wcyA9IE5VTEw7CisgIHRtcF90b194 ZmVyX3BhcnRpYWwgPSBOVUxMOworICB0bXBfdG9faW5zZXJ0X2JyZWFrcG9p bnQgPSBOVUxMOworICB0bXBfdG9fcmVtb3ZlX2JyZWFrcG9pbnQgPSBOVUxM OwogCiAgIC8qIFNldCB0aGUgYmVuZWF0aCBmdW5jdGlvbiBwb2ludGVycy4g ICovCiAgIGZvciAodCA9IGN1cnJlbnRfdGFyZ2V0LmJlbmVhdGg7IHQgIT0g TlVMTDsgdCA9IHQtPmJlbmVhdGgpCiAgICAgewotICAgICAgaWYgKCFyZWNv cmRfYmVuZWF0aF90b19yZXN1bWUpCisgICAgICBpZiAoIXRtcF90b19yZXN1 bWUpCiAgICAgICAgIHsKLQkgIHJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSA9 IHQtPnRvX3Jlc3VtZTsKLQkgIHJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZV9v cHMgPSB0OworCSAgdG1wX3RvX3Jlc3VtZSA9IHQtPnRvX3Jlc3VtZTsKKwkg IHRtcF90b19yZXN1bWVfb3BzID0gdDsKICAgICAgICAgfQotICAgICAgaWYg KCFyZWNvcmRfYmVuZWF0aF90b193YWl0KQorICAgICAgaWYgKCF0bXBfdG9f d2FpdCkKICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVhdGhfdG9fd2FpdCA9 IHQtPnRvX3dhaXQ7Ci0JICByZWNvcmRfYmVuZWF0aF90b193YWl0X29wcyA9 IHQ7CisJICB0bXBfdG9fd2FpdCA9IHQtPnRvX3dhaXQ7CisJICB0bXBfdG9f d2FpdF9vcHMgPSB0OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29yZF9i ZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycykKKyAgICAgIGlmICghdG1wX3Rv X3N0b3JlX3JlZ2lzdGVycykKICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVh dGhfdG9fc3RvcmVfcmVnaXN0ZXJzID0gdC0+dG9fc3RvcmVfcmVnaXN0ZXJz OwotCSAgcmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzX29wcyA9 IHQ7CisJICB0bXBfdG9fc3RvcmVfcmVnaXN0ZXJzID0gdC0+dG9fc3RvcmVf cmVnaXN0ZXJzOworCSAgdG1wX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHMgPSB0 OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3hm ZXJfcGFydGlhbCkKKyAgICAgIGlmICghdG1wX3RvX3hmZXJfcGFydGlhbCkK ICAgICAgICAgewotCSAgcmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFs ID0gdC0+dG9feGZlcl9wYXJ0aWFsOwotCSAgcmVjb3JkX2JlbmVhdGhfdG9f eGZlcl9wYXJ0aWFsX29wcyA9IHQ7CisJICB0bXBfdG9feGZlcl9wYXJ0aWFs ID0gdC0+dG9feGZlcl9wYXJ0aWFsOworCSAgdG1wX3RvX3hmZXJfcGFydGlh bF9vcHMgPSB0OwogICAgICAgICB9Ci0gICAgICBpZiAoIXJlY29yZF9iZW5l YXRoX3RvX2luc2VydF9icmVha3BvaW50KQotCXJlY29yZF9iZW5lYXRoX3Rv X2luc2VydF9icmVha3BvaW50ID0gdC0+dG9faW5zZXJ0X2JyZWFrcG9pbnQ7 Ci0gICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3Bv aW50KQotCXJlY29yZF9iZW5lYXRoX3RvX3JlbW92ZV9icmVha3BvaW50ID0g dC0+dG9fcmVtb3ZlX2JyZWFrcG9pbnQ7CisgICAgICBpZiAoIXRtcF90b19p bnNlcnRfYnJlYWtwb2ludCkKKwl0bXBfdG9faW5zZXJ0X2JyZWFrcG9pbnQg PSB0LT50b19pbnNlcnRfYnJlYWtwb2ludDsKKyAgICAgIGlmICghdG1wX3Rv X3JlbW92ZV9icmVha3BvaW50KQorCXRtcF90b19yZW1vdmVfYnJlYWtwb2lu dCA9IHQtPnRvX3JlbW92ZV9icmVha3BvaW50OwogICAgIH0KLSAgaWYgKCFy ZWNvcmRfYmVuZWF0aF90b19yZXN1bWUpCi0gICAgZXJyb3IgKF8oIlByb2Nl c3MgcmVjb3JkIGNhbid0IGdldCB0b19yZXN1bWUuIikpOwotICBpZiAoIXJl Y29yZF9iZW5lYXRoX3RvX3dhaXQpCi0gICAgZXJyb3IgKF8oIlByb2Nlc3Mg cmVjb3JkIGNhbid0IGdldCB0b193YWl0LiIpKTsKLSAgaWYgKCFyZWNvcmRf YmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMpCi0gICAgZXJyb3IgKF8oIlBy b2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19zdG9yZV9yZWdpc3RlcnMuIikp OwotICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCkKKyAg aWYgKCF0bXBfdG9feGZlcl9wYXJ0aWFsKQogICAgIGVycm9yIChfKCJQcm9j ZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9feGZlcl9wYXJ0aWFsLiIpKTsKLSAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJlYWtwb2ludCkKLSAg ICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2luc2Vy dF9icmVha3BvaW50LiIpKTsKLSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19y ZW1vdmVfYnJlYWtwb2ludCkKLSAgICBlcnJvciAoXygiUHJvY2VzcyByZWNv cmQgY2FuJ3QgZ2V0IHRvX3JlbW92ZV9icmVha3BvaW50LiIpKTsKIAotICBw dXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOworICBpZiAoY3VycmVudF90YXJn ZXQudG9fc3RyYXR1bSA9PSBjb3JlX3N0cmF0dW0pCisgICAgcmVjb3JkX2Nv cmVfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CisgIGVsc2UKKyAgICByZWNv cmRfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CiAKICAgLyogUmVzZXQgKi8K ICAgcmVjb3JkX2luc25fbnVtID0gMDsKICAgcmVjb3JkX2xpc3QgPSAmcmVj b3JkX2ZpcnN0OwogICByZWNvcmRfbGlzdC0+bmV4dCA9IE5VTEw7CisKKyAg LyogU2V0IHRoZSB0bXAgYmVuZWF0aCBwb2ludGVycyB0byBiZW5lYXRoIHBv aW50ZXJzLiAgKi8KKyAgcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1lX29wcyA9 IHRtcF90b19yZXN1bWVfb3BzOworICByZWNvcmRfYmVuZWF0aF90b19yZXN1 bWUgPSB0bXBfdG9fcmVzdW1lOworICByZWNvcmRfYmVuZWF0aF90b193YWl0 X29wcyA9IHRtcF90b193YWl0X29wczsKKyAgcmVjb3JkX2JlbmVhdGhfdG9f d2FpdCA9IHRtcF90b193YWl0OworICByZWNvcmRfYmVuZWF0aF90b19zdG9y ZV9yZWdpc3RlcnNfb3BzID0gdG1wX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHM7 CisgIHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVycyA9IHRtcF90 b19zdG9yZV9yZWdpc3RlcnM7CisgIHJlY29yZF9iZW5lYXRoX3RvX3hmZXJf cGFydGlhbF9vcHMgPSB0bXBfdG9feGZlcl9wYXJ0aWFsX29wczsKKyAgcmVj b3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsID0gdG1wX3RvX3hmZXJfcGFy dGlhbDsKKyAgcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0X2JyZWFrcG9pbnQg PSB0bXBfdG9faW5zZXJ0X2JyZWFrcG9pbnQ7CisgIHJlY29yZF9iZW5lYXRo X3RvX3JlbW92ZV9icmVha3BvaW50ID0gdG1wX3RvX3JlbW92ZV9icmVha3Bv aW50OworCisgIC8qIExvYWQgaWYgdGhlcmUgaXMgYXJndW1lbnQuICAqLwor ICByZWNvcmRfbG9hZCAobmFtZSk7CiB9CiAKIHN0YXRpYyB2b2lkCiByZWNv cmRfY2xvc2UgKGludCBxdWl0dGluZykKIHsKKyAgc3RydWN0IHJlY29yZF9j b3JlX2J1Zl9lbnRyeSAqZW50cnk7CisKICAgaWYgKHJlY29yZF9kZWJ1ZykK ICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csICJQcm9jZXNz IHJlY29yZDogcmVjb3JkX2Nsb3NlXG4iKTsKIAogICByZWNvcmRfbGlzdF9y ZWxlYXNlIChyZWNvcmRfbGlzdCk7CisKKyAgLyogUmVsZWFzZSByZWNvcmRf Y29yZV9yZWdidWYuICAqLworICBpZiAocmVjb3JkX2NvcmVfcmVnYnVmKQor ICAgIHsKKyAgICAgIHhmcmVlIChyZWNvcmRfY29yZV9yZWdidWYpOworICAg ICAgcmVjb3JkX2NvcmVfcmVnYnVmID0gTlVMTDsKKyAgICB9CisKKyAgLyog UmVsZWFzZSByZWNvcmRfY29yZV9idWZfbGlzdC4gICovCisgIGlmIChyZWNv cmRfY29yZV9idWZfbGlzdCkKKyAgICB7CisgICAgICBmb3IgKGVudHJ5ID0g cmVjb3JkX2NvcmVfYnVmX2xpc3QtPnByZXY7IGVudHJ5OyBlbnRyeSA9IGVu dHJ5LT5wcmV2KQorICAgICAgICB7CisgICAgICAgICAgeGZyZWUgKHJlY29y ZF9jb3JlX2J1Zl9saXN0KTsKKyAgICAgICAgICByZWNvcmRfY29yZV9idWZf bGlzdCA9IGVudHJ5OworICAgICAgICB9CisgICAgICByZWNvcmRfY29yZV9i dWZfbGlzdCA9IE5VTEw7CisgICAgfQogfQogCiBzdGF0aWMgaW50IHJlY29y ZF9yZXN1bWVfc3RlcCA9IDA7CkBAIC01ODQsNyArOTU2LDcgQEAgcmVjb3Jk X3dhaXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCiAJCQkicmVjb3JkX3Jl c3VtZV9zdGVwID0gJWRcbiIsCiAJCQlyZWNvcmRfcmVzdW1lX3N0ZXApOwog Ci0gIGlmICghUkVDT1JEX0lTX1JFUExBWSkKKyAgaWYgKCFSRUNPUkRfSVNf UkVQTEFZICYmIG9wcyAhPSAmcmVjb3JkX2NvcmVfb3BzKQogICAgIHsKICAg ICAgIGlmIChyZWNvcmRfcmVzdW1lX2Vycm9yKQogCXsKQEAgLTcxMiw3NiAr MTA4NCwxMCBAQCByZWNvcmRfd2FpdCAoc3RydWN0IHRhcmdldF9vcHMgKm9w cywKIAkgICAgICBicmVhazsKIAkgICAgfQogCi0JICAvKiBTZXQgcHRpZCwg cmVnaXN0ZXIgYW5kIG1lbW9yeSBhY2NvcmRpbmcgdG8gcmVjb3JkX2xpc3Qu ICAqLwotCSAgaWYgKHJlY29yZF9saXN0LT50eXBlID09IHJlY29yZF9yZWcp Ci0JICAgIHsKLQkgICAgICAvKiByZWcgKi8KLQkgICAgICBnZGJfYnl0ZSBy ZWdbTUFYX1JFR0lTVEVSX1NJWkVdOwotCSAgICAgIGlmIChyZWNvcmRfZGVi dWcgPiAxKQotCQlmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCi0J CQkJICAgICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX3JlZyAlcyB0byAiCi0J CQkJICAgICJpbmZlcmlvciBudW0gPSAlZC5cbiIsCi0JCQkJICAgIGhvc3Rf YWRkcmVzc190b19zdHJpbmcgKHJlY29yZF9saXN0KSwKLQkJCQkgICAgcmVj b3JkX2xpc3QtPnUucmVnLm51bSk7Ci0JICAgICAgcmVnY2FjaGVfY29va2Vk X3JlYWQgKHJlZ2NhY2hlLCByZWNvcmRfbGlzdC0+dS5yZWcubnVtLCByZWcp OwotCSAgICAgIHJlZ2NhY2hlX2Nvb2tlZF93cml0ZSAocmVnY2FjaGUsIHJl Y29yZF9saXN0LT51LnJlZy5udW0sCi0JCQkJICAgICByZWNvcmRfbGlzdC0+ dS5yZWcudmFsKTsKLQkgICAgICBtZW1jcHkgKHJlY29yZF9saXN0LT51LnJl Zy52YWwsIHJlZywgTUFYX1JFR0lTVEVSX1NJWkUpOwotCSAgICB9Ci0JICBl bHNlIGlmIChyZWNvcmRfbGlzdC0+dHlwZSA9PSByZWNvcmRfbWVtKQotCSAg ICB7Ci0JICAgICAgLyogbWVtICovCi0JICAgICAgLyogTm90aGluZyB0byBk byBpZiB0aGUgZW50cnkgaXMgZmxhZ2dlZCBub3RfYWNjZXNzaWJsZS4gICov Ci0JICAgICAgaWYgKCFyZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25v dF9hY2Nlc3NpYmxlKQotCQl7Ci0JCSAgZ2RiX2J5dGUgKm1lbSA9IGFsbG9j YSAocmVjb3JkX2xpc3QtPnUubWVtLmxlbik7Ci0JCSAgaWYgKHJlY29yZF9k ZWJ1ZyA+IDEpCi0JCSAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRs b2csCi0JCQkJICAgICAgICAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9tZW0g JXMgdG8gIgotCQkJCSAgICAgICAgImluZmVyaW9yIGFkZHIgPSAlcyBsZW4g PSAlZC5cbiIsCi0JCQkJICAgICAgICBob3N0X2FkZHJlc3NfdG9fc3RyaW5n IChyZWNvcmRfbGlzdCksCi0JCQkJICAgICAgICBwYWRkcmVzcyAoZ2RiYXJj aCwKLQkJCQkJICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5hZGRyKSwK LQkJCQkgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5sZW4pOworICAgICAg ICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVj b3JkX2xpc3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChvcHMg PT0gJnJlY29yZF9jb3JlX29wcykgPyAxIDogMCk7CiAKLQkJICBpZiAodGFy Z2V0X3JlYWRfbWVtb3J5IChyZWNvcmRfbGlzdC0+dS5tZW0uYWRkciwgbWVt LAotCQkgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51 Lm1lbS5sZW4pKQotCSAgICAgICAgICAgIHsKLQkJICAgICAgaWYgKGV4ZWN1 dGlvbl9kaXJlY3Rpb24gIT0gRVhFQ19SRVZFUlNFKQotCQkgICAgICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZDogZXJyb3IgcmVhZGluZyBtZW1vcnkg YXQgIgotCQkJICAgICAgICAgImFkZHIgPSAlcyBsZW4gPSAlZC4iKSwKLQkJ ICAgICAgICAgICAgICAgcGFkZHJlc3MgKGdkYmFyY2gsIHJlY29yZF9saXN0 LT51Lm1lbS5hZGRyKSwKLQkJICAgICAgICAgICAgICAgcmVjb3JkX2xpc3Qt PnUubWVtLmxlbik7Ci0JCSAgICAgIGVsc2UKLQkJCS8qIFJlYWQgZmFpbGVk IC0tIAotCQkJICAgZmxhZyBlbnRyeSBhcyBub3RfYWNjZXNzaWJsZS4gICov Ci0JCSAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3Rf YWNjZXNzaWJsZSA9IDE7Ci0JCSAgICB9Ci0JCSAgZWxzZQotCQkgICAgewot CQkgICAgICBpZiAodGFyZ2V0X3dyaXRlX21lbW9yeSAocmVjb3JkX2xpc3Qt PnUubWVtLmFkZHIsCi0JCQkgICAgICAgICAgICAgICAgICAgICAgIHJlY29y ZF9saXN0LT51Lm1lbS52YWwsCi0JCSAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKSkKLQkgICAgICAgICAg ICAgICAgewotCQkJICBpZiAoZXhlY3V0aW9uX2RpcmVjdGlvbiAhPSBFWEVD X1JFVkVSU0UpCi0JCQkgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBl cnJvciB3cml0aW5nIG1lbW9yeSBhdCAiCi0JCQkgICAgICAgICAgICAgImFk ZHIgPSAlcyBsZW4gPSAlZC4iKSwKLQkJICAgICAgICAgICAgICAgICAgIHBh ZGRyZXNzIChnZGJhcmNoLCByZWNvcmRfbGlzdC0+dS5tZW0uYWRkciksCi0J CSAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsK LQkJCSAgZWxzZQotCQkJICAgIC8qIFdyaXRlIGZhaWxlZCAtLSAKLQkJCSAg ICAgICBmbGFnIGVudHJ5IGFzIG5vdF9hY2Nlc3NpYmxlLiAgKi8KLQkJCSAg ICByZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25vdF9hY2Nlc3NpYmxl ID0gMTsKLQkJCX0KLQkJICAgICAgZWxzZQotCQkgICAgICAgIHsKLQkJCSAg bWVtY3B5IChyZWNvcmRfbGlzdC0+dS5tZW0udmFsLCBtZW0sCi0JCQkJICBy ZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKLQkJCX0KLQkJICAgIH0KLQkJfQot CSAgICB9Ci0JICBlbHNlCisJICBpZiAocmVjb3JkX2xpc3QtPnR5cGUgPT0g cmVjb3JkX2VuZCkKIAkgICAgewogCSAgICAgIGlmIChyZWNvcmRfZGVidWcg PiAxKQogCQlmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCkBAIC05 MDEsNiArMTIwNyw3IEBAIHJlY29yZF9raWxsIChzdHJ1Y3QgdGFyZ2V0X29w cyAqb3BzKQogICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywg IlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfa2lsbFxuIik7CiAKICAgdW5wdXNo X3RhcmdldCAoJnJlY29yZF9vcHMpOworCiAgIHRhcmdldF9raWxsICgpOwog fQogCkBAIC05NDUsNyArMTI1Miw3IEBAIHJlY29yZF9yZWdpc3RlcnNfY2hh bmdlIChzdHJ1Y3QgcmVnY2FjaGUKICAgcmVjb3JkX2xpc3QgPSByZWNvcmRf YXJjaF9saXN0X3RhaWw7CiAKICAgaWYgKHJlY29yZF9pbnNuX251bSA9PSBy ZWNvcmRfaW5zbl9tYXhfbnVtICYmIHJlY29yZF9pbnNuX21heF9udW0pCi0g ICAgcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdCAoKTsKKyAgICByZWNvcmRf bGlzdF9yZWxlYXNlX2ZpcnN0X2luc24gKCk7CiAgIGVsc2UKICAgICByZWNv cmRfaW5zbl9udW0rKzsKIH0KQEAgLTEwNTgsNyArMTM2NSw3IEBAIHJlY29y ZF94ZmVyX3BhcnRpYWwgKHN0cnVjdCB0YXJnZXRfb3BzICoKICAgICAgIHJl Y29yZF9saXN0ID0gcmVjb3JkX2FyY2hfbGlzdF90YWlsOwogCiAgICAgICBp ZiAocmVjb3JkX2luc25fbnVtID09IHJlY29yZF9pbnNuX21heF9udW0gJiYg cmVjb3JkX2luc25fbWF4X251bSkKLQlyZWNvcmRfbGlzdF9yZWxlYXNlX2Zp cnN0ICgpOworCXJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsK ICAgICAgIGVsc2UKIAlyZWNvcmRfaW5zbl9udW0rKzsKICAgICB9CkBAIC0x MTM4LDYgKzE0NDUsMTkxIEBAIGluaXRfcmVjb3JkX29wcyAodm9pZCkKIH0K IAogc3RhdGljIHZvaWQKK3JlY29yZF9jb3JlX3Jlc3VtZSAoc3RydWN0IHRh cmdldF9vcHMgKm9wcywgcHRpZF90IHB0aWQsIGludCBzdGVwLAorICAgICAg ICAgICAgICAgICAgICBlbnVtIHRhcmdldF9zaWduYWwgc2lnZ25hbCkKK3sK KyAgcmVjb3JkX3Jlc3VtZV9zdGVwID0gc3RlcDsKKyAgcmVjb3JkX3Jlc3Vt ZV9zaWdnbmFsID0gc2lnZ25hbDsKK30KKworc3RhdGljIHZvaWQKK3JlY29y ZF9jb3JlX2tpbGwgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMpCit7CisgIGlm IChyZWNvcmRfZGVidWcpCisgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9jb3JlX2tpbGxcbiIp OworCisgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfY29yZV9vcHMpOworfQor CitzdGF0aWMgdm9pZAorcmVjb3JkX2NvcmVfZmV0Y2hfcmVnaXN0ZXJzIChz dHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBpbnQgcmVnbm8pCit7CisgIGlmIChyZWdu byA8IDApCisgICAgeworICAgICAgaW50IG51bSA9IGdkYmFyY2hfbnVtX3Jl Z3MgKGdldF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSkpOworICAgICAgaW50 IGk7CisKKyAgICAgIGZvciAoaSA9IDA7IGkgPCBudW07IGkgKyspCisgICAg ICAgIHJlZ2NhY2hlX3Jhd19zdXBwbHkgKHJlZ2NhY2hlLCBpLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfY29yZV9yZWdidWYgKyBN QVhfUkVHSVNURVJfU0laRSAqIGkpOworICAgIH0KKyAgZWxzZQorICAgIHJl Z2NhY2hlX3Jhd19zdXBwbHkgKHJlZ2NhY2hlLCByZWdubywKKyAgICAgICAg ICAgICAgICAgICAgICAgICByZWNvcmRfY29yZV9yZWdidWYgKyBNQVhfUkVH SVNURVJfU0laRSAqIHJlZ25vKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29y ZF9jb3JlX3ByZXBhcmVfdG9fc3RvcmUgKHN0cnVjdCByZWdjYWNoZSAqcmVn Y2FjaGUpCit7Cit9CisKK3N0YXRpYyB2b2lkCityZWNvcmRfY29yZV9zdG9y ZV9yZWdpc3RlcnMgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2Fj aGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludCByZWdubykK K3sKKyAgaWYgKHJlY29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGUpCisgICAg cmVnY2FjaGVfcmF3X2NvbGxlY3QgKHJlZ2NhY2hlLCByZWdubywKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFY X1JFR0lTVEVSX1NJWkUgKiByZWdubyk7CisgIGVsc2UKKyAgICBlcnJvciAo XygiWW91IGNhbid0IGRvIHRoYXQgd2l0aG91dCBhIHByb2Nlc3MgdG8gZGVi dWcuIikpOworfQorCitzdGF0aWMgTE9OR0VTVAorcmVjb3JkX2NvcmVfeGZl cl9wYXJ0aWFsIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLCBlbnVtIHRhcmdl dF9vYmplY3Qgb2JqZWN0LAorCQkgICAgICAgICAgY29uc3QgY2hhciAqYW5u ZXgsIGdkYl9ieXRlICpyZWFkYnVmLAorCQkgICAgICAgICAgY29uc3QgZ2Ri X2J5dGUgKndyaXRlYnVmLCBVTE9OR0VTVCBvZmZzZXQsCisgICAgICAgICAg ICAgICAgICAgICAgICAgIExPTkdFU1QgbGVuKQoreworICAgaWYgKG9iamVj dCA9PSBUQVJHRVRfT0JKRUNUX01FTU9SWSkKKyAgICAgeworICAgICAgIGlm IChyZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlIHx8ICF3cml0ZWJ1ZikK KyAgICAgICAgIHsKKyAgICAgICAgICAgc3RydWN0IHRhcmdldF9zZWN0aW9u ICpwOworICAgICAgICAgICBmb3IgKHAgPSByZWNvcmRfY29yZV9zdGFydDsg cCA8IHJlY29yZF9jb3JlX2VuZDsgcCsrKQorICAgICAgICAgICAgIHsKKyAg ICAgICAgICAgICAgIGlmIChvZmZzZXQgPj0gcC0+YWRkcikKKyAgICAgICAg ICAgICAgICAgeworICAgICAgICAgICAgICAgICAgIHN0cnVjdCByZWNvcmRf Y29yZV9idWZfZW50cnkgKmVudHJ5OworCisgICAgICAgICAgICAgICAgICAg aWYgKG9mZnNldCA+PSBwLT5lbmRhZGRyKQorICAgICAgICAgICAgICAgICAg ICAgY29udGludWU7CisKKyAgICAgICAgICAgICAgICAgICBpZiAob2Zmc2V0 ICsgbGVuID4gcC0+ZW5kYWRkcikKKyAgICAgICAgICAgICAgICAgICAgIGxl biA9IHAtPmVuZGFkZHIgLSBvZmZzZXQ7CisKKyAgICAgICAgICAgICAgICAg ICBvZmZzZXQgLT0gcC0+YWRkcjsKKworICAgICAgICAgICAgICAgICAgIC8q IFJlYWQgcmVhZGJ1ZiBvciB3cml0ZSB3cml0ZWJ1ZiBwLCBvZmZzZXQsIGxl bi4gICovCisgICAgICAgICAgICAgICAgICAgLyogQ2hlY2sgZmxhZ3MuICAq LworICAgICAgICAgICAgICAgICAgIGlmIChwLT50aGVfYmZkX3NlY3Rpb24t PmZsYWdzICYgU0VDX0NPTlNUUlVDVE9SCisgICAgICAgICAgICAgICAgICAg ICAgIHx8IChwLT50aGVfYmZkX3NlY3Rpb24tPmZsYWdzICYgU0VDX0hBU19D T05URU5UUykgPT0gMCkKKyAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgICAgICAgaWYgKHJlYWRidWYpCisgICAgICAgICAgICAg ICAgICAgICAgICAgbWVtc2V0IChyZWFkYnVmLCAwLCBsZW4pOworICAgICAg ICAgICAgICAgICAgICAgICByZXR1cm4gbGVuOworICAgICAgICAgICAgICAg ICAgICAgfQorICAgICAgICAgICAgICAgICAgIC8qIEdldCByZWNvcmRfY29y ZV9idWZfZW50cnkuICAqLworICAgICAgICAgICAgICAgICAgIGZvciAoZW50 cnkgPSByZWNvcmRfY29yZV9idWZfbGlzdDsgZW50cnk7CisgICAgICAgICAg ICAgICAgICAgICAgICBlbnRyeSA9IGVudHJ5LT5wcmV2KQorICAgICAgICAg ICAgICAgICAgICAgaWYgKGVudHJ5LT5wID09IHApCisgICAgICAgICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgICAgIGlmICh3cml0 ZWJ1ZikKKyAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAg ICAgICAgICAgaWYgKCFlbnRyeSkKKyAgICAgICAgICAgICAgICAgICAgICAg ICB7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBBZGQgYSBuZXcg ZW50cnkuICAqLworICAgICAgICAgICAgICAgICAgICAgICAgICAgZW50cnkK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPSAoc3RydWN0IHJlY29y ZF9jb3JlX2J1Zl9lbnRyeSAqKQorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgeG1hbGxvYworICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAoc2l6ZW9mIChzdHJ1Y3QgcmVjb3JkX2NvcmVfYnVmX2VudHJ5 KSk7CisgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+cCA9IHA7 CisgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWJmZF9tYWxsb2Nf YW5kX2dldF9zZWN0aW9uIChwLT5iZmQsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwLT50 aGVfYmZkX3NlY3Rpb24sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmZW50cnktPmJ1Zikp CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICB4ZnJlZSAoZW50cnkpOworICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHJldHVybiAwOworICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgICAgICAg ICBlbnRyeS0+cHJldiA9IHJlY29yZF9jb3JlX2J1Zl9saXN0OworICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfYnVmX2xpc3QgPSBl bnRyeTsKKyAgICAgICAgICAgICAgICAgICAgICAgICB9CisKKyAgICAgICAg ICAgICAgICAgICAgICAgIG1lbWNweSAoZW50cnktPmJ1ZiArIG9mZnNldCwg d3JpdGVidWYsIChzaXplX3QpIGxlbik7CisgICAgICAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICAgICAgICAgZWxzZQorICAgICAgICAgICAgICAg ICAgICAgeworICAgICAgICAgICAgICAgICAgICAgICBpZiAoIWVudHJ5KQor ICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiByZWNvcmRfYmVuZWF0 aF90b194ZmVyX3BhcnRpYWwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAocmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0LCBh bm5leCwgcmVhZGJ1Ziwgd3JpdGVidWYsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIG9mZnNldCwgbGVuKTsKKworICAgICAgICAgICAg ICAgICAgICAgICBtZW1jcHkgKHJlYWRidWYsIGVudHJ5LT5idWYgKyBvZmZz ZXQsIChzaXplX3QpIGxlbik7CisgICAgICAgICAgICAgICAgICAgICB9CisK KyAgICAgICAgICAgICAgICAgICByZXR1cm4gbGVuOworICAgICAgICAgICAg ICAgICB9CisgICAgICAgICAgICAgfQorCisgICAgICAgICAgIHJldHVybiAt MTsKKyAgICAgICAgIH0KKyAgICAgICBlbHNlCisgICAgICAgICBlcnJvciAo XygiWW91IGNhbid0IGRvIHRoYXQgd2l0aG91dCBhIHByb2Nlc3MgdG8gZGVi dWcuIikpOworICAgICB9CisKKyAgcmV0dXJuIHJlY29yZF9iZW5lYXRoX3Rv X3hmZXJfcGFydGlhbCAocmVjb3JkX2JlbmVhdGhfdG9feGZlcl9wYXJ0aWFs X29wcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgb2JqZWN0LCBhbm5leCwgcmVhZGJ1Ziwgd3JpdGVidWYsCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9mZnNldCwgbGVu KTsKK30KKworc3RhdGljIGludAorcmVjb3JkX2NvcmVfaW5zZXJ0X2JyZWFr cG9pbnQgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLAorCQkJICAgICAgIHN0 cnVjdCBicF90YXJnZXRfaW5mbyAqYnBfdGd0KQoreworICByZXR1cm4gMDsK K30KKworc3RhdGljIGludAorcmVjb3JkX2NvcmVfcmVtb3ZlX2JyZWFrcG9p bnQgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLAorCQkJICAgICAgIHN0cnVj dCBicF90YXJnZXRfaW5mbyAqYnBfdGd0KQoreworICByZXR1cm4gMDsKK30K KworaW50CityZWNvcmRfY29yZV9oYXNfZXhlY3V0aW9uIChzdHJ1Y3QgdGFy Z2V0X29wcyAqb3BzKQoreworICByZXR1cm4gMTsKK30KKworc3RhdGljIHZv aWQKK2luaXRfcmVjb3JkX2NvcmVfb3BzICh2b2lkKQoreworICByZWNvcmRf Y29yZV9vcHMudG9fc2hvcnRuYW1lID0gInJlY29yZF9jb3JlIjsKKyAgcmVj b3JkX2NvcmVfb3BzLnRvX2xvbmduYW1lID0gIlByb2Nlc3MgcmVjb3JkIGFu ZCByZXBsYXkgdGFyZ2V0IjsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX2RvYyA9 CisgICAgIkxvZyBwcm9ncmFtIHdoaWxlIGV4ZWN1dGluZyBhbmQgcmVwbGF5 IGV4ZWN1dGlvbiBmcm9tIGxvZy4iOworICByZWNvcmRfY29yZV9vcHMudG9f b3BlbiA9IHJlY29yZF9vcGVuOworICByZWNvcmRfY29yZV9vcHMudG9fY2xv c2UgPSByZWNvcmRfY2xvc2U7CisgIHJlY29yZF9jb3JlX29wcy50b19yZXN1 bWUgPSByZWNvcmRfY29yZV9yZXN1bWU7CisgIHJlY29yZF9jb3JlX29wcy50 b193YWl0ID0gcmVjb3JkX3dhaXQ7CisgIHJlY29yZF9jb3JlX29wcy50b19r aWxsID0gcmVjb3JkX2NvcmVfa2lsbDsKKyAgcmVjb3JkX2NvcmVfb3BzLnRv X2ZldGNoX3JlZ2lzdGVycyA9IHJlY29yZF9jb3JlX2ZldGNoX3JlZ2lzdGVy czsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX3ByZXBhcmVfdG9fc3RvcmUgPSBy ZWNvcmRfY29yZV9wcmVwYXJlX3RvX3N0b3JlOworICByZWNvcmRfY29yZV9v cHMudG9fc3RvcmVfcmVnaXN0ZXJzID0gcmVjb3JkX2NvcmVfc3RvcmVfcmVn aXN0ZXJzOworICByZWNvcmRfY29yZV9vcHMudG9feGZlcl9wYXJ0aWFsID0g cmVjb3JkX2NvcmVfeGZlcl9wYXJ0aWFsOworICByZWNvcmRfY29yZV9vcHMu dG9faW5zZXJ0X2JyZWFrcG9pbnQgPSByZWNvcmRfY29yZV9pbnNlcnRfYnJl YWtwb2ludDsKKyAgcmVjb3JkX2NvcmVfb3BzLnRvX3JlbW92ZV9icmVha3Bv aW50ID0gcmVjb3JkX2NvcmVfcmVtb3ZlX2JyZWFrcG9pbnQ7CisgIHJlY29y ZF9jb3JlX29wcy50b19jYW5fZXhlY3V0ZV9yZXZlcnNlID0gcmVjb3JkX2Nh bl9leGVjdXRlX3JldmVyc2U7CisgIHJlY29yZF9jb3JlX29wcy50b19oYXNf ZXhlY3V0aW9uID0gcmVjb3JkX2NvcmVfaGFzX2V4ZWN1dGlvbjsKKyAgcmVj b3JkX2NvcmVfb3BzLnRvX3N0cmF0dW0gPSByZWNvcmRfc3RyYXR1bTsKKyAg cmVjb3JkX2NvcmVfb3BzLnRvX21hZ2ljID0gT1BTX01BR0lDOworfQorCitz dGF0aWMgdm9pZAogc2hvd19yZWNvcmRfZGVidWcgKHN0cnVjdCB1aV9maWxl ICpmaWxlLCBpbnQgZnJvbV90dHksCiAJCSAgIHN0cnVjdCBjbWRfbGlzdF9l bGVtZW50ICpjLCBjb25zdCBjaGFyICp2YWx1ZSkKIHsKQEAgLTExNTMsNiAr MTY0NSwyMTIgQEAgY21kX3JlY29yZF9zdGFydCAoY2hhciAqYXJncywgaW50 IGZyb21fdAogICBleGVjdXRlX2NvbW1hbmQgKCJ0YXJnZXQgcmVjb3JkIiwg ZnJvbV90dHkpOwogfQogCitzdGF0aWMgdm9pZAorY21kX3JlY29yZF9sb2Fk IChjaGFyICphcmdzLCBpbnQgZnJvbV90dHkpCit7CisgIGNoYXIgYnVmWzUx Ml07CisKKyAgc25wcmludGYgKGJ1ZiwgNTEyLCAidGFyZ2V0IHJlY29yZCAl cyIsIGFyZ3MpOworICBleGVjdXRlX2NvbW1hbmQgKGJ1ZiwgZnJvbV90dHkp OworfQorCitzdGF0aWMgaW5saW5lIHZvaWQKK3JlY29yZF93cml0ZV9kdW1w IChjaGFyICpyZWNmaWxlbmFtZSwgaW50IGZpbGRlcywgY29uc3Qgdm9pZCAq YnVmLAorICAgICAgICAgICAgICAgICAgIHNpemVfdCBuYnl0ZSkKK3sKKyAg aWYgKHdyaXRlIChmaWxkZXMsIGJ1ZiwgbmJ5dGUpICE9IG5ieXRlKQorICAg IGVycm9yIChfKCJGYWlsZWQgdG8gd3JpdGUgZHVtcCBvZiBleGVjdXRpb24g cmVjb3JkcyB0byAnJXMnLiIpLAorICAgICAgICAgICByZWNmaWxlbmFtZSk7 Cit9CisKKy8qIFJlY29yZCBsb2cgc2F2ZS1maWxlIGZvcm1hdAorICAgVmVy c2lvbiAxCisKKyAgIEhlYWRlcjoKKyAgICAgNCBieXRlczogbWFnaWMgbnVt YmVyIGh0b25sKDB4MjAwOTA3MjYpLgorICAgICAgIE5PVEU6IGJlIHN1cmUg dG8gY2hhbmdlIHdoZW5ldmVyIHRoaXMgZmlsZSBmb3JtYXQgY2hhbmdlcyEK KworICAgUmVjb3JkczoKKyAgICAgcmVjb3JkX2VuZDoKKyAgICAgICAxIGJ5 dGU6ICByZWNvcmQgdHlwZSAocmVjb3JkX2VuZCkuCisgICAgIHJlY29yZF9y ZWc6CisgICAgICAgMSBieXRlOiAgcmVjb3JkIHR5cGUgKHJlY29yZF9yZWcp LgorICAgICAgIDggYnl0ZXM6IHJlZ2lzdGVyIGlkIChuZXR3b3JrIGJ5dGUg b3JkZXIpLgorICAgICAgIE1BWF9SRUdJU1RFUl9TSVpFIGJ5dGVzOiByZWdp c3RlciB2YWx1ZS4KKyAgICAgcmVjb3JkX21lbToKKyAgICAgICAxIGJ5dGU6 ICByZWNvcmQgdHlwZSAocmVjb3JkX21lbSkuCisgICAgICAgOCBieXRlczog bWVtb3J5IGFkZHJlc3MgKG5ldHdvcmsgYnl0ZSBvcmRlcikuCisgICAgICAg OCBieXRlczogbWVtb3J5IGxlbmd0aCAobmV0d29yayBieXRlIG9yZGVyKS4K KyAgICAgICBuIGJ5dGVzOiBtZW1vcnkgdmFsdWUgKG4gPT0gbWVtb3J5IGxl bmd0aCkuCisqLworCisvKiBEdW1wIHRoZSBleGVjdXRpb24gbG9nIHRvIGEg ZmlsZS4gICovCisKK3N0YXRpYyB2b2lkCitjbWRfcmVjb3JkX2R1bXAgKGNo YXIgKmFyZ3MsIGludCBmcm9tX3R0eSkKK3sKKyAgY2hhciAqcmVjZmlsZW5h bWUsIHJlY2ZpbGVuYW1lX2J1ZmZlcls0MF07CisgIGludCByZWNmZDsKKyAg c3RydWN0IHJlY29yZF9lbnRyeSAqY3VyX3JlY29yZF9saXN0OworICB1aW50 MzJfdCBtYWdpYzsKKyAgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZTsKKyAg c3RydWN0IGdkYmFyY2ggKmdkYmFyY2g7CisgIHN0cnVjdCBjbGVhbnVwICpv bGRfY2xlYW51cHM7CisgIHN0cnVjdCBjbGVhbnVwICpzZXRfY2xlYW51cHM7 CisKKyAgaWYgKHN0cmNtcCAoY3VycmVudF90YXJnZXQudG9fc2hvcnRuYW1l LCAicmVjb3JkIikgIT0gMCkKKyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNv cmQgaXMgbm90IHN0YXJ0ZWQuXG4iKSk7CisKKyAgaWYgKGFyZ3MgJiYgKmFy Z3MpCisgICAgcmVjZmlsZW5hbWUgPSBhcmdzOworICBlbHNlCisgICAgewor ICAgICAgLyogRGVmYXVsdCBjb3JlZmlsZSBuYW1lIGlzICJnZGJfcmVjb3Jk LlBJRCIuICAqLworICAgICAgc25wcmludGYgKHJlY2ZpbGVuYW1lX2J1ZmZl ciwgNDAsICJnZGJfcmVjb3JkLiVkIiwKKyAgICAgICAgICAgICAgICBQSURH RVQgKGluZmVyaW9yX3B0aWQpKTsKKyAgICAgIHJlY2ZpbGVuYW1lID0gcmVj ZmlsZW5hbWVfYnVmZmVyOworICAgIH0KKworICAvKiBPcGVuIHRoZSBkdW1w IGZpbGUuICAqLworICBpZiAocmVjb3JkX2RlYnVnKQorICAgIGZwcmludGZf dW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKyAgICAgICAgICAgICAgICAgICAg ICAgIF8oIlNhdmluZyByZWNvcmRpbmcgdG8gZmlsZSAnJXMnXG4iKSwKKyAg ICAgICAgICAgICAgICAgICAgICAgIHJlY2ZpbGVuYW1lKTsKKyAgcmVjZmQg PSBvcGVuIChyZWNmaWxlbmFtZSwgT19XUk9OTFkgfCBPX0NSRUFUIHwgT19U UlVOQyB8IE9fQklOQVJZLAorICAgICAgICAgICAgICAgIFNfSVJVU1IgfCBT X0lXVVNSKTsKKyAgaWYgKHJlY2ZkIDwgMCkKKyAgICBlcnJvciAoXygiRmFp bGVkIHRvIG9wZW4gJyVzJyBmb3IgZHVtcCBleGVjdXRpb24gcmVjb3Jkczog JXMiKSwKKyAgICAgICAgICAgcmVjZmlsZW5hbWUsIHN0cmVycm9yIChlcnJu bykpOworICBvbGRfY2xlYW51cHMgPSBtYWtlX2NsZWFudXAgKHJlY29yZF9m ZF9jbGVhbnVwcywgJnJlY2ZkKTsKKworICAvKiBTYXZlIHRoZSBjdXJyZW50 IHJlY29yZCBlbnRyeSB0byAiY3VyX3JlY29yZF9saXN0Ii4gICovCisgIGN1 cl9yZWNvcmRfbGlzdCA9IHJlY29yZF9saXN0OworCisgIC8qIEdldCB0aGUg dmFsdWVzIG9mIHJlZ2NhY2hlIGFuZCBnZGJhcmNoLiAgKi8KKyAgcmVnY2Fj aGUgPSBnZXRfY3VycmVudF9yZWdjYWNoZSAoKTsKKyAgZ2RiYXJjaCA9IGdl dF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSk7CisKKyAgLyogRGlzYWJsZSB0 aGUgR0RCIG9wZXJhdGlvbiByZWNvcmQuICAqLworICBzZXRfY2xlYW51cHMg PSByZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlX3NldCAoKTsKKworICAv KiBXcml0ZSB0aGUgbWFnaWMgY29kZS4gICovCisgIG1hZ2ljID0gUkVDT1JE X0ZJTEVfTUFHSUM7CisgIGlmIChyZWNvcmRfZGVidWcpCisgICAgZnByaW50 Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCBfKCJcCitXcml0aW5nIDQtYnl0 ZSBtYWdpYyBjb29raWUgUkVDT1JEX0ZJTEVfTUFHSUMgKDB4JTA4eClcbiIp LAorICAgICAgICAgICAgICAgICAgICAgICAgbWFnaWMpOworICByZWNvcmRf d3JpdGVfZHVtcCAocmVjZmlsZW5hbWUsIHJlY2ZkLCAmbWFnaWMsIDQpOwor CisgIC8qIFJldmVyc2UgZXhlY3V0ZSB0byB0aGUgYmVnaW4gb2YgcmVjb3Jk IGxpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBDaGVj ayBmb3IgYmVnaW5uaW5nIGFuZCBlbmQgb2YgbG9nLiAgKi8KKyAgICAgIGlm IChyZWNvcmRfbGlzdCA9PSAmcmVjb3JkX2ZpcnN0KQorICAgICAgICBicmVh azsKKworICAgICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJh cmNoLCByZWNvcmRfbGlzdCwgMCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlz dC0+cHJldikKKyAgICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+ cHJldjsKKyAgICB9CisKKyAgLyogRHVtcCB0aGUgZW50cmllcyB0byByZWNm ZCBhbmQgZm9yd2FyZCBleGVjdXRlIHRvIHRoZSBlbmQgb2YKKyAgICAgcmVj b3JkIGxpc3QuICAqLworICB3aGlsZSAoMSkKKyAgICB7CisgICAgICAvKiBE dW1wIGVudHJ5LiAgKi8KKyAgICAgIGlmIChyZWNvcmRfbGlzdCAhPSAmcmVj b3JkX2ZpcnN0KQorICAgICAgICB7CisgICAgICAgICAgdWludDhfdCB0bXB1 ODsKKyAgICAgICAgICB1aW50NjRfdCB0bXB1NjQ7CisKKyAgICAgICAgICB0 bXB1OCA9IHJlY29yZF9saXN0LT50eXBlOworICAgICAgICAgIHJlY29yZF93 cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVjZmQsICZ0bXB1OCwgMSk7CisK KyAgICAgICAgICBzd2l0Y2ggKHJlY29yZF9saXN0LT50eXBlKQorICAgICAg ICAgICAgeworICAgICAgICAgICAgY2FzZSByZWNvcmRfcmVnOiAvKiByZWcg Ki8KKyAgICAgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICAgICAg ICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csIF8oIlwK K1dyaXRpbmcgcmVnaXN0ZXIgJWQgKDEgcGx1cyA4IHBsdXMgJWQgYnl0ZXMp XG4iKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJl Y29yZF9saXN0LT51LnJlZy5udW0sCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBNQVhfUkVHSVNURVJfU0laRSk7CisKKyAgICAgICAg ICAgICAgdG1wdTY0ID0gcmVjb3JkX2xpc3QtPnUucmVnLm51bTsKKyAgICAg ICAgICAgICAgaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikKKyAg ICAgICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyAg ICAgICAgICAgICAgcmVjb3JkX3dyaXRlX2R1bXAgKHJlY2ZpbGVuYW1lLCBy ZWNmZCwgJnRtcHU2NCwgOCk7CisKKyAgICAgICAgICAgICAgcmVjb3JkX3dy aXRlX2R1bXAgKHJlY2ZpbGVuYW1lLCByZWNmZCwgcmVjb3JkX2xpc3QtPnUu cmVnLnZhbCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE1B WF9SRUdJU1RFUl9TSVpFKTsKKyAgICAgICAgICAgICAgYnJlYWs7CisKKyAg ICAgICAgICAgIGNhc2UgcmVjb3JkX21lbTogLyogbWVtICovCisgICAgICAg ICAgICAgIGlmICghcmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3Rf YWNjZXNzaWJsZSkKKyAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAg ICAgICBpZiAocmVjb3JkX2RlYnVnKQorICAgICAgICAgICAgICAgICAgICBm cHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csIF8oIlwKK1dyaXRpbmcg bWVtb3J5ICVzICgxIHBsdXMgOCBwbHVzIDggYnl0ZXMgcGx1cyAlZCBieXRl cylcbiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHBhZGRyZXNzIChnZGJhcmNoLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5t ZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisKKyAgICAgICAgICAg ICAgICAgIHRtcHU2NCA9IHJlY29yZF9saXN0LT51Lm1lbS5hZGRyOworICAg ICAgICAgICAgICAgICAgaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElB TikKKyAgICAgICAgICAgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRt cHU2NCk7CisgICAgICAgICAgICAgICAgICByZWNvcmRfd3JpdGVfZHVtcCAo cmVjZmlsZW5hbWUsIHJlY2ZkLCAmdG1wdTY0LCA4KTsKKworICAgICAgICAg ICAgICAgICAgdG1wdTY0ID0gcmVjb3JkX2xpc3QtPnUubWVtLmxlbjsKKyAg ICAgICAgICAgICAgICAgIGlmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJ QU4pCisgICAgICAgICAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0 bXB1NjQpOworICAgICAgICAgICAgICAgICAgcmVjb3JkX3dyaXRlX2R1bXAg KHJlY2ZpbGVuYW1lLCByZWNmZCwgJnRtcHU2NCwgOCk7CisKKyAgICAgICAg ICAgICAgICAgIHJlY29yZF93cml0ZV9kdW1wIChyZWNmaWxlbmFtZSwgcmVj ZmQsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVj b3JkX2xpc3QtPnUubWVtLnZhbCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKKyAgICAg ICAgICAgICAgICB9CisgICAgICAgICAgICAgIGJyZWFrOworCisgICAgICAg ICAgICAgIGNhc2UgcmVjb3JkX2VuZDoKKyAgICAgICAgICAgICAgICAvKiBG SVhNRTogcmVjb3JkIHRoZSBjb250ZW50cyBvZiByZWNvcmRfZW5kIHJlYy4g ICovCisgICAgICAgICAgICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICAg ICAgICAgICAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXygiV3Jp dGluZyByZWNvcmRfZW5kICgxIGJ5dGUpXG4iKSk7CisgICAgICAgICAgICAg ICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAg LyogRXhlY3V0ZSBlbnRyeS4gICovCisgICAgICByZWNvcmRfZXhlY19lbnRy eSAocmVnY2FjaGUsIGdkYmFyY2gsIHJlY29yZF9saXN0LCAwKTsKKworICAg ICAgaWYgKHJlY29yZF9saXN0LT5uZXh0KQorICAgICAgICByZWNvcmRfbGlz dCA9IHJlY29yZF9saXN0LT5uZXh0OworICAgICAgZWxzZQorICAgICAgICBi cmVhazsKKyAgICB9CisKKyAgLyogUmV2ZXJzZSBleGVjdXRlIHRvIGN1cl9y ZWNvcmRfbGlzdC4gICovCisgIHdoaWxlICgxKQorICAgIHsKKyAgICAgIC8q IENoZWNrIGZvciBiZWdpbm5pbmcgYW5kIGVuZCBvZiBsb2cuICAqLworICAg ICAgaWYgKHJlY29yZF9saXN0ID09IGN1cl9yZWNvcmRfbGlzdCkKKyAgICAg ICAgYnJlYWs7CisKKyAgICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdjYWNo ZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QsIDApOworCisgICAgICBpZiAocmVj b3JkX2xpc3QtPnByZXYpCisgICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3Jk X2xpc3QtPnByZXY7CisgICAgfQorCisgIGRvX2NsZWFudXBzIChzZXRfY2xl YW51cHMpOworICBkb19jbGVhbnVwcyAob2xkX2NsZWFudXBzKTsKKworICAv KiBTdWNjZWVkZWQuICAqLworICBmcHJpbnRmX2ZpbHRlcmVkIChnZGJfc3Rk b3V0LCBfKCJTYXZlZCBkdW1wIG9mIGV4ZWN1dGlvbiAiCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgInJlY29yZHMgdG8gYCVzJy5cbiIp LAorICAgICAgICAgICAgICAgICAgICByZWNmaWxlbmFtZSk7Cit9CisKIC8q IFRydW5jYXRlIHRoZSByZWNvcmQgbG9nIGZyb20gdGhlIHByZXNlbnQgcG9p bnQKICAgIG9mIHJlcGxheSB1bnRpbCB0aGUgZW5kLiAgKi8KIApAQCAtMTE4 NSw3ICsxODgzLDEyIEBAIGNtZF9yZWNvcmRfc3RvcCAoY2hhciAqYXJncywg aW50IGZyb21fdHQKICAgICB7CiAgICAgICBpZiAoIXJlY29yZF9saXN0IHx8 ICFmcm9tX3R0eSB8fCBxdWVyeSAoXygiRGVsZXRlIHJlY29yZGVkIGxvZyBh bmQgIgogCSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAic3RvcCByZWNvcmRpbmc/IikpKQotCXVucHVzaF90YXJnZXQgKCZyZWNv cmRfb3BzKTsKKyAgICAgICAgeworICAgICAgICAgIGlmIChzdHJjbXAgKGN1 cnJlbnRfdGFyZ2V0LnRvX3Nob3J0bmFtZSwgInJlY29yZCIpID09IDApCisJ ICAgIHVucHVzaF90YXJnZXQgKCZyZWNvcmRfb3BzKTsKKyAgICAgICAgICBl bHNlCisgICAgICAgICAgICB1bnB1c2hfdGFyZ2V0ICgmcmVjb3JkX2NvcmVf b3BzKTsKKyAgICAgICAgfQogICAgIH0KICAgZWxzZQogICAgIHByaW50Zl91 bmZpbHRlcmVkIChfKCJQcm9jZXNzIHJlY29yZCBpcyBub3Qgc3RhcnRlZC5c biIpKTsKQEAgLTEyMDMsNyArMTkwNiw3IEBAIHNldF9yZWNvcmRfaW5zbl9t YXhfbnVtIChjaGFyICphcmdzLCBpbnQKIAkJICAgICAgICAgICAidGhlIGZp cnN0IG9uZXM/XG4iKSk7CiAKICAgICAgIHdoaWxlIChyZWNvcmRfaW5zbl9u dW0gPiByZWNvcmRfaW5zbl9tYXhfbnVtKQotCXJlY29yZF9saXN0X3JlbGVh c2VfZmlyc3QgKCk7CisJcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNu ICgpOwogICAgIH0KIH0KIApAQCAtMTI0Myw2ICsxOTQ2LDggQEAgaW5mb19y ZWNvcmRfY29tbWFuZCAoY2hhciAqYXJncywgaW50IGZybwogdm9pZAogX2lu aXRpYWxpemVfcmVjb3JkICh2b2lkKQogeworICBzdHJ1Y3QgY21kX2xpc3Rf ZWxlbWVudCAqYzsKKwogICAvKiBJbml0IHJlY29yZF9maXJzdC4gICovCiAg IHJlY29yZF9maXJzdC5wcmV2ID0gTlVMTDsKICAgcmVjb3JkX2ZpcnN0Lm5l eHQgPSBOVUxMOwpAQCAtMTI1MCw2ICsxOTU1LDggQEAgX2luaXRpYWxpemVf cmVjb3JkICh2b2lkKQogCiAgIGluaXRfcmVjb3JkX29wcyAoKTsKICAgYWRk X3RhcmdldCAoJnJlY29yZF9vcHMpOworICBpbml0X3JlY29yZF9jb3JlX29w cyAoKTsKKyAgYWRkX3RhcmdldCAoJnJlY29yZF9jb3JlX29wcyk7CiAKICAg YWRkX3NldHNob3dfemludGVnZXJfY21kICgicmVjb3JkIiwgbm9fY2xhc3Ms ICZyZWNvcmRfZGVidWcsCiAJCQkgICAgXygiU2V0IGRlYnVnZ2luZyBvZiBy ZWNvcmQvcmVwbGF5IGZlYXR1cmUuIiksCkBAIC0xMjU5LDkgKzE5NjYsMTAg QEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogCQkJICAgIE5VTEwsIHNo b3dfcmVjb3JkX2RlYnVnLCAmc2V0ZGVidWdsaXN0LAogCQkJICAgICZzaG93 ZGVidWdsaXN0KTsKIAotICBhZGRfcHJlZml4X2NtZCAoInJlY29yZCIsIGNs YXNzX29ic2N1cmUsIGNtZF9yZWNvcmRfc3RhcnQsCi0JCSAgXygiQWJicmV2 aWF0ZWQgZm9ybSBvZiBcInRhcmdldCByZWNvcmRcIiBjb21tYW5kLiIpLAot IAkJICAmcmVjb3JkX2NtZGxpc3QsICJyZWNvcmQgIiwgMCwgJmNtZGxpc3Qp OworICBjID0gYWRkX3ByZWZpeF9jbWQgKCJyZWNvcmQiLCBjbGFzc19vYnNj dXJlLCBjbWRfcmVjb3JkX3N0YXJ0LAorCQkgICAgICBfKCJBYmJyZXZpYXRl ZCBmb3JtIG9mIFwidGFyZ2V0IHJlY29yZFwiIGNvbW1hbmQuIiksCisgCQkg ICAgICAmcmVjb3JkX2NtZGxpc3QsICJyZWNvcmQgIiwgMCwgJmNtZGxpc3Qp OworICBzZXRfY21kX2NvbXBsZXRlciAoYywgZmlsZW5hbWVfY29tcGxldGVy KTsKICAgYWRkX2NvbV9hbGlhcyAoInJlYyIsICJyZWNvcmQiLCBjbGFzc19v YnNjdXJlLCAxKTsKICAgYWRkX3ByZWZpeF9jbWQgKCJyZWNvcmQiLCBjbGFz c19zdXBwb3J0LCBzZXRfcmVjb3JkX2NvbW1hbmQsCiAJCSAgXygiU2V0IHJl Y29yZCBvcHRpb25zIiksICZzZXRfcmVjb3JkX2NtZGxpc3QsCkBAIC0xMjc2 LDYgKzE5ODQsMTYgQEAgX2luaXRpYWxpemVfcmVjb3JkICh2b2lkKQogCQkg ICJpbmZvIHJlY29yZCAiLCAwLCAmaW5mb2xpc3QpOwogICBhZGRfYWxpYXNf Y21kICgicmVjIiwgInJlY29yZCIsIGNsYXNzX29ic2N1cmUsIDEsICZpbmZv bGlzdCk7CiAKKyAgYyA9IGFkZF9jbWQgKCJsb2FkIiwgY2xhc3Nfb2JzY3Vy ZSwgY21kX3JlY29yZF9sb2FkLAorCSAgICAgICBfKCJMb2FkIHByZXZpb3Vz bHkgZHVtcGVkIGV4ZWN1dGlvbiByZWNvcmRzIGZyb20gXAorYSBmaWxlIGdp dmVuIGFzIGFyZ3VtZW50LiIpLAorICAgICAgICAgICAgICAgJnJlY29yZF9j bWRsaXN0KTsKKyAgc2V0X2NtZF9jb21wbGV0ZXIgKGMsIGZpbGVuYW1lX2Nv bXBsZXRlcik7CisgIGMgPSBhZGRfY21kICgiZHVtcCIsIGNsYXNzX29ic2N1 cmUsIGNtZF9yZWNvcmRfZHVtcCwKKwkgICAgICAgXygiRHVtcCB0aGUgZXhl Y3V0aW9uIHJlY29yZHMgdG8gYSBmaWxlLlxuXAorQXJndW1lbnQgaXMgb3B0 aW9uYWwgZmlsZW5hbWUuICBEZWZhdWx0IGZpbGVuYW1lIGlzICdnZGJfcmVj b3JkLjxwcm9jZXNzX2lkPicuIiksCisgICAgICAgICAgICAgICAmcmVjb3Jk X2NtZGxpc3QpOworICBzZXRfY21kX2NvbXBsZXRlciAoYywgZmlsZW5hbWVf Y29tcGxldGVyKTsKIAogICBhZGRfY21kICgiZGVsZXRlIiwgY2xhc3Nfb2Jz Y3VyZSwgY21kX3JlY29yZF9kZWxldGUsCiAJICAgXygiRGVsZXRlIHRoZSBy ZXN0IG9mIGV4ZWN1dGlvbiBsb2cgYW5kIHN0YXJ0IHJlY29yZGluZyBpdCBh bmV3LiIpLAo= --00504502bfe940e2800471be6642--