From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 28136 invoked by alias); 1 Aug 2009 07:31:24 -0000 Received: (qmail 28109 invoked by uid 22791); 1 Aug 2009 07:31:13 -0000 X-SWARE-Spam-Status: No, hits=-0.4 required=5.0 tests=AWL,BAYES_20,J_CHICKENPOX_37,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from wf-out-1314.google.com (HELO wf-out-1314.google.com) (209.85.200.172) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 01 Aug 2009 07:31:00 +0000 Received: by wf-out-1314.google.com with SMTP id 23so778238wfg.24 for ; Sat, 01 Aug 2009 00:30:58 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.11.2 with SMTP id 2mr107027wfk.104.1249111858154; Sat, 01 Aug 2009 00:30:58 -0700 (PDT) From: Hui Zhu Date: Sat, 01 Aug 2009 07:31:00 -0000 Message-ID: Subject: [RFA/RFC] Add dump and load command to process record and replay To: gdb-patches ml Cc: Michael Snyder , Eli Zaretskii Content-Type: multipart/mixed; boundary=000e0cd3313a970f5a04700f8418 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/msg00002.txt.bz2 --000e0cd3313a970f5a04700f8418 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 40055 Hi, This patch add command record dump and record load to make prec can dump execution log to a file and load it later. And load can work with core file. And I include "mem_entry_not_accessible"(not_replay) patch to this patch because when replay with core file, some address in lib cannot be read and write. For example: ./gdb ./a.out GNU gdb (GDB) 6.8.50.20090801-cvs Copyright (C) 2009 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i686-pc-linux-gnu". For bug reporting instructions, please see: ... Setting up the environment for debugging gdb. Function "internal_error" not defined. Make breakpoint pending on future shared library load? (y or [n]) [answered N; input not from terminal] Function "info_command" not defined. Make breakpoint pending on future shared library load? (y or [n]) [answered N; input not from terminal] /home/teawater/gdb/bgdbno/gdb/.gdbinit:8: Error in sourced command file: No breakpoint number 0. (gdb) start Temporary breakpoint 1 at 0x80483c1: file 1.c, line 20. Starting program: /home/teawater/gdb/bgdbno/gdb/a.out Temporary breakpoint 1, main () at 1.c:20 20 int b = 0; (gdb) gcore Saved corefile core.11945 (gdb) record (gdb) n During symbol reading, incomplete CFI data; unspecified registers (e.g., eax) at 0x80483be. 21 int c = 1; (gdb) 24 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) a = 0 b = 0 c = 1 25 b = cool (); (gdb) a = 3 26 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) a = 3 b = 3 c = 1 29 c += 1; (gdb) 30 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) a = 3 b = 3 c = 2 31 a -= 2; (gdb) 32 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) a = 1 b = 3 c = 2 35 return (0); (gdb) 36 } (gdb) rc Continuing. No more reverse-execution history. main () at 1.c:20 20 int b = 0; (gdb) record dump Saved recfile rec.11945. (gdb) quit After that, you get core.11945 and rec.11945. Then you can replay 11945 execution log with them. ./gdb ./a.out ./core.11945 GNU gdb (GDB) 6.8.50.20090801-cvs Copyright (C) 2009 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "i686-pc-linux-gnu". For bug reporting instructions, please see: ... Reading symbols from /lib/tls/i686/cmov/libc.so.6...done. Loaded symbols for /lib/tls/i686/cmov/libc.so.6 Reading symbols from /lib/ld-linux.so.2...done. Loaded symbols for /lib/ld-linux.so.2 Core was generated by `/home/teawater/gdb/bgdbno/gdb/a.out'. Program terminated with signal 5, Trace/breakpoint trap. #0 main () at 1.c:20 20 int b = 0; Setting up the environment for debugging gdb. Function "internal_error" not defined. Make breakpoint pending on future shared library load? (y or [n]) [answered N; input not from terminal] Function "info_command" not defined. Make breakpoint pending on future shared library load? (y or [n]) [answered N; input not from terminal] /home/teawater/gdb/bgdbno/gdb/.gdbinit:8: Error in sourced command file: No breakpoint number 0. (gdb) record load ./rec.11945 Auto start process record. Loaded recfile ./rec.11945. (gdb) p b During symbol reading, incomplete CFI data; unspecified registers (e.g., eax) at 0x80483be. $1 = -1208017488 (gdb) n 21 int c = 1; (gdb) p b $2 = 0 (gdb) n 24 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) 25 b = cool (); (gdb) p b $3 = 0 (gdb) n 26 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) 29 c += 1; (gdb) p c $4 = 1 (gdb) n 30 printf ("a = %d b = %d c = %d\n", a, b, c); (gdb) p c $5 = 2 (gdb) c Continuing. No more reverse-execution history. main () at 1.c:36 36 } (gdb) rc Continuing. No more reverse-execution history. main () at 1.c:20 20 int b = 0; (gdb) p c $6 = 134513849 (gdb) quit The program is running. Quit anyway (and kill it)? (y or n) y Please send your comments about it. Thanks a lot. Hui 2009-08-01 Hui Zhu Add dump and load command to process record and replay. * record.c (completer.h, arch-utils.h, gdbcore.h, exec.h, byteswap.h, netinet/in.h): Include files. (RECORD_IS_REPLAY): Return true if record_core is true. (RECORD_FILE_MAGIC): New macro. (record_mem_entry): New field 'mem_entry_not_accessible'. (record_core_buf_entry): New struct. (record_core, record_core_regbuf, record_core_start, record_core_end, record_core_buf_list, record_beneath_to_fetch_registers_ops, record_beneath_to_fetch_registers, record_beneath_to_store_registers_ops, record_beneath_to_store_registers, record_beneath_to_has_execution_ops, record_beneath_to_has_execution, record_beneath_to_prepare_to_store): New variables. (record_list_release_first_insn): Change function record_list_release_first to this name. (record_arch_list_add_mem): Initialize mem_entry_not_accessible to 0. (record_arch_list_cleanups): New function. (record_message_cleanups): Removed. (record_message): Change to call record_arch_list_cleanups and record_list_release_first_insn. (record_exec_entry): New function. (record_open): Add support for target core. (record_close): Add support for target core. (record_wait): Call record_exec_entry. (record_kill): Add support for target core. (record_registers_change): Call record_list_release_first_insn. (record_fetch_registers): New function. (record_prepare_to_store): New function. (record_store_registers): Add support for target core. (record_xfer_partial): Add support for target core. (record_has_execution): New function. (init_record_ops): Set record_ops.to_fetch_registers, record_ops.to_prepare_to_store and record_ops.to_has_execution. (cmd_record_fd_cleanups): New function. (cmd_record_dump): New function. (cmd_record_load): New function. (set_record_insn_max_num): Call record_list_release_first_insn. (_initialize_record): Add commands "record dump" and "record load". --- record.c | 709 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 641 insertions(+), 68 deletions(-) --- a/record.c +++ b/record.c @@ -23,14 +23,22 @@ #include "gdbthread.h" #include "event-top.h" #include "exceptions.h" +#include "completer.h" +#include "arch-utils.h" +#include "gdbcore.h" +#include "exec.h" #include "record.h" +#include #include +#include #define DEFAULT_RECORD_INSN_MAX_NUM 200000 #define RECORD_IS_REPLAY \ - (record_list->next || execution_direction == EXEC_REVERSE) + (record_list->next || execution_direction == EXEC_REVERSE || record_core) + +#define RECORD_FILE_MAGIC htonl(0x20090726) /* These are the core struct of record function. @@ -51,6 +59,7 @@ struct record_mem_entry { CORE_ADDR addr; int len; + int mem_entry_not_accessible; gdb_byte *val; }; @@ -75,9 +84,23 @@ struct record_entry } u; }; +struct record_core_buf_entry +{ + struct record_core_buf_entry *prev; + struct target_section *p; + bfd_byte *buf; +}; + /* This is the debug switch for process record. */ int record_debug = 0; +/* Record with core target. */ +static int record_core = 0; +static gdb_byte *record_core_regbuf; +static struct target_section *record_core_start; +static struct target_section *record_core_end; +static struct record_core_buf_entry *record_core_buf_list = NULL; + /* These list is for execution log. */ static struct record_entry record_first; static struct record_entry *record_list = &record_first; @@ -100,6 +123,14 @@ static struct target_ops *record_beneath static ptid_t (*record_beneath_to_wait) (struct target_ops *, ptid_t, struct target_waitstatus *, int); +static struct target_ops *record_beneath_to_fetch_registers_ops; +static void (*record_beneath_to_fetch_registers) (struct target_ops *, + struct regcache *, + int regno); +static struct target_ops *record_beneath_to_store_registers_ops; +static void (*record_beneath_to_store_registers) (struct target_ops *, + struct regcache *, + int regno); static struct target_ops *record_beneath_to_store_registers_ops; static void (*record_beneath_to_store_registers) (struct target_ops *, struct regcache *, @@ -116,6 +147,9 @@ static int (*record_beneath_to_insert_br struct bp_target_info *); static int (*record_beneath_to_remove_breakpoint) (struct gdbarch *, struct bp_target_info *); +static struct target_ops *record_beneath_to_has_execution_ops; +static int (*record_beneath_to_has_execution) (struct target_ops *ops); +static void (*record_beneath_to_prepare_to_store) (struct regcache *regcache); static void record_list_release (struct record_entry *rec) @@ -166,7 +200,7 @@ record_list_release_next (void) } static void -record_list_release_first (void) +record_list_release_first_insn (void) { struct record_entry *tmp = NULL; enum record_type type; @@ -275,6 +309,7 @@ record_arch_list_add_mem (CORE_ADDR addr rec->type = record_mem; rec->u.mem.addr = addr; rec->u.mem.len = len; + rec->u.mem.mem_entry_not_accessible = 0; if (target_read_memory (addr, rec->u.mem.val, len)) { @@ -336,30 +371,30 @@ record_check_insn_num (int set_terminal) if (q) record_stop_at_limit = 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 = args; - struct cleanup *old_cleanups = make_cleanup (record_message_cleanups, 0); + struct cleanup *old_cleanups = make_cleanup (record_arch_list_cleanups, 0); record_arch_list_head = NULL; record_arch_list_tail = NULL; @@ -382,7 +417,7 @@ record_message (void *args) record_list = record_arch_list_tail; if (record_insn_num == record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; @@ -412,6 +447,92 @@ record_gdb_operation_disable_set (void) return old_cleanups; } +static inline void +record_exec_entry (struct regcache *regcache, struct gdbarch *gdbarch, + struct record_entry *entry) +{ + switch (entry->type) + { + case record_reg: /* reg */ + { + gdb_byte reg[MAX_REGISTER_SIZE]; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_reg %s to " + "inferior num = %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.val); + memcpy (entry->u.reg.val, reg, MAX_REGISTER_SIZE); + } + break; + case record_mem: /* mem */ + { + if (record_list->u.mem.mem_entry_not_accessible) + record_list->u.mem.mem_entry_not_accessible = 0; + else + { + gdb_byte *mem = alloca (entry->u.mem.len); + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_mem %s to " + "inferior addr = %s len = %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.len)) + { + if ((execution_direction == EXEC_REVERSE && !record_core) + || (execution_direction != EXEC_REVERSE && record_core)) + { + record_list->u.mem.mem_entry_not_accessible = 1; + if (record_debug) + warning (_("Process record: error reading memory at " + "addr = %s len = %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + error (_("Process record: error reading memory at " + "addr = %s len = %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + { + if (target_write_memory (entry->u.mem.addr, entry->u.mem.val, + entry->u.mem.len)) + { + if ((execution_direction == EXEC_REVERSE && !record_core) + || (execution_direction != EXEC_REVERSE && record_core)) + { + record_list->u.mem.mem_entry_not_accessible = 1; + if (record_debug) + warning (_("Process record: error writing memory at " + "addr = %s len = %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + else + error (_("Process record: error writing memory at " + "addr = %s len = %d."), + paddress (gdbarch, entry->u.mem.addr), + entry->u.mem.len); + } + } + + memcpy (entry->u.mem.val, mem, entry->u.mem.len); + } + } + break; + } +} + static void record_open (char *name, int from_tty) { @@ -420,8 +541,13 @@ record_open (char *name, int from_tty) if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_open\n"); + if (!strcmp (current_target.to_shortname, "core")) + record_core = 1; + else + record_core = 0; + /* check exec */ - if (!target_has_execution) + if (!target_has_execution && !record_core) error (_("Process record: the program is not being run.")); if (non_stop) error (_("Process record target can't debug inferior in non-stop mode " @@ -450,6 +576,8 @@ record_open (char *name, int from_tty) record_beneath_to_xfer_partial = NULL; record_beneath_to_insert_breakpoint = NULL; record_beneath_to_remove_breakpoint = NULL; + record_beneath_to_has_execution = NULL; + record_beneath_to_prepare_to_store = NULL; /* Set the beneath function pointers. */ for (t = current_target.beneath; t != NULL; t = t->beneath) @@ -464,6 +592,11 @@ record_open (char *name, int from_tty) record_beneath_to_wait = t->to_wait; record_beneath_to_wait_ops = t; } + if (!record_beneath_to_fetch_registers) + { + record_beneath_to_fetch_registers = t->to_fetch_registers; + record_beneath_to_fetch_registers_ops = t; + } if (!record_beneath_to_store_registers) { record_beneath_to_store_registers = t->to_store_registers; @@ -478,19 +611,51 @@ record_open (char *name, int from_tty) record_beneath_to_insert_breakpoint = t->to_insert_breakpoint; if (!record_beneath_to_remove_breakpoint) record_beneath_to_remove_breakpoint = t->to_remove_breakpoint; + if (!record_beneath_to_has_execution) + { + record_beneath_to_has_execution_ops = t; + record_beneath_to_has_execution = t->to_has_execution; + } + if (!record_beneath_to_prepare_to_store) + record_beneath_to_prepare_to_store = t->to_prepare_to_store; } - if (!record_beneath_to_resume) + if (!record_beneath_to_resume && !record_core) error (_("Process record can't get to_resume.")); - if (!record_beneath_to_wait) + if (!record_beneath_to_wait && !record_core) error (_("Process record can't get to_wait.")); - if (!record_beneath_to_store_registers) + if (!record_beneath_to_fetch_registers) + error (_("Process record can't get to_fetch_registers.")); + if (!record_beneath_to_store_registers && !record_core) error (_("Process record can't get to_store_registers.")); if (!record_beneath_to_xfer_partial) error (_("Process record can't get to_xfer_partial.")); - if (!record_beneath_to_insert_breakpoint) + if (!record_beneath_to_insert_breakpoint && !record_core) error (_("Process record can't get to_insert_breakpoint.")); - if (!record_beneath_to_remove_breakpoint) + if (!record_beneath_to_remove_breakpoint && !record_core) error (_("Process record can't get to_remove_breakpoint.")); + if (!record_beneath_to_has_execution && !record_core) + error (_("Process record can't get to_has_execution.")); + if (!record_beneath_to_prepare_to_store && !record_core) + error (_("Process record can't get to_prepare_to_store.")); + + if (record_core) + { + /* Get record_core_regbuf. */ + struct regcache *regcache = get_current_regcache (); + int regnum = gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + target_fetch_registers (regcache, -1); + record_core_regbuf = xmalloc (MAX_REGISTER_SIZE * regnum); + for (i = 0; i < regnum; i ++) + regcache_raw_collect (regcache, i, + record_core_regbuf + MAX_REGISTER_SIZE * i); + + /* Get record_core_start and record_core_end. */ + if (build_section_table (core_bfd, &record_core_start, &record_core_end)) + error (_("\"%s\": Can't find sections: %s"), + bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ())); + } push_target (&record_ops); @@ -503,10 +668,26 @@ record_open (char *name, int from_tty) static void record_close (int quitting) { + struct record_core_buf_entry *entry; + if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n"); record_list_release (record_list); + + /* Release record_core_regbuf. */ + xfree (record_core_regbuf); + + /* Release record_core_buf_list. */ + if (record_core_buf_list) + { + for (entry = record_core_buf_list->prev; entry; entry = entry->prev) + { + xfree (record_core_buf_list); + record_core_buf_list = entry; + } + record_core_buf_list = NULL; + } } static int record_resume_step = 0; @@ -708,53 +889,9 @@ record_wait (struct target_ops *ops, break; } - /* Set ptid, register and memory according to record_list. */ - if (record_list->type == 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 = %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 == record_mem) - { - /* mem */ - gdb_byte *mem = alloca (record_list->u.mem.len); - if (record_debug > 1) - fprintf_unfiltered (gdb_stdlog, - "Process record: record_mem %s to " - "inferior addr = %s len = %d.\n", - host_address_to_string (record_list), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - - if (target_read_memory - (record_list->u.mem.addr, mem, record_list->u.mem.len)) - error (_("Process record: error reading memory at " - "addr = %s len = %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); - - if (target_write_memory - (record_list->u.mem.addr, record_list->u.mem.val, - record_list->u.mem.len)) - error (_ - ("Process record: error writing memory at " - "addr = %s len = %d."), - paddress (gdbarch, record_list->u.mem.addr), - record_list->u.mem.len); + record_exec_entry (regcache, gdbarch, record_list); - memcpy (record_list->u.mem.val, mem, record_list->u.mem.len); - } - else + if (record_list->type == record_end) { if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, @@ -874,7 +1011,9 @@ record_kill (struct target_ops *ops) fprintf_unfiltered (gdb_stdlog, "Process record: record_kill\n"); unpush_target (&record_ops); - target_kill (); + + if (!record_core) + target_kill (); } /* Record registers change (by user or by GDB) to list as an instruction. */ @@ -918,15 +1057,58 @@ record_registers_change (struct regcache record_list = record_arch_list_tail; if (record_insn_num == record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } static void +record_fetch_registers (struct target_ops *ops, struct regcache *regcache, + int regno) +{ + if (record_core) + { + if (regno < 0) + { + int num = gdbarch_num_regs (get_regcache_arch (regcache)); + int i; + + for (i = 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); + } + else + record_beneath_to_fetch_registers (record_beneath_to_store_registers_ops, + regcache, regno); +} + +static void +record_prepare_to_store (struct regcache *regcache) +{ + if (!record_core) + record_beneath_to_prepare_to_store (regcache); +} + +static void record_store_registers (struct target_ops *ops, struct regcache *regcache, int regno) { + if (record_core) + { + /* Debug with core. */ + if (record_gdb_operation_disable) + regcache_raw_collect (regcache, regno, + record_core_regbuf + MAX_REGISTER_SIZE * regno); + else + error (_("You can't do that without a process to debug.")); + + return; + } + if (!record_gdb_operation_disable) { if (RECORD_IS_REPLAY) @@ -973,6 +1155,7 @@ record_store_registers (struct target_op record_registers_change (regcache, regno); } + record_beneath_to_store_registers (record_beneath_to_store_registers_ops, regcache, regno); } @@ -988,7 +1171,7 @@ record_xfer_partial (struct target_ops * { if (!record_gdb_operation_disable && (object == TARGET_OBJECT_MEMORY - || object == TARGET_OBJECT_RAW_MEMORY) && writebuf) + || object == TARGET_OBJECT_RAW_MEMORY) && writebuf && !record_core) { if (RECORD_IS_REPLAY) { @@ -1032,11 +1215,91 @@ record_xfer_partial (struct target_ops * record_list = record_arch_list_tail; if (record_insn_num == record_insn_max_num && record_insn_max_num) - record_list_release_first (); + record_list_release_first_insn (); else record_insn_num++; } + if (record_core && object == TARGET_OBJECT_MEMORY) + { + /* Debug with core. */ + if (record_gdb_operation_disable || !writebuf) + { + struct target_section *p; + for (p = record_core_start; p < record_core_end; p++) + { + if (offset >= p->addr) + { + struct record_core_buf_entry *entry; + + if (offset >= p->endaddr) + continue; + + if (offset + len > p->endaddr) + len = p->endaddr - offset; + + offset -= 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) == 0) + { + if (readbuf) + memset (readbuf, 0, len); + return len; + } + /* Get record_core_buf_entry. */ + for (entry = record_core_buf_list; entry; + entry = entry->prev) + if (entry->p == p) + break; + if (writebuf) + { + if (!entry) + { + /* Add a new entry. */ + entry + = (struct record_core_buf_entry *) + xmalloc + (sizeof (struct record_core_buf_entry)); + entry->p = p; + if (!bfd_malloc_and_get_section (p->bfd, + p->the_bfd_section, + &entry->buf)) + { + xfree (entry); + return 0; + } + entry->prev = record_core_buf_list; + record_core_buf_list = entry; + } + + memcpy (entry->buf + offset, writebuf, (size_t) len); + } + else + { + if (!entry) + return record_beneath_to_xfer_partial + (record_beneath_to_xfer_partial_ops, + object, annex, readbuf, writebuf, + offset, len); + + memcpy (readbuf, entry->buf + offset, (size_t) len); + } + + return len; + } + } + + return 0; + } + else + error (_("You can't do that without a process to debug.")); + + return 0; + } + return record_beneath_to_xfer_partial (record_beneath_to_xfer_partial_ops, object, annex, readbuf, writebuf, offset, len); @@ -1086,6 +1349,15 @@ record_can_execute_reverse (void) return 1; } +int +record_has_execution (struct target_ops *ops) +{ + if (record_core) + return 1; + + return record_beneath_to_has_execution (ops); +} + static void init_record_ops (void) { @@ -1102,11 +1374,14 @@ init_record_ops (void) record_ops.to_mourn_inferior = record_mourn_inferior; record_ops.to_kill = record_kill; record_ops.to_create_inferior = find_default_create_inferior; + record_ops.to_fetch_registers = record_fetch_registers; + record_ops.to_prepare_to_store = record_prepare_to_store; record_ops.to_store_registers = record_store_registers; record_ops.to_xfer_partial = record_xfer_partial; record_ops.to_insert_breakpoint = record_insert_breakpoint; record_ops.to_remove_breakpoint = record_remove_breakpoint; record_ops.to_can_execute_reverse = record_can_execute_reverse; + record_ops.to_has_execution = record_has_execution; record_ops.to_stratum = record_stratum; record_ops.to_magic = OPS_MAGIC; } @@ -1127,6 +1402,293 @@ cmd_record_start (char *args, int from_t execute_command ("target record", from_tty); } +static void +cmd_record_fd_cleanups (void *recfdp) +{ + int recfd = *(int *) recfdp; + close (recfd); +} + +/* Dump the execution log to a file. */ + +static void +cmd_record_dump (char *args, int from_tty) +{ + char *recfilename, recfilename_buffer[40]; + int recfd; + struct record_entry *cur_record_list; + uint32_t magic; + struct regcache *regcache; + struct gdbarch *gdbarch; + struct cleanup *old_cleanups; + struct cleanup *set_cleanups; + + if (current_target.to_stratum != record_stratum) + error (_("Process record is not started.\n")); + + if (args && *args) + recfilename = args; + else + { + /* Default corefile name is "rec.PID". */ + sprintf (recfilename_buffer, "rec.%d", PIDGET (inferior_ptid)); + recfilename = recfilename_buffer; + } + + /* Open the dump file. */ + recfd = open (recfilename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, + S_IRUSR | S_IWUSR); + if (recfd < 0) + error (_("Failed to open '%s' for dump."), recfilename); + old_cleanups = make_cleanup (cmd_record_fd_cleanups, &recfd); + + /* Save the current record entry to "cur_record_list". */ + cur_record_list = record_list; + + /* Get the values of regcache and gdbarch. */ + regcache = get_current_regcache (); + gdbarch = get_regcache_arch (regcache); + + /* Disable the GDB operation record. */ + set_cleanups = record_gdb_operation_disable_set (); + + /* Write the magic code. */ + magic = RECORD_FILE_MAGIC; + if (write (recfd, &magic, 4) != 4) + error (_("Failed to write '%s' for dump."), recfilename); + + /* Reverse execute to the begin of record list. */ + while (1) + { + /* Check for beginning and end of log. */ + if (record_list == &record_first) + break; + + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->prev) + record_list = record_list->prev; + } + + /* Dump the entries to recfd and forward execute to the end of + record list. */ + while (1) + { + /* Dump entry. */ + if (record_list != &record_first) + { + uint8_t tmpu8; + uint64_t tmpu64; + + tmpu8 = record_list->type; + if (write (recfd, &tmpu8, 1) != 1) + error (_("Failed to write '%s' for dump."), recfilename); + + switch (record_list->type) + { + case record_reg: /* reg */ + tmpu64 = record_list->u.reg.num; +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + if (write (recfd, &tmpu64, 8) != 8) + error (_("Failed to write '%s' for dump."), recfilename); + + if (write (recfd, record_list->u.reg.val, + MAX_REGISTER_SIZE) != MAX_REGISTER_SIZE) + error (_("Failed to write '%s' for dump."), recfilename); + break; + case record_mem: /* mem */ + if (!record_list->u.mem.mem_entry_not_accessible) + { + tmpu64 = record_list->u.mem.addr; +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + if (write (recfd, &tmpu64, 8) != 8) + error (_("Failed to write '%s' for dump."), recfilename); + + tmpu64 = record_list->u.mem.len; +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + if (write (recfd, &tmpu64, 8) != 8) + error (_("Failed to write '%s' for dump."), recfilename); + + if (write (recfd, record_list->u.mem.val, + record_list->u.mem.len) != record_list->u.mem.len) + error (_("Failed to write '%s' for dump."), recfilename); + } + break; + } + } + + /* Execute entry. */ + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->next) + record_list = record_list->next; + else + break; + } + + /* Reverse execute to cur_record_list. */ + while (1) + { + /* Check for beginning and end of log. */ + if (record_list == cur_record_list) + break; + + record_exec_entry (regcache, gdbarch, record_list); + + if (record_list->prev) + record_list = record_list->prev; + } + + do_cleanups (set_cleanups); + do_cleanups (old_cleanups); + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, "Saved recfile %s.\n", recfilename); +} + +/* Load the execution log from a file. */ + +static void +cmd_record_load (char *args, int from_tty) +{ + int recfd; + uint32_t magic; + struct cleanup *old_cleanups; + struct cleanup *old_cleanups2; + struct record_entry *rec; + int insn_number = 0; + + if (current_target.to_stratum != record_stratum) + { + cmd_record_start (NULL, from_tty); + printf_unfiltered (_("Auto start process record.\n")); + } + + if (!args || (args && !*args)) + error (_("Argument for filename required.\n")); + + /* Open the load file. */ + recfd = open (args, O_RDONLY | O_BINARY); + if (recfd < 0) + error (_("Failed to open '%s' for load."), args); + old_cleanups = make_cleanup (cmd_record_fd_cleanups, &recfd); + + /* Check the magic code. */ + if (read (recfd, &magic, 4) != 4) + error (_("Failed to read '%s' for load."), args); + if (magic != RECORD_FILE_MAGIC) + error (_("'%s' is not a record dump."), args); + + /* Load the entries in recfd to the record_arch_list_head and + record_arch_list_tail. */ + record_arch_list_head = NULL; + record_arch_list_tail = NULL; + old_cleanups2 = make_cleanup (record_arch_list_cleanups, 0); + + while (1) + { + int ret; + uint8_t tmpu8; + uint64_t tmpu64; + + ret = read (recfd, &tmpu8, 1); + if (ret < 0) + error (_("Failed to read '%s' for load."), args); + if (ret == 0) + break; + + switch (tmpu8) + { + case record_reg: /* reg */ + rec = (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->u.reg.val = (gdb_byte *) xmalloc (MAX_REGISTER_SIZE); + rec->prev = NULL; + rec->next = NULL; + rec->type = record_reg; + /* Get num. */ + if (read (recfd, &tmpu64, 8) != 8) + error (_("Failed to read '%s' for load."), args); +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + rec->u.reg.num = tmpu64; + /* Get val. */ + if (read (recfd, rec->u.reg.val, + MAX_REGISTER_SIZE) != MAX_REGISTER_SIZE) + error (_("Failed to read '%s' for load."), args); + record_arch_list_add (rec); + break; + case record_mem: /* mem */ + rec = (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->prev = NULL; + rec->next = NULL; + rec->type = record_mem; + /* Get addr. */ + if (read (recfd, &tmpu64, 8) != 8) + error (_("Failed to read '%s' for load."), args); +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + rec->u.mem.addr = tmpu64; + /* Get len. */ + if (read (recfd, &tmpu64, 8) != 8) + error (_("Failed to read '%s' for load."), args); +#if (BYTE_ORDER == LITTLE_ENDIAN) + tmpu64 = bswap_64 (tmpu64); +#endif + rec->u.mem.len = tmpu64; + rec->u.mem.mem_entry_not_accessible = 0; + rec->u.mem.val = (gdb_byte *) xmalloc (rec->u.mem.len); + /* Get val. */ + if (read (recfd, rec->u.mem.val, + rec->u.mem.len) != rec->u.mem.len) + error (_("Failed to read '%s' for load."), args); + record_arch_list_add (rec); + break; + + case record_end: /* end */ + rec = (struct record_entry *) xmalloc (sizeof (struct record_entry)); + rec->prev = NULL; + rec->next = NULL; + rec->type = record_end; + record_arch_list_add (rec); + insn_number ++; + break; + + default: + error (_("Format of '%s' is not right."), args); + break; + } + } + + discard_cleanups (old_cleanups2); + + /* Add record_arch_list_head to the end of record list. */ + for (rec = record_list; rec->next; rec = rec->next); + rec->next = record_arch_list_head; + record_arch_list_head->prev = rec; + + /* Update record_insn_num and record_insn_max_num. */ + record_insn_num += insn_number; + if (record_insn_num > record_insn_max_num) + { + record_insn_max_num = record_insn_num; + warning (_("Auto increase record/replay buffer limit to %d."), + record_insn_max_num); + } + + do_cleanups (old_cleanups); + + /* Succeeded. */ + fprintf_filtered (gdb_stdout, "Loaded recfile %s.\n", args); +} + /* Truncate the record log from the present point of replay until the end. */ @@ -1177,7 +1739,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 (); } } @@ -1217,6 +1779,8 @@ info_record_command (char *args, int fro void _initialize_record (void) { + struct cmd_list_element *c; + /* Init record_first. */ record_first.prev = NULL; record_first.next = NULL; @@ -1250,6 +1814,15 @@ _initialize_record (void) "info record ", 0, &infolist); add_alias_cmd ("rec", "record", class_obscure, 1, &infolist); + c = add_cmd ("dump", class_obscure, cmd_record_dump, + _("Dump the execution log to a file.\n\ +Argument is optional filename. Default filename is 'rec.'."), + &record_cmdlist); + set_cmd_completer (c, filename_completer); + c = add_cmd ("load", class_obscure, cmd_record_load, + _("Load the execution log from a file. Argument is filename."), + &record_cmdlist); + set_cmd_completer (c, filename_completer); add_cmd ("delete", class_obscure, cmd_record_delete, _("Delete the rest of execution log and start recording it anew."), 2009-08-01 Hui Zhu * gdb.texinfo (Process Record and Replay): Document the "record dump" and "record dump" commands. --- doc/gdb.texinfo | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) --- a/doc/gdb.texinfo +++ b/doc/gdb.texinfo @@ -5190,6 +5190,22 @@ When record target runs in replay mode ( subsequent execution log and begin to record a new execution log starting from the current address. This means you will abandon the previously recorded ``future'' and begin recording a new ``future''. + +@kindex record dump +@kindex rec dump +@item record dump [@var{file}] +@itemx rec dump [@var{file}] +Produce a record execution log of the inferior process. The optional +argument @var{file} specifies the file name where to put the record dump. +If not specified, the file name defaults to @file{rec.@var{pid}}, where +@var{pid} is the inferior process ID. + +@kindex record load +@kindex rec load +@item record load @var{file} +@itemx rec dump @var{file} +Load process record execution log from @var{file}. +It can work with @code{core-file}. @end table --000e0cd3313a970f5a04700f8418 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_fxu0uoo00 Content-length: 44197 LS0tCiByZWNvcmQuYyB8ICA3MDkgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tCiAxIGZp bGUgY2hhbmdlZCwgNjQxIGluc2VydGlvbnMoKyksIDY4IGRlbGV0aW9ucygt KQoKLS0tIGEvcmVjb3JkLmMKKysrIGIvcmVjb3JkLmMKQEAgLTIzLDE0ICsy MywyMiBAQAogI2luY2x1ZGUgImdkYnRocmVhZC5oIgogI2luY2x1ZGUgImV2 ZW50LXRvcC5oIgogI2luY2x1ZGUgImV4Y2VwdGlvbnMuaCIKKyNpbmNsdWRl ICJjb21wbGV0ZXIuaCIKKyNpbmNsdWRlICJhcmNoLXV0aWxzLmgiCisjaW5j bHVkZSAiZ2RiY29yZS5oIgorI2luY2x1ZGUgImV4ZWMuaCIKICNpbmNsdWRl ICJyZWNvcmQuaCIKIAorI2luY2x1ZGUgPGJ5dGVzd2FwLmg+CiAjaW5jbHVk ZSA8c2lnbmFsLmg+CisjaW5jbHVkZSA8bmV0aW5ldC9pbi5oPgogCiAjZGVm aW5lIERFRkFVTFRfUkVDT1JEX0lOU05fTUFYX05VTQkyMDAwMDAKIAogI2Rl ZmluZSBSRUNPUkRfSVNfUkVQTEFZIFwKLSAgICAgKHJlY29yZF9saXN0LT5u ZXh0IHx8IGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQor ICAgICAocmVjb3JkX2xpc3QtPm5leHQgfHwgZXhlY3V0aW9uX2RpcmVjdGlv biA9PSBFWEVDX1JFVkVSU0UgfHwgcmVjb3JkX2NvcmUpCisKKyNkZWZpbmUg UkVDT1JEX0ZJTEVfTUFHSUMJaHRvbmwoMHgyMDA5MDcyNikKIAogLyogVGhl c2UgYXJlIHRoZSBjb3JlIHN0cnVjdCBvZiByZWNvcmQgZnVuY3Rpb24uCiAK QEAgLTUxLDYgKzU5LDcgQEAgc3RydWN0IHJlY29yZF9tZW1fZW50cnkKIHsK ICAgQ09SRV9BRERSIGFkZHI7CiAgIGludCBsZW47CisgIGludCBtZW1fZW50 cnlfbm90X2FjY2Vzc2libGU7CiAgIGdkYl9ieXRlICp2YWw7CiB9OwogCkBA IC03NSw5ICs4NCwyMyBAQCBzdHJ1Y3QgcmVjb3JkX2VudHJ5CiAgIH0gdTsK IH07CiAKK3N0cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkKK3sKKyAgc3Ry dWN0IHJlY29yZF9jb3JlX2J1Zl9lbnRyeSAqcHJldjsKKyAgc3RydWN0IHRh cmdldF9zZWN0aW9uICpwOworICBiZmRfYnl0ZSAqYnVmOworfTsKKwogLyog VGhpcyBpcyB0aGUgZGVidWcgc3dpdGNoIGZvciBwcm9jZXNzIHJlY29yZC4g ICovCiBpbnQgcmVjb3JkX2RlYnVnID0gMDsKIAorLyogUmVjb3JkIHdpdGgg Y29yZSB0YXJnZXQuICAqLworc3RhdGljIGludCByZWNvcmRfY29yZSA9IDA7 CitzdGF0aWMgZ2RiX2J5dGUgKnJlY29yZF9jb3JlX3JlZ2J1ZjsKK3N0YXRp YyBzdHJ1Y3QgdGFyZ2V0X3NlY3Rpb24gKnJlY29yZF9jb3JlX3N0YXJ0Owor c3RhdGljIHN0cnVjdCB0YXJnZXRfc2VjdGlvbiAqcmVjb3JkX2NvcmVfZW5k Oworc3RhdGljIHN0cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkgKnJlY29y ZF9jb3JlX2J1Zl9saXN0ID0gTlVMTDsKKwogLyogVGhlc2UgbGlzdCBpcyBm b3IgZXhlY3V0aW9uIGxvZy4gICovCiBzdGF0aWMgc3RydWN0IHJlY29yZF9l bnRyeSByZWNvcmRfZmlyc3Q7CiBzdGF0aWMgc3RydWN0IHJlY29yZF9lbnRy eSAqcmVjb3JkX2xpc3QgPSAmcmVjb3JkX2ZpcnN0OwpAQCAtMTAwLDYgKzEy MywxNCBAQCBzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5l YXRoCiBzdGF0aWMgcHRpZF90ICgqcmVjb3JkX2JlbmVhdGhfdG9fd2FpdCkg KHN0cnVjdCB0YXJnZXRfb3BzICosIHB0aWRfdCwKIAkJCQkJIHN0cnVjdCB0 YXJnZXRfd2FpdHN0YXR1cyAqLAogCQkJCQkgaW50KTsKK3N0YXRpYyBzdHJ1 Y3QgdGFyZ2V0X29wcyAqcmVjb3JkX2JlbmVhdGhfdG9fZmV0Y2hfcmVnaXN0 ZXJzX29wczsKK3N0YXRpYyB2b2lkICgqcmVjb3JkX2JlbmVhdGhfdG9fZmV0 Y2hfcmVnaXN0ZXJzKSAoc3RydWN0IHRhcmdldF9vcHMgKiwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3Ry dWN0IHJlZ2NhY2hlICosCisJCQkJCQkgIGludCByZWdubyk7CitzdGF0aWMg c3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3Jl Z2lzdGVyc19vcHM7CitzdGF0aWMgdm9pZCAoKnJlY29yZF9iZW5lYXRoX3Rv X3N0b3JlX3JlZ2lzdGVycykgKHN0cnVjdCB0YXJnZXRfb3BzICosCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IHN0cnVjdCByZWdjYWNoZSAqLAorCQkJCQkJICBpbnQgcmVnbm8pOwogc3Rh dGljIHN0cnVjdCB0YXJnZXRfb3BzICpyZWNvcmRfYmVuZWF0aF90b19zdG9y ZV9yZWdpc3RlcnNfb3BzOwogc3RhdGljIHZvaWQgKCpyZWNvcmRfYmVuZWF0 aF90b19zdG9yZV9yZWdpc3RlcnMpIChzdHJ1Y3QgdGFyZ2V0X29wcyAqLAog ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBzdHJ1Y3QgcmVnY2FjaGUgKiwKQEAgLTExNiw2ICsxNDcsOSBAQCBz dGF0aWMgaW50ICgqcmVjb3JkX2JlbmVhdGhfdG9faW5zZXJ0X2JyCiAJCQkJ CQkgICBzdHJ1Y3QgYnBfdGFyZ2V0X2luZm8gKik7CiBzdGF0aWMgaW50ICgq cmVjb3JkX2JlbmVhdGhfdG9fcmVtb3ZlX2JyZWFrcG9pbnQpIChzdHJ1Y3Qg Z2RiYXJjaCAqLAogCQkJCQkJICAgc3RydWN0IGJwX3RhcmdldF9pbmZvICop Oworc3RhdGljIHN0cnVjdCB0YXJnZXRfb3BzICpyZWNvcmRfYmVuZWF0aF90 b19oYXNfZXhlY3V0aW9uX29wczsKK3N0YXRpYyBpbnQgKCpyZWNvcmRfYmVu ZWF0aF90b19oYXNfZXhlY3V0aW9uKSAoc3RydWN0IHRhcmdldF9vcHMgKm9w cyk7CitzdGF0aWMgdm9pZCAoKnJlY29yZF9iZW5lYXRoX3RvX3ByZXBhcmVf dG9fc3RvcmUpIChzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlKTsKIAogc3Rh dGljIHZvaWQKIHJlY29yZF9saXN0X3JlbGVhc2UgKHN0cnVjdCByZWNvcmRf ZW50cnkgKnJlYykKQEAgLTE2Niw3ICsyMDAsNyBAQCByZWNvcmRfbGlzdF9y ZWxlYXNlX25leHQgKHZvaWQpCiB9CiAKIHN0YXRpYyB2b2lkCi1yZWNvcmRf bGlzdF9yZWxlYXNlX2ZpcnN0ICh2b2lkKQorcmVjb3JkX2xpc3RfcmVsZWFz ZV9maXJzdF9pbnNuICh2b2lkKQogewogICBzdHJ1Y3QgcmVjb3JkX2VudHJ5 ICp0bXAgPSBOVUxMOwogICBlbnVtIHJlY29yZF90eXBlIHR5cGU7CkBAIC0y NzUsNiArMzA5LDcgQEAgcmVjb3JkX2FyY2hfbGlzdF9hZGRfbWVtIChDT1JF X0FERFIgYWRkcgogICByZWMtPnR5cGUgPSByZWNvcmRfbWVtOwogICByZWMt PnUubWVtLmFkZHIgPSBhZGRyOwogICByZWMtPnUubWVtLmxlbiA9IGxlbjsK KyAgcmVjLT51Lm1lbS5tZW1fZW50cnlfbm90X2FjY2Vzc2libGUgPSAwOwog CiAgIGlmICh0YXJnZXRfcmVhZF9tZW1vcnkgKGFkZHIsIHJlYy0+dS5tZW0u dmFsLCBsZW4pKQogICAgIHsKQEAgLTMzNiwzMCArMzcxLDMwIEBAIHJlY29y ZF9jaGVja19pbnNuX251bSAoaW50IHNldF90ZXJtaW5hbCkKIAkgICAgICBp ZiAocSkKIAkJcmVjb3JkX3N0b3BfYXRfbGltaXQgPSAwOwogCSAgICAgIGVs c2UKLQkJZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBpbmZlcmlvciBwcm9n cmFtIHN0b3BwZWQuIikpOworCQllcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6 IHN0b3BlZCBieSB1c2VyLiIpKTsKIAkgICAgfQogCX0KICAgICB9CiB9CiAK K3N0YXRpYyB2b2lkCityZWNvcmRfYXJjaF9saXN0X2NsZWFudXBzICh2b2lk ICppZ25vcmUpCit7CisgIHJlY29yZF9saXN0X3JlbGVhc2UgKHJlY29yZF9h cmNoX2xpc3RfdGFpbCk7Cit9CisKIC8qIEJlZm9yZSBpbmZlcmlvciBzdGVw ICh3aGVuIEdEQiByZWNvcmQgdGhlIHJ1bm5pbmcgbWVzc2FnZSwgaW5mZXJp b3IKICAgIG9ubHkgY2FuIHN0ZXApLCBHREIgd2lsbCBjYWxsIHRoaXMgZnVu Y3Rpb24gdG8gcmVjb3JkIHRoZSB2YWx1ZXMgdG8KICAgIHJlY29yZF9saXN0 LiAgVGhpcyBmdW5jdGlvbiB3aWxsIGNhbGwgZ2RiYXJjaF9wcm9jZXNzX3Jl Y29yZCB0bwogICAgcmVjb3JkIHRoZSBydW5uaW5nIG1lc3NhZ2Ugb2YgaW5m ZXJpb3IgYW5kIHNldCB0aGVtIHRvCiAgICByZWNvcmRfYXJjaF9saXN0LCBh bmQgYWRkIGl0IHRvIHJlY29yZF9saXN0LiAgKi8KIAotc3RhdGljIHZvaWQK LXJlY29yZF9tZXNzYWdlX2NsZWFudXBzICh2b2lkICppZ25vcmUpCi17Ci0g IHJlY29yZF9saXN0X3JlbGVhc2UgKHJlY29yZF9hcmNoX2xpc3RfdGFpbCk7 Ci19Ci0KIHN0YXRpYyBpbnQKIHJlY29yZF9tZXNzYWdlICh2b2lkICphcmdz KQogewogICBpbnQgcmV0OwogICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hl ID0gYXJnczsKLSAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwcyA9IG1h a2VfY2xlYW51cCAocmVjb3JkX21lc3NhZ2VfY2xlYW51cHMsIDApOworICBz dHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzID0gbWFrZV9jbGVhbnVwIChy ZWNvcmRfYXJjaF9saXN0X2NsZWFudXBzLCAwKTsKIAogICByZWNvcmRfYXJj aF9saXN0X2hlYWQgPSBOVUxMOwogICByZWNvcmRfYXJjaF9saXN0X3RhaWwg PSBOVUxMOwpAQCAtMzgyLDcgKzQxNyw3IEBAIHJlY29yZF9tZXNzYWdlICh2 b2lkICphcmdzKQogICByZWNvcmRfbGlzdCA9IHJlY29yZF9hcmNoX2xpc3Rf dGFpbDsKIAogICBpZiAocmVjb3JkX2luc25fbnVtID09IHJlY29yZF9pbnNu X21heF9udW0gJiYgcmVjb3JkX2luc25fbWF4X251bSkKLSAgICByZWNvcmRf bGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworICAgIHJlY29yZF9saXN0X3JlbGVh c2VfZmlyc3RfaW5zbiAoKTsKICAgZWxzZQogICAgIHJlY29yZF9pbnNuX251 bSsrOwogCkBAIC00MTIsNiArNDQ3LDkyIEBAIHJlY29yZF9nZGJfb3BlcmF0 aW9uX2Rpc2FibGVfc2V0ICh2b2lkKQogICByZXR1cm4gb2xkX2NsZWFudXBz OwogfQogCitzdGF0aWMgaW5saW5lIHZvaWQKK3JlY29yZF9leGVjX2VudHJ5 IChzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLCBzdHJ1Y3QgZ2RiYXJjaCAq Z2RiYXJjaCwKKyAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgcmVjb3JkX2Vu dHJ5ICplbnRyeSkKK3sKKyAgc3dpdGNoIChlbnRyeS0+dHlwZSkKKyAgICB7 CisgICAgY2FzZSByZWNvcmRfcmVnOiAvKiByZWcgKi8KKyAgICAgIHsKKyAg ICAgICAgZ2RiX2J5dGUgcmVnW01BWF9SRUdJU1RFUl9TSVpFXTsKKworICAg ICAgICBpZiAocmVjb3JkX2RlYnVnID4gMSkKKyAgICAgICAgICBmcHJpbnRm X3VuZmlsdGVyZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAiUHJvY2VzcyByZWNvcmQ6IHJlY29yZF9yZWcgJXMgdG8g IgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImluZmVyaW9yIG51 bSA9ICVkLlxuIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhv c3RfYWRkcmVzc190b19zdHJpbmcgKGVudHJ5KSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIGVudHJ5LT51LnJlZy5udW0pOworCisgICAgICAg IHJlZ2NhY2hlX2Nvb2tlZF9yZWFkIChyZWdjYWNoZSwgZW50cnktPnUucmVn Lm51bSwgcmVnKTsKKyAgICAgICAgcmVnY2FjaGVfY29va2VkX3dyaXRlIChy ZWdjYWNoZSwgZW50cnktPnUucmVnLm51bSwgZW50cnktPnUucmVnLnZhbCk7 CisgICAgICAgIG1lbWNweSAoZW50cnktPnUucmVnLnZhbCwgcmVnLCBNQVhf UkVHSVNURVJfU0laRSk7CisgICAgICB9CisgICAgICBicmVhazsKKyAgICBj YXNlIHJlY29yZF9tZW06IC8qIG1lbSAqLworICAgICAgeworICAgICAgICBp ZiAocmVjb3JkX2xpc3QtPnUubWVtLm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJs ZSkKKyAgICAgICAgICByZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2VudHJ5X25v dF9hY2Nlc3NpYmxlID0gMDsKKyAgICAgICAgZWxzZQorICAgICAgICAgIHsK KyAgICAgICAgICAgIGdkYl9ieXRlICptZW0gPSBhbGxvY2EgKGVudHJ5LT51 Lm1lbS5sZW4pOworCisgICAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnID4g MSkKKyAgICAgICAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3Rk bG9nLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJQcm9j ZXNzIHJlY29yZDogcmVjb3JkX21lbSAlcyB0byAiCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgImluZmVyaW9yIGFkZHIgPSAlcyBsZW4g PSAlZC5cbiIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg aG9zdF9hZGRyZXNzX3RvX3N0cmluZyAoZW50cnkpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRy eS0+dS5tZW0uYWRkciksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7CisKKyAgICAgICAgICAg IGlmICh0YXJnZXRfcmVhZF9tZW1vcnkgKGVudHJ5LT51Lm1lbS5hZGRyLCBt ZW0sIGVudHJ5LT51Lm1lbS5sZW4pKQorICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgaWYgKChleGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNf UkVWRVJTRSAmJiAhcmVjb3JkX2NvcmUpCisgICAgICAgICAgICAgICAgICAg IHx8IChleGVjdXRpb25fZGlyZWN0aW9uICE9IEVYRUNfUkVWRVJTRSAmJiBy ZWNvcmRfY29yZSkpCisgICAgICAgICAgICAgICAgICB7CisgICAgICAgICAg ICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50cnlfbm90X2Fj Y2Vzc2libGUgPSAxOworICAgICAgICAgICAgICAgICAgICBpZiAocmVjb3Jk X2RlYnVnKQorICAgICAgICAgICAgICAgICAgICAgIHdhcm5pbmcgKF8oIlBy b2Nlc3MgcmVjb3JkOiBlcnJvciByZWFkaW5nIG1lbW9yeSBhdCAiCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiYWRkciA9ICVzIGxlbiA9 ICVkLiIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhZGRy ZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgZW50cnktPnUubWVtLmxlbik7CisgICAg ICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgZWxzZQorICAgICAg ICAgICAgICAgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBlcnJvciBy ZWFkaW5nIG1lbW9yeSBhdCAiCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAorICAgICAgICAgICAgICAgICAg ICAgICAgIHBhZGRyZXNzIChnZGJhcmNoLCBlbnRyeS0+dS5tZW0uYWRkciks CisgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+dS5tZW0ubGVuKTsK KyAgICAgICAgICAgICAgfQorICAgICAgICAgICAgZWxzZQorICAgICAgICAg ICAgICB7CisgICAgICAgICAgICAgICAgaWYgKHRhcmdldF93cml0ZV9tZW1v cnkgKGVudHJ5LT51Lm1lbS5hZGRyLCBlbnRyeS0+dS5tZW0udmFsLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRyeS0+ dS5tZW0ubGVuKSkKKyAgICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAg ICAgICAgICAgaWYgKChleGVjdXRpb25fZGlyZWN0aW9uID09IEVYRUNfUkVW RVJTRSAmJiAhcmVjb3JkX2NvcmUpCisgICAgICAgICAgICAgICAgICAgICAg ICB8fCAoZXhlY3V0aW9uX2RpcmVjdGlvbiAhPSBFWEVDX1JFVkVSU0UgJiYg cmVjb3JkX2NvcmUpKQorICAgICAgICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgICAgICAgIHJlY29yZF9saXN0LT51Lm1lbS5tZW1fZW50 cnlfbm90X2FjY2Vzc2libGUgPSAxOworICAgICAgICAgICAgICAgICAgICAg ICAgaWYgKHJlY29yZF9kZWJ1ZykKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgd2FybmluZyAoXygiUHJvY2VzcyByZWNvcmQ6IGVycm9yIHdyaXRpbmcg bWVtb3J5IGF0ICIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwgZW50cnkt PnUubWVtLmFkZHIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBlbnRyeS0+dS5tZW0ubGVuKTsKKyAgICAgICAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICAgICAgICAgIGVsc2UKKyAgICAgICAgICAgICAg ICAgICAgICBlcnJvciAoXygiUHJvY2VzcyByZWNvcmQ6IGVycm9yIHdyaXRp bmcgbWVtb3J5IGF0ICIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAiYWRkciA9ICVzIGxlbiA9ICVkLiIpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBwYWRkcmVzcyAoZ2RiYXJjaCwgZW50cnktPnUubWVtLmFk ZHIpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5LT51Lm1l bS5sZW4pOworICAgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICB9 CisKKyAgICAgICAgICAgIG1lbWNweSAoZW50cnktPnUubWVtLnZhbCwgbWVt LCBlbnRyeS0+dS5tZW0ubGVuKTsKKyAgICAgICAgICB9CisgICAgICB9Cisg ICAgICBicmVhazsKKyAgICB9Cit9CisKIHN0YXRpYyB2b2lkCiByZWNvcmRf b3BlbiAoY2hhciAqbmFtZSwgaW50IGZyb21fdHR5KQogewpAQCAtNDIwLDgg KzU0MSwxMyBAQCByZWNvcmRfb3BlbiAoY2hhciAqbmFtZSwgaW50IGZyb21f dHR5KQogICBpZiAocmVjb3JkX2RlYnVnKQogICAgIGZwcmludGZfdW5maWx0 ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRfb3Bl blxuIik7CiAKKyAgaWYgKCFzdHJjbXAgKGN1cnJlbnRfdGFyZ2V0LnRvX3No b3J0bmFtZSwgImNvcmUiKSkKKyAgICByZWNvcmRfY29yZSA9IDE7CisgIGVs c2UKKyAgICByZWNvcmRfY29yZSA9IDA7CisKICAgLyogY2hlY2sgZXhlYyAq LwotICBpZiAoIXRhcmdldF9oYXNfZXhlY3V0aW9uKQorICBpZiAoIXRhcmdl dF9oYXNfZXhlY3V0aW9uICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJvciAo XygiUHJvY2VzcyByZWNvcmQ6IHRoZSBwcm9ncmFtIGlzIG5vdCBiZWluZyBy dW4uIikpOwogICBpZiAobm9uX3N0b3ApCiAgICAgZXJyb3IgKF8oIlByb2Nl c3MgcmVjb3JkIHRhcmdldCBjYW4ndCBkZWJ1ZyBpbmZlcmlvciBpbiBub24t c3RvcCBtb2RlICIKQEAgLTQ1MCw2ICs1NzYsOCBAQCByZWNvcmRfb3BlbiAo Y2hhciAqbmFtZSwgaW50IGZyb21fdHR5KQogICByZWNvcmRfYmVuZWF0aF90 b194ZmVyX3BhcnRpYWwgPSBOVUxMOwogICByZWNvcmRfYmVuZWF0aF90b19p bnNlcnRfYnJlYWtwb2ludCA9IE5VTEw7CiAgIHJlY29yZF9iZW5lYXRoX3Rv X3JlbW92ZV9icmVha3BvaW50ID0gTlVMTDsKKyAgcmVjb3JkX2JlbmVhdGhf dG9faGFzX2V4ZWN1dGlvbiA9IE5VTEw7CisgIHJlY29yZF9iZW5lYXRoX3Rv X3ByZXBhcmVfdG9fc3RvcmUgPSBOVUxMOwogCiAgIC8qIFNldCB0aGUgYmVu ZWF0aCBmdW5jdGlvbiBwb2ludGVycy4gICovCiAgIGZvciAodCA9IGN1cnJl bnRfdGFyZ2V0LmJlbmVhdGg7IHQgIT0gTlVMTDsgdCA9IHQtPmJlbmVhdGgp CkBAIC00NjQsNiArNTkyLDExIEBAIHJlY29yZF9vcGVuIChjaGFyICpuYW1l LCBpbnQgZnJvbV90dHkpCiAJICByZWNvcmRfYmVuZWF0aF90b193YWl0ID0g dC0+dG9fd2FpdDsKIAkgIHJlY29yZF9iZW5lYXRoX3RvX3dhaXRfb3BzID0g dDsKICAgICAgICAgfQorICAgICAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19m ZXRjaF9yZWdpc3RlcnMpCisgICAgICAgIHsKKwkgIHJlY29yZF9iZW5lYXRo X3RvX2ZldGNoX3JlZ2lzdGVycyA9IHQtPnRvX2ZldGNoX3JlZ2lzdGVyczsK KwkgIHJlY29yZF9iZW5lYXRoX3RvX2ZldGNoX3JlZ2lzdGVyc19vcHMgPSB0 OworICAgICAgICB9CiAgICAgICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3N0 b3JlX3JlZ2lzdGVycykKICAgICAgICAgewogCSAgcmVjb3JkX2JlbmVhdGhf dG9fc3RvcmVfcmVnaXN0ZXJzID0gdC0+dG9fc3RvcmVfcmVnaXN0ZXJzOwpA QCAtNDc4LDE5ICs2MTEsNTEgQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUs IGludCBmcm9tX3R0eSkKIAlyZWNvcmRfYmVuZWF0aF90b19pbnNlcnRfYnJl YWtwb2ludCA9IHQtPnRvX2luc2VydF9icmVha3BvaW50OwogICAgICAgaWYg KCFyZWNvcmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2ludCkKIAlyZWNv cmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2ludCA9IHQtPnRvX3JlbW92 ZV9icmVha3BvaW50OworICAgICAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19o YXNfZXhlY3V0aW9uKQorICAgICAgICB7CisgICAgICAgICAgcmVjb3JkX2Jl bmVhdGhfdG9faGFzX2V4ZWN1dGlvbl9vcHMgPSB0OworCSAgcmVjb3JkX2Jl bmVhdGhfdG9faGFzX2V4ZWN1dGlvbiA9IHQtPnRvX2hhc19leGVjdXRpb247 CisgICAgICAgIH0KKyAgICAgIGlmICghcmVjb3JkX2JlbmVhdGhfdG9fcHJl cGFyZV90b19zdG9yZSkKKwlyZWNvcmRfYmVuZWF0aF90b19wcmVwYXJlX3Rv X3N0b3JlID0gdC0+dG9fcHJlcGFyZV90b19zdG9yZTsKICAgICB9Ci0gIGlm ICghcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1lKQorICBpZiAoIXJlY29yZF9i ZW5lYXRoX3RvX3Jlc3VtZSAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJyb3Ig KF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b19yZXN1bWUuIikpOwot ICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX3dhaXQpCisgIGlmICghcmVjb3Jk X2JlbmVhdGhfdG9fd2FpdCAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJyb3Ig KF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b193YWl0LiIpKTsKLSAg aWYgKCFyZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMpCisgIGlm ICghcmVjb3JkX2JlbmVhdGhfdG9fZmV0Y2hfcmVnaXN0ZXJzKQorICAgIGVy cm9yIChfKCJQcm9jZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fZmV0Y2hfcmVn aXN0ZXJzLiIpKTsKKyAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19zdG9yZV9y ZWdpc3RlcnMgJiYgIXJlY29yZF9jb3JlKQogICAgIGVycm9yIChfKCJQcm9j ZXNzIHJlY29yZCBjYW4ndCBnZXQgdG9fc3RvcmVfcmVnaXN0ZXJzLiIpKTsK ICAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWwpCiAgICAg ZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdldCB0b194ZmVyX3Bh cnRpYWwuIikpOwotICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9i cmVha3BvaW50KQorICBpZiAoIXJlY29yZF9iZW5lYXRoX3RvX2luc2VydF9i cmVha3BvaW50ICYmICFyZWNvcmRfY29yZSkKICAgICBlcnJvciAoXygiUHJv Y2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX2luc2VydF9icmVha3BvaW50LiIp KTsKLSAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2lu dCkKKyAgaWYgKCFyZWNvcmRfYmVuZWF0aF90b19yZW1vdmVfYnJlYWtwb2lu dCAmJiAhcmVjb3JkX2NvcmUpCiAgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVj b3JkIGNhbid0IGdldCB0b19yZW1vdmVfYnJlYWtwb2ludC4iKSk7CisgIGlm ICghcmVjb3JkX2JlbmVhdGhfdG9faGFzX2V4ZWN1dGlvbiAmJiAhcmVjb3Jk X2NvcmUpCisgICAgZXJyb3IgKF8oIlByb2Nlc3MgcmVjb3JkIGNhbid0IGdl dCB0b19oYXNfZXhlY3V0aW9uLiIpKTsKKyAgaWYgKCFyZWNvcmRfYmVuZWF0 aF90b19wcmVwYXJlX3RvX3N0b3JlICYmICFyZWNvcmRfY29yZSkKKyAgICBl cnJvciAoXygiUHJvY2VzcyByZWNvcmQgY2FuJ3QgZ2V0IHRvX3ByZXBhcmVf dG9fc3RvcmUuIikpOworCisgIGlmIChyZWNvcmRfY29yZSkKKyAgICB7Cisg ICAgICAvKiBHZXQgcmVjb3JkX2NvcmVfcmVnYnVmLiAgKi8KKyAgICAgIHN0 cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUgPSBnZXRfY3VycmVudF9yZWdjYWNo ZSAoKTsKKyAgICAgIGludCByZWdudW0gPSBnZGJhcmNoX251bV9yZWdzIChn ZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpKTsKKyAgICAgIGludCBpOwor CisgICAgICB0YXJnZXRfZmV0Y2hfcmVnaXN0ZXJzIChyZWdjYWNoZSwgLTEp OworICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmID0geG1hbGxvYyAoTUFYX1JF R0lTVEVSX1NJWkUgKiByZWdudW0pOworICAgICAgZm9yIChpID0gMDsgaSA8 IHJlZ251bTsgaSArKykKKyAgICAgICAgcmVnY2FjaGVfcmF3X2NvbGxlY3Qg KHJlZ2NhY2hlLCBpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JFR0lTVEVSX1NJWkUgKiBpKTsK KworICAgICAgLyogR2V0IHJlY29yZF9jb3JlX3N0YXJ0IGFuZCByZWNvcmRf Y29yZV9lbmQuICAqLworICAgICAgaWYgKGJ1aWxkX3NlY3Rpb25fdGFibGUg KGNvcmVfYmZkLCAmcmVjb3JkX2NvcmVfc3RhcnQsICZyZWNvcmRfY29yZV9l bmQpKQorICAgICAgICBlcnJvciAoXygiXCIlc1wiOiBDYW4ndCBmaW5kIHNl Y3Rpb25zOiAlcyIpLAorICAgICAgICAgICAgICAgYmZkX2dldF9maWxlbmFt ZSAoY29yZV9iZmQpLCBiZmRfZXJybXNnIChiZmRfZ2V0X2Vycm9yICgpKSk7 CisgICAgfQogCiAgIHB1c2hfdGFyZ2V0ICgmcmVjb3JkX29wcyk7CiAKQEAg LTUwMywxMCArNjY4LDI2IEBAIHJlY29yZF9vcGVuIChjaGFyICpuYW1lLCBp bnQgZnJvbV90dHkpCiBzdGF0aWMgdm9pZAogcmVjb3JkX2Nsb3NlIChpbnQg cXVpdHRpbmcpCiB7CisgIHN0cnVjdCByZWNvcmRfY29yZV9idWZfZW50cnkg KmVudHJ5OworCiAgIGlmIChyZWNvcmRfZGVidWcpCiAgICAgZnByaW50Zl91 bmZpbHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IHJlY29y ZF9jbG9zZVxuIik7CiAKICAgcmVjb3JkX2xpc3RfcmVsZWFzZSAocmVjb3Jk X2xpc3QpOworCisgIC8qIFJlbGVhc2UgcmVjb3JkX2NvcmVfcmVnYnVmLiAg Ki8KKyAgeGZyZWUgKHJlY29yZF9jb3JlX3JlZ2J1Zik7CisKKyAgLyogUmVs ZWFzZSByZWNvcmRfY29yZV9idWZfbGlzdC4gICovCisgIGlmIChyZWNvcmRf Y29yZV9idWZfbGlzdCkKKyAgICB7CisgICAgICBmb3IgKGVudHJ5ID0gcmVj b3JkX2NvcmVfYnVmX2xpc3QtPnByZXY7IGVudHJ5OyBlbnRyeSA9IGVudHJ5 LT5wcmV2KQorICAgICAgICB7CisgICAgICAgICAgeGZyZWUgKHJlY29yZF9j b3JlX2J1Zl9saXN0KTsKKyAgICAgICAgICByZWNvcmRfY29yZV9idWZfbGlz dCA9IGVudHJ5OworICAgICAgICB9CisgICAgICByZWNvcmRfY29yZV9idWZf bGlzdCA9IE5VTEw7CisgICAgfQogfQogCiBzdGF0aWMgaW50IHJlY29yZF9y ZXN1bWVfc3RlcCA9IDA7CkBAIC03MDgsNTMgKzg4OSw5IEBAIHJlY29yZF93 YWl0IChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAogCSAgICAgIGJyZWFrOwog CSAgICB9CiAKLQkgIC8qIFNldCBwdGlkLCByZWdpc3RlciBhbmQgbWVtb3J5 IGFjY29yZGluZyB0byByZWNvcmRfbGlzdC4gICovCi0JICBpZiAocmVjb3Jk X2xpc3QtPnR5cGUgPT0gcmVjb3JkX3JlZykKLQkgICAgewotCSAgICAgIC8q IHJlZyAqLwotCSAgICAgIGdkYl9ieXRlIHJlZ1tNQVhfUkVHSVNURVJfU0la RV07Ci0JICAgICAgaWYgKHJlY29yZF9kZWJ1ZyA+IDEpCi0JCWZwcmludGZf dW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKLQkJCQkgICAgIlByb2Nlc3MgcmVj b3JkOiByZWNvcmRfcmVnICVzIHRvICIKLQkJCQkgICAgImluZmVyaW9yIG51 bSA9ICVkLlxuIiwKLQkJCQkgICAgaG9zdF9hZGRyZXNzX3RvX3N0cmluZyAo cmVjb3JkX2xpc3QpLAotCQkJCSAgICByZWNvcmRfbGlzdC0+dS5yZWcubnVt KTsKLQkgICAgICByZWdjYWNoZV9jb29rZWRfcmVhZCAocmVnY2FjaGUsIHJl Y29yZF9saXN0LT51LnJlZy5udW0sIHJlZyk7Ci0JICAgICAgcmVnY2FjaGVf Y29va2VkX3dyaXRlIChyZWdjYWNoZSwgcmVjb3JkX2xpc3QtPnUucmVnLm51 bSwKLQkJCQkgICAgIHJlY29yZF9saXN0LT51LnJlZy52YWwpOwotCSAgICAg IG1lbWNweSAocmVjb3JkX2xpc3QtPnUucmVnLnZhbCwgcmVnLCBNQVhfUkVH SVNURVJfU0laRSk7Ci0JICAgIH0KLQkgIGVsc2UgaWYgKHJlY29yZF9saXN0 LT50eXBlID09IHJlY29yZF9tZW0pCi0JICAgIHsKLQkgICAgICAvKiBtZW0g Ki8KLQkgICAgICBnZGJfYnl0ZSAqbWVtID0gYWxsb2NhIChyZWNvcmRfbGlz dC0+dS5tZW0ubGVuKTsKLQkgICAgICBpZiAocmVjb3JkX2RlYnVnID4gMSkK LQkJZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLAotCQkJCSAgICAi UHJvY2VzcyByZWNvcmQ6IHJlY29yZF9tZW0gJXMgdG8gIgotCQkJCSAgICAi aW5mZXJpb3IgYWRkciA9ICVzIGxlbiA9ICVkLlxuIiwKLQkJCQkgICAgaG9z dF9hZGRyZXNzX3RvX3N0cmluZyAocmVjb3JkX2xpc3QpLAotCQkJCSAgICBw YWRkcmVzcyAoZ2RiYXJjaCwgcmVjb3JkX2xpc3QtPnUubWVtLmFkZHIpLAot CQkJCSAgICByZWNvcmRfbGlzdC0+dS5tZW0ubGVuKTsKLQotCSAgICAgIGlm ICh0YXJnZXRfcmVhZF9tZW1vcnkKLQkJICAocmVjb3JkX2xpc3QtPnUubWVt LmFkZHIsIG1lbSwgcmVjb3JkX2xpc3QtPnUubWVtLmxlbikpCi0JCWVycm9y IChfKCJQcm9jZXNzIHJlY29yZDogZXJyb3IgcmVhZGluZyBtZW1vcnkgYXQg IgotCQkJICJhZGRyID0gJXMgbGVuID0gJWQuIiksCi0JCSAgICAgICBwYWRk cmVzcyAoZ2RiYXJjaCwgcmVjb3JkX2xpc3QtPnUubWVtLmFkZHIpLAotCQkg ICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbik7Ci0KLQkgICAgICBpZiAo dGFyZ2V0X3dyaXRlX21lbW9yeQotCQkgIChyZWNvcmRfbGlzdC0+dS5tZW0u YWRkciwgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwKLQkJICAgcmVjb3JkX2xp c3QtPnUubWVtLmxlbikpCi0JCWVycm9yIChfCi0JCSAgICAgICAoIlByb2Nl c3MgcmVjb3JkOiBlcnJvciB3cml0aW5nIG1lbW9yeSBhdCAiCi0JCQkiYWRk ciA9ICVzIGxlbiA9ICVkLiIpLAotCQkgICAgICAgcGFkZHJlc3MgKGdkYmFy Y2gsIHJlY29yZF9saXN0LT51Lm1lbS5hZGRyKSwKLQkJICAgICAgIHJlY29y ZF9saXN0LT51Lm1lbS5sZW4pOworICAgICAgICAgIHJlY29yZF9leGVjX2Vu dHJ5IChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOwogCi0JICAg ICAgbWVtY3B5IChyZWNvcmRfbGlzdC0+dS5tZW0udmFsLCBtZW0sIHJlY29y ZF9saXN0LT51Lm1lbS5sZW4pOwotCSAgICB9Ci0JICBlbHNlCisJICBpZiAo cmVjb3JkX2xpc3QtPnR5cGUgPT0gcmVjb3JkX2VuZCkKIAkgICAgewogCSAg ICAgIGlmIChyZWNvcmRfZGVidWcgPiAxKQogCQlmcHJpbnRmX3VuZmlsdGVy ZWQgKGdkYl9zdGRsb2csCkBAIC04NzQsNyArMTAxMSw5IEBAIHJlY29yZF9r aWxsIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzKQogICAgIGZwcmludGZfdW5m aWx0ZXJlZCAoZ2RiX3N0ZGxvZywgIlByb2Nlc3MgcmVjb3JkOiByZWNvcmRf a2lsbFxuIik7CiAKICAgdW5wdXNoX3RhcmdldCAoJnJlY29yZF9vcHMpOwot ICB0YXJnZXRfa2lsbCAoKTsKKworICBpZiAoIXJlY29yZF9jb3JlKQorICAg IHRhcmdldF9raWxsICgpOwogfQogCiAvKiBSZWNvcmQgcmVnaXN0ZXJzIGNo YW5nZSAoYnkgdXNlciBvciBieSBHREIpIHRvIGxpc3QgYXMgYW4gaW5zdHJ1 Y3Rpb24uICAqLwpAQCAtOTE4LDE1ICsxMDU3LDU4IEBAIHJlY29yZF9yZWdp c3RlcnNfY2hhbmdlIChzdHJ1Y3QgcmVnY2FjaGUKICAgcmVjb3JkX2xpc3Qg PSByZWNvcmRfYXJjaF9saXN0X3RhaWw7CiAKICAgaWYgKHJlY29yZF9pbnNu X251bSA9PSByZWNvcmRfaW5zbl9tYXhfbnVtICYmIHJlY29yZF9pbnNuX21h eF9udW0pCi0gICAgcmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdCAoKTsKKyAg ICByZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0X2luc24gKCk7CiAgIGVsc2UK ICAgICByZWNvcmRfaW5zbl9udW0rKzsKIH0KIAogc3RhdGljIHZvaWQKK3Jl Y29yZF9mZXRjaF9yZWdpc3RlcnMgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMs IHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsCisgICAgICAgICAgICAgICAg ICAgICAgICBpbnQgcmVnbm8pCit7CisgIGlmIChyZWNvcmRfY29yZSkKKyAg ICB7CisgICAgICBpZiAocmVnbm8gPCAwKQorICAgICAgICB7CisgICAgICAg ICAgaW50IG51bSA9IGdkYmFyY2hfbnVtX3JlZ3MgKGdldF9yZWdjYWNoZV9h cmNoIChyZWdjYWNoZSkpOworICAgICAgICAgIGludCBpOworCisgICAgICAg ICAgZm9yIChpID0gMDsgaSA8IG51bTsgaSArKykKKyAgICAgICAgICAgIHJl Z2NhY2hlX3Jhd19zdXBwbHkgKHJlZ2NhY2hlLCBpLAorICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFY X1JFR0lTVEVSX1NJWkUgKiBpKTsKKyAgICAgICAgfQorICAgICAgZWxzZQor ICAgICAgICByZWdjYWNoZV9yYXdfc3VwcGx5IChyZWdjYWNoZSwgcmVnbm8s CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlY29yZF9jb3JlX3Jl Z2J1ZiArIE1BWF9SRUdJU1RFUl9TSVpFICogcmVnbm8pOworICAgIH0KKyAg ZWxzZQorICAgIHJlY29yZF9iZW5lYXRoX3RvX2ZldGNoX3JlZ2lzdGVycyAo cmVjb3JkX2JlbmVhdGhfdG9fc3RvcmVfcmVnaXN0ZXJzX29wcywKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlZ2NhY2hlLCBy ZWdubyk7Cit9CisKK3N0YXRpYyB2b2lkCityZWNvcmRfcHJlcGFyZV90b19z dG9yZSAoc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSkKK3sKKyAgaWYgKCFy ZWNvcmRfY29yZSkKKyAgICByZWNvcmRfYmVuZWF0aF90b19wcmVwYXJlX3Rv X3N0b3JlIChyZWdjYWNoZSk7Cit9CisKK3N0YXRpYyB2b2lkCiByZWNvcmRf c3RvcmVfcmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLCBzdHJ1 Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLAogICAgICAgICAgICAgICAgICAgICAg ICAgaW50IHJlZ25vKQogeworICBpZiAocmVjb3JkX2NvcmUpCisgICAgewor ICAgICAgLyogRGVidWcgd2l0aCBjb3JlLiAgKi8KKyAgICAgIGlmIChyZWNv cmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlKQorICAgICAgICByZWdjYWNoZV9y YXdfY29sbGVjdCAocmVnY2FjaGUsIHJlZ25vLAorICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVjb3JkX2NvcmVfcmVnYnVmICsgTUFYX1JFR0lT VEVSX1NJWkUgKiByZWdubyk7CisgICAgICBlbHNlCisgICAgICAgIGVycm9y IChfKCJZb3UgY2FuJ3QgZG8gdGhhdCB3aXRob3V0IGEgcHJvY2VzcyB0byBk ZWJ1Zy4iKSk7CisKKyAgICAgIHJldHVybjsKKyAgICB9CisKICAgaWYgKCFy ZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlKQogICAgIHsKICAgICAgIGlm IChSRUNPUkRfSVNfUkVQTEFZKQpAQCAtOTczLDYgKzExNTUsNyBAQCByZWNv cmRfc3RvcmVfcmVnaXN0ZXJzIChzdHJ1Y3QgdGFyZ2V0X29wCiAKICAgICAg IHJlY29yZF9yZWdpc3RlcnNfY2hhbmdlIChyZWdjYWNoZSwgcmVnbm8pOwog ICAgIH0KKwogICByZWNvcmRfYmVuZWF0aF90b19zdG9yZV9yZWdpc3RlcnMg KHJlY29yZF9iZW5lYXRoX3RvX3N0b3JlX3JlZ2lzdGVyc19vcHMsCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVnY2FjaGUsIHJl Z25vKTsKIH0KQEAgLTk4OCw3ICsxMTcxLDcgQEAgcmVjb3JkX3hmZXJfcGFy dGlhbCAoc3RydWN0IHRhcmdldF9vcHMgKgogewogICBpZiAoIXJlY29yZF9n ZGJfb3BlcmF0aW9uX2Rpc2FibGUKICAgICAgICYmIChvYmplY3QgPT0gVEFS R0VUX09CSkVDVF9NRU1PUlkKLQkgIHx8IG9iamVjdCA9PSBUQVJHRVRfT0JK RUNUX1JBV19NRU1PUlkpICYmIHdyaXRlYnVmKQorCSAgfHwgb2JqZWN0ID09 IFRBUkdFVF9PQkpFQ1RfUkFXX01FTU9SWSkgJiYgd3JpdGVidWYgJiYgIXJl Y29yZF9jb3JlKQogICAgIHsKICAgICAgIGlmIChSRUNPUkRfSVNfUkVQTEFZ KQogCXsKQEAgLTEwMzIsMTEgKzEyMTUsOTEgQEAgcmVjb3JkX3hmZXJfcGFy dGlhbCAoc3RydWN0IHRhcmdldF9vcHMgKgogICAgICAgcmVjb3JkX2xpc3Qg PSByZWNvcmRfYXJjaF9saXN0X3RhaWw7CiAKICAgICAgIGlmIChyZWNvcmRf aW5zbl9udW0gPT0gcmVjb3JkX2luc25fbWF4X251bSAmJiByZWNvcmRfaW5z bl9tYXhfbnVtKQotCXJlY29yZF9saXN0X3JlbGVhc2VfZmlyc3QgKCk7CisJ cmVjb3JkX2xpc3RfcmVsZWFzZV9maXJzdF9pbnNuICgpOwogICAgICAgZWxz ZQogCXJlY29yZF9pbnNuX251bSsrOwogICAgIH0KIAorICAgaWYgKHJlY29y ZF9jb3JlICYmIG9iamVjdCA9PSBUQVJHRVRfT0JKRUNUX01FTU9SWSkKKyAg ICAgeworICAgICAgIC8qIERlYnVnIHdpdGggY29yZS4gICovCisgICAgICAg aWYgKHJlY29yZF9nZGJfb3BlcmF0aW9uX2Rpc2FibGUgfHwgIXdyaXRlYnVm KQorICAgICAgICAgeworICAgICAgICAgICBzdHJ1Y3QgdGFyZ2V0X3NlY3Rp b24gKnA7CisgICAgICAgICAgIGZvciAocCA9IHJlY29yZF9jb3JlX3N0YXJ0 OyBwIDwgcmVjb3JkX2NvcmVfZW5kOyBwKyspCisgICAgICAgICAgICAgewor ICAgICAgICAgICAgICAgaWYgKG9mZnNldCA+PSBwLT5hZGRyKQorICAgICAg ICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgc3RydWN0IHJlY29y ZF9jb3JlX2J1Zl9lbnRyeSAqZW50cnk7CisKKyAgICAgICAgICAgICAgICAg ICBpZiAob2Zmc2V0ID49IHAtPmVuZGFkZHIpCisgICAgICAgICAgICAgICAg ICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgICAgICAgIGlmIChvZmZz ZXQgKyBsZW4gPiBwLT5lbmRhZGRyKQorICAgICAgICAgICAgICAgICAgICAg bGVuID0gcC0+ZW5kYWRkciAtIG9mZnNldDsKKworICAgICAgICAgICAgICAg ICAgIG9mZnNldCAtPSBwLT5hZGRyOworCisgICAgICAgICAgICAgICAgICAg LyogUmVhZCByZWFkYnVmIG9yIHdyaXRlIHdyaXRlYnVmIHAsIG9mZnNldCwg bGVuLiAgKi8KKyAgICAgICAgICAgICAgICAgICAvKiBDaGVjayBmbGFncy4g ICovCisgICAgICAgICAgICAgICAgICAgaWYgKHAtPnRoZV9iZmRfc2VjdGlv bi0+ZmxhZ3MgJiBTRUNfQ09OU1RSVUNUT1IKKyAgICAgICAgICAgICAgICAg ICAgICAgfHwgKHAtPnRoZV9iZmRfc2VjdGlvbi0+ZmxhZ3MgJiBTRUNfSEFT X0NPTlRFTlRTKSA9PSAwKQorICAgICAgICAgICAgICAgICAgICAgeworICAg ICAgICAgICAgICAgICAgICAgICBpZiAocmVhZGJ1ZikKKyAgICAgICAgICAg ICAgICAgICAgICAgICBtZW1zZXQgKHJlYWRidWYsIDAsIGxlbik7CisgICAg ICAgICAgICAgICAgICAgICAgIHJldHVybiBsZW47CisgICAgICAgICAgICAg ICAgICAgICB9CisgICAgICAgICAgICAgICAgICAgLyogR2V0IHJlY29yZF9j b3JlX2J1Zl9lbnRyeS4gICovCisgICAgICAgICAgICAgICAgICAgZm9yIChl bnRyeSA9IHJlY29yZF9jb3JlX2J1Zl9saXN0OyBlbnRyeTsKKyAgICAgICAg ICAgICAgICAgICAgICAgIGVudHJ5ID0gZW50cnktPnByZXYpCisgICAgICAg ICAgICAgICAgICAgICBpZiAoZW50cnktPnAgPT0gcCkKKyAgICAgICAgICAg ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgaWYgKHdy aXRlYnVmKQorICAgICAgICAgICAgICAgICAgICAgeworICAgICAgICAgICAg ICAgICAgICAgICBpZiAoIWVudHJ5KQorICAgICAgICAgICAgICAgICAgICAg ICAgIHsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIEFkZCBhIG5l dyBlbnRyeS4gICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnRy eQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICA9IChzdHJ1Y3QgcmVj b3JkX2NvcmVfYnVmX2VudHJ5ICopCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB4bWFsbG9jCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIChzaXplb2YgKHN0cnVjdCByZWNvcmRfY29yZV9idWZfZW50 cnkpKTsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudHJ5LT5wID0g cDsKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmICghYmZkX21hbGxv Y19hbmRfZ2V0X3NlY3Rpb24gKHAtPmJmZCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHAt PnRoZV9iZmRfc2VjdGlvbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZlbnRyeS0+YnVm KSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgeworICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHhmcmVlIChlbnRyeSk7CisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIDA7CisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIGVudHJ5LT5wcmV2ID0gcmVjb3JkX2NvcmVfYnVmX2xpc3Q7CisgICAg ICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfY29yZV9idWZfbGlzdCA9 IGVudHJ5OworICAgICAgICAgICAgICAgICAgICAgICAgIH0KKworICAgICAg ICAgICAgICAgICAgICAgICAgbWVtY3B5IChlbnRyeS0+YnVmICsgb2Zmc2V0 LCB3cml0ZWJ1ZiwgKHNpemVfdCkgbGVuKTsKKyAgICAgICAgICAgICAgICAg ICAgIH0KKyAgICAgICAgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAg ICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgICAgIGlmICghZW50cnkp CisgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHJlY29yZF9iZW5l YXRoX3RvX3hmZXJfcGFydGlhbAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIChyZWNvcmRfYmVuZWF0aF90b194ZmVyX3BhcnRpYWxfb3Bz LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvYmplY3Qs IGFubmV4LCByZWFkYnVmLCB3cml0ZWJ1ZiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgb2Zmc2V0LCBsZW4pOworCisgICAgICAgICAg ICAgICAgICAgICAgIG1lbWNweSAocmVhZGJ1ZiwgZW50cnktPmJ1ZiArIG9m ZnNldCwgKHNpemVfdCkgbGVuKTsKKyAgICAgICAgICAgICAgICAgICAgIH0K KworICAgICAgICAgICAgICAgICAgIHJldHVybiBsZW47CisgICAgICAgICAg ICAgICAgIH0KKyAgICAgICAgICAgICB9CisKKyAgICAgICAgICAgcmV0dXJu IDA7CisgICAgICAgICB9CisgICAgICAgZWxzZQorICAgICAgICAgZXJyb3Ig KF8oIllvdSBjYW4ndCBkbyB0aGF0IHdpdGhvdXQgYSBwcm9jZXNzIHRvIGRl YnVnLiIpKTsKKworICAgICAgIHJldHVybiAwOworICAgICB9CisKICAgcmV0 dXJuIHJlY29yZF9iZW5lYXRoX3RvX3hmZXJfcGFydGlhbCAocmVjb3JkX2Jl bmVhdGhfdG9feGZlcl9wYXJ0aWFsX29wcywKICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgb2JqZWN0LCBhbm5leCwgcmVhZGJ1 Ziwgd3JpdGVidWYsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIG9mZnNldCwgbGVuKTsKQEAgLTEwODYsNiArMTM0OSwxNSBA QCByZWNvcmRfY2FuX2V4ZWN1dGVfcmV2ZXJzZSAodm9pZCkKICAgcmV0dXJu IDE7CiB9CiAKK2ludAorcmVjb3JkX2hhc19leGVjdXRpb24gKHN0cnVjdCB0 YXJnZXRfb3BzICpvcHMpCit7CisgIGlmIChyZWNvcmRfY29yZSkKKyAgICBy ZXR1cm4gMTsKKworICByZXR1cm4gcmVjb3JkX2JlbmVhdGhfdG9faGFzX2V4 ZWN1dGlvbiAob3BzKTsKK30KKwogc3RhdGljIHZvaWQKIGluaXRfcmVjb3Jk X29wcyAodm9pZCkKIHsKQEAgLTExMDIsMTEgKzEzNzQsMTQgQEAgaW5pdF9y ZWNvcmRfb3BzICh2b2lkKQogICByZWNvcmRfb3BzLnRvX21vdXJuX2luZmVy aW9yID0gcmVjb3JkX21vdXJuX2luZmVyaW9yOwogICByZWNvcmRfb3BzLnRv X2tpbGwgPSByZWNvcmRfa2lsbDsKICAgcmVjb3JkX29wcy50b19jcmVhdGVf aW5mZXJpb3IgPSBmaW5kX2RlZmF1bHRfY3JlYXRlX2luZmVyaW9yOworICBy ZWNvcmRfb3BzLnRvX2ZldGNoX3JlZ2lzdGVycyA9IHJlY29yZF9mZXRjaF9y ZWdpc3RlcnM7CisgIHJlY29yZF9vcHMudG9fcHJlcGFyZV90b19zdG9yZSA9 IHJlY29yZF9wcmVwYXJlX3RvX3N0b3JlOwogICByZWNvcmRfb3BzLnRvX3N0 b3JlX3JlZ2lzdGVycyA9IHJlY29yZF9zdG9yZV9yZWdpc3RlcnM7CiAgIHJl Y29yZF9vcHMudG9feGZlcl9wYXJ0aWFsID0gcmVjb3JkX3hmZXJfcGFydGlh bDsKICAgcmVjb3JkX29wcy50b19pbnNlcnRfYnJlYWtwb2ludCA9IHJlY29y ZF9pbnNlcnRfYnJlYWtwb2ludDsKICAgcmVjb3JkX29wcy50b19yZW1vdmVf YnJlYWtwb2ludCA9IHJlY29yZF9yZW1vdmVfYnJlYWtwb2ludDsKICAgcmVj b3JkX29wcy50b19jYW5fZXhlY3V0ZV9yZXZlcnNlID0gcmVjb3JkX2Nhbl9l eGVjdXRlX3JldmVyc2U7CisgIHJlY29yZF9vcHMudG9faGFzX2V4ZWN1dGlv biA9IHJlY29yZF9oYXNfZXhlY3V0aW9uOwogICByZWNvcmRfb3BzLnRvX3N0 cmF0dW0gPSByZWNvcmRfc3RyYXR1bTsKICAgcmVjb3JkX29wcy50b19tYWdp YyA9IE9QU19NQUdJQzsKIH0KQEAgLTExMjcsNiArMTQwMiwyOTMgQEAgY21k X3JlY29yZF9zdGFydCAoY2hhciAqYXJncywgaW50IGZyb21fdAogICBleGVj dXRlX2NvbW1hbmQgKCJ0YXJnZXQgcmVjb3JkIiwgZnJvbV90dHkpOwogfQog CitzdGF0aWMgdm9pZAorY21kX3JlY29yZF9mZF9jbGVhbnVwcyAodm9pZCAq cmVjZmRwKQoreworICBpbnQgcmVjZmQgPSAqKGludCAqKSByZWNmZHA7Cisg IGNsb3NlIChyZWNmZCk7Cit9CisKKy8qIER1bXAgdGhlIGV4ZWN1dGlvbiBs b2cgdG8gYSBmaWxlLiAgKi8KKworc3RhdGljIHZvaWQKK2NtZF9yZWNvcmRf ZHVtcCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5KQoreworICBjaGFyICpy ZWNmaWxlbmFtZSwgcmVjZmlsZW5hbWVfYnVmZmVyWzQwXTsKKyAgaW50IHJl Y2ZkOworICBzdHJ1Y3QgcmVjb3JkX2VudHJ5ICpjdXJfcmVjb3JkX2xpc3Q7 CisgIHVpbnQzMl90IG1hZ2ljOworICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2Nh Y2hlOworICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaDsKKyAgc3RydWN0IGNs ZWFudXAgKm9sZF9jbGVhbnVwczsKKyAgc3RydWN0IGNsZWFudXAgKnNldF9j bGVhbnVwczsKKworICBpZiAoY3VycmVudF90YXJnZXQudG9fc3RyYXR1bSAh PSByZWNvcmRfc3RyYXR1bSkKKyAgICBlcnJvciAoXygiUHJvY2VzcyByZWNv cmQgaXMgbm90IHN0YXJ0ZWQuXG4iKSk7CisKKyAgaWYgKGFyZ3MgJiYgKmFy Z3MpCisgICAgcmVjZmlsZW5hbWUgPSBhcmdzOworICBlbHNlCisgICAgewor ICAgICAgLyogRGVmYXVsdCBjb3JlZmlsZSBuYW1lIGlzICJyZWMuUElEIi4g ICovCisgICAgICBzcHJpbnRmIChyZWNmaWxlbmFtZV9idWZmZXIsICJyZWMu JWQiLCBQSURHRVQgKGluZmVyaW9yX3B0aWQpKTsKKyAgICAgIHJlY2ZpbGVu YW1lID0gcmVjZmlsZW5hbWVfYnVmZmVyOworICAgIH0KKworICAvKiBPcGVu IHRoZSBkdW1wIGZpbGUuICAqLworICByZWNmZCA9IG9wZW4gKHJlY2ZpbGVu YW1lLCBPX1dST05MWSB8IE9fQ1JFQVQgfCBPX1RSVU5DIHwgT19CSU5BUlks CisgICAgICAgICAgICAgICAgU19JUlVTUiB8IFNfSVdVU1IpOworICBpZiAo cmVjZmQgPCAwKQorICAgIGVycm9yIChfKCJGYWlsZWQgdG8gb3BlbiAnJXMn IGZvciBkdW1wLiIpLCByZWNmaWxlbmFtZSk7CisgIG9sZF9jbGVhbnVwcyA9 IG1ha2VfY2xlYW51cCAoY21kX3JlY29yZF9mZF9jbGVhbnVwcywgJnJlY2Zk KTsKKworICAvKiBTYXZlIHRoZSBjdXJyZW50IHJlY29yZCBlbnRyeSB0byAi Y3VyX3JlY29yZF9saXN0Ii4gICovCisgIGN1cl9yZWNvcmRfbGlzdCA9IHJl Y29yZF9saXN0OworCisgIC8qIEdldCB0aGUgdmFsdWVzIG9mIHJlZ2NhY2hl IGFuZCBnZGJhcmNoLiAgKi8KKyAgcmVnY2FjaGUgPSBnZXRfY3VycmVudF9y ZWdjYWNoZSAoKTsKKyAgZ2RiYXJjaCA9IGdldF9yZWdjYWNoZV9hcmNoIChy ZWdjYWNoZSk7CisKKyAgLyogRGlzYWJsZSB0aGUgR0RCIG9wZXJhdGlvbiBy ZWNvcmQuICAqLworICBzZXRfY2xlYW51cHMgPSByZWNvcmRfZ2RiX29wZXJh dGlvbl9kaXNhYmxlX3NldCAoKTsKKworICAvKiBXcml0ZSB0aGUgbWFnaWMg Y29kZS4gICovCisgIG1hZ2ljID0gUkVDT1JEX0ZJTEVfTUFHSUM7CisgIGlm ICh3cml0ZSAocmVjZmQsICZtYWdpYywgNCkgIT0gNCkKKyAgICBlcnJvciAo XygiRmFpbGVkIHRvIHdyaXRlICclcycgZm9yIGR1bXAuIiksIHJlY2ZpbGVu YW1lKTsKKworICAvKiBSZXZlcnNlIGV4ZWN1dGUgdG8gdGhlIGJlZ2luIG9m IHJlY29yZCBsaXN0LiAgKi8KKyAgd2hpbGUgKDEpCisgICAgeworICAgICAg LyogQ2hlY2sgZm9yIGJlZ2lubmluZyBhbmQgZW5kIG9mIGxvZy4gICovCisg ICAgICBpZiAocmVjb3JkX2xpc3QgPT0gJnJlY29yZF9maXJzdCkKKyAgICAg ICAgYnJlYWs7CisKKyAgICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdjYWNo ZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOworCisgICAgICBpZiAocmVjb3Jk X2xpc3QtPnByZXYpCisgICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2xp c3QtPnByZXY7CisgICAgfQorCisgIC8qIER1bXAgdGhlIGVudHJpZXMgdG8g cmVjZmQgYW5kIGZvcndhcmQgZXhlY3V0ZSB0byB0aGUgZW5kIG9mCisgICAg IHJlY29yZCBsaXN0LiAgKi8KKyAgd2hpbGUgKDEpCisgICAgeworICAgICAg LyogRHVtcCBlbnRyeS4gICovCisgICAgICBpZiAocmVjb3JkX2xpc3QgIT0g JnJlY29yZF9maXJzdCkKKyAgICAgICAgeworICAgICAgICAgIHVpbnQ4X3Qg dG1wdTg7CisgICAgICAgICAgdWludDY0X3QgdG1wdTY0OworCisgICAgICAg ICAgdG1wdTggPSByZWNvcmRfbGlzdC0+dHlwZTsKKyAgICAgICAgICBpZiAo d3JpdGUgKHJlY2ZkLCAmdG1wdTgsIDEpICE9IDEpCisgICAgICAgICAgICBl cnJvciAoXygiRmFpbGVkIHRvIHdyaXRlICclcycgZm9yIGR1bXAuIiksIHJl Y2ZpbGVuYW1lKTsKKworICAgICAgICAgIHN3aXRjaCAocmVjb3JkX2xpc3Qt PnR5cGUpCisgICAgICAgICAgICB7CisgICAgICAgICAgICBjYXNlIHJlY29y ZF9yZWc6IC8qIHJlZyAqLworICAgICAgICAgICAgICB0bXB1NjQgPSByZWNv cmRfbGlzdC0+dS5yZWcubnVtOworI2lmIChCWVRFX09SREVSID09IExJVFRM RV9FTkRJQU4pCisgICAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0 bXB1NjQpOworI2VuZGlmCisgICAgICAgICAgICAgIGlmICh3cml0ZSAocmVj ZmQsICZ0bXB1NjQsIDgpICE9IDgpCisgICAgICAgICAgICAgICAgZXJyb3Ig KF8oIkZhaWxlZCB0byB3cml0ZSAnJXMnIGZvciBkdW1wLiIpLCByZWNmaWxl bmFtZSk7CisKKyAgICAgICAgICAgICAgaWYgKHdyaXRlIChyZWNmZCwgcmVj b3JkX2xpc3QtPnUucmVnLnZhbCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICBNQVhfUkVHSVNURVJfU0laRSkgIT0gTUFYX1JFR0lTVEVSX1NJWkUpCisg ICAgICAgICAgICAgICAgZXJyb3IgKF8oIkZhaWxlZCB0byB3cml0ZSAnJXMn IGZvciBkdW1wLiIpLCByZWNmaWxlbmFtZSk7CisgICAgICAgICAgICAgIGJy ZWFrOworICAgICAgICAgICAgY2FzZSByZWNvcmRfbWVtOiAvKiBtZW0gKi8K KyAgICAgICAgICAgICAgaWYgKCFyZWNvcmRfbGlzdC0+dS5tZW0ubWVtX2Vu dHJ5X25vdF9hY2Nlc3NpYmxlKQorICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgIHRtcHU2NCA9IHJlY29yZF9saXN0LT51Lm1lbS5hZGRy OworI2lmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAg ICAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyNlbmRp ZgorICAgICAgICAgICAgICAgICAgaWYgKHdyaXRlIChyZWNmZCwgJnRtcHU2 NCwgOCkgIT0gOCkKKyAgICAgICAgICAgICAgICAgICAgZXJyb3IgKF8oIkZh aWxlZCB0byB3cml0ZSAnJXMnIGZvciBkdW1wLiIpLCByZWNmaWxlbmFtZSk7 CisKKyAgICAgICAgICAgICAgICAgIHRtcHU2NCA9IHJlY29yZF9saXN0LT51 Lm1lbS5sZW47CisjaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElBTikK KyAgICAgICAgICAgICAgICAgIHRtcHU2NCA9IGJzd2FwXzY0ICh0bXB1NjQp OworI2VuZGlmCisgICAgICAgICAgICAgICAgICBpZiAod3JpdGUgKHJlY2Zk LCAmdG1wdTY0LCA4KSAhPSA4KQorICAgICAgICAgICAgICAgICAgICBlcnJv ciAoXygiRmFpbGVkIHRvIHdyaXRlICclcycgZm9yIGR1bXAuIiksIHJlY2Zp bGVuYW1lKTsKKworICAgICAgICAgICAgICAgICAgaWYgKHdyaXRlIChyZWNm ZCwgcmVjb3JkX2xpc3QtPnUubWVtLnZhbCwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgcmVjb3JkX2xpc3QtPnUubWVtLmxlbikgIT0gcmVjb3Jk X2xpc3QtPnUubWVtLmxlbikKKyAgICAgICAgICAgICAgICAgICAgZXJyb3Ig KF8oIkZhaWxlZCB0byB3cml0ZSAnJXMnIGZvciBkdW1wLiIpLCByZWNmaWxl bmFtZSk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgICBicmVh azsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorCisgICAgICAvKiBFeGVj dXRlIGVudHJ5LiAgKi8KKyAgICAgIHJlY29yZF9leGVjX2VudHJ5IChyZWdj YWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOworCisgICAgICBpZiAocmVj b3JkX2xpc3QtPm5leHQpCisgICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3Jk X2xpc3QtPm5leHQ7CisgICAgICBlbHNlCisgICAgICAgIGJyZWFrOworICAg IH0KKworICAvKiBSZXZlcnNlIGV4ZWN1dGUgdG8gY3VyX3JlY29yZF9saXN0 LiAgKi8KKyAgd2hpbGUgKDEpCisgICAgeworICAgICAgLyogQ2hlY2sgZm9y IGJlZ2lubmluZyBhbmQgZW5kIG9mIGxvZy4gICovCisgICAgICBpZiAocmVj b3JkX2xpc3QgPT0gY3VyX3JlY29yZF9saXN0KQorICAgICAgICBicmVhazsK KworICAgICAgcmVjb3JkX2V4ZWNfZW50cnkgKHJlZ2NhY2hlLCBnZGJhcmNo LCByZWNvcmRfbGlzdCk7CisKKyAgICAgIGlmIChyZWNvcmRfbGlzdC0+cHJl dikKKyAgICAgICAgcmVjb3JkX2xpc3QgPSByZWNvcmRfbGlzdC0+cHJldjsK KyAgICB9CisKKyAgZG9fY2xlYW51cHMgKHNldF9jbGVhbnVwcyk7CisgIGRv X2NsZWFudXBzIChvbGRfY2xlYW51cHMpOworCisgIC8qIFN1Y2NlZWRlZC4g ICovCisgIGZwcmludGZfZmlsdGVyZWQgKGdkYl9zdGRvdXQsICJTYXZlZCBy ZWNmaWxlICVzLlxuIiwgcmVjZmlsZW5hbWUpOworfQorCisvKiBMb2FkIHRo ZSBleGVjdXRpb24gbG9nIGZyb20gYSBmaWxlLiAgKi8KKworc3RhdGljIHZv aWQKK2NtZF9yZWNvcmRfbG9hZCAoY2hhciAqYXJncywgaW50IGZyb21fdHR5 KQoreworICBpbnQgcmVjZmQ7CisgIHVpbnQzMl90IG1hZ2ljOworICBzdHJ1 Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzOworICBzdHJ1Y3QgY2xlYW51cCAq b2xkX2NsZWFudXBzMjsKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVjOwor ICBpbnQgaW5zbl9udW1iZXIgPSAwOworCisgIGlmIChjdXJyZW50X3Rhcmdl dC50b19zdHJhdHVtICE9IHJlY29yZF9zdHJhdHVtKQorICAgIHsKKyAgICAg IGNtZF9yZWNvcmRfc3RhcnQgKE5VTEwsIGZyb21fdHR5KTsKKyAgICAgIHBy aW50Zl91bmZpbHRlcmVkIChfKCJBdXRvIHN0YXJ0IHByb2Nlc3MgcmVjb3Jk LlxuIikpOworICAgIH0KKworICBpZiAoIWFyZ3MgfHwgKGFyZ3MgJiYgISph cmdzKSkKKyAgICBlcnJvciAoXygiQXJndW1lbnQgZm9yIGZpbGVuYW1lIHJl cXVpcmVkLlxuIikpOworCisgIC8qIE9wZW4gdGhlIGxvYWQgZmlsZS4gICov CisgIHJlY2ZkID0gb3BlbiAoYXJncywgT19SRE9OTFkgfCBPX0JJTkFSWSk7 CisgIGlmIChyZWNmZCA8IDApCisgICAgZXJyb3IgKF8oIkZhaWxlZCB0byBv cGVuICclcycgZm9yIGxvYWQuIiksIGFyZ3MpOworICBvbGRfY2xlYW51cHMg PSBtYWtlX2NsZWFudXAgKGNtZF9yZWNvcmRfZmRfY2xlYW51cHMsICZyZWNm ZCk7CisKKyAgLyogQ2hlY2sgdGhlIG1hZ2ljIGNvZGUuICAqLworICBpZiAo cmVhZCAocmVjZmQsICZtYWdpYywgNCkgIT0gNCkKKyAgICBlcnJvciAoXygi RmFpbGVkIHRvIHJlYWQgJyVzJyBmb3IgbG9hZC4iKSwgYXJncyk7CisgIGlm IChtYWdpYyAhPSBSRUNPUkRfRklMRV9NQUdJQykKKyAgICBlcnJvciAoXygi JyVzJyBpcyBub3QgYSByZWNvcmQgZHVtcC4iKSwgYXJncyk7CisKKyAgLyog TG9hZCB0aGUgZW50cmllcyBpbiByZWNmZCB0byB0aGUgcmVjb3JkX2FyY2hf bGlzdF9oZWFkIGFuZAorICAgICByZWNvcmRfYXJjaF9saXN0X3RhaWwuICAq LworICByZWNvcmRfYXJjaF9saXN0X2hlYWQgPSBOVUxMOworICByZWNvcmRf YXJjaF9saXN0X3RhaWwgPSBOVUxMOworICBvbGRfY2xlYW51cHMyID0gbWFr ZV9jbGVhbnVwIChyZWNvcmRfYXJjaF9saXN0X2NsZWFudXBzLCAwKTsKKwor ICB3aGlsZSAoMSkKKyAgICB7CisgICAgICBpbnQgcmV0OworICAgICAgdWlu dDhfdCB0bXB1ODsKKyAgICAgIHVpbnQ2NF90IHRtcHU2NDsKKworICAgICAg cmV0ID0gcmVhZCAocmVjZmQsICZ0bXB1OCwgMSk7CisgICAgICBpZiAocmV0 IDwgMCkKKyAgICAgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFkICclcycg Zm9yIGxvYWQuIiksIGFyZ3MpOworICAgICAgaWYgKHJldCA9PSAwKQorICAg ICAgICBicmVhazsKKworICAgICAgc3dpdGNoICh0bXB1OCkKKyAgICAgICAg eworICAgICAgICBjYXNlIHJlY29yZF9yZWc6IC8qIHJlZyAqLworICAgICAg ICAgIHJlYyA9IChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2MgKHNp emVvZiAoc3RydWN0IHJlY29yZF9lbnRyeSkpOworICAgICAgICAgIHJlYy0+ dS5yZWcudmFsID0gKGdkYl9ieXRlICopIHhtYWxsb2MgKE1BWF9SRUdJU1RF Ul9TSVpFKTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOworICAgICAg ICAgIHJlYy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50eXBlID0g cmVjb3JkX3JlZzsKKyAgICAgICAgICAvKiBHZXQgbnVtLiAgKi8KKyAgICAg ICAgICBpZiAocmVhZCAocmVjZmQsICZ0bXB1NjQsIDgpICE9IDgpCisgICAg ICAgICAgICBlcnJvciAoXygiRmFpbGVkIHRvIHJlYWQgJyVzJyBmb3IgbG9h ZC4iKSwgYXJncyk7CisjaWYgKEJZVEVfT1JERVIgPT0gTElUVExFX0VORElB TikKKyAgICAgICAgICB0bXB1NjQgPSBic3dhcF82NCAodG1wdTY0KTsKKyNl bmRpZgorICAgICAgICAgIHJlYy0+dS5yZWcubnVtID0gdG1wdTY0OworICAg ICAgICAgIC8qIEdldCB2YWwuICAqLworICAgICAgICAgIGlmIChyZWFkIChy ZWNmZCwgcmVjLT51LnJlZy52YWwsCisgICAgICAgICAgICAgICAgICAgIE1B WF9SRUdJU1RFUl9TSVpFKSAhPSBNQVhfUkVHSVNURVJfU0laRSkKKyAgICAg ICAgICAgIGVycm9yIChfKCJGYWlsZWQgdG8gcmVhZCAnJXMnIGZvciBsb2Fk LiIpLCBhcmdzKTsKKyAgICAgICAgICByZWNvcmRfYXJjaF9saXN0X2FkZCAo cmVjKTsKKyAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSByZWNvcmRf bWVtOiAvKiBtZW0gKi8KKyAgICAgICAgICByZWMgPSAoc3RydWN0IHJlY29y ZF9lbnRyeSAqKSB4bWFsbG9jIChzaXplb2YgKHN0cnVjdCByZWNvcmRfZW50 cnkpKTsKKyAgICAgICAgICByZWMtPnByZXYgPSBOVUxMOworICAgICAgICAg IHJlYy0+bmV4dCA9IE5VTEw7CisgICAgICAgICAgcmVjLT50eXBlID0gcmVj b3JkX21lbTsKKyAgICAgICAgICAvKiBHZXQgYWRkci4gICovCisgICAgICAg ICAgaWYgKHJlYWQgKHJlY2ZkLCAmdG1wdTY0LCA4KSAhPSA4KQorICAgICAg ICAgICAgZXJyb3IgKF8oIkZhaWxlZCB0byByZWFkICclcycgZm9yIGxvYWQu IiksIGFyZ3MpOworI2lmIChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4p CisgICAgICAgICAgdG1wdTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisjZW5k aWYKKyAgICAgICAgICByZWMtPnUubWVtLmFkZHIgPSB0bXB1NjQ7CisgICAg ICAgICAgLyogR2V0IGxlbi4gICovCisgICAgICAgICAgaWYgKHJlYWQgKHJl Y2ZkLCAmdG1wdTY0LCA4KSAhPSA4KQorICAgICAgICAgICAgZXJyb3IgKF8o IkZhaWxlZCB0byByZWFkICclcycgZm9yIGxvYWQuIiksIGFyZ3MpOworI2lm IChCWVRFX09SREVSID09IExJVFRMRV9FTkRJQU4pCisgICAgICAgICAgdG1w dTY0ID0gYnN3YXBfNjQgKHRtcHU2NCk7CisjZW5kaWYKKyAgICAgICAgICBy ZWMtPnUubWVtLmxlbiA9IHRtcHU2NDsKKyAgICAgICAgICByZWMtPnUubWVt Lm1lbV9lbnRyeV9ub3RfYWNjZXNzaWJsZSA9IDA7CisgICAgICAgICAgcmVj LT51Lm1lbS52YWwgPSAoZ2RiX2J5dGUgKikgeG1hbGxvYyAocmVjLT51Lm1l bS5sZW4pOworICAgICAgICAgIC8qIEdldCB2YWwuICAqLworICAgICAgICAg IGlmIChyZWFkIChyZWNmZCwgcmVjLT51Lm1lbS52YWwsCisgICAgICAgICAg ICAgICAgICAgIHJlYy0+dS5tZW0ubGVuKSAhPSByZWMtPnUubWVtLmxlbikK KyAgICAgICAgICAgIGVycm9yIChfKCJGYWlsZWQgdG8gcmVhZCAnJXMnIGZv ciBsb2FkLiIpLCBhcmdzKTsKKyAgICAgICAgICByZWNvcmRfYXJjaF9saXN0 X2FkZCAocmVjKTsKKyAgICAgICAgICBicmVhazsKKworICAgICAgICBjYXNl IHJlY29yZF9lbmQ6IC8qIGVuZCAqLworICAgICAgICAgIHJlYyA9IChzdHJ1 Y3QgcmVjb3JkX2VudHJ5ICopIHhtYWxsb2MgKHNpemVvZiAoc3RydWN0IHJl Y29yZF9lbnRyeSkpOworICAgICAgICAgIHJlYy0+cHJldiA9IE5VTEw7Cisg ICAgICAgICAgcmVjLT5uZXh0ID0gTlVMTDsKKyAgICAgICAgICByZWMtPnR5 cGUgPSByZWNvcmRfZW5kOworICAgICAgICAgIHJlY29yZF9hcmNoX2xpc3Rf YWRkIChyZWMpOworICAgICAgICAgIGluc25fbnVtYmVyICsrOworICAgICAg ICAgIGJyZWFrOworCisgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgZXJy b3IgKF8oIkZvcm1hdCBvZiAnJXMnIGlzIG5vdCByaWdodC4iKSwgYXJncyk7 CisgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgZGlz Y2FyZF9jbGVhbnVwcyAob2xkX2NsZWFudXBzMik7CisKKyAgLyogQWRkIHJl Y29yZF9hcmNoX2xpc3RfaGVhZCB0byB0aGUgZW5kIG9mIHJlY29yZCBsaXN0 LiAgKi8KKyAgZm9yIChyZWMgPSByZWNvcmRfbGlzdDsgcmVjLT5uZXh0OyBy ZWMgPSByZWMtPm5leHQpOworICByZWMtPm5leHQgPSByZWNvcmRfYXJjaF9s aXN0X2hlYWQ7CisgIHJlY29yZF9hcmNoX2xpc3RfaGVhZC0+cHJldiA9IHJl YzsKKworICAvKiBVcGRhdGUgcmVjb3JkX2luc25fbnVtIGFuZCByZWNvcmRf aW5zbl9tYXhfbnVtLiAgKi8KKyAgcmVjb3JkX2luc25fbnVtICs9IGluc25f bnVtYmVyOworICBpZiAocmVjb3JkX2luc25fbnVtID4gcmVjb3JkX2luc25f bWF4X251bSkKKyAgICB7CisgICAgICByZWNvcmRfaW5zbl9tYXhfbnVtID0g cmVjb3JkX2luc25fbnVtOworICAgICAgd2FybmluZyAoXygiQXV0byBpbmNy ZWFzZSByZWNvcmQvcmVwbGF5IGJ1ZmZlciBsaW1pdCB0byAlZC4iKSwKKyAg ICAgICAgICAgICAgIHJlY29yZF9pbnNuX21heF9udW0pOworICAgIH0KKwor ICBkb19jbGVhbnVwcyAob2xkX2NsZWFudXBzKTsKKworICAvKiBTdWNjZWVk ZWQuICAqLworICBmcHJpbnRmX2ZpbHRlcmVkIChnZGJfc3Rkb3V0LCAiTG9h ZGVkIHJlY2ZpbGUgJXMuXG4iLCBhcmdzKTsKK30KKwogLyogVHJ1bmNhdGUg dGhlIHJlY29yZCBsb2cgZnJvbSB0aGUgcHJlc2VudCBwb2ludAogICAgb2Yg cmVwbGF5IHVudGlsIHRoZSBlbmQuICAqLwogCkBAIC0xMTc3LDcgKzE3Mzks NyBAQCBzZXRfcmVjb3JkX2luc25fbWF4X251bSAoY2hhciAqYXJncywgaW50 CiAJCSAgICAgICAgICAgInRoZSBmaXJzdCBvbmVzP1xuIikpOwogCiAgICAg ICB3aGlsZSAocmVjb3JkX2luc25fbnVtID4gcmVjb3JkX2luc25fbWF4X251 bSkKLQlyZWNvcmRfbGlzdF9yZWxlYXNlX2ZpcnN0ICgpOworCXJlY29yZF9s aXN0X3JlbGVhc2VfZmlyc3RfaW5zbiAoKTsKICAgICB9CiB9CiAKQEAgLTEy MTcsNiArMTc3OSw4IEBAIGluZm9fcmVjb3JkX2NvbW1hbmQgKGNoYXIgKmFy Z3MsIGludCBmcm8KIHZvaWQKIF9pbml0aWFsaXplX3JlY29yZCAodm9pZCkK IHsKKyAgc3RydWN0IGNtZF9saXN0X2VsZW1lbnQgKmM7CisKICAgLyogSW5p dCByZWNvcmRfZmlyc3QuICAqLwogICByZWNvcmRfZmlyc3QucHJldiA9IE5V TEw7CiAgIHJlY29yZF9maXJzdC5uZXh0ID0gTlVMTDsKQEAgLTEyNTAsNiAr MTgxNCwxNSBAQCBfaW5pdGlhbGl6ZV9yZWNvcmQgKHZvaWQpCiAJCSAgImlu Zm8gcmVjb3JkICIsIDAsICZpbmZvbGlzdCk7CiAgIGFkZF9hbGlhc19jbWQg KCJyZWMiLCAicmVjb3JkIiwgY2xhc3Nfb2JzY3VyZSwgMSwgJmluZm9saXN0 KTsKIAorICBjID0gYWRkX2NtZCAoImR1bXAiLCBjbGFzc19vYnNjdXJlLCBj bWRfcmVjb3JkX2R1bXAsCisJICAgICAgIF8oIkR1bXAgdGhlIGV4ZWN1dGlv biBsb2cgdG8gYSBmaWxlLlxuXAorQXJndW1lbnQgaXMgb3B0aW9uYWwgZmls ZW5hbWUuICBEZWZhdWx0IGZpbGVuYW1lIGlzICdyZWMuPHByb2Nlc3NfaWQ+ Jy4iKSwKKyAgICAgICAgICAgICAgICZyZWNvcmRfY21kbGlzdCk7CisgIHNl dF9jbWRfY29tcGxldGVyIChjLCBmaWxlbmFtZV9jb21wbGV0ZXIpOworICBj ID0gYWRkX2NtZCAoImxvYWQiLCBjbGFzc19vYnNjdXJlLCBjbWRfcmVjb3Jk X2xvYWQsCisJICAgICAgIF8oIkxvYWQgdGhlIGV4ZWN1dGlvbiBsb2cgZnJv bSBhIGZpbGUuICBBcmd1bWVudCBpcyBmaWxlbmFtZS4iKSwKKyAgICAgICAg ICAgICAgICZyZWNvcmRfY21kbGlzdCk7CisgIHNldF9jbWRfY29tcGxldGVy IChjLCBmaWxlbmFtZV9jb21wbGV0ZXIpOwogCiAgIGFkZF9jbWQgKCJkZWxl dGUiLCBjbGFzc19vYnNjdXJlLCBjbWRfcmVjb3JkX2RlbGV0ZSwKIAkgICBf KCJEZWxldGUgdGhlIHJlc3Qgb2YgZXhlY3V0aW9uIGxvZyBhbmQgc3RhcnQg cmVjb3JkaW5nIGl0IGFuZXcuIiksCg== --000e0cd3313a970f5a04700f8418 Content-Type: text/plain; charset=US-ASCII; name="prec-dump-doc.txt" Content-Disposition: attachment; filename="prec-dump-doc.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fxu0upnc1 Content-length: 1298 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgIDE2ICsrKysrKysrKysrKysrKysK IDEgZmlsZSBjaGFuZ2VkLCAxNiBpbnNlcnRpb25zKCspCgotLS0gYS9kb2Mv Z2RiLnRleGluZm8KKysrIGIvZG9jL2dkYi50ZXhpbmZvCkBAIC01MTkwLDYg KzUxOTAsMjIgQEAgV2hlbiByZWNvcmQgdGFyZ2V0IHJ1bnMgaW4gcmVwbGF5 IG1vZGUgKAogc3Vic2VxdWVudCBleGVjdXRpb24gbG9nIGFuZCBiZWdpbiB0 byByZWNvcmQgYSBuZXcgZXhlY3V0aW9uIGxvZyBzdGFydGluZwogZnJvbSB0 aGUgY3VycmVudCBhZGRyZXNzLiAgVGhpcyBtZWFucyB5b3Ugd2lsbCBhYmFu ZG9uIHRoZSBwcmV2aW91c2x5CiByZWNvcmRlZCBgYGZ1dHVyZScnIGFuZCBi ZWdpbiByZWNvcmRpbmcgYSBuZXcgYGBmdXR1cmUnJy4KKworQGtpbmRleCBy ZWNvcmQgZHVtcAorQGtpbmRleCByZWMgZHVtcAorQGl0ZW0gcmVjb3JkIGR1 bXAgW0B2YXJ7ZmlsZX1dCitAaXRlbXggcmVjIGR1bXAgW0B2YXJ7ZmlsZX1d CitQcm9kdWNlIGEgcmVjb3JkIGV4ZWN1dGlvbiBsb2cgb2YgdGhlIGluZmVy aW9yIHByb2Nlc3MuICBUaGUgb3B0aW9uYWwKK2FyZ3VtZW50IEB2YXJ7Zmls ZX0gc3BlY2lmaWVzIHRoZSBmaWxlIG5hbWUgd2hlcmUgdG8gcHV0IHRoZSBy ZWNvcmQgZHVtcC4KK0lmIG5vdCBzcGVjaWZpZWQsIHRoZSBmaWxlIG5hbWUg ZGVmYXVsdHMgdG8gQGZpbGV7cmVjLkB2YXJ7cGlkfX0sIHdoZXJlCitAdmFy e3BpZH0gaXMgdGhlIGluZmVyaW9yIHByb2Nlc3MgSUQuCisKK0BraW5kZXgg cmVjb3JkIGxvYWQKK0BraW5kZXggcmVjIGxvYWQKK0BpdGVtIHJlY29yZCBs b2FkIEB2YXJ7ZmlsZX0KK0BpdGVteCByZWMgZHVtcCBAdmFye2ZpbGV9CitM b2FkIHByb2Nlc3MgcmVjb3JkIGV4ZWN1dGlvbiBsb2cgZnJvbSBAdmFye2Zp bGV9LgorSXQgY2FuIHdvcmsgd2l0aCBAY29kZXtjb3JlLWZpbGV9LgogQGVu ZCB0YWJsZQogCiAK --000e0cd3313a970f5a04700f8418--