From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:38068) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1d7nMS-00019m-3T for qemu-devel@nongnu.org; Mon, 08 May 2017 14:26:21 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1d7nMO-00038N-P2 for qemu-devel@nongnu.org; Mon, 08 May 2017 14:26:20 -0400 Received: from mx1.redhat.com ([209.132.183.28]:57503) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1d7nMO-00038C-Fy for qemu-devel@nongnu.org; Mon, 08 May 2017 14:26:16 -0400 From: Markus Armbruster References: <20170505193810.2934-1-eblake@redhat.com> <20170505193810.2934-3-eblake@redhat.com> Date: Mon, 08 May 2017 20:26:11 +0200 In-Reply-To: <20170505193810.2934-3-eblake@redhat.com> (Eric Blake's message of "Fri, 5 May 2017 14:38:07 -0500") Message-ID: <87zien433w.fsf@dusky.pond.sub.org> MIME-Version: 1.0 Content-Type: text/plain Subject: Re: [Qemu-devel] [PATCH v6 2/5] shutdown: Prepare for use of an enum in reset/shutdown_request List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Eric Blake Cc: qemu-devel@nongnu.org, Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , Juan Quintela , alistair.francis@xilinx.com, zhanghailiang , "open list:X86" , Anthony Perard , Paolo Bonzini , "Dr. David Alan Gilbert" , Richard Henderson Eric Blake writes: > We want to track why a guest was shutdown; in particular, being able > to tell the difference between a guest request (such as ACPI request) > and host request (such as SIGINT) will prove useful to libvirt. > Since all requests eventually end up changing shutdown_requested in > vl.c, the logical change is to make that value track the reason, > rather than its current 0/1 contents. > > Since command-line options control whether a reset request is turned > into a shutdown request instead, the same treatment is given to > reset_requested. > > This patch adds an internal enum ShutdownCause that describes reasons > that a shutdown can be requested, and changes qemu_system_reset() to > pass the reason through, although for now it is not reported. The > enum could be exported via QAPI at a later date, if deemed necessary, > but for now, there has not been a request to expose that much detail > to end clients. > > For now, we only populate the reason with HOST_ERROR, along with FIXME > comments that describe our plans for how to pass an actual correct > reason. In other words, replacing 0 by SHUTDOWN_CAUSE_NONE, and 1 by SHUTDOWN_CAUSE_HOST_ERROR. Makes sense. > The next patches will then actually wire things up to modify > events to report data based on the reason, and to pass the correct enum > value in from various call-sites that can trigger a reset/shutdown (big > enough that it was worth splitting from this patch). > > Signed-off-by: Eric Blake > > --- > v6: make ShutdownCause internal-only, add SHUTDOWN_CAUSE_NONE so that > comparison to 0 still works, tweak initial FIXME values > v5: no change > v4: s/ShutdownType/ShutdownCause/, no thanks to mingw header pollution > v3: new patch > --- > include/sysemu/sysemu.h | 22 ++++++++++++++++++--- > vl.c | 51 +++++++++++++++++++++++++++++++------------------ > hw/i386/xen/xen-hvm.c | 7 +++++-- > migration/colo.c | 2 +- > migration/savevm.c | 2 +- > 5 files changed, 58 insertions(+), 26 deletions(-) > > diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h > index 16175f7..e4da9d4 100644 > --- a/include/sysemu/sysemu.h > +++ b/include/sysemu/sysemu.h > @@ -36,6 +36,22 @@ void vm_state_notify(int running, RunState state); > #define VMRESET_SILENT false > #define VMRESET_REPORT true > > +/* Enumeration of various causes for shutdown. */ > +typedef enum ShutdownCause ShutdownCause; > +enum ShutdownCause { Why define the typedef separately here? What's wrong with typedef enum ShutdownCause { ... } ShutdownCause; ? > + SHUTDOWN_CAUSE_NONE, /* No shutdown requested yet */ Comment is fine. Possible alternative: /* No shutdown request pending */ > + SHUTDOWN_CAUSE_HOST_QMP, /* Reaction to a QMP command, like 'quit' */ > + SHUTDOWN_CAUSE_HOST_SIGNAL, /* Reaction to a signal, such as SIGINT */ > + SHUTDOWN_CAUSE_HOST_UI, /* Reaction to UI event, like window close */ > + SHUTDOWN_CAUSE_HOST_ERROR, /* An error prevents further use of guest */ > + SHUTDOWN_CAUSE_GUEST_SHUTDOWN,/* Guest requested shutdown, such as via > + ACPI or other hardware-specific means */ > + SHUTDOWN_CAUSE_GUEST_RESET, /* Guest requested reset, and command line > + turns that into a shutdown */ > + SHUTDOWN_CAUSE_GUEST_PANIC, /* Guest panicked, and command line turns > + that into a shutdown */ > +}; > + > void vm_start(void); > int vm_prepare_start(void); > int vm_stop(RunState state); > @@ -62,10 +78,10 @@ void qemu_system_debug_request(void); > void qemu_system_vmstop_request(RunState reason); > void qemu_system_vmstop_request_prepare(void); > bool qemu_vmstop_requested(RunState *r); > -int qemu_shutdown_requested_get(void); > -int qemu_reset_requested_get(void); > +ShutdownCause qemu_shutdown_requested_get(void); > +ShutdownCause qemu_reset_requested_get(void); > void qemu_system_killed(int signal, pid_t pid); > -void qemu_system_reset(bool report); > +void qemu_system_reset(bool report, ShutdownCause reason); > void qemu_system_guest_panicked(GuestPanicInformation *info); > size_t qemu_target_page_size(void); > > diff --git a/vl.c b/vl.c > index f22a3ac..6069fb2 100644 > --- a/vl.c > +++ b/vl.c > @@ -1597,8 +1597,9 @@ void vm_state_notify(int running, RunState state) > } > } > > -static int reset_requested; > -static int shutdown_requested, shutdown_signal; > +static ShutdownCause reset_requested; > +static ShutdownCause shutdown_requested; > +static int shutdown_signal; > static pid_t shutdown_pid; > static int powerdown_requested; > static int debug_requested; > @@ -1612,19 +1613,19 @@ static NotifierList wakeup_notifiers = > NOTIFIER_LIST_INITIALIZER(wakeup_notifiers); > static uint32_t wakeup_reason_mask = ~(1 << QEMU_WAKEUP_REASON_NONE); > > -int qemu_shutdown_requested_get(void) > +ShutdownCause qemu_shutdown_requested_get(void) > { > return shutdown_requested; > } > > -int qemu_reset_requested_get(void) > +ShutdownCause qemu_reset_requested_get(void) > { > return reset_requested; > } > > static int qemu_shutdown_requested(void) > { > - return atomic_xchg(&shutdown_requested, 0); > + return atomic_xchg(&shutdown_requested, SHUTDOWN_CAUSE_NONE); > } > > static void qemu_kill_report(void) > @@ -1647,14 +1648,14 @@ static void qemu_kill_report(void) > } > } > > -static int qemu_reset_requested(void) > +static ShutdownCause qemu_reset_requested(void) > { > - int r = reset_requested; > + ShutdownCause r = reset_requested; Good opportunity to insert a blank line here. > if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) { > - reset_requested = 0; > + reset_requested = SHUTDOWN_CAUSE_NONE; > return r; > } > - return false; > + return SHUTDOWN_CAUSE_NONE; > } > > static int qemu_suspend_requested(void) > @@ -1686,7 +1687,12 @@ static int qemu_debug_requested(void) > return r; > } > > -void qemu_system_reset(bool report) > +/* > + * Reset the VM. If @report is VMRESET_REPORT, issue an event, using > + * the @reason interpreted as ShutdownCause for details. Otherwise, > + * @report is VMRESET_SILENT and @reason is ignored. > + */ "interpreted as ShutdownCause"? It *is* a ShutdownCause. Leftover? > +void qemu_system_reset(bool report, ShutdownCause reason) > { > MachineClass *mc; > > @@ -1700,6 +1706,7 @@ void qemu_system_reset(bool report) > qemu_devices_reset(); > } > if (report) { > + assert(reason); > qapi_event_send_reset(&error_abort); > } > cpu_synchronize_all_post_reset(); Looks like we're not using @reason "for details" just yet. > @@ -1738,9 +1745,10 @@ void qemu_system_guest_panicked(GuestPanicInformation *info) > void qemu_system_reset_request(void) > { > if (no_reboot) { > - shutdown_requested = 1; > + /* FIXME - add a parameter to allow callers to specify reason */ > + shutdown_requested = SHUTDOWN_CAUSE_HOST_ERROR; > } else { > - reset_requested = 1; > + reset_requested = SHUTDOWN_CAUSE_HOST_ERROR; > } > cpu_stop_current(); > qemu_notify_event(); > @@ -1807,7 +1815,7 @@ void qemu_system_killed(int signal, pid_t pid) > /* Cannot call qemu_system_shutdown_request directly because > * we are in a signal handler. > */ > - shutdown_requested = 1; > + shutdown_requested = SHUTDOWN_CAUSE_HOST_SIGNAL; Should this be SHUTDOWN_CAUSE_HOST_ERROR, to be updated in the next patch? Alternatively, tweak this patch's commit message? > qemu_notify_event(); > } > > @@ -1815,7 +1823,8 @@ void qemu_system_shutdown_request(void) > { > trace_qemu_system_shutdown_request(); > replay_shutdown_request(); > - shutdown_requested = 1; > + /* FIXME - add a parameter to allow callers to specify reason */ > + shutdown_requested = SHUTDOWN_CAUSE_HOST_ERROR; > qemu_notify_event(); > } > > @@ -1846,13 +1855,16 @@ void qemu_system_debug_request(void) > static bool main_loop_should_exit(void) > { > RunState r; > + ShutdownCause request; > + > if (qemu_debug_requested()) { > vm_stop(RUN_STATE_DEBUG); > } > if (qemu_suspend_requested()) { > qemu_system_suspend(); > } > - if (qemu_shutdown_requested()) { > + request = qemu_shutdown_requested(); > + if (request) { > qemu_kill_report(); > qapi_event_send_shutdown(&error_abort); > if (no_shutdown) { The detour through @request appears isn't necessary here. Perhaps you do it for consistency with the next hunk. Do you? Just asking to make sure I get what you're doing. Hmm, there's another one in xen-hvm.c, but consistency hardly applies there. If later patches add more uses, you might want delay the change until then. > @@ -1861,9 +1873,10 @@ static bool main_loop_should_exit(void) > return true; > } > } > - if (qemu_reset_requested()) { > + request = qemu_reset_requested(); > + if (request) { > pause_all_vcpus(); > - qemu_system_reset(VMRESET_REPORT); > + qemu_system_reset(VMRESET_REPORT, request); > resume_all_vcpus(); > if (!runstate_check(RUN_STATE_RUNNING) && > !runstate_check(RUN_STATE_INMIGRATE)) { > @@ -1872,7 +1885,7 @@ static bool main_loop_should_exit(void) > } > if (qemu_wakeup_requested()) { > pause_all_vcpus(); > - qemu_system_reset(VMRESET_SILENT); > + qemu_system_reset(VMRESET_SILENT, SHUTDOWN_CAUSE_NONE); > notifier_list_notify(&wakeup_notifiers, &wakeup_reason); > wakeup_reason = QEMU_WAKEUP_REASON_NONE; > resume_all_vcpus(); > @@ -4686,7 +4699,7 @@ int main(int argc, char **argv, char **envp) > reading from the other reads, because timer polling functions query > clock values from the log. */ > replay_checkpoint(CHECKPOINT_RESET); > - qemu_system_reset(VMRESET_SILENT); > + qemu_system_reset(VMRESET_SILENT, SHUTDOWN_CAUSE_NONE); > register_global_state(); > if (replay_mode != REPLAY_MODE_NONE) { > replay_vmstate_init(); > diff --git a/hw/i386/xen/xen-hvm.c b/hw/i386/xen/xen-hvm.c > index b1c05ff..b1001c1 100644 > --- a/hw/i386/xen/xen-hvm.c > +++ b/hw/i386/xen/xen-hvm.c > @@ -1089,11 +1089,14 @@ static void cpu_handle_ioreq(void *opaque) > * causes Xen to powerdown the domain. > */ > if (runstate_is_running()) { > + ShutdownCause request; > + > if (qemu_shutdown_requested_get()) { > destroy_hvm_domain(false); > } > - if (qemu_reset_requested_get()) { > - qemu_system_reset(VMRESET_REPORT); > + request = qemu_reset_requested_get(); > + if (request) { > + qemu_system_reset(VMRESET_REPORT, request); > destroy_hvm_domain(true); > } > } > diff --git a/migration/colo.c b/migration/colo.c > index 963c802..bf5b7e9 100644 > --- a/migration/colo.c > +++ b/migration/colo.c > @@ -623,7 +623,7 @@ void *colo_process_incoming_thread(void *opaque) > } > > qemu_mutex_lock_iothread(); > - qemu_system_reset(VMRESET_SILENT); > + qemu_system_reset(VMRESET_SILENT, SHUTDOWN_CAUSE_NONE); > vmstate_loading = true; > if (qemu_loadvm_state(fb) < 0) { > error_report("COLO: loadvm failed"); > diff --git a/migration/savevm.c b/migration/savevm.c > index a00c1ab..9ac2d22 100644 > --- a/migration/savevm.c > +++ b/migration/savevm.c > @@ -2300,7 +2300,7 @@ int load_vmstate(const char *name) > return -EINVAL; > } > > - qemu_system_reset(VMRESET_SILENT); > + qemu_system_reset(VMRESET_SILENT, SHUTDOWN_CAUSE_NONE); > mis->from_src_file = f; > > aio_context_acquire(aio_context); You seem to be passing SHUTDOWN_CAUSE_NONE exactly with VMRESET_SILENT. Would it be possible to have SHUTDOWN_CAUSE_NONE imply !report, any other case imply report, and get rid of the first parameter? From mboxrd@z Thu Jan 1 00:00:00 1970 From: Markus Armbruster Subject: Re: [Qemu-devel] [PATCH v6 2/5] shutdown: Prepare for use of an enum in reset/shutdown_request Date: Mon, 08 May 2017 20:26:11 +0200 Message-ID: <87zien433w.fsf@dusky.pond.sub.org> References: <20170505193810.2934-1-eblake@redhat.com> <20170505193810.2934-3-eblake@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1d7nMU-0006QL-QU for xen-devel@lists.xenproject.org; Mon, 08 May 2017 18:26:23 +0000 In-Reply-To: <20170505193810.2934-3-eblake@redhat.com> (Eric Blake's message of "Fri, 5 May 2017 14:38:07 -0500") List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Eric Blake Cc: Stefano Stabellini , Eduardo Habkost , Juan Quintela , "Michael S. Tsirkin" , qemu-devel@nongnu.org, alistair.francis@xilinx.com, Paolo Bonzini , Anthony Perard , "open list:X86" , Richard Henderson , "Dr. David Alan Gilbert" , zhanghailiang List-Id: xen-devel@lists.xenproject.org RXJpYyBCbGFrZSA8ZWJsYWtlQHJlZGhhdC5jb20+IHdyaXRlczoKCj4gV2Ugd2FudCB0byB0cmFj ayB3aHkgYSBndWVzdCB3YXMgc2h1dGRvd247IGluIHBhcnRpY3VsYXIsIGJlaW5nIGFibGUKPiB0 byB0ZWxsIHRoZSBkaWZmZXJlbmNlIGJldHdlZW4gYSBndWVzdCByZXF1ZXN0IChzdWNoIGFzIEFD UEkgcmVxdWVzdCkKPiBhbmQgaG9zdCByZXF1ZXN0IChzdWNoIGFzIFNJR0lOVCkgd2lsbCBwcm92 ZSB1c2VmdWwgdG8gbGlidmlydC4KPiBTaW5jZSBhbGwgcmVxdWVzdHMgZXZlbnR1YWxseSBlbmQg dXAgY2hhbmdpbmcgc2h1dGRvd25fcmVxdWVzdGVkIGluCj4gdmwuYywgdGhlIGxvZ2ljYWwgY2hh bmdlIGlzIHRvIG1ha2UgdGhhdCB2YWx1ZSB0cmFjayB0aGUgcmVhc29uLAo+IHJhdGhlciB0aGFu IGl0cyBjdXJyZW50IDAvMSBjb250ZW50cy4KPgo+IFNpbmNlIGNvbW1hbmQtbGluZSBvcHRpb25z IGNvbnRyb2wgd2hldGhlciBhIHJlc2V0IHJlcXVlc3QgaXMgdHVybmVkCj4gaW50byBhIHNodXRk b3duIHJlcXVlc3QgaW5zdGVhZCwgdGhlIHNhbWUgdHJlYXRtZW50IGlzIGdpdmVuIHRvCj4gcmVz ZXRfcmVxdWVzdGVkLgo+Cj4gVGhpcyBwYXRjaCBhZGRzIGFuIGludGVybmFsIGVudW0gU2h1dGRv d25DYXVzZSB0aGF0IGRlc2NyaWJlcyByZWFzb25zCj4gdGhhdCBhIHNodXRkb3duIGNhbiBiZSBy ZXF1ZXN0ZWQsIGFuZCBjaGFuZ2VzIHFlbXVfc3lzdGVtX3Jlc2V0KCkgdG8KPiBwYXNzIHRoZSBy ZWFzb24gdGhyb3VnaCwgYWx0aG91Z2ggZm9yIG5vdyBpdCBpcyBub3QgcmVwb3J0ZWQuICBUaGUK PiBlbnVtIGNvdWxkIGJlIGV4cG9ydGVkIHZpYSBRQVBJIGF0IGEgbGF0ZXIgZGF0ZSwgaWYgZGVl bWVkIG5lY2Vzc2FyeSwKPiBidXQgZm9yIG5vdywgdGhlcmUgaGFzIG5vdCBiZWVuIGEgcmVxdWVz dCB0byBleHBvc2UgdGhhdCBtdWNoIGRldGFpbAo+IHRvIGVuZCBjbGllbnRzLgo+Cj4gRm9yIG5v dywgd2Ugb25seSBwb3B1bGF0ZSB0aGUgcmVhc29uIHdpdGggSE9TVF9FUlJPUiwgYWxvbmcgd2l0 aCBGSVhNRQo+IGNvbW1lbnRzIHRoYXQgZGVzY3JpYmUgb3VyIHBsYW5zIGZvciBob3cgdG8gcGFz cyBhbiBhY3R1YWwgY29ycmVjdAo+IHJlYXNvbi4KCkluIG90aGVyIHdvcmRzLCByZXBsYWNpbmcg MCBieSBTSFVURE9XTl9DQVVTRV9OT05FLCBhbmQgMSBieQpTSFVURE9XTl9DQVVTRV9IT1NUX0VS Uk9SLiAgTWFrZXMgc2Vuc2UuCgo+ICAgICAgICAgIFRoZSBuZXh0IHBhdGNoZXMgd2lsbCB0aGVu IGFjdHVhbGx5IHdpcmUgdGhpbmdzIHVwIHRvIG1vZGlmeQo+IGV2ZW50cyB0byByZXBvcnQgZGF0 YSBiYXNlZCBvbiB0aGUgcmVhc29uLCBhbmQgdG8gcGFzcyB0aGUgY29ycmVjdCBlbnVtCj4gdmFs dWUgaW4gZnJvbSB2YXJpb3VzIGNhbGwtc2l0ZXMgdGhhdCBjYW4gdHJpZ2dlciBhIHJlc2V0L3No dXRkb3duIChiaWcKPiBlbm91Z2ggdGhhdCBpdCB3YXMgd29ydGggc3BsaXR0aW5nIGZyb20gdGhp cyBwYXRjaCkuCj4KPiBTaWduZWQtb2ZmLWJ5OiBFcmljIEJsYWtlIDxlYmxha2VAcmVkaGF0LmNv bT4KPgo+IC0tLQo+IHY2OiBtYWtlIFNodXRkb3duQ2F1c2UgaW50ZXJuYWwtb25seSwgYWRkIFNI VVRET1dOX0NBVVNFX05PTkUgc28gdGhhdAo+IGNvbXBhcmlzb24gdG8gMCBzdGlsbCB3b3Jrcywg dHdlYWsgaW5pdGlhbCBGSVhNRSB2YWx1ZXMKPiB2NTogbm8gY2hhbmdlCj4gdjQ6IHMvU2h1dGRv d25UeXBlL1NodXRkb3duQ2F1c2UvLCBubyB0aGFua3MgdG8gbWluZ3cgaGVhZGVyIHBvbGx1dGlv bgo+IHYzOiBuZXcgcGF0Y2gKPiAtLS0KPiAgaW5jbHVkZS9zeXNlbXUvc3lzZW11LmggfCAyMiAr KysrKysrKysrKysrKysrKystLS0KPiAgdmwuYyAgICAgICAgICAgICAgICAgICAgfCA1MSArKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tCj4gIGh3L2kzODYv eGVuL3hlbi1odm0uYyAgIHwgIDcgKysrKystLQo+ICBtaWdyYXRpb24vY29sby5jICAgICAgICB8 ICAyICstCj4gIG1pZ3JhdGlvbi9zYXZldm0uYyAgICAgIHwgIDIgKy0KPiAgNSBmaWxlcyBjaGFu Z2VkLCA1OCBpbnNlcnRpb25zKCspLCAyNiBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9p bmNsdWRlL3N5c2VtdS9zeXNlbXUuaCBiL2luY2x1ZGUvc3lzZW11L3N5c2VtdS5oCj4gaW5kZXgg MTYxNzVmNy4uZTRkYTlkNCAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL3N5c2VtdS9zeXNlbXUuaAo+ ICsrKyBiL2luY2x1ZGUvc3lzZW11L3N5c2VtdS5oCj4gQEAgLTM2LDYgKzM2LDIyIEBAIHZvaWQg dm1fc3RhdGVfbm90aWZ5KGludCBydW5uaW5nLCBSdW5TdGF0ZSBzdGF0ZSk7Cj4gICNkZWZpbmUg Vk1SRVNFVF9TSUxFTlQgICBmYWxzZQo+ICAjZGVmaW5lIFZNUkVTRVRfUkVQT1JUICAgdHJ1ZQo+ Cj4gKy8qIEVudW1lcmF0aW9uIG9mIHZhcmlvdXMgY2F1c2VzIGZvciBzaHV0ZG93bi4gKi8KPiAr dHlwZWRlZiBlbnVtIFNodXRkb3duQ2F1c2UgU2h1dGRvd25DYXVzZTsKPiArZW51bSBTaHV0ZG93 bkNhdXNlIHsKCldoeSBkZWZpbmUgdGhlIHR5cGVkZWYgc2VwYXJhdGVseSBoZXJlPyAgV2hhdCdz IHdyb25nIHdpdGgKCiAgICB0eXBlZGVmIGVudW0gU2h1dGRvd25DYXVzZSB7CiAgICAgICAgLi4u CiAgICB9IFNodXRkb3duQ2F1c2U7Cgo/Cgo+ICsgICAgU0hVVERPV05fQ0FVU0VfTk9ORSwgICAg ICAgICAgLyogTm8gc2h1dGRvd24gcmVxdWVzdGVkIHlldCAqLwoKQ29tbWVudCBpcyBmaW5lLiAg UG9zc2libGUgYWx0ZXJuYXRpdmU6IC8qIE5vIHNodXRkb3duIHJlcXVlc3QgcGVuZGluZyAqLwoK PiArICAgIFNIVVRET1dOX0NBVVNFX0hPU1RfUU1QLCAgICAgIC8qIFJlYWN0aW9uIHRvIGEgUU1Q IGNvbW1hbmQsIGxpa2UgJ3F1aXQnICovCj4gKyAgICBTSFVURE9XTl9DQVVTRV9IT1NUX1NJR05B TCwgICAvKiBSZWFjdGlvbiB0byBhIHNpZ25hbCwgc3VjaCBhcyBTSUdJTlQgKi8KPiArICAgIFNI VVRET1dOX0NBVVNFX0hPU1RfVUksICAgICAgIC8qIFJlYWN0aW9uIHRvIFVJIGV2ZW50LCBsaWtl IHdpbmRvdyBjbG9zZSAqLwo+ICsgICAgU0hVVERPV05fQ0FVU0VfSE9TVF9FUlJPUiwgICAgLyog QW4gZXJyb3IgcHJldmVudHMgZnVydGhlciB1c2Ugb2YgZ3Vlc3QgKi8KPiArICAgIFNIVVRET1dO X0NBVVNFX0dVRVNUX1NIVVRET1dOLC8qIEd1ZXN0IHJlcXVlc3RlZCBzaHV0ZG93biwgc3VjaCBh cyB2aWEKPiArICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFDUEkgb3Igb3Ro ZXIgaGFyZHdhcmUtc3BlY2lmaWMgbWVhbnMgKi8KPiArICAgIFNIVVRET1dOX0NBVVNFX0dVRVNU X1JFU0VULCAgIC8qIEd1ZXN0IHJlcXVlc3RlZCByZXNldCwgYW5kIGNvbW1hbmQgbGluZQo+ICsg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdHVybnMgdGhhdCBpbnRvIGEgc2h1 dGRvd24gKi8KPiArICAgIFNIVVRET1dOX0NBVVNFX0dVRVNUX1BBTklDLCAgIC8qIEd1ZXN0IHBh bmlja2VkLCBhbmQgY29tbWFuZCBsaW5lIHR1cm5zCj4gKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICB0aGF0IGludG8gYSBzaHV0ZG93biAqLwo+ICt9Owo+ICsKPiAgdm9pZCB2 bV9zdGFydCh2b2lkKTsKPiAgaW50IHZtX3ByZXBhcmVfc3RhcnQodm9pZCk7Cj4gIGludCB2bV9z dG9wKFJ1blN0YXRlIHN0YXRlKTsKPiBAQCAtNjIsMTAgKzc4LDEwIEBAIHZvaWQgcWVtdV9zeXN0 ZW1fZGVidWdfcmVxdWVzdCh2b2lkKTsKPiAgdm9pZCBxZW11X3N5c3RlbV92bXN0b3BfcmVxdWVz dChSdW5TdGF0ZSByZWFzb24pOwo+ICB2b2lkIHFlbXVfc3lzdGVtX3Ztc3RvcF9yZXF1ZXN0X3By ZXBhcmUodm9pZCk7Cj4gIGJvb2wgcWVtdV92bXN0b3BfcmVxdWVzdGVkKFJ1blN0YXRlICpyKTsK PiAtaW50IHFlbXVfc2h1dGRvd25fcmVxdWVzdGVkX2dldCh2b2lkKTsKPiAtaW50IHFlbXVfcmVz ZXRfcmVxdWVzdGVkX2dldCh2b2lkKTsKPiArU2h1dGRvd25DYXVzZSBxZW11X3NodXRkb3duX3Jl cXVlc3RlZF9nZXQodm9pZCk7Cj4gK1NodXRkb3duQ2F1c2UgcWVtdV9yZXNldF9yZXF1ZXN0ZWRf Z2V0KHZvaWQpOwo+ICB2b2lkIHFlbXVfc3lzdGVtX2tpbGxlZChpbnQgc2lnbmFsLCBwaWRfdCBw aWQpOwo+IC12b2lkIHFlbXVfc3lzdGVtX3Jlc2V0KGJvb2wgcmVwb3J0KTsKPiArdm9pZCBxZW11 X3N5c3RlbV9yZXNldChib29sIHJlcG9ydCwgU2h1dGRvd25DYXVzZSByZWFzb24pOwo+ICB2b2lk IHFlbXVfc3lzdGVtX2d1ZXN0X3Bhbmlja2VkKEd1ZXN0UGFuaWNJbmZvcm1hdGlvbiAqaW5mbyk7 Cj4gIHNpemVfdCBxZW11X3RhcmdldF9wYWdlX3NpemUodm9pZCk7Cj4KPiBkaWZmIC0tZ2l0IGEv dmwuYyBiL3ZsLmMKPiBpbmRleCBmMjJhM2FjLi42MDY5ZmIyIDEwMDY0NAo+IC0tLSBhL3ZsLmMK PiArKysgYi92bC5jCj4gQEAgLTE1OTcsOCArMTU5Nyw5IEBAIHZvaWQgdm1fc3RhdGVfbm90aWZ5 KGludCBydW5uaW5nLCBSdW5TdGF0ZSBzdGF0ZSkKPiAgICAgIH0KPiAgfQo+Cj4gLXN0YXRpYyBp bnQgcmVzZXRfcmVxdWVzdGVkOwo+IC1zdGF0aWMgaW50IHNodXRkb3duX3JlcXVlc3RlZCwgc2h1 dGRvd25fc2lnbmFsOwo+ICtzdGF0aWMgU2h1dGRvd25DYXVzZSByZXNldF9yZXF1ZXN0ZWQ7Cj4g K3N0YXRpYyBTaHV0ZG93bkNhdXNlIHNodXRkb3duX3JlcXVlc3RlZDsKPiArc3RhdGljIGludCBz aHV0ZG93bl9zaWduYWw7Cj4gIHN0YXRpYyBwaWRfdCBzaHV0ZG93bl9waWQ7Cj4gIHN0YXRpYyBp bnQgcG93ZXJkb3duX3JlcXVlc3RlZDsKPiAgc3RhdGljIGludCBkZWJ1Z19yZXF1ZXN0ZWQ7Cj4g QEAgLTE2MTIsMTkgKzE2MTMsMTkgQEAgc3RhdGljIE5vdGlmaWVyTGlzdCB3YWtldXBfbm90aWZp ZXJzID0KPiAgICAgIE5PVElGSUVSX0xJU1RfSU5JVElBTElaRVIod2FrZXVwX25vdGlmaWVycyk7 Cj4gIHN0YXRpYyB1aW50MzJfdCB3YWtldXBfcmVhc29uX21hc2sgPSB+KDEgPDwgUUVNVV9XQUtF VVBfUkVBU09OX05PTkUpOwo+Cj4gLWludCBxZW11X3NodXRkb3duX3JlcXVlc3RlZF9nZXQodm9p ZCkKPiArU2h1dGRvd25DYXVzZSBxZW11X3NodXRkb3duX3JlcXVlc3RlZF9nZXQodm9pZCkKPiAg ewo+ICAgICAgcmV0dXJuIHNodXRkb3duX3JlcXVlc3RlZDsKPiAgfQo+Cj4gLWludCBxZW11X3Jl c2V0X3JlcXVlc3RlZF9nZXQodm9pZCkKPiArU2h1dGRvd25DYXVzZSBxZW11X3Jlc2V0X3JlcXVl c3RlZF9nZXQodm9pZCkKPiAgewo+ICAgICAgcmV0dXJuIHJlc2V0X3JlcXVlc3RlZDsKPiAgfQo+ Cj4gIHN0YXRpYyBpbnQgcWVtdV9zaHV0ZG93bl9yZXF1ZXN0ZWQodm9pZCkKPiAgewo+IC0gICAg cmV0dXJuIGF0b21pY194Y2hnKCZzaHV0ZG93bl9yZXF1ZXN0ZWQsIDApOwo+ICsgICAgcmV0dXJu IGF0b21pY194Y2hnKCZzaHV0ZG93bl9yZXF1ZXN0ZWQsIFNIVVRET1dOX0NBVVNFX05PTkUpOwo+ ICB9Cj4KPiAgc3RhdGljIHZvaWQgcWVtdV9raWxsX3JlcG9ydCh2b2lkKQo+IEBAIC0xNjQ3LDE0 ICsxNjQ4LDE0IEBAIHN0YXRpYyB2b2lkIHFlbXVfa2lsbF9yZXBvcnQodm9pZCkKPiAgICAgIH0K PiAgfQo+Cj4gLXN0YXRpYyBpbnQgcWVtdV9yZXNldF9yZXF1ZXN0ZWQodm9pZCkKPiArc3RhdGlj IFNodXRkb3duQ2F1c2UgcWVtdV9yZXNldF9yZXF1ZXN0ZWQodm9pZCkKPiAgewo+IC0gICAgaW50 IHIgPSByZXNldF9yZXF1ZXN0ZWQ7Cj4gKyAgICBTaHV0ZG93bkNhdXNlIHIgPSByZXNldF9yZXF1 ZXN0ZWQ7CgpHb29kIG9wcG9ydHVuaXR5IHRvIGluc2VydCBhIGJsYW5rIGxpbmUgaGVyZS4KCj4g ICAgICBpZiAociAmJiByZXBsYXlfY2hlY2twb2ludChDSEVDS1BPSU5UX1JFU0VUX1JFUVVFU1RF RCkpIHsKPiAtICAgICAgICByZXNldF9yZXF1ZXN0ZWQgPSAwOwo+ICsgICAgICAgIHJlc2V0X3Jl cXVlc3RlZCA9IFNIVVRET1dOX0NBVVNFX05PTkU7Cj4gICAgICAgICAgcmV0dXJuIHI7Cj4gICAg ICB9Cj4gLSAgICByZXR1cm4gZmFsc2U7Cj4gKyAgICByZXR1cm4gU0hVVERPV05fQ0FVU0VfTk9O RTsKPiAgfQo+Cj4gIHN0YXRpYyBpbnQgcWVtdV9zdXNwZW5kX3JlcXVlc3RlZCh2b2lkKQo+IEBA IC0xNjg2LDcgKzE2ODcsMTIgQEAgc3RhdGljIGludCBxZW11X2RlYnVnX3JlcXVlc3RlZCh2b2lk KQo+ICAgICAgcmV0dXJuIHI7Cj4gIH0KPgo+IC12b2lkIHFlbXVfc3lzdGVtX3Jlc2V0KGJvb2wg cmVwb3J0KQo+ICsvKgo+ICsgKiBSZXNldCB0aGUgVk0uIElmIEByZXBvcnQgaXMgVk1SRVNFVF9S RVBPUlQsIGlzc3VlIGFuIGV2ZW50LCB1c2luZwo+ICsgKiB0aGUgQHJlYXNvbiBpbnRlcnByZXRl ZCBhcyBTaHV0ZG93bkNhdXNlIGZvciBkZXRhaWxzLiAgT3RoZXJ3aXNlLAo+ICsgKiBAcmVwb3J0 IGlzIFZNUkVTRVRfU0lMRU5UIGFuZCBAcmVhc29uIGlzIGlnbm9yZWQuCj4gKyAqLwoKImludGVy cHJldGVkIGFzIFNodXRkb3duQ2F1c2UiPyAgSXQgKmlzKiBhIFNodXRkb3duQ2F1c2UuICBMZWZ0 b3Zlcj8KCj4gK3ZvaWQgcWVtdV9zeXN0ZW1fcmVzZXQoYm9vbCByZXBvcnQsIFNodXRkb3duQ2F1 c2UgcmVhc29uKQo+ICB7Cj4gICAgICBNYWNoaW5lQ2xhc3MgKm1jOwo+Cj4gQEAgLTE3MDAsNiAr MTcwNiw3IEBAIHZvaWQgcWVtdV9zeXN0ZW1fcmVzZXQoYm9vbCByZXBvcnQpCj4gICAgICAgICAg cWVtdV9kZXZpY2VzX3Jlc2V0KCk7Cj4gICAgICB9Cj4gICAgICBpZiAocmVwb3J0KSB7Cj4gKyAg ICAgICAgYXNzZXJ0KHJlYXNvbik7Cj4gICAgICAgICAgcWFwaV9ldmVudF9zZW5kX3Jlc2V0KCZl cnJvcl9hYm9ydCk7Cj4gICAgICB9Cj4gICAgICBjcHVfc3luY2hyb25pemVfYWxsX3Bvc3RfcmVz ZXQoKTsKCkxvb2tzIGxpa2Ugd2UncmUgbm90IHVzaW5nIEByZWFzb24gImZvciBkZXRhaWxzIiBq dXN0IHlldC4KCj4gQEAgLTE3MzgsOSArMTc0NSwxMCBAQCB2b2lkIHFlbXVfc3lzdGVtX2d1ZXN0 X3Bhbmlja2VkKEd1ZXN0UGFuaWNJbmZvcm1hdGlvbiAqaW5mbykKPiAgdm9pZCBxZW11X3N5c3Rl bV9yZXNldF9yZXF1ZXN0KHZvaWQpCj4gIHsKPiAgICAgIGlmIChub19yZWJvb3QpIHsKPiAtICAg ICAgICBzaHV0ZG93bl9yZXF1ZXN0ZWQgPSAxOwo+ICsgICAgICAgIC8qIEZJWE1FIC0gYWRkIGEg cGFyYW1ldGVyIHRvIGFsbG93IGNhbGxlcnMgdG8gc3BlY2lmeSByZWFzb24gKi8KPiArICAgICAg ICBzaHV0ZG93bl9yZXF1ZXN0ZWQgPSBTSFVURE9XTl9DQVVTRV9IT1NUX0VSUk9SOwo+ICAgICAg fSBlbHNlIHsKPiAtICAgICAgICByZXNldF9yZXF1ZXN0ZWQgPSAxOwo+ICsgICAgICAgIHJlc2V0 X3JlcXVlc3RlZCA9IFNIVVRET1dOX0NBVVNFX0hPU1RfRVJST1I7Cj4gICAgICB9Cj4gICAgICBj cHVfc3RvcF9jdXJyZW50KCk7Cj4gICAgICBxZW11X25vdGlmeV9ldmVudCgpOwo+IEBAIC0xODA3 LDcgKzE4MTUsNyBAQCB2b2lkIHFlbXVfc3lzdGVtX2tpbGxlZChpbnQgc2lnbmFsLCBwaWRfdCBw aWQpCj4gICAgICAvKiBDYW5ub3QgY2FsbCBxZW11X3N5c3RlbV9zaHV0ZG93bl9yZXF1ZXN0IGRp cmVjdGx5IGJlY2F1c2UKPiAgICAgICAqIHdlIGFyZSBpbiBhIHNpZ25hbCBoYW5kbGVyLgo+ICAg ICAgICovCj4gLSAgICBzaHV0ZG93bl9yZXF1ZXN0ZWQgPSAxOwo+ICsgICAgc2h1dGRvd25fcmVx dWVzdGVkID0gU0hVVERPV05fQ0FVU0VfSE9TVF9TSUdOQUw7CgpTaG91bGQgdGhpcyBiZSBTSFVU RE9XTl9DQVVTRV9IT1NUX0VSUk9SLCB0byBiZSB1cGRhdGVkIGluIHRoZSBuZXh0CnBhdGNoPyAg QWx0ZXJuYXRpdmVseSwgdHdlYWsgdGhpcyBwYXRjaCdzIGNvbW1pdCBtZXNzYWdlPwoKPiAgICAg IHFlbXVfbm90aWZ5X2V2ZW50KCk7Cj4gIH0KPgo+IEBAIC0xODE1LDcgKzE4MjMsOCBAQCB2b2lk IHFlbXVfc3lzdGVtX3NodXRkb3duX3JlcXVlc3Qodm9pZCkKPiAgewo+ICAgICAgdHJhY2VfcWVt dV9zeXN0ZW1fc2h1dGRvd25fcmVxdWVzdCgpOwo+ICAgICAgcmVwbGF5X3NodXRkb3duX3JlcXVl c3QoKTsKPiAtICAgIHNodXRkb3duX3JlcXVlc3RlZCA9IDE7Cj4gKyAgICAvKiBGSVhNRSAtIGFk ZCBhIHBhcmFtZXRlciB0byBhbGxvdyBjYWxsZXJzIHRvIHNwZWNpZnkgcmVhc29uICovCj4gKyAg ICBzaHV0ZG93bl9yZXF1ZXN0ZWQgPSBTSFVURE9XTl9DQVVTRV9IT1NUX0VSUk9SOwo+ICAgICAg cWVtdV9ub3RpZnlfZXZlbnQoKTsKPiAgfQo+Cj4gQEAgLTE4NDYsMTMgKzE4NTUsMTYgQEAgdm9p ZCBxZW11X3N5c3RlbV9kZWJ1Z19yZXF1ZXN0KHZvaWQpCj4gIHN0YXRpYyBib29sIG1haW5fbG9v cF9zaG91bGRfZXhpdCh2b2lkKQo+ICB7Cj4gICAgICBSdW5TdGF0ZSByOwo+ICsgICAgU2h1dGRv d25DYXVzZSByZXF1ZXN0Owo+ICsKPiAgICAgIGlmIChxZW11X2RlYnVnX3JlcXVlc3RlZCgpKSB7 Cj4gICAgICAgICAgdm1fc3RvcChSVU5fU1RBVEVfREVCVUcpOwo+ICAgICAgfQo+ICAgICAgaWYg KHFlbXVfc3VzcGVuZF9yZXF1ZXN0ZWQoKSkgewo+ICAgICAgICAgIHFlbXVfc3lzdGVtX3N1c3Bl bmQoKTsKPiAgICAgIH0KPiAtICAgIGlmIChxZW11X3NodXRkb3duX3JlcXVlc3RlZCgpKSB7Cj4g KyAgICByZXF1ZXN0ID0gcWVtdV9zaHV0ZG93bl9yZXF1ZXN0ZWQoKTsKPiArICAgIGlmIChyZXF1 ZXN0KSB7Cj4gICAgICAgICAgcWVtdV9raWxsX3JlcG9ydCgpOwo+ICAgICAgICAgIHFhcGlfZXZl bnRfc2VuZF9zaHV0ZG93bigmZXJyb3JfYWJvcnQpOwo+ICAgICAgICAgIGlmIChub19zaHV0ZG93 bikgewoKVGhlIGRldG91ciB0aHJvdWdoIEByZXF1ZXN0IGFwcGVhcnMgaXNuJ3QgbmVjZXNzYXJ5 IGhlcmUuICBQZXJoYXBzIHlvdQpkbyBpdCBmb3IgY29uc2lzdGVuY3kgd2l0aCB0aGUgbmV4dCBo dW5rLiAgRG8geW91PyAgSnVzdCBhc2tpbmcgdG8gbWFrZQpzdXJlIEkgZ2V0IHdoYXQgeW91J3Jl IGRvaW5nLgoKSG1tLCB0aGVyZSdzIGFub3RoZXIgb25lIGluIHhlbi1odm0uYywgYnV0IGNvbnNp c3RlbmN5IGhhcmRseSBhcHBsaWVzCnRoZXJlLiAgSWYgbGF0ZXIgcGF0Y2hlcyBhZGQgbW9yZSB1 c2VzLCB5b3UgbWlnaHQgd2FudCBkZWxheSB0aGUgY2hhbmdlCnVudGlsIHRoZW4uCgo+IEBAIC0x ODYxLDkgKzE4NzMsMTAgQEAgc3RhdGljIGJvb2wgbWFpbl9sb29wX3Nob3VsZF9leGl0KHZvaWQp Cj4gICAgICAgICAgICAgIHJldHVybiB0cnVlOwo+ICAgICAgICAgIH0KPiAgICAgIH0KPiAtICAg IGlmIChxZW11X3Jlc2V0X3JlcXVlc3RlZCgpKSB7Cj4gKyAgICByZXF1ZXN0ID0gcWVtdV9yZXNl dF9yZXF1ZXN0ZWQoKTsKPiArICAgIGlmIChyZXF1ZXN0KSB7Cj4gICAgICAgICAgcGF1c2VfYWxs X3ZjcHVzKCk7Cj4gLSAgICAgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9SRVBPUlQpOwo+ ICsgICAgICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfUkVQT1JULCByZXF1ZXN0KTsKPiAg ICAgICAgICByZXN1bWVfYWxsX3ZjcHVzKCk7Cj4gICAgICAgICAgaWYgKCFydW5zdGF0ZV9jaGVj ayhSVU5fU1RBVEVfUlVOTklORykgJiYKPiAgICAgICAgICAgICAgICAgICFydW5zdGF0ZV9jaGVj ayhSVU5fU1RBVEVfSU5NSUdSQVRFKSkgewo+IEBAIC0xODcyLDcgKzE4ODUsNyBAQCBzdGF0aWMg Ym9vbCBtYWluX2xvb3Bfc2hvdWxkX2V4aXQodm9pZCkKPiAgICAgIH0KPiAgICAgIGlmIChxZW11 X3dha2V1cF9yZXF1ZXN0ZWQoKSkgewo+ICAgICAgICAgIHBhdXNlX2FsbF92Y3B1cygpOwo+IC0g ICAgICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfU0lMRU5UKTsKPiArICAgICAgICBxZW11 X3N5c3RlbV9yZXNldChWTVJFU0VUX1NJTEVOVCwgU0hVVERPV05fQ0FVU0VfTk9ORSk7Cj4gICAg ICAgICAgbm90aWZpZXJfbGlzdF9ub3RpZnkoJndha2V1cF9ub3RpZmllcnMsICZ3YWtldXBfcmVh c29uKTsKPiAgICAgICAgICB3YWtldXBfcmVhc29uID0gUUVNVV9XQUtFVVBfUkVBU09OX05PTkU7 Cj4gICAgICAgICAgcmVzdW1lX2FsbF92Y3B1cygpOwo+IEBAIC00Njg2LDcgKzQ2OTksNyBAQCBp bnQgbWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3YsIGNoYXIgKiplbnZwKQo+ICAgICAgICAgcmVh ZGluZyBmcm9tIHRoZSBvdGhlciByZWFkcywgYmVjYXVzZSB0aW1lciBwb2xsaW5nIGZ1bmN0aW9u cyBxdWVyeQo+ICAgICAgICAgY2xvY2sgdmFsdWVzIGZyb20gdGhlIGxvZy4gKi8KPiAgICAgIHJl cGxheV9jaGVja3BvaW50KENIRUNLUE9JTlRfUkVTRVQpOwo+IC0gICAgcWVtdV9zeXN0ZW1fcmVz ZXQoVk1SRVNFVF9TSUxFTlQpOwo+ICsgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9TSUxF TlQsIFNIVVRET1dOX0NBVVNFX05PTkUpOwo+ICAgICAgcmVnaXN0ZXJfZ2xvYmFsX3N0YXRlKCk7 Cj4gICAgICBpZiAocmVwbGF5X21vZGUgIT0gUkVQTEFZX01PREVfTk9ORSkgewo+ICAgICAgICAg IHJlcGxheV92bXN0YXRlX2luaXQoKTsKPiBkaWZmIC0tZ2l0IGEvaHcvaTM4Ni94ZW4veGVuLWh2 bS5jIGIvaHcvaTM4Ni94ZW4veGVuLWh2bS5jCj4gaW5kZXggYjFjMDVmZi4uYjEwMDFjMSAxMDA2 NDQKPiAtLS0gYS9ody9pMzg2L3hlbi94ZW4taHZtLmMKPiArKysgYi9ody9pMzg2L3hlbi94ZW4t aHZtLmMKPiBAQCAtMTA4OSwxMSArMTA4OSwxNCBAQCBzdGF0aWMgdm9pZCBjcHVfaGFuZGxlX2lv cmVxKHZvaWQgKm9wYXF1ZSkKPiAgICAgICAgICAgKiBjYXVzZXMgWGVuIHRvIHBvd2VyZG93biB0 aGUgZG9tYWluLgo+ICAgICAgICAgICAqLwo+ICAgICAgICAgIGlmIChydW5zdGF0ZV9pc19ydW5u aW5nKCkpIHsKPiArICAgICAgICAgICAgU2h1dGRvd25DYXVzZSByZXF1ZXN0Owo+ICsKPiAgICAg ICAgICAgICAgaWYgKHFlbXVfc2h1dGRvd25fcmVxdWVzdGVkX2dldCgpKSB7Cj4gICAgICAgICAg ICAgICAgICBkZXN0cm95X2h2bV9kb21haW4oZmFsc2UpOwo+ICAgICAgICAgICAgICB9Cj4gLSAg ICAgICAgICAgIGlmIChxZW11X3Jlc2V0X3JlcXVlc3RlZF9nZXQoKSkgewo+IC0gICAgICAgICAg ICAgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9SRVBPUlQpOwo+ICsgICAgICAgICAgICBy ZXF1ZXN0ID0gcWVtdV9yZXNldF9yZXF1ZXN0ZWRfZ2V0KCk7Cj4gKyAgICAgICAgICAgIGlmIChy ZXF1ZXN0KSB7Cj4gKyAgICAgICAgICAgICAgICBxZW11X3N5c3RlbV9yZXNldChWTVJFU0VUX1JF UE9SVCwgcmVxdWVzdCk7Cj4gICAgICAgICAgICAgICAgICBkZXN0cm95X2h2bV9kb21haW4odHJ1 ZSk7Cj4gICAgICAgICAgICAgIH0KPiAgICAgICAgICB9Cj4gZGlmZiAtLWdpdCBhL21pZ3JhdGlv bi9jb2xvLmMgYi9taWdyYXRpb24vY29sby5jCj4gaW5kZXggOTYzYzgwMi4uYmY1YjdlOSAxMDA2 NDQKPiAtLS0gYS9taWdyYXRpb24vY29sby5jCj4gKysrIGIvbWlncmF0aW9uL2NvbG8uYwo+IEBA IC02MjMsNyArNjIzLDcgQEAgdm9pZCAqY29sb19wcm9jZXNzX2luY29taW5nX3RocmVhZCh2b2lk ICpvcGFxdWUpCj4gICAgICAgICAgfQo+Cj4gICAgICAgICAgcWVtdV9tdXRleF9sb2NrX2lvdGhy ZWFkKCk7Cj4gLSAgICAgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9TSUxFTlQpOwo+ICsg ICAgICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfU0lMRU5ULCBTSFVURE9XTl9DQVVTRV9O T05FKTsKPiAgICAgICAgICB2bXN0YXRlX2xvYWRpbmcgPSB0cnVlOwo+ICAgICAgICAgIGlmIChx ZW11X2xvYWR2bV9zdGF0ZShmYikgPCAwKSB7Cj4gICAgICAgICAgICAgIGVycm9yX3JlcG9ydCgi Q09MTzogbG9hZHZtIGZhaWxlZCIpOwo+IGRpZmYgLS1naXQgYS9taWdyYXRpb24vc2F2ZXZtLmMg Yi9taWdyYXRpb24vc2F2ZXZtLmMKPiBpbmRleCBhMDBjMWFiLi45YWMyZDIyIDEwMDY0NAo+IC0t LSBhL21pZ3JhdGlvbi9zYXZldm0uYwo+ICsrKyBiL21pZ3JhdGlvbi9zYXZldm0uYwo+IEBAIC0y MzAwLDcgKzIzMDAsNyBAQCBpbnQgbG9hZF92bXN0YXRlKGNvbnN0IGNoYXIgKm5hbWUpCj4gICAg ICAgICAgcmV0dXJuIC1FSU5WQUw7Cj4gICAgICB9Cj4KPiAtICAgIHFlbXVfc3lzdGVtX3Jlc2V0 KFZNUkVTRVRfU0lMRU5UKTsKPiArICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfU0lMRU5U LCBTSFVURE9XTl9DQVVTRV9OT05FKTsKPiAgICAgIG1pcy0+ZnJvbV9zcmNfZmlsZSA9IGY7Cj4K PiAgICAgIGFpb19jb250ZXh0X2FjcXVpcmUoYWlvX2NvbnRleHQpOwoKWW91IHNlZW0gdG8gYmUg cGFzc2luZyBTSFVURE9XTl9DQVVTRV9OT05FIGV4YWN0bHkgd2l0aCBWTVJFU0VUX1NJTEVOVC4K V291bGQgaXQgYmUgcG9zc2libGUgdG8gaGF2ZSBTSFVURE9XTl9DQVVTRV9OT05FIGltcGx5ICFy ZXBvcnQsIGFueQpvdGhlciBjYXNlIGltcGx5IHJlcG9ydCwgYW5kIGdldCByaWQgb2YgdGhlIGZp cnN0IHBhcmFtZXRlcj8KCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0 cHM6Ly9saXN0cy54ZW4ub3JnL3hlbi1kZXZlbAo=