KVM: Support vCPU-based gfn->hva cache

Provide versions of struct gfn_to_hva_cache functions that take vcpu as a parameter instead of struct kvm. The existing functions are not needed anymore, so delete them. This allows dirty pages to be logged in the vcpu dirty ring, instead of the global dirty ring, for ring-based dirty memory tracking.

Cao, Lei committed 9 years ago

Commit bbd64111 parent 4bd518f4 files · +55 −58Browse files

Unified · Split

4 files

arch/x86/kvm/lapic.c +10 −12
arch/x86/kvm/x86.c +20 −21
include/linux/kvm_host.h +8 −8
virt/kvm/kvm_main.c +17 −17

arch/x86/kvm/lapic.c+10−12

@@ -529,16 +529,14 @@ int kvm_apic_set_irq(struct kvm_vcpu vcpu, struct kvm_lapic_irq irq, · 528 unmodified lines
529	529
530	530	static int pv_eoi_put_user(struct kvm_vcpu *vcpu, u8 val)
531	531	{
532		−
533		− return kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.pv_eoi.data, &val,
534		− sizeof(val));
	532	+ return kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.pv_eoi.data, &val,
	533	+ sizeof(val));
535	534	}
536	535
537	536	static int pv_eoi_get_user(struct kvm_vcpu vcpu, u8 val)
538	537	{
539		−
540		− return kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.pv_eoi.data, val,
541		− sizeof(*val));
	538	+ return kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.pv_eoi.data, val,
	539	+ sizeof(*val));
542	540	}
543	541
544	542	static inline bool pv_eoi_enabled(struct kvm_vcpu *vcpu)
@@ -2287,8 +2285,8 @@ void kvm_lapic_sync_from_vapic(struct kvm_vcpu *vcpu) · 1742 unmodified lines
2287	2285	if (!test_bit(KVM_APIC_CHECK_VAPIC, &vcpu->arch.apic_attention))
2288	2286	return;
2289	2287
2290		− if (kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.apic->vapic_cache, &data,
2291		− sizeof(u32)))
	2288	+ if (kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.apic->vapic_cache, &data,
	2289	+ sizeof(u32)))
2292	2290	return;
2293	2291
2294	2292	apic_set_tpr(vcpu->arch.apic, data & 0xff);
@@ -2340,14 +2338,14 @@ void kvm_lapic_sync_to_vapic(struct kvm_vcpu *vcpu) · 45 unmodified lines
2340	2338	max_isr = 0;
2341	2339	data = (tpr & 0xff) \| ((max_isr & 0xf0) << 8) \| (max_irr << 24);
2342	2340
2343		− kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.apic->vapic_cache, &data,
2344		− sizeof(u32));
	2341	+ kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.apic->vapic_cache, &data,
	2342	+ sizeof(u32));
2345	2343	}
2346	2344
2347	2345	int kvm_lapic_set_vapic_addr(struct kvm_vcpu *vcpu, gpa_t vapic_addr)
2348	2346	{
2349	2347	if (vapic_addr) {
2350		− if (kvm_gfn_to_hva_cache_init(vcpu->kvm,
	2348	+ if (kvm_vcpu_gfn_to_hva_cache_init(vcpu,
2351	2349	&vcpu->arch.apic->vapic_cache,
2352	2350	vapic_addr, sizeof(u32)))
2353	2351	return -EINVAL;
@@ -2441,7 +2439,7 @@ int kvm_lapic_enable_pv_eoi(struct kvm_vcpu *vcpu, u64 data) · 87 unmodified lines
2441	2439	vcpu->arch.pv_eoi.msr_val = data;
2442	2440	if (!pv_eoi_enabled(vcpu))
2443	2441	return 0;
2444		− return kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.pv_eoi.data,
	2442	+ return kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.pv_eoi.data,
2445	2443	addr, sizeof(u8));
2446	2444	}
2447	2445

arch/x86/kvm/x86.c+20−21

@@ -1811,7 +1811,7 @@ static void kvm_setup_pvclock_page(struct kvm_vcpu *v) · 1810 unmodified lines
1811	1811	struct kvm_vcpu_arch *vcpu = &v->arch;
1812	1812	struct pvclock_vcpu_time_info guest_hv_clock;
1813	1813
1814		− if (unlikely(kvm_read_guest_cached(v->kvm, &vcpu->pv_time,
	1814	+ if (unlikely(kvm_vcpu_read_guest_cached(v, &vcpu->pv_time,
1815	1815	&guest_hv_clock, sizeof(guest_hv_clock))))
1816	1816	return;
1817	1817
@@ -1832,9 +1832,9 @@ static void kvm_setup_pvclock_page(struct kvm_vcpu *v) · 14 unmodified lines
1832	1832	BUILD_BUG_ON(offsetof(struct pvclock_vcpu_time_info, version) != 0);
1833	1833
1834	1834	vcpu->hv_clock.version = guest_hv_clock.version + 1;
1835		− kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
1836		− &vcpu->hv_clock,
1837		− sizeof(vcpu->hv_clock.version));
	1835	+ kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
	1836	+ &vcpu->hv_clock,
	1837	+ sizeof(vcpu->hv_clock.version));
1838	1838
1839	1839	smp_wmb();
1840	1840
@@ -1848,16 +1848,16 @@ static void kvm_setup_pvclock_page(struct kvm_vcpu *v) · 7 unmodified lines
1848	1848
1849	1849	trace_kvm_pvclock_update(v->vcpu_id, &vcpu->hv_clock);
1850	1850
1851		− kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
1852		− &vcpu->hv_clock,
1853		− sizeof(vcpu->hv_clock));
	1851	+ kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
	1852	+ &vcpu->hv_clock,
	1853	+ sizeof(vcpu->hv_clock));
1854	1854
1855	1855	smp_wmb();
1856	1856
1857	1857	vcpu->hv_clock.version++;
1858		− kvm_write_guest_cached(v->kvm, &vcpu->pv_time,
1859		− &vcpu->hv_clock,
1860		− sizeof(vcpu->hv_clock.version));
	1858	+ kvm_vcpu_write_guest_cached(v, &vcpu->pv_time,
	1859	+ &vcpu->hv_clock,
	1860	+ sizeof(vcpu->hv_clock.version));
1861	1861	}
1862	1862
1863	1863	static int kvm_guest_time_update(struct kvm_vcpu *v)
@@ -2090,7 +2090,7 @@ static int kvm_pv_enable_async_pf(struct kvm_vcpu *vcpu, u64 data) · 226 unmodified lines
2090	2090	return 0;
2091	2091	}
2092	2092
2093		− if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.apf.data, gpa,
	2093	+ if (kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.apf.data, gpa,
2094	2094	sizeof(u32)))
2095	2095	return 1;
2096	2096
@@ -2109,7 +2109,7 @@ static void record_steal_time(struct kvm_vcpu *vcpu) · 12 unmodified lines
2109	2109	if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED))
2110	2110	return;
2111	2111
2112		− if (unlikely(kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
	2112	+ if (unlikely(kvm_vcpu_read_guest_cached(vcpu, &vcpu->arch.st.stime,
2113	2113	&vcpu->arch.st.steal, sizeof(struct kvm_steal_time))))
2114	2114	return;
2115	2115
@@ -2120,7 +2120,7 @@ static void record_steal_time(struct kvm_vcpu *vcpu) · 4 unmodified lines
2120	2120
2121	2121	vcpu->arch.st.steal.version += 1;
2122	2122
2123		− kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
	2123	+ kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
2124	2124	&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
2125	2125
2126	2126	smp_wmb();
@@ -2129,14 +2129,14 @@ static void record_steal_time(struct kvm_vcpu *vcpu) · 2 unmodified lines
2129	2129	vcpu->arch.st.last_steal;
2130	2130	vcpu->arch.st.last_steal = current->sched_info.run_delay;
2131	2131
2132		− kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
	2132	+ kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
2133	2133	&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
2134	2134
2135	2135	smp_wmb();
2136	2136
2137	2137	vcpu->arch.st.steal.version += 1;
2138	2138
2139		− kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime,
	2139	+ kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.st.stime,
2140	2140	&vcpu->arch.st.steal, sizeof(struct kvm_steal_time));
2141	2141	}
2142	2142
@@ -2241,7 +2241,7 @@ int kvm_set_msr_common(struct kvm_vcpu vcpu, struct msr_data msr_info) · 98 unmodified lines
2241	2241	if (!(data & 1))
2242	2242	break;
2243	2243
2244		− if (kvm_gfn_to_hva_cache_init(vcpu->kvm,
	2244	+ if (kvm_vcpu_gfn_to_hva_cache_init(vcpu,
2245	2245	&vcpu->arch.pv_time, data & ~1ULL,
2246	2246	sizeof(struct pvclock_vcpu_time_info)))
2247	2247	vcpu->arch.pv_time_enabled = false;
@@ -2262,7 +2262,7 @@ int kvm_set_msr_common(struct kvm_vcpu vcpu, struct msr_data msr_info) · 14 unmodified lines
2262	2262	if (data & KVM_STEAL_RESERVED_MASK)
2263	2263	return 1;
2264	2264
2265		− if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.st.stime,
	2265	+ if (kvm_vcpu_gfn_to_hva_cache_init(vcpu, &vcpu->arch.st.stime,
2266	2266	data & KVM_STEAL_VALID_BITS,
2267	2267	sizeof(struct kvm_steal_time)))
2268	2268	return 1;
@@ -2875,7 +2875,7 @@ static void kvm_steal_time_set_preempted(struct kvm_vcpu *vcpu) · 606 unmodified lines
2875	2875
2876	2876	vcpu->arch.st.steal.preempted = 1;
2877	2877
2878		− kvm_write_guest_offset_cached(vcpu->kvm, &vcpu->arch.st.stime,
	2878	+ kvm_vcpu_write_guest_offset_cached(vcpu, &vcpu->arch.st.stime,
2879	2879	&vcpu->arch.st.steal.preempted,
2880	2880	offsetof(struct kvm_steal_time, preempted),
2881	2881	sizeof(vcpu->arch.st.steal.preempted));
@@ -8533,9 +8533,8 @@ static void kvm_del_async_pf_gfn(struct kvm_vcpu *vcpu, gfn_t gfn) · 5651 unmodified lines
8533	8533
8534	8534	static int apf_put_user(struct kvm_vcpu *vcpu, u32 val)
8535	8535	{
8536		−
8537		− return kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.apf.data, &val,
8538		− sizeof(val));
	8536	+ return kvm_vcpu_write_guest_cached(vcpu, &vcpu->arch.apf.data, &val,
	8537	+ sizeof(val));
8539	8538	}
8540	8539
8541	8540	void kvm_arch_async_page_not_present(struct kvm_vcpu *vcpu,

include/linux/kvm_host.h+8−8

@@ -641,18 +641,18 @@ int kvm_read_guest_page(struct kvm kvm, gfn_t gfn, void data, int offset, · 640 unmodified lines
641	641	int kvm_read_guest_atomic(struct kvm kvm, gpa_t gpa, void data,
642	642	unsigned long len);
643	643	int kvm_read_guest(struct kvm kvm, gpa_t gpa, void data, unsigned long len);
644		−int kvm_read_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
645		− void *data, unsigned long len);
	644	+int kvm_vcpu_read_guest_cached(struct kvm_vcpu vcpu, struct gfn_to_hva_cache ghc,
	645	+ void *data, unsigned long len);
646	646	int kvm_write_guest_page(struct kvm kvm, gfn_t gfn, const void data,
647	647	int offset, int len);
648	648	int kvm_write_guest(struct kvm kvm, gpa_t gpa, const void data,
649	649	unsigned long len);
650		−int kvm_write_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
651		− void *data, unsigned long len);
652		−int kvm_write_guest_offset_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
653		− void *data, int offset, unsigned long len);
654		−int kvm_gfn_to_hva_cache_init(struct kvm kvm, struct gfn_to_hva_cache ghc,
655		− gpa_t gpa, unsigned long len);
	650	+int kvm_vcpu_write_guest_cached(struct kvm_vcpu v, struct gfn_to_hva_cache ghc,
	651	+ void *data, unsigned long len);
	652	+int kvm_vcpu_write_guest_offset_cached(struct kvm_vcpu v, struct gfn_to_hva_cache ghc,
	653	+ void *data, int offset, unsigned long len);
	654	+int kvm_vcpu_gfn_to_hva_cache_init(struct kvm_vcpu v, struct gfn_to_hva_cache ghc,
	655	+ gpa_t gpa, unsigned long len);
656	656	int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len);
657	657	int kvm_clear_guest(struct kvm *kvm, gpa_t gpa, unsigned long len);
658	658	struct kvm_memory_slot gfn_to_memslot(struct kvm kvm, gfn_t gfn);

virt/kvm/kvm_main.c+17−17

@@ -1981,18 +1981,18 @@ static int __kvm_gfn_to_hva_cache_init(struct kvm_memslots *slots, · 1980 unmodified lines
1981	1981	return 0;
1982	1982	}
1983	1983
1984		−int kvm_gfn_to_hva_cache_init(struct kvm kvm, struct gfn_to_hva_cache ghc,
	1984	+int kvm_vcpu_gfn_to_hva_cache_init(struct kvm_vcpu vcpu, struct gfn_to_hva_cache ghc,
1985	1985	gpa_t gpa, unsigned long len)
1986	1986	{
1987		− struct kvm_memslots *slots = kvm_memslots(kvm);
	1987	+ struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
1988	1988	return __kvm_gfn_to_hva_cache_init(slots, ghc, gpa, len);
1989	1989	}
1990		−EXPORT_SYMBOL_GPL(kvm_gfn_to_hva_cache_init);
	1990	+EXPORT_SYMBOL_GPL(kvm_vcpu_gfn_to_hva_cache_init);
1991	1991
1992		−int kvm_write_guest_offset_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
1993		− void *data, int offset, unsigned long len)
	1992	+int kvm_vcpu_write_guest_offset_cached(struct kvm_vcpu vcpu, struct gfn_to_hva_cache ghc,
	1993	+ void *data, int offset, unsigned long len)
1994	1994	{
1995		− struct kvm_memslots *slots = kvm_memslots(kvm);
	1995	+ struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
1996	1996	int r;
1997	1997	gpa_t gpa = ghc->gpa + offset;
1998	1998
@@ -2002,7 +2002,7 @@ int kvm_write_guest_offset_cached(struct kvm kvm, struct gfn_to_hva_cache ghc, · 3 unmodified lines
2002	2002	__kvm_gfn_to_hva_cache_init(slots, ghc, ghc->gpa, ghc->len);
2003	2003
2004	2004	if (unlikely(!ghc->memslot))
2005		− return kvm_write_guest(kvm, gpa, data, len);
	2005	+ return kvm_vcpu_write_guest(vcpu, gpa, data, len);
2006	2006
2007	2007	if (kvm_is_error_hva(ghc->hva))
2008	2008	return -EFAULT;
@@ -2014,19 +2014,19 @@ int kvm_write_guest_offset_cached(struct kvm kvm, struct gfn_to_hva_cache ghc, · 5 unmodified lines
2014	2014
2015	2015	return 0;
2016	2016	}
2017		−EXPORT_SYMBOL_GPL(kvm_write_guest_offset_cached);
	2017	+EXPORT_SYMBOL_GPL(kvm_vcpu_write_guest_offset_cached);
2018	2018
2019		−int kvm_write_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
2020		− void *data, unsigned long len)
	2019	+int kvm_vcpu_write_guest_cached(struct kvm_vcpu vcpu, struct gfn_to_hva_cache ghc,
	2020	+ void *data, unsigned long len)
2021	2021	{
2022		− return kvm_write_guest_offset_cached(kvm, ghc, data, 0, len);
	2022	+ return kvm_vcpu_write_guest_offset_cached(vcpu, ghc, data, 0, len);
2023	2023	}
2024		−EXPORT_SYMBOL_GPL(kvm_write_guest_cached);
	2024	+EXPORT_SYMBOL_GPL(kvm_vcpu_write_guest_cached);
2025	2025
2026		−int kvm_read_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc,
2027		− void *data, unsigned long len)
	2026	+int kvm_vcpu_read_guest_cached(struct kvm_vcpu vcpu, struct gfn_to_hva_cache ghc,
	2027	+ void *data, unsigned long len)
2028	2028	{
2029		− struct kvm_memslots *slots = kvm_memslots(kvm);
	2029	+ struct kvm_memslots *slots = kvm_vcpu_memslots(vcpu);
2030	2030	int r;
2031	2031
2032	2032	BUG_ON(len > ghc->len);
@@ -2035,7 +2035,7 @@ int kvm_read_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc, · 2 unmodified lines
2035	2035	__kvm_gfn_to_hva_cache_init(slots, ghc, ghc->gpa, ghc->len);
2036	2036
2037	2037	if (unlikely(!ghc->memslot))
2038		− return kvm_read_guest(kvm, ghc->gpa, data, len);
	2038	+ return kvm_vcpu_read_guest(vcpu, ghc->gpa, data, len);
2039	2039
2040	2040	if (kvm_is_error_hva(ghc->hva))
2041	2041	return -EFAULT;
@@ -2046,7 +2046,7 @@ int kvm_read_guest_cached(struct kvm kvm, struct gfn_to_hva_cache ghc, · 4 unmodified lines
2046	2046
2047	2047	return 0;
2048	2048	}
2049		−EXPORT_SYMBOL_GPL(kvm_read_guest_cached);
	2049	+EXPORT_SYMBOL_GPL(kvm_vcpu_read_guest_cached);
2050	2050
2051	2051	int kvm_clear_guest_page(struct kvm *kvm, gfn_t gfn, int offset, int len)
2052	2052	{