KVM: arm64: Remove the target table
cover KVM: arm64: Remove the target table
Hi guys,
KVM's target_table indirection is a relic from 32bit where different CPUs had different reset values for ACTLR. All 64bit CPUs have the same behaviour here, but we support different targets, that all map to the same behaviour.
This series removes the indirection and the fiddly handling of two tables.
We still need to offer user-space the preferred target, and check it selects a supported target, but we no longer do anything with the information.
This series based on v5.8-rc1, and can be retrieved from:git://git.kernel.org/pub/scm/linux/kernel/git/morse/linux.git kvm-arm64/kill_target_table/v1
Thanks,
James Morse (5):
KVM: arm64: Drop the target_table[] indirection
KVM: arm64: Tolerate an empty target_table list
KVM: arm64: Move ACTLR_EL1 emulation to the sys_reg_descs array
KVM: arm64: Remove target_table from exit handlers
KVM: arm64: Remove the target table
arch/arm64/include/asm/kvm_coproc.h | 8 -- arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/sys_regs.c | 177 +++++++++------------------ arch/arm64/kvm/sys_regs_generic_v8.c | 96 --------------- 4 files changed, 56 insertions(+), 227 deletions(-) delete mode 100644 arch/arm64/kvm/sys_regs_generic_v8.c
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH 1/5 KVM: arm64: Drop the target_table[] indirection
KVM for 32bit arm had a get/set target mechanism to allow for micro-architecture differences that are visible in system registers to be described.
KVM's user-space can query the supported targets for a CPU, and create vCPUs for that target. The target can override the handling of system registers to provide different reset or RES0 behaviour. On 32bit arm this was used to provide different ACTLR reset values for A7 and A15.
On 64bit arm, the first few CPUs out of the gate used this mechanism, before it was deemed redundant in commit bca556ac468a ("arm64/kvm:
Add generic v8 KVM target"). All future CPUs use the KVM_ARM_TARGET_GENERIC_V8 target.
The 64bit target_table[] stuff exists to preserve the ABI to user-space. As all targets registers genericv8_target_table, there is no reason to look the target up.
Until we can merge genericv8_target_table with the main sys_regs array, kvm_register_target_sys_reg_table() becomes kvm_check_target_sys_reg_table(), which uses BUG_ON() in keeping with the other callers in this file.
--- arch/arm64/include/asm/kvm_coproc.h | 3 +-- arch/arm64/kvm/sys_regs.c | 16 ++++------------ arch/arm64/kvm/sys_regs.h | 2 ++ arch/arm64/kvm/sys_regs_generic_v8.c | 15 ++------------- 4 files changed, 9 insertions(+), 27 deletions(-)
arch/arm64/include/asm/kvm_coproc.h +1 -2
@@ -24,8 +24,7 @@ struct kvm_sys_reg_target_table {struct kvm_sys_reg_table table32; }; -void kvm_register_target_sys_reg_table (unsigned int target, -struct kvm_sys_reg_target_table *table); +void kvm_check_target_sys_reg_table (struct kvm_sys_reg_target_table *table);int kvm_handle_cp14_load_store (struct kvm_vcpu *vcpu,struct kvm_run *run);int kvm_handle_cp14_32 (struct kvm_vcpu *vcpu,struct kvm_run *run);
arch/arm64/kvm/sys_regs.c +4 -12
@@ -2109,17 +2109,10 @@ static int check_sysreg_table(const struct sys_reg_desc *table, unsigned int n,return 0 ; } -/* Target specific emulation tables */ -static struct kvm_sys_reg_target_table *target_tables[KVM_ARM_NUM_TARGETS ]; - -void kvm_register_target_sys_reg_table (unsigned int target, -struct kvm_sys_reg_target_table *table) +void kvm_check_target_sys_reg_table (struct kvm_sys_reg_target_table *table) { -if (check_sysreg_table (table->table64.table, table->table64.num, false) || -check_sysreg_table (table->table32.table, table->table32.num, true)) -return ; - - target_tables[target] = table; +BUG_ON (check_sysreg_table (table->table64.table, table->table64.num, false)); +BUG_ON (check_sysreg_table (table->table32.table, table->table32.num, true)); }/* Get specific register table for this target. */
@@ -2127,9 +2120,8 @@ static const struct sys_reg_desc *get_target_table(unsigned target,bool mode_is_64, size_t *num) { - struct kvm_sys_reg_target_table *table; + struct kvm_sys_reg_target_table *table = &genericv8_target_table; - table = target_tables[target];if (mode_is_64) { *num = table->table64.num;return table->table64.table;
arch/arm64/kvm/sys_regs.h +2 -0
@@ -165,4 +165,6 @@ const struct sys_reg_desc *find_reg_by_id(u64 id, CRn(sys_reg_CRn(reg)), CRm(sys_reg_CRm(reg)), \ Op2(sys_reg_Op2(reg)) +extern struct kvm_sys_reg_target_table genericv8_target_table; +#endif /* __ARM64_KVM_SYS_REGS_LOCAL_H__ */
arch/arm64/kvm/sys_regs_generic_v8.c +2 -13
@@ -59,7 +59,7 @@ static const struct sys_reg_desc genericv8_cp15_regs[] = { access_actlr }, }; -static struct kvm_sys_reg_target_table genericv8_target_table = { +struct kvm_sys_reg_target_table genericv8_target_table = { .table64 = { .table = genericv8_sys_regs, .num =ARRAY_SIZE (genericv8_sys_regs),
@@ -78,18 +78,7 @@ static int __init sys_reg_genericv8_init(void)BUG_ON (cmp_sys_reg (&genericv8_sys_regs[i-1 ], &genericv8_sys_regs[i]) >=0 ); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_AEM_V8 , - &genericv8_target_table); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_FOUNDATION_V8 , - &genericv8_target_table); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_CORTEX_A53 , - &genericv8_target_table); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_CORTEX_A57 , - &genericv8_target_table); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_XGENE_POTENZA , - &genericv8_target_table); -kvm_register_target_sys_reg_table (KVM_ARM_TARGET_GENERIC_V8 , - &genericv8_target_table); +kvm_check_target_sys_reg_table (&genericv8_target_table);return 0 ; }
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH 2/5 KVM: arm64: Tolerate an empty target_table list
In reply to James MorseBefore emptying the target_table lists, and then removing their infrastructure, add some tolerance to an empty list.
Instead of bugging-out on an empty list, pretend we already reached the end in the two-list-walk.
--- arch/arm64/kvm/sys_regs.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
arch/arm64/kvm/sys_regs.c +4 -1
@@ -2809,7 +2809,10 @@ static int walk_sys_regs(struct kvm_vcpu *vcpu, u64 __user *uind) i2 = sys_reg_descs; end2 = sys_reg_descs +ARRAY_SIZE (sys_reg_descs); -BUG_ON (i1 == end1 || i2 == end2); +if (i1 == end1) + i1 =NULL ; + +BUG_ON (i2 == end2);/* Walk carefully, as both tables may refer to the same register. */ while (i1 || i2) {
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH 3/5 KVM: arm64: Move ACTLR_EL1 emulation to the sys_reg_descs array
In reply to James MorseThe only entry in the genericv8_sys_regs arrays is for emulation of ACTLR_EL1. As all targets emulate this in the same way, move it to sys_reg_descs[].
--- arch/arm64/kvm/sys_regs.c | 28 ++++++++++++++++++++++++++ arch/arm64/kvm/sys_regs_generic_v8.c | 30 ---------------------------- 2 files changed, 28 insertions(+), 30 deletions(-)
arch/arm64/kvm/sys_regs.c +28 -0
@@ -242,6 +242,25 @@ static bool access_vm_reg(struct kvm_vcpu *vcpu,return true; } +static bool access_actlr (struct kvm_vcpu *vcpu, +struct sys_reg_params *p, +const struct sys_reg_desc *r) +{ +if (p->is_write) +return ignore_write (vcpu, p); + + p->regval =vcpu_read_sys_reg (vcpu,ACTLR_EL1 ); + +if (p->is_aarch32) { +if (r->Op2 &2 ) + p->regval =upper_32_bits (p->regval); +else + p->regval =lower_32_bits (p->regval); + } + +return true; +} +/* * Trap handler for the GICv3 SGI generation system register. * Forward the request to the VGIC emulation.
@@ -615,6 +634,12 @@ static void reset_amair_el1(struct kvm_vcpu *vcpu, const struct sys_reg_desc *r)vcpu_write_sys_reg (vcpu, amair,AMAIR_EL1 ); } +static void reset_actlr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) +{ +u64 actlr =read_sysreg (actlr_el1); +vcpu_write_sys_reg (vcpu, actlr,ACTLR_EL1 ); +} +static void reset_mpidr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) {u64 mpidr;
@@ -1518,6 +1543,7 @@ static const struct sys_reg_desc sys_reg_descs[] = {ID_UNALLOCATED (7 ,7 ), { SYS_DESC(SYS_SCTLR_EL1), access_vm_reg, reset_val, SCTLR_EL1, 0x00C50078 }, + { SYS_DESC(SYS_ACTLR_EL1), access_actlr, reset_actlr, ACTLR_EL1 }, { SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 }, { SYS_DESC(SYS_ZCR_EL1), NULL, reset_val, ZCR_EL1, 0, .visibility = sve_visibility }, { SYS_DESC(SYS_TTBR0_EL1), access_vm_reg, reset_unknown, TTBR0_EL1 },
@@ -1957,6 +1983,8 @@ static const struct sys_reg_desc cp14_64_regs[] = {static const struct sys_reg_desc cp15_regs[] = { {Op1 (0 ),CRn (0 ),CRm (0 ),Op2 (1 ), access_ctr }, {Op1 (0 ),CRn (1 ),CRm (0 ),Op2 (0 ), access_vm_reg,NULL , c1_SCTLR }, + {Op1 (0 ),CRn (1 ),CRm (0 ),Op2 (1 ), access_actlr }, + {Op1 (0 ),CRn (1 ),CRm (0 ),Op2 (3 ), access_actlr }, {Op1 (0 ),CRn (2 ),CRm (0 ),Op2 (0 ), access_vm_reg,NULL , c2_TTBR0 }, {Op1 (0 ),CRn (2 ),CRm (0 ),Op2 (1 ), access_vm_reg,NULL , c2_TTBR1 }, {Op1 (0 ),CRn (2 ),CRm (0 ),Op2 (2 ), access_vm_reg,NULL , c2_TTBCR },
arch/arm64/kvm/sys_regs_generic_v8.c +0 -30
@@ -19,44 +19,14 @@#include "sys_regs.h" -static bool access_actlr (struct kvm_vcpu *vcpu, -struct sys_reg_params *p, -const struct sys_reg_desc *r) -{ -if (p->is_write) -return ignore_write (vcpu, p); - - p->regval =vcpu_read_sys_reg (vcpu,ACTLR_EL1 ); - -if (p->is_aarch32) { -if (r->Op2 &2 ) - p->regval =upper_32_bits (p->regval); -else - p->regval =lower_32_bits (p->regval); - } - -return true; -} - -static void reset_actlr (struct kvm_vcpu *vcpu,const struct sys_reg_desc *r) -{ -__vcpu_sys_reg (vcpu,ACTLR_EL1 ) =read_sysreg (actlr_el1); -} -/* * Implementation specific sys-reg registers. * Important: Must be sorted ascending by Op0, Op1, CRn, CRm, Op2 */ static const struct sys_reg_desc genericv8_sys_regs[] = { - {SYS_DESC (SYS_ACTLR_EL1 ), access_actlr, reset_actlr,ACTLR_EL1 }, };static const struct sys_reg_desc genericv8_cp15_regs[] = { -/* ACTLR */ - {Op1 (0b000 ),CRn (0b0001 ),CRm (0b0000 ),Op2 (0b001 ), - access_actlr }, - {Op1 (0b000 ),CRn (0b0001 ),CRm (0b0000 ),Op2 (0b011 ), - access_actlr }, };struct kvm_sys_reg_target_table genericv8_target_table = {
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH 4/5 KVM: arm64: Remove target_table from exit handlers
In reply to James MorseWhenever KVM searches for a register (e.g. due to a guest exit), it works with two tables, as the target table overrides the sys_regs array.
Now that everything is in the sys_regs array, and the target table is empty, stop doing that.
Remove the second table and its size from all the functions that take it.
--- arch/arm64/kvm/sys_regs.c | 87 +++++++-------------------------------- 1 file changed, 16 insertions(+), 71 deletions(-)
arch/arm64/kvm/sys_regs.c +16 -71
@@ -2269,9 +2269,7 @@ static void unhandled_cp_access(struct kvm_vcpu *vcpu,*/ static int kvm_handle_cp_64 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *global, -size_t nr_global, -const struct sys_reg_desc *target_specific, -size_t nr_specific) +size_t nr_global) {struct sys_reg_params params;u32 hsr =kvm_vcpu_get_hsr (vcpu);
@@ -2298,14 +2296,11 @@ static int kvm_handle_cp_64(struct kvm_vcpu *vcpu, }/* -* Try to emulate the coprocessor access using the target -* specific table first, and using the global table afterwards. -* If either of the tables contains a handler, handle the +* If the table contains a handler, handle the * potential register operation in the case of a read and return * with success. */ -if (!emulate_cp (vcpu, ¶ms, target_specific, nr_specific) || - !emulate_cp (vcpu, ¶ms, global, nr_global)) { +if (!emulate_cp (vcpu, ¶ms, global, nr_global)) {/* Split up the value between registers for the read side */ if (!params.is_write) {vcpu_set_reg (vcpu, Rt,lower_32_bits (params.regval));
@@ -2326,9 +2321,7 @@ static int kvm_handle_cp_64(struct kvm_vcpu *vcpu,*/ static int kvm_handle_cp_32 (struct kvm_vcpu *vcpu,const struct sys_reg_desc *global, -size_t nr_global, -const struct sys_reg_desc *target_specific, -size_t nr_specific) +size_t nr_global) {struct sys_reg_params params;u32 hsr =kvm_vcpu_get_hsr (vcpu);
@@ -2344,8 +2337,7 @@ static int kvm_handle_cp_32(struct kvm_vcpu *vcpu, params.Op1 = (hsr >>14 ) &0x7 ; params.Op2 = (hsr >>17 ) &0x7 ; -if (!emulate_cp (vcpu, ¶ms, target_specific, nr_specific) || - !emulate_cp (vcpu, ¶ms, global, nr_global)) { +if (!emulate_cp (vcpu, ¶ms, global, nr_global)) {if (!params.is_write)vcpu_set_reg (vcpu, Rt, params.regval);return 1 ;
@@ -2357,38 +2349,22 @@ static int kvm_handle_cp_32(struct kvm_vcpu *vcpu,int kvm_handle_cp15_64 (struct kvm_vcpu *vcpu,struct kvm_run *run) { -const struct sys_reg_desc *target_specific; -size_t num; - - target_specific =get_target_table (vcpu->arch.target, false, &num); -return kvm_handle_cp_64 (vcpu, - cp15_64_regs,ARRAY_SIZE (cp15_64_regs), - target_specific, num); +return kvm_handle_cp_64 (vcpu, cp15_64_regs,ARRAY_SIZE (cp15_64_regs)); }int kvm_handle_cp15_32 (struct kvm_vcpu *vcpu,struct kvm_run *run) { -const struct sys_reg_desc *target_specific; -size_t num; - - target_specific =get_target_table (vcpu->arch.target, false, &num); -return kvm_handle_cp_32 (vcpu, - cp15_regs,ARRAY_SIZE (cp15_regs), - target_specific, num); +return kvm_handle_cp_32 (vcpu, cp15_regs,ARRAY_SIZE (cp15_regs)); }int kvm_handle_cp14_64 (struct kvm_vcpu *vcpu,struct kvm_run *run) { -return kvm_handle_cp_64 (vcpu, - cp14_64_regs,ARRAY_SIZE (cp14_64_regs), -NULL ,0 ); +return kvm_handle_cp_64 (vcpu, cp14_64_regs,ARRAY_SIZE (cp14_64_regs)); }int kvm_handle_cp14_32 (struct kvm_vcpu *vcpu,struct kvm_run *run) { -return kvm_handle_cp_32 (vcpu, - cp14_regs,ARRAY_SIZE (cp14_regs), -NULL ,0 ); +return kvm_handle_cp_32 (vcpu, cp14_regs,ARRAY_SIZE (cp14_regs)); }static bool is_imp_def_sys_reg (struct sys_reg_params *params)
@@ -2400,15 +2376,9 @@ static bool is_imp_def_sys_reg(struct sys_reg_params *params)static int emulate_sys_reg (struct kvm_vcpu *vcpu,struct sys_reg_params *params) { -size_t num; -const struct sys_reg_desc *table, *r; - - table =get_target_table (vcpu->arch.target, true, &num); +const struct sys_reg_desc *r; -/* Search target-specific then generic table. */ - r =find_reg (params, table, num); -if (!r) - r =find_reg (params, sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); + r =find_reg (params, sys_reg_descs,ARRAY_SIZE (sys_reg_descs));if (likely (r)) {perform_access (vcpu, params, r);
@@ -2512,8 +2482,7 @@ const struct sys_reg_desc *find_reg_by_id(u64 id,static const struct sys_reg_desc *index_to_sys_reg_desc (struct kvm_vcpu *vcpu,u64 id) { -size_t num; -const struct sys_reg_desc *table, *r; +const struct sys_reg_desc *r;struct sys_reg_params params;/* We only do sys_reg for now. */
@@ -2523,10 +2492,7 @@ static const struct sys_reg_desc *index_to_sys_reg_desc(struct kvm_vcpu *vcpu,if (!index_to_params (id, ¶ms))return NULL ; - table =get_target_table (vcpu->arch.target, true, &num); - r =find_reg (¶ms, table, num); -if (!r) - r =find_reg (¶ms, sys_reg_descs,ARRAY_SIZE (sys_reg_descs)); + r =find_reg (¶ms, sys_reg_descs,ARRAY_SIZE (sys_reg_descs));/* Not saved in the sys_reg array and not otherwise accessible? */ if (r && !(r->reg || r->get_user))
@@ -2826,38 +2792,17 @@ static int walk_one_sys_reg(const struct kvm_vcpu *vcpu,/* Assumed ordered tables, see kvm_sys_reg_table_init. */ static int walk_sys_regs (struct kvm_vcpu *vcpu,u64 __user *uind) { -const struct sys_reg_desc *i1, *i2, *end1, *end2; +const struct sys_reg_desc *i2, *end2;unsigned int total =0 ; -size_t num;int err; -/* We check for duplicates here, to allow arch-specific overrides. */ - i1 =get_target_table (vcpu->arch.target, true, &num); - end1 = i1 + num; i2 = sys_reg_descs; end2 = sys_reg_descs +ARRAY_SIZE (sys_reg_descs); -if (i1 == end1) - i1 =NULL ; - -BUG_ON (i2 == end2); - -/* Walk carefully, as both tables may refer to the same register. */ -while (i1 || i2) { -int cmp =cmp_sys_reg (i1, i2); -/* target-specific overrides generic entry. */ -if (cmp <=0 ) - err =walk_one_sys_reg (vcpu, i1, &uind, &total); -else - err =walk_one_sys_reg (vcpu, i2, &uind, &total); - +while (i2 != end2) { + err =walk_one_sys_reg (vcpu, i2++, &uind, &total);if (err)return err; - -if (cmp <=0 && ++i1 == end1) - i1 =NULL ; -if (cmp >=0 && ++i2 == end2) - i2 =NULL ; }return total; }
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH 5/5 KVM: arm64: Remove the target table
In reply to James MorseFinally, remove the target table. Merge the code that checks the tables into kvm_reset_sys_regs() as there is now only one table.
--- arch/arm64/include/asm/kvm_coproc.h | 7 ---- arch/arm64/kvm/Makefile | 2 +- arch/arm64/kvm/sys_regs.c | 57 ++++++---------------------- arch/arm64/kvm/sys_regs.h | 2 - arch/arm64/kvm/sys_regs_generic_v8.c | 55 --------------------------- 5 files changed, 12 insertions(+), 111 deletions(-) delete mode 100644 arch/arm64/kvm/sys_regs_generic_v8.c
arch/arm64/include/asm/kvm_coproc.h +0 -7
@@ -19,13 +19,6 @@ struct kvm_sys_reg_table {size_t num; }; -struct kvm_sys_reg_target_table { -struct kvm_sys_reg_table table64; -struct kvm_sys_reg_table table32; -}; - -void kvm_check_target_sys_reg_table (struct kvm_sys_reg_target_table *table); -int kvm_handle_cp14_load_store (struct kvm_vcpu *vcpu,struct kvm_run *run);int kvm_handle_cp14_32 (struct kvm_vcpu *vcpu,struct kvm_run *run);int kvm_handle_cp14_64 (struct kvm_vcpu *vcpu,struct kvm_run *run);
arch/arm64/kvm/Makefile +1 -1
@@ -14,7 +14,7 @@ kvm-y := $(KVM)/kvm_main.o $(KVM)/coalesced_mmio.o $(KVM)/eventfd.o \ $(KVM)/vfio.o $(KVM)/irqchip.o \ arm.o mmu.o mmio.o psci.o perf.o hypercalls.o pvtime.o \ inject_fault.o regmap.o va_layout.o hyp.o hyp-init.o handle_exit.o \ - guest.o debug.o reset.o sys_regs.o sys_regs_generic_v8.o \ + guest.o debug.o reset.o sys_regs.o \ vgic-sys-reg-v3.o fpsimd.o pmu.o \ aarch32.o arch_timer.o \ vgic/vgic.o vgic/vgic-init.o \
arch/arm64/kvm/sys_regs.c +11 -46
75 lines not on this page · raw message
arch/arm64/kvm/sys_regs.h +0 -2
@@ -165,6 +165,4 @@ const struct sys_reg_desc *find_reg_by_id(u64 id,CRn (sys_reg_CRn (reg)),CRm (sys_reg_CRm (reg)), \ Op2(sys_reg_Op2(reg)) -extern struct kvm_sys_reg_target_table genericv8_target_table; -#endif /* __ARM64_KVM_SYS_REGS_LOCAL_H__ */
arch/arm64/kvm/sys_regs_generic_v8.c deleted +0 -55
55 lines not on this page · raw message
Signature · 6 lines
2.20.1 _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
Quoted 9 lines · James Morse
KVM's
target_tableindirection is a relic from 32bit where different CPUs had different reset values for ACTLR. All 64bit CPUs have the same behaviour here, but we support different targets, that all map to the same behaviour.This series removes the indirection and the fiddly handling of two tables.
[...]
Applied to kvm-arm64/next-5.9, thanks!
[1/5] KVM: arm64: Drop the target_table[] indirection
commit: 6b33e0d64f8501b51d32069e08d3ed68c58c25b4
[2/5] KVM: arm64: Tolerate an empty target_table list
commit: 04343ae312ef0d80d601ea1b784b6b039ae9c82a
[3/5] KVM: arm64: Move ACTLR_EL1 emulation to the sys_reg_descs array
commit: af4738290d9dfe3787f60e40f709a4f78a115943
[4/5] KVM: arm64: Remove target_table from exit handlers
commit: dcaffa7bf911578a6d69165d712501996c587fbe
[5/5] KVM: arm64: Remove the target table
commit: 750ed56693803e992ed09ac9c46e07226dd4d350Cheers,
M.
Signature · 7 lines
Without deviation from the norm, progress is not possible. _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm