From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 587B2C433EF for ; Wed, 6 Oct 2021 17:41:15 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 45DDF6052B for ; Wed, 6 Oct 2021 17:41:15 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239491AbhJFRnC (ORCPT ); Wed, 6 Oct 2021 13:43:02 -0400 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:53736 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239175AbhJFRmi (ORCPT ); Wed, 6 Oct 2021 13:42:38 -0400 Received: from smtp.bitdefender.com (smtp01.buh.bitdefender.com [10.17.80.75]) by mx01.bbu.dsd.mx.bitdefender.com (Postfix) with ESMTPS id 645DF305D7F4; Wed, 6 Oct 2021 20:31:13 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 4A4A03064495; Wed, 6 Oct 2021 20:31:13 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Cc: virtualization@lists.linux-foundation.org, Paolo Bonzini , Sean Christopherson , Vitaly Kuznetsov , Wanpeng Li , Jim Mattson , Joerg Roedel , Mathieu Tarral , Tamas K Lengyel , =?UTF-8?q?Adalbert=20Laz=C4=83r?= Subject: [PATCH v12 47/77] KVM: introspection: add KVMI_VCPU_EVENT_PAUSE Date: Wed, 6 Oct 2021 20:30:43 +0300 Message-Id: <20211006173113.26445-48-alazar@bitdefender.com> In-Reply-To: <20211006173113.26445-1-alazar@bitdefender.com> References: <20211006173113.26445-1-alazar@bitdefender.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: kvm@vger.kernel.org This event is sent by the vCPU thread as a response to the KVMI_VM_PAUSE_VCPU command, but it has a lower priority, being sent after any other introspection event and when no other introspection command is queued. The number of KVMI_VCPU_EVENT_PAUSE will match the number of successful KVMI_VM_PAUSE_VCPU commands. Signed-off-by: Adalbert Lazăr --- Documentation/virt/kvm/kvmi.rst | 26 ++++++++ include/uapi/linux/kvmi.h | 2 + .../testing/selftests/kvm/x86_64/kvmi_test.c | 65 ++++++++++++++++++- virt/kvm/introspection/kvmi.c | 26 +++++++- virt/kvm/introspection/kvmi_int.h | 1 + virt/kvm/introspection/kvmi_msg.c | 18 +++++ 6 files changed, 136 insertions(+), 2 deletions(-) diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst index c46e870cc728..7f3daeb88886 100644 --- a/Documentation/virt/kvm/kvmi.rst +++ b/Documentation/virt/kvm/kvmi.rst @@ -596,3 +596,29 @@ the guest (see **Unhooking**) and the introspection has been enabled for this event (see **KVMI_VM_CONTROL_EVENTS**). The introspection tool has a chance to unhook and close the introspection socket (signaling that the operation can proceed). + +2. KVMI_VCPU_EVENT_PAUSE +------------------------ + +:Architectures: all +:Versions: >= 1 +:Actions: CONTINUE, CRASH +:Parameters: + +:: + + struct kvmi_event_hdr; + struct kvmi_vcpu_event; + +:Returns: + +:: + + struct kvmi_vcpu_hdr; + struct kvmi_vcpu_event_reply; + +This event is sent in response to a *KVMI_VCPU_PAUSE* command and +cannot be controlled with *KVMI_VCPU_CONTROL_EVENTS*. +Because it has a low priority, it will be sent after any other vCPU +introspection event and when no other vCPU introspection command is +queued. diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h index 6a57efb5664d..757d4b84f473 100644 --- a/include/uapi/linux/kvmi.h +++ b/include/uapi/linux/kvmi.h @@ -50,6 +50,8 @@ enum { }; enum { + KVMI_VCPU_EVENT_PAUSE = KVMI_VCPU_EVENT_ID(0), + KVMI_NEXT_VCPU_EVENT }; diff --git a/tools/testing/selftests/kvm/x86_64/kvmi_test.c b/tools/testing/selftests/kvm/x86_64/kvmi_test.c index f8d355aff5fa..9eb17d820a8b 100644 --- a/tools/testing/selftests/kvm/x86_64/kvmi_test.c +++ b/tools/testing/selftests/kvm/x86_64/kvmi_test.c @@ -34,6 +34,17 @@ static vm_paddr_t test_gpa; static int page_size; +struct vcpu_event { + struct kvmi_event_hdr hdr; + struct kvmi_vcpu_event common; +}; + +struct vcpu_reply { + struct kvmi_msg_hdr hdr; + struct kvmi_vcpu_hdr vcpu_hdr; + struct kvmi_vcpu_event_reply reply; +}; + struct vcpu_worker_data { struct kvm_vm *vm; int vcpu_id; @@ -704,14 +715,66 @@ static void pause_vcpu(void) cmd_vcpu_pause(1, 0); } +static void reply_to_event(struct kvmi_msg_hdr *ev_hdr, struct vcpu_event *ev, + __u8 action, struct vcpu_reply *rpl, size_t rpl_size) +{ + ssize_t r; + + rpl->hdr.id = ev_hdr->id; + rpl->hdr.seq = ev_hdr->seq; + rpl->hdr.size = rpl_size - sizeof(rpl->hdr); + + rpl->vcpu_hdr.vcpu = ev->common.vcpu; + + rpl->reply.action = action; + rpl->reply.event = ev->hdr.event; + + r = send(Userspace_socket, rpl, rpl_size, 0); + TEST_ASSERT(r == rpl_size, + "send() failed, sending %zd, result %zd, errno %d (%s)\n", + rpl_size, r, errno, strerror(errno)); +} + +static void receive_vcpu_event(struct kvmi_msg_hdr *msg_hdr, + struct vcpu_event *ev, + size_t ev_size, u16 ev_id) +{ + receive_event(msg_hdr, KVMI_VCPU_EVENT, + &ev->hdr, ev_id, ev_size); +} + +static void discard_pause_event(struct kvm_vm *vm) +{ + struct vcpu_worker_data data = {.vm = vm, .vcpu_id = VCPU_ID}; + struct vcpu_reply rpl = {}; + struct kvmi_msg_hdr hdr; + pthread_t vcpu_thread; + struct vcpu_event ev; + + vcpu_thread = start_vcpu_worker(&data); + + receive_vcpu_event(&hdr, &ev, sizeof(ev), KVMI_VCPU_EVENT_PAUSE); + + reply_to_event(&hdr, &ev, KVMI_EVENT_ACTION_CONTINUE, + &rpl, sizeof(rpl)); + + wait_vcpu_worker(vcpu_thread); +} + static void test_pause(struct kvm_vm *vm) { - __u8 wait = 1, wait_inval = 2; + __u8 no_wait = 0, wait = 1, wait_inval = 2; pause_vcpu(); + discard_pause_event(vm); cmd_vcpu_pause(wait, 0); + discard_pause_event(vm); cmd_vcpu_pause(wait_inval, -KVM_EINVAL); + + disallow_event(vm, KVMI_VCPU_EVENT_PAUSE); + cmd_vcpu_pause(no_wait, -KVM_EPERM); + allow_event(vm, KVMI_VCPU_EVENT_PAUSE); } static void test_introspection(struct kvm_vm *vm) diff --git a/virt/kvm/introspection/kvmi.c b/virt/kvm/introspection/kvmi.c index 26ab5b8526d1..39c43b8a127d 100644 --- a/virt/kvm/introspection/kvmi.c +++ b/virt/kvm/introspection/kvmi.c @@ -103,6 +103,7 @@ static void kvmi_init_known_events(void) bitmap_zero(Kvmi_known_vcpu_events, KVMI_NUM_EVENTS); kvmi_arch_init_vcpu_events_mask(Kvmi_known_vcpu_events); + set_bit(KVMI_VCPU_EVENT_PAUSE, Kvmi_known_vcpu_events); bitmap_or(Kvmi_known_events, Kvmi_known_vm_events, Kvmi_known_vcpu_events, KVMI_NUM_EVENTS); @@ -741,12 +742,35 @@ void kvmi_run_jobs(struct kvm_vcpu *vcpu) } } +static void kvmi_handle_unsupported_event_action(struct kvm *kvm) +{ + kvmi_sock_shutdown(KVMI(kvm)); +} + +void kvmi_handle_common_event_actions(struct kvm_vcpu *vcpu, u32 action) +{ + struct kvm *kvm = vcpu->kvm; + + switch (action) { + default: + kvmi_handle_unsupported_event_action(kvm); + } +} + static void kvmi_vcpu_pause_event(struct kvm_vcpu *vcpu) { struct kvm_vcpu_introspection *vcpui = VCPUI(vcpu); + u32 action; atomic_dec(&vcpui->pause_requests); - /* to be implemented */ + + action = kvmi_msg_send_vcpu_pause(vcpu); + switch (action) { + case KVMI_EVENT_ACTION_CONTINUE: + break; + default: + kvmi_handle_common_event_actions(vcpu, action); + } } void kvmi_handle_requests(struct kvm_vcpu *vcpu) diff --git a/virt/kvm/introspection/kvmi_int.h b/virt/kvm/introspection/kvmi_int.h index 65d8c1c37796..0876740dfa24 100644 --- a/virt/kvm/introspection/kvmi_int.h +++ b/virt/kvm/introspection/kvmi_int.h @@ -38,6 +38,7 @@ int kvmi_send_vcpu_event(struct kvm_vcpu *vcpu, u32 ev_id, int kvmi_msg_vcpu_reply(const struct kvmi_vcpu_msg_job *job, const struct kvmi_msg_hdr *msg, int err, const void *rpl, size_t rpl_size); +u32 kvmi_msg_send_vcpu_pause(struct kvm_vcpu *vcpu); /* kvmi.c */ void *kvmi_msg_alloc(void); diff --git a/virt/kvm/introspection/kvmi_msg.c b/virt/kvm/introspection/kvmi_msg.c index 894610e7e5cb..447105a82eff 100644 --- a/virt/kvm/introspection/kvmi_msg.c +++ b/virt/kvm/introspection/kvmi_msg.c @@ -258,6 +258,11 @@ static int handle_vm_pause_vcpu(struct kvm_introspection *kvmi, goto reply; } + if (!kvmi_is_event_allowed(kvmi, KVMI_VCPU_EVENT_PAUSE)) { + ec = -KVM_EPERM; + goto reply; + } + vcpu = kvmi_get_vcpu(kvmi, req->vcpu); if (!vcpu) ec = -KVM_EINVAL; @@ -702,3 +707,16 @@ int kvmi_send_vcpu_event(struct kvm_vcpu *vcpu, u32 ev_id, return err; } + +u32 kvmi_msg_send_vcpu_pause(struct kvm_vcpu *vcpu) +{ + u32 action; + int err; + + err = kvmi_send_vcpu_event(vcpu, KVMI_VCPU_EVENT_PAUSE, NULL, 0, + NULL, 0, &action); + if (err) + return KVMI_EVENT_ACTION_CONTINUE; + + return action; +} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 628B7C4332F for ; Wed, 6 Oct 2021 17:40:58 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [140.211.166.136]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 1F36F6052B for ; Wed, 6 Oct 2021 17:40:58 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 1F36F6052B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=bitdefender.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=lists.linux-foundation.org Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id 9414160F09; Wed, 6 Oct 2021 17:40:56 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id jqQr_jU8JpGy; Wed, 6 Oct 2021 17:40:55 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTPS id 1823C60F14; Wed, 6 Oct 2021 17:40:55 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id BBA30C0026; Wed, 6 Oct 2021 17:40:53 +0000 (UTC) Received: from smtp3.osuosl.org (smtp3.osuosl.org [IPv6:2605:bc80:3010::136]) by lists.linuxfoundation.org (Postfix) with ESMTP id 1373EC0032 for ; Wed, 6 Oct 2021 17:40:48 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp3.osuosl.org (Postfix) with ESMTP id 1CA4060EE9 for ; Wed, 6 Oct 2021 17:40:47 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp3.osuosl.org ([127.0.0.1]) by localhost (smtp3.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id Df89R_CzTrOX for ; Wed, 6 Oct 2021 17:40:45 +0000 (UTC) X-Greylist: from auto-whitelisted by SQLgrey-1.8.0 Received: from mx01.bbu.dsd.mx.bitdefender.com (mx01.bbu.dsd.mx.bitdefender.com [91.199.104.161]) by smtp3.osuosl.org (Postfix) with ESMTPS id E38C360EEB for ; Wed, 6 Oct 2021 17:40:44 +0000 (UTC) Received: from smtp.bitdefender.com (smtp01.buh.bitdefender.com [10.17.80.75]) by mx01.bbu.dsd.mx.bitdefender.com (Postfix) with ESMTPS id 645DF305D7F4; Wed, 6 Oct 2021 20:31:13 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 4A4A03064495; Wed, 6 Oct 2021 20:31:13 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Subject: [PATCH v12 47/77] KVM: introspection: add KVMI_VCPU_EVENT_PAUSE Date: Wed, 6 Oct 2021 20:30:43 +0300 Message-Id: <20211006173113.26445-48-alazar@bitdefender.com> In-Reply-To: <20211006173113.26445-1-alazar@bitdefender.com> References: <20211006173113.26445-1-alazar@bitdefender.com> MIME-Version: 1.0 Cc: Tamas K Lengyel , Wanpeng Li , Sean Christopherson , Joerg Roedel , virtualization@lists.linux-foundation.org, =?UTF-8?q?Adalbert=20Laz=C4=83r?= , Mathieu Tarral , Paolo Bonzini , Jim Mattson X-BeenThere: virtualization@lists.linux-foundation.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Linux virtualization List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" VGhpcyBldmVudCBpcyBzZW50IGJ5IHRoZSB2Q1BVIHRocmVhZCBhcyBhIHJlc3BvbnNlIHRvIHRo ZQpLVk1JX1ZNX1BBVVNFX1ZDUFUgY29tbWFuZCwgYnV0IGl0IGhhcyBhIGxvd2VyIHByaW9yaXR5 LCBiZWluZyBzZW50CmFmdGVyIGFueSBvdGhlciBpbnRyb3NwZWN0aW9uIGV2ZW50IGFuZCB3aGVu IG5vIG90aGVyIGludHJvc3BlY3Rpb24KY29tbWFuZCBpcyBxdWV1ZWQuCgpUaGUgbnVtYmVyIG9m IEtWTUlfVkNQVV9FVkVOVF9QQVVTRSB3aWxsIG1hdGNoIHRoZSBudW1iZXIgb2Ygc3VjY2Vzc2Z1 bApLVk1JX1ZNX1BBVVNFX1ZDUFUgY29tbWFuZHMuCgpTaWduZWQtb2ZmLWJ5OiBBZGFsYmVydCBM YXrEg3IgPGFsYXphckBiaXRkZWZlbmRlci5jb20+Ci0tLQogRG9jdW1lbnRhdGlvbi92aXJ0L2t2 bS9rdm1pLnJzdCAgICAgICAgICAgICAgIHwgMjYgKysrKysrKysKIGluY2x1ZGUvdWFwaS9saW51 eC9rdm1pLmggICAgICAgICAgICAgICAgICAgICB8ICAyICsKIC4uLi90ZXN0aW5nL3NlbGZ0ZXN0 cy9rdm0veDg2XzY0L2t2bWlfdGVzdC5jICB8IDY1ICsrKysrKysrKysrKysrKysrKy0KIHZpcnQv a3ZtL2ludHJvc3BlY3Rpb24va3ZtaS5jICAgICAgICAgICAgICAgICB8IDI2ICsrKysrKystCiB2 aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlfaW50LmggICAgICAgICAgICAgfCAgMSArCiB2aXJ0 L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlfbXNnLmMgICAgICAgICAgICAgfCAxOCArKysrKwogNiBm aWxlcyBjaGFuZ2VkLCAxMzYgaW5zZXJ0aW9ucygrKSwgMiBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9Eb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2t2bWkucnN0IGIvRG9jdW1lbnRhdGlvbi92aXJ0 L2t2bS9rdm1pLnJzdAppbmRleCBjNDZlODcwY2M3MjguLjdmM2RhZWI4ODg4NiAxMDA2NDQKLS0t IGEvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9rdm1pLnJzdAorKysgYi9Eb2N1bWVudGF0aW9uL3Zp cnQva3ZtL2t2bWkucnN0CkBAIC01OTYsMyArNTk2LDI5IEBAIHRoZSBndWVzdCAoc2VlICoqVW5o b29raW5nKiopIGFuZCB0aGUgaW50cm9zcGVjdGlvbiBoYXMgYmVlbiBlbmFibGVkIGZvcgogdGhp cyBldmVudCAoc2VlICoqS1ZNSV9WTV9DT05UUk9MX0VWRU5UUyoqKS4gVGhlIGludHJvc3BlY3Rp b24gdG9vbCBoYXMKIGEgY2hhbmNlIHRvIHVuaG9vayBhbmQgY2xvc2UgdGhlIGludHJvc3BlY3Rp b24gc29ja2V0IChzaWduYWxpbmcgdGhhdAogdGhlIG9wZXJhdGlvbiBjYW4gcHJvY2VlZCkuCisK KzIuIEtWTUlfVkNQVV9FVkVOVF9QQVVTRQorLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKzpB cmNoaXRlY3R1cmVzOiBhbGwKKzpWZXJzaW9uczogPj0gMQorOkFjdGlvbnM6IENPTlRJTlVFLCBD UkFTSAorOlBhcmFtZXRlcnM6CisKKzo6CisKKwlzdHJ1Y3Qga3ZtaV9ldmVudF9oZHI7CisJc3Ry dWN0IGt2bWlfdmNwdV9ldmVudDsKKworOlJldHVybnM6CisKKzo6CisKKwlzdHJ1Y3Qga3ZtaV92 Y3B1X2hkcjsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3JlcGx5OworCitUaGlzIGV2ZW50IGlz IHNlbnQgaW4gcmVzcG9uc2UgdG8gYSAqS1ZNSV9WQ1BVX1BBVVNFKiBjb21tYW5kIGFuZAorY2Fu bm90IGJlIGNvbnRyb2xsZWQgd2l0aCAqS1ZNSV9WQ1BVX0NPTlRST0xfRVZFTlRTKi4KK0JlY2F1 c2UgaXQgaGFzIGEgbG93IHByaW9yaXR5LCBpdCB3aWxsIGJlIHNlbnQgYWZ0ZXIgYW55IG90aGVy IHZDUFUKK2ludHJvc3BlY3Rpb24gZXZlbnQgYW5kIHdoZW4gbm8gb3RoZXIgdkNQVSBpbnRyb3Nw ZWN0aW9uIGNvbW1hbmQgaXMKK3F1ZXVlZC4KZGlmZiAtLWdpdCBhL2luY2x1ZGUvdWFwaS9saW51 eC9rdm1pLmggYi9pbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oCmluZGV4IDZhNTdlZmI1NjY0ZC4u NzU3ZDRiODRmNDczIDEwMDY0NAotLS0gYS9pbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oCisrKyBi L2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmgKQEAgLTUwLDYgKzUwLDggQEAgZW51bSB7CiB9Owog CiBlbnVtIHsKKwlLVk1JX1ZDUFVfRVZFTlRfUEFVU0UgPSBLVk1JX1ZDUFVfRVZFTlRfSUQoMCks CisKIAlLVk1JX05FWFRfVkNQVV9FVkVOVAogfTsKIApkaWZmIC0tZ2l0IGEvdG9vbHMvdGVzdGlu Zy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRl c3RzL2t2bS94ODZfNjQva3ZtaV90ZXN0LmMKaW5kZXggZjhkMzU1YWZmNWZhLi45ZWIxN2Q4MjBh OGIgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQva3ZtaV90 ZXN0LmMKKysrIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3Qu YwpAQCAtMzQsNiArMzQsMTcgQEAgc3RhdGljIHZtX3BhZGRyX3QgdGVzdF9ncGE7CiAKIHN0YXRp YyBpbnQgcGFnZV9zaXplOwogCitzdHJ1Y3QgdmNwdV9ldmVudCB7CisJc3RydWN0IGt2bWlfZXZl bnRfaGRyIGhkcjsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50IGNvbW1vbjsKK307CisKK3N0cnVj dCB2Y3B1X3JlcGx5IHsKKwlzdHJ1Y3Qga3ZtaV9tc2dfaGRyIGhkcjsKKwlzdHJ1Y3Qga3ZtaV92 Y3B1X2hkciB2Y3B1X2hkcjsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3JlcGx5IHJlcGx5Owor fTsKKwogc3RydWN0IHZjcHVfd29ya2VyX2RhdGEgewogCXN0cnVjdCBrdm1fdm0gKnZtOwogCWlu dCB2Y3B1X2lkOwpAQCAtNzA0LDE0ICs3MTUsNjYgQEAgc3RhdGljIHZvaWQgcGF1c2VfdmNwdSh2 b2lkKQogCWNtZF92Y3B1X3BhdXNlKDEsIDApOwogfQogCitzdGF0aWMgdm9pZCByZXBseV90b19l dmVudChzdHJ1Y3Qga3ZtaV9tc2dfaGRyICpldl9oZHIsIHN0cnVjdCB2Y3B1X2V2ZW50ICpldiwK KwkJCSAgIF9fdTggYWN0aW9uLCBzdHJ1Y3QgdmNwdV9yZXBseSAqcnBsLCBzaXplX3QgcnBsX3Np emUpCit7CisJc3NpemVfdCByOworCisJcnBsLT5oZHIuaWQgPSBldl9oZHItPmlkOworCXJwbC0+ aGRyLnNlcSA9IGV2X2hkci0+c2VxOworCXJwbC0+aGRyLnNpemUgPSBycGxfc2l6ZSAtIHNpemVv ZihycGwtPmhkcik7CisKKwlycGwtPnZjcHVfaGRyLnZjcHUgPSBldi0+Y29tbW9uLnZjcHU7CisK KwlycGwtPnJlcGx5LmFjdGlvbiA9IGFjdGlvbjsKKwlycGwtPnJlcGx5LmV2ZW50ID0gZXYtPmhk ci5ldmVudDsKKworCXIgPSBzZW5kKFVzZXJzcGFjZV9zb2NrZXQsIHJwbCwgcnBsX3NpemUsIDAp OworCVRFU1RfQVNTRVJUKHIgPT0gcnBsX3NpemUsCisJCSJzZW5kKCkgZmFpbGVkLCBzZW5kaW5n ICV6ZCwgcmVzdWx0ICV6ZCwgZXJybm8gJWQgKCVzKVxuIiwKKwkJcnBsX3NpemUsIHIsIGVycm5v LCBzdHJlcnJvcihlcnJubykpOworfQorCitzdGF0aWMgdm9pZCByZWNlaXZlX3ZjcHVfZXZlbnQo c3RydWN0IGt2bWlfbXNnX2hkciAqbXNnX2hkciwKKwkJCSAgICAgICBzdHJ1Y3QgdmNwdV9ldmVu dCAqZXYsCisJCQkgICAgICAgc2l6ZV90IGV2X3NpemUsIHUxNiBldl9pZCkKK3sKKwlyZWNlaXZl X2V2ZW50KG1zZ19oZHIsIEtWTUlfVkNQVV9FVkVOVCwKKwkJICAgICAgJmV2LT5oZHIsIGV2X2lk LCBldl9zaXplKTsKK30KKworc3RhdGljIHZvaWQgZGlzY2FyZF9wYXVzZV9ldmVudChzdHJ1Y3Qg a3ZtX3ZtICp2bSkKK3sKKwlzdHJ1Y3QgdmNwdV93b3JrZXJfZGF0YSBkYXRhID0gey52bSA9IHZt LCAudmNwdV9pZCA9IFZDUFVfSUR9OworCXN0cnVjdCB2Y3B1X3JlcGx5IHJwbCA9IHt9OworCXN0 cnVjdCBrdm1pX21zZ19oZHIgaGRyOworCXB0aHJlYWRfdCB2Y3B1X3RocmVhZDsKKwlzdHJ1Y3Qg dmNwdV9ldmVudCBldjsKKworCXZjcHVfdGhyZWFkID0gc3RhcnRfdmNwdV93b3JrZXIoJmRhdGEp OworCisJcmVjZWl2ZV92Y3B1X2V2ZW50KCZoZHIsICZldiwgc2l6ZW9mKGV2KSwgS1ZNSV9WQ1BV X0VWRU5UX1BBVVNFKTsKKworCXJlcGx5X3RvX2V2ZW50KCZoZHIsICZldiwgS1ZNSV9FVkVOVF9B Q1RJT05fQ09OVElOVUUsCisJCQkmcnBsLCBzaXplb2YocnBsKSk7CisKKwl3YWl0X3ZjcHVfd29y a2VyKHZjcHVfdGhyZWFkKTsKK30KKwogc3RhdGljIHZvaWQgdGVzdF9wYXVzZShzdHJ1Y3Qga3Zt X3ZtICp2bSkKIHsKLQlfX3U4IHdhaXQgPSAxLCB3YWl0X2ludmFsID0gMjsKKwlfX3U4IG5vX3dh aXQgPSAwLCB3YWl0ID0gMSwgd2FpdF9pbnZhbCA9IDI7CiAKIAlwYXVzZV92Y3B1KCk7CisJZGlz Y2FyZF9wYXVzZV9ldmVudCh2bSk7CiAKIAljbWRfdmNwdV9wYXVzZSh3YWl0LCAwKTsKKwlkaXNj YXJkX3BhdXNlX2V2ZW50KHZtKTsKIAljbWRfdmNwdV9wYXVzZSh3YWl0X2ludmFsLCAtS1ZNX0VJ TlZBTCk7CisKKwlkaXNhbGxvd19ldmVudCh2bSwgS1ZNSV9WQ1BVX0VWRU5UX1BBVVNFKTsKKwlj bWRfdmNwdV9wYXVzZShub193YWl0LCAtS1ZNX0VQRVJNKTsKKwlhbGxvd19ldmVudCh2bSwgS1ZN SV9WQ1BVX0VWRU5UX1BBVVNFKTsKIH0KIAogc3RhdGljIHZvaWQgdGVzdF9pbnRyb3NwZWN0aW9u KHN0cnVjdCBrdm1fdm0gKnZtKQpkaWZmIC0tZ2l0IGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9r dm1pLmMgYi92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWkuYwppbmRleCAyNmFiNWI4NTI2ZDEu LjM5YzQzYjhhMTI3ZCAxMDA2NDQKLS0tIGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMK KysrIGIvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMKQEAgLTEwMyw2ICsxMDMsNyBAQCBz dGF0aWMgdm9pZCBrdm1pX2luaXRfa25vd25fZXZlbnRzKHZvaWQpCiAKIAliaXRtYXBfemVybyhL dm1pX2tub3duX3ZjcHVfZXZlbnRzLCBLVk1JX05VTV9FVkVOVFMpOwogCWt2bWlfYXJjaF9pbml0 X3ZjcHVfZXZlbnRzX21hc2soS3ZtaV9rbm93bl92Y3B1X2V2ZW50cyk7CisJc2V0X2JpdChLVk1J X1ZDUFVfRVZFTlRfUEFVU0UsIEt2bWlfa25vd25fdmNwdV9ldmVudHMpOwogCiAJYml0bWFwX29y KEt2bWlfa25vd25fZXZlbnRzLCBLdm1pX2tub3duX3ZtX2V2ZW50cywKIAkJICBLdm1pX2tub3du X3ZjcHVfZXZlbnRzLCBLVk1JX05VTV9FVkVOVFMpOwpAQCAtNzQxLDEyICs3NDIsMzUgQEAgdm9p ZCBrdm1pX3J1bl9qb2JzKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKIAl9CiB9CiAKK3N0YXRpYyB2 b2lkIGt2bWlfaGFuZGxlX3Vuc3VwcG9ydGVkX2V2ZW50X2FjdGlvbihzdHJ1Y3Qga3ZtICprdm0p Cit7CisJa3ZtaV9zb2NrX3NodXRkb3duKEtWTUkoa3ZtKSk7Cit9CisKK3ZvaWQga3ZtaV9oYW5k bGVfY29tbW9uX2V2ZW50X2FjdGlvbnMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCB1MzIgYWN0aW9u KQoreworCXN0cnVjdCBrdm0gKmt2bSA9IHZjcHUtPmt2bTsKKworCXN3aXRjaCAoYWN0aW9uKSB7 CisJZGVmYXVsdDoKKwkJa3ZtaV9oYW5kbGVfdW5zdXBwb3J0ZWRfZXZlbnRfYWN0aW9uKGt2bSk7 CisJfQorfQorCiBzdGF0aWMgdm9pZCBrdm1pX3ZjcHVfcGF1c2VfZXZlbnQoc3RydWN0IGt2bV92 Y3B1ICp2Y3B1KQogewogCXN0cnVjdCBrdm1fdmNwdV9pbnRyb3NwZWN0aW9uICp2Y3B1aSA9IFZD UFVJKHZjcHUpOworCXUzMiBhY3Rpb247CiAKIAlhdG9taWNfZGVjKCZ2Y3B1aS0+cGF1c2VfcmVx dWVzdHMpOwotCS8qIHRvIGJlIGltcGxlbWVudGVkICovCisKKwlhY3Rpb24gPSBrdm1pX21zZ19z ZW5kX3ZjcHVfcGF1c2UodmNwdSk7CisJc3dpdGNoIChhY3Rpb24pIHsKKwljYXNlIEtWTUlfRVZF TlRfQUNUSU9OX0NPTlRJTlVFOgorCQlicmVhazsKKwlkZWZhdWx0OgorCQlrdm1pX2hhbmRsZV9j b21tb25fZXZlbnRfYWN0aW9ucyh2Y3B1LCBhY3Rpb24pOworCX0KIH0KIAogdm9pZCBrdm1pX2hh bmRsZV9yZXF1ZXN0cyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCmRpZmYgLS1naXQgYS92aXJ0L2t2 bS9pbnRyb3NwZWN0aW9uL2t2bWlfaW50LmggYi92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlf aW50LmgKaW5kZXggNjVkOGMxYzM3Nzk2Li4wODc2NzQwZGZhMjQgMTAwNjQ0Ci0tLSBhL3ZpcnQv a3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9pbnQuaAorKysgYi92aXJ0L2t2bS9pbnRyb3NwZWN0aW9u L2t2bWlfaW50LmgKQEAgLTM4LDYgKzM4LDcgQEAgaW50IGt2bWlfc2VuZF92Y3B1X2V2ZW50KHN0 cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTMyIGV2X2lkLAogaW50IGt2bWlfbXNnX3ZjcHVfcmVwbHko Y29uc3Qgc3RydWN0IGt2bWlfdmNwdV9tc2dfam9iICpqb2IsCiAJCQljb25zdCBzdHJ1Y3Qga3Zt aV9tc2dfaGRyICptc2csIGludCBlcnIsCiAJCQljb25zdCB2b2lkICpycGwsIHNpemVfdCBycGxf c2l6ZSk7Cit1MzIga3ZtaV9tc2dfc2VuZF92Y3B1X3BhdXNlKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSk7CiAKIC8qIGt2bWkuYyAqLwogdm9pZCAqa3ZtaV9tc2dfYWxsb2Modm9pZCk7CmRpZmYgLS1n aXQgYS92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlfbXNnLmMgYi92aXJ0L2t2bS9pbnRyb3Nw ZWN0aW9uL2t2bWlfbXNnLmMKaW5kZXggODk0NjEwZTdlNWNiLi40NDcxMDVhODJlZmYgMTAwNjQ0 Ci0tLSBhL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYworKysgYi92aXJ0L2t2bS9p bnRyb3NwZWN0aW9uL2t2bWlfbXNnLmMKQEAgLTI1OCw2ICsyNTgsMTEgQEAgc3RhdGljIGludCBo YW5kbGVfdm1fcGF1c2VfdmNwdShzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWksCiAJCWdv dG8gcmVwbHk7CiAJfQogCisJaWYgKCFrdm1pX2lzX2V2ZW50X2FsbG93ZWQoa3ZtaSwgS1ZNSV9W Q1BVX0VWRU5UX1BBVVNFKSkgeworCQllYyA9IC1LVk1fRVBFUk07CisJCWdvdG8gcmVwbHk7CisJ fQorCiAJdmNwdSA9IGt2bWlfZ2V0X3ZjcHUoa3ZtaSwgcmVxLT52Y3B1KTsKIAlpZiAoIXZjcHUp CiAJCWVjID0gLUtWTV9FSU5WQUw7CkBAIC03MDIsMyArNzA3LDE2IEBAIGludCBrdm1pX3NlbmRf dmNwdV9ldmVudChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHUzMiBldl9pZCwKIAogCXJldHVybiBl cnI7CiB9CisKK3UzMiBrdm1pX21zZ19zZW5kX3ZjcHVfcGF1c2Uoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1KQoreworCXUzMiBhY3Rpb247CisJaW50IGVycjsKKworCWVyciA9IGt2bWlfc2VuZF92Y3B1 X2V2ZW50KHZjcHUsIEtWTUlfVkNQVV9FVkVOVF9QQVVTRSwgTlVMTCwgMCwKKwkJCQkgICBOVUxM LCAwLCAmYWN0aW9uKTsKKwlpZiAoZXJyKQorCQlyZXR1cm4gS1ZNSV9FVkVOVF9BQ1RJT05fQ09O VElOVUU7CisKKwlyZXR1cm4gYWN0aW9uOworfQpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwpWaXJ0dWFsaXphdGlvbiBtYWlsaW5nIGxpc3QKVmlydHVhbGl6 YXRpb25AbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcKaHR0cHM6Ly9saXN0cy5saW51eGZvdW5k YXRpb24ub3JnL21haWxtYW4vbGlzdGluZm8vdmlydHVhbGl6YXRpb24=