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 11FE0C433EF for ; Wed, 6 Oct 2021 17:41:32 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id F289D6052B for ; Wed, 6 Oct 2021 17:41:31 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239311AbhJFRnX (ORCPT ); Wed, 6 Oct 2021 13:43:23 -0400 Received: from mx01.bbu.dsd.mx.bitdefender.com ([91.199.104.161]:53576 "EHLO mx01.bbu.dsd.mx.bitdefender.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239265AbhJFRml (ORCPT ); Wed, 6 Oct 2021 13:42:41 -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 A0B9B30828BB; Wed, 6 Oct 2021 20:31:23 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 83D583064495; Wed, 6 Oct 2021 20:31:23 +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?Mihai=20Don=C8=9Bu?= , =?UTF-8?q?Adalbert=20Laz=C4=83r?= Subject: [PATCH v12 71/77] KVM: introspection: add KVMI_VCPU_EVENT_PF Date: Wed, 6 Oct 2021 20:31:07 +0300 Message-Id: <20211006173113.26445-72-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 From: Mihai Donțu This event is sent when a #PF occurs due to a failed permission check in the shadow page tables, for a page in which the introspection tool has shown interest. Signed-off-by: Mihai Donțu Co-developed-by: Adalbert Lazăr Signed-off-by: Adalbert Lazăr --- Documentation/virt/kvm/kvmi.rst | 66 ++++++++++ arch/x86/include/asm/kvmi_host.h | 1 + arch/x86/kvm/kvmi.c | 122 ++++++++++++++++++ include/uapi/linux/kvmi.h | 10 ++ .../testing/selftests/kvm/x86_64/kvmi_test.c | 76 +++++++++++ virt/kvm/introspection/kvmi.c | 116 +++++++++++++++++ virt/kvm/introspection/kvmi_int.h | 7 + virt/kvm/introspection/kvmi_msg.c | 19 +++ 8 files changed, 417 insertions(+) diff --git a/Documentation/virt/kvm/kvmi.rst b/Documentation/virt/kvm/kvmi.rst index 02b9f0a240c0..b12affb0d64f 100644 --- a/Documentation/virt/kvm/kvmi.rst +++ b/Documentation/virt/kvm/kvmi.rst @@ -543,6 +543,7 @@ the following events:: KVMI_VCPU_EVENT_DESCRIPTOR KVMI_VCPU_EVENT_HYPERCALL KVMI_VCPU_EVENT_MSR + KVMI_VCPU_EVENT_PF KVMI_VCPU_EVENT_XSETBV When an event is enabled, the introspection tool is notified and @@ -1379,3 +1380,68 @@ register (see **KVMI_VCPU_CONTROL_EVENTS**). ``kvmi_vcpu_event`` (with the vCPU state), the MSR number (``msr``), the old value (``old_value``) and the new value (``new_value``) are sent to the introspection tool. The *CONTINUE* action will set the ``new_val``. + +10. KVMI_VCPU_EVENT_PF +---------------------- + +:Architectures: x86 +:Versions: >= 1 +:Actions: CONTINUE, CRASH, RETRY +:Parameters: + +:: + + struct kvmi_vcpu_event; + struct kvmi_vcpu_event_pf { + __u64 gva; + __u64 gpa; + __u8 access; + __u8 padding1; + __u16 padding2; + __u32 padding3; + }; + +:Returns: + +:: + + struct kvmi_vcpu_hdr; + struct kvmi_vcpu_event_reply; + +This event is sent when a hypervisor page fault occurs due to a failed +permission checks, the introspection has been enabled for this event +(see *KVMI_VCPU_CONTROL_EVENTS*) and the event was generated for a +page in which the introspection tool has shown interest (ie. has +previously touched it by adjusting the spte permissions; see +*KVMI_VM_SET_PAGE_ACCESS*). + +These permissions can be used by the introspection tool to guarantee +the purpose of code areas inside the guest (code, rodata, stack, heap +etc.) Each attempt at an operation unfitting for a certain memory +range (eg. execute code in heap) triggers a page fault and gives the +introspection tool the chance to audit the code attempting the operation. + +``kvmi_vcpu_event`` (with the vCPU state), guest virtual address (``gva``) +if available or ~0 (UNMAPPED_GVA), guest physical address (``gpa``) +and the ``access`` flags (e.g. KVMI_PAGE_ACCESS_R) are sent to the +introspection tool. + +In case of a restricted read access, the guest address is the location +of the memory being read. On write access, the guest address is the +location of the memory being written. On execute access, the guest +address is the location of the instruction being executed +(``gva == kvmi_vcpu_event.arch.regs.rip``). + +In the current implementation, most of these events are sent during +emulation. If the page fault has set more than one access bit +(e.g. r-x/-rw), the introspection tool may receive more than one +KVMI_VCPU_EVENT_PF and the order depends on the KVM emulator. Another +cause of multiple events is when the page fault is triggered on access +crossing the page boundary. + +The *CONTINUE* action will continue the page fault handling (e.g. via +emulation). + +The *RETRY* action is used by the introspection tool to retry the +execution of the current instruction, usually because it changed the +instruction pointer or the page restrictions. diff --git a/arch/x86/include/asm/kvmi_host.h b/arch/x86/include/asm/kvmi_host.h index 3e749208b8a1..045bc885f007 100644 --- a/arch/x86/include/asm/kvmi_host.h +++ b/arch/x86/include/asm/kvmi_host.h @@ -53,6 +53,7 @@ struct kvm_vcpu_arch_introspection { }; struct kvm_arch_introspection { + struct kvm_page_track_notifier_node kptn_node; }; #define KVMI_MEM_SLOTS_NUM SHRT_MAX diff --git a/arch/x86/kvm/kvmi.c b/arch/x86/kvm/kvmi.c index 73eae96d2167..6432c40817d2 100644 --- a/arch/x86/kvm/kvmi.c +++ b/arch/x86/kvm/kvmi.c @@ -19,10 +19,26 @@ void kvmi_arch_init_vcpu_events_mask(unsigned long *supported) set_bit(KVMI_VCPU_EVENT_HYPERCALL, supported); set_bit(KVMI_VCPU_EVENT_DESCRIPTOR, supported); set_bit(KVMI_VCPU_EVENT_MSR, supported); + set_bit(KVMI_VCPU_EVENT_PF, supported); set_bit(KVMI_VCPU_EVENT_TRAP, supported); set_bit(KVMI_VCPU_EVENT_XSETBV, supported); } +static bool kvmi_track_preread(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + int bytes, + struct kvm_page_track_notifier_node *node); +static bool kvmi_track_prewrite(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + const u8 *new, int bytes, + struct kvm_page_track_notifier_node *node); +static bool kvmi_track_preexec(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + struct kvm_page_track_notifier_node *node); +static void kvmi_track_create_slot(struct kvm *kvm, + struct kvm_memory_slot *slot, + unsigned long npages, + struct kvm_page_track_notifier_node *node); +static void kvmi_track_flush_slot(struct kvm *kvm, struct kvm_memory_slot *slot, + struct kvm_page_track_notifier_node *node); + static unsigned int kvmi_vcpu_mode(const struct kvm_vcpu *vcpu, const struct kvm_sregs *sregs) { @@ -962,3 +978,109 @@ void kvmi_arch_update_page_tracking(struct kvm *kvm, } } } + +void kvmi_arch_hook(struct kvm *kvm) +{ + struct kvm_introspection *kvmi = KVMI(kvm); + + kvmi->arch.kptn_node.track_preread = kvmi_track_preread; + kvmi->arch.kptn_node.track_prewrite = kvmi_track_prewrite; + kvmi->arch.kptn_node.track_preexec = kvmi_track_preexec; + kvmi->arch.kptn_node.track_create_slot = kvmi_track_create_slot; + kvmi->arch.kptn_node.track_flush_slot = kvmi_track_flush_slot; + + kvm_page_track_register_notifier(kvm, &kvmi->arch.kptn_node); +} + +void kvmi_arch_unhook(struct kvm *kvm) +{ + struct kvm_introspection *kvmi = KVMI(kvm); + + kvm_page_track_unregister_notifier(kvm, &kvmi->arch.kptn_node); +} + +static bool kvmi_track_preread(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + int bytes, + struct kvm_page_track_notifier_node *node) +{ + struct kvm_introspection *kvmi; + bool ret = true; + + kvmi = kvmi_get(vcpu->kvm); + if (!kvmi) + return true; + + if (is_vcpu_event_enabled(vcpu, KVMI_VCPU_EVENT_PF)) + ret = kvmi_pf_event(vcpu, gpa, gva, KVMI_PAGE_ACCESS_R); + + kvmi_put(vcpu->kvm); + + return ret; +} + +static bool kvmi_track_prewrite(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + const u8 *new, int bytes, + struct kvm_page_track_notifier_node *node) +{ + struct kvm_introspection *kvmi; + bool ret = true; + + kvmi = kvmi_get(vcpu->kvm); + if (!kvmi) + return true; + + if (is_vcpu_event_enabled(vcpu, KVMI_VCPU_EVENT_PF)) + ret = kvmi_pf_event(vcpu, gpa, gva, KVMI_PAGE_ACCESS_W); + + kvmi_put(vcpu->kvm); + + return ret; +} + +static bool kvmi_track_preexec(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, + struct kvm_page_track_notifier_node *node) +{ + struct kvm_introspection *kvmi; + bool ret = true; + + kvmi = kvmi_get(vcpu->kvm); + if (!kvmi) + return true; + + if (is_vcpu_event_enabled(vcpu, KVMI_VCPU_EVENT_PF)) + ret = kvmi_pf_event(vcpu, gpa, gva, KVMI_PAGE_ACCESS_X); + + kvmi_put(vcpu->kvm); + + return ret; +} + +static void kvmi_track_create_slot(struct kvm *kvm, + struct kvm_memory_slot *slot, + unsigned long npages, + struct kvm_page_track_notifier_node *node) +{ + struct kvm_introspection *kvmi; + + kvmi = kvmi_get(kvm); + if (!kvmi) + return; + + kvmi_add_memslot(kvm, slot, npages); + + kvmi_put(kvm); +} + +static void kvmi_track_flush_slot(struct kvm *kvm, struct kvm_memory_slot *slot, + struct kvm_page_track_notifier_node *node) +{ + struct kvm_introspection *kvmi; + + kvmi = kvmi_get(kvm); + if (!kvmi) + return; + + kvmi_remove_memslot(kvm, slot); + + kvmi_put(kvm); +} diff --git a/include/uapi/linux/kvmi.h b/include/uapi/linux/kvmi.h index 38afe8ab215e..bb6265e4539a 100644 --- a/include/uapi/linux/kvmi.h +++ b/include/uapi/linux/kvmi.h @@ -71,6 +71,7 @@ enum { KVMI_VCPU_EVENT_XSETBV = KVMI_VCPU_EVENT_ID(5), KVMI_VCPU_EVENT_DESCRIPTOR = KVMI_VCPU_EVENT_ID(6), KVMI_VCPU_EVENT_MSR = KVMI_VCPU_EVENT_ID(7), + KVMI_VCPU_EVENT_PF = KVMI_VCPU_EVENT_ID(8), KVMI_NEXT_VCPU_EVENT }; @@ -205,4 +206,13 @@ struct kvmi_vm_set_page_access { struct kvmi_page_access_entry entries[0]; }; +struct kvmi_vcpu_event_pf { + __u64 gva; + __u64 gpa; + __u8 access; + __u8 padding1; + __u16 padding2; + __u32 padding3; +}; + #endif /* _UAPI__LINUX_KVMI_H */ diff --git a/tools/testing/selftests/kvm/x86_64/kvmi_test.c b/tools/testing/selftests/kvm/x86_64/kvmi_test.c index 81ab385ef1df..9cf099b38bdf 100644 --- a/tools/testing/selftests/kvm/x86_64/kvmi_test.c +++ b/tools/testing/selftests/kvm/x86_64/kvmi_test.c @@ -47,6 +47,11 @@ struct vcpu_reply { struct kvmi_vcpu_event_reply reply; }; +struct pf_ev { + struct vcpu_event vcpu_ev; + struct kvmi_vcpu_event_pf pf; +}; + struct vcpu_worker_data { struct kvm_vm *vm; int vcpu_id; @@ -54,6 +59,10 @@ struct vcpu_worker_data { bool restart_on_shutdown; }; +typedef void (*fct_pf_event)(struct kvm_vm *vm, struct kvmi_msg_hdr *hdr, + struct pf_ev *ev, + struct vcpu_reply *rpl); + enum { GUEST_TEST_NOOP = 0, GUEST_TEST_BP, @@ -61,6 +70,7 @@ enum { GUEST_TEST_DESCRIPTOR, GUEST_TEST_HYPERCALL, GUEST_TEST_MSR, + GUEST_TEST_PF, GUEST_TEST_XSETBV, }; @@ -114,6 +124,11 @@ static void guest_msr_test(void) wrmsr(MSR_MISC_FEATURES_ENABLES, msr); } +static void guest_pf_test(void) +{ + *((uint8_t *)test_gva) = GUEST_TEST_PF; +} + /* from fpu/internal.h */ static u64 xgetbv(u32 index) { @@ -174,6 +189,9 @@ static void guest_code(void) case GUEST_TEST_MSR: guest_msr_test(); break; + case GUEST_TEST_PF: + guest_pf_test(); + break; case GUEST_TEST_XSETBV: guest_xsetbv_test(); break; @@ -1727,6 +1745,63 @@ static void test_cmd_vm_set_page_access(struct kvm_vm *vm) set_page_access(gpa, full_access); } +static void test_pf(struct kvm_vm *vm, fct_pf_event cbk) +{ + __u16 event_id = KVMI_VCPU_EVENT_PF; + struct vcpu_worker_data data = { + .vm = vm, + .vcpu_id = VCPU_ID, + .test_id = GUEST_TEST_PF, + }; + struct kvmi_msg_hdr hdr; + struct vcpu_reply rpl = {}; + pthread_t vcpu_thread; + struct pf_ev ev; + + set_page_access(test_gpa, KVMI_PAGE_ACCESS_R); + enable_vcpu_event(vm, event_id); + + *((uint8_t *)test_hva) = ~GUEST_TEST_PF; + + vcpu_thread = start_vcpu_worker(&data); + + receive_vcpu_event(&hdr, &ev.vcpu_ev, sizeof(ev), event_id); + + pr_debug("PF event, gpa 0x%llx, gva 0x%llx, access 0x%x\n", + ev.pf.gpa, ev.pf.gva, ev.pf.access); + + TEST_ASSERT(ev.pf.gpa == test_gpa && ev.pf.gva == test_gva, + "Unexpected #PF event, gpa 0x%llx (expended 0x%lx), gva 0x%llx (expected 0x%lx)\n", + ev.pf.gpa, test_gpa, ev.pf.gva, test_gva); + + cbk(vm, &hdr, &ev, &rpl); + + wait_vcpu_worker(vcpu_thread); + + TEST_ASSERT(*((uint8_t *)test_hva) == GUEST_TEST_PF, + "Write failed, expected 0x%x, result 0x%x\n", + GUEST_TEST_PF, *((uint8_t *)test_hva)); + + disable_vcpu_event(vm, event_id); + set_page_access(test_gpa, KVMI_PAGE_ACCESS_R | + KVMI_PAGE_ACCESS_W | + KVMI_PAGE_ACCESS_X); +} + +static void cbk_test_event_pf(struct kvm_vm *vm, struct kvmi_msg_hdr *hdr, + struct pf_ev *ev, struct vcpu_reply *rpl) +{ + set_page_access(test_gpa, KVMI_PAGE_ACCESS_R | KVMI_PAGE_ACCESS_W); + + reply_to_event(hdr, &ev->vcpu_ev, KVMI_EVENT_ACTION_RETRY, + rpl, sizeof(*rpl)); +} + +static void test_event_pf(struct kvm_vm *vm) +{ + test_pf(vm, cbk_test_event_pf); +} + static void test_introspection(struct kvm_vm *vm) { srandom(time(0)); @@ -1759,6 +1834,7 @@ static void test_introspection(struct kvm_vm *vm) test_event_descriptor(vm); test_cmd_vcpu_control_msr(vm); test_cmd_vm_set_page_access(vm); + test_event_pf(vm); unhook_introspection(vm); } diff --git a/virt/kvm/introspection/kvmi.c b/virt/kvm/introspection/kvmi.c index 79f4ee56230b..4bc29382ba5a 100644 --- a/virt/kvm/introspection/kvmi.c +++ b/virt/kvm/introspection/kvmi.c @@ -377,6 +377,8 @@ static void __kvmi_unhook(struct kvm *kvm) struct kvm_introspection *kvmi = KVMI(kvm); wait_for_completion_killable(&kvm->kvmi_complete); + + kvmi_arch_unhook(kvm); kvmi_sock_put(kvmi); } @@ -424,6 +426,8 @@ static int __kvmi_hook(struct kvm *kvm, if (!kvmi_sock_get(kvmi, hook->fd)) return -EINVAL; + kvmi_arch_hook(kvm); + return 0; } @@ -1056,3 +1060,115 @@ int kvmi_set_gfn_access(struct kvm *kvm, gfn_t gfn, u8 access) return err; } + +static int kvmi_get_gfn_access(struct kvm_introspection *kvmi, const gfn_t gfn, + u8 *access) +{ + struct kvmi_mem_access *m; + + read_lock(&kvmi->access_tree_lock); + m = __kvmi_get_gfn_access(kvmi, gfn); + if (m) + *access = m->access; + read_unlock(&kvmi->access_tree_lock); + + return m ? 0 : -1; +} + +static bool kvmi_restricted_page_access(struct kvm_introspection *kvmi, + gpa_t gpa, u8 access) +{ + u8 allowed_access; + int err; + + err = kvmi_get_gfn_access(kvmi, gpa_to_gfn(gpa), &allowed_access); + if (err) + return false; + + /* + * We want to be notified only for violations involving access + * bits that we've specifically cleared + */ + if (access & (~allowed_access)) + return true; + + return false; +} + +bool kvmi_pf_event(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, u8 access) +{ + bool ret = false; + u32 action; + + if (!kvmi_restricted_page_access(KVMI(vcpu->kvm), gpa, access)) + return true; + + action = kvmi_msg_send_vcpu_pf(vcpu, gpa, gva, access); + switch (action) { + case KVMI_EVENT_ACTION_CONTINUE: + ret = true; + break; + case KVMI_EVENT_ACTION_RETRY: + break; + default: + kvmi_handle_common_event_actions(vcpu, action); + } + + return ret; +} + +void kvmi_add_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, + unsigned long npages) +{ + struct kvm_introspection *kvmi = KVMI(kvm); + gfn_t start = slot->base_gfn; + gfn_t end = start + npages; + int idx; + + idx = srcu_read_lock(&kvm->srcu); + KVM_MMU_LOCK(kvm); + read_lock(&kvmi->access_tree_lock); + + while (start < end) { + struct kvmi_mem_access *m; + + m = __kvmi_get_gfn_access(kvmi, start); + if (m) + kvmi_arch_update_page_tracking(kvm, slot, m); + start++; + } + + read_unlock(&kvmi->access_tree_lock); + KVM_MMU_UNLOCK(kvm); + srcu_read_unlock(&kvm->srcu, idx); +} + +void kvmi_remove_memslot(struct kvm *kvm, struct kvm_memory_slot *slot) +{ + struct kvm_introspection *kvmi = KVMI(kvm); + gfn_t start = slot->base_gfn; + gfn_t end = start + slot->npages; + int idx; + + idx = srcu_read_lock(&kvm->srcu); + KVM_MMU_LOCK(kvm); + write_lock(&kvmi->access_tree_lock); + + while (start < end) { + struct kvmi_mem_access *m; + + m = __kvmi_get_gfn_access(kvmi, start); + if (m) { + u8 prev_access = m->access; + + m->access = full_access; + kvmi_arch_update_page_tracking(kvm, slot, m); + m->access = prev_access; + } + start++; + } + + write_unlock(&kvmi->access_tree_lock); + KVM_MMU_UNLOCK(kvm); + srcu_read_unlock(&kvm->srcu, idx); +} diff --git a/virt/kvm/introspection/kvmi_int.h b/virt/kvm/introspection/kvmi_int.h index 41720b194458..bf6545e66425 100644 --- a/virt/kvm/introspection/kvmi_int.h +++ b/virt/kvm/introspection/kvmi_int.h @@ -63,6 +63,7 @@ int kvmi_msg_vcpu_reply(const struct kvmi_vcpu_msg_job *job, u32 kvmi_msg_send_vcpu_pause(struct kvm_vcpu *vcpu); u32 kvmi_msg_send_vcpu_hypercall(struct kvm_vcpu *vcpu); u32 kvmi_msg_send_vcpu_bp(struct kvm_vcpu *vcpu, u64 gpa, u8 insn_len); +u32 kvmi_msg_send_vcpu_pf(struct kvm_vcpu *vcpu, u64 gpa, u64 gva, u8 access); /* kvmi.c */ void *kvmi_msg_alloc(void); @@ -93,6 +94,10 @@ int kvmi_cmd_write_physical(struct kvm *kvm, u64 gpa, size_t size, const void *buf); int kvmi_cmd_vcpu_pause(struct kvm_vcpu *vcpu, bool wait); int kvmi_set_gfn_access(struct kvm *kvm, gfn_t gfn, u8 access); +bool kvmi_pf_event(struct kvm_vcpu *vcpu, gpa_t gpa, gva_t gva, u8 access); +void kvmi_add_memslot(struct kvm *kvm, struct kvm_memory_slot *slot, + unsigned long npages); +void kvmi_remove_memslot(struct kvm *kvm, struct kvm_memory_slot *slot); /* arch */ void kvmi_arch_init_vcpu_events_mask(unsigned long *supported); @@ -114,5 +119,7 @@ void kvmi_arch_send_pending_event(struct kvm_vcpu *vcpu); void kvmi_arch_update_page_tracking(struct kvm *kvm, struct kvm_memory_slot *slot, struct kvmi_mem_access *m); +void kvmi_arch_hook(struct kvm *kvm); +void kvmi_arch_unhook(struct kvm *kvm); #endif diff --git a/virt/kvm/introspection/kvmi_msg.c b/virt/kvm/introspection/kvmi_msg.c index d2f843cbe2c0..745d10981b6f 100644 --- a/virt/kvm/introspection/kvmi_msg.c +++ b/virt/kvm/introspection/kvmi_msg.c @@ -862,3 +862,22 @@ u32 kvmi_msg_send_vcpu_bp(struct kvm_vcpu *vcpu, u64 gpa, u8 insn_len) return action; } + +u32 kvmi_msg_send_vcpu_pf(struct kvm_vcpu *vcpu, u64 gpa, u64 gva, u8 access) +{ + struct kvmi_vcpu_event_pf e; + u32 action; + int err; + + memset(&e, 0, sizeof(e)); + e.gpa = gpa; + e.gva = gva; + e.access = access; + + err = kvmi_send_vcpu_event(vcpu, KVMI_VCPU_EVENT_PF, &e, sizeof(e), + 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 A5AE0C433EF for ; Wed, 6 Oct 2021 17:50:50 +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 6A8B86117A for ; Wed, 6 Oct 2021 17:50:50 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 6A8B86117A 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 480A960EFB; Wed, 6 Oct 2021 17:50:50 +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 KhcFgzoKQChe; Wed, 6 Oct 2021 17:50:48 +0000 (UTC) Received: from lists.linuxfoundation.org (lf-lists.osuosl.org [140.211.9.56]) by smtp3.osuosl.org (Postfix) with ESMTPS id EF70C60629; Wed, 6 Oct 2021 17:50:47 +0000 (UTC) Received: from lf-lists.osuosl.org (localhost [127.0.0.1]) by lists.linuxfoundation.org (Postfix) with ESMTP id D6854C002C; Wed, 6 Oct 2021 17:50:46 +0000 (UTC) Received: from smtp1.osuosl.org (smtp1.osuosl.org [140.211.166.138]) by lists.linuxfoundation.org (Postfix) with ESMTP id E9A5CC000D for ; Wed, 6 Oct 2021 17:50:43 +0000 (UTC) Received: from localhost (localhost [127.0.0.1]) by smtp1.osuosl.org (Postfix) with ESMTP id D761C83EAB for ; Wed, 6 Oct 2021 17:50:43 +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 3P4mZar2VoMr for ; Wed, 6 Oct 2021 17:50:42 +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 5683383D41 for ; Wed, 6 Oct 2021 17:50:42 +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 A0B9B30828BB; Wed, 6 Oct 2021 20:31:23 +0300 (EEST) Received: from localhost (unknown [91.199.104.28]) by smtp.bitdefender.com (Postfix) with ESMTPSA id 83D583064495; Wed, 6 Oct 2021 20:31:23 +0300 (EEST) X-Is-Junk-Enabled: fGZTSsP0qEJE2AIKtlSuFiRRwg9xyHmJ From: =?UTF-8?q?Adalbert=20Laz=C4=83r?= To: kvm@vger.kernel.org Subject: [PATCH v12 71/77] KVM: introspection: add KVMI_VCPU_EVENT_PF Date: Wed, 6 Oct 2021 20:31:07 +0300 Message-Id: <20211006173113.26445-72-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 , =?UTF-8?q?Mihai=20Don=C8=9Bu?= , 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" RnJvbTogTWloYWkgRG9uyJt1IDxtZG9udHVAYml0ZGVmZW5kZXIuY29tPgoKVGhpcyBldmVudCBp cyBzZW50IHdoZW4gYSAjUEYgb2NjdXJzIGR1ZSB0byBhIGZhaWxlZCBwZXJtaXNzaW9uIGNoZWNr CmluIHRoZSBzaGFkb3cgcGFnZSB0YWJsZXMsIGZvciBhIHBhZ2UgaW4gd2hpY2ggdGhlIGludHJv c3BlY3Rpb24gdG9vbApoYXMgc2hvd24gaW50ZXJlc3QuCgpTaWduZWQtb2ZmLWJ5OiBNaWhhaSBE b27Im3UgPG1kb250dUBiaXRkZWZlbmRlci5jb20+CkNvLWRldmVsb3BlZC1ieTogQWRhbGJlcnQg TGF6xINyIDxhbGF6YXJAYml0ZGVmZW5kZXIuY29tPgpTaWduZWQtb2ZmLWJ5OiBBZGFsYmVydCBM YXrEg3IgPGFsYXphckBiaXRkZWZlbmRlci5jb20+Ci0tLQogRG9jdW1lbnRhdGlvbi92aXJ0L2t2 bS9rdm1pLnJzdCAgICAgICAgICAgICAgIHwgIDY2ICsrKysrKysrKysKIGFyY2gveDg2L2luY2x1 ZGUvYXNtL2t2bWlfaG9zdC5oICAgICAgICAgICAgICB8ICAgMSArCiBhcmNoL3g4Ni9rdm0va3Zt aS5jICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxMjIgKysrKysrKysrKysrKysrKysrCiBp bmNsdWRlL3VhcGkvbGludXgva3ZtaS5oICAgICAgICAgICAgICAgICAgICAgfCAgMTAgKysKIC4u Li90ZXN0aW5nL3NlbGZ0ZXN0cy9rdm0veDg2XzY0L2t2bWlfdGVzdC5jICB8ICA3NiArKysrKysr KysrKwogdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMgICAgICAgICAgICAgICAgIHwgMTE2 ICsrKysrKysrKysrKysrKysrCiB2aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlfaW50LmggICAg ICAgICAgICAgfCAgIDcgKwogdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX21zZy5jICAgICAg ICAgICAgIHwgIDE5ICsrKwogOCBmaWxlcyBjaGFuZ2VkLCA0MTcgaW5zZXJ0aW9ucygrKQoKZGlm ZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdmlydC9rdm0va3ZtaS5yc3QgYi9Eb2N1bWVudGF0aW9u L3ZpcnQva3ZtL2t2bWkucnN0CmluZGV4IDAyYjlmMGEyNDBjMC4uYjEyYWZmYjBkNjRmIDEwMDY0 NAotLS0gYS9Eb2N1bWVudGF0aW9uL3ZpcnQva3ZtL2t2bWkucnN0CisrKyBiL0RvY3VtZW50YXRp b24vdmlydC9rdm0va3ZtaS5yc3QKQEAgLTU0Myw2ICs1NDMsNyBAQCB0aGUgZm9sbG93aW5nIGV2 ZW50czo6CiAJS1ZNSV9WQ1BVX0VWRU5UX0RFU0NSSVBUT1IKIAlLVk1JX1ZDUFVfRVZFTlRfSFlQ RVJDQUxMCiAJS1ZNSV9WQ1BVX0VWRU5UX01TUgorCUtWTUlfVkNQVV9FVkVOVF9QRgogCUtWTUlf VkNQVV9FVkVOVF9YU0VUQlYKIAogV2hlbiBhbiBldmVudCBpcyBlbmFibGVkLCB0aGUgaW50cm9z cGVjdGlvbiB0b29sIGlzIG5vdGlmaWVkIGFuZApAQCAtMTM3OSwzICsxMzgwLDY4IEBAIHJlZ2lz dGVyIChzZWUgKipLVk1JX1ZDUFVfQ09OVFJPTF9FVkVOVFMqKikuCiBgYGt2bWlfdmNwdV9ldmVu dGBgICh3aXRoIHRoZSB2Q1BVIHN0YXRlKSwgdGhlIE1TUiBudW1iZXIgKGBgbXNyYGApLAogdGhl IG9sZCB2YWx1ZSAoYGBvbGRfdmFsdWVgYCkgYW5kIHRoZSBuZXcgdmFsdWUgKGBgbmV3X3ZhbHVl YGApIGFyZSBzZW50CiB0byB0aGUgaW50cm9zcGVjdGlvbiB0b29sLiBUaGUgKkNPTlRJTlVFKiBh Y3Rpb24gd2lsbCBzZXQgdGhlIGBgbmV3X3ZhbGBgLgorCisxMC4gS1ZNSV9WQ1BVX0VWRU5UX1BG CistLS0tLS0tLS0tLS0tLS0tLS0tLS0tCisKKzpBcmNoaXRlY3R1cmVzOiB4ODYKKzpWZXJzaW9u czogPj0gMQorOkFjdGlvbnM6IENPTlRJTlVFLCBDUkFTSCwgUkVUUlkKKzpQYXJhbWV0ZXJzOgor Cis6OgorCisJc3RydWN0IGt2bWlfdmNwdV9ldmVudDsKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50 X3BmIHsKKwkJX191NjQgZ3ZhOworCQlfX3U2NCBncGE7CisJCV9fdTggYWNjZXNzOworCQlfX3U4 IHBhZGRpbmcxOworCQlfX3UxNiBwYWRkaW5nMjsKKwkJX191MzIgcGFkZGluZzM7CisJfTsKKwor OlJldHVybnM6CisKKzo6CisKKwlzdHJ1Y3Qga3ZtaV92Y3B1X2hkcjsKKwlzdHJ1Y3Qga3ZtaV92 Y3B1X2V2ZW50X3JlcGx5OworCitUaGlzIGV2ZW50IGlzIHNlbnQgd2hlbiBhIGh5cGVydmlzb3Ig cGFnZSBmYXVsdCBvY2N1cnMgZHVlIHRvIGEgZmFpbGVkCitwZXJtaXNzaW9uIGNoZWNrcywgdGhl IGludHJvc3BlY3Rpb24gaGFzIGJlZW4gZW5hYmxlZCBmb3IgdGhpcyBldmVudAorKHNlZSAqS1ZN SV9WQ1BVX0NPTlRST0xfRVZFTlRTKikgYW5kIHRoZSBldmVudCB3YXMgZ2VuZXJhdGVkIGZvciBh CitwYWdlIGluIHdoaWNoIHRoZSBpbnRyb3NwZWN0aW9uIHRvb2wgaGFzIHNob3duIGludGVyZXN0 IChpZS4gaGFzCitwcmV2aW91c2x5IHRvdWNoZWQgaXQgYnkgYWRqdXN0aW5nIHRoZSBzcHRlIHBl cm1pc3Npb25zOyBzZWUKKypLVk1JX1ZNX1NFVF9QQUdFX0FDQ0VTUyopLgorCitUaGVzZSBwZXJt aXNzaW9ucyBjYW4gYmUgdXNlZCBieSB0aGUgaW50cm9zcGVjdGlvbiB0b29sIHRvIGd1YXJhbnRl ZQordGhlIHB1cnBvc2Ugb2YgY29kZSBhcmVhcyBpbnNpZGUgdGhlIGd1ZXN0IChjb2RlLCByb2Rh dGEsIHN0YWNrLCBoZWFwCitldGMuKSBFYWNoIGF0dGVtcHQgYXQgYW4gb3BlcmF0aW9uIHVuZml0 dGluZyBmb3IgYSBjZXJ0YWluIG1lbW9yeQorcmFuZ2UgKGVnLiBleGVjdXRlIGNvZGUgaW4gaGVh cCkgdHJpZ2dlcnMgYSBwYWdlIGZhdWx0IGFuZCBnaXZlcyB0aGUKK2ludHJvc3BlY3Rpb24gdG9v bCB0aGUgY2hhbmNlIHRvIGF1ZGl0IHRoZSBjb2RlIGF0dGVtcHRpbmcgdGhlIG9wZXJhdGlvbi4K KworYGBrdm1pX3ZjcHVfZXZlbnRgYCAod2l0aCB0aGUgdkNQVSBzdGF0ZSksIGd1ZXN0IHZpcnR1 YWwgYWRkcmVzcyAoYGBndmFgYCkKK2lmIGF2YWlsYWJsZSBvciB+MCAoVU5NQVBQRURfR1ZBKSwg Z3Vlc3QgcGh5c2ljYWwgYWRkcmVzcyAoYGBncGFgYCkKK2FuZCB0aGUgYGBhY2Nlc3NgYCBmbGFn cyAoZS5nLiBLVk1JX1BBR0VfQUNDRVNTX1IpIGFyZSBzZW50IHRvIHRoZQoraW50cm9zcGVjdGlv biB0b29sLgorCitJbiBjYXNlIG9mIGEgcmVzdHJpY3RlZCByZWFkIGFjY2VzcywgdGhlIGd1ZXN0 IGFkZHJlc3MgaXMgdGhlIGxvY2F0aW9uCitvZiB0aGUgbWVtb3J5IGJlaW5nIHJlYWQuIE9uIHdy aXRlIGFjY2VzcywgdGhlIGd1ZXN0IGFkZHJlc3MgaXMgdGhlCitsb2NhdGlvbiBvZiB0aGUgbWVt b3J5IGJlaW5nIHdyaXR0ZW4uIE9uIGV4ZWN1dGUgYWNjZXNzLCB0aGUgZ3Vlc3QKK2FkZHJlc3Mg aXMgdGhlIGxvY2F0aW9uIG9mIHRoZSBpbnN0cnVjdGlvbiBiZWluZyBleGVjdXRlZAorKGBgZ3Zh ID09IGt2bWlfdmNwdV9ldmVudC5hcmNoLnJlZ3MucmlwYGApLgorCitJbiB0aGUgY3VycmVudCBp bXBsZW1lbnRhdGlvbiwgbW9zdCBvZiB0aGVzZSBldmVudHMgYXJlIHNlbnQgZHVyaW5nCitlbXVs YXRpb24uIElmIHRoZSBwYWdlIGZhdWx0IGhhcyBzZXQgbW9yZSB0aGFuIG9uZSBhY2Nlc3MgYml0 CisoZS5nLiByLXgvLXJ3KSwgdGhlIGludHJvc3BlY3Rpb24gdG9vbCBtYXkgcmVjZWl2ZSBtb3Jl IHRoYW4gb25lCitLVk1JX1ZDUFVfRVZFTlRfUEYgYW5kIHRoZSBvcmRlciBkZXBlbmRzIG9uIHRo ZSBLVk0gZW11bGF0b3IuIEFub3RoZXIKK2NhdXNlIG9mIG11bHRpcGxlIGV2ZW50cyBpcyB3aGVu IHRoZSBwYWdlIGZhdWx0IGlzIHRyaWdnZXJlZCBvbiBhY2Nlc3MKK2Nyb3NzaW5nIHRoZSBwYWdl IGJvdW5kYXJ5LgorCitUaGUgKkNPTlRJTlVFKiBhY3Rpb24gd2lsbCBjb250aW51ZSB0aGUgcGFn ZSBmYXVsdCBoYW5kbGluZyAoZS5nLiB2aWEKK2VtdWxhdGlvbikuCisKK1RoZSAqUkVUUlkqIGFj dGlvbiBpcyB1c2VkIGJ5IHRoZSBpbnRyb3NwZWN0aW9uIHRvb2wgdG8gcmV0cnkgdGhlCitleGVj dXRpb24gb2YgdGhlIGN1cnJlbnQgaW5zdHJ1Y3Rpb24sIHVzdWFsbHkgYmVjYXVzZSBpdCBjaGFu Z2VkIHRoZQoraW5zdHJ1Y3Rpb24gcG9pbnRlciBvciB0aGUgcGFnZSByZXN0cmljdGlvbnMuCmRp ZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9rdm1pX2hvc3QuaCBiL2FyY2gveDg2L2lu Y2x1ZGUvYXNtL2t2bWlfaG9zdC5oCmluZGV4IDNlNzQ5MjA4YjhhMS4uMDQ1YmM4ODVmMDA3IDEw MDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9rdm1pX2hvc3QuaAorKysgYi9hcmNoL3g4 Ni9pbmNsdWRlL2FzbS9rdm1pX2hvc3QuaApAQCAtNTMsNiArNTMsNyBAQCBzdHJ1Y3Qga3ZtX3Zj cHVfYXJjaF9pbnRyb3NwZWN0aW9uIHsKIH07CiAKIHN0cnVjdCBrdm1fYXJjaF9pbnRyb3NwZWN0 aW9uIHsKKwlzdHJ1Y3Qga3ZtX3BhZ2VfdHJhY2tfbm90aWZpZXJfbm9kZSBrcHRuX25vZGU7CiB9 OwogCiAjZGVmaW5lIEtWTUlfTUVNX1NMT1RTX05VTSBTSFJUX01BWApkaWZmIC0tZ2l0IGEvYXJj aC94ODYva3ZtL2t2bWkuYyBiL2FyY2gveDg2L2t2bS9rdm1pLmMKaW5kZXggNzNlYWU5NmQyMTY3 Li42NDMyYzQwODE3ZDIgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2t2bS9rdm1pLmMKKysrIGIvYXJj aC94ODYva3ZtL2t2bWkuYwpAQCAtMTksMTAgKzE5LDI2IEBAIHZvaWQga3ZtaV9hcmNoX2luaXRf dmNwdV9ldmVudHNfbWFzayh1bnNpZ25lZCBsb25nICpzdXBwb3J0ZWQpCiAJc2V0X2JpdChLVk1J X1ZDUFVfRVZFTlRfSFlQRVJDQUxMLCBzdXBwb3J0ZWQpOwogCXNldF9iaXQoS1ZNSV9WQ1BVX0VW RU5UX0RFU0NSSVBUT1IsIHN1cHBvcnRlZCk7CiAJc2V0X2JpdChLVk1JX1ZDUFVfRVZFTlRfTVNS LCBzdXBwb3J0ZWQpOworCXNldF9iaXQoS1ZNSV9WQ1BVX0VWRU5UX1BGLCBzdXBwb3J0ZWQpOwog CXNldF9iaXQoS1ZNSV9WQ1BVX0VWRU5UX1RSQVAsIHN1cHBvcnRlZCk7CiAJc2V0X2JpdChLVk1J X1ZDUFVfRVZFTlRfWFNFVEJWLCBzdXBwb3J0ZWQpOwogfQogCitzdGF0aWMgYm9vbCBrdm1pX3Ry YWNrX3ByZXJlYWQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwK KwkJCSAgICAgICBpbnQgYnl0ZXMsCisJCQkgICAgICAgc3RydWN0IGt2bV9wYWdlX3RyYWNrX25v dGlmaWVyX25vZGUgKm5vZGUpOworc3RhdGljIGJvb2wga3ZtaV90cmFja19wcmV3cml0ZShzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUsIGdwYV90IGdwYSwgZ3ZhX3QgZ3ZhLAorCQkJCWNvbnN0IHU4ICpu ZXcsIGludCBieXRlcywKKwkJCQlzdHJ1Y3Qga3ZtX3BhZ2VfdHJhY2tfbm90aWZpZXJfbm9kZSAq bm9kZSk7CitzdGF0aWMgYm9vbCBrdm1pX3RyYWNrX3ByZWV4ZWMoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwKKwkJCSAgICAgICBzdHJ1Y3Qga3ZtX3BhZ2VfdHJh Y2tfbm90aWZpZXJfbm9kZSAqbm9kZSk7CitzdGF0aWMgdm9pZCBrdm1pX3RyYWNrX2NyZWF0ZV9z bG90KHN0cnVjdCBrdm0gKmt2bSwKKwkJCQkgICBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90 LAorCQkJCSAgIHVuc2lnbmVkIGxvbmcgbnBhZ2VzLAorCQkJCSAgIHN0cnVjdCBrdm1fcGFnZV90 cmFja19ub3RpZmllcl9ub2RlICpub2RlKTsKK3N0YXRpYyB2b2lkIGt2bWlfdHJhY2tfZmx1c2hf c2xvdChzdHJ1Y3Qga3ZtICprdm0sIHN0cnVjdCBrdm1fbWVtb3J5X3Nsb3QgKnNsb3QsCisJCQkJ ICBzdHJ1Y3Qga3ZtX3BhZ2VfdHJhY2tfbm90aWZpZXJfbm9kZSAqbm9kZSk7CisKIHN0YXRpYyB1 bnNpZ25lZCBpbnQga3ZtaV92Y3B1X21vZGUoY29uc3Qgc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAog CQkJCSAgIGNvbnN0IHN0cnVjdCBrdm1fc3JlZ3MgKnNyZWdzKQogewpAQCAtOTYyLDMgKzk3OCwx MDkgQEAgdm9pZCBrdm1pX2FyY2hfdXBkYXRlX3BhZ2VfdHJhY2tpbmcoc3RydWN0IGt2bSAqa3Zt LAogCQl9CiAJfQogfQorCit2b2lkIGt2bWlfYXJjaF9ob29rKHN0cnVjdCBrdm0gKmt2bSkKK3sK KwlzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWkgPSBLVk1JKGt2bSk7CisKKwlrdm1pLT5h cmNoLmtwdG5fbm9kZS50cmFja19wcmVyZWFkID0ga3ZtaV90cmFja19wcmVyZWFkOworCWt2bWkt PmFyY2gua3B0bl9ub2RlLnRyYWNrX3ByZXdyaXRlID0ga3ZtaV90cmFja19wcmV3cml0ZTsKKwlr dm1pLT5hcmNoLmtwdG5fbm9kZS50cmFja19wcmVleGVjID0ga3ZtaV90cmFja19wcmVleGVjOwor CWt2bWktPmFyY2gua3B0bl9ub2RlLnRyYWNrX2NyZWF0ZV9zbG90ID0ga3ZtaV90cmFja19jcmVh dGVfc2xvdDsKKwlrdm1pLT5hcmNoLmtwdG5fbm9kZS50cmFja19mbHVzaF9zbG90ID0ga3ZtaV90 cmFja19mbHVzaF9zbG90OworCisJa3ZtX3BhZ2VfdHJhY2tfcmVnaXN0ZXJfbm90aWZpZXIoa3Zt LCAma3ZtaS0+YXJjaC5rcHRuX25vZGUpOworfQorCit2b2lkIGt2bWlfYXJjaF91bmhvb2soc3Ry dWN0IGt2bSAqa3ZtKQoreworCXN0cnVjdCBrdm1faW50cm9zcGVjdGlvbiAqa3ZtaSA9IEtWTUko a3ZtKTsKKworCWt2bV9wYWdlX3RyYWNrX3VucmVnaXN0ZXJfbm90aWZpZXIoa3ZtLCAma3ZtaS0+ YXJjaC5rcHRuX25vZGUpOworfQorCitzdGF0aWMgYm9vbCBrdm1pX3RyYWNrX3ByZXJlYWQoc3Ry dWN0IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwKKwkJCSAgICAgICBpbnQg Ynl0ZXMsCisJCQkgICAgICAgc3RydWN0IGt2bV9wYWdlX3RyYWNrX25vdGlmaWVyX25vZGUgKm5v ZGUpCit7CisJc3RydWN0IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pOworCWJvb2wgcmV0ID0gdHJ1 ZTsKKworCWt2bWkgPSBrdm1pX2dldCh2Y3B1LT5rdm0pOworCWlmICgha3ZtaSkKKwkJcmV0dXJu IHRydWU7CisKKwlpZiAoaXNfdmNwdV9ldmVudF9lbmFibGVkKHZjcHUsIEtWTUlfVkNQVV9FVkVO VF9QRikpCisJCXJldCA9IGt2bWlfcGZfZXZlbnQodmNwdSwgZ3BhLCBndmEsIEtWTUlfUEFHRV9B Q0NFU1NfUik7CisKKwlrdm1pX3B1dCh2Y3B1LT5rdm0pOworCisJcmV0dXJuIHJldDsKK30KKwor c3RhdGljIGJvb2wga3ZtaV90cmFja19wcmV3cml0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGdw YV90IGdwYSwgZ3ZhX3QgZ3ZhLAorCQkJCWNvbnN0IHU4ICpuZXcsIGludCBieXRlcywKKwkJCQlz dHJ1Y3Qga3ZtX3BhZ2VfdHJhY2tfbm90aWZpZXJfbm9kZSAqbm9kZSkKK3sKKwlzdHJ1Y3Qga3Zt X2ludHJvc3BlY3Rpb24gKmt2bWk7CisJYm9vbCByZXQgPSB0cnVlOworCisJa3ZtaSA9IGt2bWlf Z2V0KHZjcHUtPmt2bSk7CisJaWYgKCFrdm1pKQorCQlyZXR1cm4gdHJ1ZTsKKworCWlmIChpc192 Y3B1X2V2ZW50X2VuYWJsZWQodmNwdSwgS1ZNSV9WQ1BVX0VWRU5UX1BGKSkKKwkJcmV0ID0ga3Zt aV9wZl9ldmVudCh2Y3B1LCBncGEsIGd2YSwgS1ZNSV9QQUdFX0FDQ0VTU19XKTsKKworCWt2bWlf cHV0KHZjcHUtPmt2bSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMgYm9vbCBrdm1pX3Ry YWNrX3ByZWV4ZWMoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBncGFfdCBncGEsIGd2YV90IGd2YSwK KwkJCSAgICAgICBzdHJ1Y3Qga3ZtX3BhZ2VfdHJhY2tfbm90aWZpZXJfbm9kZSAqbm9kZSkKK3sK KwlzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWk7CisJYm9vbCByZXQgPSB0cnVlOworCisJ a3ZtaSA9IGt2bWlfZ2V0KHZjcHUtPmt2bSk7CisJaWYgKCFrdm1pKQorCQlyZXR1cm4gdHJ1ZTsK KworCWlmIChpc192Y3B1X2V2ZW50X2VuYWJsZWQodmNwdSwgS1ZNSV9WQ1BVX0VWRU5UX1BGKSkK KwkJcmV0ID0ga3ZtaV9wZl9ldmVudCh2Y3B1LCBncGEsIGd2YSwgS1ZNSV9QQUdFX0FDQ0VTU19Y KTsKKworCWt2bWlfcHV0KHZjcHUtPmt2bSk7CisKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMg dm9pZCBrdm1pX3RyYWNrX2NyZWF0ZV9zbG90KHN0cnVjdCBrdm0gKmt2bSwKKwkJCQkgICBzdHJ1 Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAorCQkJCSAgIHVuc2lnbmVkIGxvbmcgbnBhZ2VzLAor CQkJCSAgIHN0cnVjdCBrdm1fcGFnZV90cmFja19ub3RpZmllcl9ub2RlICpub2RlKQoreworCXN0 cnVjdCBrdm1faW50cm9zcGVjdGlvbiAqa3ZtaTsKKworCWt2bWkgPSBrdm1pX2dldChrdm0pOwor CWlmICgha3ZtaSkKKwkJcmV0dXJuOworCisJa3ZtaV9hZGRfbWVtc2xvdChrdm0sIHNsb3QsIG5w YWdlcyk7CisKKwlrdm1pX3B1dChrdm0pOworfQorCitzdGF0aWMgdm9pZCBrdm1pX3RyYWNrX2Zs dXNoX3Nsb3Qoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAor CQkJCSAgc3RydWN0IGt2bV9wYWdlX3RyYWNrX25vdGlmaWVyX25vZGUgKm5vZGUpCit7CisJc3Ry dWN0IGt2bV9pbnRyb3NwZWN0aW9uICprdm1pOworCisJa3ZtaSA9IGt2bWlfZ2V0KGt2bSk7CisJ aWYgKCFrdm1pKQorCQlyZXR1cm47CisKKwlrdm1pX3JlbW92ZV9tZW1zbG90KGt2bSwgc2xvdCk7 CisKKwlrdm1pX3B1dChrdm0pOworfQpkaWZmIC0tZ2l0IGEvaW5jbHVkZS91YXBpL2xpbnV4L2t2 bWkuaCBiL2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmgKaW5kZXggMzhhZmU4YWIyMTVlLi5iYjYy NjVlNDUzOWEgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvdWFwaS9saW51eC9rdm1pLmgKKysrIGIvaW5j bHVkZS91YXBpL2xpbnV4L2t2bWkuaApAQCAtNzEsNiArNzEsNyBAQCBlbnVtIHsKIAlLVk1JX1ZD UFVfRVZFTlRfWFNFVEJWICAgICA9IEtWTUlfVkNQVV9FVkVOVF9JRCg1KSwKIAlLVk1JX1ZDUFVf RVZFTlRfREVTQ1JJUFRPUiA9IEtWTUlfVkNQVV9FVkVOVF9JRCg2KSwKIAlLVk1JX1ZDUFVfRVZF TlRfTVNSICAgICAgICA9IEtWTUlfVkNQVV9FVkVOVF9JRCg3KSwKKwlLVk1JX1ZDUFVfRVZFTlRf UEYgICAgICAgICA9IEtWTUlfVkNQVV9FVkVOVF9JRCg4KSwKIAogCUtWTUlfTkVYVF9WQ1BVX0VW RU5UCiB9OwpAQCAtMjA1LDQgKzIwNiwxMyBAQCBzdHJ1Y3Qga3ZtaV92bV9zZXRfcGFnZV9hY2Nl c3MgewogCXN0cnVjdCBrdm1pX3BhZ2VfYWNjZXNzX2VudHJ5IGVudHJpZXNbMF07CiB9OwogCitz dHJ1Y3Qga3ZtaV92Y3B1X2V2ZW50X3BmIHsKKwlfX3U2NCBndmE7CisJX191NjQgZ3BhOworCV9f dTggYWNjZXNzOworCV9fdTggcGFkZGluZzE7CisJX191MTYgcGFkZGluZzI7CisJX191MzIgcGFk ZGluZzM7Cit9OworCiAjZW5kaWYgLyogX1VBUElfX0xJTlVYX0tWTUlfSCAqLwpkaWZmIC0tZ2l0 IGEvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4Nl82NC9rdm1pX3Rlc3QuYyBiL3Rvb2xz L3Rlc3Rpbmcvc2VsZnRlc3RzL2t2bS94ODZfNjQva3ZtaV90ZXN0LmMKaW5kZXggODFhYjM4NWVm MWRmLi45Y2YwOTliMzhiZGYgMTAwNjQ0Ci0tLSBhL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2t2 bS94ODZfNjQva3ZtaV90ZXN0LmMKKysrIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMva3ZtL3g4 Nl82NC9rdm1pX3Rlc3QuYwpAQCAtNDcsNiArNDcsMTEgQEAgc3RydWN0IHZjcHVfcmVwbHkgewog CXN0cnVjdCBrdm1pX3ZjcHVfZXZlbnRfcmVwbHkgcmVwbHk7CiB9OwogCitzdHJ1Y3QgcGZfZXYg eworCXN0cnVjdCB2Y3B1X2V2ZW50IHZjcHVfZXY7CisJc3RydWN0IGt2bWlfdmNwdV9ldmVudF9w ZiBwZjsKK307CisKIHN0cnVjdCB2Y3B1X3dvcmtlcl9kYXRhIHsKIAlzdHJ1Y3Qga3ZtX3ZtICp2 bTsKIAlpbnQgdmNwdV9pZDsKQEAgLTU0LDYgKzU5LDEwIEBAIHN0cnVjdCB2Y3B1X3dvcmtlcl9k YXRhIHsKIAlib29sIHJlc3RhcnRfb25fc2h1dGRvd247CiB9OwogCit0eXBlZGVmIHZvaWQgKCpm Y3RfcGZfZXZlbnQpKHN0cnVjdCBrdm1fdm0gKnZtLCBzdHJ1Y3Qga3ZtaV9tc2dfaGRyICpoZHIs CisJCQkJc3RydWN0IHBmX2V2ICpldiwKKwkJCQlzdHJ1Y3QgdmNwdV9yZXBseSAqcnBsKTsKKwog ZW51bSB7CiAJR1VFU1RfVEVTVF9OT09QID0gMCwKIAlHVUVTVF9URVNUX0JQLApAQCAtNjEsNiAr NzAsNyBAQCBlbnVtIHsKIAlHVUVTVF9URVNUX0RFU0NSSVBUT1IsCiAJR1VFU1RfVEVTVF9IWVBF UkNBTEwsCiAJR1VFU1RfVEVTVF9NU1IsCisJR1VFU1RfVEVTVF9QRiwKIAlHVUVTVF9URVNUX1hT RVRCViwKIH07CiAKQEAgLTExNCw2ICsxMjQsMTEgQEAgc3RhdGljIHZvaWQgZ3Vlc3RfbXNyX3Rl c3Qodm9pZCkKIAl3cm1zcihNU1JfTUlTQ19GRUFUVVJFU19FTkFCTEVTLCBtc3IpOwogfQogCitz dGF0aWMgdm9pZCBndWVzdF9wZl90ZXN0KHZvaWQpCit7CisJKigodWludDhfdCAqKXRlc3RfZ3Zh KSA9IEdVRVNUX1RFU1RfUEY7Cit9CisKIC8qIGZyb20gZnB1L2ludGVybmFsLmggKi8KIHN0YXRp YyB1NjQgeGdldGJ2KHUzMiBpbmRleCkKIHsKQEAgLTE3NCw2ICsxODksOSBAQCBzdGF0aWMgdm9p ZCBndWVzdF9jb2RlKHZvaWQpCiAJCWNhc2UgR1VFU1RfVEVTVF9NU1I6CiAJCQlndWVzdF9tc3Jf dGVzdCgpOwogCQkJYnJlYWs7CisJCWNhc2UgR1VFU1RfVEVTVF9QRjoKKwkJCWd1ZXN0X3BmX3Rl c3QoKTsKKwkJCWJyZWFrOwogCQljYXNlIEdVRVNUX1RFU1RfWFNFVEJWOgogCQkJZ3Vlc3RfeHNl dGJ2X3Rlc3QoKTsKIAkJCWJyZWFrOwpAQCAtMTcyNyw2ICsxNzQ1LDYzIEBAIHN0YXRpYyB2b2lk IHRlc3RfY21kX3ZtX3NldF9wYWdlX2FjY2VzcyhzdHJ1Y3Qga3ZtX3ZtICp2bSkKIAlzZXRfcGFn ZV9hY2Nlc3MoZ3BhLCBmdWxsX2FjY2Vzcyk7CiB9CiAKK3N0YXRpYyB2b2lkIHRlc3RfcGYoc3Ry dWN0IGt2bV92bSAqdm0sIGZjdF9wZl9ldmVudCBjYmspCit7CisJX191MTYgZXZlbnRfaWQgPSBL Vk1JX1ZDUFVfRVZFTlRfUEY7CisJc3RydWN0IHZjcHVfd29ya2VyX2RhdGEgZGF0YSA9IHsKKwkJ LnZtID0gdm0sCisJCS52Y3B1X2lkID0gVkNQVV9JRCwKKwkJLnRlc3RfaWQgPSBHVUVTVF9URVNU X1BGLAorCX07CisJc3RydWN0IGt2bWlfbXNnX2hkciBoZHI7CisJc3RydWN0IHZjcHVfcmVwbHkg cnBsID0ge307CisJcHRocmVhZF90IHZjcHVfdGhyZWFkOworCXN0cnVjdCBwZl9ldiBldjsKKwor CXNldF9wYWdlX2FjY2Vzcyh0ZXN0X2dwYSwgS1ZNSV9QQUdFX0FDQ0VTU19SKTsKKwllbmFibGVf dmNwdV9ldmVudCh2bSwgZXZlbnRfaWQpOworCisJKigodWludDhfdCAqKXRlc3RfaHZhKSA9IH5H VUVTVF9URVNUX1BGOworCisJdmNwdV90aHJlYWQgPSBzdGFydF92Y3B1X3dvcmtlcigmZGF0YSk7 CisKKwlyZWNlaXZlX3ZjcHVfZXZlbnQoJmhkciwgJmV2LnZjcHVfZXYsIHNpemVvZihldiksIGV2 ZW50X2lkKTsKKworCXByX2RlYnVnKCJQRiBldmVudCwgZ3BhIDB4JWxseCwgZ3ZhIDB4JWxseCwg YWNjZXNzIDB4JXhcbiIsCisJCSBldi5wZi5ncGEsIGV2LnBmLmd2YSwgZXYucGYuYWNjZXNzKTsK KworCVRFU1RfQVNTRVJUKGV2LnBmLmdwYSA9PSB0ZXN0X2dwYSAmJiBldi5wZi5ndmEgPT0gdGVz dF9ndmEsCisJCSJVbmV4cGVjdGVkICNQRiBldmVudCwgZ3BhIDB4JWxseCAoZXhwZW5kZWQgMHgl bHgpLCBndmEgMHglbGx4IChleHBlY3RlZCAweCVseClcbiIsCisJCWV2LnBmLmdwYSwgdGVzdF9n cGEsIGV2LnBmLmd2YSwgdGVzdF9ndmEpOworCisJY2JrKHZtLCAmaGRyLCAmZXYsICZycGwpOwor CisJd2FpdF92Y3B1X3dvcmtlcih2Y3B1X3RocmVhZCk7CisKKwlURVNUX0FTU0VSVCgqKCh1aW50 OF90ICopdGVzdF9odmEpID09IEdVRVNUX1RFU1RfUEYsCisJCSJXcml0ZSBmYWlsZWQsIGV4cGVj dGVkIDB4JXgsIHJlc3VsdCAweCV4XG4iLAorCQlHVUVTVF9URVNUX1BGLCAqKCh1aW50OF90ICop dGVzdF9odmEpKTsKKworCWRpc2FibGVfdmNwdV9ldmVudCh2bSwgZXZlbnRfaWQpOworCXNldF9w YWdlX2FjY2Vzcyh0ZXN0X2dwYSwgS1ZNSV9QQUdFX0FDQ0VTU19SIHwKKwkJCQkgIEtWTUlfUEFH RV9BQ0NFU1NfVyB8CisJCQkJICBLVk1JX1BBR0VfQUNDRVNTX1gpOworfQorCitzdGF0aWMgdm9p ZCBjYmtfdGVzdF9ldmVudF9wZihzdHJ1Y3Qga3ZtX3ZtICp2bSwgc3RydWN0IGt2bWlfbXNnX2hk ciAqaGRyLAorCQkJCXN0cnVjdCBwZl9ldiAqZXYsIHN0cnVjdCB2Y3B1X3JlcGx5ICpycGwpCit7 CisJc2V0X3BhZ2VfYWNjZXNzKHRlc3RfZ3BhLCBLVk1JX1BBR0VfQUNDRVNTX1IgfCBLVk1JX1BB R0VfQUNDRVNTX1cpOworCisJcmVwbHlfdG9fZXZlbnQoaGRyLCAmZXYtPnZjcHVfZXYsIEtWTUlf RVZFTlRfQUNUSU9OX1JFVFJZLAorCQkJcnBsLCBzaXplb2YoKnJwbCkpOworfQorCitzdGF0aWMg dm9pZCB0ZXN0X2V2ZW50X3BmKHN0cnVjdCBrdm1fdm0gKnZtKQoreworCXRlc3RfcGYodm0sIGNi a190ZXN0X2V2ZW50X3BmKTsKK30KKwogc3RhdGljIHZvaWQgdGVzdF9pbnRyb3NwZWN0aW9uKHN0 cnVjdCBrdm1fdm0gKnZtKQogewogCXNyYW5kb20odGltZSgwKSk7CkBAIC0xNzU5LDYgKzE4MzQs NyBAQCBzdGF0aWMgdm9pZCB0ZXN0X2ludHJvc3BlY3Rpb24oc3RydWN0IGt2bV92bSAqdm0pCiAJ dGVzdF9ldmVudF9kZXNjcmlwdG9yKHZtKTsKIAl0ZXN0X2NtZF92Y3B1X2NvbnRyb2xfbXNyKHZt KTsKIAl0ZXN0X2NtZF92bV9zZXRfcGFnZV9hY2Nlc3Modm0pOworCXRlc3RfZXZlbnRfcGYodm0p OwogCiAJdW5ob29rX2ludHJvc3BlY3Rpb24odm0pOwogfQpkaWZmIC0tZ2l0IGEvdmlydC9rdm0v aW50cm9zcGVjdGlvbi9rdm1pLmMgYi92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWkuYwppbmRl eCA3OWY0ZWU1NjIzMGIuLjRiYzI5MzgyYmE1YSAxMDA2NDQKLS0tIGEvdmlydC9rdm0vaW50cm9z cGVjdGlvbi9rdm1pLmMKKysrIGIvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pLmMKQEAgLTM3 Nyw2ICszNzcsOCBAQCBzdGF0aWMgdm9pZCBfX2t2bWlfdW5ob29rKHN0cnVjdCBrdm0gKmt2bSkK IAlzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24gKmt2bWkgPSBLVk1JKGt2bSk7CiAKIAl3YWl0X2Zv cl9jb21wbGV0aW9uX2tpbGxhYmxlKCZrdm0tPmt2bWlfY29tcGxldGUpOworCisJa3ZtaV9hcmNo X3VuaG9vayhrdm0pOwogCWt2bWlfc29ja19wdXQoa3ZtaSk7CiB9CiAKQEAgLTQyNCw2ICs0MjYs OCBAQCBzdGF0aWMgaW50IF9fa3ZtaV9ob29rKHN0cnVjdCBrdm0gKmt2bSwKIAlpZiAoIWt2bWlf c29ja19nZXQoa3ZtaSwgaG9vay0+ZmQpKQogCQlyZXR1cm4gLUVJTlZBTDsKIAorCWt2bWlfYXJj aF9ob29rKGt2bSk7CisKIAlyZXR1cm4gMDsKIH0KIApAQCAtMTA1NiwzICsxMDYwLDExNSBAQCBp bnQga3ZtaV9zZXRfZ2ZuX2FjY2VzcyhzdHJ1Y3Qga3ZtICprdm0sIGdmbl90IGdmbiwgdTggYWNj ZXNzKQogCiAJcmV0dXJuIGVycjsKIH0KKworc3RhdGljIGludCBrdm1pX2dldF9nZm5fYWNjZXNz KHN0cnVjdCBrdm1faW50cm9zcGVjdGlvbiAqa3ZtaSwgY29uc3QgZ2ZuX3QgZ2ZuLAorCQkJICAg ICAgIHU4ICphY2Nlc3MpCit7CisJc3RydWN0IGt2bWlfbWVtX2FjY2VzcyAqbTsKKworCXJlYWRf bG9jaygma3ZtaS0+YWNjZXNzX3RyZWVfbG9jayk7CisJbSA9IF9fa3ZtaV9nZXRfZ2ZuX2FjY2Vz cyhrdm1pLCBnZm4pOworCWlmIChtKQorCQkqYWNjZXNzID0gbS0+YWNjZXNzOworCXJlYWRfdW5s b2NrKCZrdm1pLT5hY2Nlc3NfdHJlZV9sb2NrKTsKKworCXJldHVybiBtID8gMCA6IC0xOworfQor CitzdGF0aWMgYm9vbCBrdm1pX3Jlc3RyaWN0ZWRfcGFnZV9hY2Nlc3Moc3RydWN0IGt2bV9pbnRy b3NwZWN0aW9uICprdm1pLAorCQkJCQlncGFfdCBncGEsIHU4IGFjY2VzcykKK3sKKwl1OCBhbGxv d2VkX2FjY2VzczsKKwlpbnQgZXJyOworCisJZXJyID0ga3ZtaV9nZXRfZ2ZuX2FjY2Vzcyhrdm1p LCBncGFfdG9fZ2ZuKGdwYSksICZhbGxvd2VkX2FjY2Vzcyk7CisJaWYgKGVycikKKwkJcmV0dXJu IGZhbHNlOworCisJLyoKKwkgKiBXZSB3YW50IHRvIGJlIG5vdGlmaWVkIG9ubHkgZm9yIHZpb2xh dGlvbnMgaW52b2x2aW5nIGFjY2VzcworCSAqIGJpdHMgdGhhdCB3ZSd2ZSBzcGVjaWZpY2FsbHkg Y2xlYXJlZAorCSAqLworCWlmIChhY2Nlc3MgJiAofmFsbG93ZWRfYWNjZXNzKSkKKwkJcmV0dXJu IHRydWU7CisKKwlyZXR1cm4gZmFsc2U7Cit9CisKK2Jvb2wga3ZtaV9wZl9ldmVudChzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUsIGdwYV90IGdwYSwgZ3ZhX3QgZ3ZhLCB1OCBhY2Nlc3MpCit7CisJYm9v bCByZXQgPSBmYWxzZTsKKwl1MzIgYWN0aW9uOworCisJaWYgKCFrdm1pX3Jlc3RyaWN0ZWRfcGFn ZV9hY2Nlc3MoS1ZNSSh2Y3B1LT5rdm0pLCBncGEsIGFjY2VzcykpCisJCXJldHVybiB0cnVlOwor CisJYWN0aW9uID0ga3ZtaV9tc2dfc2VuZF92Y3B1X3BmKHZjcHUsIGdwYSwgZ3ZhLCBhY2Nlc3Mp OworCXN3aXRjaCAoYWN0aW9uKSB7CisJY2FzZSBLVk1JX0VWRU5UX0FDVElPTl9DT05USU5VRToK KwkJcmV0ID0gdHJ1ZTsKKwkJYnJlYWs7CisJY2FzZSBLVk1JX0VWRU5UX0FDVElPTl9SRVRSWToK KwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJa3ZtaV9oYW5kbGVfY29tbW9uX2V2ZW50X2FjdGlvbnMo dmNwdSwgYWN0aW9uKTsKKwl9CisKKwlyZXR1cm4gcmV0OworfQorCit2b2lkIGt2bWlfYWRkX21l bXNsb3Qoc3RydWN0IGt2bSAqa3ZtLCBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAorCQkg ICAgICB1bnNpZ25lZCBsb25nIG5wYWdlcykKK3sKKwlzdHJ1Y3Qga3ZtX2ludHJvc3BlY3Rpb24g Kmt2bWkgPSBLVk1JKGt2bSk7CisJZ2ZuX3Qgc3RhcnQgPSBzbG90LT5iYXNlX2dmbjsKKwlnZm5f dCBlbmQgPSBzdGFydCArIG5wYWdlczsKKwlpbnQgaWR4OworCisJaWR4ID0gc3JjdV9yZWFkX2xv Y2soJmt2bS0+c3JjdSk7CisJS1ZNX01NVV9MT0NLKGt2bSk7CisJcmVhZF9sb2NrKCZrdm1pLT5h Y2Nlc3NfdHJlZV9sb2NrKTsKKworCXdoaWxlIChzdGFydCA8IGVuZCkgeworCQlzdHJ1Y3Qga3Zt aV9tZW1fYWNjZXNzICptOworCisJCW0gPSBfX2t2bWlfZ2V0X2dmbl9hY2Nlc3Moa3ZtaSwgc3Rh cnQpOworCQlpZiAobSkKKwkJCWt2bWlfYXJjaF91cGRhdGVfcGFnZV90cmFja2luZyhrdm0sIHNs b3QsIG0pOworCQlzdGFydCsrOworCX0KKworCXJlYWRfdW5sb2NrKCZrdm1pLT5hY2Nlc3NfdHJl ZV9sb2NrKTsKKwlLVk1fTU1VX1VOTE9DSyhrdm0pOworCXNyY3VfcmVhZF91bmxvY2soJmt2bS0+ c3JjdSwgaWR4KTsKK30KKwordm9pZCBrdm1pX3JlbW92ZV9tZW1zbG90KHN0cnVjdCBrdm0gKmt2 bSwgc3RydWN0IGt2bV9tZW1vcnlfc2xvdCAqc2xvdCkKK3sKKwlzdHJ1Y3Qga3ZtX2ludHJvc3Bl Y3Rpb24gKmt2bWkgPSBLVk1JKGt2bSk7CisJZ2ZuX3Qgc3RhcnQgPSBzbG90LT5iYXNlX2dmbjsK KwlnZm5fdCBlbmQgPSBzdGFydCArIHNsb3QtPm5wYWdlczsKKwlpbnQgaWR4OworCisJaWR4ID0g c3JjdV9yZWFkX2xvY2soJmt2bS0+c3JjdSk7CisJS1ZNX01NVV9MT0NLKGt2bSk7CisJd3JpdGVf bG9jaygma3ZtaS0+YWNjZXNzX3RyZWVfbG9jayk7CisKKwl3aGlsZSAoc3RhcnQgPCBlbmQpIHsK KwkJc3RydWN0IGt2bWlfbWVtX2FjY2VzcyAqbTsKKworCQltID0gX19rdm1pX2dldF9nZm5fYWNj ZXNzKGt2bWksIHN0YXJ0KTsKKwkJaWYgKG0pIHsKKwkJCXU4IHByZXZfYWNjZXNzID0gbS0+YWNj ZXNzOworCisJCQltLT5hY2Nlc3MgPSBmdWxsX2FjY2VzczsKKwkJCWt2bWlfYXJjaF91cGRhdGVf cGFnZV90cmFja2luZyhrdm0sIHNsb3QsIG0pOworCQkJbS0+YWNjZXNzID0gcHJldl9hY2Nlc3M7 CisJCX0KKwkJc3RhcnQrKzsKKwl9CisKKwl3cml0ZV91bmxvY2soJmt2bWktPmFjY2Vzc190cmVl X2xvY2spOworCUtWTV9NTVVfVU5MT0NLKGt2bSk7CisJc3JjdV9yZWFkX3VubG9jaygma3ZtLT5z cmN1LCBpZHgpOworfQpkaWZmIC0tZ2l0IGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2lu dC5oIGIvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oCmluZGV4IDQxNzIwYjE5NDQ1 OC4uYmY2NTQ1ZTY2NDI1IDEwMDY0NAotLS0gYS92aXJ0L2t2bS9pbnRyb3NwZWN0aW9uL2t2bWlf aW50LmgKKysrIGIvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX2ludC5oCkBAIC02Myw2ICs2 Myw3IEBAIGludCBrdm1pX21zZ192Y3B1X3JlcGx5KGNvbnN0IHN0cnVjdCBrdm1pX3ZjcHVfbXNn X2pvYiAqam9iLAogdTMyIGt2bWlfbXNnX3NlbmRfdmNwdV9wYXVzZShzdHJ1Y3Qga3ZtX3ZjcHUg KnZjcHUpOwogdTMyIGt2bWlfbXNnX3NlbmRfdmNwdV9oeXBlcmNhbGwoc3RydWN0IGt2bV92Y3B1 ICp2Y3B1KTsKIHUzMiBrdm1pX21zZ19zZW5kX3ZjcHVfYnAoc3RydWN0IGt2bV92Y3B1ICp2Y3B1 LCB1NjQgZ3BhLCB1OCBpbnNuX2xlbik7Cit1MzIga3ZtaV9tc2dfc2VuZF92Y3B1X3BmKHN0cnVj dCBrdm1fdmNwdSAqdmNwdSwgdTY0IGdwYSwgdTY0IGd2YSwgdTggYWNjZXNzKTsKIAogLyoga3Zt aS5jICovCiB2b2lkICprdm1pX21zZ19hbGxvYyh2b2lkKTsKQEAgLTkzLDYgKzk0LDEwIEBAIGlu dCBrdm1pX2NtZF93cml0ZV9waHlzaWNhbChzdHJ1Y3Qga3ZtICprdm0sIHU2NCBncGEsIHNpemVf dCBzaXplLAogCQkJICAgIGNvbnN0IHZvaWQgKmJ1Zik7CiBpbnQga3ZtaV9jbWRfdmNwdV9wYXVz ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGJvb2wgd2FpdCk7CiBpbnQga3ZtaV9zZXRfZ2ZuX2Fj Y2VzcyhzdHJ1Y3Qga3ZtICprdm0sIGdmbl90IGdmbiwgdTggYWNjZXNzKTsKK2Jvb2wga3ZtaV9w Zl9ldmVudChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsIGdwYV90IGdwYSwgZ3ZhX3QgZ3ZhLCB1OCBh Y2Nlc3MpOwordm9pZCBrdm1pX2FkZF9tZW1zbG90KHN0cnVjdCBrdm0gKmt2bSwgc3RydWN0IGt2 bV9tZW1vcnlfc2xvdCAqc2xvdCwKKwkJICAgICAgdW5zaWduZWQgbG9uZyBucGFnZXMpOwordm9p ZCBrdm1pX3JlbW92ZV9tZW1zbG90KHN0cnVjdCBrdm0gKmt2bSwgc3RydWN0IGt2bV9tZW1vcnlf c2xvdCAqc2xvdCk7CiAKIC8qIGFyY2ggKi8KIHZvaWQga3ZtaV9hcmNoX2luaXRfdmNwdV9ldmVu dHNfbWFzayh1bnNpZ25lZCBsb25nICpzdXBwb3J0ZWQpOwpAQCAtMTE0LDUgKzExOSw3IEBAIHZv aWQga3ZtaV9hcmNoX3NlbmRfcGVuZGluZ19ldmVudChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpOwog dm9pZCBrdm1pX2FyY2hfdXBkYXRlX3BhZ2VfdHJhY2tpbmcoc3RydWN0IGt2bSAqa3ZtLAogCQkJ CSAgICBzdHJ1Y3Qga3ZtX21lbW9yeV9zbG90ICpzbG90LAogCQkJCSAgICBzdHJ1Y3Qga3ZtaV9t ZW1fYWNjZXNzICptKTsKK3ZvaWQga3ZtaV9hcmNoX2hvb2soc3RydWN0IGt2bSAqa3ZtKTsKK3Zv aWQga3ZtaV9hcmNoX3VuaG9vayhzdHJ1Y3Qga3ZtICprdm0pOwogCiAjZW5kaWYKZGlmZiAtLWdp dCBhL3ZpcnQva3ZtL2ludHJvc3BlY3Rpb24va3ZtaV9tc2cuYyBiL3ZpcnQva3ZtL2ludHJvc3Bl Y3Rpb24va3ZtaV9tc2cuYwppbmRleCBkMmY4NDNjYmUyYzAuLjc0NWQxMDk4MWI2ZiAxMDA2NDQK LS0tIGEvdmlydC9rdm0vaW50cm9zcGVjdGlvbi9rdm1pX21zZy5jCisrKyBiL3ZpcnQva3ZtL2lu dHJvc3BlY3Rpb24va3ZtaV9tc2cuYwpAQCAtODYyLDMgKzg2MiwyMiBAQCB1MzIga3ZtaV9tc2df c2VuZF92Y3B1X2JwKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IGdwYSwgdTggaW5zbl9sZW4p CiAKIAlyZXR1cm4gYWN0aW9uOwogfQorCit1MzIga3ZtaV9tc2dfc2VuZF92Y3B1X3BmKHN0cnVj dCBrdm1fdmNwdSAqdmNwdSwgdTY0IGdwYSwgdTY0IGd2YSwgdTggYWNjZXNzKQoreworCXN0cnVj dCBrdm1pX3ZjcHVfZXZlbnRfcGYgZTsKKwl1MzIgYWN0aW9uOworCWludCBlcnI7CisKKwltZW1z ZXQoJmUsIDAsIHNpemVvZihlKSk7CisJZS5ncGEgPSBncGE7CisJZS5ndmEgPSBndmE7CisJZS5h Y2Nlc3MgPSBhY2Nlc3M7CisKKwllcnIgPSBrdm1pX3NlbmRfdmNwdV9ldmVudCh2Y3B1LCBLVk1J X1ZDUFVfRVZFTlRfUEYsICZlLCBzaXplb2YoZSksCisJCQkJICAgTlVMTCwgMCwgJmFjdGlvbik7 CisJaWYgKGVycikKKwkJcmV0dXJuIEtWTUlfRVZFTlRfQUNUSU9OX0NPTlRJTlVFOworCisJcmV0 dXJuIGFjdGlvbjsKK30KX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18KVmlydHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZpcnR1YWxpemF0aW9uQGxpc3RzLmxp bnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGludXhmb3VuZGF0aW9uLm9yZy9tYWls bWFuL2xpc3RpbmZvL3ZpcnR1YWxpemF0aW9u