From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 20006 invoked by alias); 22 May 2013 10:22:57 -0000 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 Received: (qmail 19980 invoked by uid 89); 22 May 2013 10:22:52 -0000 X-Spam-SWARE-Status: No, score=-3.0 required=5.0 tests=AWL,BAYES_00,FREEMAIL_FROM,KHOP_THREADED,RCVD_IN_DNSWL_LOW,RCVD_IN_HOSTKARMA_YE,SPF_PASS,TW_XP autolearn=ham version=3.3.1 Received: from mail-oa0-f51.google.com (HELO mail-oa0-f51.google.com) (209.85.219.51) by sourceware.org (qpsmtpd/0.84/v0.84-167-ge50287c) with ESMTP; Wed, 22 May 2013 10:22:36 +0000 Received: by mail-oa0-f51.google.com with SMTP id f4so2265107oah.38 for ; Wed, 22 May 2013 03:22:35 -0700 (PDT) X-Received: by 10.182.112.133 with SMTP id iq5mr4113673obb.75.1369218155262; Wed, 22 May 2013 03:22:35 -0700 (PDT) MIME-Version: 1.0 Received: by 10.60.38.193 with HTTP; Wed, 22 May 2013 03:21:55 -0700 (PDT) In-Reply-To: <51969A92.80003@redhat.com> References: <1361192891-29341-1-git-send-email-yao@codesourcery.com> <8738wpd3qe.fsf@fleche.redhat.com> <5176C14B.6010603@redhat.com> <51774714.9060306@codesourcery.com> <51969A92.80003@redhat.com> From: Hui Zhu Date: Wed, 22 May 2013 10:22:00 -0000 Message-ID: Subject: Re: [RFC] PR 15075 dprintf interferes with "next" To: Pedro Alves Cc: gdb-patches@sourceware.org, Keith Seitz , Tom Tromey , Yao Qi Content-Type: multipart/mixed; boundary=089e0149cfe0c3b8fa04dd4bf10c X-Virus-Found: No X-SW-Source: 2013-05/txt/msg00820.txt.bz2 --089e0149cfe0c3b8fa04dd4bf10c Content-Type: text/plain; charset=ISO-8859-1 Content-length: 17421 Hi Pedro, Thanks for your review. On Sat, May 18, 2013 at 5:01 AM, Pedro Alves wrote: > On 05/16/2013 08:28 AM, Hui Zhu wrote: >> Hi, >> >> Because this patch also can handle bug 15434, I updated the test >> patches to add test dprintf with non-stop mode. > > Looks like the test is racy. :-/ I got: > > At foo entry > arg=1235, g=2222 > iAt foo entry > ntarg=1236, g=3013 > errupt > (gdb) FAIL: gdb.base/dprintf.exp: interrupt > > This will need to be sorted out. > > I also saw: > > (gdb) At foo entry > arg=1235, g=2222 > At foo entry > arg=1236, g=3013 > [Inferior 1 (process 30651) exited with code 0152] > FAIL: gdb.base/dprintf.exp: shell echo foo (timeout) > interrupt > ../../src/gdb/thread.c:694: internal-error: set_stop_requested: Assertion `tp' failed. > A problem internal to GDB has been detected, > further debugging may prove unreliable. > Quit this debugging session? (y or n) FAIL: gdb.base/dprintf.exp: interrupt (GDB internal error) > Resyncing due to internal error. > n > ../../src/gdb/thread.c:694: internal-error: set_stop_requested: Assertion `tp' failed. > A problem internal to GDB has been detected, > further debugging may prove unreliable. > Create a core file of GDB? (y or n) n > (gdb) FAIL: gdb.base/dprintf.exp: process stopped (timeout) > testcase ../../../src/gdb/testsuite/gdb.base/dprintf.exp completed in 20 seconds > > :-( Though that's likely unrelated. I updated this part and put it to dpintf-non-stop.exp. I tried it on fedora and looks it works OK most of times. I only got trouble is when run this test with remote, [runto main] with "non-stop" is open will fail sometime. > > >> 2013-05-16 Yao Qi >> Hui Zhu >> >> PR breakpoints/15075 >> PR breakpoints/15434 >> * breakpoint.c (bpstat_stop_status): Call b->ops->after_cond. >> (update_dprintf_command_list): Don't append "continue" command >> to the command of dprintf breakpoint. > > "to the command list." Fixed. > >> (base_breakpoint_after_cond): New. >> (base_breakpoint_ops): Add base_breakpoint_after_cond. >> (dprintf_after_cond): New. > > Say "New function." Fixed. > >> (initialize_breakpoint_ops): Set dprintf_after_cond. >> * breakpoint.h (breakpoint_ops): Add after_cond. >> >> 2013-05-16 Yao Qi >> Hui Zhu >> >> PR breakpoints/15075 >> PR breakpoints/15434 >> * gdb.base/dprintf.exp: Don't check "continue" in the output >> of "info breakpoints". >> Add test dprintf with non-stop mode. > > Add test for dprintf in non-stop mode. > >> * gdb.base/dprintf.c: Add a sleep for test dprintf with non-stop > > for testing. Fixed. > >> mode. >> * gdb.mi/mi-breakpoint-changed.exp (test_insert_delete_modify): >> Don't check "continue" in script field. >> * gdb.base/pr15075.c: New. >> * gdb.base/pr15075.exp: New. >> > > > >> >> >> --- a/gdb/breakpoint.c >> +++ b/gdb/breakpoint.c >> @@ -5283,13 +5283,7 @@ bpstat_stop_status (struct address_space >> b->enable_state = bp_disabled; >> removed_any = 1; >> } >> - if (b->silent) >> - bs->print = 0; >> - bs->commands = b->commands; >> - incref_counted_command_line (bs->commands); >> - if (command_line_is_silent (bs->commands >> - ? bs->commands->commands : NULL)) >> - bs->print = 0; >> + b->ops->after_cond (bs); >> } >> >> } >> @@ -8939,25 +8933,16 @@ update_dprintf_command_list (struct brea >> _("Invalid dprintf style.")); >> >> gdb_assert (printf_line != NULL); >> - /* Manufacture a printf/continue sequence. */ >> + /* Manufacture a printf sequence. */ >> { >> - struct command_line *printf_cmd_line, *cont_cmd_line = NULL; >> - >> - if (strcmp (dprintf_style, dprintf_style_agent) != 0) >> - { >> - cont_cmd_line = xmalloc (sizeof (struct command_line)); >> - cont_cmd_line->control_type = simple_control; >> - cont_cmd_line->body_count = 0; >> - cont_cmd_line->body_list = NULL; >> - cont_cmd_line->next = NULL; >> - cont_cmd_line->line = xstrdup ("continue"); >> - } >> + struct command_line *printf_cmd_line >> + = xmalloc (sizeof (struct command_line)); >> >> printf_cmd_line = xmalloc (sizeof (struct command_line)); >> printf_cmd_line->control_type = simple_control; >> printf_cmd_line->body_count = 0; >> printf_cmd_line->body_list = NULL; >> - printf_cmd_line->next = cont_cmd_line; >> + printf_cmd_line->next = NULL; >> printf_cmd_line->line = printf_line; >> >> breakpoint_set_commands (b, printf_cmd_line); >> @@ -12743,6 +12728,22 @@ base_breakpoint_explains_signal (struct >> return BPSTAT_SIGNAL_HIDE; >> } >> > > > >> +/* The default 'after_cond' method. */ > > You used '' here. Fixed. > >> + >> +static void >> +base_breakpoint_after_cond (struct bpstats *bs) >> +{ >> + struct breakpoint *b = bs->breakpoint_at; >> + >> + if (b->silent) >> + bs->print = 0; >> + bs->commands = b->commands; >> + incref_counted_command_line (bs->commands); >> + if (command_line_is_silent (bs->commands >> + ? bs->commands->commands : NULL)) >> + bs->print = 0; > > Indentation is wrong here. > > I think we can keep all these where it was. Fixed. > >> +} >> + > > >> +/* Implement the "after_cond" breakpoint_ops method for dprintf. */ > > You used "" here. :-) Spurious double space before breakpoint_ops. Fixed. :) > >> + >> +static void >> +dprintf_after_cond (struct bpstats *bs) >> +{ >> + bpstat tmp; >> + struct breakpoint *b = bs->breakpoint_at; >> + >> + bs->stop = 0; >> + bs->print = 0; > > If we make dprintf's silent (b->silent = 0), then bs->print will > end up 0 for them too, given the: > > if (b->silent) > bs->print = 0; > > bit. > > Not sure even that is necessary, given bs->stop==0 and: > > /* Print nothing for this entry if we don't stop or don't > print. */ > if (!bs->stop || !bs->print) > bs->print_it = print_it_noop; I am not sure about this part. If my understanding about Tom's review in before is right, the action of dprintf command should be handled when GDB check the condition. And after that, dprintf not need be handled. So dprintf_after_cond just clear the bs->stop and bs->print because dprintf not need be handled after this function. And call command of this dprintf because the its condition is true. I added some comments for that. > >> + bs->commands = b->commands; >> + tmp = bs->next; >> + bs->next = tmp; > > A = B; > B = A; > > ? > > Was this supposed to be: > > A = B; > B = NULL; > > ? I think this "bs->next = tmp;" is duplicate line after bpstat_do_actions_1. Fixed. > >> + incref_counted_command_line (bs->commands); > > If copying all this code here really is necessary, then keep the > incref close to the commands copy, like in the original code. Fixed. > >> + bpstat_do_actions_1 (&bs); >> + bs->next = tmp; >> +} > > Could you add some comments explaining what this is > doing, and why? I update this function to following part: /* Implement the "after_cond" breakpoint_ops method for dprintf. */ static void dprintf_after_cond (struct bpstats *bs) { struct cleanup *old_chain; struct breakpoint *b = bs->breakpoint_at; bs->commands = b->commands; incref_counted_command_line (bs->commands); /* Because function bpstat_do_actions_1 will execute all the command list of BS and follow it by BS->NEXT, temporarily set BS->NEXT to NULL. */ old_chain = make_cleanup_restore_ptr ((void **)&bs->next); bs->next = NULL; bpstat_do_actions_1 (&bs); do_cleanups (old_chain); /* This dprintf need not be handled after this function because its command list is executed by bpstat_do_actions_1. Clear STOP and PRINT for that. */ bs->stop = 0; bs->print = 0; } > >> + >> /* The breakpoint_ops structure to be used on static tracepoints with >> markers (`-m'). */ >> >> @@ -15852,6 +15872,7 @@ initialize_breakpoint_ops (void) >> ops->print_it = bkpt_print_it; >> ops->print_mention = bkpt_print_mention; >> ops->print_recreate = dprintf_print_recreate; >> + ops->after_cond = dprintf_after_cond; >> } >> >> /* Chain containing all defined "enable breakpoint" subcommands. */ >> --- a/gdb/breakpoint.h >> +++ b/gdb/breakpoint.h >> @@ -614,6 +614,9 @@ struct breakpoint_ops >> 'catch signal' interact properly with 'handle'; see >> bpstat_explains_signal. */ >> enum bpstat_signal_value (*explains_signal) (struct breakpoint *); >> + >> + /* Do some setup after check condition is true. */ > > /* Called after evaluating the breakpoint's condition, > and only if it evaluated true. */ Fixed. > >> + void (*after_cond) (struct bpstats *bs); > > I'd rather spell out "cond". I suggest: > > void (*after_condition_true) (...); > > To be a bit more self descriptive. > Fixed. >> }; >> >> /* Helper for breakpoint_ops->print_recreate implementations. Prints >> >> >> dprintf-continue-test.txt >> >> >> --- a/gdb/testsuite/gdb.base/dprintf.c >> +++ b/gdb/testsuite/gdb.base/dprintf.c >> @@ -39,6 +39,9 @@ main (int argc, char *argv[]) >> foo (loc++); >> foo (loc++); >> foo (loc++); >> + >> + sleep (3); >> + >> return g; >> } >> >> --- a/gdb/testsuite/gdb.base/dprintf.exp >> +++ b/gdb/testsuite/gdb.base/dprintf.exp >> @@ -50,10 +50,8 @@ gdb_test_sequence "info breakpoints" "dp >> "\[\r\n\]2 breakpoint" >> "\[\r\n\]3 dprintf" >> "\[\r\n\] printf \"At foo entry\\\\n\"" >> - "\[\r\n\] continue" >> "\[\r\n\]4 dprintf" >> "\[\r\n\] printf \"arg=%d, g=%d\\\\n\", arg, g" >> - "\[\r\n\] continue" >> } >> >> gdb_test "break $bp_location1" \ >> @@ -136,3 +134,41 @@ if $target_can_dprintf { >> gdb_test "set dprintf-style foobar" "Undefined item: \"foobar\"." \ >> "Set dprintf style to an unrecognized type" >> >> + >> +# Test dprintf with non-stop mode. >> +# The testfile uses "run". The real bug happened only for ![is_remote target]. > > It doesn't need to use "run", AFAICS. You can run to > main as usual, and then use "c&" to get the same effect, > and then the test should pass with GDBserver too. > > There are targets that don't support non-stop, > and, the call/gdb dprintf styles works on all targets. > The test should be gracefully skipped on those targets. > It might be better to split this to a separate test file. Add dprintf-non-stop.exp and dprintf-non-stop.c for it. > >> +if [target_info exists use_gdb_stub] { >> + unsupported "dprintf with non-stop mode" >> + return 0 >> +} >> +gdb_test_no_output "delete 2 5" >> +send_gdb "kill\n" >> +gdb_expect 120 { >> + -re "Kill the program being debugged. .y or n. $" { >> + send_gdb "y\n" >> + verbose "\t\tKilling previous program being debugged" >> + exp_continue >> + } >> + -re "$gdb_prompt $" { >> + # OK. >> + } >> +} > > Why do this manually? This part was removed. > >> +gdb_test_no_output "set dprintf-style gdb" "Set dprintf style to gdb" >> +gdb_test_no_output "set target-async on" >> +gdb_test_no_output "set non-stop on" >> +set gdbindex_warning_re "warning: Skipping \[^\r\n\]+ \\.gdb_index section \[^\r\n\]*\r\nDo \"set use-deprecated-index-sections on\" before the file is read\r\nto use the section anyway\\." > > I don't under why do we need to explicitly check for this warning? Removed too. > >> +gdb_test "run &" "Starting program: \[^\r\n\]*(\r\n$gdbindex_warning_re)?" >> +gdb_test "shell echo foo" "foo" > > What's this shell echo for? This part copy from other test of non-stop. It let test wait some time then dprintf execution can complete. Now I changed it to exec sleep 1. > >> +set test "interrupt" >> +gdb_test_multiple $test $test { >> + -re "interrupt\r\n$gdb_prompt " { >> + pass $test >> + } >> +} >> +set test "process stopped" >> +gdb_test_multiple "" $test { >> + -re "\r\n\\\[process \[0-9\]+\\\] #1 stopped\\\.\r\n" { >> + pass $test >> + } >> +} >> --- /dev/null >> +++ b/gdb/testsuite/gdb.base/pr15075.c > > We prefer that test files are named for something that suggests what they > contain, rather than bug numbers. Please call it something > like dprintf-next.exp. Fixed. > >> @@ -0,0 +1,26 @@ >> +/* This testcase is part of GDB, the GNU debugger. >> + >> + Copyright (C) 2013 Free Software Foundation, Inc. >> + >> + This program is free software; you can redistribute it and/or modify >> + it under the terms of the GNU General Public License as published by >> + the Free Software Foundation; either version 3 of the License, or >> + (at your option) any later version. >> + >> + This program is distributed in the hope that it will be useful, >> + but WITHOUT ANY WARRANTY; without even the implied warranty of >> + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> + GNU General Public License for more details. >> + >> + You should have received a copy of the GNU General Public License >> + along with this program. If not, see . */ >> + >> +int >> +main(void) > > Missing space. Fixed. > >> + { >> + int x = 5; > > Wrong indentation. Fixed. > >> + >> + ++x; >> + ++x; /* set dprintf here */ >> + return x - 7; >> + } >> --- /dev/null >> +++ b/gdb/testsuite/gdb.base/pr15075.exp >> @@ -0,0 +1,38 @@ >> +# Copyright 2013 Free Software Foundation, Inc. >> +# This program is free software; you can redistribute it and/or modify >> +# it under the terms of the GNU General Public License as published by >> +# the Free Software Foundation; either version 3 of the License, or >> +# (at your option) any later version. >> +# >> +# This program is distributed in the hope that it will be useful, >> +# but WITHOUT ANY WARRANTY; without even the implied warranty of >> +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the >> +# GNU General Public License for more details. >> +# >> +# You should have received a copy of the GNU General Public License >> +# along with this program. If not, see . >> + >> +standard_testfile >> + >> +set executable $testfile >> +set expfile $testfile.exp >> + >> +set dp_location [gdb_get_line_number "set dprintf here"] >> + >> +if [prepare_for_testing $expfile $executable $srcfile {debug}] { >> + untested "failed to prepare for trace tests" > > This is not a trace test. Actually, prepare_for_testing > already calls untested with whatever we pass it as first argument. > I think it'd be the first such call in the testsuite, but I > think this would be better: > > if [prepare_for_testing "failed to prepare for trace tests" \ > $executable $srcfile {debug}] { > return -1 > } After I use this part of code, I got: ERROR: tcl error sourcing ../../../src/gdb/testsuite/gdb.base/dprintf-next.exp. ERROR: wrong # args: should be "prepare_for_testing testname executable ?sources? ?options?" while executing "prepare_for_testing "failed to prepare for dprintf next tests"" invoked from within "if [prepare_for_testing "failed to prepare for dprintf next tests" $executable $srcfile {debug}] { return -1 }" So I change this part to: if { [prepare_for_testing dprintf-next.exp "dprintf-next" {} {debug}] } { return -1 } > >> + >> +if ![runto_main] { >> + fail "Can't run to main" >> + return -1 >> +} >> + >> +gdb_test "dprintf $dp_location, \"%d\\n\", x" \ >> + "Dprintf .*" >> + >> +gdb_test "next" ".*" "next 1" >> +gdb_test "next" ".*" "next 2" > > Please use more string regexes for these, that confirm the next stopped > at the right lines. Fixed. > >> +# Test inferior doesn't exit. > > Check that the inferior didn't exit. > >> +gdb_test "p x" ".* = 6" > > With the stricter regexes, I don't think this test would be > necessary though. Removed. Post new patches according to your comments. Best, Hui 2013-05-22 Yao Qi Hui Zhu PR breakpoints/15075 PR breakpoints/15434 * utils.c (restore_ptr_closure): New struct. (restore_ptr, make_cleanup_restore_ptr): New functions. * utils.h (make_cleanup_restore_ptr): New extern. * breakpoint.c (bpstat_stop_status): Call b->ops->after_condition_true. (update_dprintf_command_list): Don't append "continue" command to the command list of dprintf breakpoint. (base_breakpoint_after_condition_true): New function. (base_breakpoint_ops): Add base_breakpoint_after_condition_true. (dprintf_after_condition_true): New function. (initialize_breakpoint_ops): Set dprintf_after_condition_true. * breakpoint.h (breakpoint_ops): Add after_condition_true. 2013-05-22 Yao Qi Hui Zhu PR breakpoints/15075 PR breakpoints/15434 * gdb.base/dprintf-next.c: New file. * gdb.base/dprintf-next.exp: New file. * gdb.base/dprintf-non-stop.c: New file. * gdb.base/dprintf-non-stop.exp: New file. * gdb.base/dprintf.exp: Don't check "continue" in the output of "info breakpoints". * gdb.mi/mi-breakpoint-changed.exp (test_insert_delete_modify): Don't check "continue" in script field. --089e0149cfe0c3b8fa04dd4bf10c Content-Type: text/plain; charset=US-ASCII; name="clean_ptr.txt" Content-Disposition: attachment; filename="clean_ptr.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hh0clqp00 Content-length: 1652 LS0tIGEvZ2RiL3V0aWxzLmMKKysrIGIvZ2RiL3V0aWxzLmMKQEAgLTM4NSw2 ICszODUsMzUgQEAgbWFrZV9jbGVhbnVwX3Jlc3RvcmVfdWludGVnZXIgKHVu c2lnbmVkCiAgIHJldHVybiBtYWtlX2NsZWFudXBfcmVzdG9yZV9pbnRlZ2Vy ICgoaW50ICopIHZhcmlhYmxlKTsKIH0KIAorc3RydWN0IHJlc3RvcmVfcHRy X2Nsb3N1cmUKK3sKKyAgdm9pZCAqKnZhcmlhYmxlOworICB2b2lkICp2YWx1 ZTsKK307CisKK3N0YXRpYyB2b2lkCityZXN0b3JlX3B0ciAodm9pZCAqcCkK K3sKKyAgc3RydWN0IHJlc3RvcmVfcHRyX2Nsb3N1cmUgKmNsb3N1cmUgPSBw OworCisgICooY2xvc3VyZS0+dmFyaWFibGUpID0gY2xvc3VyZS0+dmFsdWU7 Cit9CisKKy8qIFJlbWVtYmVyIHRoZSBjdXJyZW50IHZhbHVlIG9mICpWQVJJ QUJMRSBhbmQgbWFrZSBpdCByZXN0b3JlZCB3aGVuCisgICB0aGUgY2xlYW51 cCBpcyBydW4uICAqLworCitzdHJ1Y3QgY2xlYW51cCAqCittYWtlX2NsZWFu dXBfcmVzdG9yZV9wdHIgKHZvaWQgKip2YXJpYWJsZSkKK3sKKyAgc3RydWN0 IHJlc3RvcmVfcHRyX2Nsb3N1cmUgKmMgPQorICAgIHhtYWxsb2MgKHNpemVv ZiAoc3RydWN0IHJlc3RvcmVfcHRyX2Nsb3N1cmUpKTsKKworICBjLT52YXJp YWJsZSA9IHZhcmlhYmxlOworICBjLT52YWx1ZSA9ICp2YXJpYWJsZTsKKwor ICByZXR1cm4gbWFrZV9jbGVhbnVwX2R0b3IgKHJlc3RvcmVfcHRyLCAodm9p ZCAqKSBjLCB4ZnJlZSk7Cit9CisKIC8qIEhlbHBlciBmb3IgbWFrZV9jbGVh bnVwX3VucHVzaF90YXJnZXQuICAqLwogCiBzdGF0aWMgdm9pZAotLS0gYS9n ZGIvdXRpbHMuaAorKysgYi9nZGIvdXRpbHMuaApAQCAtOTcsNiArOTcsNyBA QCBleHRlcm4gc3RydWN0IGNsZWFudXAgKm1ha2VfY2xlYW51cF9vYnN0CiAK IGV4dGVybiBzdHJ1Y3QgY2xlYW51cCAqbWFrZV9jbGVhbnVwX3Jlc3RvcmVf aW50ZWdlciAoaW50ICp2YXJpYWJsZSk7CiBleHRlcm4gc3RydWN0IGNsZWFu dXAgKm1ha2VfY2xlYW51cF9yZXN0b3JlX3VpbnRlZ2VyICh1bnNpZ25lZCBp bnQgKnZhcmlhYmxlKTsKK2V4dGVybiBzdHJ1Y3QgY2xlYW51cCAqbWFrZV9j bGVhbnVwX3Jlc3RvcmVfcHRyICh2b2lkICoqdmFyaWFibGUpOwogCiBzdHJ1 Y3QgdGFyZ2V0X29wczsKIGV4dGVybiBzdHJ1Y3QgY2xlYW51cCAqbWFrZV9j bGVhbnVwX3VucHVzaF90YXJnZXQgKHN0cnVjdCB0YXJnZXRfb3BzICpvcHMp Owo= --089e0149cfe0c3b8fa04dd4bf10c Content-Type: text/plain; charset=US-ASCII; name="dprintf-continue.txt" Content-Disposition: attachment; filename="dprintf-continue.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hh0cm6f11 Content-length: 5848 LS0tIGEvZ2RiL2JyZWFrcG9pbnQuYworKysgYi9nZGIvYnJlYWtwb2ludC5j CkBAIC01MjgzLDEzICs1MjgzLDcgQEAgYnBzdGF0X3N0b3Bfc3RhdHVzIChz dHJ1Y3QgYWRkcmVzc19zcGFjZQogCQkgICAgYi0+ZW5hYmxlX3N0YXRlID0g YnBfZGlzYWJsZWQ7CiAJCSAgcmVtb3ZlZF9hbnkgPSAxOwogCQl9Ci0JICAg ICAgaWYgKGItPnNpbGVudCkKLQkJYnMtPnByaW50ID0gMDsKLQkgICAgICBi cy0+Y29tbWFuZHMgPSBiLT5jb21tYW5kczsKLQkgICAgICBpbmNyZWZfY291 bnRlZF9jb21tYW5kX2xpbmUgKGJzLT5jb21tYW5kcyk7Ci0JICAgICAgaWYg KGNvbW1hbmRfbGluZV9pc19zaWxlbnQgKGJzLT5jb21tYW5kcwotCQkJCQkg ID8gYnMtPmNvbW1hbmRzLT5jb21tYW5kcyA6IE5VTEwpKQotCQlicy0+cHJp bnQgPSAwOworCSAgICAgIGItPm9wcy0+YWZ0ZXJfY29uZGl0aW9uX3RydWUg KGJzKTsKIAkgICAgfQogCiAJfQpAQCAtODkzOSwyNSArODkzMywxNiBAQCB1 cGRhdGVfZHByaW50Zl9jb21tYW5kX2xpc3QgKHN0cnVjdCBicmVhCiAJCSAg ICBfKCJJbnZhbGlkIGRwcmludGYgc3R5bGUuIikpOwogCiAgIGdkYl9hc3Nl cnQgKHByaW50Zl9saW5lICE9IE5VTEwpOwotICAvKiBNYW51ZmFjdHVyZSBh IHByaW50Zi9jb250aW51ZSBzZXF1ZW5jZS4gICovCisgIC8qIE1hbnVmYWN0 dXJlIGEgcHJpbnRmIHNlcXVlbmNlLiAgKi8KICAgewotICAgIHN0cnVjdCBj b21tYW5kX2xpbmUgKnByaW50Zl9jbWRfbGluZSwgKmNvbnRfY21kX2xpbmUg PSBOVUxMOwotCi0gICAgaWYgKHN0cmNtcCAoZHByaW50Zl9zdHlsZSwgZHBy aW50Zl9zdHlsZV9hZ2VudCkgIT0gMCkKLSAgICAgIHsKLQljb250X2NtZF9s aW5lID0geG1hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgY29tbWFuZF9saW5lKSk7 Ci0JY29udF9jbWRfbGluZS0+Y29udHJvbF90eXBlID0gc2ltcGxlX2NvbnRy b2w7Ci0JY29udF9jbWRfbGluZS0+Ym9keV9jb3VudCA9IDA7Ci0JY29udF9j bWRfbGluZS0+Ym9keV9saXN0ID0gTlVMTDsKLQljb250X2NtZF9saW5lLT5u ZXh0ID0gTlVMTDsKLQljb250X2NtZF9saW5lLT5saW5lID0geHN0cmR1cCAo ImNvbnRpbnVlIik7Ci0gICAgICB9CisgICAgc3RydWN0IGNvbW1hbmRfbGlu ZSAqcHJpbnRmX2NtZF9saW5lCisgICAgICA9IHhtYWxsb2MgKHNpemVvZiAo c3RydWN0IGNvbW1hbmRfbGluZSkpOwogCiAgICAgcHJpbnRmX2NtZF9saW5l ID0geG1hbGxvYyAoc2l6ZW9mIChzdHJ1Y3QgY29tbWFuZF9saW5lKSk7CiAg ICAgcHJpbnRmX2NtZF9saW5lLT5jb250cm9sX3R5cGUgPSBzaW1wbGVfY29u dHJvbDsKICAgICBwcmludGZfY21kX2xpbmUtPmJvZHlfY291bnQgPSAwOwog ICAgIHByaW50Zl9jbWRfbGluZS0+Ym9keV9saXN0ID0gTlVMTDsKLSAgICBw cmludGZfY21kX2xpbmUtPm5leHQgPSBjb250X2NtZF9saW5lOworICAgIHBy aW50Zl9jbWRfbGluZS0+bmV4dCA9IE5VTEw7CiAgICAgcHJpbnRmX2NtZF9s aW5lLT5saW5lID0gcHJpbnRmX2xpbmU7CiAKICAgICBicmVha3BvaW50X3Nl dF9jb21tYW5kcyAoYiwgcHJpbnRmX2NtZF9saW5lKTsKQEAgLTEyNzQzLDYg KzEyNzI4LDIyIEBAIGJhc2VfYnJlYWtwb2ludF9leHBsYWluc19zaWduYWwg KHN0cnVjdAogICByZXR1cm4gQlBTVEFUX1NJR05BTF9ISURFOwogfQogCisv KiBUaGUgZGVmYXVsdCAiYWZ0ZXJfY29uZGl0aW9uX3RydWUiIG1ldGhvZC4g ICovCisKK3N0YXRpYyB2b2lkCitiYXNlX2JyZWFrcG9pbnRfYWZ0ZXJfY29u ZGl0aW9uX3RydWUgKHN0cnVjdCBicHN0YXRzICpicykKK3sKKyAgc3RydWN0 IGJyZWFrcG9pbnQgKmIgPSBicy0+YnJlYWtwb2ludF9hdDsKKworICBpZiAo Yi0+c2lsZW50KQorICAgIGJzLT5wcmludCA9IDA7CisgIGJzLT5jb21tYW5k cyA9IGItPmNvbW1hbmRzOworICBpbmNyZWZfY291bnRlZF9jb21tYW5kX2xp bmUgKGJzLT5jb21tYW5kcyk7CisgIGlmIChjb21tYW5kX2xpbmVfaXNfc2ls ZW50IChicy0+Y29tbWFuZHMKKwkJCSAgICAgID8gYnMtPmNvbW1hbmRzLT5j b21tYW5kcyA6IE5VTEwpKQorICAgIGJzLT5wcmludCA9IDA7Cit9CisKIHN0 cnVjdCBicmVha3BvaW50X29wcyBiYXNlX2JyZWFrcG9pbnRfb3BzID0KIHsK ICAgYmFzZV9icmVha3BvaW50X2R0b3IsCkBAIC0xMjc2Miw3ICsxMjc2Myw4 IEBAIHN0cnVjdCBicmVha3BvaW50X29wcyBiYXNlX2JyZWFrcG9pbnRfb3AK ICAgYmFzZV9icmVha3BvaW50X2NyZWF0ZV9zYWxzX2Zyb21fYWRkcmVzcywK ICAgYmFzZV9icmVha3BvaW50X2NyZWF0ZV9icmVha3BvaW50c19zYWwsCiAg IGJhc2VfYnJlYWtwb2ludF9kZWNvZGVfbGluZXNwZWMsCi0gIGJhc2VfYnJl YWtwb2ludF9leHBsYWluc19zaWduYWwKKyAgYmFzZV9icmVha3BvaW50X2V4 cGxhaW5zX3NpZ25hbCwKKyAgYmFzZV9icmVha3BvaW50X2FmdGVyX2NvbmRp dGlvbl90cnVlLAogfTsKIAogLyogRGVmYXVsdCBicmVha3BvaW50X29wcyBt ZXRob2RzLiAgKi8KQEAgLTEzMzU2LDYgKzEzMzU4LDMzIEBAIGRwcmludGZf cHJpbnRfcmVjcmVhdGUgKHN0cnVjdCBicmVha3BvaW4KICAgcHJpbnRfcmVj cmVhdGVfdGhyZWFkICh0cCwgZnApOwogfQogCisvKiBJbXBsZW1lbnQgdGhl ICJhZnRlcl9jb25kaXRpb25fdHJ1ZSIgYnJlYWtwb2ludF9vcHMgbWV0aG9k IGZvcgorICAgZHByaW50Zi4gICovCisKK3N0YXRpYyB2b2lkCitkcHJpbnRm X2FmdGVyX2NvbmRpdGlvbl90cnVlIChzdHJ1Y3QgYnBzdGF0cyAqYnMpCit7 CisgIHN0cnVjdCBjbGVhbnVwICpvbGRfY2hhaW47CisgIHN0cnVjdCBicmVh a3BvaW50ICpiID0gYnMtPmJyZWFrcG9pbnRfYXQ7CisKKyAgYnMtPmNvbW1h bmRzID0gYi0+Y29tbWFuZHM7CisgIGluY3JlZl9jb3VudGVkX2NvbW1hbmRf bGluZSAoYnMtPmNvbW1hbmRzKTsKKworICAvKiBCZWNhdXNlIGZ1bmN0aW9u IGJwc3RhdF9kb19hY3Rpb25zXzEgd2lsbCBleGVjdXRlIGFsbCB0aGUgY29t bWFuZAorICAgICBsaXN0IG9mIEJTIGFuZCBmb2xsb3cgaXQgYnkgQlMtPk5F WFQsIHRlbXBvcmFyaWx5IHNldCBCUy0+TkVYVCB0bworICAgICBOVUxMLiAg Ki8KKyAgb2xkX2NoYWluID0gbWFrZV9jbGVhbnVwX3Jlc3RvcmVfcHRyICgo dm9pZCAqKikmYnMtPm5leHQpOworICBicy0+bmV4dCA9IE5VTEw7CisgIGJw c3RhdF9kb19hY3Rpb25zXzEgKCZicyk7CisgIGRvX2NsZWFudXBzIChvbGRf Y2hhaW4pOworCisgIC8qIFRoaXMgZHByaW50ZiBuZWVkIG5vdCBiZSBoYW5k bGVkIGFmdGVyIHRoaXMgZnVuY3Rpb24KKyAgICAgYmVjYXVzZSBpdHMgY29t bWFuZCBsaXN0IGlzIGV4ZWN1dGVkIGJ5IGJwc3RhdF9kb19hY3Rpb25zXzEu CisgICAgIENsZWFyIFNUT1AgYW5kIFBSSU5UIGZvciB0aGF0LiAgKi8KKyAg YnMtPnN0b3AgPSAwOworICBicy0+cHJpbnQgPSAwOworfQorCiAvKiBUaGUg YnJlYWtwb2ludF9vcHMgc3RydWN0dXJlIHRvIGJlIHVzZWQgb24gc3RhdGlj IHRyYWNlcG9pbnRzIHdpdGgKICAgIG1hcmtlcnMgKGAtbScpLiAgKi8KIApA QCAtMTU4NTIsNiArMTU4ODEsNyBAQCBpbml0aWFsaXplX2JyZWFrcG9pbnRf b3BzICh2b2lkKQogICBvcHMtPnByaW50X2l0ID0gYmtwdF9wcmludF9pdDsK ICAgb3BzLT5wcmludF9tZW50aW9uID0gYmtwdF9wcmludF9tZW50aW9uOwog ICBvcHMtPnByaW50X3JlY3JlYXRlID0gZHByaW50Zl9wcmludF9yZWNyZWF0 ZTsKKyAgb3BzLT5hZnRlcl9jb25kaXRpb25fdHJ1ZSA9IGRwcmludGZfYWZ0 ZXJfY29uZGl0aW9uX3RydWU7CiB9CiAKIC8qIENoYWluIGNvbnRhaW5pbmcg YWxsIGRlZmluZWQgImVuYWJsZSBicmVha3BvaW50IiBzdWJjb21tYW5kcy4g ICovCi0tLSBhL2dkYi9icmVha3BvaW50LmgKKysrIGIvZ2RiL2JyZWFrcG9p bnQuaApAQCAtNjE0LDYgKzYxNCwxMCBAQCBzdHJ1Y3QgYnJlYWtwb2ludF9v cHMKICAgICAgJ2NhdGNoIHNpZ25hbCcgaW50ZXJhY3QgcHJvcGVybHkgd2l0 aCAnaGFuZGxlJzsgc2VlCiAgICAgIGJwc3RhdF9leHBsYWluc19zaWduYWwu ICAqLwogICBlbnVtIGJwc3RhdF9zaWduYWxfdmFsdWUgKCpleHBsYWluc19z aWduYWwpIChzdHJ1Y3QgYnJlYWtwb2ludCAqKTsKKworICAvKiBDYWxsZWQg YWZ0ZXIgZXZhbHVhdGluZyB0aGUgYnJlYWtwb2ludCdzIGNvbmRpdGlvbiwK KyAgICAgYW5kIG9ubHkgaWYgaXQgZXZhbHVhdGVkIHRydWUuICAqLworICB2 b2lkICgqYWZ0ZXJfY29uZGl0aW9uX3RydWUpIChzdHJ1Y3QgYnBzdGF0cyAq YnMpOwogfTsKIAogLyogSGVscGVyIGZvciBicmVha3BvaW50X29wcy0+cHJp bnRfcmVjcmVhdGUgaW1wbGVtZW50YXRpb25zLiAgUHJpbnRzCg== --089e0149cfe0c3b8fa04dd4bf10c Content-Type: text/plain; charset=US-ASCII; name="dprintf-continue-test.txt" Content-Disposition: attachment; filename="dprintf-continue-test.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_hh0cmgux2 Content-length: 7841 LS0tIC9kZXYvbnVsbAorKysgYi9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL2Rw cmludGYtbmV4dC5jCkBAIC0wLDAgKzEsMjYgQEAKKy8qIFRoaXMgdGVzdGNh c2UgaXMgcGFydCBvZiBHREIsIHRoZSBHTlUgZGVidWdnZXIuCisKKyAgIENv cHlyaWdodCAoQykgMjAxMyBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIElu Yy4KKworICAgVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBj YW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKKyAgIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug YXMgcHVibGlzaGVkIGJ5CisgICB0aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0 aW9uOyBlaXRoZXIgdmVyc2lvbiAzIG9mIHRoZSBMaWNlbnNlLCBvcgorICAg KGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0ZXIgdmVyc2lvbi4KKworICAgVGhp cyBwcm9ncmFtIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQg d2lsbCBiZSB1c2VmdWwsCisgICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7 IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICAgTUVS Q0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQ T1NFLiAgU2VlIHRoZQorICAgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2Ug Zm9yIG1vcmUgZGV0YWlscy4KKworICAgWW91IHNob3VsZCBoYXZlIHJlY2Vp dmVkIGEgY29weSBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UK KyAgIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0 dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LiAgKi8KKworaW50CittYWlu ICh2b2lkKQoreworICBpbnQgeCA9IDU7CisKKyAgKyt4OworICArK3g7IC8q IHNldCBkcHJpbnRmIGhlcmUgKi8KKyAgcmV0dXJuIHggLSA3OworfQotLS0g L2Rldi9udWxsCisrKyBiL2dkYi90ZXN0c3VpdGUvZ2RiLmJhc2UvZHByaW50 Zi1uZXh0LmV4cApAQCAtMCwwICsxLDM1IEBACisjIENvcHlyaWdodCAyMDEz IEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLgorIyBUaGlzIHByb2dy YW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yIG1vZGlmeQorIyBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorIyB0 aGUgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uOyBlaXRoZXIgdmVyc2lvbiAz IG9mIHRoZSBMaWNlbnNlLCBvcgorIyAoYXQgeW91ciBvcHRpb24pIGFueSBs YXRlciB2ZXJzaW9uLgorIworIyBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0 ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyMgYnV0 IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxp ZWQgd2FycmFudHkgb2YKKyMgTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQorIyBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorIworIyBZ b3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2Vu ZXJhbCBQdWJsaWMgTGljZW5zZQorIyBhbG9uZyB3aXRoIHRoaXMgcHJvZ3Jh bS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMv Pi4KKworc3RhbmRhcmRfdGVzdGZpbGUKKworc2V0IGV4ZWN1dGFibGUgJHRl c3RmaWxlCitzZXQgZXhwZmlsZSAkdGVzdGZpbGUuZXhwCisKK3NldCBkcF9s b2NhdGlvbiBbZ2RiX2dldF9saW5lX251bWJlciAic2V0IGRwcmludGYgaGVy ZSJdCisKK2lmIHsgW3ByZXBhcmVfZm9yX3Rlc3RpbmcgZHByaW50Zi1uZXh0 LmV4cCAiZHByaW50Zi1uZXh0IiB7fSB7ZGVidWd9XSB9IHsKKyAgICByZXR1 cm4gLTEKK30KKworaWYgIVtydW50b19tYWluXSB7CisgICAgZmFpbCAiQ2Fu J3QgcnVuIHRvIG1haW4iCisgICAgcmV0dXJuIC0xCit9CisKK2dkYl90ZXN0 ICJkcHJpbnRmICRkcF9sb2NhdGlvbiwgXCIlZFxcblwiLCB4IiBcCisgICAg IkRwcmludGYgLioiCisKK2dkYl90ZXN0ICJuZXh0IiAiMjMuKlxcK1xcK3gu KiIgIm5leHQgMSIKK2dkYl90ZXN0ICJuZXh0IiAiMjQuKlxcK1xcK3guKiIg Im5leHQgMiIKLS0tIC9kZXYvbnVsbAorKysgYi9nZGIvdGVzdHN1aXRlL2dk Yi5iYXNlL2RwcmludGYtbm9uLXN0b3AuYwpAQCAtMCwwICsxLDMwIEBACisv KiBUaGlzIHRlc3RjYXNlIGlzIHBhcnQgb2YgR0RCLCB0aGUgR05VIGRlYnVn Z2VyLgorCisgICBDb3B5cmlnaHQgKEMpIDIwMTMgRnJlZSBTb2Z0d2FyZSBG b3VuZGF0aW9uLCBJbmMuCisgICBDb250cmlidXRlZCBieSBIdWkgWmh1ICA8 aHVpQGNvZGVzb3VyY2VyeS5jb20+CisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBm cmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3Ig bW9kaWZ5CisgICBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxpc2hlZCBieQorICAgdGhlIEZy ZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZlcnNpb24gMyBvZiB0 aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVy IHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBp biB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAorICAgYnV0IFdJ VEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQg d2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAgIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisKKyAgIFlv dSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5l cmFsIFB1YmxpYyBMaWNlbnNlCisgICBhbG9uZyB3aXRoIHRoaXMgcHJvZ3Jh bS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMv Pi4gICovCisKK3ZvaWQKK2ZvbyAoKQoreworfQorCitpbnQKK21haW4gKCkK K3sKKyAgZm9vICgpOworICB3aGlsZSAoMSk7CisgIHJldHVybiAwOworfQpc IE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKLS0tIC9kZXYvbnVsbAorKysg Yi9nZGIvdGVzdHN1aXRlL2dkYi5iYXNlL2RwcmludGYtbm9uLXN0b3AuZXhw CkBAIC0wLDAgKzEsNDUgQEAKKyMgICBDb3B5cmlnaHQgKEMpIDIwMTMgRnJl ZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisjICAgQ29udHJpYnV0ZWQg YnkgSHVpIFpodSAgPGh1aUBjb2Rlc291cmNlcnkuY29tPgorCisjIFRoaXMg cHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0 ZSBpdCBhbmQvb3IgbW9kaWZ5CisjIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0 aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5 CisjIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJz aW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCisjIChhdCB5b3VyIG9wdGlvbikg YW55IGxhdGVyIHZlcnNpb24uCisjCisjIFRoaXMgcHJvZ3JhbSBpcyBkaXN0 cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLAor IyBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUg aW1wbGllZCB3YXJyYW50eSBvZgorIyBNRVJDSEFOVEFCSUxJVFkgb3IgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlCisjIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCisj CisjIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdO VSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisjIGFsb25nIHdpdGggdGhpcyBw cm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNl bnNlcy8+LgorCitpZiB7IFtwcmVwYXJlX2Zvcl90ZXN0aW5nIGRwcmludGYt bm9uLXN0b3AuZXhwICJkcHJpbnRmLW5vbi1zdG9wIiB7fSB7ZGVidWd9XSB9 IHsKKyAgICByZXR1cm4gLTEKK30KKworZ2RiX3Rlc3Rfbm9fb3V0cHV0ICJz ZXQgdGFyZ2V0LWFzeW5jIG9uIgorZ2RiX3Rlc3Rfbm9fb3V0cHV0ICJzZXQg bm9uLXN0b3Agb24iCisKK2lmICFbcnVudG8gbWFpbl0geworICAgIGZhaWwg IkNhbid0IHJ1biB0byBtYWluIgorICAgIHJldHVybiAtMQorfQorCitnZGJf dGVzdCAiZHByaW50ZiBmb28sXCJBdCBmb28gZW50cnlcXG5cIiIgIkRwcmlu dGYgLioiCisKK3NlbmRfZ2RiICJjb250aW51ZSAmXG4iCitleGVjIHNsZWVw IDEKK3NldCB0ZXN0ICJpbnRlcnJ1cHQiCitnZGJfdGVzdF9tdWx0aXBsZSAk dGVzdCAkdGVzdCB7CisgICAgLXJlICJpbnRlcnJ1cHRcclxuJGdkYl9wcm9t cHQgIiB7CisJcGFzcyAkdGVzdAorICAgIH0KK30KKworc2V0IHRlc3QgImlu ZmVyaW9yIHN0b3BwZWQiCitnZGJfdGVzdF9tdWx0aXBsZSAiIiAkdGVzdCB7 CisgICAgLXJlICJcclxuXFxcWy4qIFxbMC05XF0rXFxcXSAjMSBzdG9wcGVk XFxcLlxyXG4iIHsKKwlwYXNzICR0ZXN0CisgICAgfQorfQotLS0gYS9nZGIv dGVzdHN1aXRlL2dkYi5iYXNlL2RwcmludGYuZXhwCisrKyBiL2dkYi90ZXN0 c3VpdGUvZ2RiLmJhc2UvZHByaW50Zi5leHAKQEAgLTUwLDEwICs1MCw4IEBA IGdkYl90ZXN0X3NlcXVlbmNlICJpbmZvIGJyZWFrcG9pbnRzIiAiZHAKICAg ICAiXFtcclxuXF0yICAgICAgIGJyZWFrcG9pbnQiCiAgICAgIlxbXHJcblxd MyAgICAgICBkcHJpbnRmIgogICAgICJcW1xyXG5cXSAgICAgICAgcHJpbnRm IFwiQXQgZm9vIGVudHJ5XFxcXG5cIiIKLSAgICAiXFtcclxuXF0gICAgICAg IGNvbnRpbnVlIgogICAgICJcW1xyXG5cXTQgICAgICAgZHByaW50ZiIKICAg ICAiXFtcclxuXF0gICAgICAgIHByaW50ZiBcImFyZz0lZCwgZz0lZFxcXFxu XCIsIGFyZywgZyIKLSAgICAiXFtcclxuXF0gICAgICAgIGNvbnRpbnVlIgog fQogCiBnZGJfdGVzdCAiYnJlYWsgJGJwX2xvY2F0aW9uMSIgXApAQCAtMTM1 LDQgKzEzMywzIEBAIGlmICR0YXJnZXRfY2FuX2RwcmludGYgewogCiBnZGJf dGVzdCAic2V0IGRwcmludGYtc3R5bGUgZm9vYmFyIiAiVW5kZWZpbmVkIGl0 ZW06IFwiZm9vYmFyXCIuIiBcCiAgICAgIlNldCBkcHJpbnRmIHN0eWxlIHRv IGFuIHVucmVjb2duaXplZCB0eXBlIgotCi0tLSBhL2dkYi90ZXN0c3VpdGUv Z2RiLm1pL21pLWJyZWFrcG9pbnQtY2hhbmdlZC5leHAKKysrIGIvZ2RiL3Rl c3RzdWl0ZS9nZGIubWkvbWktYnJlYWtwb2ludC1jaGFuZ2VkLmV4cApAQCAt OTYsNyArOTYsNyBAQCBwcm9jIHRlc3RfaW5zZXJ0X2RlbGV0ZV9tb2RpZnkg eyB9IHsKIAkkdGVzdAogICAgIHNldCB0ZXN0ICJkcHJpbnRmIG1hcmtlciwg XCJhcmdcIiBcIiIKICAgICBtaV9nZGJfdGVzdCAkdGVzdCBcCi0Jey4qPWJy ZWFrcG9pbnQtY3JlYXRlZCxia3B0PVx7bnVtYmVyPSI2Iix0eXBlPSJkcHJp bnRmIi4qLHNjcmlwdD1ce1wicHJpbnRmIFxcXFxcImFyZ1xcXFxcIiBcXFxc XCJcIixcImNvbnRpbnVlXCJcfS4qXH1cclxuXF5kb25lfSBcCisJey4qPWJy ZWFrcG9pbnQtY3JlYXRlZCxia3B0PVx7bnVtYmVyPSI2Iix0eXBlPSJkcHJp bnRmIi4qLHNjcmlwdD1ce1wicHJpbnRmIFxcXFxcImFyZ1xcXFxcIiBcXFxc XCJcIlx9LipcfVxyXG5cXmRvbmV9IFwKIAkkdGVzdAogCiAgICAgIyAyLiB3 aGVuIG1vZGlmeWluZyBjb25kaXRpb24K --089e0149cfe0c3b8fa04dd4bf10c--