From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 3421 invoked by alias); 24 Feb 2009 01:32:54 -0000 Received: (qmail 3408 invoked by uid 22791); 24 Feb 2009 01:32:52 -0000 X-SWARE-Spam-Status: No, hits=-1.9 required=5.0 tests=AWL,BAYES_00,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from smtp-out.google.com (HELO smtp-out.google.com) (216.239.45.13) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 24 Feb 2009 01:32:45 +0000 Received: from spaceape14.eur.corp.google.com (spaceape14.eur.corp.google.com [172.28.16.148]) by smtp-out.google.com with ESMTP id n1O1Wf6S006975 for ; Mon, 23 Feb 2009 17:32:42 -0800 Received: from rv-out-0708.google.com (rvfb17.prod.google.com [10.140.179.17]) by spaceape14.eur.corp.google.com with ESMTP id n1O1WdZm005883 for ; Mon, 23 Feb 2009 17:32:39 -0800 Received: by rv-out-0708.google.com with SMTP id b17so2018332rvf.44 for ; Mon, 23 Feb 2009 17:32:38 -0800 (PST) MIME-Version: 1.0 Received: by 10.140.136.5 with SMTP id j5mr2294380rvd.39.1235439158526; Mon, 23 Feb 2009 17:32:38 -0800 (PST) In-Reply-To: <200812171914.mBHJE61T002958@d12av02.megacenter.de.ibm.com> References: <200812171914.mBHJE61T002958@d12av02.megacenter.de.ibm.com> Date: Tue, 24 Feb 2009 10:42:00 -0000 Message-ID: Subject: Re: [RFA] Fix hand called function when another thread has hit a bp. From: Doug Evans To: Ulrich Weigand , gdb-patches Content-Type: multipart/mixed; boundary=000e0cd2900e2f82970463a018d1 X-System-Of-Record: true 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-02/txt/msg00453.txt.bz2 --000e0cd2900e2f82970463a018d1 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 3185 On Wed, Dec 17, 2008 at 11:14 AM, Ulrich Weigand wrote: > Doug Evans wrote: > >> > The problem arises when scheduler locking is switched on. Actually, >> > I think there are really two problems. First of all, after we've >> > switched back and single-stepped over an already-hit breakpoint via >> > the prepare_to_proceed logic, we'll continue only a single thread >> > if scheduler-locking is on -- and that is the wrong thread. The >> > prepare_to_proceed logic only explicitly switches *back* to the >> > user-selected thread if the user was *stepping* (that's the >> > deferred_step_ptid logic). For scheduler-locking, we should probably >> > switch back always ... >> >> If scheduler locking is on, why is there any switching at all? If >> scheduler-locking is on and I switch threads I'd want gdb to defer >> single-stepping the other thread over its breakpoint until the point >> when I make that other thread runnable. >> >> Also, I think removing the notion of one previously stopped thread and >> generalizing it to not caring, i.e. checking the status of every >> stopped thread before resuming will simplify things and fix a few bugs >> along the way. IOW, make deferred_ptid go away. > > That may indeed be the best solution. The simplest implementation > might be to simply remember in a per-thread flag the fact that the > last time this thread stopped, we reported a breakpoint at stop_pc > (which would have to be made per-thread as well, but we'd already > decided this should happen anyway). > > This information could then be consulted the next time the thread > is made runnable again. > >> > The second problem is more a problem of definition: even if the >> > first problem above were fixed, we've have to single-step the other >> > thread at least once to get over the breakpoint. This would seem >> > to violate the definition of scheduler locking if interpreted >> > absolutely strictly. Now you could argue that as the user should >> > never be aware of that single step, it doesn't really matter. >> >> I'm not sure how we necessarily have a violation of the definition of >> scheduler locking. > > This is just saying the same you said in other words: "If scheduler- > locking is on and I switch threads I'd want gdb to defer single- > stepping the other thread over its breakpoint until the point when > I make that other thread runnable." > > I.e. "definition of scheduler locking" meaning: no other thread but > the one selected by the user runs, ever. Today, this is not true, > in the case of single-stepping over a breakpoint in another thread. Hi. Here's an updated version of the patch. Handling the restart after several threads are all stopped at a breakpoint (via scheduler-locking = on), is left for a later patch (it's happens more rarely). Ok to check in? 2009-02-23 Doug Evans * infrun.c (prepare_to_proceed): Document. Assert !non_stop. If scheduler-locking is enabled, we're not going to be singlestepping any other previously stopped thread. * gdb.threads/hand-call-in-threads.exp: New file. * gdb.threads/hand-call-in-threads.c: New file. --000e0cd2900e2f82970463a018d1 Content-Type: text/plain; charset=US-ASCII; name="gdb-090223-schedlock-4.patch.txt" Content-Disposition: attachment; filename="gdb-090223-schedlock-4.patch.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_frjwhn3n0 Content-length: 14535 MjAwOS0wMi0yMyAgRG91ZyBFdmFucyAgPGRqZUBnb29nbGUuY29tPgoKCSog aW5mcnVuLmMgKHByZXBhcmVfdG9fcHJvY2VlZCk6IERvY3VtZW50LiAgQXNz ZXJ0ICFub25fc3RvcC4KCUlmIHNjaGVkdWxlci1sb2NraW5nIGlzIGVuYWJs ZWQsIHdlJ3JlIG5vdCBnb2luZyB0byBiZSBzaW5nbGVzdGVwcGluZwoJYW55 IG90aGVyIHByZXZpb3VzbHkgc3RvcHBlZCB0aHJlYWQuCgoJKiBnZGIudGhy ZWFkcy9oYW5kLWNhbGwtaW4tdGhyZWFkcy5leHA6IE5ldyBmaWxlLgoJKiBn ZGIudGhyZWFkcy9oYW5kLWNhbGwtaW4tdGhyZWFkcy5jOiBOZXcgZmlsZS4K CkluZGV4OiBpbmZydW4uYwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09ClJDUyBm aWxlOiAvY3ZzL3NyYy9zcmMvZ2RiL2luZnJ1bi5jLHYKcmV0cmlldmluZyBy ZXZpc2lvbiAxLjM1OQpkaWZmIC11IC1wIC11IC1wIC1yMS4zNTkgaW5mcnVu LmMKLS0tIGluZnJ1bi5jCTIxIEZlYiAyMDA5IDE2OjE0OjQ4IC0wMDAwCTEu MzU5CisrKyBpbmZydW4uYwkyNCBGZWIgMjAwOSAwMDozNzowMyAtMDAwMApA QCAtMTIzOSwxMyArMTIzOSwyMSBAQCBjbGVhcl9wcm9jZWVkX3N0YXR1cyAo dm9pZCkKICAgICB9CiB9CiAKLS8qIFRoaXMgc2hvdWxkIGJlIHN1aXRhYmxl IGZvciBhbnkgdGFyZ2V0cyB0aGF0IHN1cHBvcnQgdGhyZWFkcy4gKi8KKy8q IENoZWNrIHRoZSBjdXJyZW50IHRocmVhZCBhZ2FpbnN0IHRoZSB0aHJlYWQg dGhhdCByZXBvcnRlZCB0aGUgbW9zdCByZWNlbnQKKyAgIGV2ZW50LiAgSWYg YSBzdGVwLW92ZXIgaXMgcmVxdWlyZWQgcmV0dXJuIFRSVUUgYW5kIHNldCB0 aGUgY3VycmVudCB0aHJlYWQKKyAgIHRvIHRoZSBvbGQgdGhyZWFkLiAgT3Ro ZXJ3aXNlIHJldHVybiBGQUxTRS4KKworICAgVGhpcyBzaG91bGQgYmUgc3Vp dGFibGUgZm9yIGFueSB0YXJnZXRzIHRoYXQgc3VwcG9ydCB0aHJlYWRzLiAq LwogCiBzdGF0aWMgaW50CiBwcmVwYXJlX3RvX3Byb2NlZWQgKGludCBzdGVw KQogewogICBwdGlkX3Qgd2FpdF9wdGlkOwogICBzdHJ1Y3QgdGFyZ2V0X3dh aXRzdGF0dXMgd2FpdF9zdGF0dXM7CisgIGludCBzY2hlZGxvY2tfZW5hYmxl ZDsKKworICAvKiBXaXRoIG5vbi1zdG9wIG1vZGUgb24sIHRocmVhZHMgYXJl IGFsd2F5cyBoYW5kbGVkIGluZGl2aWR1YWxseS4gICovCisgIGdkYl9hc3Nl cnQgKCEgbm9uX3N0b3ApOwogCiAgIC8qIEdldCB0aGUgbGFzdCB0YXJnZXQg c3RhdHVzIHJldHVybmVkIGJ5IHRhcmdldF93YWl0KCkuICAqLwogICBnZXRf bGFzdF90YXJnZXRfc3RhdHVzICgmd2FpdF9wdGlkLCAmd2FpdF9zdGF0dXMp OwpAQCAtMTI1Nyw5ICsxMjY1LDE1IEBAIHByZXBhcmVfdG9fcHJvY2VlZCAo aW50IHN0ZXApCiAgICAgICByZXR1cm4gMDsKICAgICB9CiAKKyAgc2NoZWRs b2NrX2VuYWJsZWQgPSAoc2NoZWR1bGVyX21vZGUgPT0gc2NoZWRsb2NrX29u CisJCSAgICAgICB8fCAoc2NoZWR1bGVyX21vZGUgPT0gc2NoZWRsb2NrX3N0 ZXAKKwkJCSAgICYmIHN0ZXApKTsKKwogICAvKiBTd2l0Y2hlZCBvdmVyIGZy b20gV0FJVF9QSUQuICAqLwogICBpZiAoIXB0aWRfZXF1YWwgKHdhaXRfcHRp ZCwgbWludXNfb25lX3B0aWQpCi0gICAgICAmJiAhcHRpZF9lcXVhbCAoaW5m ZXJpb3JfcHRpZCwgd2FpdF9wdGlkKSkKKyAgICAgICYmICFwdGlkX2VxdWFs IChpbmZlcmlvcl9wdGlkLCB3YWl0X3B0aWQpCisgICAgICAvKiBEb24ndCBz aW5nbGUgc3RlcCBXQUlUX1BJRCBpZiBzY2hlZHVsZXIgbG9ja2luZyBpcyBv bi4gICovCisgICAgICAmJiAhc2NoZWRsb2NrX2VuYWJsZWQpCiAgICAgewog ICAgICAgc3RydWN0IHJlZ2NhY2hlICpyZWdjYWNoZSA9IGdldF90aHJlYWRf cmVnY2FjaGUgKHdhaXRfcHRpZCk7CiAKSW5kZXg6IHRlc3RzdWl0ZS9nZGIu dGhyZWFkcy9oYW5kLWNhbGwtaW4tdGhyZWFkcy5jCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT0KUkNTIGZpbGU6IHRlc3RzdWl0ZS9nZGIudGhyZWFkcy9oYW5k LWNhbGwtaW4tdGhyZWFkcy5jCmRpZmYgLU4gdGVzdHN1aXRlL2dkYi50aHJl YWRzL2hhbmQtY2FsbC1pbi10aHJlYWRzLmMKLS0tIC9kZXYvbnVsbAkxIEph biAxOTcwIDAwOjAwOjAwIC0wMDAwCisrKyB0ZXN0c3VpdGUvZ2RiLnRocmVh ZHMvaGFuZC1jYWxsLWluLXRocmVhZHMuYwkyNCBGZWIgMjAwOSAwMDozNzow NCAtMDAwMApAQCAtMCwwICsxLDEyNyBAQAorLyogVGVzdCBjYXNlIGZvciBo YW5kIGZ1bmN0aW9uIGNhbGxzIGluIG11bHRpLXRocmVhZGVkIHByb2dyYW0u CisKKyAgIENvcHlyaWdodCAyMDA4IEZyZWUgU29mdHdhcmUgRm91bmRhdGlv biwgSW5jLgorCisgICBUaGlzIGZpbGUgaXMgcGFydCBvZiBHREIuCisKKyAg IFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5CisgICBpdCB1bmRlciB0aGUgdGVy bXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGFzIHB1Ymxp c2hlZCBieQorICAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0 aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyAgIChhdCB5b3Vy IG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCisKKyAgIFRoaXMgcHJvZ3Jh bSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUg dXNlZnVsLAorICAgYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0 IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKKyAgIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNl ZSB0aGUKKyAgIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3Jl IGRldGFpbHMuCisKKyAgIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNv cHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlCisgICBhbG9u ZyB3aXRoIHRoaXMgcHJvZ3JhbS4gIElmIG5vdCwgc2VlIDxodHRwOi8vd3d3 LmdudS5vcmcvbGljZW5zZXMvPi4gICovCisKKyNpbmNsdWRlIDxwdGhyZWFk Lmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4K KyNpbmNsdWRlIDx0aW1lLmg+CisjaW5jbHVkZSA8dW5pc3RkLmg+CisKKyNp Zm5kZWYgTlJfVEhSRUFEUworI2RlZmluZSBOUl9USFJFQURTIDQKKyNlbmRp ZgorCitpbnQgdGhyZWFkX2NvdW50OworCitwdGhyZWFkX211dGV4X3QgdGhy ZWFkX2NvdW50X211dGV4OworCitwdGhyZWFkX2NvbmRfdCB0aHJlYWRfY291 bnRfY29uZHZhcjsKKwordm9pZAoraW5jcl90aHJlYWRfY291bnQgKHZvaWQp Cit7CisgIHB0aHJlYWRfbXV0ZXhfbG9jayAoJnRocmVhZF9jb3VudF9tdXRl eCk7CisgICsrdGhyZWFkX2NvdW50OworICBpZiAodGhyZWFkX2NvdW50ID09 IE5SX1RIUkVBRFMpCisgICAgcHRocmVhZF9jb25kX3NpZ25hbCAoJnRocmVh ZF9jb3VudF9jb25kdmFyKTsKKyAgcHRocmVhZF9tdXRleF91bmxvY2sgKCZ0 aHJlYWRfY291bnRfbXV0ZXgpOworfQorCit2b2lkCitjb25kX3dhaXQgKHB0 aHJlYWRfY29uZF90ICpjb25kLCBwdGhyZWFkX211dGV4X3QgKm11dCkKK3sK KyAgcHRocmVhZF9tdXRleF9sb2NrIChtdXQpOworICBwdGhyZWFkX2NvbmRf d2FpdCAoY29uZCwgbXV0KTsKKyAgcHRocmVhZF9tdXRleF91bmxvY2sgKG11 dCk7Cit9CisKK3ZvaWQKK25vcmV0dXJuICh2b2lkKQoreworICBwdGhyZWFk X211dGV4X3QgbXV0OworICBwdGhyZWFkX2NvbmRfdCBjb25kOworCisgIHB0 aHJlYWRfbXV0ZXhfaW5pdCAoJm11dCwgTlVMTCk7CisgIHB0aHJlYWRfY29u ZF9pbml0ICgmY29uZCwgTlVMTCk7CisKKyAgLyogV2FpdCBmb3IgYSBjb25k aXRpb24gdGhhdCB3aWxsIG5ldmVyIGJlIHNpZ25hbGVkLCBzbyB3ZSBlZmZl Y3RpdmVseQorICAgICBibG9jayB0aGUgdGhyZWFkIGhlcmUuICAqLworICBj b25kX3dhaXQgKCZjb25kLCAmbXV0KTsKK30KKwordm9pZCAqCitmb3JldmVy X3B0aHJlYWQgKHZvaWQgKnVudXNlZCkKK3sKKyAgaW5jcl90aHJlYWRfY291 bnQgKCk7CisgIG5vcmV0dXJuICgpOworfQorCit2b2lkCitoYW5kX2NhbGwg KHZvaWQpCit7Cit9CisKKy8qIFdhaXQgdW50aWwgYWxsIHRocmVhZHMgYXJl IHJ1bm5pbmcuICAqLworCit2b2lkCit3YWl0X2FsbF90aHJlYWRzX3J1bm5p bmcgKHZvaWQpCit7CisgIHB0aHJlYWRfbXV0ZXhfbG9jayAoJnRocmVhZF9j b3VudF9tdXRleCk7CisgIGlmICh0aHJlYWRfY291bnQgPT0gTlJfVEhSRUFE UykKKyAgICB7CisgICAgICBwdGhyZWFkX211dGV4X3VubG9jayAoJnRocmVh ZF9jb3VudF9tdXRleCk7CisgICAgICByZXR1cm47CisgICAgfQorICBwdGhy ZWFkX2NvbmRfd2FpdCAoJnRocmVhZF9jb3VudF9jb25kdmFyLCAmdGhyZWFk X2NvdW50X211dGV4KTsKKyAgaWYgKHRocmVhZF9jb3VudCA9PSBOUl9USFJF QURTKQorICAgIHsKKyAgICAgIHB0aHJlYWRfbXV0ZXhfdW5sb2NrICgmdGhy ZWFkX2NvdW50X211dGV4KTsKKyAgICAgIHJldHVybjsKKyAgICB9CisgIHB0 aHJlYWRfbXV0ZXhfdW5sb2NrICgmdGhyZWFkX2NvdW50X211dGV4KTsKKyAg cHJpbnRmICgiZmFpbGVkIHdhaXRpbmcgZm9yIGFsbCB0aHJlYWRzIHRvIHN0 YXJ0XG4iKTsKKyAgYWJvcnQgKCk7Cit9CisKKy8qIENhbGxlZCB3aGVuIGFs bCB0aHJlYWRzIGFyZSBydW5uaW5nLgorICAgRWFzeSBwbGFjZSBmb3IgYSBi cmVha3BvaW50LiAgKi8KKwordm9pZAorYWxsX3RocmVhZHNfcnVubmluZyAo dm9pZCkKK3sKK30KKworaW50CittYWluICh2b2lkKQoreworICBwdGhyZWFk X3QgZm9yZXZlcltOUl9USFJFQURTXTsKKyAgaW50IGk7CisKKyAgcHRocmVh ZF9tdXRleF9pbml0ICgmdGhyZWFkX2NvdW50X211dGV4LCBOVUxMKTsKKyAg cHRocmVhZF9jb25kX2luaXQgKCZ0aHJlYWRfY291bnRfY29uZHZhciwgTlVM TCk7CisKKyAgZm9yIChpID0gMDsgaSA8IE5SX1RIUkVBRFM7ICsraSkKKyAg ICBwdGhyZWFkX2NyZWF0ZSAoJmZvcmV2ZXJbaV0sIE5VTEwsIGZvcmV2ZXJf cHRocmVhZCwgTlVMTCk7CisKKyAgd2FpdF9hbGxfdGhyZWFkc19ydW5uaW5n ICgpOworICBhbGxfdGhyZWFkc19ydW5uaW5nICgpOworCisgIHJldHVybiAw OworfQorCkluZGV4OiB0ZXN0c3VpdGUvZ2RiLnRocmVhZHMvaGFuZC1jYWxs LWluLXRocmVhZHMuZXhwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZp bGU6IHRlc3RzdWl0ZS9nZGIudGhyZWFkcy9oYW5kLWNhbGwtaW4tdGhyZWFk cy5leHAKZGlmZiAtTiB0ZXN0c3VpdGUvZ2RiLnRocmVhZHMvaGFuZC1jYWxs LWluLXRocmVhZHMuZXhwCi0tLSAvZGV2L251bGwJMSBKYW4gMTk3MCAwMDow MDowMCAtMDAwMAorKysgdGVzdHN1aXRlL2dkYi50aHJlYWRzL2hhbmQtY2Fs bC1pbi10aHJlYWRzLmV4cAkyNCBGZWIgMjAwOSAwMDozNzowNCAtMDAwMApA QCAtMCwwICsxLDE2MCBAQAorIyBDb3B5cmlnaHQgKEMpIDIwMDQsIDIwMDcs IDIwMDggRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uLCBJbmMuCisKKyMgVGhp cyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmli dXRlIGl0IGFuZC9vciBtb2RpZnkKKyMgaXQgdW5kZXIgdGhlIHRlcm1zIG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhcyBwdWJsaXNoZWQg YnkKKyMgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyIHZl cnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKyMgKGF0IHlvdXIgb3B0aW9u KSBhbnkgbGF0ZXIgdmVyc2lvbi4KKyMKKyMgVGhpcyBwcm9ncmFtIGlzIGRp c3RyaWJ1dGVkIGluIHRoZSBob3BlIHRoYXQgaXQgd2lsbCBiZSB1c2VmdWws CisjIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRo ZSBpbXBsaWVkIHdhcnJhbnR5IG9mCisjIE1FUkNIQU5UQUJJTElUWSBvciBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyMg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4K KyMKKyMgWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUg R05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UKKyMgYWxvbmcgd2l0aCB0aGlz IHByb2dyYW0uICBJZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xp Y2Vuc2VzLz4uCisKKyMgVGVzdCBtYWtpbmcgaGFuZCBmdW5jdGlvbiBjYWxs cyBpbiBtdWx0aXBsZSB0aHJlYWRzLgorCitzZXQgTlJfVEhSRUFEUyA0CisK K2lmICR0cmFjZWxldmVsIHRoZW4geworCXN0cmFjZSAkdHJhY2VsZXZlbAor fQorCitzZXQgdGVzdGZpbGUgImhhbmQtY2FsbC1pbi10aHJlYWRzIgorc2V0 IHNyY2ZpbGUgJHt0ZXN0ZmlsZX0uYworc2V0IGJpbmZpbGUgJHtvYmpkaXJ9 LyR7c3ViZGlyfS8ke3Rlc3RmaWxlfQorCitpZiB7W2dkYl9jb21waWxlX3B0 aHJlYWRzICIke3NyY2Rpcn0vJHtzdWJkaXJ9LyR7c3JjZmlsZX0iICIke2Jp bmZpbGV9IiBleGVjdXRhYmxlIFtsaXN0IGRlYnVnICJpbmNkaXI9JHtvYmpk aXJ9IiAiYWRkaXRpb25hbF9mbGFncz0tRE5SX1RIUkVBRFM9JE5SX1RIUkVB RFMiXV0gIT0gIiIgfSB7CisgICAgcmV0dXJuIC0xCit9CisKKyMgU29tZSB0 YXJnZXRzIGNhbid0IGRvIGZ1bmN0aW9uIGNhbGxzLCBzbyBkb24ndCBldmVu IGJvdGhlciB3aXRoIHRoaXMKKyMgdGVzdC4KK2lmIFt0YXJnZXRfaW5mbyBl eGlzdHMgZ2RiLGNhbm5vdF9jYWxsX2Z1bmN0aW9uc10geworICAgIHNldHVw X3hmYWlsICIqLSotKiIgMjQxNgorICAgIGZhaWwgIlRoaXMgdGFyZ2V0IGNh biBub3QgY2FsbCBmdW5jdGlvbnMiCisgICAgY29udGludWUKK30KKworcHJv YyBnZXRfZHVtbXlfZnJhbWVfbnVtYmVyIHsgfSB7CisgIGdsb2JhbCBnZGJf cHJvbXB0CisKKyAgc2VuZF9nZGIgImJ0XG4iCisgIGdkYl9leHBlY3Qgewor ICAgIC1yZSAiIyhcWzAtOVxdKikgKjxmdW5jdGlvbiBjYWxsZWQgZnJvbSBn ZGI+LiokZ2RiX3Byb21wdCAkIgorICAgICAgeworCXJldHVybiAkZXhwZWN0 X291dCgxLHN0cmluZykKKyAgICAgIH0KKyAgICAtcmUgIiRnZGJfcHJvbXB0 ICQiCisgICAgICB7CisJcmV0dXJuICIiCisgICAgICB9CisgICAgdGltZW91 dAorICAgICAgeworCXJldHVybiAiIgorICAgICAgfQorICB9CisgIHJldHVy biAiIgorfQorCitnZGJfZXhpdAorZ2RiX3N0YXJ0CitnZGJfcmVpbml0aWFs aXplX2RpciAkc3JjZGlyLyRzdWJkaXIKK2dkYl9sb2FkICR7YmluZmlsZX0K KworaWYgeyAhW3J1bnRvX21haW5dIH0geworICAgIGZhaWwgIkNhbid0IHJ1 biB0byBtYWluIgorICAgIHJldHVybiAwCit9CisKK2dkYl90ZXN0ICJicmVh ayBhbGxfdGhyZWFkc19ydW5uaW5nIiBcCisgICAgICAgICAiQnJlYWtwb2lu dCAyIGF0IC4qOiBmaWxlIC4qJHtzcmNmaWxlfSwgbGluZSAuKiIgXAorICAg ICAgICAgImJyZWFrcG9pbnQgb24gYWxsX3RocmVhZHNfcnVubmluZyIKKwor Z2RiX3Rlc3QgImJyZWFrIGhhbmRfY2FsbCIgXAorICAgICAgICAgIkJyZWFr cG9pbnQgMyBhdCAuKjogZmlsZSAuKiR7c3JjZmlsZX0sIGxpbmUgLioiIFwK KyAgICAgICAgICJicmVha3BvaW50IG9uIGhhbmRfY2FsbCIKKworIyBSdW4g dGhlIHByb2dyYW0gYW5kIG1ha2Ugc3VyZSBHREIgcmVwb3J0cyB0aGF0IHdl IHN0b3BwZWQgYWZ0ZXIKKyMgaGl0dGluZyBicmVha3BvaW50IDIgaW4gYWxs X3RocmVhZHNfcnVubmluZygpLgorCitnZGJfdGVzdCAiY29udGludWUiIFwK KyAgICAgICAgICIuKkJyZWFrcG9pbnQgMiwgYWxsX3RocmVhZHNfcnVubmlu ZyAoKS4qIiBcCisgICAgICAgICAicnVuIHRvIGFsbF90aHJlYWRzX3J1bm5p bmciCisKKyMgQmVmb3JlIHdlIHN0YXJ0IG1ha2luZyBoYW5kIGZ1bmN0aW9u IGNhbGxzLCB0dXJuIG9uIHNjaGVkdWxlciBsb2NraW5nLgorCitnZGJfdGVz dCAic2V0IHNjaGVkdWxlci1sb2NraW5nIG9uIiAiIiAiZW5hYmxlIHNjaGVk dWxlciBsb2NraW5nIgorZ2RiX3Rlc3QgInNob3cgc2NoZWR1bGVyLWxvY2tp bmciICIuKiBsb2NraW5nIHNjaGVkdWxlciAuKiBpcyBcIm9uXCIuIiAic2hv dyBzY2hlZHVsZXIgbG9ja2luZyBvbiIKKworIyBOb3cgaGFuZC1jYWxsIGEg ZnVuY3Rpb24gaW4gZWFjaCB0aHJlYWQsIGhhdmluZyB0aGUgZnVuY3Rpb24K KyMgc3RvcCB3aXRob3V0IHJldHVybmluZy4KKworIyBBZGQgb25lIGZvciB0 aGUgbWFpbiB0aHJlYWQuCitzZXQgdG90YWxfbnJfdGhyZWFkcyBbZXhwciAk TlJfVEhSRUFEUyArIDFdCisKKyMgVGhyZWFkIG51bWJlcmluZyBpbiBnZGIg aXMgb3JpZ2luLTEsIHNvIGJlZ2luIG51bWJlcmluZyBhdCAxLgorZm9yIHsg c2V0IGkgMSB9IHsgJGkgPD0gJHRvdGFsX25yX3RocmVhZHMgfSB7IGluY3Ig aSB9IHsKKyAgICBzZXQgdGhyZWFkX25yICRpCisgICAgZ2RiX3Rlc3QgInRo cmVhZCAkdGhyZWFkX25yIiAiIiAicHJlcGFyZSB0byBtYWtlIGhhbmQgY2Fs bCwgdGhyZWFkICR0aHJlYWRfbnIiCisgICAgZ2RiX3Rlc3QgImNhbGwgaGFu ZF9jYWxsKCkiICJCcmVha3BvaW50IDMsIC4qIiAiaGFuZCBjYWxsLCB0aHJl YWQgJHRocmVhZF9uciIKK30KKworIyBOb3cgaGF2ZSBlYWNoIGhhbmQtY2Fs bGVkIGZ1bmN0aW9uIHJldHVybi4KKworIyBUdXJuIGNvbmZpcm1hdGlvbiBv ZmYgZm9yIHRoZSAicmV0dXJuIiBjb21tYW5kLgorZ2RiX3Rlc3QgInNldCBj b25maXJtIG9mZiIgIiIKKworY2xlYXJfeGZhaWwgIiotKi0qIgorCitmb3Ig eyBzZXQgaSAxIH0geyAkaSA8PSAkdG90YWxfbnJfdGhyZWFkcyB9IHsgaW5j ciBpIH0geworICAgIHNldCB0aHJlYWRfbnIgJGkKKyAgICBnZGJfdGVzdCAi dGhyZWFkICR0aHJlYWRfbnIiICIiICJwcmVwYXJlIHRvIGRpc2NhcmQgaGFu ZCBjYWxsLCB0aHJlYWQgJHRocmVhZF9uciIKKyAgICBzZXQgZnJhbWVfbnVt YmVyIFtnZXRfZHVtbXlfZnJhbWVfbnVtYmVyXQorICAgIGlmIHsgIiRmcmFt ZV9udW1iZXIiID09ICIiIH0geworCWZhaWwgImR1bW15IHN0YWNrIGZyYW1l IG51bWJlciwgdGhyZWFkICR0aHJlYWRfbnIiCisJc2V0dXBfeGZhaWwgIiot Ki0qIgorCSMgTmVlZCBzb21ldGhpbmcuCisJc2V0IGZyYW1lX251bWJlciAw CisgICAgfSBlbHNlIHsKKwlwYXNzICJkdW1teSBzdGFjayBmcmFtZSBudW1i ZXIsIHRocmVhZCAkdGhyZWFkX25yIgorICAgIH0KKyAgICAjIFBvcCB0aGUg ZHVtbXkgZnJhbWUuCisgICAgZ2RiX3Rlc3QgImZyYW1lICRmcmFtZV9udW1i ZXIiICIiICJzZXR0aW5nIGZyYW1lLCB0aHJlYWQgJHRocmVhZF9uciIKKyAg ICBnZGJfdGVzdCAicmV0dXJuIiAiIiAiZGlzY2FyZCBoYW5kIGNhbGwsIHRo cmVhZCAkdGhyZWFkX25yIgorICAgICMgSW4gY2FzZSBnZXR0aW5nIHRoZSBk dW1teSBmcmFtZSBudW1iZXIgZmFpbGVkLCByZS1lbmFibGUgZm9yIG5leHQg aXRlci4KKyAgICBjbGVhcl94ZmFpbCAiKi0qLSoiCit9CisKKyMgTWFrZSBz dXJlIGFsbCBkdW1teSBmcmFtZXMgZ290IHBvcHBlZC4KKworZ2RiX3Rlc3Rf bXVsdGlwbGUgIm1haW50IHByaW50IGR1bW15LWZyYW1lcyIgImFsbCBkdW1t aWVzIHBvcHBlZCIgeworICAgIC1yZSAiLipzdGFjaz0uKiRnZGJfcHJvbXB0 ICQiIHsKKwlmYWlsICJhbGwgZHVtbWllcyBwb3BwZWQiCisgICAgfQorICAg IC1yZSAiLiokZ2RiX3Byb21wdCAkIiB7CisJcGFzcyAiYWxsIGR1bW1pZXMg cG9wcGVkIgorICAgIH0KK30KKworIyBCZWZvcmUgd2UgcmVzdW1lIHRoZSBm dWxsIHByb2dyYW0sIHR1cm4gb2Ygc2NoZWR1bGVyIGxvY2tpbmcuCitnZGJf dGVzdCAic2V0IHNjaGVkdWxlci1sb2NraW5nIG9mZiIgIiIgImRpc2FibGUg c2NoZWR1bGVyIGxvY2tpbmciCitnZGJfdGVzdCAic2hvdyBzY2hlZHVsZXIt bG9ja2luZyIgIi4qIGxvY2tpbmcgc2NoZWR1bGVyIC4qIGlzIFwib2ZmXCIu IiAic2hvdyBzY2hlZHVsZXIgbG9ja2luZyBvZmYiCisKKyMgQ29udGludWUg b25lIGxhc3QgdGltZSwgdGhlIHByb2dyYW0gc2hvdWxkIGV4aXQgbm9ybWFs bHkuCisjCisjID8/PyBUaGlzIGN1cnJlbnRseSBkb2Vzbid0IHdvcmsgYmVj YXVzZSBnZGIgZG9lc24ndCBrbm93IGhvdyB0byBzaW5nbGVzdGVwCisjIG92 ZXIgcmVwb3J0ZWQgYnJlYWtwb2ludHMgdGhhdCB3ZXJlbid0IGluIHRoZSBs YXN0IHRocmVhZCB0byBydW4uCisjIEZpeGluZyB0aGlzIGZpcnN0IHJlcXVp cmVzIGRlZmluaW5nIHdoYXQgdGhlIGNvcnJlY3QgYmVoYXZpb3VyIGlzLgor IyBDb21tZW50ZWQgb3V0IHVudGlsIHRoZW4uCisjCisjIE1hbnVhbGx5IHNl dCB0aGUgdGhyZWFkIGJhY2sgdG8gdGhlIGZpcnN0IHRocmVhZDogdGhlIHBy b2dyYW0gaXMgc3RpbGwgYXQKKyMgdGhlIGFsbF90aHJlYWRzX3J1bm5pbmcg YnJlYWtwb2ludCwgd2hpY2ggd2Fzbid0IHRoZSBsYXN0IHRocmVhZCB0byBy dW4sCisjIGFuZCBnZGIgZG9lc24ndCBrbm93IGhvdyB0byBzaW5nbGVzdGVw IG92ZXIgcmVwb3J0ZWQgYnJlYWtwb2ludHMgdGhhdAorIyB3ZXJlbid0IGlu IHRoZSBsYXN0IHRocmVhZCB0byBydW4uCisjZ2RiX3Rlc3QgInRocmVhZCAx IiAiIiAic2V0IHRocmVhZCB0byAxLCBwcmVwYXJlIHRvIHJlc3VtZSIKKyMK KyNnZGJfY29udGludWVfdG9fZW5kICJoYW5kLWNhbGwtaW4tdGhyZWFkcyIK KworcmV0dXJuIDAK --000e0cd2900e2f82970463a018d1--