License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2007-12-17 05:59:56 +00:00
|
|
|
#ifndef __KVM_X86_LAPIC_H
|
|
|
|
|
#define __KVM_X86_LAPIC_H
|
|
|
|
|
|
2015-03-26 14:39:29 +00:00
|
|
|
#include <kvm/iodev.h>
|
2007-12-17 05:59:56 +00:00
|
|
|
|
|
|
|
|
#include <linux/kvm_host.h>
|
|
|
|
|
|
2021-01-26 13:48:11 +00:00
|
|
|
#include "hyperv.h"
|
|
|
|
|
|
2013-03-13 11:42:34 +00:00
|
|
|
#define KVM_APIC_INIT 0
|
|
|
|
|
#define KVM_APIC_SIPI 1
|
2016-05-04 19:09:40 +00:00
|
|
|
#define KVM_APIC_LVT_NUM 6
|
2013-03-13 11:42:34 +00:00
|
|
|
|
2019-12-04 19:07:19 +00:00
|
|
|
#define APIC_SHORT_MASK 0xc0000
|
|
|
|
|
#define APIC_DEST_NOSHORT 0x0
|
|
|
|
|
#define APIC_DEST_MASK 0x800
|
2016-05-04 19:09:48 +00:00
|
|
|
|
2017-07-26 11:32:59 +00:00
|
|
|
#define APIC_BUS_CYCLE_NS 1
|
|
|
|
|
#define APIC_BUS_FREQUENCY (1000000000ULL / APIC_BUS_CYCLE_NS)
|
|
|
|
|
|
2020-04-02 08:20:26 +00:00
|
|
|
#define APIC_BROADCAST 0xFF
|
|
|
|
|
#define X2APIC_BROADCAST 0xFFFFFFFFul
|
|
|
|
|
|
2018-05-09 20:56:04 +00:00
|
|
|
enum lapic_mode {
|
|
|
|
|
LAPIC_MODE_DISABLED = 0,
|
|
|
|
|
LAPIC_MODE_INVALID = X2APIC_ENABLE,
|
|
|
|
|
LAPIC_MODE_XAPIC = MSR_IA32_APICBASE_ENABLE,
|
|
|
|
|
LAPIC_MODE_X2APIC = MSR_IA32_APICBASE_ENABLE | X2APIC_ENABLE,
|
|
|
|
|
};
|
|
|
|
|
|
2012-07-26 15:01:50 +00:00
|
|
|
struct kvm_timer {
|
|
|
|
|
struct hrtimer timer;
|
|
|
|
|
s64 period; /* unit: ns */
|
2016-10-24 10:23:13 +00:00
|
|
|
ktime_t target_expiration;
|
2014-10-30 14:06:46 +00:00
|
|
|
u32 timer_mode;
|
2012-07-26 15:01:50 +00:00
|
|
|
u32 timer_mode_mask;
|
|
|
|
|
u64 tscdeadline;
|
2014-12-16 14:08:15 +00:00
|
|
|
u64 expired_tscdeadline;
|
2019-04-17 17:15:32 +00:00
|
|
|
u32 timer_advance_ns;
|
2019-05-20 08:18:08 +00:00
|
|
|
s64 advance_expire_delta;
|
2012-07-26 15:01:50 +00:00
|
|
|
atomic_t pending; /* accumulated triggered timers */
|
2016-06-13 21:20:01 +00:00
|
|
|
bool hv_timer_in_use;
|
2012-07-26 15:01:50 +00:00
|
|
|
};
|
|
|
|
|
|
2007-12-17 05:59:56 +00:00
|
|
|
struct kvm_lapic {
|
|
|
|
|
unsigned long base_address;
|
|
|
|
|
struct kvm_io_device dev;
|
2009-02-23 13:57:41 +00:00
|
|
|
struct kvm_timer lapic_timer;
|
|
|
|
|
u32 divide_count;
|
2007-12-17 05:59:56 +00:00
|
|
|
struct kvm_vcpu *vcpu;
|
2014-10-30 14:06:45 +00:00
|
|
|
bool sw_enabled;
|
2009-06-11 08:06:51 +00:00
|
|
|
bool irr_pending;
|
2015-06-30 20:19:16 +00:00
|
|
|
bool lvt0_in_nmi_mode;
|
2012-06-24 16:24:26 +00:00
|
|
|
/* Number of bits set in ISR. */
|
|
|
|
|
s16 isr_count;
|
|
|
|
|
/* The highest vector set in ISR; if -1 - invalid, must scan ISR. */
|
|
|
|
|
int highest_isr_cache;
|
2012-06-24 16:24:19 +00:00
|
|
|
/**
|
|
|
|
|
* APIC register page. The layout matches the register layout seen by
|
|
|
|
|
* the guest 1:1, because it is accessed by the vmx microcode.
|
|
|
|
|
* Note: Only one register, the TPR, is used by the microcode.
|
|
|
|
|
*/
|
2007-12-17 05:59:56 +00:00
|
|
|
void *regs;
|
2007-10-25 14:52:32 +00:00
|
|
|
gpa_t vapic_addr;
|
2013-11-20 18:23:22 +00:00
|
|
|
struct gfn_to_hva_cache vapic_cache;
|
2013-03-13 11:42:34 +00:00
|
|
|
unsigned long pending_events;
|
|
|
|
|
unsigned int sipi_vector;
|
2007-12-17 05:59:56 +00:00
|
|
|
};
|
2016-02-29 15:04:43 +00:00
|
|
|
|
|
|
|
|
struct dest_map;
|
|
|
|
|
|
KVM: lapic: Allow user to disable adaptive tuning of timer advancement
The introduction of adaptive tuning of lapic timer advancement did not
allow for the scenario where userspace would want to disable adaptive
tuning but still employ timer advancement, e.g. for testing purposes or
to handle a use case where adaptive tuning is unable to settle on a
suitable time. This is epecially pertinent now that KVM places a hard
threshold on the maximum advancment time.
Rework the timer semantics to accept signed values, with a value of '-1'
being interpreted as "use adaptive tuning with KVM's internal default",
and any other value being used as an explicit advancement time, e.g. a
time of '0' effectively disables advancement.
Note, this does not completely restore the original behavior of
lapic_timer_advance_ns. Prior to tracking the advancement per vCPU,
which is necessary to support autotuning, userspace could adjust
lapic_timer_advance_ns for *running* vCPU. With per-vCPU tracking, the
module params are snapshotted at vCPU creation, i.e. applying a new
advancement effectively requires restarting a VM.
Dynamically updating a running vCPU is possible, e.g. a helper could be
added to retrieve the desired delay, choosing between the global module
param and the per-VCPU value depending on whether or not auto-tuning is
(globally) enabled, but introduces a great deal of complexity. The
wrapper itself is not complex, but understanding and documenting the
effects of dynamically toggling auto-tuning and/or adjusting the timer
advancement is nigh impossible since the behavior would be dependent on
KVM's implementation as well as compiler optimizations. In other words,
providing stable behavior would require extremely careful consideration
now and in the future.
Given that the expected use of a manually-tuned timer advancement is to
"tune once, run many", use the vastly simpler approach of recognizing
changes to the module params only when creating a new vCPU.
Cc: Liran Alon <liran.alon@oracle.com>
Cc: Wanpeng Li <wanpengli@tencent.com>
Reviewed-by: Liran Alon <liran.alon@oracle.com>
Cc: stable@vger.kernel.org
Fixes: 3b8a5df6c4dc6 ("KVM: LAPIC: Tune lapic_timer_advance_ns automatically")
Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2019-04-17 17:15:33 +00:00
|
|
|
int kvm_create_lapic(struct kvm_vcpu *vcpu, int timer_advance_ns);
|
2007-12-17 05:59:56 +00:00
|
|
|
void kvm_free_lapic(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
|
|
|
|
int kvm_apic_has_interrupt(struct kvm_vcpu *vcpu);
|
|
|
|
|
int kvm_apic_accept_pic_intr(struct kvm_vcpu *vcpu);
|
|
|
|
|
int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu);
|
2021-06-04 17:26:04 +00:00
|
|
|
int kvm_apic_accept_events(struct kvm_vcpu *vcpu);
|
KVM: x86: INIT and reset sequences are different
x86 architecture defines differences between the reset and INIT sequences.
INIT does not initialize the FPU (including MMX, XMM, YMM, etc.), TSC, PMU,
MSRs (in general), MTRRs machine-check, APIC ID, APIC arbitration ID and BSP.
References (from Intel SDM):
"If the MP protocol has completed and a BSP is chosen, subsequent INITs (either
to a specific processor or system wide) do not cause the MP protocol to be
repeated." [8.4.2: MP Initialization Protocol Requirements and Restrictions]
[Table 9-1. IA-32 Processor States Following Power-up, Reset, or INIT]
"If the processor is reset by asserting the INIT# pin, the x87 FPU state is not
changed." [9.2: X87 FPU INITIALIZATION]
"The state of the local APIC following an INIT reset is the same as it is after
a power-up or hardware reset, except that the APIC ID and arbitration ID
registers are not affected." [10.4.7.3: Local APIC State After an INIT Reset
("Wait-for-SIPI" State)]
Signed-off-by: Nadav Amit <namit@cs.technion.ac.il>
Message-Id: <1428924848-28212-1-git-send-email-namit@cs.technion.ac.il>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2015-04-13 11:34:08 +00:00
|
|
|
void kvm_lapic_reset(struct kvm_vcpu *vcpu, bool init_event);
|
2007-12-17 05:59:56 +00:00
|
|
|
u64 kvm_lapic_get_cr8(struct kvm_vcpu *vcpu);
|
|
|
|
|
void kvm_lapic_set_tpr(struct kvm_vcpu *vcpu, unsigned long cr8);
|
2011-08-30 10:56:17 +00:00
|
|
|
void kvm_lapic_set_eoi(struct kvm_vcpu *vcpu);
|
2007-12-17 05:59:56 +00:00
|
|
|
void kvm_lapic_set_base(struct kvm_vcpu *vcpu, u64 value);
|
2008-04-27 19:14:13 +00:00
|
|
|
u64 kvm_lapic_get_base(struct kvm_vcpu *vcpu);
|
2020-02-26 02:41:02 +00:00
|
|
|
void kvm_recalculate_apic_map(struct kvm *kvm);
|
2009-07-05 14:39:35 +00:00
|
|
|
void kvm_apic_set_version(struct kvm_vcpu *vcpu);
|
2016-05-04 19:09:40 +00:00
|
|
|
bool kvm_apic_match_dest(struct kvm_vcpu *vcpu, struct kvm_lapic *source,
|
2019-12-04 19:07:20 +00:00
|
|
|
int shorthand, unsigned int dest, int dest_mode);
|
2019-12-04 19:07:17 +00:00
|
|
|
int kvm_apic_compare_prio(struct kvm_vcpu *vcpu1, struct kvm_vcpu *vcpu2);
|
KVM: nVMX: Morph notification vector IRQ on nested VM-Enter to pending PI
On successful nested VM-Enter, check for pending interrupts and convert
the highest priority interrupt to a pending posted interrupt if it
matches L2's notification vector. If the vCPU receives a notification
interrupt before nested VM-Enter (assuming L1 disables IRQs before doing
VM-Enter), the pending interrupt (for L1) should be recognized and
processed as a posted interrupt when interrupts become unblocked after
VM-Enter to L2.
This fixes a bug where L1/L2 will get stuck in an infinite loop if L1 is
trying to inject an interrupt into L2 by setting the appropriate bit in
L2's PIR and sending a self-IPI prior to VM-Enter (as opposed to KVM's
method of manually moving the vector from PIR->vIRR/RVI). KVM will
observe the IPI while the vCPU is in L1 context and so won't immediately
morph it to a posted interrupt for L2. The pending interrupt will be
seen by vmx_check_nested_events(), cause KVM to force an immediate exit
after nested VM-Enter, and eventually be reflected to L1 as a VM-Exit.
After handling the VM-Exit, L1 will see that L2 has a pending interrupt
in PIR, send another IPI, and repeat until L2 is killed.
Note, posted interrupts require virtual interrupt deliveriy, and virtual
interrupt delivery requires exit-on-interrupt, ergo interrupts will be
unconditionally unmasked on VM-Enter if posted interrupts are enabled.
Fixes: 705699a13994 ("KVM: nVMX: Enable nested posted interrupt processing")
Cc: stable@vger.kernel.org
Cc: Liran Alon <liran.alon@oracle.com>
Signed-off-by: Sean Christopherson <sean.j.christopherson@intel.com>
Message-Id: <20200812175129.12172-1-sean.j.christopherson@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2020-08-12 17:51:29 +00:00
|
|
|
void kvm_apic_clear_irr(struct kvm_vcpu *vcpu, int vec);
|
2017-12-24 16:12:54 +00:00
|
|
|
bool __kvm_apic_update_irr(u32 *pir, void *regs, int *max_irr);
|
|
|
|
|
bool kvm_apic_update_irr(struct kvm_vcpu *vcpu, u32 *pir, int *max_irr);
|
2016-12-18 13:02:21 +00:00
|
|
|
void kvm_apic_update_ppr(struct kvm_vcpu *vcpu);
|
2013-04-11 11:21:37 +00:00
|
|
|
int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq,
|
2016-02-29 15:04:43 +00:00
|
|
|
struct dest_map *dest_map);
|
2011-11-10 12:57:21 +00:00
|
|
|
int kvm_apic_local_deliver(struct kvm_lapic *apic, int lvt_type);
|
2019-11-14 20:15:04 +00:00
|
|
|
void kvm_apic_update_apicv(struct kvm_vcpu *vcpu);
|
2007-12-17 05:59:56 +00:00
|
|
|
|
2012-09-13 14:19:24 +00:00
|
|
|
bool kvm_irq_delivery_to_apic_fast(struct kvm *kvm, struct kvm_lapic *src,
|
2016-02-29 15:04:43 +00:00
|
|
|
struct kvm_lapic_irq *irq, int *r, struct dest_map *dest_map);
|
2020-03-26 02:20:02 +00:00
|
|
|
void kvm_apic_send_ipi(struct kvm_lapic *apic, u32 icr_low, u32 icr_high);
|
2012-09-13 14:19:24 +00:00
|
|
|
|
2007-12-17 05:59:56 +00:00
|
|
|
u64 kvm_get_apic_base(struct kvm_vcpu *vcpu);
|
2014-01-24 15:48:44 +00:00
|
|
|
int kvm_set_apic_base(struct kvm_vcpu *vcpu, struct msr_data *msr_info);
|
2016-07-12 20:09:22 +00:00
|
|
|
int kvm_apic_get_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s);
|
|
|
|
|
int kvm_apic_set_state(struct kvm_vcpu *vcpu, struct kvm_lapic_state *s);
|
2018-05-09 20:56:04 +00:00
|
|
|
enum lapic_mode kvm_get_apic_mode(struct kvm_vcpu *vcpu);
|
2007-12-17 05:59:56 +00:00
|
|
|
int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
2011-09-22 08:55:52 +00:00
|
|
|
u64 kvm_get_lapic_tscdeadline_msr(struct kvm_vcpu *vcpu);
|
|
|
|
|
void kvm_set_lapic_tscdeadline_msr(struct kvm_vcpu *vcpu, u64 data);
|
|
|
|
|
|
2013-01-25 02:18:49 +00:00
|
|
|
void kvm_apic_write_nodecode(struct kvm_vcpu *vcpu, u32 offset);
|
2013-01-25 02:18:51 +00:00
|
|
|
void kvm_apic_set_eoi_accelerated(struct kvm_vcpu *vcpu, int vector);
|
2013-01-25 02:18:49 +00:00
|
|
|
|
2013-11-20 18:23:22 +00:00
|
|
|
int kvm_lapic_set_vapic_addr(struct kvm_vcpu *vcpu, gpa_t vapic_addr);
|
2007-10-25 14:52:32 +00:00
|
|
|
void kvm_lapic_sync_from_vapic(struct kvm_vcpu *vcpu);
|
|
|
|
|
void kvm_lapic_sync_to_vapic(struct kvm_vcpu *vcpu);
|
|
|
|
|
|
2022-02-04 21:42:04 +00:00
|
|
|
int kvm_x2apic_icr_write(struct kvm_lapic *apic, u64 data);
|
2009-07-05 14:39:36 +00:00
|
|
|
int kvm_x2apic_msr_write(struct kvm_vcpu *vcpu, u32 msr, u64 data);
|
|
|
|
|
int kvm_x2apic_msr_read(struct kvm_vcpu *vcpu, u32 msr, u64 *data);
|
2010-01-17 13:51:23 +00:00
|
|
|
|
|
|
|
|
int kvm_hv_vapic_msr_write(struct kvm_vcpu *vcpu, u32 msr, u64 data);
|
|
|
|
|
int kvm_hv_vapic_msr_read(struct kvm_vcpu *vcpu, u32 msr, u64 *data);
|
|
|
|
|
|
2021-11-08 15:28:18 +00:00
|
|
|
int kvm_lapic_set_pv_eoi(struct kvm_vcpu *vcpu, u64 data, unsigned long len);
|
2016-12-16 22:30:36 +00:00
|
|
|
void kvm_lapic_exit(void);
|
2012-08-05 12:58:33 +00:00
|
|
|
|
2016-05-04 19:09:40 +00:00
|
|
|
#define VEC_POS(v) ((v) & (32 - 1))
|
|
|
|
|
#define REG_POS(v) (((v) >> 5) << 4)
|
|
|
|
|
|
2019-04-01 02:17:22 +00:00
|
|
|
static inline void kvm_lapic_clear_vector(int vec, void *bitmap)
|
|
|
|
|
{
|
|
|
|
|
clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-04 19:09:40 +00:00
|
|
|
static inline void kvm_lapic_set_vector(int vec, void *bitmap)
|
|
|
|
|
{
|
|
|
|
|
set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void kvm_lapic_set_irr(int vec, struct kvm_lapic *apic)
|
|
|
|
|
{
|
|
|
|
|
kvm_lapic_set_vector(vec, apic->regs + APIC_IRR);
|
|
|
|
|
/*
|
|
|
|
|
* irr_pending must be true if any interrupt is pending; set it after
|
|
|
|
|
* APIC_IRR to avoid race with apic_clear_irr
|
|
|
|
|
*/
|
|
|
|
|
apic->irr_pending = true;
|
|
|
|
|
}
|
|
|
|
|
|
2022-02-04 21:42:04 +00:00
|
|
|
static inline u32 __kvm_lapic_get_reg(char *regs, int reg_off)
|
2012-08-05 12:58:33 +00:00
|
|
|
{
|
2022-02-04 21:42:04 +00:00
|
|
|
return *((u32 *) (regs + reg_off));
|
2012-08-05 12:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
2022-02-04 21:42:04 +00:00
|
|
|
static inline u32 kvm_lapic_get_reg(struct kvm_lapic *apic, int reg_off)
|
2016-05-04 19:09:40 +00:00
|
|
|
{
|
2022-02-04 21:42:04 +00:00
|
|
|
return __kvm_lapic_get_reg(apic->regs, reg_off);
|
2016-05-04 19:09:40 +00:00
|
|
|
}
|
|
|
|
|
|
2021-01-11 15:24:35 +00:00
|
|
|
DECLARE_STATIC_KEY_FALSE(kvm_has_noapic_vcpu);
|
2012-08-05 12:58:33 +00:00
|
|
|
|
2016-01-08 12:48:51 +00:00
|
|
|
static inline bool lapic_in_kernel(struct kvm_vcpu *vcpu)
|
2012-08-05 12:58:33 +00:00
|
|
|
{
|
2021-01-11 15:24:35 +00:00
|
|
|
if (static_branch_unlikely(&kvm_has_noapic_vcpu))
|
2012-08-05 12:58:33 +00:00
|
|
|
return vcpu->arch.apic;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-11 15:24:35 +00:00
|
|
|
extern struct static_key_false_deferred apic_hw_disabled;
|
2012-08-05 12:58:33 +00:00
|
|
|
|
|
|
|
|
static inline int kvm_apic_hw_enabled(struct kvm_lapic *apic)
|
|
|
|
|
{
|
2021-01-11 15:24:35 +00:00
|
|
|
if (static_branch_unlikely(&apic_hw_disabled.key))
|
2012-08-05 12:58:33 +00:00
|
|
|
return apic->vcpu->arch.apic_base & MSR_IA32_APICBASE_ENABLE;
|
|
|
|
|
return MSR_IA32_APICBASE_ENABLE;
|
|
|
|
|
}
|
|
|
|
|
|
2021-01-11 15:24:35 +00:00
|
|
|
extern struct static_key_false_deferred apic_sw_disabled;
|
2012-08-05 12:58:33 +00:00
|
|
|
|
2014-10-30 14:06:47 +00:00
|
|
|
static inline bool kvm_apic_sw_enabled(struct kvm_lapic *apic)
|
2012-08-05 12:58:33 +00:00
|
|
|
{
|
2021-01-11 15:24:35 +00:00
|
|
|
if (static_branch_unlikely(&apic_sw_disabled.key))
|
2014-10-30 14:06:47 +00:00
|
|
|
return apic->sw_enabled;
|
|
|
|
|
return true;
|
2012-08-05 12:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline bool kvm_apic_present(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-01-08 12:48:51 +00:00
|
|
|
return lapic_in_kernel(vcpu) && kvm_apic_hw_enabled(vcpu->arch.apic);
|
2012-08-05 12:58:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int kvm_lapic_enabled(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
|
|
|
|
return kvm_apic_present(vcpu) && kvm_apic_sw_enabled(vcpu->arch.apic);
|
|
|
|
|
}
|
|
|
|
|
|
2013-01-25 02:18:50 +00:00
|
|
|
static inline int apic_x2apic_mode(struct kvm_lapic *apic)
|
|
|
|
|
{
|
|
|
|
|
return apic->vcpu->arch.apic_base & X2APIC_ENABLE;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-10 12:36:33 +00:00
|
|
|
static inline bool kvm_vcpu_apicv_active(struct kvm_vcpu *vcpu)
|
2013-01-25 02:18:51 +00:00
|
|
|
{
|
2015-11-10 12:36:33 +00:00
|
|
|
return vcpu->arch.apic && vcpu->arch.apicv_active;
|
2013-01-25 02:18:51 +00:00
|
|
|
}
|
|
|
|
|
|
2013-03-13 11:42:34 +00:00
|
|
|
static inline bool kvm_apic_has_events(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-01-08 12:48:51 +00:00
|
|
|
return lapic_in_kernel(vcpu) && vcpu->arch.apic->pending_events;
|
2013-03-13 11:42:34 +00:00
|
|
|
}
|
|
|
|
|
|
2015-03-19 01:26:04 +00:00
|
|
|
static inline bool kvm_lowest_prio_delivery(struct kvm_lapic_irq *irq)
|
|
|
|
|
{
|
|
|
|
|
return (irq->delivery_mode == APIC_DM_LOWEST ||
|
|
|
|
|
irq->msi_redir_hint);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-01 13:06:40 +00:00
|
|
|
static inline int kvm_lapic_latched_init(struct kvm_vcpu *vcpu)
|
|
|
|
|
{
|
2016-01-08 12:48:51 +00:00
|
|
|
return lapic_in_kernel(vcpu) && test_bit(KVM_APIC_INIT, &vcpu->arch.apic->pending_events);
|
2015-04-01 13:06:40 +00:00
|
|
|
}
|
|
|
|
|
|
2013-04-11 11:21:38 +00:00
|
|
|
bool kvm_apic_pending_eoi(struct kvm_vcpu *vcpu, int vector);
|
|
|
|
|
|
2019-05-20 08:18:09 +00:00
|
|
|
void kvm_wait_lapic_expire(struct kvm_vcpu *vcpu);
|
2014-12-16 14:08:15 +00:00
|
|
|
|
2019-11-07 12:53:43 +00:00
|
|
|
void kvm_bitmap_or_dest_vcpus(struct kvm *kvm, struct kvm_lapic_irq *irq,
|
|
|
|
|
unsigned long *vcpu_bitmap);
|
|
|
|
|
|
2015-09-18 14:29:47 +00:00
|
|
|
bool kvm_intr_is_single_vcpu_fast(struct kvm *kvm, struct kvm_lapic_irq *irq,
|
|
|
|
|
struct kvm_vcpu **dest_vcpu);
|
2016-01-25 08:53:33 +00:00
|
|
|
int kvm_vector_to_index(u32 vector, u32 dest_vcpus,
|
|
|
|
|
const unsigned long *bitmap, u32 bitmap_size);
|
2016-06-13 21:20:01 +00:00
|
|
|
void kvm_lapic_switch_to_sw_timer(struct kvm_vcpu *vcpu);
|
|
|
|
|
void kvm_lapic_switch_to_hv_timer(struct kvm_vcpu *vcpu);
|
|
|
|
|
void kvm_lapic_expired_hv_timer(struct kvm_vcpu *vcpu);
|
|
|
|
|
bool kvm_lapic_hv_timer_in_use(struct kvm_vcpu *vcpu);
|
2017-06-29 15:14:50 +00:00
|
|
|
void kvm_lapic_restart_hv_timer(struct kvm_vcpu *vcpu);
|
2020-05-05 10:45:35 +00:00
|
|
|
bool kvm_can_use_hv_timer(struct kvm_vcpu *vcpu);
|
2018-05-09 20:56:04 +00:00
|
|
|
|
|
|
|
|
static inline enum lapic_mode kvm_apic_mode(u64 apic_base)
|
|
|
|
|
{
|
|
|
|
|
return apic_base & (MSR_IA32_APICBASE_ENABLE | X2APIC_ENABLE);
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-18 02:50:31 +00:00
|
|
|
static inline u8 kvm_xapic_id(struct kvm_lapic *apic)
|
|
|
|
|
{
|
|
|
|
|
return kvm_lapic_get_reg(apic, APIC_ID) >> 24;
|
|
|
|
|
}
|
|
|
|
|
|
2007-12-17 05:59:56 +00:00
|
|
|
#endif
|