From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:56835) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1d3vPm-0006VP-Bx for qemu-devel@nongnu.org; Thu, 27 Apr 2017 22:13:47 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1d3vPk-0001v2-U6 for qemu-devel@nongnu.org; Thu, 27 Apr 2017 22:13:46 -0400 Received: from mx1.redhat.com ([209.132.183.28]:49756) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1d3vPk-0001u4-Kn for qemu-devel@nongnu.org; Thu, 27 Apr 2017 22:13:44 -0400 From: Eric Blake Date: Thu, 27 Apr 2017 21:13:15 -0500 Message-Id: <20170428021317.24711-3-eblake@redhat.com> In-Reply-To: <20170428021317.24711-1-eblake@redhat.com> References: <20170428021317.24711-1-eblake@redhat.com> Subject: [Qemu-devel] [PATCH v5 2/4] shutdown: Prepare for use of an enum in reset/shutdown_request List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org Cc: armbru@redhat.com, berrange@redhat.com, alistair.francis@xilinx.com, Stefano Stabellini , Anthony Perard , "Michael S. Tsirkin" , Paolo Bonzini , Richard Henderson , Eduardo Habkost , zhanghailiang , Juan Quintela , "Dr. David Alan Gilbert" , "open list:X86" 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 a QAPI 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 next patch will 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. Since QAPI generates enums starting at 0, it's easier if we use a different number as our sentinel that no request has happened yet. Most of the changes are in vl.c, but xen was using things externally. Signed-off-by: Eric Blake --- v4: s/ShutdownType/ShutdownCause/, no thanks to mingw header pollution v3: new patch --- qapi-schema.json | 23 +++++++++++++++++++++++ include/sysemu/sysemu.h | 2 +- vl.c | 44 ++++++++++++++++++++++++++++---------------- hw/i386/xen/xen-hvm.c | 9 ++++++--- migration/colo.c | 2 +- migration/savevm.c | 2 +- 6 files changed, 60 insertions(+), 22 deletions(-) diff --git a/qapi-schema.json b/qapi-schema.json index 01b087f..a4ebdd1 100644 --- a/qapi-schema.json +++ b/qapi-schema.json @@ -2304,6 +2304,29 @@ { 'command': 'system_powerdown' } ## +# @ShutdownCause: +# +# Enumeration of various causes for shutdown. +# +# @host-qmp: Reaction to a QMP command, such as 'quit' +# @host-signal: Reaction to a signal, such as SIGINT +# @host-ui: Reaction to a UI event, such as closing the window +# @host-replay: The host is replaying an earlier shutdown event +# @host-error: Qemu encountered an error that prevents further use of the guest +# @guest-shutdown: The guest requested a shutdown, such as via ACPI or +# other hardware-specific action +# @guest-reset: The guest requested a reset, and the command line +# response to a reset is to instead trigger a shutdown +# @guest-panic: The guest panicked, and the command line response to +# a panic is to trigger a shutdown +# +# Since: 2.10 +## +{ 'enum': 'ShutdownCause', + 'data': [ 'host-qmp', 'host-signal', 'host-ui', 'host-replay', 'host-error', + 'guest-shutdown', 'guest-reset', 'guest-panic' ] } + +## # @cpu: # # This command is a nop that is only provided for the purposes of compatibility. diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h index 16175f7..00a907f 100644 --- a/include/sysemu/sysemu.h +++ b/include/sysemu/sysemu.h @@ -65,7 +65,7 @@ bool qemu_vmstop_requested(RunState *r); int qemu_shutdown_requested_get(void); int 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, int reason); void qemu_system_guest_panicked(GuestPanicInformation *info); size_t qemu_target_page_size(void); diff --git a/vl.c b/vl.c index 879786a..2b95b7f 100644 --- a/vl.c +++ b/vl.c @@ -1597,8 +1597,8 @@ void vm_state_notify(int running, RunState state) } } -static int reset_requested; -static int shutdown_requested, shutdown_signal; +static int reset_requested = -1; +static int shutdown_requested = -1, shutdown_signal; static pid_t shutdown_pid; static int powerdown_requested; static int debug_requested; @@ -1624,7 +1624,7 @@ int qemu_reset_requested_get(void) static int qemu_shutdown_requested(void) { - return atomic_xchg(&shutdown_requested, 0); + return atomic_xchg(&shutdown_requested, -1); } static void qemu_kill_report(void) @@ -1650,11 +1650,11 @@ static void qemu_kill_report(void) static int qemu_reset_requested(void) { int r = reset_requested; - if (r && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) { - reset_requested = 0; + if (r >= 0 && replay_checkpoint(CHECKPOINT_RESET_REQUESTED)) { + reset_requested = -1; return r; } - return false; + return -1; } static int qemu_suspend_requested(void) @@ -1686,7 +1686,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 ShutdownType for details. Otherwise, + * @report is VMRESET_SILENT and @reason is ignored. + */ +void qemu_system_reset(bool report, int reason) { MachineClass *mc; @@ -1700,6 +1705,7 @@ void qemu_system_reset(bool report) qemu_devices_reset(); } if (report) { + assert(reason >= 0); qapi_event_send_reset(&error_abort); } cpu_synchronize_all_post_reset(); @@ -1738,9 +1744,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_GUEST_RESET; } else { - reset_requested = 1; + reset_requested = SHUTDOWN_CAUSE_GUEST_RESET; } cpu_stop_current(); qemu_notify_event(); @@ -1807,7 +1814,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; qemu_notify_event(); } @@ -1815,7 +1822,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_GUEST_SHUTDOWN; qemu_notify_event(); } @@ -1846,13 +1854,16 @@ void qemu_system_debug_request(void) static bool main_loop_should_exit(void) { RunState r; + int 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 >= 0) { qemu_kill_report(); qapi_event_send_shutdown(&error_abort); if (no_shutdown) { @@ -1861,9 +1872,10 @@ static bool main_loop_should_exit(void) return true; } } - if (qemu_reset_requested()) { + request = qemu_reset_requested(); + if (request >= 0) { 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 +1884,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, -1); notifier_list_notify(&wakeup_notifiers, &wakeup_reason); wakeup_reason = QEMU_WAKEUP_REASON_NONE; resume_all_vcpus(); @@ -4684,7 +4696,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, -1); 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..3a6484c 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()) { - if (qemu_shutdown_requested_get()) { + int request; + + if (qemu_shutdown_requested_get() >= 0) { destroy_hvm_domain(false); } - if (qemu_reset_requested_get()) { - qemu_system_reset(VMRESET_REPORT); + request = qemu_reset_requested_get(); + if (request >= 0) { + qemu_system_reset(VMRESET_REPORT, request); destroy_hvm_domain(true); } } diff --git a/migration/colo.c b/migration/colo.c index c19eb3f..17a5482 100644 --- a/migration/colo.c +++ b/migration/colo.c @@ -611,7 +611,7 @@ void *colo_process_incoming_thread(void *opaque) } qemu_mutex_lock_iothread(); - qemu_system_reset(VMRESET_SILENT); + qemu_system_reset(VMRESET_SILENT, -1); 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 03ae1bd..dcbaf00 100644 --- a/migration/savevm.c +++ b/migration/savevm.c @@ -2292,7 +2292,7 @@ int load_vmstate(const char *name) return -EINVAL; } - qemu_system_reset(VMRESET_SILENT); + qemu_system_reset(VMRESET_SILENT, -1); mis->from_src_file = f; aio_context_acquire(aio_context); -- 2.9.3 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Eric Blake Subject: [PATCH v5 2/4] shutdown: Prepare for use of an enum in reset/shutdown_request Date: Thu, 27 Apr 2017 21:13:15 -0500 Message-ID: <20170428021317.24711-3-eblake@redhat.com> References: <20170428021317.24711-1-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 1d3vPo-0000VY-5O for xen-devel@lists.xenproject.org; Fri, 28 Apr 2017 02:13:48 +0000 In-Reply-To: <20170428021317.24711-1-eblake@redhat.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: qemu-devel@nongnu.org Cc: Stefano Stabellini , berrange@redhat.com, Eduardo Habkost , "Michael S. Tsirkin" , Juan Quintela , armbru@redhat.com, alistair.francis@xilinx.com, zhanghailiang , "open list:X86" , Anthony Perard , Paolo Bonzini , "Dr. David Alan Gilbert" , Richard Henderson List-Id: xen-devel@lists.xenproject.org V2Ugd2FudCB0byB0cmFjayB3aHkgYSBndWVzdCB3YXMgc2h1dGRvd247IGluIHBhcnRpY3VsYXIs IGJlaW5nIGFibGUKdG8gdGVsbCB0aGUgZGlmZmVyZW5jZSBiZXR3ZWVuIGEgZ3Vlc3QgcmVxdWVz dCAoc3VjaCBhcyBBQ1BJIHJlcXVlc3QpCmFuZCBob3N0IHJlcXVlc3QgKHN1Y2ggYXMgU0lHSU5U KSB3aWxsIHByb3ZlIHVzZWZ1bCB0byBsaWJ2aXJ0LgpTaW5jZSBhbGwgcmVxdWVzdHMgZXZlbnR1 YWxseSBlbmQgdXAgY2hhbmdpbmcgc2h1dGRvd25fcmVxdWVzdGVkIGluCnZsLmMsIHRoZSBsb2dp Y2FsIGNoYW5nZSBpcyB0byBtYWtlIHRoYXQgdmFsdWUgdHJhY2sgdGhlIHJlYXNvbiwKcmF0aGVy IHRoYW4gaXRzIGN1cnJlbnQgMC8xIGNvbnRlbnRzLgoKU2luY2UgY29tbWFuZC1saW5lIG9wdGlv bnMgY29udHJvbCB3aGV0aGVyIGEgcmVzZXQgcmVxdWVzdCBpcyB0dXJuZWQKaW50byBhIHNodXRk b3duIHJlcXVlc3QgaW5zdGVhZCwgdGhlIHNhbWUgdHJlYXRtZW50IGlzIGdpdmVuIHRvCnJlc2V0 X3JlcXVlc3RlZC4KClRoaXMgcGF0Y2ggYWRkcyBhIFFBUEkgZW51bSBTaHV0ZG93bkNhdXNlIHRo YXQgZGVzY3JpYmVzIHJlYXNvbnMKdGhhdCBhIHNodXRkb3duIGNhbiBiZSByZXF1ZXN0ZWQsIGFu ZCBjaGFuZ2VzIHFlbXVfc3lzdGVtX3Jlc2V0KCkgdG8KcGFzcyB0aGUgcmVhc29uIHRocm91Z2gs IGFsdGhvdWdoIGZvciBub3cgaXQgaXMgbm90IHJlcG9ydGVkLiAgVGhlCm5leHQgcGF0Y2ggd2ls bCBhY3R1YWxseSB3aXJlIHRoaW5ncyB1cCB0byBtb2RpZnkgZXZlbnRzIHRvIHJlcG9ydApkYXRh IGJhc2VkIG9uIHRoZSByZWFzb24sIGFuZCB0byBwYXNzIHRoZSBjb3JyZWN0IGVudW0gdmFsdWUg aW4gZnJvbQp2YXJpb3VzIGNhbGwtc2l0ZXMgdGhhdCBjYW4gdHJpZ2dlciBhIHJlc2V0L3NodXRk b3duLiAgU2luY2UgUUFQSQpnZW5lcmF0ZXMgZW51bXMgc3RhcnRpbmcgYXQgMCwgaXQncyBlYXNp ZXIgaWYgd2UgdXNlIGEgZGlmZmVyZW50Cm51bWJlciBhcyBvdXIgc2VudGluZWwgdGhhdCBubyBy ZXF1ZXN0IGhhcyBoYXBwZW5lZCB5ZXQuICBNb3N0IG9mCnRoZSBjaGFuZ2VzIGFyZSBpbiB2bC5j LCBidXQgeGVuIHdhcyB1c2luZyB0aGluZ3MgZXh0ZXJuYWxseS4KClNpZ25lZC1vZmYtYnk6IEVy aWMgQmxha2UgPGVibGFrZUByZWRoYXQuY29tPgoKLS0tCnY0OiBzL1NodXRkb3duVHlwZS9TaHV0 ZG93bkNhdXNlLywgbm8gdGhhbmtzIHRvIG1pbmd3IGhlYWRlciBwb2xsdXRpb24KdjM6IG5ldyBw YXRjaAotLS0KIHFhcGktc2NoZW1hLmpzb24gICAgICAgIHwgMjMgKysrKysrKysrKysrKysrKysr KysrKysKIGluY2x1ZGUvc3lzZW11L3N5c2VtdS5oIHwgIDIgKy0KIHZsLmMgICAgICAgICAgICAg ICAgICAgIHwgNDQgKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0tLS0tLS0K IGh3L2kzODYveGVuL3hlbi1odm0uYyAgIHwgIDkgKysrKysrLS0tCiBtaWdyYXRpb24vY29sby5j ICAgICAgICB8ICAyICstCiBtaWdyYXRpb24vc2F2ZXZtLmMgICAgICB8ICAyICstCiA2IGZpbGVz IGNoYW5nZWQsIDYwIGluc2VydGlvbnMoKyksIDIyIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L3FhcGktc2NoZW1hLmpzb24gYi9xYXBpLXNjaGVtYS5qc29uCmluZGV4IDAxYjA4N2YuLmE0ZWJk ZDEgMTAwNjQ0Ci0tLSBhL3FhcGktc2NoZW1hLmpzb24KKysrIGIvcWFwaS1zY2hlbWEuanNvbgpA QCAtMjMwNCw2ICsyMzA0LDI5IEBACiB7ICdjb21tYW5kJzogJ3N5c3RlbV9wb3dlcmRvd24nIH0K CiAjIworIyBAU2h1dGRvd25DYXVzZToKKyMKKyMgRW51bWVyYXRpb24gb2YgdmFyaW91cyBjYXVz ZXMgZm9yIHNodXRkb3duLgorIworIyBAaG9zdC1xbXA6IFJlYWN0aW9uIHRvIGEgUU1QIGNvbW1h bmQsIHN1Y2ggYXMgJ3F1aXQnCisjIEBob3N0LXNpZ25hbDogUmVhY3Rpb24gdG8gYSBzaWduYWws IHN1Y2ggYXMgU0lHSU5UCisjIEBob3N0LXVpOiBSZWFjdGlvbiB0byBhIFVJIGV2ZW50LCBzdWNo IGFzIGNsb3NpbmcgdGhlIHdpbmRvdworIyBAaG9zdC1yZXBsYXk6IFRoZSBob3N0IGlzIHJlcGxh eWluZyBhbiBlYXJsaWVyIHNodXRkb3duIGV2ZW50CisjIEBob3N0LWVycm9yOiBRZW11IGVuY291 bnRlcmVkIGFuIGVycm9yIHRoYXQgcHJldmVudHMgZnVydGhlciB1c2Ugb2YgdGhlIGd1ZXN0Cisj IEBndWVzdC1zaHV0ZG93bjogVGhlIGd1ZXN0IHJlcXVlc3RlZCBhIHNodXRkb3duLCBzdWNoIGFz IHZpYSBBQ1BJIG9yCisjICAgICAgICAgICAgICAgICAgb3RoZXIgaGFyZHdhcmUtc3BlY2lmaWMg YWN0aW9uCisjIEBndWVzdC1yZXNldDogVGhlIGd1ZXN0IHJlcXVlc3RlZCBhIHJlc2V0LCBhbmQg dGhlIGNvbW1hbmQgbGluZQorIyAgICAgICAgICAgICAgIHJlc3BvbnNlIHRvIGEgcmVzZXQgaXMg dG8gaW5zdGVhZCB0cmlnZ2VyIGEgc2h1dGRvd24KKyMgQGd1ZXN0LXBhbmljOiBUaGUgZ3Vlc3Qg cGFuaWNrZWQsIGFuZCB0aGUgY29tbWFuZCBsaW5lIHJlc3BvbnNlIHRvCisjICAgICAgICAgICAg ICAgYSBwYW5pYyBpcyB0byB0cmlnZ2VyIGEgc2h1dGRvd24KKyMKKyMgU2luY2U6IDIuMTAKKyMj Cit7ICdlbnVtJzogJ1NodXRkb3duQ2F1c2UnLAorICAnZGF0YSc6IFsgJ2hvc3QtcW1wJywgJ2hv c3Qtc2lnbmFsJywgJ2hvc3QtdWknLCAnaG9zdC1yZXBsYXknLCAnaG9zdC1lcnJvcicsCisgICAg ICAgICAgICAnZ3Vlc3Qtc2h1dGRvd24nLCAnZ3Vlc3QtcmVzZXQnLCAnZ3Vlc3QtcGFuaWMnIF0g fQorCisjIwogIyBAY3B1OgogIwogIyBUaGlzIGNvbW1hbmQgaXMgYSBub3AgdGhhdCBpcyBvbmx5 IHByb3ZpZGVkIGZvciB0aGUgcHVycG9zZXMgb2YgY29tcGF0aWJpbGl0eS4KZGlmZiAtLWdpdCBh L2luY2x1ZGUvc3lzZW11L3N5c2VtdS5oIGIvaW5jbHVkZS9zeXNlbXUvc3lzZW11LmgKaW5kZXgg MTYxNzVmNy4uMDBhOTA3ZiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9zeXNlbXUvc3lzZW11LmgKKysr IGIvaW5jbHVkZS9zeXNlbXUvc3lzZW11LmgKQEAgLTY1LDcgKzY1LDcgQEAgYm9vbCBxZW11X3Zt c3RvcF9yZXF1ZXN0ZWQoUnVuU3RhdGUgKnIpOwogaW50IHFlbXVfc2h1dGRvd25fcmVxdWVzdGVk X2dldCh2b2lkKTsKIGludCBxZW11X3Jlc2V0X3JlcXVlc3RlZF9nZXQodm9pZCk7CiB2b2lkIHFl bXVfc3lzdGVtX2tpbGxlZChpbnQgc2lnbmFsLCBwaWRfdCBwaWQpOwotdm9pZCBxZW11X3N5c3Rl bV9yZXNldChib29sIHJlcG9ydCk7Cit2b2lkIHFlbXVfc3lzdGVtX3Jlc2V0KGJvb2wgcmVwb3J0 LCBpbnQgcmVhc29uKTsKIHZvaWQgcWVtdV9zeXN0ZW1fZ3Vlc3RfcGFuaWNrZWQoR3Vlc3RQYW5p Y0luZm9ybWF0aW9uICppbmZvKTsKIHNpemVfdCBxZW11X3RhcmdldF9wYWdlX3NpemUodm9pZCk7 CgpkaWZmIC0tZ2l0IGEvdmwuYyBiL3ZsLmMKaW5kZXggODc5Nzg2YS4uMmI5NWI3ZiAxMDA2NDQK LS0tIGEvdmwuYworKysgYi92bC5jCkBAIC0xNTk3LDggKzE1OTcsOCBAQCB2b2lkIHZtX3N0YXRl X25vdGlmeShpbnQgcnVubmluZywgUnVuU3RhdGUgc3RhdGUpCiAgICAgfQogfQoKLXN0YXRpYyBp bnQgcmVzZXRfcmVxdWVzdGVkOwotc3RhdGljIGludCBzaHV0ZG93bl9yZXF1ZXN0ZWQsIHNodXRk b3duX3NpZ25hbDsKK3N0YXRpYyBpbnQgcmVzZXRfcmVxdWVzdGVkID0gLTE7CitzdGF0aWMgaW50 IHNodXRkb3duX3JlcXVlc3RlZCA9IC0xLCBzaHV0ZG93bl9zaWduYWw7CiBzdGF0aWMgcGlkX3Qg c2h1dGRvd25fcGlkOwogc3RhdGljIGludCBwb3dlcmRvd25fcmVxdWVzdGVkOwogc3RhdGljIGlu dCBkZWJ1Z19yZXF1ZXN0ZWQ7CkBAIC0xNjI0LDcgKzE2MjQsNyBAQCBpbnQgcWVtdV9yZXNldF9y ZXF1ZXN0ZWRfZ2V0KHZvaWQpCgogc3RhdGljIGludCBxZW11X3NodXRkb3duX3JlcXVlc3RlZCh2 b2lkKQogewotICAgIHJldHVybiBhdG9taWNfeGNoZygmc2h1dGRvd25fcmVxdWVzdGVkLCAwKTsK KyAgICByZXR1cm4gYXRvbWljX3hjaGcoJnNodXRkb3duX3JlcXVlc3RlZCwgLTEpOwogfQoKIHN0 YXRpYyB2b2lkIHFlbXVfa2lsbF9yZXBvcnQodm9pZCkKQEAgLTE2NTAsMTEgKzE2NTAsMTEgQEAg c3RhdGljIHZvaWQgcWVtdV9raWxsX3JlcG9ydCh2b2lkKQogc3RhdGljIGludCBxZW11X3Jlc2V0 X3JlcXVlc3RlZCh2b2lkKQogewogICAgIGludCByID0gcmVzZXRfcmVxdWVzdGVkOwotICAgIGlm IChyICYmIHJlcGxheV9jaGVja3BvaW50KENIRUNLUE9JTlRfUkVTRVRfUkVRVUVTVEVEKSkgewot ICAgICAgICByZXNldF9yZXF1ZXN0ZWQgPSAwOworICAgIGlmIChyID49IDAgJiYgcmVwbGF5X2No ZWNrcG9pbnQoQ0hFQ0tQT0lOVF9SRVNFVF9SRVFVRVNURUQpKSB7CisgICAgICAgIHJlc2V0X3Jl cXVlc3RlZCA9IC0xOwogICAgICAgICByZXR1cm4gcjsKICAgICB9Ci0gICAgcmV0dXJuIGZhbHNl OworICAgIHJldHVybiAtMTsKIH0KCiBzdGF0aWMgaW50IHFlbXVfc3VzcGVuZF9yZXF1ZXN0ZWQo dm9pZCkKQEAgLTE2ODYsNyArMTY4NiwxMiBAQCBzdGF0aWMgaW50IHFlbXVfZGVidWdfcmVxdWVz dGVkKHZvaWQpCiAgICAgcmV0dXJuIHI7CiB9Cgotdm9pZCBxZW11X3N5c3RlbV9yZXNldChib29s IHJlcG9ydCkKKy8qCisgKiBSZXNldCB0aGUgVk0uIElmIEByZXBvcnQgaXMgVk1SRVNFVF9SRVBP UlQsIGlzc3VlIGFuIGV2ZW50LCB1c2luZworICogdGhlIEByZWFzb24gaW50ZXJwcmV0ZWQgYXMg U2h1dGRvd25UeXBlIGZvciBkZXRhaWxzLiAgT3RoZXJ3aXNlLAorICogQHJlcG9ydCBpcyBWTVJF U0VUX1NJTEVOVCBhbmQgQHJlYXNvbiBpcyBpZ25vcmVkLgorICovCit2b2lkIHFlbXVfc3lzdGVt X3Jlc2V0KGJvb2wgcmVwb3J0LCBpbnQgcmVhc29uKQogewogICAgIE1hY2hpbmVDbGFzcyAqbWM7 CgpAQCAtMTcwMCw2ICsxNzA1LDcgQEAgdm9pZCBxZW11X3N5c3RlbV9yZXNldChib29sIHJlcG9y dCkKICAgICAgICAgcWVtdV9kZXZpY2VzX3Jlc2V0KCk7CiAgICAgfQogICAgIGlmIChyZXBvcnQp IHsKKyAgICAgICAgYXNzZXJ0KHJlYXNvbiA+PSAwKTsKICAgICAgICAgcWFwaV9ldmVudF9zZW5k X3Jlc2V0KCZlcnJvcl9hYm9ydCk7CiAgICAgfQogICAgIGNwdV9zeW5jaHJvbml6ZV9hbGxfcG9z dF9yZXNldCgpOwpAQCAtMTczOCw5ICsxNzQ0LDEwIEBAIHZvaWQgcWVtdV9zeXN0ZW1fZ3Vlc3Rf cGFuaWNrZWQoR3Vlc3RQYW5pY0luZm9ybWF0aW9uICppbmZvKQogdm9pZCBxZW11X3N5c3RlbV9y ZXNldF9yZXF1ZXN0KHZvaWQpCiB7CiAgICAgaWYgKG5vX3JlYm9vdCkgewotICAgICAgICBzaHV0 ZG93bl9yZXF1ZXN0ZWQgPSAxOworICAgICAgICAvKiBGSVhNRSAtIGFkZCBhIHBhcmFtZXRlciB0 byBhbGxvdyBjYWxsZXJzIHRvIHNwZWNpZnkgcmVhc29uICovCisgICAgICAgIHNodXRkb3duX3Jl cXVlc3RlZCA9IFNIVVRET1dOX0NBVVNFX0dVRVNUX1JFU0VUOwogICAgIH0gZWxzZSB7Ci0gICAg ICAgIHJlc2V0X3JlcXVlc3RlZCA9IDE7CisgICAgICAgIHJlc2V0X3JlcXVlc3RlZCA9IFNIVVRE T1dOX0NBVVNFX0dVRVNUX1JFU0VUOwogICAgIH0KICAgICBjcHVfc3RvcF9jdXJyZW50KCk7CiAg ICAgcWVtdV9ub3RpZnlfZXZlbnQoKTsKQEAgLTE4MDcsNyArMTgxNCw3IEBAIHZvaWQgcWVtdV9z eXN0ZW1fa2lsbGVkKGludCBzaWduYWwsIHBpZF90IHBpZCkKICAgICAvKiBDYW5ub3QgY2FsbCBx ZW11X3N5c3RlbV9zaHV0ZG93bl9yZXF1ZXN0IGRpcmVjdGx5IGJlY2F1c2UKICAgICAgKiB3ZSBh cmUgaW4gYSBzaWduYWwgaGFuZGxlci4KICAgICAgKi8KLSAgICBzaHV0ZG93bl9yZXF1ZXN0ZWQg PSAxOworICAgIHNodXRkb3duX3JlcXVlc3RlZCA9IFNIVVRET1dOX0NBVVNFX0hPU1RfU0lHTkFM OwogICAgIHFlbXVfbm90aWZ5X2V2ZW50KCk7CiB9CgpAQCAtMTgxNSw3ICsxODIyLDggQEAgdm9p ZCBxZW11X3N5c3RlbV9zaHV0ZG93bl9yZXF1ZXN0KHZvaWQpCiB7CiAgICAgdHJhY2VfcWVtdV9z eXN0ZW1fc2h1dGRvd25fcmVxdWVzdCgpOwogICAgIHJlcGxheV9zaHV0ZG93bl9yZXF1ZXN0KCk7 Ci0gICAgc2h1dGRvd25fcmVxdWVzdGVkID0gMTsKKyAgICAvKiBGSVhNRSAtIGFkZCBhIHBhcmFt ZXRlciB0byBhbGxvdyBjYWxsZXJzIHRvIHNwZWNpZnkgcmVhc29uICovCisgICAgc2h1dGRvd25f cmVxdWVzdGVkID0gU0hVVERPV05fQ0FVU0VfR1VFU1RfU0hVVERPV047CiAgICAgcWVtdV9ub3Rp ZnlfZXZlbnQoKTsKIH0KCkBAIC0xODQ2LDEzICsxODU0LDE2IEBAIHZvaWQgcWVtdV9zeXN0ZW1f ZGVidWdfcmVxdWVzdCh2b2lkKQogc3RhdGljIGJvb2wgbWFpbl9sb29wX3Nob3VsZF9leGl0KHZv aWQpCiB7CiAgICAgUnVuU3RhdGUgcjsKKyAgICBpbnQgcmVxdWVzdDsKKwogICAgIGlmIChxZW11 X2RlYnVnX3JlcXVlc3RlZCgpKSB7CiAgICAgICAgIHZtX3N0b3AoUlVOX1NUQVRFX0RFQlVHKTsK ICAgICB9CiAgICAgaWYgKHFlbXVfc3VzcGVuZF9yZXF1ZXN0ZWQoKSkgewogICAgICAgICBxZW11 X3N5c3RlbV9zdXNwZW5kKCk7CiAgICAgfQotICAgIGlmIChxZW11X3NodXRkb3duX3JlcXVlc3Rl ZCgpKSB7CisgICAgcmVxdWVzdCA9IHFlbXVfc2h1dGRvd25fcmVxdWVzdGVkKCk7CisgICAgaWYg KHJlcXVlc3QgPj0gMCkgewogICAgICAgICBxZW11X2tpbGxfcmVwb3J0KCk7CiAgICAgICAgIHFh cGlfZXZlbnRfc2VuZF9zaHV0ZG93bigmZXJyb3JfYWJvcnQpOwogICAgICAgICBpZiAobm9fc2h1 dGRvd24pIHsKQEAgLTE4NjEsOSArMTg3MiwxMCBAQCBzdGF0aWMgYm9vbCBtYWluX2xvb3Bfc2hv dWxkX2V4aXQodm9pZCkKICAgICAgICAgICAgIHJldHVybiB0cnVlOwogICAgICAgICB9CiAgICAg fQotICAgIGlmIChxZW11X3Jlc2V0X3JlcXVlc3RlZCgpKSB7CisgICAgcmVxdWVzdCA9IHFlbXVf cmVzZXRfcmVxdWVzdGVkKCk7CisgICAgaWYgKHJlcXVlc3QgPj0gMCkgewogICAgICAgICBwYXVz ZV9hbGxfdmNwdXMoKTsKLSAgICAgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9SRVBPUlQp OworICAgICAgICBxZW11X3N5c3RlbV9yZXNldChWTVJFU0VUX1JFUE9SVCwgcmVxdWVzdCk7CiAg ICAgICAgIHJlc3VtZV9hbGxfdmNwdXMoKTsKICAgICAgICAgaWYgKCFydW5zdGF0ZV9jaGVjayhS VU5fU1RBVEVfUlVOTklORykgJiYKICAgICAgICAgICAgICAgICAhcnVuc3RhdGVfY2hlY2soUlVO X1NUQVRFX0lOTUlHUkFURSkpIHsKQEAgLTE4NzIsNyArMTg4NCw3IEBAIHN0YXRpYyBib29sIG1h aW5fbG9vcF9zaG91bGRfZXhpdCh2b2lkKQogICAgIH0KICAgICBpZiAocWVtdV93YWtldXBfcmVx dWVzdGVkKCkpIHsKICAgICAgICAgcGF1c2VfYWxsX3ZjcHVzKCk7Ci0gICAgICAgIHFlbXVfc3lz dGVtX3Jlc2V0KFZNUkVTRVRfU0lMRU5UKTsKKyAgICAgICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1S RVNFVF9TSUxFTlQsIC0xKTsKICAgICAgICAgbm90aWZpZXJfbGlzdF9ub3RpZnkoJndha2V1cF9u b3RpZmllcnMsICZ3YWtldXBfcmVhc29uKTsKICAgICAgICAgd2FrZXVwX3JlYXNvbiA9IFFFTVVf V0FLRVVQX1JFQVNPTl9OT05FOwogICAgICAgICByZXN1bWVfYWxsX3ZjcHVzKCk7CkBAIC00Njg0 LDcgKzQ2OTYsNyBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hhciAqKmFyZ3YsIGNoYXIgKiplbnZw KQogICAgICAgIHJlYWRpbmcgZnJvbSB0aGUgb3RoZXIgcmVhZHMsIGJlY2F1c2UgdGltZXIgcG9s bGluZyBmdW5jdGlvbnMgcXVlcnkKICAgICAgICBjbG9jayB2YWx1ZXMgZnJvbSB0aGUgbG9nLiAq LwogICAgIHJlcGxheV9jaGVja3BvaW50KENIRUNLUE9JTlRfUkVTRVQpOwotICAgIHFlbXVfc3lz dGVtX3Jlc2V0KFZNUkVTRVRfU0lMRU5UKTsKKyAgICBxZW11X3N5c3RlbV9yZXNldChWTVJFU0VU X1NJTEVOVCwgLTEpOwogICAgIHJlZ2lzdGVyX2dsb2JhbF9zdGF0ZSgpOwogICAgIGlmIChyZXBs YXlfbW9kZSAhPSBSRVBMQVlfTU9ERV9OT05FKSB7CiAgICAgICAgIHJlcGxheV92bXN0YXRlX2lu aXQoKTsKZGlmZiAtLWdpdCBhL2h3L2kzODYveGVuL3hlbi1odm0uYyBiL2h3L2kzODYveGVuL3hl bi1odm0uYwppbmRleCBiMWMwNWZmLi4zYTY0ODRjIDEwMDY0NAotLS0gYS9ody9pMzg2L3hlbi94 ZW4taHZtLmMKKysrIGIvaHcvaTM4Ni94ZW4veGVuLWh2bS5jCkBAIC0xMDg5LDExICsxMDg5LDE0 IEBAIHN0YXRpYyB2b2lkIGNwdV9oYW5kbGVfaW9yZXEodm9pZCAqb3BhcXVlKQogICAgICAgICAg KiBjYXVzZXMgWGVuIHRvIHBvd2VyZG93biB0aGUgZG9tYWluLgogICAgICAgICAgKi8KICAgICAg ICAgaWYgKHJ1bnN0YXRlX2lzX3J1bm5pbmcoKSkgewotICAgICAgICAgICAgaWYgKHFlbXVfc2h1 dGRvd25fcmVxdWVzdGVkX2dldCgpKSB7CisgICAgICAgICAgICBpbnQgcmVxdWVzdDsKKworICAg ICAgICAgICAgaWYgKHFlbXVfc2h1dGRvd25fcmVxdWVzdGVkX2dldCgpID49IDApIHsKICAgICAg ICAgICAgICAgICBkZXN0cm95X2h2bV9kb21haW4oZmFsc2UpOwogICAgICAgICAgICAgfQotICAg ICAgICAgICAgaWYgKHFlbXVfcmVzZXRfcmVxdWVzdGVkX2dldCgpKSB7Ci0gICAgICAgICAgICAg ICAgcWVtdV9zeXN0ZW1fcmVzZXQoVk1SRVNFVF9SRVBPUlQpOworICAgICAgICAgICAgcmVxdWVz dCA9IHFlbXVfcmVzZXRfcmVxdWVzdGVkX2dldCgpOworICAgICAgICAgICAgaWYgKHJlcXVlc3Qg Pj0gMCkgeworICAgICAgICAgICAgICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfUkVQT1JU LCByZXF1ZXN0KTsKICAgICAgICAgICAgICAgICBkZXN0cm95X2h2bV9kb21haW4odHJ1ZSk7CiAg ICAgICAgICAgICB9CiAgICAgICAgIH0KZGlmZiAtLWdpdCBhL21pZ3JhdGlvbi9jb2xvLmMgYi9t aWdyYXRpb24vY29sby5jCmluZGV4IGMxOWViM2YuLjE3YTU0ODIgMTAwNjQ0Ci0tLSBhL21pZ3Jh dGlvbi9jb2xvLmMKKysrIGIvbWlncmF0aW9uL2NvbG8uYwpAQCAtNjExLDcgKzYxMSw3IEBAIHZv aWQgKmNvbG9fcHJvY2Vzc19pbmNvbWluZ190aHJlYWQodm9pZCAqb3BhcXVlKQogICAgICAgICB9 CgogICAgICAgICBxZW11X211dGV4X2xvY2tfaW90aHJlYWQoKTsKLSAgICAgICAgcWVtdV9zeXN0 ZW1fcmVzZXQoVk1SRVNFVF9TSUxFTlQpOworICAgICAgICBxZW11X3N5c3RlbV9yZXNldChWTVJF U0VUX1NJTEVOVCwgLTEpOwogICAgICAgICB2bXN0YXRlX2xvYWRpbmcgPSB0cnVlOwogICAgICAg ICBpZiAocWVtdV9sb2Fkdm1fc3RhdGUoZmIpIDwgMCkgewogICAgICAgICAgICAgZXJyb3JfcmVw b3J0KCJDT0xPOiBsb2Fkdm0gZmFpbGVkIik7CmRpZmYgLS1naXQgYS9taWdyYXRpb24vc2F2ZXZt LmMgYi9taWdyYXRpb24vc2F2ZXZtLmMKaW5kZXggMDNhZTFiZC4uZGNiYWYwMCAxMDA2NDQKLS0t IGEvbWlncmF0aW9uL3NhdmV2bS5jCisrKyBiL21pZ3JhdGlvbi9zYXZldm0uYwpAQCAtMjI5Miw3 ICsyMjkyLDcgQEAgaW50IGxvYWRfdm1zdGF0ZShjb25zdCBjaGFyICpuYW1lKQogICAgICAgICBy ZXR1cm4gLUVJTlZBTDsKICAgICB9CgotICAgIHFlbXVfc3lzdGVtX3Jlc2V0KFZNUkVTRVRfU0lM RU5UKTsKKyAgICBxZW11X3N5c3RlbV9yZXNldChWTVJFU0VUX1NJTEVOVCwgLTEpOwogICAgIG1p cy0+ZnJvbV9zcmNfZmlsZSA9IGY7CgogICAgIGFpb19jb250ZXh0X2FjcXVpcmUoYWlvX2NvbnRl eHQpOwotLSAKMi45LjMKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW4ub3JnCmh0 dHBzOi8vbGlzdHMueGVuLm9yZy94ZW4tZGV2ZWwK