From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 16732 invoked by alias); 25 Nov 2009 08:07:00 -0000 Received: (qmail 16702 invoked by uid 22791); 25 Nov 2009 08:06:52 -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-f189.google.com (HELO mail-pz0-f189.google.com) (209.85.222.189) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 25 Nov 2009 08:06:41 +0000 Received: by mail-pz0-f189.google.com with SMTP id 27so5464743pzk.12 for ; Wed, 25 Nov 2009 00:06:40 -0800 (PST) MIME-Version: 1.0 Received: by 10.142.6.20 with SMTP id 20mr737848wff.262.1259136400277; Wed, 25 Nov 2009 00:06:40 -0800 (PST) From: Hui Zhu Date: Wed, 25 Nov 2009 08:07:00 -0000 Message-ID: Subject: [RFA/RFC] Prec multi-thread support [4/4] record target To: gdb-patches ml Cc: Michael Snyder Content-Type: multipart/mixed; boundary=00504502b22edcc1b804792d8914 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-11/txt/msg00545.txt.bz2 --00504502b22edcc1b804792d8914 Content-Type: text/plain; charset=ISO-8859-1 Content-length: 37316 To record the multithread inferior, record let each thread exec one by one. For example: Inferior have 2 threads t1 and t2. 1. set t1 to inferior_ptid. 2. record_message t1. 3. resume t1. 4. wait t1. 5. Check if t1 get breakpoint or someting. If so, return. 5. set t2 to inferior_ptid. 6. record_message t2. 7. resume t2. 8. wait t2. 9. Check if t2 get breakpoint or someting. If so, return. 10. Check if step, if so return. If not, goto 1. But there is a problem that thread will hang by a lock sometime. If t1 is waiting a lock and t2 have it. GDB and inferior will dead lock in there. So record call wait with TARGET_WNOHANG. After we get TARGET_WAITKIND_IGNORE (thread is keep running), we will set tp->record_is_waiting to 1 that flag thread is running. And record set non_stop to 1, because if we want linux-nat handle 2 thread running. This is the only way. If not set, GDB will get a lot of internal_error. Then the inferior exec will be: 1. set t1 to inferior_ptid. 2. If t1->record_is_waiting is 0, record_message t1. 3. If t1->record_is_waiting is 0, resume t1. 4. wait t1. 5. If get TARGET_WAITKIND_IGNORE, set t1->record_is_waiting to 1. Check if t1 get breakpoint or someting. If so, return. 5. set t2 to inferior_ptid. 6. If t2->record_is_waiting is 0, record_message t2. 7. If t2->record_is_waiting is 0, resume t2. 8. wait t2. 9. If get TARGET_WAITKIND_IGNORE, set t2->record_is_waiting to 1. Check if t2 get breakpoint or someting. If so, return. 10. Check if step, if so return. If not, goto 1. Before record_wait return, it will call iterate_over_threads (record_thread_stop_callback, NULL) to stop each thread that record_is_waiting is 1. And if this is a single thread or just one thread exec, record will exec it like before. record_new_thread_observer and record_thread_exit_observer make record know how much thread in inferior. 2009-11-25 Hui Zhu * record.c (observer.h): New include. (RECORD_THREAD): New macro. (record_type): Add record_ptid. (record_entry): Add ptid. (record_prev_ptid, record_new_thread_observer, record_thread_exit_observer): New variable. (record_ptid_alloc, record_ptid_release): New function. (record_entry_release): Add record_ptid. (record_entry_remove_from_list, record_arch_list_add_ptid): New function. (record_message_args): Remove regcache. (record_message): Add code for multithread. (do_record_message): Remove regcache. (record_exec_insn): Remove regcache, gdbarch. Add regcache_p, gdbarch_p, aspace_p. Add suport for record_ptid. (record_thread_number): New variable. (record_thread_number_count, record_thread_number_reset, record_new_thread_handler, record_thread_exit_handler): New function. (record_open_1): Add record_new_thread_observer and record_thread_exit_observer. (record_open): Add record_prev_ptid and record_thread_number_reset. (record_close): Add record_new_thread_observer and record_thread_exit_observer. (record_resume_ptid, record_resume_signal): New variable. (record_resume): Add code for multithread. (record_thread_wait_args): New struct. (record_thread_reset_callback, record_thread_stop_callback, record_thread_wait, record_thread_wait_callback, record_wait_signal_cleanups) New function. (record_wait_cleanups): Change to record_wait_replay_cleanups. (record_wait_mthread_cleanups): New function. (record_wait): Add code for multithread. (record_registers_change): Ditto. (record_xfer_partial): Ditto. (record_restore): Add code restore record_ptid entry. (cmd_record_save): Add code save record_ptid entry. (record_goto_insn): Update argument to call record_exec_insn. record.h (record_step): New extern. --- record.c | 734 ++++++++++++++++++++++++++++++++++++++++++++++++++++++--------- record.h | 1 2 files changed, 631 insertions(+), 104 deletions(-) --- a/record.c +++ b/record.c @@ -30,6 +30,7 @@ #include "record.h" #include "elf-bfd.h" #include "gcore.h" +#include "observer.h" #include @@ -60,6 +61,8 @@ #define RECORD_FILE_MAGIC netorder32(0x20091016) +#define RECORD_THREAD (current_target.beneath->beneath->to_stratum == thread_stratum) + /* These are the core structs of the process record functionality. A record_entry is a record of the value change of a register @@ -106,7 +109,8 @@ enum record_type { record_end = 0, record_reg, - record_mem + record_mem, + record_ptid }; /* This is the data structure that makes up the execution log. @@ -144,6 +148,8 @@ struct record_entry struct record_reg_entry reg; /* mem */ struct record_mem_entry mem; + /* ptid */ + ptid_t ptid; /* end */ struct record_end_entry end; } u; @@ -196,10 +202,19 @@ static int record_insn_num = 0; than count of insns presently in execution log). */ static ULONGEST record_insn_count; +/* In record mode, it's the step of next resume. */ +int record_step; + +/* The current inferior_ptid that is recorded. */ +static ptid_t record_prev_ptid; + /* The target_ops of process record. */ static struct target_ops record_ops; static struct target_ops record_core_ops; +static struct observer *record_new_thread_observer = NULL; +static struct observer *record_thread_exit_observer = NULL; + /* The beneath function pointers. */ static struct target_ops *record_beneath_to_resume_ops; static void (*record_beneath_to_resume) (struct target_ops *, ptid_t, int, @@ -288,6 +303,27 @@ record_mem_release (struct record_entry xfree (rec); } +/* Alloc a record_ptid record entry. */ + +static inline struct record_entry * +record_ptid_alloc (void) +{ + struct record_entry *rec; + + rec = (struct record_entry *) xcalloc (1, sizeof (struct record_entry)); + rec->type = record_ptid; + + return rec; +} + +/* Free a record_ptid record entry. */ + +static inline void +record_ptid_release (struct record_entry *rec) +{ + xfree (rec); +} + /* Alloc a record_end record entry. */ static inline struct record_entry * @@ -324,6 +360,9 @@ record_entry_release (struct record_entr case record_mem: record_mem_release (rec); break; + case record_ptid: + record_ptid_release (rec); + break; case record_end: record_end_release (rec); break; @@ -331,6 +370,16 @@ record_entry_release (struct record_entr return type; } +/* Remove one record entry from record_list. */ + +static void +record_entry_remove_from_list (struct record_entry *rec) +{ + if (rec->next) + rec->next->prev = rec->prev; + rec->prev->next = rec->next; +} + /* Free all record entries in list pointed to by REC. */ static void @@ -512,6 +561,24 @@ record_arch_list_add_mem (CORE_ADDR addr return 0; } +static void +record_arch_list_add_ptid (ptid_t *ptid) +{ + struct record_entry *rec; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: add ptid = %s to " + "record list.\n", + target_pid_to_str (*ptid)); + + rec = record_ptid_alloc (); + + rec->u.ptid = *ptid; + + record_arch_list_add (rec); +} + /* Add a record_end type struct record_entry to record_arch_list. */ int @@ -573,7 +640,6 @@ record_arch_list_cleanups (void *ignore) record_arch_list, and add it to record_list. */ struct record_message_args { - struct regcache *regcache; enum target_signal signal; }; @@ -582,15 +648,21 @@ record_message (void *args) { int ret; struct record_message_args *myargs = args; - struct gdbarch *gdbarch = get_regcache_arch (myargs->regcache); + struct regcache *regcache; + struct gdbarch *gdbarch; struct cleanup *old_cleanups = make_cleanup (record_arch_list_cleanups, 0); + record_step = 1; + record_arch_list_head = NULL; record_arch_list_tail = NULL; /* Check record_insn_num. */ record_check_insn_num (1); + regcache = get_current_regcache (); + gdbarch = get_regcache_arch (regcache); + /* If gdb sends a signal value to target_resume, save it in the 'end' field of the previous instruction. @@ -613,20 +685,45 @@ record_message (void *args) But we should still deliver the signal to gdb during the replay, if we delivered it during the recording. Therefore we should record the signal during record_wait, not record_resume. */ - if (record_list != &record_first) /* FIXME better way to check */ + if (ptid_equal (record_prev_ptid, inferior_ptid)) { - gdb_assert (record_list->type == record_end); - record_list->u.end.sigval = myargs->signal; + if (myargs->signal != TARGET_SIGNAL_0) + { + gdb_assert (record_list->type == record_end); + record_list->u.end.sigval = myargs->signal; + } + } + else + { + if (myargs->signal != TARGET_SIGNAL_0) + { + struct record_entry *rec; + for (rec = record_list; rec != record_first.next; rec = rec->prev) + { + if (rec->type == record_ptid + && ptid_equal (rec->u.ptid, inferior_ptid)) + { + gdb_assert (rec->prev->type == record_end); + rec->prev->u.end.sigval = myargs->signal; + break; + } + } + } + + /* If the inferior_ptid change (inferior_ptid is not same with + record_prev_ptid), record record_prev_ptid to record list. */ + record_arch_list_add_ptid (&record_prev_ptid); + record_prev_ptid = inferior_ptid; } if (myargs->signal == TARGET_SIGNAL_0 || !gdbarch_process_record_signal_p (gdbarch)) ret = gdbarch_process_record (gdbarch, - myargs->regcache, - regcache_read_pc (myargs->regcache)); + regcache, + regcache_read_pc (regcache)); else ret = gdbarch_process_record_signal (gdbarch, - myargs->regcache, + regcache, myargs->signal); if (ret > 0) @@ -649,12 +746,10 @@ record_message (void *args) } static int -do_record_message (struct regcache *regcache, - enum target_signal signal, int catch) +do_record_message (enum target_signal signal, int catch) { struct record_message_args args; - args.regcache = regcache; args.signal = signal; if (catch) @@ -688,9 +783,14 @@ static int record_hw_watchpoint = 0; entries and memory entries, followed by an 'end' entry. */ static inline void -record_exec_insn (struct regcache *regcache, struct gdbarch *gdbarch, +record_exec_insn (struct regcache **regcache_p, + struct gdbarch **gdbarch_p, + struct address_space **aspace_p, struct record_entry *entry) { + struct regcache *regcache = *regcache_p; + struct gdbarch *gdbarch = *gdbarch_p; + switch (entry->type) { case record_reg: /* reg */ @@ -769,6 +869,110 @@ record_exec_insn (struct regcache *regca } } break; + + case record_ptid: /* ptid */ + { + ptid_t tmp_ptid; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_ptid %s to " + "inferior ptid = %s.\n", + host_address_to_string (entry), + target_pid_to_str (entry->u.ptid)); + + if (!ptid_equal (entry->u.ptid, null_ptid)) + { + inferior_ptid = entry->u.ptid; + *regcache_p = get_current_regcache (); + *gdbarch_p = get_regcache_arch (*regcache_p); + *aspace_p = get_regcache_aspace (*regcache_p); + } + tmp_ptid = entry->u.ptid; + entry->u.ptid = record_prev_ptid; + record_prev_ptid = tmp_ptid; + } + break; + } +} + +static int record_thread_number; + +static int +record_thread_number_count (struct thread_info *thread, void *unused) +{ + if (thread->state_ != THREAD_EXITED) + record_thread_number ++; + + return 0; +} + +static void +record_thread_number_reset (void) +{ + record_thread_number = 0; + + if (RECORD_THREAD) + iterate_over_threads (record_thread_number_count, NULL); +} + +static void +record_new_thread_handler (struct thread_info *tp) +{ + tp->record_is_waiting = 0; + + record_thread_number_reset (); +} + +static void +record_thread_exit_handler (struct thread_info *tp, int silent) +{ + struct record_entry *rec; + ptid_t cur_ptid = record_prev_ptid; + + if (!record_first.next) + return; + + tp->record_is_waiting = 0; + + if (tp->state_ != THREAD_EXITED) + { + gdb_assert (record_thread_number > 0); + record_thread_number --; + } + + /* Delete all the record_reg and record_ptid for tp->ptid + from record list. */ + for (rec = record_list; rec != &record_first;) + { + struct record_entry *tmp = rec; + rec = rec->prev; + + switch (tmp->type) { + case record_reg: + /* If this record_reg is for tp->ptid, delte it. */ + if (ptid_equal (cur_ptid, tp->ptid)) + { + record_entry_remove_from_list (tmp); + record_entry_release (tmp); + } + break; + case record_ptid: + /* If this record_ptid is for tp->ptid, delte it. */ + cur_ptid = tmp->u.ptid; + if (ptid_equal (record_prev_ptid, tp->ptid)) + { + record_prev_ptid = cur_ptid; + record_entry_remove_from_list (tmp); + record_entry_release (tmp); + } + else if (ptid_equal (cur_ptid, tp->ptid)) + { + record_entry_remove_from_list (tmp); + record_entry_release (tmp); + } + break; + } } } @@ -865,6 +1069,9 @@ record_open_1 (char *name, int from_tty) error (_("Could not find 'to_remove_breakpoint' method on the target stack.")); push_target (&record_ops); + + record_new_thread_observer = observer_attach_new_thread (record_new_thread_handler); + record_thread_exit_observer = observer_attach_thread_exit (record_thread_exit_handler); } /* "to_open" target method. Open the process record target. */ @@ -934,6 +1141,7 @@ record_open (char *name, int from_tty) record_insn_count = 0; record_list = &record_first; record_list->next = NULL; + record_prev_ptid = null_ptid; /* Set the tmp beneath pointers to beneath pointers. */ record_beneath_to_resume_ops = tmp_to_resume_ops; @@ -953,6 +1161,8 @@ record_open (char *name, int from_tty) record_core_open_1 (name, from_tty); else record_open_1 (name, from_tty); + + record_thread_number_reset (); } /* "to_close" target method. Close the process record target. */ @@ -965,6 +1175,17 @@ record_close (int quitting) if (record_debug) fprintf_unfiltered (gdb_stdlog, "Process record: record_close\n"); + if (record_new_thread_observer) + { + observer_detach_new_thread (record_new_thread_observer); + record_new_thread_observer = NULL; + } + if (record_thread_exit_observer) + { + observer_detach_thread_exit (record_thread_exit_observer); + record_thread_exit_observer = NULL; + } + record_list_release (record_list); /* Release record_core_regbuf. */ @@ -987,6 +1208,8 @@ record_close (int quitting) } static int record_resume_step = 0; +static ptid_t record_resume_ptid; +static enum target_signal record_resume_signal = TARGET_SIGNAL_0; /* "to_resume" target method. Resume the process record target. */ @@ -998,10 +1221,201 @@ record_resume (struct target_ops *ops, p if (!RECORD_IS_REPLAY) { - do_record_message (get_current_regcache (), signal, 0); - record_beneath_to_resume (record_beneath_to_resume_ops, ptid, 1, - signal); + record_resume_ptid = ptid; + if (record_thread_number > 1 && !ptid_equal (ptid, inferior_ptid)) + { + record_resume_signal = signal; + } + else + { + do_record_message (signal, 0); + record_beneath_to_resume (record_beneath_to_resume_ops, ptid, + record_step, signal); + } + } +} + +struct record_thread_wait_args { + ptid_t real_inferior_ptid; + struct thread_info *real_inferior_tp; + struct target_waitstatus real_inferior_status; + + struct target_waitstatus *status; + int options; +}; + +static int +record_thread_reset_callback (struct thread_info *tp, void *data) +{ + tp->record_is_waiting = 0; + + return 0; +} + +static int +record_thread_stop_callback (struct thread_info *tp, void *data) +{ + if (tp->state_ != THREAD_EXITED && tp->record_is_waiting) + target_stop (tp->ptid); + + return 0; +} + +/* Return 1 if it is not a simple step. + Return 0 if it is a simple step. */ + +static int +record_thread_wait (ptid_t ptid, struct target_waitstatus *status, + int options, ptid_t *ret_ptid) +{ + ptid_t wait_ptid = record_beneath_to_wait (record_beneath_to_wait_ops, + ptid, status, options); + + if (ret_ptid) + *ret_ptid = wait_ptid; + + if (status->kind == TARGET_WAITKIND_IGNORE) + return 0; + + inferior_ptid = wait_ptid; + + /* Is this a SIGTRAP? */ + if (status->kind == TARGET_WAITKIND_STOPPED + && status->value.sig == TARGET_SIGNAL_TRAP) + { + CORE_ADDR tmp_pc; + struct regcache *regcache; + struct gdbarch *gdbarch; + struct address_space *aspace; + CORE_ADDR decr_pc_after_break; + + /* Yes -- this is likely our single-step finishing, + but check if there's any reason the core would be + interested in the event. */ + + registers_changed (); + regcache = get_current_regcache (); + gdbarch = get_regcache_arch (regcache); + tmp_pc = regcache_read_pc (regcache); + aspace = get_regcache_aspace (regcache); + decr_pc_after_break = gdbarch_decr_pc_after_break (gdbarch); + + /* To check if this is breakpoint need the right pc, if this is not + a single step. So we need adjust tmp_pc to make it right. */ + if (!record_step) + tmp_pc -= decr_pc_after_break; + + if (target_stopped_by_watchpoint ()) + { + /* Always interested in watchpoints. */ + return 1; + } + else if (breakpoint_inserted_here_p (aspace, tmp_pc)) + { + /* There is a breakpoint here. Let the core handle it. */ + if (record_step + && software_breakpoint_inserted_here_p (aspace, tmp_pc)) + { + if (decr_pc_after_break) + regcache_write_pc (regcache, tmp_pc + decr_pc_after_break); + } + + return 1; + } + + return 0; + } + + return 1; +} + +static int +record_thread_wait_callback (struct thread_info *tp, void *data) +{ + struct record_thread_wait_args *args = data; + enum target_signal sig = TARGET_SIGNAL_0; + int options = args->options; + int ret; + + if (tp->state_ == THREAD_EXITED) + return 0; + + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_thread_wait_callback " + "resume %s\n", target_pid_to_str (tp->ptid)); + + inferior_ptid = tp->ptid; + + if (!tp->record_is_waiting) + { + if (record_resume_signal != TARGET_SIGNAL_0 + && ptid_equal (inferior_ptid, args->real_inferior_ptid)) + { + sig = record_resume_signal; + record_resume_signal = TARGET_SIGNAL_0; + } + if (!do_record_message (sig, 1)) + { + args->status->kind = TARGET_WAITKIND_STOPPED; + args->status->value.sig = TARGET_SIGNAL_0; + return 1; + } + + if (record_step == 0) + { + /* The next insn is a sys_clone. */ + iterate_over_threads (record_thread_stop_callback, NULL); + non_stop = 0; + } + + record_beneath_to_resume (record_beneath_to_resume_ops, inferior_ptid, + record_step, sig); + } + else + { + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_thread_wait_callback " + "not resume %s\n", target_pid_to_str (tp->ptid)); + } + + if (record_step) + options |= TARGET_WNOHANG; + ret = record_thread_wait (inferior_ptid, args->status, + options, NULL); + if (args->status->kind == TARGET_WAITKIND_IGNORE) + { + if (!tp->record_is_waiting) + { + tp->record_is_waiting = 1; + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_thread_wait_callback " + "start waiting %s.\n", + target_pid_to_str (tp->ptid)); + } + } + else + { + if (tp->record_is_waiting) + { + tp->record_is_waiting = 0; + if (record_debug > 1) + fprintf_unfiltered (gdb_stdlog, + "Process record: record_thread_wait_callback " + "stop waiting %s.\n", + target_pid_to_str (tp->ptid)); + } + + if (!args->real_inferior_tp + && ptid_equal (inferior_ptid, args->real_inferior_ptid)) + args->real_inferior_tp = tp; + if (args->real_inferior_tp == tp) + args->real_inferior_status = *args->status; } + + return ret; } static int record_get_sig = 0; @@ -1023,7 +1437,13 @@ record_sig_handler (int signo) } static void -record_wait_cleanups (void *ignore) +record_wait_signal_cleanups (void *ignore) +{ + signal (SIGINT, handle_sigint); +} + +static void +record_wait_replay_cleanups (void *ignore) { if (execution_direction == EXEC_REVERSE) { @@ -1034,6 +1454,17 @@ record_wait_cleanups (void *ignore) record_list = record_list->prev; } +static void +record_wait_mthread_cleanups (void *ignore) +{ + non_stop = 1; + + /* Stop the threads that still running. */ + iterate_over_threads (record_thread_stop_callback, NULL); + + non_stop = 0; +} + /* "to_wait" target method for process record target. In record mode, the target is always run in singlestep mode @@ -1052,7 +1483,10 @@ record_wait (struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options) { + ptid_t ret_ptid; struct cleanup *set_cleanups = record_gdb_operation_disable_set (); + struct cleanup *signal_cleanups + = make_cleanup (record_wait_signal_cleanups, 0); if (record_debug) fprintf_unfiltered (gdb_stdlog, @@ -1060,93 +1494,112 @@ record_wait (struct target_ops *ops, "record_resume_step = %d\n", record_resume_step); + record_get_sig = 0; + signal (SIGINT, record_sig_handler); + if (!RECORD_IS_REPLAY && ops != &record_core_ops) { - if (record_resume_step) - { - /* This is a single step. */ - return record_beneath_to_wait (record_beneath_to_wait_ops, - ptid, status, options); - } - else - { - /* This is not a single step. */ - ptid_t ret; - CORE_ADDR tmp_pc; + /* Record mode. */ + if (record_thread_number > 1 && !ptid_equal (record_resume_ptid, + inferior_ptid)) + { + /* Multi-threads record. */ + struct record_thread_wait_args args; + struct thread_info *tp; + struct cleanup *mthread_cleanups + = make_cleanup (record_wait_mthread_cleanups, 0); - while (1) - { - ret = record_beneath_to_wait (record_beneath_to_wait_ops, - ptid, status, options); + args.real_inferior_ptid = inferior_ptid; + args.real_inferior_tp = NULL; + args.status = status; + args.options = options; + non_stop = 1; + iterate_over_threads (record_thread_reset_callback, NULL); - /* Is this a SIGTRAP? */ - if (status->kind == TARGET_WAITKIND_STOPPED - && status->value.sig == TARGET_SIGNAL_TRAP) - { - struct regcache *regcache; - struct address_space *aspace; + while (1) + { + tp = iterate_over_threads (record_thread_wait_callback, &args); + if (tp) + break; + if (record_resume_step + && args.real_inferior_tp + && !args.real_inferior_tp->record_is_waiting) + { + *status = args.real_inferior_status; + inferior_ptid = args.real_inferior_ptid; + break; + } + } - /* Yes -- this is likely our single-step finishing, - but check if there's any reason the core would be - interested in the event. */ + do_cleanups (mthread_cleanups); - registers_changed (); - regcache = get_current_regcache (); - tmp_pc = regcache_read_pc (regcache); - aspace = get_regcache_aspace (regcache); + if (tp && tp->state_ != THREAD_EXITED) + { + inferior_ptid = tp->ptid; + } + ret_ptid = inferior_ptid; + } + else + { + /* Single-thread record. */ + if (record_thread_number > 1) + ptid = record_resume_ptid; - if (target_stopped_by_watchpoint ()) - { - /* Always interested in watchpoints. */ - } - else if (breakpoint_inserted_here_p (aspace, tmp_pc)) - { - /* There is a breakpoint here. Let the core - handle it. */ - if (software_breakpoint_inserted_here_p (aspace, tmp_pc)) - { - struct gdbarch *gdbarch = get_regcache_arch (regcache); - CORE_ADDR decr_pc_after_break - = gdbarch_decr_pc_after_break (gdbarch); - if (decr_pc_after_break) - regcache_write_pc (regcache, - tmp_pc + decr_pc_after_break); - } - } - else - { - /* This must be a single-step trap. Record the - insn and issue another step. */ - if (!do_record_message (regcache, TARGET_SIGNAL_0, 1)) - { - status->kind = TARGET_WAITKIND_STOPPED; - status->value.sig = TARGET_SIGNAL_0; - break; - } + if (record_resume_step) + { + /* This is a single step. */ + ret_ptid = record_beneath_to_wait (record_beneath_to_wait_ops, + ptid, status, options); + } + else + { + /* This is not a single step. */ + while (1) + { + if (record_thread_wait (ptid, status, + options, &ret_ptid)) + break; - record_beneath_to_resume (record_beneath_to_resume_ops, - ptid, 1, - TARGET_SIGNAL_0); - continue; - } - } + if (record_resume_step) + break; - /* The inferior is broken by a breakpoint or a signal. */ - break; - } + /* There is not a breakpoint, and gdb is not + stepping, therefore gdb will not stop. + Therefore we will not return to gdb. + Record the insn and resume. */ + if (!do_record_message (TARGET_SIGNAL_0, 1)) + { + ret_ptid = inferior_ptid; + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_0; + break; + } - return ret; - } + record_beneath_to_resume (record_beneath_to_resume_ops, + record_resume_ptid, record_step, + TARGET_SIGNAL_0); + } + } + } } else { - struct regcache *regcache = get_current_regcache (); - struct gdbarch *gdbarch = get_regcache_arch (regcache); - struct address_space *aspace = get_regcache_aspace (regcache); + /* Replay mode. */ + struct regcache *regcache; + struct gdbarch *gdbarch; + struct address_space *aspace; int continue_flag = 1; int first_record_end = 1; - struct cleanup *old_cleanups = make_cleanup (record_wait_cleanups, 0); + struct cleanup *old_cleanups = + make_cleanup (record_wait_replay_cleanups, 0); CORE_ADDR tmp_pc; + ptid_t old_inferior_ptid = inferior_ptid; + + if (!ptid_equal (record_prev_ptid, null_ptid)) + inferior_ptid = record_prev_ptid; + regcache = get_current_regcache (); + gdbarch = get_regcache_arch (regcache); + aspace = get_regcache_aspace (regcache); record_hw_watchpoint = 0; status->kind = TARGET_WAITKIND_STOPPED; @@ -1173,8 +1626,6 @@ record_wait (struct target_ops *ops, } } - record_get_sig = 0; - signal (SIGINT, record_sig_handler); /* If GDB is in terminal_inferior mode, it will not get the signal. And in GDB replay mode, GDB doesn't need to be in terminal_inferior mode, because inferior will not executed. @@ -1205,7 +1656,7 @@ record_wait (struct target_ops *ops, break; } - record_exec_insn (regcache, gdbarch, record_list); + record_exec_insn (®cache, &gdbarch, &aspace, record_list); if (record_list->type == record_end) { @@ -1228,19 +1679,20 @@ record_wait (struct target_ops *ops, In EXEC_FORWARD mode, this is the record_end of current instruction. */ /* step */ - if (record_resume_step) + if (record_resume_step + && ptid_equal (inferior_ptid, old_inferior_ptid)) { if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, "Process record: step.\n"); - continue_flag = 0; + continue_flag = 0; } /* check breakpoint */ tmp_pc = regcache_read_pc (regcache); if (breakpoint_inserted_here_p (aspace, tmp_pc)) { - int decr_pc_after_break + CORE_ADDR decr_pc_after_break = gdbarch_decr_pc_after_break (gdbarch); if (record_debug) @@ -1288,22 +1740,23 @@ Process record: hit hw watchpoint.\n"); } while (continue_flag); - signal (SIGINT, handle_sigint); - replay_out: - if (record_get_sig) - status->value.sig = TARGET_SIGNAL_INT; - else if (record_list->u.end.sigval != TARGET_SIGNAL_0) + if (record_list->u.end.sigval != TARGET_SIGNAL_0) /* FIXME: better way to check */ status->value.sig = record_list->u.end.sigval; else status->value.sig = TARGET_SIGNAL_TRAP; + ret_ptid = inferior_ptid; discard_cleanups (old_cleanups); } + if (record_get_sig) + status->value.sig = TARGET_SIGNAL_INT; + + do_cleanups (signal_cleanups); do_cleanups (set_cleanups); - return inferior_ptid; + return ret_ptid; } static int @@ -1384,6 +1837,12 @@ record_registers_change (struct regcache record_arch_list_head = NULL; record_arch_list_tail = NULL; + if (!ptid_equal (record_prev_ptid, inferior_ptid)) + { + record_arch_list_add_ptid (&record_prev_ptid); + record_prev_ptid = inferior_ptid; + } + if (regnum < 0) { int i; @@ -1506,6 +1965,11 @@ record_xfer_partial (struct target_ops * /* Record registers change to list as an instruction. */ record_arch_list_head = NULL; record_arch_list_tail = NULL; + if (!ptid_equal (record_prev_ptid, inferior_ptid)) + { + record_arch_list_add_ptid (&record_prev_ptid); + record_prev_ptid = inferior_ptid; + } if (record_arch_list_add_mem (offset, len)) { record_list_release (record_arch_list_tail); @@ -2061,6 +2525,17 @@ info_record_command (char *args, int fro 4 bytes: memory length (network byte order). 8 bytes: memory address (network byte order). n bytes: memory value (n == memory length). + record_mem: + 1 byte: record type (record_mem, see enum record_type). + 4 bytes: memory length (network byte order). + 8 bytes: memory address (network byte order). + n bytes: memory value (n == memory length). + record_ptid: + 1 byte: record type (record_ptid, see enum record_type). + 8 bytes: process id (network byte order). + It must same with CORELOW_PID (1). + 8 bytes: lightweight process id (network byte order). + 8 bytes: thread id (network byte order). */ @@ -2222,6 +2697,32 @@ record_restore (void) rec->u.mem.len); break; + case record_ptid: /* ptid */ + rec = record_ptid_alloc (); + + /* Get Process id. */ + bfdcore_read (core_bfd, osec, &addr, + sizeof (addr), &bfd_offset); + rec->u.ptid.pid = (int) netorder64 (addr); + + /* Get Lightweight process id. */ + bfdcore_read (core_bfd, osec, &addr, + sizeof (addr), &bfd_offset); + rec->u.ptid.lwp = (long) netorder64 (addr); + + /* Get Thread id. */ + bfdcore_read (core_bfd, osec, &addr, + sizeof (addr), &bfd_offset); + rec->u.ptid.tid = (long) netorder64 (addr); + + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "\ + Reading ptid %s (1 + 8 + 8 + 8 bytes), offset == %s\n", + target_pid_to_str (record_list->u.ptid), + paddress (get_current_arch (), + bfd_offset)); + break; + case record_end: /* end */ rec = record_end_alloc (); record_insn_num ++; @@ -2327,6 +2828,7 @@ cmd_record_save (char *args, int from_tt uint32_t magic; struct regcache *regcache; struct gdbarch *gdbarch; + struct address_space *aspace; struct cleanup *old_cleanups; struct cleanup *set_cleanups; bfd *obfd; @@ -2363,6 +2865,7 @@ cmd_record_save (char *args, int from_tt /* Get the values of regcache and gdbarch. */ regcache = get_current_regcache (); gdbarch = get_regcache_arch (regcache); + aspace = get_regcache_aspace (regcache); /* Disable the GDB operation record. */ set_cleanups = record_gdb_operation_disable_set (); @@ -2374,7 +2877,7 @@ cmd_record_save (char *args, int from_tt if (record_list == &record_first) break; - record_exec_insn (regcache, gdbarch, record_list); + record_exec_insn (®cache, &gdbarch, &aspace, record_list); if (record_list->prev) record_list = record_list->prev; @@ -2395,6 +2898,9 @@ cmd_record_save (char *args, int from_tt case record_mem: save_size += 1 + 4 + 8 + record_list->u.mem.len; break; + case record_ptid: + save_size += 1 + 8 + 8 + 8; + break; } /* Make the new bfd section. */ @@ -2481,6 +2987,25 @@ cmd_record_save (char *args, int from_tt record_list->u.mem.len, &bfd_offset); break; + case record_ptid: /* ptid */ + if (record_debug) + fprintf_unfiltered (gdb_stdlog, "\ + Writing ptid %s (1 plus 8 plus 8 plus 8 bytes)\n", + target_pid_to_str (record_list->u.ptid)); + + /* Write Process id. */ + addr = netorder64 ((uint64_t) 1); + bfdcore_write (obfd, osec, &addr, sizeof (addr), &bfd_offset); + + /* Write Lightweight process id. */ + addr = netorder64 ((uint64_t) record_list->u.ptid.lwp); + bfdcore_write (obfd, osec, &addr, sizeof (addr), &bfd_offset); + + /* Write Thread id. */ + addr = netorder64 ((uint64_t) record_list->u.ptid.tid); + bfdcore_write (obfd, osec, &addr, sizeof (addr), &bfd_offset); + break; + case record_end: if (record_debug) fprintf_unfiltered (gdb_stdlog, "\ @@ -2501,7 +3026,7 @@ cmd_record_save (char *args, int from_tt } /* Execute entry. */ - record_exec_insn (regcache, gdbarch, record_list); + record_exec_insn (®cache, &gdbarch, &aspace, record_list); if (record_list->next) record_list = record_list->next; @@ -2516,7 +3041,7 @@ cmd_record_save (char *args, int from_tt if (record_list == cur_record_list) break; - record_exec_insn (regcache, gdbarch, record_list); + record_exec_insn (®cache, &gdbarch, &aspace, record_list); if (record_list->prev) record_list = record_list->prev; @@ -2542,6 +3067,7 @@ record_goto_insn (struct record_entry *e struct cleanup *set_cleanups = record_gdb_operation_disable_set (); struct regcache *regcache = get_current_regcache (); struct gdbarch *gdbarch = get_regcache_arch (regcache); + struct address_space *aspace = get_regcache_aspace (regcache); /* Assume everything is valid: we will hit the entry, and we will not hit the end of the recording. */ @@ -2551,7 +3077,7 @@ record_goto_insn (struct record_entry *e do { - record_exec_insn (regcache, gdbarch, record_list); + record_exec_insn (®cache, &gdbarch, &aspace, record_list); if (dir == EXEC_REVERSE) record_list = record_list->prev; else --- a/record.h +++ b/record.h @@ -23,6 +23,7 @@ #define RECORD_IS_USED (current_target.to_stratum == record_stratum) extern int record_debug; +extern int record_step; extern int record_arch_list_add_reg (struct regcache *regcache, int num); extern int record_arch_list_add_mem (CORE_ADDR addr, int len); --00504502b22edcc1b804792d8914 Content-Type: text/plain; charset=US-ASCII; name="prec-thread-target.txt" Content-Disposition: attachment; filename="prec-thread-target.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_g2fthr9c0 Content-length: 45702 LS0tCiByZWNvcmQuYyB8ICA3MzQgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tCiByZWNv cmQuaCB8ICAgIDEgCiAyIGZpbGVzIGNoYW5nZWQsIDYzMSBpbnNlcnRpb25z KCspLCAxMDQgZGVsZXRpb25zKC0pCgotLS0gYS9yZWNvcmQuYworKysgYi9y ZWNvcmQuYwpAQCAtMzAsNiArMzAsNyBAQAogI2luY2x1ZGUgInJlY29yZC5o IgogI2luY2x1ZGUgImVsZi1iZmQuaCIKICNpbmNsdWRlICJnY29yZS5oIgor I2luY2x1ZGUgIm9ic2VydmVyLmgiCiAKICNpbmNsdWRlIDxzaWduYWwuaD4K IApAQCAtNjAsNiArNjEsOCBAQAogCiAjZGVmaW5lIFJFQ09SRF9GSUxFX01B R0lDCW5ldG9yZGVyMzIoMHgyMDA5MTAxNikKIAorI2RlZmluZSBSRUNPUkRf VEhSRUFECShjdXJyZW50X3RhcmdldC5iZW5lYXRoLT5iZW5lYXRoLT50b19z dHJhdHVtID09IHRocmVhZF9zdHJhdHVtKQorCiAvKiBUaGVzZSBhcmUgdGhl IGNvcmUgc3RydWN0cyBvZiB0aGUgcHJvY2VzcyByZWNvcmQgZnVuY3Rpb25h bGl0eS4KIAogICAgQSByZWNvcmRfZW50cnkgaXMgYSByZWNvcmQgb2YgdGhl IHZhbHVlIGNoYW5nZSBvZiBhIHJlZ2lzdGVyCkBAIC0xMDYsNyArMTA5LDgg QEAgZW51bSByZWNvcmRfdHlwZQogewogICByZWNvcmRfZW5kID0gMCwKICAg cmVjb3JkX3JlZywKLSAgcmVjb3JkX21lbQorICByZWNvcmRfbWVtLAorICBy ZWNvcmRfcHRpZAogfTsKIAogLyogVGhpcyBpcyB0aGUgZGF0YSBzdHJ1Y3R1 cmUgdGhhdCBtYWtlcyB1cCB0aGUgZXhlY3V0aW9uIGxvZy4KQEAgLTE0NCw2 ICsxNDgsOCBAQCBzdHJ1Y3QgcmVjb3JkX2VudHJ5CiAgICAgc3RydWN0IHJl Y29yZF9yZWdfZW50cnkgcmVnOwogICAgIC8qIG1lbSAqLwogICAgIHN0cnVj dCByZWNvcmRfbWVtX2VudHJ5IG1lbTsKKyAgICAvKiBwdGlkICovCisgICAg cHRpZF90IHB0aWQ7CiAgICAgLyogZW5kICovCiAgICAgc3RydWN0IHJlY29y ZF9lbmRfZW50cnkgZW5kOwogICB9IHU7CkBAIC0xOTYsMTAgKzIwMiwxOSBA QCBzdGF0aWMgaW50IHJlY29yZF9pbnNuX251bSA9IDA7CiAgICB0aGFuIGNv dW50IG9mIGluc25zIHByZXNlbnRseSBpbiBleGVjdXRpb24gbG9nKS4gICov CiBzdGF0aWMgVUxPTkdFU1QgcmVjb3JkX2luc25fY291bnQ7CiAKKy8qIElu IHJlY29yZCBtb2RlLCBpdCdzIHRoZSBzdGVwIG9mIG5leHQgcmVzdW1lLiAg Ki8KK2ludCByZWNvcmRfc3RlcDsKKworLyogVGhlIGN1cnJlbnQgaW5mZXJp b3JfcHRpZCB0aGF0IGlzIHJlY29yZGVkLiAgKi8KK3N0YXRpYyBwdGlkX3Qg cmVjb3JkX3ByZXZfcHRpZDsKKwogLyogVGhlIHRhcmdldF9vcHMgb2YgcHJv Y2VzcyByZWNvcmQuICAqLwogc3RhdGljIHN0cnVjdCB0YXJnZXRfb3BzIHJl Y29yZF9vcHM7CiBzdGF0aWMgc3RydWN0IHRhcmdldF9vcHMgcmVjb3JkX2Nv cmVfb3BzOwogCitzdGF0aWMgc3RydWN0IG9ic2VydmVyICpyZWNvcmRfbmV3 X3RocmVhZF9vYnNlcnZlciA9IE5VTEw7CitzdGF0aWMgc3RydWN0IG9ic2Vy dmVyICpyZWNvcmRfdGhyZWFkX2V4aXRfb2JzZXJ2ZXIgPSBOVUxMOworCiAv KiBUaGUgYmVuZWF0aCBmdW5jdGlvbiBwb2ludGVycy4gICovCiBzdGF0aWMg c3RydWN0IHRhcmdldF9vcHMgKnJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZV9v cHM7CiBzdGF0aWMgdm9pZCAoKnJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZSkg KHN0cnVjdCB0YXJnZXRfb3BzICosIHB0aWRfdCwgaW50LApAQCAtMjg4LDYg KzMwMywyNyBAQCByZWNvcmRfbWVtX3JlbGVhc2UgKHN0cnVjdCByZWNvcmRf ZW50cnkgCiAgIHhmcmVlIChyZWMpOwogfQogCisvKiBBbGxvYyBhIHJlY29y ZF9wdGlkIHJlY29yZCBlbnRyeS4gICovCisKK3N0YXRpYyBpbmxpbmUgc3Ry dWN0IHJlY29yZF9lbnRyeSAqCityZWNvcmRfcHRpZF9hbGxvYyAodm9pZCkK K3sKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVjOworCisgIHJlYyA9IChz dHJ1Y3QgcmVjb3JkX2VudHJ5ICopIHhjYWxsb2MgKDEsIHNpemVvZiAoc3Ry dWN0IHJlY29yZF9lbnRyeSkpOworICByZWMtPnR5cGUgPSByZWNvcmRfcHRp ZDsKKworICByZXR1cm4gcmVjOworfQorCisvKiBGcmVlIGEgcmVjb3JkX3B0 aWQgcmVjb3JkIGVudHJ5LiAgKi8KKworc3RhdGljIGlubGluZSB2b2lkCity ZWNvcmRfcHRpZF9yZWxlYXNlIChzdHJ1Y3QgcmVjb3JkX2VudHJ5ICpyZWMp Cit7CisgIHhmcmVlIChyZWMpOworfQorCiAvKiBBbGxvYyBhIHJlY29yZF9l bmQgcmVjb3JkIGVudHJ5LiAgKi8KIAogc3RhdGljIGlubGluZSBzdHJ1Y3Qg cmVjb3JkX2VudHJ5ICoKQEAgLTMyNCw2ICszNjAsOSBAQCByZWNvcmRfZW50 cnlfcmVsZWFzZSAoc3RydWN0IHJlY29yZF9lbnRyCiAgIGNhc2UgcmVjb3Jk X21lbToKICAgICByZWNvcmRfbWVtX3JlbGVhc2UgKHJlYyk7CiAgICAgYnJl YWs7CisgIGNhc2UgcmVjb3JkX3B0aWQ6CisgICAgcmVjb3JkX3B0aWRfcmVs ZWFzZSAocmVjKTsKKyAgICBicmVhazsKICAgY2FzZSByZWNvcmRfZW5kOgog ICAgIHJlY29yZF9lbmRfcmVsZWFzZSAocmVjKTsKICAgICBicmVhazsKQEAg LTMzMSw2ICszNzAsMTYgQEAgcmVjb3JkX2VudHJ5X3JlbGVhc2UgKHN0cnVj dCByZWNvcmRfZW50cgogICByZXR1cm4gdHlwZTsKIH0KIAorLyogUmVtb3Zl IG9uZSByZWNvcmQgZW50cnkgZnJvbSByZWNvcmRfbGlzdC4gICovCisKK3N0 YXRpYyB2b2lkCityZWNvcmRfZW50cnlfcmVtb3ZlX2Zyb21fbGlzdCAoc3Ry dWN0IHJlY29yZF9lbnRyeSAqcmVjKQoreworICBpZiAocmVjLT5uZXh0KQor ICAgIHJlYy0+bmV4dC0+cHJldiA9IHJlYy0+cHJldjsKKyAgcmVjLT5wcmV2 LT5uZXh0ID0gcmVjLT5uZXh0OworfQorCiAvKiBGcmVlIGFsbCByZWNvcmQg ZW50cmllcyBpbiBsaXN0IHBvaW50ZWQgdG8gYnkgUkVDLiAgKi8KIAogc3Rh dGljIHZvaWQKQEAgLTUxMiw2ICs1NjEsMjQgQEAgcmVjb3JkX2FyY2hfbGlz dF9hZGRfbWVtIChDT1JFX0FERFIgYWRkcgogICByZXR1cm4gMDsKIH0KIAor c3RhdGljIHZvaWQKK3JlY29yZF9hcmNoX2xpc3RfYWRkX3B0aWQgKHB0aWRf dCAqcHRpZCkKK3sKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVjOworCisg IGlmIChyZWNvcmRfZGVidWcgPiAxKQorICAgIGZwcmludGZfdW5maWx0ZXJl ZCAoZ2RiX3N0ZGxvZywKKwkJCSJQcm9jZXNzIHJlY29yZDogYWRkIHB0aWQg PSAlcyB0byAiCisJCQkicmVjb3JkIGxpc3QuXG4iLAorCQkJdGFyZ2V0X3Bp ZF90b19zdHIgKCpwdGlkKSk7CisKKyAgcmVjID0gcmVjb3JkX3B0aWRfYWxs b2MgKCk7CisKKyAgcmVjLT51LnB0aWQgPSAqcHRpZDsKKworICByZWNvcmRf YXJjaF9saXN0X2FkZCAocmVjKTsKK30KKwogLyogQWRkIGEgcmVjb3JkX2Vu ZCB0eXBlIHN0cnVjdCByZWNvcmRfZW50cnkgdG8gcmVjb3JkX2FyY2hfbGlz dC4gICovCiAKIGludApAQCAtNTczLDcgKzY0MCw2IEBAIHJlY29yZF9hcmNo X2xpc3RfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKICAgIHJlY29yZF9hcmNo X2xpc3QsIGFuZCBhZGQgaXQgdG8gcmVjb3JkX2xpc3QuICAqLwogCiBzdHJ1 Y3QgcmVjb3JkX21lc3NhZ2VfYXJncyB7Ci0gIHN0cnVjdCByZWdjYWNoZSAq cmVnY2FjaGU7CiAgIGVudW0gdGFyZ2V0X3NpZ25hbCBzaWduYWw7CiB9Owog CkBAIC01ODIsMTUgKzY0OCwyMSBAQCByZWNvcmRfbWVzc2FnZSAodm9pZCAq YXJncykKIHsKICAgaW50IHJldDsKICAgc3RydWN0IHJlY29yZF9tZXNzYWdl X2FyZ3MgKm15YXJncyA9IGFyZ3M7Ci0gIHN0cnVjdCBnZGJhcmNoICpnZGJh cmNoID0gZ2V0X3JlZ2NhY2hlX2FyY2ggKG15YXJncy0+cmVnY2FjaGUpOwor ICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlOworICBzdHJ1Y3QgZ2RiYXJj aCAqZ2RiYXJjaDsKICAgc3RydWN0IGNsZWFudXAgKm9sZF9jbGVhbnVwcyA9 IG1ha2VfY2xlYW51cCAocmVjb3JkX2FyY2hfbGlzdF9jbGVhbnVwcywgMCk7 CiAKKyAgcmVjb3JkX3N0ZXAgPSAxOworCiAgIHJlY29yZF9hcmNoX2xpc3Rf aGVhZCA9IE5VTEw7CiAgIHJlY29yZF9hcmNoX2xpc3RfdGFpbCA9IE5VTEw7 CiAKICAgLyogQ2hlY2sgcmVjb3JkX2luc25fbnVtLiAgKi8KICAgcmVjb3Jk X2NoZWNrX2luc25fbnVtICgxKTsKIAorICByZWdjYWNoZSA9IGdldF9jdXJy ZW50X3JlZ2NhY2hlICgpOworICBnZGJhcmNoID0gZ2V0X3JlZ2NhY2hlX2Fy Y2ggKHJlZ2NhY2hlKTsKKwogICAvKiBJZiBnZGIgc2VuZHMgYSBzaWduYWwg dmFsdWUgdG8gdGFyZ2V0X3Jlc3VtZSwKICAgICAgc2F2ZSBpdCBpbiB0aGUg J2VuZCcgZmllbGQgb2YgdGhlIHByZXZpb3VzIGluc3RydWN0aW9uLgogCkBA IC02MTMsMjAgKzY4NSw0NSBAQCByZWNvcmRfbWVzc2FnZSAodm9pZCAqYXJn cykKICAgICAgQnV0IHdlIHNob3VsZCBzdGlsbCBkZWxpdmVyIHRoZSBzaWdu YWwgdG8gZ2RiIGR1cmluZyB0aGUgcmVwbGF5LAogICAgICBpZiB3ZSBkZWxp dmVyZWQgaXQgZHVyaW5nIHRoZSByZWNvcmRpbmcuICBUaGVyZWZvcmUgd2Ug c2hvdWxkCiAgICAgIHJlY29yZCB0aGUgc2lnbmFsIGR1cmluZyByZWNvcmRf d2FpdCwgbm90IHJlY29yZF9yZXN1bWUuICAqLwotICBpZiAocmVjb3JkX2xp c3QgIT0gJnJlY29yZF9maXJzdCkgICAgLyogRklYTUUgYmV0dGVyIHdheSB0 byBjaGVjayAqLworICBpZiAocHRpZF9lcXVhbCAocmVjb3JkX3ByZXZfcHRp ZCwgaW5mZXJpb3JfcHRpZCkpCiAgICAgewotICAgICAgZ2RiX2Fzc2VydCAo cmVjb3JkX2xpc3QtPnR5cGUgPT0gcmVjb3JkX2VuZCk7Ci0gICAgICByZWNv cmRfbGlzdC0+dS5lbmQuc2lndmFsID0gbXlhcmdzLT5zaWduYWw7CisgICAg ICBpZiAobXlhcmdzLT5zaWduYWwgIT0gVEFSR0VUX1NJR05BTF8wKQorICAg ICAgICB7CisgICAgICAgICAgZ2RiX2Fzc2VydCAocmVjb3JkX2xpc3QtPnR5 cGUgPT0gcmVjb3JkX2VuZCk7CisgICAgICAgICAgcmVjb3JkX2xpc3QtPnUu ZW5kLnNpZ3ZhbCA9IG15YXJncy0+c2lnbmFsOworICAgICAgICB9CisgICAg fQorICBlbHNlCisgICAgeworICAgICAgaWYgKG15YXJncy0+c2lnbmFsICE9 IFRBUkdFVF9TSUdOQUxfMCkKKyAgICAgICAgeworICAgICAgICAgIHN0cnVj dCByZWNvcmRfZW50cnkgKnJlYzsKKyAgICAgICAgICBmb3IgKHJlYyA9IHJl Y29yZF9saXN0OyByZWMgIT0gcmVjb3JkX2ZpcnN0Lm5leHQ7IHJlYyA9IHJl Yy0+cHJldikKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgaWYgKHJl Yy0+dHlwZSA9PSByZWNvcmRfcHRpZAorICAgICAgICAgICAgICAgICAgJiYg cHRpZF9lcXVhbCAocmVjLT51LnB0aWQsIGluZmVyaW9yX3B0aWQpKQorICAg ICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgIGdkYl9hc3NlcnQg KHJlYy0+cHJldi0+dHlwZSA9PSByZWNvcmRfZW5kKTsKKyAgICAgICAgICAg ICAgICAgIHJlYy0+cHJldi0+dS5lbmQuc2lndmFsID0gbXlhcmdzLT5zaWdu YWw7CisgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAg ICB9CisgICAgICAgICAgICB9CisgICAgICAgIH0KKworICAgICAgLyogSWYg dGhlIGluZmVyaW9yX3B0aWQgY2hhbmdlIChpbmZlcmlvcl9wdGlkIGlzIG5v dCBzYW1lIHdpdGgKKyAgICAgICAgIHJlY29yZF9wcmV2X3B0aWQpLCByZWNv cmQgcmVjb3JkX3ByZXZfcHRpZCB0byByZWNvcmQgbGlzdC4gICovCisgICAg ICByZWNvcmRfYXJjaF9saXN0X2FkZF9wdGlkICgmcmVjb3JkX3ByZXZfcHRp ZCk7CisgICAgICByZWNvcmRfcHJldl9wdGlkID0gaW5mZXJpb3JfcHRpZDsK ICAgICB9CiAKICAgaWYgKG15YXJncy0+c2lnbmFsID09IFRBUkdFVF9TSUdO QUxfMAogICAgICAgfHwgIWdkYmFyY2hfcHJvY2Vzc19yZWNvcmRfc2lnbmFs X3AgKGdkYmFyY2gpKQogICAgIHJldCA9IGdkYmFyY2hfcHJvY2Vzc19yZWNv cmQgKGdkYmFyY2gsCi0JCQkJICBteWFyZ3MtPnJlZ2NhY2hlLAotCQkJCSAg cmVnY2FjaGVfcmVhZF9wYyAobXlhcmdzLT5yZWdjYWNoZSkpOworCQkJCSAg cmVnY2FjaGUsCisJCQkJICByZWdjYWNoZV9yZWFkX3BjIChyZWdjYWNoZSkp OwogICBlbHNlCiAgICAgcmV0ID0gZ2RiYXJjaF9wcm9jZXNzX3JlY29yZF9z aWduYWwgKGdkYmFyY2gsCi0JCQkJCSBteWFyZ3MtPnJlZ2NhY2hlLAorCQkJ CQkgcmVnY2FjaGUsCiAJCQkJCSBteWFyZ3MtPnNpZ25hbCk7CiAKICAgaWYg KHJldCA+IDApCkBAIC02NDksMTIgKzc0NiwxMCBAQCByZWNvcmRfbWVzc2Fn ZSAodm9pZCAqYXJncykKIH0KIAogc3RhdGljIGludAotZG9fcmVjb3JkX21l c3NhZ2UgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsCi0JCSAgIGVudW0g dGFyZ2V0X3NpZ25hbCBzaWduYWwsIGludCBjYXRjaCkKK2RvX3JlY29yZF9t ZXNzYWdlIChlbnVtIHRhcmdldF9zaWduYWwgc2lnbmFsLCBpbnQgY2F0Y2gp CiB7CiAgIHN0cnVjdCByZWNvcmRfbWVzc2FnZV9hcmdzIGFyZ3M7CiAKLSAg YXJncy5yZWdjYWNoZSA9IHJlZ2NhY2hlOwogICBhcmdzLnNpZ25hbCA9IHNp Z25hbDsKIAogICBpZiAoY2F0Y2gpCkBAIC02ODgsOSArNzgzLDE0IEBAIHN0 YXRpYyBpbnQgcmVjb3JkX2h3X3dhdGNocG9pbnQgPSAwOwogICAgZW50cmll cyBhbmQgbWVtb3J5IGVudHJpZXMsIGZvbGxvd2VkIGJ5IGFuICdlbmQnIGVu dHJ5LiAgKi8KIAogc3RhdGljIGlubGluZSB2b2lkCi1yZWNvcmRfZXhlY19p bnNuIChzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLCBzdHJ1Y3QgZ2RiYXJj aCAqZ2RiYXJjaCwKK3JlY29yZF9leGVjX2luc24gKHN0cnVjdCByZWdjYWNo ZSAqKnJlZ2NhY2hlX3AsCisgICAgICAgICAgICAgICAgICBzdHJ1Y3QgZ2Ri YXJjaCAqKmdkYmFyY2hfcCwKKyAgICAgICAgICAgICAgICAgIHN0cnVjdCBh ZGRyZXNzX3NwYWNlICoqYXNwYWNlX3AsCiAJCSAgc3RydWN0IHJlY29yZF9l bnRyeSAqZW50cnkpCiB7CisgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUg PSAqcmVnY2FjaGVfcDsKKyAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2ggPSAq Z2RiYXJjaF9wOworCiAgIHN3aXRjaCAoZW50cnktPnR5cGUpCiAgICAgewog ICAgIGNhc2UgcmVjb3JkX3JlZzogLyogcmVnICovCkBAIC03NjksNiArODY5 LDExMCBAQCByZWNvcmRfZXhlY19pbnNuIChzdHJ1Y3QgcmVnY2FjaGUgKnJl Z2NhCiAgICAgICAgICAgfQogICAgICAgfQogICAgICAgYnJlYWs7CisKKyAg ICBjYXNlIHJlY29yZF9wdGlkOiAvKiBwdGlkICovCisgICAgICB7CisgICAg ICAgIHB0aWRfdCB0bXBfcHRpZDsKKworICAgICAgICBpZiAocmVjb3JkX2Rl YnVnID4gMSkKKyAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVyZWQgKGdkYl9z dGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiUHJvY2Vz cyByZWNvcmQ6IHJlY29yZF9wdGlkICVzIHRvICIKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICJpbmZlcmlvciBwdGlkID0gJXMuXG4iLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaG9zdF9hZGRyZXNzX3RvX3N0 cmluZyAoZW50cnkpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg dGFyZ2V0X3BpZF90b19zdHIgKGVudHJ5LT51LnB0aWQpKTsKKworICAgICAg ICBpZiAoIXB0aWRfZXF1YWwgKGVudHJ5LT51LnB0aWQsIG51bGxfcHRpZCkp CisgICAgICAgICAgeworICAgICAgICAgICAgaW5mZXJpb3JfcHRpZCA9IGVu dHJ5LT51LnB0aWQ7CisgICAgICAgICAgICAqcmVnY2FjaGVfcCA9IGdldF9j dXJyZW50X3JlZ2NhY2hlICgpOworICAgICAgICAgICAgKmdkYmFyY2hfcCA9 IGdldF9yZWdjYWNoZV9hcmNoICgqcmVnY2FjaGVfcCk7CisgICAgICAgICAg ICAqYXNwYWNlX3AgPSBnZXRfcmVnY2FjaGVfYXNwYWNlICgqcmVnY2FjaGVf cCk7CisgICAgICAgICAgfQorICAgICAgICB0bXBfcHRpZCA9IGVudHJ5LT51 LnB0aWQ7CisgICAgICAgIGVudHJ5LT51LnB0aWQgPSByZWNvcmRfcHJldl9w dGlkOworICAgICAgICByZWNvcmRfcHJldl9wdGlkID0gdG1wX3B0aWQ7Cisg ICAgICB9CisgICAgICBicmVhazsKKyAgICB9Cit9CisKK3N0YXRpYyBpbnQg cmVjb3JkX3RocmVhZF9udW1iZXI7CisKK3N0YXRpYyBpbnQKK3JlY29yZF90 aHJlYWRfbnVtYmVyX2NvdW50IChzdHJ1Y3QgdGhyZWFkX2luZm8gKnRocmVh ZCwgdm9pZCAqdW51c2VkKQoreworICBpZiAodGhyZWFkLT5zdGF0ZV8gIT0g VEhSRUFEX0VYSVRFRCkKKyAgICByZWNvcmRfdGhyZWFkX251bWJlciArKzsK KworICByZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF90aHJl YWRfbnVtYmVyX3Jlc2V0ICh2b2lkKQoreworICByZWNvcmRfdGhyZWFkX251 bWJlciA9IDA7CisKKyAgaWYgKFJFQ09SRF9USFJFQUQpCisgICAgaXRlcmF0 ZV9vdmVyX3RocmVhZHMgKHJlY29yZF90aHJlYWRfbnVtYmVyX2NvdW50LCBO VUxMKTsKK30KKworc3RhdGljIHZvaWQKK3JlY29yZF9uZXdfdGhyZWFkX2hh bmRsZXIgKHN0cnVjdCB0aHJlYWRfaW5mbyAqdHApCit7CisgIHRwLT5yZWNv cmRfaXNfd2FpdGluZyA9IDA7CisKKyAgcmVjb3JkX3RocmVhZF9udW1iZXJf cmVzZXQgKCk7Cit9CisKK3N0YXRpYyB2b2lkCityZWNvcmRfdGhyZWFkX2V4 aXRfaGFuZGxlciAoc3RydWN0IHRocmVhZF9pbmZvICp0cCwgaW50IHNpbGVu dCkKK3sKKyAgc3RydWN0IHJlY29yZF9lbnRyeSAqcmVjOworICBwdGlkX3Qg Y3VyX3B0aWQgPSByZWNvcmRfcHJldl9wdGlkOworCisgIGlmICghcmVjb3Jk X2ZpcnN0Lm5leHQpCisgICAgcmV0dXJuOworCisgIHRwLT5yZWNvcmRfaXNf d2FpdGluZyA9IDA7CisKKyAgaWYgKHRwLT5zdGF0ZV8gIT0gVEhSRUFEX0VY SVRFRCkKKyAgICB7CisgICAgICBnZGJfYXNzZXJ0IChyZWNvcmRfdGhyZWFk X251bWJlciA+IDApOworICAgICAgcmVjb3JkX3RocmVhZF9udW1iZXIgLS07 CisgICAgfQorCisgIC8qIERlbGV0ZSBhbGwgdGhlIHJlY29yZF9yZWcgYW5k IHJlY29yZF9wdGlkIGZvciB0cC0+cHRpZAorICAgICBmcm9tIHJlY29yZCBs aXN0LiAgKi8KKyAgZm9yIChyZWMgPSByZWNvcmRfbGlzdDsgcmVjICE9ICZy ZWNvcmRfZmlyc3Q7KQorICAgIHsKKyAgICAgIHN0cnVjdCByZWNvcmRfZW50 cnkgKnRtcCA9IHJlYzsKKyAgICAgIHJlYyA9IHJlYy0+cHJldjsKKworICAg ICAgc3dpdGNoICh0bXAtPnR5cGUpIHsKKyAgICAgICAgY2FzZSByZWNvcmRf cmVnOgorICAgICAgICAgIC8qIElmIHRoaXMgcmVjb3JkX3JlZyBpcyBmb3Ig dHAtPnB0aWQsIGRlbHRlIGl0LiAgKi8KKyAgICAgICAgICBpZiAocHRpZF9l cXVhbCAoY3VyX3B0aWQsIHRwLT5wdGlkKSkKKyAgICAgICAgICAgIHsKKyAg ICAgICAgICAgICAgcmVjb3JkX2VudHJ5X3JlbW92ZV9mcm9tX2xpc3QgKHRt cCk7CisgICAgICAgICAgICAgIHJlY29yZF9lbnRyeV9yZWxlYXNlICh0bXAp OworICAgICAgICAgICAgfQorICAgICAgICAgIGJyZWFrOworICAgICAgICBj YXNlIHJlY29yZF9wdGlkOgorICAgICAgICAgIC8qIElmIHRoaXMgcmVjb3Jk X3B0aWQgaXMgZm9yIHRwLT5wdGlkLCBkZWx0ZSBpdC4gICovCisgICAgICAg ICAgY3VyX3B0aWQgPSB0bXAtPnUucHRpZDsKKyAgICAgICAgICBpZiAocHRp ZF9lcXVhbCAocmVjb3JkX3ByZXZfcHRpZCwgdHAtPnB0aWQpKQorICAgICAg ICAgICAgeworICAgICAgICAgICAgICByZWNvcmRfcHJldl9wdGlkID0gY3Vy X3B0aWQ7CisgICAgICAgICAgICAgIHJlY29yZF9lbnRyeV9yZW1vdmVfZnJv bV9saXN0ICh0bXApOworICAgICAgICAgICAgICByZWNvcmRfZW50cnlfcmVs ZWFzZSAodG1wKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgICBlbHNlIGlm IChwdGlkX2VxdWFsIChjdXJfcHRpZCwgdHAtPnB0aWQpKQorICAgICAgICAg ICAgeworICAgICAgICAgICAgICByZWNvcmRfZW50cnlfcmVtb3ZlX2Zyb21f bGlzdCAodG1wKTsKKyAgICAgICAgICAgICAgcmVjb3JkX2VudHJ5X3JlbGVh c2UgKHRtcCk7CisgICAgICAgICAgICB9CisgICAgICAgICAgYnJlYWs7Cisg ICAgICB9CiAgICAgfQogfQogCkBAIC04NjUsNiArMTA2OSw5IEBAIHJlY29y ZF9vcGVuXzEgKGNoYXIgKm5hbWUsIGludCBmcm9tX3R0eSkKICAgICBlcnJv ciAoXygiQ291bGQgbm90IGZpbmQgJ3RvX3JlbW92ZV9icmVha3BvaW50JyBt ZXRob2Qgb24gdGhlIHRhcmdldCBzdGFjay4iKSk7CiAKICAgcHVzaF90YXJn ZXQgKCZyZWNvcmRfb3BzKTsKKworICByZWNvcmRfbmV3X3RocmVhZF9vYnNl cnZlciA9IG9ic2VydmVyX2F0dGFjaF9uZXdfdGhyZWFkIChyZWNvcmRfbmV3 X3RocmVhZF9oYW5kbGVyKTsKKyAgcmVjb3JkX3RocmVhZF9leGl0X29ic2Vy dmVyID0gb2JzZXJ2ZXJfYXR0YWNoX3RocmVhZF9leGl0IChyZWNvcmRfdGhy ZWFkX2V4aXRfaGFuZGxlcik7CiB9CiAKIC8qICJ0b19vcGVuIiB0YXJnZXQg bWV0aG9kLiAgT3BlbiB0aGUgcHJvY2VzcyByZWNvcmQgdGFyZ2V0LiAgKi8K QEAgLTkzNCw2ICsxMTQxLDcgQEAgcmVjb3JkX29wZW4gKGNoYXIgKm5hbWUs IGludCBmcm9tX3R0eSkKICAgcmVjb3JkX2luc25fY291bnQgPSAwOwogICBy ZWNvcmRfbGlzdCA9ICZyZWNvcmRfZmlyc3Q7CiAgIHJlY29yZF9saXN0LT5u ZXh0ID0gTlVMTDsKKyAgcmVjb3JkX3ByZXZfcHRpZCA9IG51bGxfcHRpZDsK IAogICAvKiBTZXQgdGhlIHRtcCBiZW5lYXRoIHBvaW50ZXJzIHRvIGJlbmVh dGggcG9pbnRlcnMuICAqLwogICByZWNvcmRfYmVuZWF0aF90b19yZXN1bWVf b3BzID0gdG1wX3RvX3Jlc3VtZV9vcHM7CkBAIC05NTMsNiArMTE2MSw4IEBA IHJlY29yZF9vcGVuIChjaGFyICpuYW1lLCBpbnQgZnJvbV90dHkpCiAgICAg cmVjb3JkX2NvcmVfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CiAgIGVsc2UK ICAgICByZWNvcmRfb3Blbl8xIChuYW1lLCBmcm9tX3R0eSk7CisKKyAgcmVj b3JkX3RocmVhZF9udW1iZXJfcmVzZXQgKCk7CiB9CiAKIC8qICJ0b19jbG9z ZSIgdGFyZ2V0IG1ldGhvZC4gIENsb3NlIHRoZSBwcm9jZXNzIHJlY29yZCB0 YXJnZXQuICAqLwpAQCAtOTY1LDYgKzExNzUsMTcgQEAgcmVjb3JkX2Nsb3Nl IChpbnQgcXVpdHRpbmcpCiAgIGlmIChyZWNvcmRfZGVidWcpCiAgICAgZnBy aW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6 IHJlY29yZF9jbG9zZVxuIik7CiAKKyAgaWYgKHJlY29yZF9uZXdfdGhyZWFk X29ic2VydmVyKQorICAgIHsKKyAgICAgIG9ic2VydmVyX2RldGFjaF9uZXdf dGhyZWFkIChyZWNvcmRfbmV3X3RocmVhZF9vYnNlcnZlcik7CisgICAgICBy ZWNvcmRfbmV3X3RocmVhZF9vYnNlcnZlciA9IE5VTEw7CisgICAgfQorICBp ZiAocmVjb3JkX3RocmVhZF9leGl0X29ic2VydmVyKQorICAgIHsKKyAgICAg IG9ic2VydmVyX2RldGFjaF90aHJlYWRfZXhpdCAocmVjb3JkX3RocmVhZF9l eGl0X29ic2VydmVyKTsKKyAgICAgIHJlY29yZF90aHJlYWRfZXhpdF9vYnNl cnZlciA9IE5VTEw7CisgICAgfQorCiAgIHJlY29yZF9saXN0X3JlbGVhc2Ug KHJlY29yZF9saXN0KTsKIAogICAvKiBSZWxlYXNlIHJlY29yZF9jb3JlX3Jl Z2J1Zi4gICovCkBAIC05ODcsNiArMTIwOCw4IEBAIHJlY29yZF9jbG9zZSAo aW50IHF1aXR0aW5nKQogfQogCiBzdGF0aWMgaW50IHJlY29yZF9yZXN1bWVf c3RlcCA9IDA7CitzdGF0aWMgcHRpZF90IHJlY29yZF9yZXN1bWVfcHRpZDsK K3N0YXRpYyBlbnVtIHRhcmdldF9zaWduYWwgcmVjb3JkX3Jlc3VtZV9zaWdu YWwgPSBUQVJHRVRfU0lHTkFMXzA7CiAKIC8qICJ0b19yZXN1bWUiIHRhcmdl dCBtZXRob2QuICBSZXN1bWUgdGhlIHByb2Nlc3MgcmVjb3JkIHRhcmdldC4g ICovCiAKQEAgLTk5OCwxMCArMTIyMSwyMDEgQEAgcmVjb3JkX3Jlc3VtZSAo c3RydWN0IHRhcmdldF9vcHMgKm9wcywgcAogCiAgIGlmICghUkVDT1JEX0lT X1JFUExBWSkKICAgICB7Ci0gICAgICBkb19yZWNvcmRfbWVzc2FnZSAoZ2V0 X2N1cnJlbnRfcmVnY2FjaGUgKCksIHNpZ25hbCwgMCk7Ci0gICAgICByZWNv cmRfYmVuZWF0aF90b19yZXN1bWUgKHJlY29yZF9iZW5lYXRoX3RvX3Jlc3Vt ZV9vcHMsIHB0aWQsIDEsCi0gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHNpZ25hbCk7CisgICAgICByZWNvcmRfcmVzdW1lX3B0aWQgPSBwdGlk OworICAgICAgaWYgKHJlY29yZF90aHJlYWRfbnVtYmVyID4gMSAmJiAhcHRp ZF9lcXVhbCAocHRpZCwgaW5mZXJpb3JfcHRpZCkpCisgICAgICAgIHsKKyAg ICAgICAgICByZWNvcmRfcmVzdW1lX3NpZ25hbCA9IHNpZ25hbDsKKyAgICAg ICAgfQorICAgICAgZWxzZQorICAgICAgICB7CisgICAgICAgICAgZG9fcmVj b3JkX21lc3NhZ2UgKHNpZ25hbCwgMCk7CisgICAgICAgICAgcmVjb3JkX2Jl bmVhdGhfdG9fcmVzdW1lIChyZWNvcmRfYmVuZWF0aF90b19yZXN1bWVfb3Bz LCBwdGlkLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cmVjb3JkX3N0ZXAsIHNpZ25hbCk7CisgICAgICAgIH0KKyAgICB9Cit9CisK K3N0cnVjdCByZWNvcmRfdGhyZWFkX3dhaXRfYXJncyB7CisgIHB0aWRfdCBy ZWFsX2luZmVyaW9yX3B0aWQ7CisgIHN0cnVjdCB0aHJlYWRfaW5mbyAqcmVh bF9pbmZlcmlvcl90cDsKKyAgc3RydWN0IHRhcmdldF93YWl0c3RhdHVzIHJl YWxfaW5mZXJpb3Jfc3RhdHVzOworCisgIHN0cnVjdCB0YXJnZXRfd2FpdHN0 YXR1cyAqc3RhdHVzOworICBpbnQgb3B0aW9uczsKK307CisKK3N0YXRpYyBp bnQKK3JlY29yZF90aHJlYWRfcmVzZXRfY2FsbGJhY2sgKHN0cnVjdCB0aHJl YWRfaW5mbyAqdHAsIHZvaWQgKmRhdGEpCit7CisgIHRwLT5yZWNvcmRfaXNf d2FpdGluZyA9IDA7CisKKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQK K3JlY29yZF90aHJlYWRfc3RvcF9jYWxsYmFjayAoc3RydWN0IHRocmVhZF9p bmZvICp0cCwgdm9pZCAqZGF0YSkKK3sKKyAgaWYgKHRwLT5zdGF0ZV8gIT0g VEhSRUFEX0VYSVRFRCAmJiB0cC0+cmVjb3JkX2lzX3dhaXRpbmcpCisgICAg dGFyZ2V0X3N0b3AgKHRwLT5wdGlkKTsKKworICByZXR1cm4gMDsKK30KKwor LyogUmV0dXJuIDEgaWYgaXQgaXMgbm90IGEgc2ltcGxlIHN0ZXAuCisgICBS ZXR1cm4gMCBpZiBpdCBpcyBhIHNpbXBsZSBzdGVwLiAgKi8KKworc3RhdGlj IGludAorcmVjb3JkX3RocmVhZF93YWl0IChwdGlkX3QgcHRpZCwgc3RydWN0 IHRhcmdldF93YWl0c3RhdHVzICpzdGF0dXMsCisgICAgICAgICAgICAgICAg ICAgIGludCBvcHRpb25zLCBwdGlkX3QgKnJldF9wdGlkKQoreworICBwdGlk X3Qgd2FpdF9wdGlkID0gcmVjb3JkX2JlbmVhdGhfdG9fd2FpdCAocmVjb3Jk X2JlbmVhdGhfdG9fd2FpdF9vcHMsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBwdGlkLCBzdGF0dXMsIG9wdGlvbnMp OworCisgIGlmIChyZXRfcHRpZCkKKyAgICAqcmV0X3B0aWQgPSB3YWl0X3B0 aWQ7CisKKyAgaWYgKHN0YXR1cy0+a2luZCA9PSBUQVJHRVRfV0FJVEtJTkRf SUdOT1JFKQorICAgIHJldHVybiAwOworCisgIGluZmVyaW9yX3B0aWQgPSB3 YWl0X3B0aWQ7CisKKyAgLyogSXMgdGhpcyBhIFNJR1RSQVA/ICAqLworICBp ZiAoc3RhdHVzLT5raW5kID09IFRBUkdFVF9XQUlUS0lORF9TVE9QUEVECisg ICAgICAmJiBzdGF0dXMtPnZhbHVlLnNpZyA9PSBUQVJHRVRfU0lHTkFMX1RS QVApCisgICAgeworICAgICAgQ09SRV9BRERSIHRtcF9wYzsKKyAgICAgIHN0 cnVjdCByZWdjYWNoZSAqcmVnY2FjaGU7CisgICAgICBzdHJ1Y3QgZ2RiYXJj aCAqZ2RiYXJjaDsKKyAgICAgIHN0cnVjdCBhZGRyZXNzX3NwYWNlICphc3Bh Y2U7CisgICAgICBDT1JFX0FERFIgZGVjcl9wY19hZnRlcl9icmVhazsKKwor ICAgICAgLyogWWVzIC0tIHRoaXMgaXMgbGlrZWx5IG91ciBzaW5nbGUtc3Rl cCBmaW5pc2hpbmcsCisgICAgICAgICBidXQgY2hlY2sgaWYgdGhlcmUncyBh bnkgcmVhc29uIHRoZSBjb3JlIHdvdWxkIGJlCisgICAgICAgICBpbnRlcmVz dGVkIGluIHRoZSBldmVudC4gICovCisKKyAgICAgIHJlZ2lzdGVyc19jaGFu Z2VkICgpOworICAgICAgcmVnY2FjaGUgPSBnZXRfY3VycmVudF9yZWdjYWNo ZSAoKTsKKyAgICAgIGdkYmFyY2ggPSBnZXRfcmVnY2FjaGVfYXJjaCAocmVn Y2FjaGUpOworICAgICAgdG1wX3BjID0gcmVnY2FjaGVfcmVhZF9wYyAocmVn Y2FjaGUpOworICAgICAgYXNwYWNlID0gZ2V0X3JlZ2NhY2hlX2FzcGFjZSAo cmVnY2FjaGUpOworICAgICAgZGVjcl9wY19hZnRlcl9icmVhayA9IGdkYmFy Y2hfZGVjcl9wY19hZnRlcl9icmVhayAoZ2RiYXJjaCk7CisKKyAgICAgIC8q IFRvIGNoZWNrIGlmIHRoaXMgaXMgYnJlYWtwb2ludCBuZWVkIHRoZSByaWdo dCBwYywgaWYgdGhpcyBpcyBub3QKKyAgICAgICAgIGEgc2luZ2xlIHN0ZXAu ICBTbyB3ZSBuZWVkIGFkanVzdCB0bXBfcGMgdG8gbWFrZSBpdCByaWdodC4g ICovCisgICAgICBpZiAoIXJlY29yZF9zdGVwKQorICAgICAgICB0bXBfcGMg LT0gZGVjcl9wY19hZnRlcl9icmVhazsKKworICAgICAgaWYgKHRhcmdldF9z dG9wcGVkX2J5X3dhdGNocG9pbnQgKCkpCisgICAgICAgIHsKKyAgICAgICAg ICAvKiBBbHdheXMgaW50ZXJlc3RlZCBpbiB3YXRjaHBvaW50cy4gICovCisg ICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgIH0KKyAgICAgIGVsc2UgaWYg KGJyZWFrcG9pbnRfaW5zZXJ0ZWRfaGVyZV9wIChhc3BhY2UsIHRtcF9wYykp CisgICAgICAgIHsKKyAgICAgICAgICAvKiBUaGVyZSBpcyBhIGJyZWFrcG9p bnQgaGVyZS4gIExldCB0aGUgY29yZSBoYW5kbGUgaXQuICAqLworICAgICAg ICAgIGlmIChyZWNvcmRfc3RlcAorICAgICAgICAgICAgICAmJiBzb2Z0d2Fy ZV9icmVha3BvaW50X2luc2VydGVkX2hlcmVfcCAoYXNwYWNlLCB0bXBfcGMp KQorICAgICAgICAgICAgeworICAgICAgICAgICAgICBpZiAoZGVjcl9wY19h ZnRlcl9icmVhaykKKyAgICAgICAgICAgICAgICByZWdjYWNoZV93cml0ZV9w YyAocmVnY2FjaGUsIHRtcF9wYyArIGRlY3JfcGNfYWZ0ZXJfYnJlYWspOwor ICAgICAgICAgICAgfQorCisgICAgICAgICAgcmV0dXJuIDE7CisgICAgICAg IH0KKworICAgICAgcmV0dXJuIDA7CisgICAgfQorCisgIHJldHVybiAxOwor fQorCitzdGF0aWMgaW50CityZWNvcmRfdGhyZWFkX3dhaXRfY2FsbGJhY2sg KHN0cnVjdCB0aHJlYWRfaW5mbyAqdHAsIHZvaWQgKmRhdGEpCit7CisgIHN0 cnVjdCByZWNvcmRfdGhyZWFkX3dhaXRfYXJncyAqYXJncyA9IGRhdGE7Cisg IGVudW0gdGFyZ2V0X3NpZ25hbCBzaWcgPSBUQVJHRVRfU0lHTkFMXzA7Cisg IGludCBvcHRpb25zID0gYXJncy0+b3B0aW9uczsKKyAgaW50IHJldDsKKwor ICBpZiAodHAtPnN0YXRlXyA9PSBUSFJFQURfRVhJVEVEKQorICAgIHJldHVy biAwOworCisgIGlmIChyZWNvcmRfZGVidWcgPiAxKQorICAgIGZwcmludGZf dW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKKyAgICAgICAgICAgICAgICAgICAg ICAgICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX3RocmVhZF93YWl0X2NhbGxi YWNrICIKKyAgICAgICAgICAgICAgICAgICAgICAgICJyZXN1bWUgJXNcbiIs IHRhcmdldF9waWRfdG9fc3RyICh0cC0+cHRpZCkpOworCisgIGluZmVyaW9y X3B0aWQgPSB0cC0+cHRpZDsKKworICBpZiAoIXRwLT5yZWNvcmRfaXNfd2Fp dGluZykKKyAgICB7CisgICAgICBpZiAocmVjb3JkX3Jlc3VtZV9zaWduYWwg IT0gVEFSR0VUX1NJR05BTF8wCisgICAgICAgICAgJiYgcHRpZF9lcXVhbCAo aW5mZXJpb3JfcHRpZCwgYXJncy0+cmVhbF9pbmZlcmlvcl9wdGlkKSkKKyAg ICAgICAgeworICAgICAgICAgIHNpZyA9IHJlY29yZF9yZXN1bWVfc2lnbmFs OworICAgICAgICAgIHJlY29yZF9yZXN1bWVfc2lnbmFsID0gVEFSR0VUX1NJ R05BTF8wOworICAgICAgICB9CisgICAgICBpZiAoIWRvX3JlY29yZF9tZXNz YWdlIChzaWcsIDEpKQorICAgICAgICB7CisgICAgICAgICAgYXJncy0+c3Rh dHVzLT5raW5kID0gVEFSR0VUX1dBSVRLSU5EX1NUT1BQRUQ7CisgICAgICAg ICAgYXJncy0+c3RhdHVzLT52YWx1ZS5zaWcgPSBUQVJHRVRfU0lHTkFMXzA7 CisgICAgICAgICAgcmV0dXJuIDE7CisgICAgICAgIH0KKworICAgICAgaWYg KHJlY29yZF9zdGVwID09IDApCisgICAgICAgIHsKKyAgICAgICAgICAvKiBU aGUgbmV4dCBpbnNuIGlzIGEgc3lzX2Nsb25lLiAgKi8KKyAgICAgICAgICBp dGVyYXRlX292ZXJfdGhyZWFkcyAocmVjb3JkX3RocmVhZF9zdG9wX2NhbGxi YWNrLCBOVUxMKTsKKyAgICAgICAgICBub25fc3RvcCA9IDA7CisgICAgICAg IH0KKworICAgICAgcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1lIChyZWNvcmRf YmVuZWF0aF90b19yZXN1bWVfb3BzLCBpbmZlcmlvcl9wdGlkLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICByZWNvcmRfc3RlcCwgc2lnKTsK KyAgICB9CisgIGVsc2UKKyAgICB7CisgICAgICBpZiAocmVjb3JkX2RlYnVn ID4gMSkKKyAgICAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9n LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICJQcm9jZXNzIHJlY29y ZDogcmVjb3JkX3RocmVhZF93YWl0X2NhbGxiYWNrICIKKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAibm90IHJlc3VtZSAlc1xuIiwgdGFyZ2V0X3Bp ZF90b19zdHIgKHRwLT5wdGlkKSk7CisgICAgfQorCisgIGlmIChyZWNvcmRf c3RlcCkKKyAgICBvcHRpb25zIHw9IFRBUkdFVF9XTk9IQU5HOworICByZXQg PSByZWNvcmRfdGhyZWFkX3dhaXQgKGluZmVyaW9yX3B0aWQsIGFyZ3MtPnN0 YXR1cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBvcHRpb25zLCBO VUxMKTsKKyAgaWYgKGFyZ3MtPnN0YXR1cy0+a2luZCA9PSBUQVJHRVRfV0FJ VEtJTkRfSUdOT1JFKQorICAgIHsKKyAgICAgIGlmICghdHAtPnJlY29yZF9p c193YWl0aW5nKQorICAgICAgICB7CisgICAgICAgICAgdHAtPnJlY29yZF9p c193YWl0aW5nID0gMTsKKyAgICAgICAgICBpZiAocmVjb3JkX2RlYnVnID4g MSkKKyAgICAgICAgICAgIGZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxv ZywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIlByb2Nlc3Mg cmVjb3JkOiByZWNvcmRfdGhyZWFkX3dhaXRfY2FsbGJhY2sgIgorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAic3RhcnQgd2FpdGluZyAlcy5c biIsCisJCQkgICAgICAgIHRhcmdldF9waWRfdG9fc3RyICh0cC0+cHRpZCkp OworICAgICAgICB9CisgICAgfQorICBlbHNlCisgICAgeworICAgICAgaWYg KHRwLT5yZWNvcmRfaXNfd2FpdGluZykKKyAgICAgICAgeworICAgICAgICAg IHRwLT5yZWNvcmRfaXNfd2FpdGluZyA9IDA7CisgICAgICAgICAgaWYgKHJl Y29yZF9kZWJ1ZyA+IDEpCisgICAgICAgICAgICBmcHJpbnRmX3VuZmlsdGVy ZWQgKGdkYl9zdGRsb2csCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICJQcm9jZXNzIHJlY29yZDogcmVjb3JkX3RocmVhZF93YWl0X2NhbGxi YWNrICIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgInN0b3Ag d2FpdGluZyAlcy5cbiIsCisJCQkgICAgICAgIHRhcmdldF9waWRfdG9fc3Ry ICh0cC0+cHRpZCkpOworICAgICAgICB9CisKKyAgICAgIGlmICghYXJncy0+ cmVhbF9pbmZlcmlvcl90cAorICAgICAgICAgICYmIHB0aWRfZXF1YWwgKGlu ZmVyaW9yX3B0aWQsIGFyZ3MtPnJlYWxfaW5mZXJpb3JfcHRpZCkpCisgICAg ICAgIGFyZ3MtPnJlYWxfaW5mZXJpb3JfdHAgPSB0cDsKKyAgICAgIGlmIChh cmdzLT5yZWFsX2luZmVyaW9yX3RwID09IHRwKQorICAgICAgICBhcmdzLT5y ZWFsX2luZmVyaW9yX3N0YXR1cyA9ICphcmdzLT5zdGF0dXM7CiAgICAgfQor CisgIHJldHVybiByZXQ7CiB9CiAKIHN0YXRpYyBpbnQgcmVjb3JkX2dldF9z aWcgPSAwOwpAQCAtMTAyMyw3ICsxNDM3LDEzIEBAIHJlY29yZF9zaWdfaGFu ZGxlciAoaW50IHNpZ25vKQogfQogCiBzdGF0aWMgdm9pZAotcmVjb3JkX3dh aXRfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKK3JlY29yZF93YWl0X3NpZ25h bF9jbGVhbnVwcyAodm9pZCAqaWdub3JlKQoreworICBzaWduYWwgKFNJR0lO VCwgaGFuZGxlX3NpZ2ludCk7Cit9CisKK3N0YXRpYyB2b2lkCityZWNvcmRf d2FpdF9yZXBsYXlfY2xlYW51cHMgKHZvaWQgKmlnbm9yZSkKIHsKICAgaWYg KGV4ZWN1dGlvbl9kaXJlY3Rpb24gPT0gRVhFQ19SRVZFUlNFKQogICAgIHsK QEAgLTEwMzQsNiArMTQ1NCwxNyBAQCByZWNvcmRfd2FpdF9jbGVhbnVwcyAo dm9pZCAqaWdub3JlKQogICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2xpc3Qt PnByZXY7CiB9CiAKK3N0YXRpYyB2b2lkCityZWNvcmRfd2FpdF9tdGhyZWFk X2NsZWFudXBzICh2b2lkICppZ25vcmUpCit7CisgIG5vbl9zdG9wID0gMTsK KworICAvKiBTdG9wIHRoZSB0aHJlYWRzIHRoYXQgc3RpbGwgcnVubmluZy4g ICovCisgIGl0ZXJhdGVfb3Zlcl90aHJlYWRzIChyZWNvcmRfdGhyZWFkX3N0 b3BfY2FsbGJhY2ssIE5VTEwpOworCisgIG5vbl9zdG9wID0gMDsKK30KKwog LyogInRvX3dhaXQiIHRhcmdldCBtZXRob2QgZm9yIHByb2Nlc3MgcmVjb3Jk IHRhcmdldC4KIAogICAgSW4gcmVjb3JkIG1vZGUsIHRoZSB0YXJnZXQgaXMg YWx3YXlzIHJ1biBpbiBzaW5nbGVzdGVwIG1vZGUKQEAgLTEwNTIsNyArMTQ4 MywxMCBAQCByZWNvcmRfd2FpdCAoc3RydWN0IHRhcmdldF9vcHMgKm9wcywK IAkgICAgIHB0aWRfdCBwdGlkLCBzdHJ1Y3QgdGFyZ2V0X3dhaXRzdGF0dXMg KnN0YXR1cywKIAkgICAgIGludCBvcHRpb25zKQogeworICBwdGlkX3QgcmV0 X3B0aWQ7CiAgIHN0cnVjdCBjbGVhbnVwICpzZXRfY2xlYW51cHMgPSByZWNv cmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlX3NldCAoKTsKKyAgc3RydWN0IGNs ZWFudXAgKnNpZ25hbF9jbGVhbnVwcworICAgICAgICAgICAgICAgICAgICA9 IG1ha2VfY2xlYW51cCAocmVjb3JkX3dhaXRfc2lnbmFsX2NsZWFudXBzLCAw KTsKIAogICBpZiAocmVjb3JkX2RlYnVnKQogICAgIGZwcmludGZfdW5maWx0 ZXJlZCAoZ2RiX3N0ZGxvZywKQEAgLTEwNjAsOTMgKzE0OTQsMTEyIEBAIHJl Y29yZF93YWl0IChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAogCQkJInJlY29y ZF9yZXN1bWVfc3RlcCA9ICVkXG4iLAogCQkJcmVjb3JkX3Jlc3VtZV9zdGVw KTsKIAorICByZWNvcmRfZ2V0X3NpZyA9IDA7CisgIHNpZ25hbCAoU0lHSU5U LCByZWNvcmRfc2lnX2hhbmRsZXIpOworCiAgIGlmICghUkVDT1JEX0lTX1JF UExBWSAmJiBvcHMgIT0gJnJlY29yZF9jb3JlX29wcykKICAgICB7Ci0gICAg ICBpZiAocmVjb3JkX3Jlc3VtZV9zdGVwKQotCXsKLQkgIC8qIFRoaXMgaXMg YSBzaW5nbGUgc3RlcC4gICovCi0JICByZXR1cm4gcmVjb3JkX2JlbmVhdGhf dG9fd2FpdCAocmVjb3JkX2JlbmVhdGhfdG9fd2FpdF9vcHMsCi0JCQkJCSBw dGlkLCBzdGF0dXMsIG9wdGlvbnMpOwotCX0KLSAgICAgIGVsc2UKLQl7Ci0J ICAvKiBUaGlzIGlzIG5vdCBhIHNpbmdsZSBzdGVwLiAgKi8KLQkgIHB0aWRf dCByZXQ7Ci0JICBDT1JFX0FERFIgdG1wX3BjOworICAgICAgLyogUmVjb3Jk IG1vZGUuICAqLworICAgICAgaWYgKHJlY29yZF90aHJlYWRfbnVtYmVyID4g MSAmJiAhcHRpZF9lcXVhbCAocmVjb3JkX3Jlc3VtZV9wdGlkLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg aW5mZXJpb3JfcHRpZCkpCisgICAgICAgIHsKKyAgICAgICAgICAvKiBNdWx0 aS10aHJlYWRzIHJlY29yZC4gICovCisgICAgICAgICAgc3RydWN0IHJlY29y ZF90aHJlYWRfd2FpdF9hcmdzIGFyZ3M7CisgICAgICAgICAgc3RydWN0IHRo cmVhZF9pbmZvICp0cDsKKyAgICAgICAgICBzdHJ1Y3QgY2xlYW51cCAqbXRo cmVhZF9jbGVhbnVwcworICAgICAgICAgICAgICAgICAgICAgICAgICAgID0g bWFrZV9jbGVhbnVwIChyZWNvcmRfd2FpdF9tdGhyZWFkX2NsZWFudXBzLCAw KTsKIAotCSAgd2hpbGUgKDEpCi0JICAgIHsKLQkgICAgICByZXQgPSByZWNv cmRfYmVuZWF0aF90b193YWl0IChyZWNvcmRfYmVuZWF0aF90b193YWl0X29w cywKLQkJCQkJICAgIHB0aWQsIHN0YXR1cywgb3B0aW9ucyk7CisgICAgICAg ICAgYXJncy5yZWFsX2luZmVyaW9yX3B0aWQgPSBpbmZlcmlvcl9wdGlkOwor ICAgICAgICAgIGFyZ3MucmVhbF9pbmZlcmlvcl90cCA9IE5VTEw7CisgICAg ICAgICAgYXJncy5zdGF0dXMgPSBzdGF0dXM7CisgICAgICAgICAgYXJncy5v cHRpb25zID0gb3B0aW9uczsKKyAgICAgICAgICBub25fc3RvcCA9IDE7Cisg ICAgICAgICAgaXRlcmF0ZV9vdmVyX3RocmVhZHMgKHJlY29yZF90aHJlYWRf cmVzZXRfY2FsbGJhY2ssIE5VTEwpOwogCi0JICAgICAgLyogSXMgdGhpcyBh IFNJR1RSQVA/ICAqLwotCSAgICAgIGlmIChzdGF0dXMtPmtpbmQgPT0gVEFS R0VUX1dBSVRLSU5EX1NUT1BQRUQKLQkJICAmJiBzdGF0dXMtPnZhbHVlLnNp ZyA9PSBUQVJHRVRfU0lHTkFMX1RSQVApCi0JCXsKLQkJICBzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlOwotCQkgIHN0cnVjdCBhZGRyZXNzX3NwYWNlICph c3BhY2U7CisgICAgICAgICAgd2hpbGUgKDEpCisgICAgICAgICAgICB7Cisg ICAgICAgICAgICAgIHRwID0gaXRlcmF0ZV9vdmVyX3RocmVhZHMgKHJlY29y ZF90aHJlYWRfd2FpdF9jYWxsYmFjaywgJmFyZ3MpOworICAgICAgICAgICAg ICBpZiAodHApCisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAg ICAgIGlmIChyZWNvcmRfcmVzdW1lX3N0ZXAKKyAgICAgICAgICAgICAgICAg ICYmIGFyZ3MucmVhbF9pbmZlcmlvcl90cAorICAgICAgICAgICAgICAgICAg JiYgIWFyZ3MucmVhbF9pbmZlcmlvcl90cC0+cmVjb3JkX2lzX3dhaXRpbmcp CisgICAgICAgICAgICAgICAgeworICAgICAgICAgICAgICAgICAgKnN0YXR1 cyA9IGFyZ3MucmVhbF9pbmZlcmlvcl9zdGF0dXM7CisgICAgICAgICAgICAg ICAgICBpbmZlcmlvcl9wdGlkID0gYXJncy5yZWFsX2luZmVyaW9yX3B0aWQ7 CisgICAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9 CisgICAgICAgICAgICB9CiAKLQkJICAvKiBZZXMgLS0gdGhpcyBpcyBsaWtl bHkgb3VyIHNpbmdsZS1zdGVwIGZpbmlzaGluZywKLQkJICAgICBidXQgY2hl Y2sgaWYgdGhlcmUncyBhbnkgcmVhc29uIHRoZSBjb3JlIHdvdWxkIGJlCi0J CSAgICAgaW50ZXJlc3RlZCBpbiB0aGUgZXZlbnQuICAqLworICAgICAgICAg IGRvX2NsZWFudXBzIChtdGhyZWFkX2NsZWFudXBzKTsKIAotCQkgIHJlZ2lz dGVyc19jaGFuZ2VkICgpOwotCQkgIHJlZ2NhY2hlID0gZ2V0X2N1cnJlbnRf cmVnY2FjaGUgKCk7Ci0JCSAgdG1wX3BjID0gcmVnY2FjaGVfcmVhZF9wYyAo cmVnY2FjaGUpOwotCQkgIGFzcGFjZSA9IGdldF9yZWdjYWNoZV9hc3BhY2Ug KHJlZ2NhY2hlKTsKKyAgICAgICAgICBpZiAodHAgJiYgdHAtPnN0YXRlXyAh PSBUSFJFQURfRVhJVEVEKQorICAgICAgICAgICAgeworICAgICAgICAgICAg ICBpbmZlcmlvcl9wdGlkID0gdHAtPnB0aWQ7CisgICAgICAgICAgICB9Cisg ICAgICAgICAgcmV0X3B0aWQgPSBpbmZlcmlvcl9wdGlkOworICAgICAgICB9 CisgICAgICBlbHNlCisgICAgICAgIHsKKyAgICAgICAgICAvKiBTaW5nbGUt dGhyZWFkIHJlY29yZC4gICovCisgICAgICAgICAgaWYgKHJlY29yZF90aHJl YWRfbnVtYmVyID4gMSkKKyAgICAgICAgICAgIHB0aWQgPSByZWNvcmRfcmVz dW1lX3B0aWQ7CiAKLQkJICBpZiAodGFyZ2V0X3N0b3BwZWRfYnlfd2F0Y2hw b2ludCAoKSkKLQkJICAgIHsKLQkJICAgICAgLyogQWx3YXlzIGludGVyZXN0 ZWQgaW4gd2F0Y2hwb2ludHMuICAqLwotCQkgICAgfQotCQkgIGVsc2UgaWYg KGJyZWFrcG9pbnRfaW5zZXJ0ZWRfaGVyZV9wIChhc3BhY2UsIHRtcF9wYykp Ci0JCSAgICB7Ci0JCSAgICAgIC8qIFRoZXJlIGlzIGEgYnJlYWtwb2ludCBo ZXJlLiAgTGV0IHRoZSBjb3JlCi0JCQkgaGFuZGxlIGl0LiAgKi8KLQkJICAg ICAgaWYgKHNvZnR3YXJlX2JyZWFrcG9pbnRfaW5zZXJ0ZWRfaGVyZV9wIChh c3BhY2UsIHRtcF9wYykpCi0JCQl7Ci0JCQkgIHN0cnVjdCBnZGJhcmNoICpn ZGJhcmNoID0gZ2V0X3JlZ2NhY2hlX2FyY2ggKHJlZ2NhY2hlKTsKLQkJCSAg Q09SRV9BRERSIGRlY3JfcGNfYWZ0ZXJfYnJlYWsKLQkJCSAgICA9IGdkYmFy Y2hfZGVjcl9wY19hZnRlcl9icmVhayAoZ2RiYXJjaCk7Ci0JCQkgIGlmIChk ZWNyX3BjX2FmdGVyX2JyZWFrKQotCQkJICAgIHJlZ2NhY2hlX3dyaXRlX3Bj IChyZWdjYWNoZSwKLQkJCQkJICAgICAgIHRtcF9wYyArIGRlY3JfcGNfYWZ0 ZXJfYnJlYWspOwotCQkJfQotCQkgICAgfQotCQkgIGVsc2UKLQkJICAgIHsK LQkJICAgICAgLyogVGhpcyBtdXN0IGJlIGEgc2luZ2xlLXN0ZXAgdHJhcC4g IFJlY29yZCB0aGUKLQkJICAgICAgICAgaW5zbiBhbmQgaXNzdWUgYW5vdGhl ciBzdGVwLiAgKi8KLQkJICAgICAgaWYgKCFkb19yZWNvcmRfbWVzc2FnZSAo cmVnY2FjaGUsIFRBUkdFVF9TSUdOQUxfMCwgMSkpCi0gIAkJCXsKLSAgICAg ICAgICAgICAgICAgICAgICAgICAgIHN0YXR1cy0+a2luZCA9IFRBUkdFVF9X QUlUS0lORF9TVE9QUEVEOwotICAgICAgICAgICAgICAgICAgICAgICAgICAg c3RhdHVzLT52YWx1ZS5zaWcgPSBUQVJHRVRfU0lHTkFMXzA7Ci0gICAgICAg ICAgICAgICAgICAgICAgICAgICBicmVhazsKLSAgCQkJfQorICAgICAgICAg IGlmIChyZWNvcmRfcmVzdW1lX3N0ZXApCisgICAgICAgICAgICB7CisJICAg ICAgLyogVGhpcyBpcyBhIHNpbmdsZSBzdGVwLiAgKi8KKwkgICAgICByZXRf cHRpZCA9IHJlY29yZF9iZW5lYXRoX3RvX3dhaXQgKHJlY29yZF9iZW5lYXRo X3RvX3dhaXRfb3BzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHB0aWQsIHN0YXR1cywgb3B0aW9ucyk7CisJ ICAgIH0KKyAgICAgICAgICBlbHNlCisgICAgICAgICAgICB7CisgICAgICAg ICAgICAgIC8qIFRoaXMgaXMgbm90IGEgc2luZ2xlIHN0ZXAuICAqLworICAg ICAgICAgICAgICB3aGlsZSAoMSkKKyAgICAgICAgICAgICAgICB7CisgICAg ICAgICAgICAgICAgICBpZiAocmVjb3JkX3RocmVhZF93YWl0IChwdGlkLCBz dGF0dXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBvcHRpb25zLCAmcmV0X3B0aWQpKQorICAgICAgICAgICAgICAgICAg ICBicmVhazsKIAotCQkgICAgICByZWNvcmRfYmVuZWF0aF90b19yZXN1bWUg KHJlY29yZF9iZW5lYXRoX3RvX3Jlc3VtZV9vcHMsCi0JCQkJCQlwdGlkLCAx LAotCQkJCQkJVEFSR0VUX1NJR05BTF8wKTsKLQkJICAgICAgY29udGludWU7 Ci0JCSAgICB9Ci0JCX0KKyAgICAgICAgICAgICAgICAgIGlmIChyZWNvcmRf cmVzdW1lX3N0ZXApCisgICAgICAgICAgICAgICAgICAgIGJyZWFrOwogCi0J ICAgICAgLyogVGhlIGluZmVyaW9yIGlzIGJyb2tlbiBieSBhIGJyZWFrcG9p bnQgb3IgYSBzaWduYWwuICAqLwotCSAgICAgIGJyZWFrOwotCSAgICB9Cisg ICAgICAgICAgICAgICAgICAvKiBUaGVyZSBpcyBub3QgYSBicmVha3BvaW50 LCBhbmQgZ2RiIGlzIG5vdAorICAgICAgICAgICAgICAgICAgICAgc3RlcHBp bmcsIHRoZXJlZm9yZSBnZGIgd2lsbCBub3Qgc3RvcC4KKyAgICAgICAgICAg ICAgICAgICAgIFRoZXJlZm9yZSB3ZSB3aWxsIG5vdCByZXR1cm4gdG8gZ2Ri LgorICAgICAgICAgICAgICAgICAgICAgUmVjb3JkIHRoZSBpbnNuIGFuZCBy ZXN1bWUuICAqLworCQkgIGlmICghZG9fcmVjb3JkX21lc3NhZ2UgKFRBUkdF VF9TSUdOQUxfMCwgMSkpCisgICAgICAgICAgICAgICAgICAgIHsKKyAgICAg ICAgICAgICAgICAgICAgICByZXRfcHRpZCA9IGluZmVyaW9yX3B0aWQ7Cisg ICAgICAgICAgICAgICAgICAgICAgc3RhdHVzLT5raW5kID0gVEFSR0VUX1dB SVRLSU5EX1NUT1BQRUQ7CisgICAgICAgICAgICAgICAgICAgICAgc3RhdHVz LT52YWx1ZS5zaWcgPSBUQVJHRVRfU0lHTkFMXzA7CisgICAgICAgICAgICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICAgICAgICAgIH0KIAotCSAg cmV0dXJuIHJldDsKLQl9CisJCSAgcmVjb3JkX2JlbmVhdGhfdG9fcmVzdW1l IChyZWNvcmRfYmVuZWF0aF90b19yZXN1bWVfb3BzLAorCQkgICAgICAgICAg ICAgICAgICAgICAgICAgICAgcmVjb3JkX3Jlc3VtZV9wdGlkLCByZWNvcmRf c3RlcCwKKwkJICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRBUkdFVF9T SUdOQUxfMCk7CisgICAgICAgICAgICAgICAgfQorICAgICAgICAgICAgfQor ICAgICAgICB9CiAgICAgfQogICBlbHNlCiAgICAgewotICAgICAgc3RydWN0 IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2NhY2hlICgp OwotICAgICAgc3RydWN0IGdkYmFyY2ggKmdkYmFyY2ggPSBnZXRfcmVnY2Fj aGVfYXJjaCAocmVnY2FjaGUpOwotICAgICAgc3RydWN0IGFkZHJlc3Nfc3Bh Y2UgKmFzcGFjZSA9IGdldF9yZWdjYWNoZV9hc3BhY2UgKHJlZ2NhY2hlKTsK KyAgICAgIC8qIFJlcGxheSBtb2RlLiAgKi8KKyAgICAgIHN0cnVjdCByZWdj YWNoZSAqcmVnY2FjaGU7CisgICAgICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aDsKKyAgICAgIHN0cnVjdCBhZGRyZXNzX3NwYWNlICphc3BhY2U7CiAgICAg ICBpbnQgY29udGludWVfZmxhZyA9IDE7CiAgICAgICBpbnQgZmlyc3RfcmVj b3JkX2VuZCA9IDE7Ci0gICAgICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFu dXBzID0gbWFrZV9jbGVhbnVwIChyZWNvcmRfd2FpdF9jbGVhbnVwcywgMCk7 CisgICAgICBzdHJ1Y3QgY2xlYW51cCAqb2xkX2NsZWFudXBzID0KKyAgICAg ICAgbWFrZV9jbGVhbnVwIChyZWNvcmRfd2FpdF9yZXBsYXlfY2xlYW51cHMs IDApOwogICAgICAgQ09SRV9BRERSIHRtcF9wYzsKKyAgICAgIHB0aWRfdCBv bGRfaW5mZXJpb3JfcHRpZCA9IGluZmVyaW9yX3B0aWQ7CisKKyAgICAgIGlm ICghcHRpZF9lcXVhbCAocmVjb3JkX3ByZXZfcHRpZCwgbnVsbF9wdGlkKSkK KyAgICAgICAgaW5mZXJpb3JfcHRpZCA9IHJlY29yZF9wcmV2X3B0aWQ7Cisg ICAgICByZWdjYWNoZSA9IGdldF9jdXJyZW50X3JlZ2NhY2hlICgpOworICAg ICAgZ2RiYXJjaCA9IGdldF9yZWdjYWNoZV9hcmNoIChyZWdjYWNoZSk7Cisg ICAgICBhc3BhY2UgPSBnZXRfcmVnY2FjaGVfYXNwYWNlIChyZWdjYWNoZSk7 CiAKICAgICAgIHJlY29yZF9od193YXRjaHBvaW50ID0gMDsKICAgICAgIHN0 YXR1cy0+a2luZCA9IFRBUkdFVF9XQUlUS0lORF9TVE9QUEVEOwpAQCAtMTE3 Myw4ICsxNjI2LDYgQEAgcmVjb3JkX3dhaXQgKHN0cnVjdCB0YXJnZXRfb3Bz ICpvcHMsCiAJICAgIH0KIAl9CiAKLSAgICAgIHJlY29yZF9nZXRfc2lnID0g MDsKLSAgICAgIHNpZ25hbCAoU0lHSU5ULCByZWNvcmRfc2lnX2hhbmRsZXIp OwogICAgICAgLyogSWYgR0RCIGlzIGluIHRlcm1pbmFsX2luZmVyaW9yIG1v ZGUsIGl0IHdpbGwgbm90IGdldCB0aGUgc2lnbmFsLgogICAgICAgICAgQW5k IGluIEdEQiByZXBsYXkgbW9kZSwgR0RCIGRvZXNuJ3QgbmVlZCB0byBiZSBp biB0ZXJtaW5hbF9pbmZlcmlvcgogICAgICAgICAgbW9kZSwgYmVjYXVzZSBp bmZlcmlvciB3aWxsIG5vdCBleGVjdXRlZC4KQEAgLTEyMDUsNyArMTY1Niw3 IEBAIHJlY29yZF93YWl0IChzdHJ1Y3QgdGFyZ2V0X29wcyAqb3BzLAogCSAg ICAgIGJyZWFrOwogCSAgICB9CiAKLSAgICAgICAgICByZWNvcmRfZXhlY19p bnNuIChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOworICAgICAg ICAgIHJlY29yZF9leGVjX2luc24gKCZyZWdjYWNoZSwgJmdkYmFyY2gsICZh c3BhY2UsIHJlY29yZF9saXN0KTsKIAogCSAgaWYgKHJlY29yZF9saXN0LT50 eXBlID09IHJlY29yZF9lbmQpCiAJICAgIHsKQEAgLTEyMjgsMTkgKzE2Nzks MjAgQEAgcmVjb3JkX3dhaXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCiAJ CSAgICAgSW4gRVhFQ19GT1JXQVJEIG1vZGUsIHRoaXMgaXMgdGhlIHJlY29y ZF9lbmQgb2YgY3VycmVudAogCQkgICAgIGluc3RydWN0aW9uLiAgKi8KIAkJ ICAvKiBzdGVwICovCi0JCSAgaWYgKHJlY29yZF9yZXN1bWVfc3RlcCkKKwkJ ICBpZiAocmVjb3JkX3Jlc3VtZV9zdGVwCisgICAgICAgICAgICAgICAgICAg ICAgJiYgcHRpZF9lcXVhbCAoaW5mZXJpb3JfcHRpZCwgb2xkX2luZmVyaW9y X3B0aWQpKQogCQkgICAgewogCQkgICAgICBpZiAocmVjb3JkX2RlYnVnID4g MSkKIAkJCWZwcmludGZfdW5maWx0ZXJlZCAoZ2RiX3N0ZGxvZywKIAkJCQkJ ICAgICJQcm9jZXNzIHJlY29yZDogc3RlcC5cbiIpOwotCQkgICAgICBjb250 aW51ZV9mbGFnID0gMDsKKyAgICAgICAgICAgICAgICAgICAgICBjb250aW51 ZV9mbGFnID0gMDsKIAkJICAgIH0KIAogCQkgIC8qIGNoZWNrIGJyZWFrcG9p bnQgKi8KIAkJICB0bXBfcGMgPSByZWdjYWNoZV9yZWFkX3BjIChyZWdjYWNo ZSk7CiAJCSAgaWYgKGJyZWFrcG9pbnRfaW5zZXJ0ZWRfaGVyZV9wIChhc3Bh Y2UsIHRtcF9wYykpCiAJCSAgICB7Ci0JCSAgICAgIGludCBkZWNyX3BjX2Fm dGVyX2JyZWFrCisJCSAgICAgIENPUkVfQUREUiBkZWNyX3BjX2FmdGVyX2Jy ZWFrCiAJCQk9IGdkYmFyY2hfZGVjcl9wY19hZnRlcl9icmVhayAoZ2RiYXJj aCk7CiAKIAkJICAgICAgaWYgKHJlY29yZF9kZWJ1ZykKQEAgLTEyODgsMjIg KzE3NDAsMjMgQEAgUHJvY2VzcyByZWNvcmQ6IGhpdCBodyB3YXRjaHBvaW50 LlxuIik7CiAJfQogICAgICAgd2hpbGUgKGNvbnRpbnVlX2ZsYWcpOwogCi0g ICAgICBzaWduYWwgKFNJR0lOVCwgaGFuZGxlX3NpZ2ludCk7Ci0KIHJlcGxh eV9vdXQ6Ci0gICAgICBpZiAocmVjb3JkX2dldF9zaWcpCi0Jc3RhdHVzLT52 YWx1ZS5zaWcgPSBUQVJHRVRfU0lHTkFMX0lOVDsKLSAgICAgIGVsc2UgaWYg KHJlY29yZF9saXN0LT51LmVuZC5zaWd2YWwgIT0gVEFSR0VUX1NJR05BTF8w KQorICAgICAgaWYgKHJlY29yZF9saXN0LT51LmVuZC5zaWd2YWwgIT0gVEFS R0VUX1NJR05BTF8wKQogCS8qIEZJWE1FOiBiZXR0ZXIgd2F5IHRvIGNoZWNr ICovCiAJc3RhdHVzLT52YWx1ZS5zaWcgPSByZWNvcmRfbGlzdC0+dS5lbmQu c2lndmFsOwogICAgICAgZWxzZQogCXN0YXR1cy0+dmFsdWUuc2lnID0gVEFS R0VUX1NJR05BTF9UUkFQOworICAgICAgcmV0X3B0aWQgPSBpbmZlcmlvcl9w dGlkOwogCiAgICAgICBkaXNjYXJkX2NsZWFudXBzIChvbGRfY2xlYW51cHMp OwogICAgIH0KIAorICBpZiAocmVjb3JkX2dldF9zaWcpCisgICAgc3RhdHVz LT52YWx1ZS5zaWcgPSBUQVJHRVRfU0lHTkFMX0lOVDsKKworICBkb19jbGVh bnVwcyAoc2lnbmFsX2NsZWFudXBzKTsKICAgZG9fY2xlYW51cHMgKHNldF9j bGVhbnVwcyk7Ci0gIHJldHVybiBpbmZlcmlvcl9wdGlkOworICByZXR1cm4g cmV0X3B0aWQ7CiB9CiAKIHN0YXRpYyBpbnQKQEAgLTEzODQsNiArMTgzNywx MiBAQCByZWNvcmRfcmVnaXN0ZXJzX2NoYW5nZSAoc3RydWN0IHJlZ2NhY2hl CiAgIHJlY29yZF9hcmNoX2xpc3RfaGVhZCA9IE5VTEw7CiAgIHJlY29yZF9h cmNoX2xpc3RfdGFpbCA9IE5VTEw7CiAKKyAgaWYgKCFwdGlkX2VxdWFsIChy ZWNvcmRfcHJldl9wdGlkLCBpbmZlcmlvcl9wdGlkKSkKKyAgICB7CisgICAg ICByZWNvcmRfYXJjaF9saXN0X2FkZF9wdGlkICgmcmVjb3JkX3ByZXZfcHRp ZCk7CisgICAgICByZWNvcmRfcHJldl9wdGlkID0gaW5mZXJpb3JfcHRpZDsK KyAgICB9CisKICAgaWYgKHJlZ251bSA8IDApCiAgICAgewogICAgICAgaW50 IGk7CkBAIC0xNTA2LDYgKzE5NjUsMTEgQEAgcmVjb3JkX3hmZXJfcGFydGlh bCAoc3RydWN0IHRhcmdldF9vcHMgKgogICAgICAgLyogUmVjb3JkIHJlZ2lz dGVycyBjaGFuZ2UgdG8gbGlzdCBhcyBhbiBpbnN0cnVjdGlvbi4gICovCiAg ICAgICByZWNvcmRfYXJjaF9saXN0X2hlYWQgPSBOVUxMOwogICAgICAgcmVj b3JkX2FyY2hfbGlzdF90YWlsID0gTlVMTDsKKyAgICAgIGlmICghcHRpZF9l cXVhbCAocmVjb3JkX3ByZXZfcHRpZCwgaW5mZXJpb3JfcHRpZCkpCisgICAg ICAgIHsKKyAgICAgICAgICByZWNvcmRfYXJjaF9saXN0X2FkZF9wdGlkICgm cmVjb3JkX3ByZXZfcHRpZCk7CisgICAgICAgICAgcmVjb3JkX3ByZXZfcHRp ZCA9IGluZmVyaW9yX3B0aWQ7CisgICAgICAgIH0KICAgICAgIGlmIChyZWNv cmRfYXJjaF9saXN0X2FkZF9tZW0gKG9mZnNldCwgbGVuKSkKIAl7CiAJICBy ZWNvcmRfbGlzdF9yZWxlYXNlIChyZWNvcmRfYXJjaF9saXN0X3RhaWwpOwpA QCAtMjA2MSw2ICsyNTI1LDE3IEBAIGluZm9fcmVjb3JkX2NvbW1hbmQgKGNo YXIgKmFyZ3MsIGludCBmcm8KICAgICAgICA0IGJ5dGVzOiBtZW1vcnkgbGVu Z3RoIChuZXR3b3JrIGJ5dGUgb3JkZXIpLgogICAgICAgIDggYnl0ZXM6IG1l bW9yeSBhZGRyZXNzIChuZXR3b3JrIGJ5dGUgb3JkZXIpLgogICAgICAgIG4g Ynl0ZXM6IG1lbW9yeSB2YWx1ZSAobiA9PSBtZW1vcnkgbGVuZ3RoKS4KKyAg ICAgcmVjb3JkX21lbToKKyAgICAgICAxIGJ5dGU6ICByZWNvcmQgdHlwZSAo cmVjb3JkX21lbSwgc2VlIGVudW0gcmVjb3JkX3R5cGUpLgorICAgICAgIDQg Ynl0ZXM6IG1lbW9yeSBsZW5ndGggKG5ldHdvcmsgYnl0ZSBvcmRlcikuCisg ICAgICAgOCBieXRlczogbWVtb3J5IGFkZHJlc3MgKG5ldHdvcmsgYnl0ZSBv cmRlcikuCisgICAgICAgbiBieXRlczogbWVtb3J5IHZhbHVlIChuID09IG1l bW9yeSBsZW5ndGgpLgorICAgICByZWNvcmRfcHRpZDoKKyAgICAgICAxIGJ5 dGU6ICByZWNvcmQgdHlwZSAocmVjb3JkX3B0aWQsIHNlZSBlbnVtIHJlY29y ZF90eXBlKS4KKyAgICAgICA4IGJ5dGVzOiBwcm9jZXNzIGlkIChuZXR3b3Jr IGJ5dGUgb3JkZXIpLgorICAgICAgICAgICAgICAgIEl0IG11c3Qgc2FtZSB3 aXRoIENPUkVMT1dfUElEICgxKS4KKyAgICAgICA4IGJ5dGVzOiBsaWdodHdl aWdodCBwcm9jZXNzIGlkIChuZXR3b3JrIGJ5dGUgb3JkZXIpLgorICAgICAg IDggYnl0ZXM6IHRocmVhZCBpZCAobmV0d29yayBieXRlIG9yZGVyKS4KIAog Ki8KIApAQCAtMjIyMiw2ICsyNjk3LDMyIEBAIHJlY29yZF9yZXN0b3JlICh2 b2lkKQogCQkJCXJlYy0+dS5tZW0ubGVuKTsKICAgICAgICAgICBicmVhazsK IAorICAgICAgICBjYXNlIHJlY29yZF9wdGlkOiAvKiBwdGlkICovCisgICAg ICAgICAgcmVjID0gcmVjb3JkX3B0aWRfYWxsb2MgKCk7CisKKwkgIC8qIEdl dCBQcm9jZXNzIGlkLiAgKi8KKwkgIGJmZGNvcmVfcmVhZCAoY29yZV9iZmQs IG9zZWMsICZhZGRyLAorCQkJc2l6ZW9mIChhZGRyKSwgJmJmZF9vZmZzZXQp OworCSAgcmVjLT51LnB0aWQucGlkID0gKGludCkgbmV0b3JkZXI2NCAoYWRk cik7CisKKwkgIC8qIEdldCBMaWdodHdlaWdodCBwcm9jZXNzIGlkLiAgKi8K KwkgIGJmZGNvcmVfcmVhZCAoY29yZV9iZmQsIG9zZWMsICZhZGRyLAorCQkJ c2l6ZW9mIChhZGRyKSwgJmJmZF9vZmZzZXQpOworCSAgcmVjLT51LnB0aWQu bHdwID0gKGxvbmcpIG5ldG9yZGVyNjQgKGFkZHIpOworCisJICAvKiBHZXQg VGhyZWFkIGlkLiAgKi8KKwkgIGJmZGNvcmVfcmVhZCAoY29yZV9iZmQsIG9z ZWMsICZhZGRyLAorCQkJc2l6ZW9mIChhZGRyKSwgJmJmZF9vZmZzZXQpOwor CSAgcmVjLT51LnB0aWQudGlkID0gKGxvbmcpIG5ldG9yZGVyNjQgKGFkZHIp OworCisJICBpZiAocmVjb3JkX2RlYnVnKQorCSAgICBmcHJpbnRmX3VuZmls dGVyZWQgKGdkYl9zdGRsb2csICJcCisgIFJlYWRpbmcgcHRpZCAlcyAoMSAr IDggKyA4ICsgOCBieXRlcyksIG9mZnNldCA9PSAlc1xuIiwKKwkJCQl0YXJn ZXRfcGlkX3RvX3N0ciAocmVjb3JkX2xpc3QtPnUucHRpZCksCisJCQkJcGFk ZHJlc3MgKGdldF9jdXJyZW50X2FyY2ggKCksCisJCQkJCSAgYmZkX29mZnNl dCkpOworICAgICAgICAgIGJyZWFrOworCiAgICAgICAgIGNhc2UgcmVjb3Jk X2VuZDogLyogZW5kICovCiAgICAgICAgICAgcmVjID0gcmVjb3JkX2VuZF9h bGxvYyAoKTsKICAgICAgICAgICByZWNvcmRfaW5zbl9udW0gKys7CkBAIC0y MzI3LDYgKzI4MjgsNyBAQCBjbWRfcmVjb3JkX3NhdmUgKGNoYXIgKmFyZ3Ms IGludCBmcm9tX3R0CiAgIHVpbnQzMl90IG1hZ2ljOwogICBzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlOwogICBzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaDsK KyAgc3RydWN0IGFkZHJlc3Nfc3BhY2UgKmFzcGFjZTsKICAgc3RydWN0IGNs ZWFudXAgKm9sZF9jbGVhbnVwczsKICAgc3RydWN0IGNsZWFudXAgKnNldF9j bGVhbnVwczsKICAgYmZkICpvYmZkOwpAQCAtMjM2Myw2ICsyODY1LDcgQEAg Y21kX3JlY29yZF9zYXZlIChjaGFyICphcmdzLCBpbnQgZnJvbV90dAogICAv KiBHZXQgdGhlIHZhbHVlcyBvZiByZWdjYWNoZSBhbmQgZ2RiYXJjaC4gICov CiAgIHJlZ2NhY2hlID0gZ2V0X2N1cnJlbnRfcmVnY2FjaGUgKCk7CiAgIGdk YmFyY2ggPSBnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpOworICBhc3Bh Y2UgPSBnZXRfcmVnY2FjaGVfYXNwYWNlIChyZWdjYWNoZSk7CiAKICAgLyog RGlzYWJsZSB0aGUgR0RCIG9wZXJhdGlvbiByZWNvcmQuICAqLwogICBzZXRf Y2xlYW51cHMgPSByZWNvcmRfZ2RiX29wZXJhdGlvbl9kaXNhYmxlX3NldCAo KTsKQEAgLTIzNzQsNyArMjg3Nyw3IEBAIGNtZF9yZWNvcmRfc2F2ZSAoY2hh ciAqYXJncywgaW50IGZyb21fdHQKICAgICAgIGlmIChyZWNvcmRfbGlzdCA9 PSAmcmVjb3JkX2ZpcnN0KQogICAgICAgICBicmVhazsKIAotICAgICAgcmVj b3JkX2V4ZWNfaW5zbiAocmVnY2FjaGUsIGdkYmFyY2gsIHJlY29yZF9saXN0 KTsKKyAgICAgIHJlY29yZF9leGVjX2luc24gKCZyZWdjYWNoZSwgJmdkYmFy Y2gsICZhc3BhY2UsIHJlY29yZF9saXN0KTsKIAogICAgICAgaWYgKHJlY29y ZF9saXN0LT5wcmV2KQogICAgICAgICByZWNvcmRfbGlzdCA9IHJlY29yZF9s aXN0LT5wcmV2OwpAQCAtMjM5NSw2ICsyODk4LDkgQEAgY21kX3JlY29yZF9z YXZlIChjaGFyICphcmdzLCBpbnQgZnJvbV90dAogICAgICAgY2FzZSByZWNv cmRfbWVtOgogCXNhdmVfc2l6ZSArPSAxICsgNCArIDggKyByZWNvcmRfbGlz dC0+dS5tZW0ubGVuOwogCWJyZWFrOworICAgICAgY2FzZSByZWNvcmRfcHRp ZDoKKwlzYXZlX3NpemUgKz0gMSArIDggKyA4ICsgODsKKwlicmVhazsKICAg ICAgIH0KIAogICAvKiBNYWtlIHRoZSBuZXcgYmZkIHNlY3Rpb24uICAqLwpA QCAtMjQ4MSw2ICsyOTg3LDI1IEBAIGNtZF9yZWNvcmRfc2F2ZSAoY2hhciAq YXJncywgaW50IGZyb21fdHQKIAkJCSAgICAgcmVjb3JkX2xpc3QtPnUubWVt LmxlbiwgJmJmZF9vZmZzZXQpOwogICAgICAgICAgICAgICBicmVhazsKIAor ICAgICAgICAgICAgY2FzZSByZWNvcmRfcHRpZDogLyogcHRpZCAqLworCSAg ICAgIGlmIChyZWNvcmRfZGVidWcpCisJCWZwcmludGZfdW5maWx0ZXJlZCAo Z2RiX3N0ZGxvZywgIlwKKyAgV3JpdGluZyBwdGlkICVzICgxIHBsdXMgOCBw bHVzIDggcGx1cyA4IGJ5dGVzKVxuIiwKKwkJCQkgICAgdGFyZ2V0X3BpZF90 b19zdHIgKHJlY29yZF9saXN0LT51LnB0aWQpKTsKKworCSAgICAgIC8qIFdy aXRlIFByb2Nlc3MgaWQuICAqLworCSAgICAgIGFkZHIgPSBuZXRvcmRlcjY0 ICgodWludDY0X3QpIDEpOworCSAgICAgIGJmZGNvcmVfd3JpdGUgKG9iZmQs IG9zZWMsICZhZGRyLCBzaXplb2YgKGFkZHIpLCAmYmZkX29mZnNldCk7CisK KwkgICAgICAvKiBXcml0ZSBMaWdodHdlaWdodCBwcm9jZXNzIGlkLiAgKi8K KwkgICAgICBhZGRyID0gbmV0b3JkZXI2NCAoKHVpbnQ2NF90KSByZWNvcmRf bGlzdC0+dS5wdGlkLmx3cCk7CisJICAgICAgYmZkY29yZV93cml0ZSAob2Jm ZCwgb3NlYywgJmFkZHIsIHNpemVvZiAoYWRkciksICZiZmRfb2Zmc2V0KTsK KworCSAgICAgIC8qIFdyaXRlIFRocmVhZCBpZC4gICovCisJICAgICAgYWRk ciA9IG5ldG9yZGVyNjQgKCh1aW50NjRfdCkgcmVjb3JkX2xpc3QtPnUucHRp ZC50aWQpOworCSAgICAgIGJmZGNvcmVfd3JpdGUgKG9iZmQsIG9zZWMsICZh ZGRyLCBzaXplb2YgKGFkZHIpLCAmYmZkX29mZnNldCk7CisgICAgICAgICAg ICAgIGJyZWFrOworCiAgICAgICAgICAgICAgIGNhc2UgcmVjb3JkX2VuZDoK IAkJaWYgKHJlY29yZF9kZWJ1ZykKIAkJICBmcHJpbnRmX3VuZmlsdGVyZWQg KGdkYl9zdGRsb2csICJcCkBAIC0yNTAxLDcgKzMwMjYsNyBAQCBjbWRfcmVj b3JkX3NhdmUgKGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0CiAgICAgICAgIH0K IAogICAgICAgLyogRXhlY3V0ZSBlbnRyeS4gICovCi0gICAgICByZWNvcmRf ZXhlY19pbnNuIChyZWdjYWNoZSwgZ2RiYXJjaCwgcmVjb3JkX2xpc3QpOwor ICAgICAgcmVjb3JkX2V4ZWNfaW5zbiAoJnJlZ2NhY2hlLCAmZ2RiYXJjaCwg JmFzcGFjZSwgcmVjb3JkX2xpc3QpOwogCiAgICAgICBpZiAocmVjb3JkX2xp c3QtPm5leHQpCiAgICAgICAgIHJlY29yZF9saXN0ID0gcmVjb3JkX2xpc3Qt Pm5leHQ7CkBAIC0yNTE2LDcgKzMwNDEsNyBAQCBjbWRfcmVjb3JkX3NhdmUg KGNoYXIgKmFyZ3MsIGludCBmcm9tX3R0CiAgICAgICBpZiAocmVjb3JkX2xp c3QgPT0gY3VyX3JlY29yZF9saXN0KQogICAgICAgICBicmVhazsKIAotICAg ICAgcmVjb3JkX2V4ZWNfaW5zbiAocmVnY2FjaGUsIGdkYmFyY2gsIHJlY29y ZF9saXN0KTsKKyAgICAgIHJlY29yZF9leGVjX2luc24gKCZyZWdjYWNoZSwg JmdkYmFyY2gsICZhc3BhY2UsIHJlY29yZF9saXN0KTsKIAogICAgICAgaWYg KHJlY29yZF9saXN0LT5wcmV2KQogICAgICAgICByZWNvcmRfbGlzdCA9IHJl Y29yZF9saXN0LT5wcmV2OwpAQCAtMjU0Miw2ICszMDY3LDcgQEAgcmVjb3Jk X2dvdG9faW5zbiAoc3RydWN0IHJlY29yZF9lbnRyeSAqZQogICBzdHJ1Y3Qg Y2xlYW51cCAqc2V0X2NsZWFudXBzID0gcmVjb3JkX2dkYl9vcGVyYXRpb25f ZGlzYWJsZV9zZXQgKCk7CiAgIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUg PSBnZXRfY3VycmVudF9yZWdjYWNoZSAoKTsKICAgc3RydWN0IGdkYmFyY2gg KmdkYmFyY2ggPSBnZXRfcmVnY2FjaGVfYXJjaCAocmVnY2FjaGUpOworICBz dHJ1Y3QgYWRkcmVzc19zcGFjZSAqYXNwYWNlID0gZ2V0X3JlZ2NhY2hlX2Fz cGFjZSAocmVnY2FjaGUpOwogCiAgIC8qIEFzc3VtZSBldmVyeXRoaW5nIGlz IHZhbGlkOiB3ZSB3aWxsIGhpdCB0aGUgZW50cnksCiAgICAgIGFuZCB3ZSB3 aWxsIG5vdCBoaXQgdGhlIGVuZCBvZiB0aGUgcmVjb3JkaW5nLiAgKi8KQEAg LTI1NTEsNyArMzA3Nyw3IEBAIHJlY29yZF9nb3RvX2luc24gKHN0cnVjdCBy ZWNvcmRfZW50cnkgKmUKIAogICBkbwogICAgIHsKLSAgICAgIHJlY29yZF9l eGVjX2luc24gKHJlZ2NhY2hlLCBnZGJhcmNoLCByZWNvcmRfbGlzdCk7Cisg ICAgICByZWNvcmRfZXhlY19pbnNuICgmcmVnY2FjaGUsICZnZGJhcmNoLCAm YXNwYWNlLCByZWNvcmRfbGlzdCk7CiAgICAgICBpZiAoZGlyID09IEVYRUNf UkVWRVJTRSkKIAlyZWNvcmRfbGlzdCA9IHJlY29yZF9saXN0LT5wcmV2Owog ICAgICAgZWxzZQotLS0gYS9yZWNvcmQuaAorKysgYi9yZWNvcmQuaApAQCAt MjMsNiArMjMsNyBAQAogI2RlZmluZSBSRUNPUkRfSVNfVVNFRAkoY3VycmVu dF90YXJnZXQudG9fc3RyYXR1bSA9PSByZWNvcmRfc3RyYXR1bSkKIAogZXh0 ZXJuIGludCByZWNvcmRfZGVidWc7CitleHRlcm4gaW50IHJlY29yZF9zdGVw OwogCiBleHRlcm4gaW50IHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAoc3Ry dWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwgaW50IG51bSk7CiBleHRlcm4gaW50 IHJlY29yZF9hcmNoX2xpc3RfYWRkX21lbSAoQ09SRV9BRERSIGFkZHIsIGlu dCBsZW4pOwo= --00504502b22edcc1b804792d8914--