From patchwork Wed May 4 19:09:46 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Suthikulpanit, Suravee" X-Patchwork-Id: 67175 Delivered-To: patch@linaro.org Received: by 10.140.92.199 with SMTP id b65csp358519qge; Wed, 4 May 2016 12:12:56 -0700 (PDT) X-Received: by 10.98.73.88 with SMTP id w85mr14654632pfa.82.1462389176454; Wed, 04 May 2016 12:12:56 -0700 (PDT) Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id bw8si6358157pad.127.2016.05.04.12.12.56; Wed, 04 May 2016 12:12:56 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@amdcloud.onmicrosoft.com; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755639AbcEDTMx (ORCPT + 29 others); Wed, 4 May 2016 15:12:53 -0400 Received: from mail-by2on0089.outbound.protection.outlook.com ([207.46.100.89]:23920 "EHLO na01-by2-obe.outbound.protection.outlook.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1755111AbcEDTK4 (ORCPT ); Wed, 4 May 2016 15:10:56 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amdcloud.onmicrosoft.com; s=selector1-amd-com; h=From:To:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=Z5fCzKAb6qsIFUtFDZuqkjlIzPqca534s4hQFDH1H9s=; b=jkVXg9h0Rt0g++dn8v/Y+OTpOd1T0sAbRXghxgxMPgUmthYHk47KWFJhid3ggFp1R61sT7D0uxo68M3mNOWrhD6yZaX0+IJFxlNq9uqaYfIHp0vhuo2iIAXrwTdTZ0PSwVCH9dBYqoFNs7Qqep7qsS7mOoj/94TbE8Lxcci3o/c= Authentication-Results: redhat.com; dkim=none (message not signed) header.d=none; redhat.com; dmarc=none action=none header.from=amd.com; Received: from ssuthiku-cz-dev.amd.com (165.204.77.1) by BLUPR12MB0433.namprd12.prod.outlook.com (10.162.92.139) with Microsoft SMTP Server (TLS) id 15.1.477.8; Wed, 4 May 2016 19:10:45 +0000 From: Suravee Suthikulpanit To: , , , , , CC: , , , , Suravee Suthikulpanit , Suravee Suthikulpanit Subject: [PART1 V5 07/13] KVM: x86: Detect and Initialize AVIC support Date: Wed, 4 May 2016 14:09:46 -0500 Message-ID: <1462388992-25242-8-git-send-email-Suravee.Suthikulpanit@amd.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1462388992-25242-1-git-send-email-Suravee.Suthikulpanit@amd.com> References: <1462388992-25242-1-git-send-email-Suravee.Suthikulpanit@amd.com> MIME-Version: 1.0 X-Originating-IP: [165.204.77.1] X-ClientProxiedBy: BY2PR21CA0014.namprd21.prod.outlook.com (10.162.74.152) To BLUPR12MB0433.namprd12.prod.outlook.com (10.162.92.139) X-MS-Office365-Filtering-Correlation-Id: 630de9c5-5791-450f-2c2b-08d3744fcf48 X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0433; 2:YXf00doSYdfkUDWmU22YbenmR5Y//J+vDQPYcXr6ogqBDMXAN8qen8iiqm7R87ps4HbSAf7OZHeBSWluDZcwGo9AVrQuHyeYeV0XwbI7YIFWTnvRv6pra/xSAtdWhK2gTMK3oUyzNQDQTr5Fhlb/TLCacmUpHHLU8KtH1+/o3ARLn3Sh33Uv+wUGwfbXj/zW; 3:msV8sBbl3SU0Rt8Xb9jC6/3LrKy52y5kiUEoVj6apofgZ3LTib2U1J/HyV/sWporcOcKPRlM8G1YJbeFD6Fh8EM0iSW/g+UoK/YgfvRBIVhQwzJrDC5N82fD/a4hfnBN; 25:6/vguJh1YHe9SmnB7yx4PPpdqwZMkOMxV/3ksJ/WgXA0fAVcnHZnS0ahKX1VBb3B+nmfqDo5R2IQqMnHIn0gqj8maDfQVP1IFglxiF8wSpEQ+OQuHB39aLO2fbrYV5aXBNiV4a2EmiTqKRn9tMEOxV4KogrFoPpF1dByI7kz7CxxU2a+oEvbROlKmGgAkUYLHTxngG6CyBKd471bzUHtfScXh8N7Oe10NSUf2Sv9ln/Y0XFT8WhG4elTcOgw21iNIQ/44W0sZb1l8kRwZbnhagi/DaG2/tcuvwUMU++hMi+TkBOSKJnkIVRrwIIB7z75B9be3lr0hI+h160xwxGYoQ== X-Microsoft-Antispam: UriScan:;BCL:0;PCL:0;RULEID:;SRVR:BLUPR12MB0433; X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0433; 20:NaOLtImj6b9FDYy0KZHNEpbr/drWMkYCtPElVUcJ2gJ5l9feU+zjAGnU6GHSJW6fdhVXGbq/OUxGkIrG9Vhvgm4pCTR0T00bxY6dFNR1wteLGoejjzVfMaoZ+SJhbE9O+w1kx9NA/OD9w5+kNRjZZzpo11eu9ovDghnT4+ToHY5kwBM+EM48BuRtJ48bLIzjb0FljxIYmYeDGUQU8BAsKQxfRtG2qUEH18J8YgEu/4qkutImC07wozc3h+bG+rVFp4aGJkBiWOv4R68EU9hPy7X1x+1uPiDTQi4+a+RxFjG/UofSpFsffMlrUKgR3VBUMiToncVUla48ZNEN6SWv3i9YDQ2avUZWftUoEuMneqVo4BHm4ttD3hNH6XqO4DGSRck/aTvR4YrTkDHeclZrFjp+CsYP6nXvdbI2noR4AqxSHR5O0/bdygtmBHHXjYQFQaB6yssKerEhW3wJLouQJFBDIkzajRBt6s/GfJQvjb/FsjBwc04EiOFGxz7AoYBa; 4:jUfwizLevQruyvJzX17cJ3zSPHa//m2Brer4V7rYXLOQdUnRYbwfkaJhZAGa1OGH6X0R5KcFE06XcocLZbYVG9PuBK2PWI1CJiYB8GAvgv8m0sFxjlF9Uip3r4MVEvixw1OO/SylqDpHsS5MCWX5fMhGSluy3ztGc9N6ttZJoPXD3elHlLbgnvS3GRnlVPzPYxFkA8siED/Z73J2t9Gc5hc86S92XXUZNzXR/NIWjPKMT8DR57CxXpXDlDBHjUGA3AKwpYXUtHT9TRGXlHzLwI2jyTShr7a6MVviaaWqyckDIELUO80oFWSsEfWlHA5lO6ub66J/EsElCoh6Xsa2+KKnjmS30YBkkTT1fgycIJGal/bCzTh8PCF1D1oKenA1vcsAUNhMimF+cO49E3UUG/U0cIdYyWt7RR9UnoK0n0yJ6ugVVw8kDHcvpTaaNGky X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(9101528026)(9101521098)(601004)(2401047)(8121501046)(5005006)(3002001)(10201501046)(6055026); SRVR:BLUPR12MB0433; BCL:0; PCL:0; RULEID:; SRVR:BLUPR12MB0433; X-Forefront-PRVS: 093290AD39 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6009001)(50986999)(76176999)(50226002)(47776003)(66066001)(229853001)(36756003)(189998001)(19580395003)(19580405001)(2906002)(2950100001)(5003940100001)(53416004)(2201001)(5004730100002)(92566002)(4326007)(5001770100001)(77096005)(586003)(42186005)(5008740100001)(81166005)(48376002)(3846002)(6116002)(575784001)(86362001)(50466002); DIR:OUT; SFP:1101; SCL:1; SRVR:BLUPR12MB0433; H:ssuthiku-cz-dev.amd.com; FPR:; SPF:None; MLV:sfv; LANG:en; X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0433; 23:Bi4vCYxCIxcXwyenAxWE94y6xLGVlC+yg75VM5ew5q76owdVCwyOsxTf04nxNweSa7ORUScXiZhPu5XRbuYdSbjpSkS91FvUR5blMVvT2QioxYGm16W58uQi8G3wPLNkZzkYJMkQOq+WGVx/eW9ILFqUSz0cRDcMEXBr3OTmpN6xYIgLld2qccHpT0AIZhoeXmioRnp7Ohf6d1RxG2Zcg0LneAX2/Xn0x3gIQ7rpY2MFzK9YjMr2ObMOg2gq+Tn7vPqSB/hUIi2GL8EgfjAOpok/+Lz0GlUFtx19vdAkvKDHjRV+t8x1pEf2FYTQC8Wup6H78NlAsoFPZgNd7aRzk2WsDaAKQ9lDIEep5SBlosjX+XW51i25rqO2WfG2LmBm6yWKzaqqrh0CJgiSULpXmyfCVdVAMbsHzRej1Dyl+FT2WuR/hFVmWwcLvy4njTUROi0P/cMz07agBbBhuaJMRr7crYayg6DECVifWw+Tl85TumpbO6HmDVvrzax1rU7UJu8+dzilwrKBcv7K4+y5wdQRxyVvBB7doiGRUH9OpUZpGCdp+jycmqDR7PlvNH4KnCUlR3ofACCxMXj7DSifKWkUI8xNY2c30oZycDzA6fR0sKg9A58eoq/DlTkA6Aa1dXJERHRNU3kED3+vBE1mMuhdDtV/eSZAX1l2hQTrj43FXwYk03PxTdahFTj/KGkpFiqUTAb5FbHa6camX1qqX81qgci87B3UqHsiQ+ZinSBJoaxckbWdVpk8oVsQ+2ogTtRjv9JWadrtLtV1yGKSvT13P4I4AMEQVstj4UuJNlaSdtlrjQ0LuxCuq41Xf49BgdlVWifqgiMOZgk+1SmqIQRASJXxDgYWm9FiP395cfnlV2D22PNUqAhLdR8BGjWu8PUolDyHUhfGtF016FZldQ== X-Microsoft-Exchange-Diagnostics: 1; BLUPR12MB0433; 5:gx2mA1d7uaAqByNuHoFiKhSpSETYEwWE2Yvx7DRwBA8vqR2kmy1/82kmvz+gwpKlaXW1wRVdTOE7s2uUpQR10/z++f+lAGZL3A+p5Rt+TBXxQnMP3P9rlZhi2bKE8JXtPRV2cFi/ENzVXHBUEmhW2A==; 24:0h6INMF+eGBEMclYiB10AGeLTLrUv1Rr4fVK6LG1xzZzWr93XaYhZXqWDw3MFBy+LR7eh0463JdOeKDSZ6+K+lde9oJNjgpwVMWlmLMt+v4=; 7:U1vA68S2/MuaELgdErnG3oIx/6qhuWL74SD+YOeDfAFGoQNcS4Zv5QIpBjCqaoj+5A19ax7HiCbrVditrZYH1b8be1/CfrFKqtgM+/iJA9t97WqXmDiOeeOwnZqY5Tg+Kuxn/j2thgH3XYJGWzxuzKtDIzTIQqCPLQh/02wueBs=; 20:C0w1gIbSfsX0/B7Hv0tQh/vYymn/uhazHCmIRo901R6DGQn6OVTJSW0sAQqZdEx+4aEeEvwngTPdpIT4snFzjeU7g6s1RE9glrjwUoIxWAoF1j75Y1veubYPybBSOQ5eU25Sqlk8PdqgLD+R1/ZDe2YHukt4ZqndmzAWyPA0legKeYINk/ENbAmKATGu5ZTBB5nhhAx3Ppp0X2IDfwWNJVPBpTZSTI6Xt3G+A5QpkQ+43XG35u07LG/3zAMutyfo X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 04 May 2016 19:10:45.0564 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: BLUPR12MB0433 Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch introduces AVIC-related data structure, and AVIC initialization code. There are three main data structures for AVIC: * Virtual APIC (vAPIC) backing page (per-VCPU) * Physical APIC ID table (per-VM) * Logical APIC ID table (per-VM) Currently, AVIC is disabled by default. Users can manually enable AVIC via kernel boot option kvm-amd.avic=1 or during kvm-amd module loading with parameter avic=1. Signed-off-by: Suravee Suthikulpanit --- arch/x86/include/asm/kvm_host.h | 4 + arch/x86/include/asm/svm.h | 3 + arch/x86/kvm/svm.c | 224 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 230 insertions(+), 1 deletion(-) -- 1.9.1 diff --git a/arch/x86/include/asm/kvm_host.h b/arch/x86/include/asm/kvm_host.h index 1454859..1ff2d46 100644 --- a/arch/x86/include/asm/kvm_host.h +++ b/arch/x86/include/asm/kvm_host.h @@ -774,6 +774,10 @@ struct kvm_arch { u8 nr_reserved_ioapic_pins; bool disabled_lapic_found; + + /* Struct members for AVIC */ + struct page *avic_logical_id_table_page; + struct page *avic_physical_id_table_page; }; struct kvm_vm_stat { diff --git a/arch/x86/include/asm/svm.h b/arch/x86/include/asm/svm.h index 4711fa4..d0fe23e 100644 --- a/arch/x86/include/asm/svm.h +++ b/arch/x86/include/asm/svm.h @@ -116,6 +116,9 @@ struct __attribute__ ((__packed__)) vmcb_control_area { #define V_INTR_MASKING_SHIFT 24 #define V_INTR_MASKING_MASK (1 << V_INTR_MASKING_SHIFT) +#define AVIC_ENABLE_SHIFT 31 +#define AVIC_ENABLE_MASK (1 << AVIC_ENABLE_SHIFT) + #define SVM_INTERRUPT_SHADOW_MASK 1 #define SVM_IOIO_STR_SHIFT 2 diff --git a/arch/x86/kvm/svm.c b/arch/x86/kvm/svm.c index 31346a3..4b00dc6 100644 --- a/arch/x86/kvm/svm.c +++ b/arch/x86/kvm/svm.c @@ -14,6 +14,9 @@ * the COPYING file in the top-level directory. * */ + +#define pr_fmt(fmt) "SVM: " fmt + #include #include "irq.h" @@ -78,6 +81,14 @@ MODULE_DEVICE_TABLE(x86cpu, svm_cpu_id); #define TSC_RATIO_MIN 0x0000000000000001ULL #define TSC_RATIO_MAX 0x000000ffffffffffULL +#define AVIC_HPA_MASK ~((0xFFFULL << 52) || 0xFFF) + +/* + * 0xff is broadcast, so the max index allowed for physical APIC ID + * table is 0xfe. APIC IDs above 0xff are reserved. + */ +#define AVIC_MAX_PHYSICAL_ID_COUNT 255 + static bool erratum_383_found __read_mostly; static const u32 host_save_user_msrs[] = { @@ -162,8 +173,19 @@ struct vcpu_svm { /* cached guest cpuid flags for faster access */ bool nrips_enabled : 1; + + struct page *avic_backing_page; + u64 *avic_physical_id_cache; }; +#define AVIC_LOGICAL_ID_ENTRY_GUEST_PHYSICAL_ID_MASK (0xFF) +#define AVIC_LOGICAL_ID_ENTRY_VALID_MASK (1 << 31) + +#define AVIC_PHYSICAL_ID_ENTRY_HOST_PHYSICAL_ID_MASK (0xFFULL) +#define AVIC_PHYSICAL_ID_ENTRY_BACKING_PAGE_MASK (0xFFFFFFFFFFULL << 12) +#define AVIC_PHYSICAL_ID_ENTRY_IS_RUNNING_MASK (1ULL << 62) +#define AVIC_PHYSICAL_ID_ENTRY_VALID_MASK (1ULL << 63) + static DEFINE_PER_CPU(u64, current_tsc_ratio); #define TSC_RATIO_DEFAULT 0x0100000000ULL @@ -205,6 +227,10 @@ module_param(npt, int, S_IRUGO); static int nested = true; module_param(nested, int, S_IRUGO); +/* enable / disable AVIC */ +static int avic; +module_param(avic, int, S_IRUGO); + static void svm_set_cr0(struct kvm_vcpu *vcpu, unsigned long cr0); static void svm_flush_tlb(struct kvm_vcpu *vcpu); static void svm_complete_interrupts(struct vcpu_svm *svm); @@ -228,12 +254,18 @@ enum { VMCB_SEG, /* CS, DS, SS, ES, CPL */ VMCB_CR2, /* CR2 only */ VMCB_LBR, /* DBGCTL, BR_FROM, BR_TO, LAST_EX_FROM, LAST_EX_TO */ + VMCB_AVIC, /* AVIC APIC_BAR, AVIC APIC_BACKING_PAGE, + * AVIC PHYSICAL_TABLE pointer, + * AVIC LOGICAL_TABLE pointer + */ VMCB_DIRTY_MAX, }; /* TPR and CR2 are always written before VMRUN */ #define VMCB_ALWAYS_DIRTY_MASK ((1U << VMCB_INTR) | (1U << VMCB_CR2)) +#define VMCB_AVIC_APIC_BAR_MASK 0xFFFFFFFFFF000ULL + static inline void mark_all_dirty(struct vmcb *vmcb) { vmcb->control.clean = 0; @@ -255,6 +287,12 @@ static inline struct vcpu_svm *to_svm(struct kvm_vcpu *vcpu) return container_of(vcpu, struct vcpu_svm, vcpu); } +static inline void avic_update_vapic_bar(struct vcpu_svm *svm, u64 data) +{ + svm->vmcb->control.avic_vapic_bar = data & VMCB_AVIC_APIC_BAR_MASK; + mark_dirty(svm->vmcb, VMCB_AVIC); +} + static void recalc_intercepts(struct vcpu_svm *svm) { struct vmcb_control_area *c, *h; @@ -923,6 +961,12 @@ static __init int svm_hardware_setup(void) } else kvm_disable_tdp(); + if (avic && (!npt_enabled || !boot_cpu_has(X86_FEATURE_AVIC))) + avic = false; + + if (avic) + pr_info("AVIC enabled\n"); + return 0; err: @@ -1000,6 +1044,22 @@ static void svm_adjust_tsc_offset_guest(struct kvm_vcpu *vcpu, s64 adjustment) mark_dirty(svm->vmcb, VMCB_INTERCEPTS); } +static void avic_init_vmcb(struct vcpu_svm *svm) +{ + struct vmcb *vmcb = svm->vmcb; + struct kvm_arch *vm_data = &svm->vcpu.kvm->arch; + phys_addr_t bpa = page_to_phys(svm->avic_backing_page); + phys_addr_t lpa = page_to_phys(vm_data->avic_logical_id_table_page); + phys_addr_t ppa = page_to_phys(vm_data->avic_physical_id_table_page); + + vmcb->control.avic_backing_page = bpa & AVIC_HPA_MASK; + vmcb->control.avic_logical_id = lpa & AVIC_HPA_MASK; + vmcb->control.avic_physical_id = ppa & AVIC_HPA_MASK; + vmcb->control.avic_physical_id |= AVIC_MAX_PHYSICAL_ID_COUNT; + vmcb->control.int_ctl |= AVIC_ENABLE_MASK; + svm->vcpu.arch.apicv_active = true; +} + static void init_vmcb(struct vcpu_svm *svm) { struct vmcb_control_area *control = &svm->vmcb->control; @@ -1110,9 +1170,130 @@ static void init_vmcb(struct vcpu_svm *svm) set_intercept(svm, INTERCEPT_PAUSE); } + if (avic) + avic_init_vmcb(svm); + mark_all_dirty(svm->vmcb); enable_gif(svm); + +} + +static u64 *avic_get_physical_id_entry(struct kvm_vcpu *vcpu, int index) +{ + u64 *avic_physical_id_table; + struct kvm_arch *vm_data = &vcpu->kvm->arch; + + if (index >= AVIC_MAX_PHYSICAL_ID_COUNT) + return NULL; + + avic_physical_id_table = page_address(vm_data->avic_physical_id_table_page); + + return &avic_physical_id_table[index]; +} + +/** + * Note: + * AVIC hardware walks the nested page table to check permissions, + * but does not use the SPA address specified in the leaf page + * table entry since it uses address in the AVIC_BACKING_PAGE pointer + * field of the VMCB. Therefore, we set up the + * APIC_ACCESS_PAGE_PRIVATE_MEMSLOT (4KB) here. + */ +static int avic_init_access_page(struct kvm_vcpu *vcpu) +{ + int ret = 0; + struct kvm *kvm = vcpu->kvm; + + if (!kvm->arch.apic_access_page_done) { + ret = x86_set_memory_region(kvm, + APIC_ACCESS_PAGE_PRIVATE_MEMSLOT, + APIC_DEFAULT_PHYS_BASE, + PAGE_SIZE); + if (ret) + return ret; + kvm->arch.apic_access_page_done = true; + } + + return ret; +} + +static int avic_init_backing_page(struct kvm_vcpu *vcpu) +{ + int ret; + u64 *entry, new_entry; + int id = vcpu->vcpu_id; + struct vcpu_svm *svm = to_svm(vcpu); + + ret = avic_init_access_page(vcpu); + if (ret) + return ret; + + if (id >= AVIC_MAX_PHYSICAL_ID_COUNT) + return -EINVAL; + + if (!svm->vcpu.arch.apic->regs) + return -EINVAL; + + svm->avic_backing_page = virt_to_page(svm->vcpu.arch.apic->regs); + + /* Setting AVIC backing page address in the phy APIC ID table */ + entry = avic_get_physical_id_entry(vcpu, id); + if (!entry) + return -EINVAL; + + new_entry = READ_ONCE(*entry); + new_entry = (page_to_phys(svm->avic_backing_page) & + AVIC_PHYSICAL_ID_ENTRY_BACKING_PAGE_MASK) | + AVIC_PHYSICAL_ID_ENTRY_VALID_MASK; + WRITE_ONCE(*entry, new_entry); + + svm->avic_physical_id_cache = entry; + + return 0; +} + +static void avic_vm_destroy(struct kvm *kvm) +{ + struct kvm_arch *vm_data = &kvm->arch; + + if (vm_data->avic_logical_id_table_page) + __free_page(vm_data->avic_logical_id_table_page); + if (vm_data->avic_physical_id_table_page) + __free_page(vm_data->avic_physical_id_table_page); +} + +static int avic_vm_init(struct kvm *kvm) +{ + int err = -ENOMEM; + struct kvm_arch *vm_data = &kvm->arch; + struct page *p_page; + struct page *l_page; + + if (!avic) + return 0; + + /* Allocating physical APIC ID table (4KB) */ + p_page = alloc_page(GFP_KERNEL); + if (!p_page) + goto free_avic; + + vm_data->avic_physical_id_table_page = p_page; + clear_page(page_address(p_page)); + + /* Allocating logical APIC ID table (4KB) */ + l_page = alloc_page(GFP_KERNEL); + if (!l_page) + goto free_avic; + + vm_data->avic_logical_id_table_page = l_page; + clear_page(page_address(l_page)); + + return 0; + +free_avic: + avic_vm_destroy(kvm); + return err; } static void svm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) @@ -1131,6 +1312,9 @@ static void svm_vcpu_reset(struct kvm_vcpu *vcpu, bool init_event) kvm_cpuid(vcpu, &eax, &dummy, &dummy, &dummy); kvm_register_write(vcpu, VCPU_REGS_RDX, eax); + + if (kvm_vcpu_apicv_active(vcpu) && !init_event) + avic_update_vapic_bar(svm, APIC_DEFAULT_PHYS_BASE); } static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id) @@ -1169,6 +1353,12 @@ static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id) if (!hsave_page) goto free_page3; + if (avic) { + err = avic_init_backing_page(&svm->vcpu); + if (err) + goto free_page4; + } + svm->nested.hsave = page_address(hsave_page); svm->msrpm = page_address(msrpm_pages); @@ -1187,6 +1377,8 @@ static struct kvm_vcpu *svm_create_vcpu(struct kvm *kvm, unsigned int id) return &svm->vcpu; +free_page4: + __free_page(hsave_page); free_page3: __free_pages(nested_msrpm_pages, MSRPM_ALLOC_ORDER); free_page2: @@ -3212,6 +3404,10 @@ static int svm_set_msr(struct kvm_vcpu *vcpu, struct msr_data *msr) case MSR_VM_IGNNE: vcpu_unimpl(vcpu, "unimplemented wrmsr: 0x%x data 0x%llx\n", ecx, data); break; + case MSR_IA32_APICBASE: + if (kvm_vcpu_apicv_active(vcpu)) + avic_update_vapic_bar(to_svm(vcpu), data); + /* Follow through */ default: return kvm_set_msr_common(vcpu, msr); } @@ -3375,10 +3571,14 @@ static void dump_vmcb(struct kvm_vcpu *vcpu) pr_err("%-20s%08x\n", "exit_int_info_err:", control->exit_int_info_err); pr_err("%-20s%lld\n", "nested_ctl:", control->nested_ctl); pr_err("%-20s%016llx\n", "nested_cr3:", control->nested_cr3); + pr_err("%-20s%016llx\n", "avic_vapic_bar:", control->avic_vapic_bar); pr_err("%-20s%08x\n", "event_inj:", control->event_inj); pr_err("%-20s%08x\n", "event_inj_err:", control->event_inj_err); pr_err("%-20s%lld\n", "lbr_ctl:", control->lbr_ctl); pr_err("%-20s%016llx\n", "next_rip:", control->next_rip); + pr_err("%-20s%016llx\n", "avic_backing_page:", control->avic_backing_page); + pr_err("%-20s%016llx\n", "avic_logical_id:", control->avic_logical_id); + pr_err("%-20s%016llx\n", "avic_physical_id:", control->avic_physical_id); pr_err("VMCB State Save Area:\n"); pr_err("%-5s s: %04x a: %04x l: %08x b: %016llx\n", "es:", @@ -3606,11 +3806,28 @@ static void svm_set_virtual_x2apic_mode(struct kvm_vcpu *vcpu, bool set) static bool svm_get_enable_apicv(void) { - return false; + return avic; } +static void svm_hwapic_irr_update(struct kvm_vcpu *vcpu, int max_irr) +{ +} + +static void svm_hwapic_isr_update(struct kvm *kvm, int isr) +{ +} + +/* Note: Currently only used by Hyper-V. */ static void svm_refresh_apicv_exec_ctrl(struct kvm_vcpu *vcpu) { + struct vcpu_svm *svm = to_svm(vcpu); + struct vmcb *vmcb = svm->vmcb; + + if (!avic) + return; + + vmcb->control.int_ctl &= ~AVIC_ENABLE_MASK; + mark_dirty(vmcb, VMCB_INTR); } static void svm_load_eoi_exitmap(struct kvm_vcpu *vcpu, u64 *eoi_exit_bitmap) @@ -4322,6 +4539,9 @@ static struct kvm_x86_ops svm_x86_ops = { .vcpu_free = svm_free_vcpu, .vcpu_reset = svm_vcpu_reset, + .vm_init = avic_vm_init, + .vm_destroy = avic_vm_destroy, + .prepare_guest_switch = svm_prepare_guest_switch, .vcpu_load = svm_vcpu_load, .vcpu_put = svm_vcpu_put, @@ -4382,6 +4602,8 @@ static struct kvm_x86_ops svm_x86_ops = { .refresh_apicv_exec_ctrl = svm_refresh_apicv_exec_ctrl, .load_eoi_exitmap = svm_load_eoi_exitmap, .sync_pir_to_irr = svm_sync_pir_to_irr, + .hwapic_irr_update = svm_hwapic_irr_update, + .hwapic_isr_update = svm_hwapic_isr_update, .set_tss_addr = svm_set_tss_addr, .get_tdp_level = get_npt_level,