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 B49F1C433FE for ; Wed, 6 Oct 2021 17:42:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9B566610FC for ; Wed, 6 Oct 2021 17:42:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239620AbhJFRo1 (ORCPT ); Wed, 6 Oct 2021 13:44:27 -0400 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:53558 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239478AbhJFRmr (ORCPT ); Wed, 6 Oct 2021 13:42:47 -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 F1721305D31C; Wed, 6 Oct 2021 20:31:12 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id D56603064495; Wed, 6 Oct 2021 20:31:12 +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 46/77] KVM: introspection: add support for vCPU events Date: Wed, 6 Oct 2021 20:30:42 +0300 Message-Id: <20211006173113.26445-47-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 is the common code used by vCPU threads to send events and wait for replies (received and dispatched by the receiving thread). While waiting for an event reply, the vCPU thread will handle any introspection command already queued or received during this period. Signed-off-by: Adalbert Lazăr --- Documentation/virt/kvm/kvmi.rst | 56 ++++++++++- arch/x86/include/uapi/asm/kvmi.h | 20 ++++ arch/x86/kvm/kvmi.c | 85 ++++++++++++++++ include/linux/kvmi_host.h | 11 ++ include/uapi/linux/kvmi.h | 23 +++++ virt/kvm/introspection/kvmi.c | 1 + virt/kvm/introspection/kvmi_int.h | 6 ++ virt/kvm/introspection/kvmi_msg.c | 161 +++++++++++++++++++++++++++++- 8 files changed, 359 insertions(+), 4 deletions(-) diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst index 9f6905456923..c46e870cc728 100644 --- a/Documentation/virt/kvm/kvmi.rst +++ b/Documentation/virt/kvm/kvmi.rst @@ -521,7 +521,61 @@ The message data begins with a common structure having the event id:: __u16 padding[3]; }; -Specific event data can follow this common structure. +The vCPU introspection events are sent using the KVMI_VCPU_EVENT message id. +No event is sent unless it is explicitly enabled or requested +(e.g. *KVMI_VCPU_EVENT_PAUSE*). +A vCPU event begins with a common structure having the size of the +structure and the vCPU index:: + + struct kvmi_vcpu_event { + __u16 size; + __u16 vcpu; + __u32 padding; + struct kvmi_vcpu_event_arch arch; + }; + +On x86:: + + struct kvmi_vcpu_event_arch { + __u8 mode; + __u8 padding[7]; + struct kvm_regs regs; + struct kvm_sregs sregs; + struct { + __u64 sysenter_cs; + __u64 sysenter_esp; + __u64 sysenter_eip; + __u64 efer; + __u64 star; + __u64 lstar; + __u64 cstar; + __u64 pat; + __u64 shadow_gs; + } msrs; + }; + +It contains information about the vCPU state at the time of the event. + +A vCPU event reply begins with two common structures:: + + struct kvmi_vcpu_hdr; + struct kvmi_vcpu_event_reply { + __u8 action; + __u8 event; + __u16 padding1; + __u32 padding2; + }; + +All events accept the KVMI_EVENT_ACTION_CRASH action, which stops the +guest ungracefully, but as soon as possible. + +Most events accept the KVMI_EVENT_ACTION_CONTINUE action, which +means that KVM will continue handling the event. + +Some events accept the KVMI_EVENT_ACTION_RETRY action, which means that +KVM will stop handling the event and re-enter in guest. + +Specific event data can follow these common structures. 1. KVMI_VM_EVENT_UNHOOK ----------------------- diff --git a/arch/x86/include/uapi/asm/kvmi.h b/arch/x86/include/uapi/asm/kvmi.h index 2b6192e1a9a4..9d9df09d381a 100644 --- a/arch/x86/include/uapi/asm/kvmi.h +++ b/arch/x86/include/uapi/asm/kvmi.h @@ -6,8 +6,28 @@ * KVM introspection - x86 specific structures and definitions */ +#include + struct kvmi_vcpu_get_info_reply { __u64 tsc_speed; }; +struct kvmi_vcpu_event_arch { + __u8 mode; /* 2, 4 or 8 */ + __u8 padding[7]; + struct kvm_regs regs; + struct kvm_sregs sregs; + struct { + __u64 sysenter_cs; + __u64 sysenter_esp; + __u64 sysenter_eip; + __u64 efer; + __u64 star; + __u64 lstar; + __u64 cstar; + __u64 pat; + __u64 shadow_gs; + } msrs; +}; + #endif /* _UAPI_ASM_X86_KVMI_H */ diff --git a/arch/x86/kvm/kvmi.c b/arch/x86/kvm/kvmi.c index 4388f2d9ff2c..90c5be3c462f 100644 --- a/arch/x86/kvm/kvmi.c +++ b/arch/x86/kvm/kvmi.c @@ -5,6 +5,91 @@ * Copyright (C) 2019-2021 Bitdefender S.R.L. */ +#include "linux/kvm_host.h" +#include "x86.h" +#include "../../../virt/kvm/introspection/kvmi_int.h" + void kvmi_arch_init_vcpu_events_mask(unsigned long *supported) { } + +static unsigned int kvmi_vcpu_mode(const struct kvm_vcpu *vcpu, + const struct kvm_sregs *sregs) +{ + unsigned int mode = 0; + + if (is_long_mode((struct kvm_vcpu *) vcpu)) { + if (sregs->cs.l) + mode = 8; + else if (!sregs->cs.db) + mode = 2; + else + mode = 4; + } else if (sregs->cr0 & X86_CR0_PE) { + if (!sregs->cs.db) + mode = 2; + else + mode = 4; + } else if (!sregs->cs.db) { + mode = 2; + } else { + mode = 4; + } + + return mode; +} + +static void kvmi_get_msrs(struct kvm_vcpu *vcpu, + struct kvmi_vcpu_event_arch *event) +{ + struct msr_data msr; + + msr.host_initiated = true; + + msr.index = MSR_IA32_SYSENTER_CS; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.sysenter_cs = msr.data; + + msr.index = MSR_IA32_SYSENTER_ESP; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.sysenter_esp = msr.data; + + msr.index = MSR_IA32_SYSENTER_EIP; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.sysenter_eip = msr.data; + + msr.index = MSR_EFER; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.efer = msr.data; + + msr.index = MSR_STAR; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.star = msr.data; + + msr.index = MSR_LSTAR; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.lstar = msr.data; + + msr.index = MSR_CSTAR; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.cstar = msr.data; + + msr.index = MSR_IA32_CR_PAT; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.pat = msr.data; + + msr.index = MSR_KERNEL_GS_BASE; + static_call(kvm_x86_get_msr)(vcpu, &msr); + event->msrs.shadow_gs = msr.data; +} + +void kvmi_arch_setup_vcpu_event(struct kvm_vcpu *vcpu, + struct kvmi_vcpu_event *ev) +{ + struct kvmi_vcpu_event_arch *event = &ev->arch; + + kvm_arch_vcpu_get_regs(vcpu, &event->regs); + kvm_arch_vcpu_get_sregs(vcpu, &event->sregs); + ev->arch.mode = kvmi_vcpu_mode(vcpu, &event->sregs); + kvmi_get_msrs(vcpu, event); +} diff --git a/include/linux/kvmi_host.h b/include/linux/kvmi_host.h index 59e645d9ea34..4a43e51a44c9 100644 --- a/include/linux/kvmi_host.h +++ b/include/linux/kvmi_host.h @@ -6,6 +6,14 @@ #include +struct kvmi_vcpu_reply { + int error; + u32 action; + u32 seq; + void *data; + size_t size; +}; + struct kvmi_job { struct list_head link; void *ctx; @@ -20,6 +28,9 @@ struct kvm_vcpu_introspection { spinlock_t job_lock; atomic_t pause_requests; + + struct kvmi_vcpu_reply reply; + bool waiting_for_reply; }; struct kvm_introspection { diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h index bb90d03f059b..6a57efb5664d 100644 --- a/include/uapi/linux/kvmi.h +++ b/include/uapi/linux/kvmi.h @@ -8,6 +8,7 @@ #include #include +#include enum { KVMI_VERSION = 0x00000001 @@ -32,6 +33,8 @@ enum { }; enum { + KVMI_VCPU_EVENT = KVMI_VCPU_MESSAGE_ID(0), + KVMI_VCPU_GET_INFO = KVMI_VCPU_MESSAGE_ID(1), KVMI_NEXT_VCPU_MESSAGE @@ -50,6 +53,12 @@ enum { KVMI_NEXT_VCPU_EVENT }; +enum { + KVMI_EVENT_ACTION_CONTINUE = 0, + KVMI_EVENT_ACTION_RETRY = 1, + KVMI_EVENT_ACTION_CRASH = 2, +}; + struct kvmi_msg_hdr { __u16 id; __u16 size; @@ -123,4 +132,18 @@ struct kvmi_vm_pause_vcpu { __u32 padding2; }; +struct kvmi_vcpu_event { + __u16 size; + __u16 vcpu; + __u32 padding; + struct kvmi_vcpu_event_arch arch; +}; + +struct kvmi_vcpu_event_reply { + __u8 action; + __u8 event; + __u16 padding1; + __u32 padding2; +}; + #endif /* _UAPI__LINUX_KVMI_H */ diff --git a/virt/kvm/introspection/kvmi.c b/virt/kvm/introspection/kvmi.c index faf443d6ce82..26ab5b8526d1 100644 --- a/virt/kvm/introspection/kvmi.c +++ b/virt/kvm/introspection/kvmi.c @@ -368,6 +368,7 @@ static void kvmi_job_release_vcpu(struct kvm_vcpu *vcpu, void *ctx) struct kvm_vcpu_introspection *vcpui = VCPUI(vcpu); atomic_set(&vcpui->pause_requests, 0); + vcpui->waiting_for_reply = false; } static void kvmi_release_vcpus(struct kvm *kvm) diff --git a/virt/kvm/introspection/kvmi_int.h b/virt/kvm/introspection/kvmi_int.h index f1caa67dbdc3..65d8c1c37796 100644 --- a/virt/kvm/introspection/kvmi_int.h +++ b/virt/kvm/introspection/kvmi_int.h @@ -32,6 +32,9 @@ void kvmi_sock_shutdown(struct kvm_introspection *kvmi); void kvmi_sock_put(struct kvm_introspection *kvmi); bool kvmi_msg_process(struct kvm_introspection *kvmi); int kvmi_msg_send_unhook(struct kvm_introspection *kvmi); +int kvmi_send_vcpu_event(struct kvm_vcpu *vcpu, u32 ev_id, + void *ev, size_t ev_size, + void *rpl, size_t rpl_size, u32 *action); 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); @@ -46,6 +49,7 @@ bool kvmi_is_known_vm_event(u16 id); int kvmi_add_job(struct kvm_vcpu *vcpu, void (*fct)(struct kvm_vcpu *vcpu, void *ctx), void *ctx, void (*free_fct)(void *ctx)); +void kvmi_run_jobs(struct kvm_vcpu *vcpu); int kvmi_cmd_vm_control_events(struct kvm_introspection *kvmi, u16 event_id, bool enable); int kvmi_cmd_read_physical(struct kvm *kvm, u64 gpa, size_t size, @@ -60,5 +64,7 @@ int kvmi_cmd_vcpu_pause(struct kvm_vcpu *vcpu, bool wait); /* arch */ void kvmi_arch_init_vcpu_events_mask(unsigned long *supported); kvmi_vcpu_msg_job_fct kvmi_arch_vcpu_msg_handler(u16 id); +void kvmi_arch_setup_vcpu_event(struct kvm_vcpu *vcpu, + struct kvmi_vcpu_event *ev); #endif diff --git a/virt/kvm/introspection/kvmi_msg.c b/virt/kvm/introspection/kvmi_msg.c index 588ceb36795d..894610e7e5cb 100644 --- a/virt/kvm/introspection/kvmi_msg.c +++ b/virt/kvm/introspection/kvmi_msg.c @@ -299,6 +299,69 @@ static bool is_vm_command(u16 id) return is_vm_message(id) && id != KVMI_VM_EVENT; } +static int check_event_reply(const struct kvmi_msg_hdr *msg, + const struct kvmi_vcpu_event_reply *reply, + const struct kvmi_vcpu_reply *expected, + u8 *action, size_t *received) +{ + size_t msg_size, common_size, event_size; + int err = -EINVAL; + + if (unlikely(msg->seq != expected->seq)) + return err; + + msg_size = msg->size; + common_size = sizeof(struct kvmi_vcpu_hdr) + sizeof(*reply); + + if (check_sub_overflow(msg_size, common_size, &event_size)) + return err; + + if (unlikely(event_size > expected->size)) + return err; + + if (unlikely(reply->padding1 || reply->padding2)) + return err; + + *received = event_size; + *action = reply->action; + return 0; +} + +static int handle_vcpu_event_reply(const struct kvmi_vcpu_msg_job *job, + const struct kvmi_msg_hdr *msg, + const void *rpl) +{ + struct kvm_vcpu_introspection *vcpui = VCPUI(job->vcpu); + struct kvmi_vcpu_reply *expected = &vcpui->reply; + const struct kvmi_vcpu_event_reply *reply = rpl; + const void *reply_data = reply + 1; + size_t useful, received; + int err = -EINTR; + u8 action; + + if (unlikely(!vcpui->waiting_for_reply)) + goto out; + + err = check_event_reply(msg, reply, expected, &action, &received); + if (unlikely(err)) + goto out; + + useful = min(received, expected->size); + if (useful) + memcpy(expected->data, reply_data, useful); + + if (expected->size > useful) + memset((char *)expected->data + useful, 0, + expected->size - useful); + + expected->action = action; + +out: + vcpui->waiting_for_reply = false; + expected->error = err; + return expected->error; +} + /* * These functions are executed from the vCPU thread. The receiving thread * passes the messages using a newly allocated 'struct kvmi_vcpu_msg_job' @@ -306,6 +369,7 @@ static bool is_vm_command(u16 id) * sending back the reply). */ static const kvmi_vcpu_msg_job_fct msg_vcpu[] = { + [KVMI_VCPU_EVENT] = handle_vcpu_event_reply, }; static kvmi_vcpu_msg_job_fct get_vcpu_msg_handler(u16 id) @@ -329,7 +393,7 @@ static bool is_vcpu_message(u16 id) static bool is_vcpu_command(u16 id) { - return is_vcpu_message(id); + return is_vcpu_message(id) && id != KVMI_VCPU_EVENT; } static void kvmi_job_vcpu_msg(struct kvm_vcpu *vcpu, void *ctx) @@ -422,7 +486,8 @@ static int kvmi_msg_handle_vm_cmd(struct kvm_introspection *kvmi, static bool vcpu_can_handle_messages(struct kvm_vcpu *vcpu) { - return vcpu->arch.mp_state != KVM_MP_STATE_UNINITIALIZED; + return VCPUI(vcpu)->waiting_for_reply + || vcpu->arch.mp_state != KVM_MP_STATE_UNINITIALIZED; } static int kvmi_get_vcpu_if_ready(struct kvm_introspection *kvmi, @@ -467,7 +532,8 @@ static int kvmi_msg_handle_vcpu_msg(struct kvm_introspection *kvmi, struct kvm_vcpu *vcpu = NULL; int err, ec; - if (!kvmi_is_command_allowed(kvmi, msg->id)) + if (msg->id != KVMI_VCPU_EVENT && + !kvmi_is_command_allowed(kvmi, msg->id)) return kvmi_msg_vm_reply_ec(kvmi, msg, -KVM_EPERM); if (vcpu_hdr->padding1 || vcpu_hdr->padding2) @@ -547,3 +613,92 @@ int kvmi_msg_send_unhook(struct kvm_introspection *kvmi) return kvmi_sock_write(kvmi, vec, n, msg_size); } + +static int kvmi_wait_for_reply(struct kvm_vcpu *vcpu) +{ + struct rcuwait *waitp = kvm_arch_vcpu_get_wait(vcpu); + struct kvm_vcpu_introspection *vcpui = VCPUI(vcpu); + int err = 0; + + while (vcpui->waiting_for_reply && !err) { + kvmi_run_jobs(vcpu); + + err = rcuwait_wait_event(waitp, + !vcpui->waiting_for_reply || + !list_empty(&vcpui->job_list), + TASK_KILLABLE); + } + + return err; +} + +static void kvmi_setup_vcpu_reply(struct kvm_vcpu_introspection *vcpui, + u32 msg_seq, void *rpl, size_t rpl_size) +{ + memset(&vcpui->reply, 0, sizeof(vcpui->reply)); + + vcpui->reply.seq = msg_seq; + vcpui->reply.data = rpl; + vcpui->reply.size = rpl_size; + vcpui->reply.error = -EINTR; + vcpui->waiting_for_reply = true; +} + +static int kvmi_fill_and_sent_vcpu_event(struct kvm_vcpu *vcpu, + u32 ev_id, void *ev, + size_t ev_size, u32 msg_seq) +{ + struct kvmi_msg_hdr msg_hdr; + struct kvmi_event_hdr ev_hdr; + struct kvmi_vcpu_event common; + struct kvec vec[] = { + {.iov_base = &msg_hdr, .iov_len = sizeof(msg_hdr)}, + {.iov_base = &ev_hdr, .iov_len = sizeof(ev_hdr) }, + {.iov_base = &common, .iov_len = sizeof(common) }, + {.iov_base = ev, .iov_len = ev_size }, + }; + size_t msg_size = sizeof(msg_hdr) + sizeof(ev_hdr) + + sizeof(common) + ev_size; + size_t n = ARRAY_SIZE(vec) - (ev_size == 0 ? 1 : 0); + struct kvm_introspection *kvmi = KVMI(vcpu->kvm); + + kvmi_fill_ev_msg_hdr(kvmi, &msg_hdr, &ev_hdr, KVMI_VCPU_EVENT, + msg_seq, msg_size, ev_id); + + common.size = sizeof(common); + common.vcpu = vcpu->vcpu_idx; + + kvmi_arch_setup_vcpu_event(vcpu, &common); + + return kvmi_sock_write(kvmi, vec, n, msg_size); +} + +int kvmi_send_vcpu_event(struct kvm_vcpu *vcpu, u32 ev_id, + void *ev, size_t ev_size, + void *rpl, size_t rpl_size, u32 *action) +{ + struct kvm_vcpu_introspection *vcpui = VCPUI(vcpu); + struct kvm_introspection *kvmi = KVMI(vcpu->kvm); + u32 msg_seq = atomic_inc_return(&kvmi->ev_seq); + int err; + + kvmi_setup_vcpu_reply(vcpui, msg_seq, rpl, rpl_size); + + err = kvmi_fill_and_sent_vcpu_event(vcpu, ev_id, ev, ev_size, msg_seq); + if (err) + goto out; + + err = kvmi_wait_for_reply(vcpu); + if (!err) + err = vcpui->reply.error; + +out: + vcpui->waiting_for_reply = false; + + if (err) + kvmi_sock_shutdown(kvmi); + else + *action = vcpui->reply.action; + + return err; +} 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 D657DC43217 for ; Wed, 6 Oct 2021 17:55:56 +0000 (UTC) Received: from smtp2.osuosl.org (smtp2.osuosl.org [140.211.166.133]) (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 9E8FF610A1 for ; Wed, 6 Oct 2021 17:55:56 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 9E8FF610A1 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 smtp2.osuosl.org (Postfix) with ESMTP id DE64E40DB4; Wed, 6 Oct 2021 17:55:55 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp2.osuosl.org ([127.0.0.1]) by localhost (smtp2.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id X6C6gIhTNZ-y; Wed, 6 Oct 2021 17:55:53 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp2.osuosl.org (Postfix) with ESMTPS id 14C6640102; Wed, 6 Oct 2021 17:55:52 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id B0358C002F; Wed, 6 Oct 2021 17:55:50 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id 6B7C8C000D for ; Wed, 6 Oct 2021 17:55:46 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id 655EE83C98 for ; Wed, 6 Oct 2021 17:55:46 +0000 (UTC) X-Virus-Scanned: amavisd-new at osuosl.org Received: from smtp1.osuosl.org ([127.0.0.1]) by localhost (smtp1.osuosl.org [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id YyGg-B8H2rkb for ; Wed, 6 Oct 2021 17:55: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 smtp1.osuosl.org (Postfix) with ESMTPS id ADDCD83C59 for ; Wed, 6 Oct 2021 17:55: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 F1721305D31C; Wed, 6 Oct 2021 20:31:12 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id D56603064495; Wed, 6 Oct 2021 20:31:12 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Subject: [PATCH v12 46/77] KVM: introspection: add support for vCPU events Date: Wed, 6 Oct 2021 20:30:42 +0300 Message-Id: <20211006173113.26445-47-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" VGhpcyBpcyB0aGUgY29tbW9uIGNvZGUgdXNlZCBieSB2Q1BVIHRocmVhZHMgdG8gc2VuZCBldmVu dHMgYW5kIHdhaXQgZm9yCnJlcGxpZXMgKHJlY2VpdmVkIGFuZCBkaXNwYXRjaGVkIGJ5IHRoZSBy ZWNlaXZpbmcgdGhyZWFkKS4gV2hpbGUgd2FpdGluZwpmb3IgYW4gZXZlbnQgcmVwbHksIHRoZSB2 Q1BVIHRocmVhZCB3aWxsIGhhbmRsZSBhbnkgaW50cm9zcGVjdGlvbiBjb21tYW5kCmFscmVhZHkg cXVldWVkIG9yIHJlY2VpdmVkIGR1cmluZyB0aGlzIHBlcmlvZC4KClNpZ25lZC1vZmYtYnk6IEFk YWxiZXJ0IExhesSDciA8YWxhemFyQGJpdGRlZmVuZGVyLmNvbT4KLS0tCiBEb2N1bWVudGF0aW9u L3ZpcnQva3ZtL2t2bWkucnN0ICAgfCAgNTYgKysrKysrKysrKy0KIGFyY2gveDg2L2luY2x1ZGUv dWFwaS9hc20va3ZtaS5oICB8ICAyMCArKysrCiBhcmNoL3g4Ni9rdm0va3ZtaS5jICAgICAgICAg ICAgICAgfCAgODUgKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9rdm1pX2hvc3QuaCAg ICAgICAgIHwgIDExICsrCiBpbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oICAgICAgICAgfCAgMjMg KysrKysKIHZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaS5jICAgICB8ICAgMSArCiB2aXJ0L2t2 bS9pbnRyb3NwZWN0aW9uL2t2bWlfaW50LmggfCAgIDYgKysKIHZpcnQva3ZtL2ludHJvc3BlY3Rp b24va3ZtaV9tc2cuYyB8IDE2MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0KIDggZmls ZXMgY2hhbmdlZCwgMzU5IGluc2VydGlvbnMoKyksIDQgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0 IGEvRG9jdW1lbnRhdGlvbi92aXJ0L2t2bS9rdm1pLnJzdCBiL0RvY3VtZW50YXRpb24vdmlydC9r dm0va3ZtaS5yc3QKaW5kZXggOWY2OTA1NDU2OTIzLi5jNDZlODcwY2M3MjggMTAwNjQ0Ci0tLSBh L0RvY3VtZW50YXRpb24vdmlydC9rdm0va3ZtaS5yc3QKKysrIGIvRG9jdW1lbnRhdGlvbi92aXJ0 L2t2bS9rdm1pLnJzdApAQCAtNTIxLDcgKzUyMSw2MSBAQCBUaGUgbWVzc2FnZSBkYXRhIGJlZ2lu cyB3aXRoIGEgY29tbW9uIHN0cnVjdHVyZSBoYXZpbmcgdGhlIGV2ZW50IGlkOjoKIAkJX191MTYg cGFkZGluZ1szXTsKIAl9OwogCi1TcGVjaWZpYyBldmVudCBkYXRhIGNhbiBmb2xsb3cgdGhpcyBj b21tb24gc3RydWN0dXJlLgorVGhlIHZDUFUgaW50cm9zcGVjdGlvbiBldmVudHMgYXJlIHNlbnQg dXNpbmcgdGhlIEtWTUlfVkNQVV9FVkVOVCBtZXNzYWdlIGlkLgorTm8gZXZlbnQgaXMgc2VudCB1 bmxlc3MgaXQgaXMgZXhwbGljaXRseSBlbmFibGVkIG9yIHJlcXVlc3RlZAorKGUuZy4gKktWTUlf VkNQVV9FVkVOVF9QQVVTRSopLgorQSB2Q1BVIGV2ZW50IGJlZ2lucyB3aXRoIGEgY29tbW9uIHN0 cnVjdHVyZSBoYXZpbmcgdGhlIHNpemUgb2YgdGhlCitzdHJ1Y3R1cmUgYW5kIHRoZSB2Q1BVIGlu ZGV4OjoKKworCXN0cnVjdCBrdm1pX3ZjcHVfZXZlbnQgeworCQlfX3UxNiBzaXplOworCQlfX3Ux NiB2Y3B1OworCQlfX3UzMiBwYWRkaW5nOworCQlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X2FyY2gg YXJjaDsKKwl9OworCitPbiB4ODY6OgorCisJc3RydWN0IGt2bWlfdmNwdV9ldmVudF9hcmNoIHsK KwkJX191OCBtb2RlOworCQlfX3U4IHBhZGRpbmdbN107CisJCXN0cnVjdCBrdm1fcmVncyByZWdz OworCQlzdHJ1Y3Qga3ZtX3NyZWdzIHNyZWdzOworCQlzdHJ1Y3QgeworCQkJX191NjQgc3lzZW50 ZXJfY3M7CisJCQlfX3U2NCBzeXNlbnRlcl9lc3A7CisJCQlfX3U2NCBzeXNlbnRlcl9laXA7CisJ CQlfX3U2NCBlZmVyOworCQkJX191NjQgc3RhcjsKKwkJCV9fdTY0IGxzdGFyOworCQkJX191NjQg Y3N0YXI7CisJCQlfX3U2NCBwYXQ7CisJCQlfX3U2NCBzaGFkb3dfZ3M7CisJCX0gbXNyczsKKwl9 OworCitJdCBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCB0aGUgdkNQVSBzdGF0ZSBhdCB0aGUg dGltZSBvZiB0aGUgZXZlbnQuCisKK0EgdkNQVSBldmVudCByZXBseSBiZWdpbnMgd2l0aCB0d28g Y29tbW9uIHN0cnVjdHVyZXM6OgorCisJc3RydWN0IGt2bWlfdmNwdV9oZHI7CisJc3RydWN0IGt2 bWlfdmNwdV9ldmVudF9yZXBseSB7CisJCV9fdTggYWN0aW9uOworCQlfX3U4IGV2ZW50OworCQlf X3UxNiBwYWRkaW5nMTsKKwkJX191MzIgcGFkZGluZzI7CisJfTsKKworQWxsIGV2ZW50cyBhY2Nl cHQgdGhlIEtWTUlfRVZFTlRfQUNUSU9OX0NSQVNIIGFjdGlvbiwgd2hpY2ggc3RvcHMgdGhlCitn dWVzdCB1bmdyYWNlZnVsbHksIGJ1dCBhcyBzb29uIGFzIHBvc3NpYmxlLgorCitNb3N0IGV2ZW50 cyBhY2NlcHQgdGhlIEtWTUlfRVZFTlRfQUNUSU9OX0NPTlRJTlVFIGFjdGlvbiwgd2hpY2gKK21l YW5zIHRoYXQgS1ZNIHdpbGwgY29udGludWUgaGFuZGxpbmcgdGhlIGV2ZW50LgorCitTb21lIGV2 ZW50cyBhY2NlcHQgdGhlIEtWTUlfRVZFTlRfQUNUSU9OX1JFVFJZIGFjdGlvbiwgd2hpY2ggbWVh bnMgdGhhdAorS1ZNIHdpbGwgc3RvcCBoYW5kbGluZyB0aGUgZXZlbnQgYW5kIHJlLWVudGVyIGlu IGd1ZXN0LgorCitTcGVjaWZpYyBldmVudCBkYXRhIGNhbiBmb2xsb3cgdGhlc2UgY29tbW9uIHN0 cnVjdHVyZXMuCiAKIDEuIEtWTUlfVk1fRVZFTlRfVU5IT09LCiAtLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvaW5jbHVkZS91YXBpL2FzbS9rdm1pLmggYi9hcmNo L3g4Ni9pbmNsdWRlL3VhcGkvYXNtL2t2bWkuaAppbmRleCAyYjYxOTJlMWE5YTQuLjlkOWRmMDlk MzgxYSAxMDA2NDQKLS0tIGEvYXJjaC94ODYvaW5jbHVkZS91YXBpL2FzbS9rdm1pLmgKKysrIGIv YXJjaC94ODYvaW5jbHVkZS91YXBpL2FzbS9rdm1pLmgKQEAgLTYsOCArNiwyOCBAQAogICogS1ZN IGludHJvc3BlY3Rpb24gLSB4ODYgc3BlY2lmaWMgc3RydWN0dXJlcyBhbmQgZGVmaW5pdGlvbnMK ICAqLwogCisjaW5jbHVkZSA8YXNtL2t2bS5oPgorCiBzdHJ1Y3Qga3ZtaV92Y3B1X2dldF9pbmZv X3JlcGx5IHsKIAlfX3U2NCB0c2Nfc3BlZWQ7CiB9OwogCitzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50 X2FyY2ggeworCV9fdTggbW9kZTsJCS8qIDIsIDQgb3IgOCAqLworCV9fdTggcGFkZGluZ1s3XTsK KwlzdHJ1Y3Qga3ZtX3JlZ3MgcmVnczsKKwlzdHJ1Y3Qga3ZtX3NyZWdzIHNyZWdzOworCXN0cnVj dCB7CisJCV9fdTY0IHN5c2VudGVyX2NzOworCQlfX3U2NCBzeXNlbnRlcl9lc3A7CisJCV9fdTY0 IHN5c2VudGVyX2VpcDsKKwkJX191NjQgZWZlcjsKKwkJX191NjQgc3RhcjsKKwkJX191NjQgbHN0 YXI7CisJCV9fdTY0IGNzdGFyOworCQlfX3U2NCBwYXQ7CisJCV9fdTY0IHNoYWRvd19nczsKKwl9 IG1zcnM7Cit9OworCiAjZW5kaWYgLyogX1VBUElfQVNNX1g4Nl9LVk1JX0ggKi8KZGlmZiAtLWdp dCBhL2FyY2gveDg2L2t2bS9rdm1pLmMgYi9hcmNoL3g4Ni9rdm0va3ZtaS5jCmluZGV4IDQzODhm MmQ5ZmYyYy4uOTBjNWJlM2M0NjJmIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rdm0va3ZtaS5jCisr KyBiL2FyY2gveDg2L2t2bS9rdm1pLmMKQEAgLTUsNiArNSw5MSBAQAogICogQ29weXJpZ2h0IChD KSAyMDE5LTIwMjEgQml0ZGVmZW5kZXIgUy5SLkwuCiAgKi8KIAorI2luY2x1ZGUgImxpbnV4L2t2 bV9ob3N0LmgiCisjaW5jbHVkZSAieDg2LmgiCisjaW5jbHVkZSAiLi4vLi4vLi4vdmlydC9rdm0v aW50cm9zcGVjdGlvbi9rdm1pX2ludC5oIgorCiB2b2lkIGt2bWlfYXJjaF9pbml0X3ZjcHVfZXZl bnRzX21hc2sodW5zaWduZWQgbG9uZyAqc3VwcG9ydGVkKQogewogfQorCitzdGF0aWMgdW5zaWdu ZWQgaW50IGt2bWlfdmNwdV9tb2RlKGNvbnN0IHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKKwkJCQkg ICBjb25zdCBzdHJ1Y3Qga3ZtX3NyZWdzICpzcmVncykKK3sKKwl1bnNpZ25lZCBpbnQgbW9kZSA9 IDA7CisKKwlpZiAoaXNfbG9uZ19tb2RlKChzdHJ1Y3Qga3ZtX3ZjcHUgKikgdmNwdSkpIHsKKwkJ aWYgKHNyZWdzLT5jcy5sKQorCQkJbW9kZSA9IDg7CisJCWVsc2UgaWYgKCFzcmVncy0+Y3MuZGIp CisJCQltb2RlID0gMjsKKwkJZWxzZQorCQkJbW9kZSA9IDQ7CisJfSBlbHNlIGlmIChzcmVncy0+ Y3IwICYgWDg2X0NSMF9QRSkgeworCQlpZiAoIXNyZWdzLT5jcy5kYikKKwkJCW1vZGUgPSAyOwor CQllbHNlCisJCQltb2RlID0gNDsKKwl9IGVsc2UgaWYgKCFzcmVncy0+Y3MuZGIpIHsKKwkJbW9k ZSA9IDI7CisJfSBlbHNlIHsKKwkJbW9kZSA9IDQ7CisJfQorCisJcmV0dXJuIG1vZGU7Cit9CisK K3N0YXRpYyB2b2lkIGt2bWlfZ2V0X21zcnMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAorCQkJICBz dHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X2FyY2ggKmV2ZW50KQoreworCXN0cnVjdCBtc3JfZGF0YSBt c3I7CisKKwltc3IuaG9zdF9pbml0aWF0ZWQgPSB0cnVlOworCisJbXNyLmluZGV4ID0gTVNSX0lB MzJfU1lTRU5URVJfQ1M7CisJc3RhdGljX2NhbGwoa3ZtX3g4Nl9nZXRfbXNyKSh2Y3B1LCAmbXNy KTsKKwlldmVudC0+bXNycy5zeXNlbnRlcl9jcyA9IG1zci5kYXRhOworCisJbXNyLmluZGV4ID0g TVNSX0lBMzJfU1lTRU5URVJfRVNQOworCXN0YXRpY19jYWxsKGt2bV94ODZfZ2V0X21zcikodmNw dSwgJm1zcik7CisJZXZlbnQtPm1zcnMuc3lzZW50ZXJfZXNwID0gbXNyLmRhdGE7CisKKwltc3Iu aW5kZXggPSBNU1JfSUEzMl9TWVNFTlRFUl9FSVA7CisJc3RhdGljX2NhbGwoa3ZtX3g4Nl9nZXRf bXNyKSh2Y3B1LCAmbXNyKTsKKwlldmVudC0+bXNycy5zeXNlbnRlcl9laXAgPSBtc3IuZGF0YTsK KworCW1zci5pbmRleCA9IE1TUl9FRkVSOworCXN0YXRpY19jYWxsKGt2bV94ODZfZ2V0X21zciko dmNwdSwgJm1zcik7CisJZXZlbnQtPm1zcnMuZWZlciA9IG1zci5kYXRhOworCisJbXNyLmluZGV4 ID0gTVNSX1NUQVI7CisJc3RhdGljX2NhbGwoa3ZtX3g4Nl9nZXRfbXNyKSh2Y3B1LCAmbXNyKTsK KwlldmVudC0+bXNycy5zdGFyID0gbXNyLmRhdGE7CisKKwltc3IuaW5kZXggPSBNU1JfTFNUQVI7 CisJc3RhdGljX2NhbGwoa3ZtX3g4Nl9nZXRfbXNyKSh2Y3B1LCAmbXNyKTsKKwlldmVudC0+bXNy cy5sc3RhciA9IG1zci5kYXRhOworCisJbXNyLmluZGV4ID0gTVNSX0NTVEFSOworCXN0YXRpY19j YWxsKGt2bV94ODZfZ2V0X21zcikodmNwdSwgJm1zcik7CisJZXZlbnQtPm1zcnMuY3N0YXIgPSBt c3IuZGF0YTsKKworCW1zci5pbmRleCA9IE1TUl9JQTMyX0NSX1BBVDsKKwlzdGF0aWNfY2FsbChr dm1feDg2X2dldF9tc3IpKHZjcHUsICZtc3IpOworCWV2ZW50LT5tc3JzLnBhdCA9IG1zci5kYXRh OworCisJbXNyLmluZGV4ID0gTVNSX0tFUk5FTF9HU19CQVNFOworCXN0YXRpY19jYWxsKGt2bV94 ODZfZ2V0X21zcikodmNwdSwgJm1zcik7CisJZXZlbnQtPm1zcnMuc2hhZG93X2dzID0gbXNyLmRh dGE7Cit9CisKK3ZvaWQga3ZtaV9hcmNoX3NldHVwX3ZjcHVfZXZlbnQoc3RydWN0IGt2bV92Y3B1 ICp2Y3B1LAorCQkJCXN0cnVjdCBrdm1pX3ZjcHVfZXZlbnQgKmV2KQoreworCXN0cnVjdCBrdm1p X3ZjcHVfZXZlbnRfYXJjaCAqZXZlbnQgPSAmZXYtPmFyY2g7CisKKwlrdm1fYXJjaF92Y3B1X2dl dF9yZWdzKHZjcHUsICZldmVudC0+cmVncyk7CisJa3ZtX2FyY2hfdmNwdV9nZXRfc3JlZ3ModmNw dSwgJmV2ZW50LT5zcmVncyk7CisJZXYtPmFyY2gubW9kZSA9IGt2bWlfdmNwdV9tb2RlKHZjcHUs ICZldmVudC0+c3JlZ3MpOworCWt2bWlfZ2V0X21zcnModmNwdSwgZXZlbnQpOworfQpkaWZmIC0t Z2l0IGEvaW5jbHVkZS9saW51eC9rdm1pX2hvc3QuaCBiL2luY2x1ZGUvbGludXgva3ZtaV9ob3N0 LmgKaW5kZXggNTllNjQ1ZDllYTM0Li40YTQzZTUxYTQ0YzkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUv bGludXgva3ZtaV9ob3N0LmgKKysrIGIvaW5jbHVkZS9saW51eC9rdm1pX2hvc3QuaApAQCAtNiw2 ICs2LDE0IEBACiAKICNpbmNsdWRlIDxhc20va3ZtaV9ob3N0Lmg+CiAKK3N0cnVjdCBrdm1pX3Zj cHVfcmVwbHkgeworCWludCBlcnJvcjsKKwl1MzIgYWN0aW9uOworCXUzMiBzZXE7CisJdm9pZCAq ZGF0YTsKKwlzaXplX3Qgc2l6ZTsKK307CisKIHN0cnVjdCBrdm1pX2pvYiB7CiAJc3RydWN0IGxp c3RfaGVhZCBsaW5rOwogCXZvaWQgKmN0eDsKQEAgLTIwLDYgKzI4LDkgQEAgc3RydWN0IGt2bV92 Y3B1X2ludHJvc3BlY3Rpb24gewogCXNwaW5sb2NrX3Qgam9iX2xvY2s7CiAKIAlhdG9taWNfdCBw YXVzZV9yZXF1ZXN0czsKKworCXN0cnVjdCBrdm1pX3ZjcHVfcmVwbHkgcmVwbHk7CisJYm9vbCB3 YWl0aW5nX2Zvcl9yZXBseTsKIH07CiAKIHN0cnVjdCBrdm1faW50cm9zcGVjdGlvbiB7CmRpZmYg LS1naXQgYS9pbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oIGIvaW5jbHVkZS91YXBpL2xpbnV4L2t2 bWkuaAppbmRleCBiYjkwZDAzZjA1OWIuLjZhNTdlZmI1NjY0ZCAxMDA2NDQKLS0tIGEvaW5jbHVk ZS91YXBpL2xpbnV4L2t2bWkuaAorKysgYi9pbmNsdWRlL3VhcGkvbGludXgva3ZtaS5oCkBAIC04 LDYgKzgsNyBAQAogCiAjaW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgv dHlwZXMuaD4KKyNpbmNsdWRlIDxhc20va3ZtaS5oPgogCiBlbnVtIHsKIAlLVk1JX1ZFUlNJT04g PSAweDAwMDAwMDAxCkBAIC0zMiw2ICszMyw4IEBAIGVudW0gewogfTsKIAogZW51bSB7CisJS1ZN SV9WQ1BVX0VWRU5UID0gS1ZNSV9WQ1BVX01FU1NBR0VfSUQoMCksCisKIAlLVk1JX1ZDUFVfR0VU X0lORk8gPSBLVk1JX1ZDUFVfTUVTU0FHRV9JRCgxKSwKIAogCUtWTUlfTkVYVF9WQ1BVX01FU1NB R0UKQEAgLTUwLDYgKzUzLDEyIEBAIGVudW0gewogCUtWTUlfTkVYVF9WQ1BVX0VWRU5UCiB9Owog CitlbnVtIHsKKwlLVk1JX0VWRU5UX0FDVElPTl9DT05USU5VRSA9IDAsCisJS1ZNSV9FVkVOVF9B Q1RJT05fUkVUUlkgICAgPSAxLAorCUtWTUlfRVZFTlRfQUNUSU9OX0NSQVNIICAgID0gMiwKK307 CisKIHN0cnVjdCBrdm1pX21zZ19oZHIgewogCV9fdTE2IGlkOwogCV9fdTE2IHNpemU7CkBAIC0x MjMsNCArMTMyLDE4IEBAIHN0cnVjdCBrdm1pX3ZtX3BhdXNlX3ZjcHUgewogCV9fdTMyIHBhZGRp bmcyOwogfTsKIAorc3RydWN0IGt2bWlfdmNwdV9ldmVudCB7CisJX191MTYgc2l6ZTsKKwlfX3Ux NiB2Y3B1OworCV9fdTMyIHBhZGRpbmc7CisJc3RydWN0IGt2bWlfdmNwdV9ldmVudF9hcmNoIGFy Y2g7Cit9OworCitzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3JlcGx5IHsKKwlfX3U4IGFjdGlvbjsK KwlfX3U4IGV2ZW50OworCV9fdTE2IHBhZGRpbmcxOworCV9fdTMyIHBhZGRpbmcyOworfTsKKwog I2VuZGlmIC8qIF9VQVBJX19MSU5VWF9LVk1JX0ggKi8KZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2lu dHJvc3BlY3Rpb24va3ZtaS5jIGIvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMKaW5kZXgg ZmFmNDQzZDZjZTgyLi4yNmFiNWI4NTI2ZDEgMTAwNjQ0Ci0tLSBhL3ZpcnQva3ZtL2ludHJvc3Bl Y3Rpb24va3ZtaS5jCisrKyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaS5jCkBAIC0zNjgs NiArMzY4LDcgQEAgc3RhdGljIHZvaWQga3ZtaV9qb2JfcmVsZWFzZV92Y3B1KHN0cnVjdCBrdm1f dmNwdSAqdmNwdSwgdm9pZCAqY3R4KQogCXN0cnVjdCBrdm1fdmNwdV9pbnRyb3NwZWN0aW9uICp2 Y3B1aSA9IFZDUFVJKHZjcHUpOwogCiAJYXRvbWljX3NldCgmdmNwdWktPnBhdXNlX3JlcXVlc3Rz LCAwKTsKKwl2Y3B1aS0+d2FpdGluZ19mb3JfcmVwbHkgPSBmYWxzZTsKIH0KIAogc3RhdGljIHZv aWQga3ZtaV9yZWxlYXNlX3ZjcHVzKHN0cnVjdCBrdm0gKmt2bSkKZGlmZiAtLWdpdCBhL3ZpcnQv a3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9pbnQuaCBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3Zt aV9pbnQuaAppbmRleCBmMWNhYTY3ZGJkYzMuLjY1ZDhjMWMzNzc5NiAxMDA2NDQKLS0tIGEvdmly dC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oCisrKyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rp b24va3ZtaV9pbnQuaApAQCAtMzIsNiArMzIsOSBAQCB2b2lkIGt2bWlfc29ja19zaHV0ZG93bihz dHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWkpOwogdm9pZCBrdm1pX3NvY2tfcHV0KHN0cnVj dCBrdm1faW50cm9zcGVjdGlvbiAqa3ZtaSk7CiBib29sIGt2bWlfbXNnX3Byb2Nlc3Moc3RydWN0 IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pKTsKIGludCBrdm1pX21zZ19zZW5kX3VuaG9vayhzdHJ1 Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWkpOworaW50IGt2bWlfc2VuZF92Y3B1X2V2ZW50KHN0 cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTMyIGV2X2lkLAorCQkJIHZvaWQgKmV2LCBzaXplX3QgZXZf c2l6ZSwKKwkJCSB2b2lkICpycGwsIHNpemVfdCBycGxfc2l6ZSwgdTMyICphY3Rpb24pOwogaW50 IGt2bWlfbXNnX3ZjcHVfcmVwbHkoY29uc3Qgc3RydWN0IGt2bWlfdmNwdV9tc2dfam9iICpqb2Is CiAJCQljb25zdCBzdHJ1Y3Qga3ZtaV9tc2dfaGRyICptc2csIGludCBlcnIsCiAJCQljb25zdCB2 b2lkICpycGwsIHNpemVfdCBycGxfc2l6ZSk7CkBAIC00Niw2ICs0OSw3IEBAIGJvb2wga3ZtaV9p c19rbm93bl92bV9ldmVudCh1MTYgaWQpOwogaW50IGt2bWlfYWRkX2pvYihzdHJ1Y3Qga3ZtX3Zj cHUgKnZjcHUsCiAJCSB2b2lkICgqZmN0KShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIHZvaWQgKmN0 eCksCiAJCSB2b2lkICpjdHgsIHZvaWQgKCpmcmVlX2ZjdCkodm9pZCAqY3R4KSk7Cit2b2lkIGt2 bWlfcnVuX2pvYnMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKIGludCBrdm1pX2NtZF92bV9jb250 cm9sX2V2ZW50cyhzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWksCiAJCQkgICAgICAgdTE2 IGV2ZW50X2lkLCBib29sIGVuYWJsZSk7CiBpbnQga3ZtaV9jbWRfcmVhZF9waHlzaWNhbChzdHJ1 Y3Qga3ZtICprdm0sIHU2NCBncGEsIHNpemVfdCBzaXplLApAQCAtNjAsNSArNjQsNyBAQCBpbnQg a3ZtaV9jbWRfdmNwdV9wYXVzZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGJvb2wgd2FpdCk7CiAv KiBhcmNoICovCiB2b2lkIGt2bWlfYXJjaF9pbml0X3ZjcHVfZXZlbnRzX21hc2sodW5zaWduZWQg bG9uZyAqc3VwcG9ydGVkKTsKIGt2bWlfdmNwdV9tc2dfam9iX2ZjdCBrdm1pX2FyY2hfdmNwdV9t c2dfaGFuZGxlcih1MTYgaWQpOwordm9pZCBrdm1pX2FyY2hfc2V0dXBfdmNwdV9ldmVudChzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUsCisJCQkJc3RydWN0IGt2bWlfdmNwdV9ldmVudCAqZXYpOwogCiAj ZW5kaWYKZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYyBiL3Zp cnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYwppbmRleCA1ODhjZWIzNjc5NWQuLjg5NDYx MGU3ZTVjYiAxMDA2NDQKLS0tIGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX21zZy5jCisr KyBiL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYwpAQCAtMjk5LDYgKzI5OSw2OSBA QCBzdGF0aWMgYm9vbCBpc192bV9jb21tYW5kKHUxNiBpZCkKIAlyZXR1cm4gaXNfdm1fbWVzc2Fn ZShpZCkgJiYgaWQgIT0gS1ZNSV9WTV9FVkVOVDsKIH0KIAorc3RhdGljIGludCBjaGVja19ldmVu dF9yZXBseShjb25zdCBzdHJ1Y3Qga3ZtaV9tc2dfaGRyICptc2csCisJCQkgICAgIGNvbnN0IHN0 cnVjdCBrdm1pX3ZjcHVfZXZlbnRfcmVwbHkgKnJlcGx5LAorCQkJICAgICBjb25zdCBzdHJ1Y3Qg a3ZtaV92Y3B1X3JlcGx5ICpleHBlY3RlZCwKKwkJCSAgICAgdTggKmFjdGlvbiwgc2l6ZV90ICpy ZWNlaXZlZCkKK3sKKwlzaXplX3QgbXNnX3NpemUsIGNvbW1vbl9zaXplLCBldmVudF9zaXplOwor CWludCBlcnIgPSAtRUlOVkFMOworCisJaWYgKHVubGlrZWx5KG1zZy0+c2VxICE9IGV4cGVjdGVk LT5zZXEpKQorCQlyZXR1cm4gZXJyOworCisJbXNnX3NpemUgPSBtc2ctPnNpemU7CisJY29tbW9u X3NpemUgPSBzaXplb2Yoc3RydWN0IGt2bWlfdmNwdV9oZHIpICsgc2l6ZW9mKCpyZXBseSk7CisK KwlpZiAoY2hlY2tfc3ViX292ZXJmbG93KG1zZ19zaXplLCBjb21tb25fc2l6ZSwgJmV2ZW50X3Np emUpKQorCQlyZXR1cm4gZXJyOworCisJaWYgKHVubGlrZWx5KGV2ZW50X3NpemUgPiBleHBlY3Rl ZC0+c2l6ZSkpCisJCXJldHVybiBlcnI7CisKKwlpZiAodW5saWtlbHkocmVwbHktPnBhZGRpbmcx IHx8IHJlcGx5LT5wYWRkaW5nMikpCisJCXJldHVybiBlcnI7CisKKwkqcmVjZWl2ZWQgPSBldmVu dF9zaXplOworCSphY3Rpb24gPSByZXBseS0+YWN0aW9uOworCXJldHVybiAwOworfQorCitzdGF0 aWMgaW50IGhhbmRsZV92Y3B1X2V2ZW50X3JlcGx5KGNvbnN0IHN0cnVjdCBrdm1pX3ZjcHVfbXNn X2pvYiAqam9iLAorCQkJCSAgIGNvbnN0IHN0cnVjdCBrdm1pX21zZ19oZHIgKm1zZywKKwkJCQkg ICBjb25zdCB2b2lkICpycGwpCit7CisJc3RydWN0IGt2bV92Y3B1X2ludHJvc3BlY3Rpb24gKnZj cHVpID0gVkNQVUkoam9iLT52Y3B1KTsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X3JlcGx5ICpleHBlY3Rl ZCA9ICZ2Y3B1aS0+cmVwbHk7CisJY29uc3Qgc3RydWN0IGt2bWlfdmNwdV9ldmVudF9yZXBseSAq cmVwbHkgPSBycGw7CisJY29uc3Qgdm9pZCAqcmVwbHlfZGF0YSA9IHJlcGx5ICsgMTsKKwlzaXpl X3QgdXNlZnVsLCByZWNlaXZlZDsKKwlpbnQgZXJyID0gLUVJTlRSOworCXU4IGFjdGlvbjsKKwor CWlmICh1bmxpa2VseSghdmNwdWktPndhaXRpbmdfZm9yX3JlcGx5KSkKKwkJZ290byBvdXQ7CisK KwllcnIgPSBjaGVja19ldmVudF9yZXBseShtc2csIHJlcGx5LCBleHBlY3RlZCwgJmFjdGlvbiwg JnJlY2VpdmVkKTsKKwlpZiAodW5saWtlbHkoZXJyKSkKKwkJZ290byBvdXQ7CisKKwl1c2VmdWwg PSBtaW4ocmVjZWl2ZWQsIGV4cGVjdGVkLT5zaXplKTsKKwlpZiAodXNlZnVsKQorCQltZW1jcHko ZXhwZWN0ZWQtPmRhdGEsIHJlcGx5X2RhdGEsIHVzZWZ1bCk7CisKKwlpZiAoZXhwZWN0ZWQtPnNp emUgPiB1c2VmdWwpCisJCW1lbXNldCgoY2hhciAqKWV4cGVjdGVkLT5kYXRhICsgdXNlZnVsLCAw LAorCQkJZXhwZWN0ZWQtPnNpemUgLSB1c2VmdWwpOworCisJZXhwZWN0ZWQtPmFjdGlvbiA9IGFj dGlvbjsKKworb3V0OgorCXZjcHVpLT53YWl0aW5nX2Zvcl9yZXBseSA9IGZhbHNlOworCWV4cGVj dGVkLT5lcnJvciA9IGVycjsKKwlyZXR1cm4gZXhwZWN0ZWQtPmVycm9yOworfQorCiAvKgogICog VGhlc2UgZnVuY3Rpb25zIGFyZSBleGVjdXRlZCBmcm9tIHRoZSB2Q1BVIHRocmVhZC4gVGhlIHJl Y2VpdmluZyB0aHJlYWQKICAqIHBhc3NlcyB0aGUgbWVzc2FnZXMgdXNpbmcgYSBuZXdseSBhbGxv Y2F0ZWQgJ3N0cnVjdCBrdm1pX3ZjcHVfbXNnX2pvYicKQEAgLTMwNiw2ICszNjksNyBAQCBzdGF0 aWMgYm9vbCBpc192bV9jb21tYW5kKHUxNiBpZCkKICAqIHNlbmRpbmcgYmFjayB0aGUgcmVwbHkp LgogICovCiBzdGF0aWMgY29uc3Qga3ZtaV92Y3B1X21zZ19qb2JfZmN0IG1zZ192Y3B1W10gPSB7 CisJW0tWTUlfVkNQVV9FVkVOVF0gPSBoYW5kbGVfdmNwdV9ldmVudF9yZXBseSwKIH07CiAKIHN0 YXRpYyBrdm1pX3ZjcHVfbXNnX2pvYl9mY3QgZ2V0X3ZjcHVfbXNnX2hhbmRsZXIodTE2IGlkKQpA QCAtMzI5LDcgKzM5Myw3IEBAIHN0YXRpYyBib29sIGlzX3ZjcHVfbWVzc2FnZSh1MTYgaWQpCiAK IHN0YXRpYyBib29sIGlzX3ZjcHVfY29tbWFuZCh1MTYgaWQpCiB7Ci0JcmV0dXJuIGlzX3ZjcHVf bWVzc2FnZShpZCk7CisJcmV0dXJuIGlzX3ZjcHVfbWVzc2FnZShpZCkgJiYgaWQgIT0gS1ZNSV9W Q1BVX0VWRU5UOwogfQogCiBzdGF0aWMgdm9pZCBrdm1pX2pvYl92Y3B1X21zZyhzdHJ1Y3Qga3Zt X3ZjcHUgKnZjcHUsIHZvaWQgKmN0eCkKQEAgLTQyMiw3ICs0ODYsOCBAQCBzdGF0aWMgaW50IGt2 bWlfbXNnX2hhbmRsZV92bV9jbWQoc3RydWN0IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pLAogCiBz dGF0aWMgYm9vbCB2Y3B1X2Nhbl9oYW5kbGVfbWVzc2FnZXMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1 KQogewotCXJldHVybiB2Y3B1LT5hcmNoLm1wX3N0YXRlICE9IEtWTV9NUF9TVEFURV9VTklOSVRJ QUxJWkVEOworCXJldHVybiBWQ1BVSSh2Y3B1KS0+d2FpdGluZ19mb3JfcmVwbHkKKwkJfHwgdmNw dS0+YXJjaC5tcF9zdGF0ZSAhPSBLVk1fTVBfU1RBVEVfVU5JTklUSUFMSVpFRDsKIH0KIAogc3Rh dGljIGludCBrdm1pX2dldF92Y3B1X2lmX3JlYWR5KHN0cnVjdCBrdm1faW50cm9zcGVjdGlvbiAq a3ZtaSwKQEAgLTQ2Nyw3ICs1MzIsOCBAQCBzdGF0aWMgaW50IGt2bWlfbXNnX2hhbmRsZV92Y3B1 X21zZyhzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWksCiAJc3RydWN0IGt2bV92Y3B1ICp2 Y3B1ID0gTlVMTDsKIAlpbnQgZXJyLCBlYzsKIAotCWlmICgha3ZtaV9pc19jb21tYW5kX2FsbG93 ZWQoa3ZtaSwgbXNnLT5pZCkpCisJaWYgKG1zZy0+aWQgIT0gS1ZNSV9WQ1BVX0VWRU5UICYmCisJ ICAgICFrdm1pX2lzX2NvbW1hbmRfYWxsb3dlZChrdm1pLCBtc2ctPmlkKSkKIAkJcmV0dXJuIGt2 bWlfbXNnX3ZtX3JlcGx5X2VjKGt2bWksIG1zZywgLUtWTV9FUEVSTSk7CiAKIAlpZiAodmNwdV9o ZHItPnBhZGRpbmcxIHx8IHZjcHVfaGRyLT5wYWRkaW5nMikKQEAgLTU0NywzICs2MTMsOTIgQEAg aW50IGt2bWlfbXNnX3NlbmRfdW5ob29rKHN0cnVjdCBrdm1faW50cm9zcGVjdGlvbiAqa3ZtaSkK IAogCXJldHVybiBrdm1pX3NvY2tfd3JpdGUoa3ZtaSwgdmVjLCBuLCBtc2dfc2l6ZSk7CiB9CisK K3N0YXRpYyBpbnQga3ZtaV93YWl0X2Zvcl9yZXBseShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCit7 CisJc3RydWN0IHJjdXdhaXQgKndhaXRwID0ga3ZtX2FyY2hfdmNwdV9nZXRfd2FpdCh2Y3B1KTsK KwlzdHJ1Y3Qga3ZtX3ZjcHVfaW50cm9zcGVjdGlvbiAqdmNwdWkgPSBWQ1BVSSh2Y3B1KTsKKwlp bnQgZXJyID0gMDsKKworCXdoaWxlICh2Y3B1aS0+d2FpdGluZ19mb3JfcmVwbHkgJiYgIWVycikg eworCQlrdm1pX3J1bl9qb2JzKHZjcHUpOworCisJCWVyciA9IHJjdXdhaXRfd2FpdF9ldmVudCh3 YWl0cCwKKwkJCSF2Y3B1aS0+d2FpdGluZ19mb3JfcmVwbHkgfHwKKwkJCSFsaXN0X2VtcHR5KCZ2 Y3B1aS0+am9iX2xpc3QpLAorCQkJVEFTS19LSUxMQUJMRSk7CisJfQorCisJcmV0dXJuIGVycjsK K30KKworc3RhdGljIHZvaWQga3ZtaV9zZXR1cF92Y3B1X3JlcGx5KHN0cnVjdCBrdm1fdmNwdV9p bnRyb3NwZWN0aW9uICp2Y3B1aSwKKwkJCQkgIHUzMiBtc2dfc2VxLCB2b2lkICpycGwsIHNpemVf dCBycGxfc2l6ZSkKK3sKKwltZW1zZXQoJnZjcHVpLT5yZXBseSwgMCwgc2l6ZW9mKHZjcHVpLT5y ZXBseSkpOworCisJdmNwdWktPnJlcGx5LnNlcSA9IG1zZ19zZXE7CisJdmNwdWktPnJlcGx5LmRh dGEgPSBycGw7CisJdmNwdWktPnJlcGx5LnNpemUgPSBycGxfc2l6ZTsKKwl2Y3B1aS0+cmVwbHku ZXJyb3IgPSAtRUlOVFI7CisJdmNwdWktPndhaXRpbmdfZm9yX3JlcGx5ID0gdHJ1ZTsKK30KKwor c3RhdGljIGludCBrdm1pX2ZpbGxfYW5kX3NlbnRfdmNwdV9ldmVudChzdHJ1Y3Qga3ZtX3ZjcHUg KnZjcHUsCisJCQkJCSB1MzIgZXZfaWQsIHZvaWQgKmV2LAorCQkJCQkgc2l6ZV90IGV2X3NpemUs IHUzMiBtc2dfc2VxKQoreworCXN0cnVjdCBrdm1pX21zZ19oZHIgbXNnX2hkcjsKKwlzdHJ1Y3Qg a3ZtaV9ldmVudF9oZHIgZXZfaGRyOworCXN0cnVjdCBrdm1pX3ZjcHVfZXZlbnQgY29tbW9uOwor CXN0cnVjdCBrdmVjIHZlY1tdID0geworCQl7Lmlvdl9iYXNlID0gJm1zZ19oZHIsIC5pb3ZfbGVu ID0gc2l6ZW9mKG1zZ19oZHIpfSwKKwkJey5pb3ZfYmFzZSA9ICZldl9oZHIsICAuaW92X2xlbiA9 IHNpemVvZihldl9oZHIpIH0sCisJCXsuaW92X2Jhc2UgPSAmY29tbW9uLCAgLmlvdl9sZW4gPSBz aXplb2YoY29tbW9uKSB9LAorCQl7Lmlvdl9iYXNlID0gZXYsICAgICAgIC5pb3ZfbGVuID0gZXZf c2l6ZSAgICAgICAgfSwKKwl9OworCXNpemVfdCBtc2dfc2l6ZSA9IHNpemVvZihtc2dfaGRyKSAr IHNpemVvZihldl9oZHIpCisJCQkrIHNpemVvZihjb21tb24pICsgZXZfc2l6ZTsKKwlzaXplX3Qg biA9IEFSUkFZX1NJWkUodmVjKSAtIChldl9zaXplID09IDAgPyAxIDogMCk7CisJc3RydWN0IGt2 bV9pbnRyb3NwZWN0aW9uICprdm1pID0gS1ZNSSh2Y3B1LT5rdm0pOworCisJa3ZtaV9maWxsX2V2 X21zZ19oZHIoa3ZtaSwgJm1zZ19oZHIsICZldl9oZHIsIEtWTUlfVkNQVV9FVkVOVCwKKwkJCSAg ICAgbXNnX3NlcSwgbXNnX3NpemUsIGV2X2lkKTsKKworCWNvbW1vbi5zaXplID0gc2l6ZW9mKGNv bW1vbik7CisJY29tbW9uLnZjcHUgPSB2Y3B1LT52Y3B1X2lkeDsKKworCWt2bWlfYXJjaF9zZXR1 cF92Y3B1X2V2ZW50KHZjcHUsICZjb21tb24pOworCisJcmV0dXJuIGt2bWlfc29ja193cml0ZShr dm1pLCB2ZWMsIG4sIG1zZ19zaXplKTsKK30KKworaW50IGt2bWlfc2VuZF92Y3B1X2V2ZW50KHN0 cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTMyIGV2X2lkLAorCQkJIHZvaWQgKmV2LCBzaXplX3QgZXZf c2l6ZSwKKwkJCSB2b2lkICpycGwsIHNpemVfdCBycGxfc2l6ZSwgdTMyICphY3Rpb24pCit7CisJ c3RydWN0IGt2bV92Y3B1X2ludHJvc3BlY3Rpb24gKnZjcHVpID0gVkNQVUkodmNwdSk7CisJc3Ry dWN0IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pID0gS1ZNSSh2Y3B1LT5rdm0pOworCXUzMiBtc2df c2VxID0gYXRvbWljX2luY19yZXR1cm4oJmt2bWktPmV2X3NlcSk7CisJaW50IGVycjsKKworCWt2 bWlfc2V0dXBfdmNwdV9yZXBseSh2Y3B1aSwgbXNnX3NlcSwgcnBsLCBycGxfc2l6ZSk7CisKKwll cnIgPSBrdm1pX2ZpbGxfYW5kX3NlbnRfdmNwdV9ldmVudCh2Y3B1LCBldl9pZCwgZXYsIGV2X3Np emUsIG1zZ19zZXEpOworCWlmIChlcnIpCisJCWdvdG8gb3V0OworCisJZXJyID0ga3ZtaV93YWl0 X2Zvcl9yZXBseSh2Y3B1KTsKKwlpZiAoIWVycikKKwkJZXJyID0gdmNwdWktPnJlcGx5LmVycm9y OworCitvdXQ6CisJdmNwdWktPndhaXRpbmdfZm9yX3JlcGx5ID0gZmFsc2U7CisKKwlpZiAoZXJy KQorCQlrdm1pX3NvY2tfc2h1dGRvd24oa3ZtaSk7CisJZWxzZQorCQkqYWN0aW9uID0gdmNwdWkt PnJlcGx5LmFjdGlvbjsKKworCXJldHVybiBlcnI7Cit9Cl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fClZpcnR1YWxpemF0aW9uIG1haWxpbmcgbGlzdApWaXJ0 dWFsaXphdGlvbkBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZwpodHRwczovL2xpc3RzLmxpbnV4 Zm91bmRhdGlvbi5vcmcvbWFpbG1hbi9saXN0aW5mby92aXJ0dWFsaXphdGlvbg==