From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 14704 invoked by alias); 27 Aug 2009 15:35:43 -0000 Received: (qmail 14681 invoked by uid 22791); 27 Aug 2009 15:35:37 -0000 X-SWARE-Spam-Status: No, hits=-1.4 required=5.0 tests=AWL,BAYES_00,J_CHICKENPOX_48,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mail-pz0-f202.google.com (HELO mail-pz0-f202.google.com) (209.85.222.202) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 27 Aug 2009 15:35:29 +0000 Received: by pzk40 with SMTP id 40so1148926pzk.26 for ; Thu, 27 Aug 2009 08:35:27 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.1.3 with SMTP id 3mr901169wfa.66.1251387327086; Thu, 27 Aug 2009 08:35:27 -0700 (PDT) From: Hui Zhu Date: Thu, 27 Aug 2009 16:50:00 -0000 Message-ID: Subject: [RFA/Prec] Add signal support for process record To: gdb-patches ml Cc: Michael Snyder , Anthony Green Content-Type: multipart/mixed; boundary=001636b2bc021b81e7047221514b 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/msg00484.txt.bz2 --001636b2bc021b81e7047221514b Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 13331 Hi guys, I found that prec with signal has some bugs and support is not very well. So I make a patch for it. What it include is: 1. Fix the bug in record_wait, it always send the same sig to the resume, it will make sig send to inferior again and agin. 2. Add a new argument sig to arch interface "process_record". Then each arch can handle with sig with itself. With linux, TARGET_SIGNAL_0 means not send a sig. Update the each process_record of i386 and moxie. 3. Add a new interface i386_signal_record in i386 to let each taget can add code to handle sig. Please post your comments about it. Thanks a lot. :) Hui 2009-08-27 Hui Zhu * gdbarch.sh (process_record): Add a argument "siggnal". * record.c (record_message): Ditto. (record_wait): Set record_resume_siggnal to TARGET_SIGNAL_0. Change the last argument of record_beneath_to_resume to TARGET_SIGNAL_0. * i386-tdep.c (i386_process_record): Add a argument "siggnal". Call "i386_signal_record". * i386-tdep.h (gdbarch_tdep): Add i386_signal_record. * i386-linux-tdep.c (i386_linux_all_register_record): New function. (i386_linux_intx80_sysenter_record): Call "i386_linux_all_register_record" if the syscall is sys_sigreturn or sys_rt_sigreturn. (i386_linux_signal_record): New function. (i386_linux_init_abi): Set tdep->i386_signal_record to i386_linux_signal_record. * amd64-linux-tdep.c (amd64_linux_all_register_record): New function. (amd64_linux_syscall_record): Call "amd64_linux_all_register_record" if syscall is sys_rt_sigreturn. (amd64_linux_signal_record): New function. (amd64_linux_init_abi): Set tdep->i386_signal_record to amd64_linux_signal_record. * moxie-tdep.c (moxie_process_record): Add a argument "siggnal". --- amd64-linux-tdep.c | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++++- gdbarch.c | 4 +-- gdbarch.h | 4 +-- gdbarch.sh | 2 - i386-linux-tdep.c | 51 ++++++++++++++++++++++++++++++++++++++++++ i386-tdep.c | 21 +++++++++++++++-- i386-tdep.h | 6 ++++- moxie-tdep.c | 7 +++-- record.c | 10 +++++--- 9 files changed, 152 insertions(+), 16 deletions(-) --- a/amd64-linux-tdep.c +++ b/amd64-linux-tdep.c @@ -275,6 +275,47 @@ static struct linux_record_tdep amd64_li #define RECORD_ARCH_GET_GS 0x1004 static int +amd64_linux_all_register_record (struct regcache *regcache) +{ + if (record_arch_list_add_reg (regcache, AMD64_RAX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RCX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RDX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RBX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RSP_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RBP_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RSI_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_RDI_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R8_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R9_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R10_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R11_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R12_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R13_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R14_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_R15_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, AMD64_EFLAGS_REGNUM)) + return -1; + + return 0; +} + +static int amd64_linux_syscall_record (struct regcache *regcache) { int ret, num = -1; @@ -347,7 +388,9 @@ amd64_linux_syscall_record (struct regca break; /* sys_rt_sigreturn */ case 15: - num = 173; + if (amd64_linux_all_register_record (regcache)) + return -1; + return 0; break; /* sys_ioctl */ case 16: @@ -1384,6 +1427,22 @@ amd64_linux_syscall_record (struct regca return 0; } +static int +amd64_linux_signal_record (struct regcache *regcache, + enum target_signal signal) +{ + if (signal == TARGET_SIGNAL_0) + return 100; + + if (amd64_linux_all_register_record (regcache)) + return -1; + + if (record_arch_list_add_reg (regcache, AMD64_RIP_REGNUM)) + return -1; + + return 0; +} + static void amd64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { @@ -1599,6 +1658,8 @@ amd64_linux_init_abi (struct gdbarch_inf amd64_linux_record_tdep.arg6 = AMD64_R9_REGNUM; tdep->i386_syscall_record = amd64_linux_syscall_record; + + tdep->i386_signal_record = amd64_linux_signal_record; } --- a/gdbarch.c +++ b/gdbarch.c @@ -3282,13 +3282,13 @@ gdbarch_process_record_p (struct gdbarch } int -gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr) +gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, enum target_signal siggnal) { gdb_assert (gdbarch != NULL); gdb_assert (gdbarch->process_record != NULL); if (gdbarch_debug >= 2) fprintf_unfiltered (gdb_stdlog, "gdbarch_process_record called\n"); - return gdbarch->process_record (gdbarch, regcache, addr); + return gdbarch->process_record (gdbarch, regcache, addr, siggnal); } void --- a/gdbarch.h +++ b/gdbarch.h @@ -817,8 +817,8 @@ extern void set_gdbarch_sofun_address_ma extern int gdbarch_process_record_p (struct gdbarch *gdbarch); -typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); -extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr); +typedef int (gdbarch_process_record_ftype) (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, enum target_signal siggnal); +extern int gdbarch_process_record (struct gdbarch *gdbarch, struct regcache *regcache, CORE_ADDR addr, enum target_signal siggnal); extern void set_gdbarch_process_record (struct gdbarch *gdbarch, gdbarch_process_record_ftype *process_record); /* Signal translation: translate inferior's signal (host's) number into --- a/gdbarch.sh +++ b/gdbarch.sh @@ -707,7 +707,7 @@ v:int:sofun_address_maybe_missing:::0:0: # the registers REGCACHE and memory ranges that will be affected when # the instruction executes, along with their current values. # Return -1 if something goes wrong, 0 otherwise. -M:int:process_record:struct regcache *regcache, CORE_ADDR addr:regcache, addr +M:int:process_record:struct regcache *regcache, CORE_ADDR addr, enum target_signal siggnal:regcache, addr, siggnal # Signal translation: translate inferior's signal (host's) number into # GDB's representation. --- a/i386-linux-tdep.c +++ b/i386-linux-tdep.c @@ -364,6 +364,31 @@ i386_linux_write_pc (struct regcache *re static struct linux_record_tdep i386_linux_record_tdep; static int +i386_linux_all_register_record (struct regcache *regcache) +{ + if (record_arch_list_add_reg (regcache, I386_EAX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_ECX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_EDX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_EBX_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_ESP_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_EBP_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_ESI_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_EDI_REGNUM)) + return -1; + if (record_arch_list_add_reg (regcache, I386_EFLAGS_REGNUM)) + return -1; + + return 0; +} + +static int i386_linux_intx80_sysenter_record (struct regcache *regcache) { int ret; @@ -378,6 +403,14 @@ i386_linux_intx80_sysenter_record (struc return -1; } + if (tmpu32 == 119 || tmpu32 == 173) + { + /* sys_sigreturn sys_rt_sigreturn */ + if (i386_linux_all_register_record (regcache)) + return -1; + return 0; + } + ret = record_linux_system_call (tmpu32, regcache, &i386_linux_record_tdep); if (ret) @@ -389,6 +422,22 @@ i386_linux_intx80_sysenter_record (struc return 0; } + +static int +i386_linux_signal_record (struct regcache *regcache, + enum target_signal signal) +{ + if (signal == TARGET_SIGNAL_0) + return 100; + + if (i386_linux_all_register_record (regcache)) + return -1; + + if (record_arch_list_add_reg (regcache, I386_EIP_REGNUM)) + return -1; + + return 0; +} /* The register sets used in GNU/Linux ELF core-dumps are identical to @@ -647,6 +696,8 @@ i386_linux_init_abi (struct gdbarch_info tdep->i386_intx80_record = i386_linux_intx80_sysenter_record; tdep->i386_sysenter_record = i386_linux_intx80_sysenter_record; + tdep->i386_signal_record = i386_linux_signal_record; + /* N_FUN symbols in shared libaries have 0 for their values and need to be relocated. */ set_gdbarch_sofun_address_maybe_missing (gdbarch, 1); --- a/i386-tdep.c +++ b/i386-tdep.c @@ -3205,7 +3205,7 @@ i386_record_push (struct i386_record_s * int i386_process_record (struct gdbarch *gdbarch, struct regcache *regcache, - CORE_ADDR addr) + CORE_ADDR addr, enum target_signal signal) { int prefixes = 0; uint8_t tmpu8; @@ -3230,8 +3230,23 @@ i386_process_record (struct gdbarch *gdb if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, "Process record: i386_process_record " - "addr = %s\n", - paddress (gdbarch, ir.addr)); + "addr = %s signal = %s\n", + paddress (gdbarch, ir.addr), + target_signal_to_name (signal)); + + if (gdbarch_tdep (gdbarch)->i386_signal_record != NULL) + { + int ret; + + /* If this signal is not be handled, return 100. */ + ret = gdbarch_tdep (gdbarch)->i386_signal_record (ir.regcache, signal); + if (ret < 100) + { + if (record_arch_list_add_end ()) + return -1; + return ret; + } + } /* prefixes */ while (1) --- a/i386-tdep.h +++ b/i386-tdep.h @@ -114,6 +114,9 @@ struct gdbarch_tdep /* The map for registers because the AMD64's registers order in GDB is not same as I386 instructions. */ const int *record_regmap; + /* Parse signal args. */ + int (*i386_signal_record) (struct regcache *regcache, + enum target_signal signal); /* Parse intx80 args. */ int (*i386_intx80_record) (struct regcache *regcache); /* Parse sysenter args. */ @@ -261,7 +264,8 @@ extern void i386_elf_init_abi (struct gd extern void i386_svr4_init_abi (struct gdbarch_info, struct gdbarch *); extern int i386_process_record (struct gdbarch *gdbarch, - struct regcache *regcache, CORE_ADDR addr); + struct regcache *regcache, CORE_ADDR addr, + enum target_signal signal); /* Functions and variables exported from i386bsd-tdep.c. */ --- a/moxie-tdep.c +++ b/moxie-tdep.c @@ -501,7 +501,7 @@ moxie_process_readu (CORE_ADDR addr, cha int moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache, - CORE_ADDR addr) + CORE_ADDR addr, enum target_signal signal) { gdb_byte buf[4]; uint16_t inst; @@ -510,8 +510,9 @@ moxie_process_record (struct gdbarch *gd if (record_debug > 1) fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record " - "addr = 0x%s\n", - paddress (target_gdbarch, addr)); + "addr = 0x%s signal = %s\n", + paddress (target_gdbarch, addr), + target_signal_to_name (signal)); inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order); --- a/record.c +++ b/record.c @@ -92,6 +92,8 @@ static int record_stop_at_limit = 1; static int record_insn_max_num = DEFAULT_RECORD_INSN_MAX_NUM; static int record_insn_num = 0; +static enum target_signal record_resume_siggnal; + /* The target_ops of process record. */ static struct target_ops record_ops; @@ -373,7 +375,8 @@ record_message (void *args) ret = gdbarch_process_record (get_regcache_arch (regcache), regcache, - regcache_read_pc (regcache)); + regcache_read_pc (regcache), + record_resume_siggnal); if (ret > 0) error (_("Process record: inferior program stopped.")); if (ret < 0) @@ -514,7 +517,6 @@ record_close (int quitting) } static int record_resume_step = 0; -static enum target_signal record_resume_siggnal; static int record_resume_error; static void @@ -606,6 +608,8 @@ record_wait (struct target_ops *ops, ptid_t ret; CORE_ADDR tmp_pc; + record_resume_siggnal = TARGET_SIGNAL_0; + while (1) { ret = record_beneath_to_wait (record_beneath_to_wait_ops, @@ -638,7 +642,7 @@ record_wait (struct target_ops *ops, } record_beneath_to_resume (record_beneath_to_resume_ops, ptid, 1, - record_resume_siggnal); + TARGET_SIGNAL_0); continue; } } --001636b2bc021b81e7047221514b Content-Type: text/plain; charset=US-ASCII; name="prec-fix-signal.txt" Content-Disposition: attachment; filename="prec-fix-signal.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fyvnm9ti0 Content-length: 15751 LS0tCiBhbWQ2NC1saW51eC10ZGVwLmMgfCAgIDYzICsrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiBnZGJh cmNoLmMgICAgICAgICAgfCAgICA0ICstLQogZ2RiYXJjaC5oICAgICAgICAg IHwgICAgNCArLS0KIGdkYmFyY2guc2ggICAgICAgICB8ICAgIDIgLQogaTM4 Ni1saW51eC10ZGVwLmMgIHwgICA1MSArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysKIGkzODYtdGRlcC5jICAgICAgICB8ICAg MjEgKysrKysrKysrKysrKysrLS0KIGkzODYtdGRlcC5oICAgICAgICB8ICAg IDYgKysrKy0KIG1veGllLXRkZXAuYyAgICAgICB8ICAgIDcgKysrLS0KIHJl Y29yZC5jICAgICAgICAgICB8ICAgMTAgKysrKystLS0KIDkgZmlsZXMgY2hh bmdlZCwgMTUyIGluc2VydGlvbnMoKyksIDE2IGRlbGV0aW9ucygtKQoKLS0t IGEvYW1kNjQtbGludXgtdGRlcC5jCisrKyBiL2FtZDY0LWxpbnV4LXRkZXAu YwpAQCAtMjc1LDYgKzI3NSw0NyBAQCBzdGF0aWMgc3RydWN0IGxpbnV4X3Jl Y29yZF90ZGVwIGFtZDY0X2xpCiAjZGVmaW5lIFJFQ09SRF9BUkNIX0dFVF9H UwkweDEwMDQKIAogc3RhdGljIGludAorYW1kNjRfbGludXhfYWxsX3JlZ2lz dGVyX3JlY29yZCAoc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSkKK3sKKyAg aWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0 X1JBWF9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYgKHJlY29yZF9h cmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0X1JDWF9SRUdOVU0p KQorICAgIHJldHVybiAtMTsKKyAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRk X3JlZyAocmVnY2FjaGUsIEFNRDY0X1JEWF9SRUdOVU0pKQorICAgIHJldHVy biAtMTsKKyAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2Fj aGUsIEFNRDY0X1JCWF9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYg KHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0X1JT UF9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYgKHJlY29yZF9hcmNo X2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0X1JCUF9SRUdOVU0pKQor ICAgIHJldHVybiAtMTsKKyAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3Jl ZyAocmVnY2FjaGUsIEFNRDY0X1JTSV9SRUdOVU0pKQorICAgIHJldHVybiAt MTsKKyAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUs IEFNRDY0X1JESV9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYgKHJl Y29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0X1I4X1JF R05VTSkpCisgICAgcmV0dXJuIC0xOworICBpZiAocmVjb3JkX2FyY2hfbGlz dF9hZGRfcmVnIChyZWdjYWNoZSwgQU1ENjRfUjlfUkVHTlVNKSkKKyAgICBy ZXR1cm4gLTE7CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJl Z2NhY2hlLCBBTUQ2NF9SMTBfUkVHTlVNKSkKKyAgICByZXR1cm4gLTE7Cisg IGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJlZ2NhY2hlLCBBTUQ2 NF9SMTFfUkVHTlVNKSkKKyAgICByZXR1cm4gLTE7CisgIGlmIChyZWNvcmRf YXJjaF9saXN0X2FkZF9yZWcgKHJlZ2NhY2hlLCBBTUQ2NF9SMTJfUkVHTlVN KSkKKyAgICByZXR1cm4gLTE7CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2Fk ZF9yZWcgKHJlZ2NhY2hlLCBBTUQ2NF9SMTNfUkVHTlVNKSkKKyAgICByZXR1 cm4gLTE7CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJlZ2Nh Y2hlLCBBTUQ2NF9SMTRfUkVHTlVNKSkKKyAgICByZXR1cm4gLTE7CisgIGlm IChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJlZ2NhY2hlLCBBTUQ2NF9S MTVfUkVHTlVNKSkKKyAgICByZXR1cm4gLTE7CisgIGlmIChyZWNvcmRfYXJj aF9saXN0X2FkZF9yZWcgKHJlZ2NhY2hlLCBBTUQ2NF9FRkxBR1NfUkVHTlVN KSkKKyAgICByZXR1cm4gLTE7CisKKyAgcmV0dXJuIDA7Cit9CisKK3N0YXRp YyBpbnQKIGFtZDY0X2xpbnV4X3N5c2NhbGxfcmVjb3JkIChzdHJ1Y3QgcmVn Y2FjaGUgKnJlZ2NhY2hlKQogewogICBpbnQgcmV0LCBudW0gPSAtMTsKQEAg LTM0Nyw3ICszODgsOSBAQCBhbWQ2NF9saW51eF9zeXNjYWxsX3JlY29yZCAo c3RydWN0IHJlZ2NhCiAgICAgICBicmVhazsKICAgICAgIC8qIHN5c19ydF9z aWdyZXR1cm4gKi8KICAgICBjYXNlIDE1OgotICAgICAgbnVtID0gMTczOwor ICAgICAgaWYgKGFtZDY0X2xpbnV4X2FsbF9yZWdpc3Rlcl9yZWNvcmQgKHJl Z2NhY2hlKSkKKyAgICAgICAgcmV0dXJuIC0xOworICAgICAgcmV0dXJuIDA7 CiAgICAgICBicmVhazsKICAgICAgIC8qIHN5c19pb2N0bCAqLwogICAgIGNh c2UgMTY6CkBAIC0xMzg0LDYgKzE0MjcsMjIgQEAgYW1kNjRfbGludXhfc3lz Y2FsbF9yZWNvcmQgKHN0cnVjdCByZWdjYQogICByZXR1cm4gMDsKIH0KIAor c3RhdGljIGludAorYW1kNjRfbGludXhfc2lnbmFsX3JlY29yZCAoc3RydWN0 IHJlZ2NhY2hlICpyZWdjYWNoZSwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgIGVudW0gdGFyZ2V0X3NpZ25hbCBzaWduYWwpCit7CisgIGlmIChzaWdu YWwgPT0gVEFSR0VUX1NJR05BTF8wKQorICAgIHJldHVybiAxMDA7CisKKyAg aWYgKGFtZDY0X2xpbnV4X2FsbF9yZWdpc3Rlcl9yZWNvcmQgKHJlZ2NhY2hl KSkKKyAgICByZXR1cm4gLTE7CisKKyAgaWYgKHJlY29yZF9hcmNoX2xpc3Rf YWRkX3JlZyAocmVnY2FjaGUsIEFNRDY0X1JJUF9SRUdOVU0pKQorICAgIHJl dHVybiAtMTsKKworICByZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQKIGFt ZDY0X2xpbnV4X2luaXRfYWJpIChzdHJ1Y3QgZ2RiYXJjaF9pbmZvIGluZm8s IHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoKQogewpAQCAtMTU5OSw2ICsxNjU4 LDggQEAgYW1kNjRfbGludXhfaW5pdF9hYmkgKHN0cnVjdCBnZGJhcmNoX2lu ZgogICBhbWQ2NF9saW51eF9yZWNvcmRfdGRlcC5hcmc2ID0gQU1ENjRfUjlf UkVHTlVNOwogCiAgIHRkZXAtPmkzODZfc3lzY2FsbF9yZWNvcmQgPSBhbWQ2 NF9saW51eF9zeXNjYWxsX3JlY29yZDsKKworICB0ZGVwLT5pMzg2X3NpZ25h bF9yZWNvcmQgPSBhbWQ2NF9saW51eF9zaWduYWxfcmVjb3JkOwogfQogDAog Ci0tLSBhL2dkYmFyY2guYworKysgYi9nZGJhcmNoLmMKQEAgLTMyODIsMTMg KzMyODIsMTMgQEAgZ2RiYXJjaF9wcm9jZXNzX3JlY29yZF9wIChzdHJ1Y3Qg Z2RiYXJjaAogfQogCiBpbnQKLWdkYmFyY2hfcHJvY2Vzc19yZWNvcmQgKHN0 cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2Nh Y2hlLCBDT1JFX0FERFIgYWRkcikKK2dkYmFyY2hfcHJvY2Vzc19yZWNvcmQg KHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgcmVnY2FjaGUgKnJl Z2NhY2hlLCBDT1JFX0FERFIgYWRkciwgZW51bSB0YXJnZXRfc2lnbmFsIHNp Z2duYWwpCiB7CiAgIGdkYl9hc3NlcnQgKGdkYmFyY2ggIT0gTlVMTCk7CiAg IGdkYl9hc3NlcnQgKGdkYmFyY2gtPnByb2Nlc3NfcmVjb3JkICE9IE5VTEwp OwogICBpZiAoZ2RiYXJjaF9kZWJ1ZyA+PSAyKQogICAgIGZwcmludGZfdW5m aWx0ZXJlZCAoZ2RiX3N0ZGxvZywgImdkYmFyY2hfcHJvY2Vzc19yZWNvcmQg Y2FsbGVkXG4iKTsKLSAgcmV0dXJuIGdkYmFyY2gtPnByb2Nlc3NfcmVjb3Jk IChnZGJhcmNoLCByZWdjYWNoZSwgYWRkcik7CisgIHJldHVybiBnZGJhcmNo LT5wcm9jZXNzX3JlY29yZCAoZ2RiYXJjaCwgcmVnY2FjaGUsIGFkZHIsIHNp Z2duYWwpOwogfQogCiB2b2lkCi0tLSBhL2dkYmFyY2guaAorKysgYi9nZGJh cmNoLmgKQEAgLTgxNyw4ICs4MTcsOCBAQCBleHRlcm4gdm9pZCBzZXRfZ2Ri YXJjaF9zb2Z1bl9hZGRyZXNzX21hCiAKIGV4dGVybiBpbnQgZ2RiYXJjaF9w cm9jZXNzX3JlY29yZF9wIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCk7CiAK LXR5cGVkZWYgaW50IChnZGJhcmNoX3Byb2Nlc3NfcmVjb3JkX2Z0eXBlKSAo c3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVjdCByZWdjYWNoZSAqcmVn Y2FjaGUsIENPUkVfQUREUiBhZGRyKTsKLWV4dGVybiBpbnQgZ2RiYXJjaF9w cm9jZXNzX3JlY29yZCAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVj dCByZWdjYWNoZSAqcmVnY2FjaGUsIENPUkVfQUREUiBhZGRyKTsKK3R5cGVk ZWYgaW50IChnZGJhcmNoX3Byb2Nlc3NfcmVjb3JkX2Z0eXBlKSAoc3RydWN0 IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUs IENPUkVfQUREUiBhZGRyLCBlbnVtIHRhcmdldF9zaWduYWwgc2lnZ25hbCk7 CitleHRlcm4gaW50IGdkYmFyY2hfcHJvY2Vzc19yZWNvcmQgKHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoLCBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLCBD T1JFX0FERFIgYWRkciwgZW51bSB0YXJnZXRfc2lnbmFsIHNpZ2duYWwpOwog ZXh0ZXJuIHZvaWQgc2V0X2dkYmFyY2hfcHJvY2Vzc19yZWNvcmQgKHN0cnVj dCBnZGJhcmNoICpnZGJhcmNoLCBnZGJhcmNoX3Byb2Nlc3NfcmVjb3JkX2Z0 eXBlICpwcm9jZXNzX3JlY29yZCk7CiAKIC8qIFNpZ25hbCB0cmFuc2xhdGlv bjogdHJhbnNsYXRlIGluZmVyaW9yJ3Mgc2lnbmFsIChob3N0J3MpIG51bWJl ciBpbnRvCi0tLSBhL2dkYmFyY2guc2gKKysrIGIvZ2RiYXJjaC5zaApAQCAt NzA3LDcgKzcwNyw3IEBAIHY6aW50OnNvZnVuX2FkZHJlc3NfbWF5YmVfbWlz c2luZzo6OjA6MDoKICMgdGhlIHJlZ2lzdGVycyBSRUdDQUNIRSBhbmQgbWVt b3J5IHJhbmdlcyB0aGF0IHdpbGwgYmUgYWZmZWN0ZWQgd2hlbgogIyB0aGUg aW5zdHJ1Y3Rpb24gZXhlY3V0ZXMsIGFsb25nIHdpdGggdGhlaXIgY3VycmVu dCB2YWx1ZXMuCiAjIFJldHVybiAtMSBpZiBzb21ldGhpbmcgZ29lcyB3cm9u ZywgMCBvdGhlcndpc2UuCi1NOmludDpwcm9jZXNzX3JlY29yZDpzdHJ1Y3Qg cmVnY2FjaGUgKnJlZ2NhY2hlLCBDT1JFX0FERFIgYWRkcjpyZWdjYWNoZSwg YWRkcgorTTppbnQ6cHJvY2Vzc19yZWNvcmQ6c3RydWN0IHJlZ2NhY2hlICpy ZWdjYWNoZSwgQ09SRV9BRERSIGFkZHIsIGVudW0gdGFyZ2V0X3NpZ25hbCBz aWdnbmFsOnJlZ2NhY2hlLCBhZGRyLCBzaWdnbmFsCiAKICMgU2lnbmFsIHRy YW5zbGF0aW9uOiB0cmFuc2xhdGUgaW5mZXJpb3IncyBzaWduYWwgKGhvc3Qn cykgbnVtYmVyIGludG8KICMgR0RCJ3MgcmVwcmVzZW50YXRpb24uCi0tLSBh L2kzODYtbGludXgtdGRlcC5jCisrKyBiL2kzODYtbGludXgtdGRlcC5jCkBA IC0zNjQsNiArMzY0LDMxIEBAIGkzODZfbGludXhfd3JpdGVfcGMgKHN0cnVj dCByZWdjYWNoZSAqcmUKIHN0YXRpYyBzdHJ1Y3QgbGludXhfcmVjb3JkX3Rk ZXAgaTM4Nl9saW51eF9yZWNvcmRfdGRlcDsKIAogc3RhdGljIGludAoraTM4 Nl9saW51eF9hbGxfcmVnaXN0ZXJfcmVjb3JkIChzdHJ1Y3QgcmVnY2FjaGUg KnJlZ2NhY2hlKQoreworICBpZiAocmVjb3JkX2FyY2hfbGlzdF9hZGRfcmVn IChyZWdjYWNoZSwgSTM4Nl9FQVhfUkVHTlVNKSkKKyAgICByZXR1cm4gLTE7 CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJlZ2NhY2hlLCBJ Mzg2X0VDWF9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYgKHJlY29y ZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEkzODZfRURYX1JFR05V TSkpCisgICAgcmV0dXJuIC0xOworICBpZiAocmVjb3JkX2FyY2hfbGlzdF9h ZGRfcmVnIChyZWdjYWNoZSwgSTM4Nl9FQlhfUkVHTlVNKSkKKyAgICByZXR1 cm4gLTE7CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcgKHJlZ2Nh Y2hlLCBJMzg2X0VTUF9SRUdOVU0pKQorICAgIHJldHVybiAtMTsKKyAgaWYg KHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEkzODZfRUJQ X1JFR05VTSkpCisgICAgcmV0dXJuIC0xOworICBpZiAocmVjb3JkX2FyY2hf bGlzdF9hZGRfcmVnIChyZWdjYWNoZSwgSTM4Nl9FU0lfUkVHTlVNKSkKKyAg ICByZXR1cm4gLTE7CisgIGlmIChyZWNvcmRfYXJjaF9saXN0X2FkZF9yZWcg KHJlZ2NhY2hlLCBJMzg2X0VESV9SRUdOVU0pKQorICAgIHJldHVybiAtMTsK KyAgaWYgKHJlY29yZF9hcmNoX2xpc3RfYWRkX3JlZyAocmVnY2FjaGUsIEkz ODZfRUZMQUdTX1JFR05VTSkpCisgICAgcmV0dXJuIC0xOworCisgIHJldHVy biAwOworfQorCitzdGF0aWMgaW50CiBpMzg2X2xpbnV4X2ludHg4MF9zeXNl bnRlcl9yZWNvcmQgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUpCiB7CiAg IGludCByZXQ7CkBAIC0zNzgsNiArNDAzLDE0IEBAIGkzODZfbGludXhfaW50 eDgwX3N5c2VudGVyX3JlY29yZCAoc3RydWMKICAgICAgIHJldHVybiAtMTsK ICAgICB9CiAKKyAgaWYgKHRtcHUzMiA9PSAxMTkgfHwgdG1wdTMyID09IDE3 MykKKyAgICB7CisgICAgICAvKiBzeXNfc2lncmV0dXJuIHN5c19ydF9zaWdy ZXR1cm4gKi8KKyAgICAgIGlmIChpMzg2X2xpbnV4X2FsbF9yZWdpc3Rlcl9y ZWNvcmQgKHJlZ2NhY2hlKSkKKyAgICAgICAgcmV0dXJuIC0xOworICAgICAg cmV0dXJuIDA7CisgICAgfQorCiAgIHJldCA9IHJlY29yZF9saW51eF9zeXN0 ZW1fY2FsbCAodG1wdTMyLCByZWdjYWNoZSwKIAkJCQkgICZpMzg2X2xpbnV4 X3JlY29yZF90ZGVwKTsKICAgaWYgKHJldCkKQEAgLTM4OSw2ICs0MjIsMjIg QEAgaTM4Nl9saW51eF9pbnR4ODBfc3lzZW50ZXJfcmVjb3JkIChzdHJ1Ywog CiAgIHJldHVybiAwOwogfQorCitzdGF0aWMgaW50CitpMzg2X2xpbnV4X3Np Z25hbF9yZWNvcmQgKHN0cnVjdCByZWdjYWNoZSAqcmVnY2FjaGUsCisgICAg ICAgICAgICAgICAgICAgICAgICAgIGVudW0gdGFyZ2V0X3NpZ25hbCBzaWdu YWwpCit7CisgIGlmIChzaWduYWwgPT0gVEFSR0VUX1NJR05BTF8wKQorICAg IHJldHVybiAxMDA7CisKKyAgaWYgKGkzODZfbGludXhfYWxsX3JlZ2lzdGVy X3JlY29yZCAocmVnY2FjaGUpKQorICAgIHJldHVybiAtMTsKKworICBpZiAo cmVjb3JkX2FyY2hfbGlzdF9hZGRfcmVnIChyZWdjYWNoZSwgSTM4Nl9FSVBf UkVHTlVNKSkKKyAgICByZXR1cm4gLTE7CisKKyAgcmV0dXJuIDA7Cit9CiAM CiAKIC8qIFRoZSByZWdpc3RlciBzZXRzIHVzZWQgaW4gR05VL0xpbnV4IEVM RiBjb3JlLWR1bXBzIGFyZSBpZGVudGljYWwgdG8KQEAgLTY0Nyw2ICs2OTYs OCBAQCBpMzg2X2xpbnV4X2luaXRfYWJpIChzdHJ1Y3QgZ2RiYXJjaF9pbmZv CiAgIHRkZXAtPmkzODZfaW50eDgwX3JlY29yZCA9IGkzODZfbGludXhfaW50 eDgwX3N5c2VudGVyX3JlY29yZDsKICAgdGRlcC0+aTM4Nl9zeXNlbnRlcl9y ZWNvcmQgPSBpMzg2X2xpbnV4X2ludHg4MF9zeXNlbnRlcl9yZWNvcmQ7CiAK KyAgdGRlcC0+aTM4Nl9zaWduYWxfcmVjb3JkID0gaTM4Nl9saW51eF9zaWdu YWxfcmVjb3JkOworCiAgIC8qIE5fRlVOIHN5bWJvbHMgaW4gc2hhcmVkIGxp YmFyaWVzIGhhdmUgMCBmb3IgdGhlaXIgdmFsdWVzIGFuZCBuZWVkCiAgICAg IHRvIGJlIHJlbG9jYXRlZC4gKi8KICAgc2V0X2dkYmFyY2hfc29mdW5fYWRk cmVzc19tYXliZV9taXNzaW5nIChnZGJhcmNoLCAxKTsKLS0tIGEvaTM4Ni10 ZGVwLmMKKysrIGIvaTM4Ni10ZGVwLmMKQEAgLTMyMDUsNyArMzIwNSw3IEBA IGkzODZfcmVjb3JkX3B1c2ggKHN0cnVjdCBpMzg2X3JlY29yZF9zICoKIAog aW50CiBpMzg2X3Byb2Nlc3NfcmVjb3JkIChzdHJ1Y3QgZ2RiYXJjaCAqZ2Ri YXJjaCwgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSwKLQkJICAgICBDT1JF X0FERFIgYWRkcikKKwkJICAgICBDT1JFX0FERFIgYWRkciwgZW51bSB0YXJn ZXRfc2lnbmFsIHNpZ25hbCkKIHsKICAgaW50IHByZWZpeGVzID0gMDsKICAg dWludDhfdCB0bXB1ODsKQEAgLTMyMzAsOCArMzIzMCwyMyBAQCBpMzg2X3By b2Nlc3NfcmVjb3JkIChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiCiAKICAgaWYgKHJl Y29yZF9kZWJ1ZyA+IDEpCiAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJf c3RkbG9nLCAiUHJvY2VzcyByZWNvcmQ6IGkzODZfcHJvY2Vzc19yZWNvcmQg IgotCQkJICAgICAgICAgICAgImFkZHIgPSAlc1xuIiwKLQkJCXBhZGRyZXNz IChnZGJhcmNoLCBpci5hZGRyKSk7CisJCQkgICAgICAgICAgICAiYWRkciA9 ICVzIHNpZ25hbCA9ICVzXG4iLAorCQkJcGFkZHJlc3MgKGdkYmFyY2gsIGly LmFkZHIpLAorICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0X3NpZ25h bF90b19uYW1lIChzaWduYWwpKTsKKworICBpZiAoZ2RiYXJjaF90ZGVwIChn ZGJhcmNoKS0+aTM4Nl9zaWduYWxfcmVjb3JkICE9IE5VTEwpCisgICAgewor ICAgICAgaW50IHJldDsKKworICAgICAgLyogSWYgdGhpcyBzaWduYWwgaXMg bm90IGJlIGhhbmRsZWQsIHJldHVybiAxMDAuICAqLworICAgICAgcmV0ID0g Z2RiYXJjaF90ZGVwIChnZGJhcmNoKS0+aTM4Nl9zaWduYWxfcmVjb3JkIChp ci5yZWdjYWNoZSwgc2lnbmFsKTsKKyAgICAgIGlmIChyZXQgPCAxMDApCisg ICAgICAgIHsKKyAgICAgICAgICBpZiAocmVjb3JkX2FyY2hfbGlzdF9hZGRf ZW5kICgpKQorICAgICAgICAgICAgcmV0dXJuIC0xOworICAgICAgICAgIHJl dHVybiByZXQ7CisgICAgICAgIH0KKyAgICB9CiAKICAgLyogcHJlZml4ZXMg Ki8KICAgd2hpbGUgKDEpCi0tLSBhL2kzODYtdGRlcC5oCisrKyBiL2kzODYt dGRlcC5oCkBAIC0xMTQsNiArMTE0LDkgQEAgc3RydWN0IGdkYmFyY2hfdGRl cAogICAvKiBUaGUgbWFwIGZvciByZWdpc3RlcnMgYmVjYXVzZSB0aGUgQU1E NjQncyByZWdpc3RlcnMgb3JkZXIKICAgICAgaW4gR0RCIGlzIG5vdCBzYW1l IGFzIEkzODYgaW5zdHJ1Y3Rpb25zLiAgKi8KICAgY29uc3QgaW50ICpyZWNv cmRfcmVnbWFwOworICAvKiBQYXJzZSBzaWduYWwgYXJncy4gICovCisgIGlu dCAoKmkzODZfc2lnbmFsX3JlY29yZCkgKHN0cnVjdCByZWdjYWNoZSAqcmVn Y2FjaGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudW0gdGFy Z2V0X3NpZ25hbCBzaWduYWwpOwogICAvKiBQYXJzZSBpbnR4ODAgYXJncy4g ICovCiAgIGludCAoKmkzODZfaW50eDgwX3JlY29yZCkgKHN0cnVjdCByZWdj YWNoZSAqcmVnY2FjaGUpOwogICAvKiBQYXJzZSBzeXNlbnRlciBhcmdzLiAg Ki8KQEAgLTI2MSw3ICsyNjQsOCBAQCBleHRlcm4gdm9pZCBpMzg2X2VsZl9p bml0X2FiaSAoc3RydWN0IGdkCiBleHRlcm4gdm9pZCBpMzg2X3N2cjRfaW5p dF9hYmkgKHN0cnVjdCBnZGJhcmNoX2luZm8sIHN0cnVjdCBnZGJhcmNoICop OwogCiBleHRlcm4gaW50IGkzODZfcHJvY2Vzc19yZWNvcmQgKHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLCBDT1JFX0FERFIgYWRk cik7CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBy ZWdjYWNoZSAqcmVnY2FjaGUsIENPUkVfQUREUiBhZGRyLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBlbnVtIHRhcmdldF9zaWduYWwgc2ln bmFsKTsKIAwKIAogLyogRnVuY3Rpb25zIGFuZCB2YXJpYWJsZXMgZXhwb3J0 ZWQgZnJvbSBpMzg2YnNkLXRkZXAuYy4gICovCi0tLSBhL21veGllLXRkZXAu YworKysgYi9tb3hpZS10ZGVwLmMKQEAgLTUwMSw3ICs1MDEsNyBAQCBtb3hp ZV9wcm9jZXNzX3JlYWR1IChDT1JFX0FERFIgYWRkciwgY2hhCiAKIGludAog bW94aWVfcHJvY2Vzc19yZWNvcmQgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNo LCBzdHJ1Y3QgcmVnY2FjaGUgKnJlZ2NhY2hlLAotCQkgICAgICBDT1JFX0FE RFIgYWRkcikKKwkJICAgICAgQ09SRV9BRERSIGFkZHIsIGVudW0gdGFyZ2V0 X3NpZ25hbCBzaWduYWwpCiB7CiAgIGdkYl9ieXRlIGJ1Zls0XTsKICAgdWlu dDE2X3QgaW5zdDsKQEAgLTUxMCw4ICs1MTAsOSBAQCBtb3hpZV9wcm9jZXNz X3JlY29yZCAoc3RydWN0IGdkYmFyY2ggKmdkCiAKICAgaWYgKHJlY29yZF9k ZWJ1ZyA+IDEpCiAgICAgZnByaW50Zl91bmZpbHRlcmVkIChnZGJfc3RkbG9n LCAiUHJvY2VzcyByZWNvcmQ6IG1veGllX3Byb2Nlc3NfcmVjb3JkICIKLQkJ CSAgICAgICAgICAgICJhZGRyID0gMHglc1xuIiwKLQkJCXBhZGRyZXNzICh0 YXJnZXRfZ2RiYXJjaCwgYWRkcikpOworCQkJICAgICAgICAgICAgImFkZHIg PSAweCVzIHNpZ25hbCA9ICVzXG4iLAorCQkJcGFkZHJlc3MgKHRhcmdldF9n ZGJhcmNoLCBhZGRyKSwKKwkJCXRhcmdldF9zaWduYWxfdG9fbmFtZSAoc2ln bmFsKSk7CiAKICAgaW5zdCA9ICh1aW50MTZfdCkgbW94aWVfcHJvY2Vzc19y ZWFkdSAoYWRkciwgYnVmLCAyLCBieXRlX29yZGVyKTsKIAotLS0gYS9yZWNv cmQuYworKysgYi9yZWNvcmQuYwpAQCAtOTIsNiArOTIsOCBAQCBzdGF0aWMg aW50IHJlY29yZF9zdG9wX2F0X2xpbWl0ID0gMTsKIHN0YXRpYyBpbnQgcmVj b3JkX2luc25fbWF4X251bSA9IERFRkFVTFRfUkVDT1JEX0lOU05fTUFYX05V TTsKIHN0YXRpYyBpbnQgcmVjb3JkX2luc25fbnVtID0gMDsKIAorc3RhdGlj IGVudW0gdGFyZ2V0X3NpZ25hbCByZWNvcmRfcmVzdW1lX3NpZ2duYWw7CisK IC8qIFRoZSB0YXJnZXRfb3BzIG9mIHByb2Nlc3MgcmVjb3JkLiAgKi8KIHN0 YXRpYyBzdHJ1Y3QgdGFyZ2V0X29wcyByZWNvcmRfb3BzOwogCkBAIC0zNzMs NyArMzc1LDggQEAgcmVjb3JkX21lc3NhZ2UgKHZvaWQgKmFyZ3MpCiAKICAg cmV0ID0gZ2RiYXJjaF9wcm9jZXNzX3JlY29yZCAoZ2V0X3JlZ2NhY2hlX2Fy Y2ggKHJlZ2NhY2hlKSwKIAkJCQlyZWdjYWNoZSwKLQkJCQlyZWdjYWNoZV9y ZWFkX3BjIChyZWdjYWNoZSkpOworCQkJCXJlZ2NhY2hlX3JlYWRfcGMgKHJl Z2NhY2hlKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVj b3JkX3Jlc3VtZV9zaWdnbmFsKTsKICAgaWYgKHJldCA+IDApCiAgICAgZXJy b3IgKF8oIlByb2Nlc3MgcmVjb3JkOiBpbmZlcmlvciBwcm9ncmFtIHN0b3Bw ZWQuIikpOwogICBpZiAocmV0IDwgMCkKQEAgLTUxNCw3ICs1MTcsNiBAQCBy ZWNvcmRfY2xvc2UgKGludCBxdWl0dGluZykKIH0KIAogc3RhdGljIGludCBy ZWNvcmRfcmVzdW1lX3N0ZXAgPSAwOwotc3RhdGljIGVudW0gdGFyZ2V0X3Np Z25hbCByZWNvcmRfcmVzdW1lX3NpZ2duYWw7CiBzdGF0aWMgaW50IHJlY29y ZF9yZXN1bWVfZXJyb3I7CiAKIHN0YXRpYyB2b2lkCkBAIC02MDYsNiArNjA4 LDggQEAgcmVjb3JkX3dhaXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMsCiAJ ICBwdGlkX3QgcmV0OwogCSAgQ09SRV9BRERSIHRtcF9wYzsKIAorICAgICAg ICAgIHJlY29yZF9yZXN1bWVfc2lnZ25hbCA9IFRBUkdFVF9TSUdOQUxfMDsK KwogCSAgd2hpbGUgKDEpCiAJICAgIHsKIAkgICAgICByZXQgPSByZWNvcmRf YmVuZWF0aF90b193YWl0IChyZWNvcmRfYmVuZWF0aF90b193YWl0X29wcywK QEAgLTYzOCw3ICs2NDIsNyBAQCByZWNvcmRfd2FpdCAoc3RydWN0IHRhcmdl dF9vcHMgKm9wcywKIAkJCX0KIAkJICAgICAgcmVjb3JkX2JlbmVhdGhfdG9f cmVzdW1lIChyZWNvcmRfYmVuZWF0aF90b19yZXN1bWVfb3BzLAogCQkJCQkJ cHRpZCwgMSwKLQkJCQkJCXJlY29yZF9yZXN1bWVfc2lnZ25hbCk7CisJCQkJ CQlUQVJHRVRfU0lHTkFMXzApOwogCQkgICAgICBjb250aW51ZTsKIAkJICAg IH0KIAkJfQo= --001636b2bc021b81e7047221514b--