[PATCH 7/9] drm/i915/gvt: Rework shadow page management code

Zhi Wang zhi.a.wang at intel.com
Mon Dec 25 11:19:59 UTC 2017


This one looks nice except the radix tree consideration.

On 12/25/17 17:11, changbin.du at intel.com wrote:
> From: Changbin Du <changbin.du at intel.com>
> 
> This is a another big one and the GVT shadow page management code is
> heavily refined.
> 
> The new code only use struct intel_vgpu_ppgtt_spt to represent a vgpu
> shadow page table - w/ or wo/ a guest page associated with. A pure shadow
> page (no guest page associated) will be used to shadow splited 2M huge
> gtt. In this case, the spt.guest_page.gfn should be a zero.
> 
> To search a existed shadow page table, we have two new interfaces:
>   - intel_vgpu_find_spt_by_gfn(), find a spt by guest gfn. It must not
>     be a pure spt.
>   - intel_vgpu_find_spt_by_mfn, Find the spt using shadow page mfn in
>     shadowed PTE.
> 
> The page track for write-protected page is moved to a standalone
> page_track.c and the interfaces are well defined. This page track
> will be used by vGUC emulation. And, let's use radix tree instead of
> hash table.
> 
> The oos_page management is remained as what is was.
> 
> Signed-off-by: Changbin Du <changbin.du at intel.com>
> ---
>   drivers/gpu/drm/i915/gvt/Makefile     |   2 +-
>   drivers/gpu/drm/i915/gvt/gtt.c        | 559 ++++++++++++----------------------
>   drivers/gpu/drm/i915/gvt/gtt.h        |  63 ++--
>   drivers/gpu/drm/i915/gvt/gvt.c        |   2 +-
>   drivers/gpu/drm/i915/gvt/gvt.h        |   2 +
>   drivers/gpu/drm/i915/gvt/mpt.h        |  36 +--
>   drivers/gpu/drm/i915/gvt/page_track.c | 181 +++++++++++
>   drivers/gpu/drm/i915/gvt/page_track.h |  54 ++++
>   drivers/gpu/drm/i915/gvt/trace.h      |  30 +-
>   drivers/gpu/drm/i915/gvt/vgpu.c       |   1 +
>   10 files changed, 481 insertions(+), 449 deletions(-)
>   create mode 100644 drivers/gpu/drm/i915/gvt/page_track.c
>   create mode 100644 drivers/gpu/drm/i915/gvt/page_track.h
> 
> diff --git a/drivers/gpu/drm/i915/gvt/Makefile b/drivers/gpu/drm/i915/gvt/Makefile
> index 347116f..b016dc7 100644
> --- a/drivers/gpu/drm/i915/gvt/Makefile
> +++ b/drivers/gpu/drm/i915/gvt/Makefile
> @@ -3,7 +3,7 @@ GVT_DIR := gvt
>   GVT_SOURCE := gvt.o aperture_gm.o handlers.o vgpu.o trace_points.o firmware.o \
>   	interrupt.o gtt.o cfg_space.o opregion.o mmio.o display.o edid.o \
>   	execlist.o scheduler.o sched_policy.o mmio_context.o cmd_parser.o debugfs.o \
> -	fb_decoder.o dmabuf.o
> +	fb_decoder.o dmabuf.o page_track.o
>   
>   ccflags-y				+= -I$(src) -I$(src)/$(GVT_DIR)
>   i915-y					+= $(addprefix $(GVT_DIR)/, $(GVT_SOURCE))
> diff --git a/drivers/gpu/drm/i915/gvt/gtt.c b/drivers/gpu/drm/i915/gvt/gtt.c
> index f8aff1d..1866c2d 100644
> --- a/drivers/gpu/drm/i915/gvt/gtt.c
> +++ b/drivers/gpu/drm/i915/gvt/gtt.c
> @@ -558,7 +558,7 @@ static inline int ppgtt_spt_get_entry(
>   		return -EINVAL;
>   
>   	ret = ops->get_entry(page_table, e, index, guest,
> -			spt->guest_page.track.gfn << I915_GTT_PAGE_SHIFT,
> +			spt->guest_page.gfn << I915_GTT_PAGE_SHIFT,

Better turn these into PAGE_SHIFT?

>   			spt->vgpu);
>   	if (ret)
>   		return ret;
> @@ -585,17 +585,17 @@ static inline int ppgtt_spt_set_entry(
>   		    type, e->type, index, e->val64);
>   
>   	return ops->set_entry(page_table, e, index, guest,
> -			spt->guest_page.track.gfn << I915_GTT_PAGE_SHIFT,
> +			spt->guest_page.gfn << I915_GTT_PAGE_SHIFT,
>   			spt->vgpu);
>   }
>   
>   #define ppgtt_get_guest_entry(spt, e, index) \
>   	ppgtt_spt_get_entry(spt, NULL, \
> -		spt->guest_page_type, e, index, true)
> +		spt->guest_page.type, e, index, true)
>   
>   #define ppgtt_set_guest_entry(spt, e, index) \
>   	ppgtt_spt_set_entry(spt, NULL, \
> -		spt->guest_page_type, e, index, true)
> +		spt->guest_page.type, e, index, true)
>   
>   #define ppgtt_get_shadow_entry(spt, e, index) \
>   	ppgtt_spt_get_entry(spt, spt->shadow_page.vaddr, \
> @@ -605,159 +605,6 @@ static inline int ppgtt_spt_set_entry(
>   	ppgtt_spt_set_entry(spt, spt->shadow_page.vaddr, \
>   		spt->shadow_page.type, e, index, false)
>   
> -/**
> - * intel_vgpu_init_page_track - init a page track data structure
> - * @vgpu: a vGPU
> - * @t: a page track data structure
> - * @gfn: guest memory page frame number
> - * @handler: the function will be called when target guest memory page has
> - * been modified.
> - *
> - * This function is called when a user wants to prepare a page track data
> - * structure to track a guest memory page.
> - *
> - * Returns:
> - * Zero on success, negative error code if failed.
> - */
> -int intel_vgpu_init_page_track(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t,
> -		unsigned long gfn,
> -		int (*handler)(void *, u64, void *, int),
> -		void *data)
> -{
> -	INIT_HLIST_NODE(&t->node);
> -
> -	t->tracked = false;
> -	t->gfn = gfn;
> -	t->handler = handler;
> -	t->data = data;
> -
> -	hash_add(vgpu->gtt.tracked_guest_page_hash_table, &t->node, t->gfn);
> -	return 0;
> -}
> -
> -/**
> - * intel_vgpu_clean_page_track - release a page track data structure
> - * @vgpu: a vGPU
> - * @t: a page track data structure
> - *
> - * This function is called before a user frees a page track data structure.
> - */
> -void intel_vgpu_clean_page_track(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t)
> -{
> -	if (!hlist_unhashed(&t->node))
> -		hash_del(&t->node);
> -
> -	if (t->tracked)
> -		intel_gvt_hypervisor_disable_page_track(vgpu, t);
> -}
> -
> -/**
> - * intel_vgpu_find_tracked_page - find a tracked guest page
> - * @vgpu: a vGPU
> - * @gfn: guest memory page frame number
> - *
> - * This function is called when the emulation layer wants to figure out if a
> - * trapped GFN is a tracked guest page.
> - *
> - * Returns:
> - * Pointer to page track data structure, NULL if not found.
> - */
> -struct intel_vgpu_page_track *intel_vgpu_find_tracked_page(
> -		struct intel_vgpu *vgpu, unsigned long gfn)
> -{
> -	struct intel_vgpu_page_track *t;
> -
> -	hash_for_each_possible(vgpu->gtt.tracked_guest_page_hash_table,
> -			t, node, gfn) {
> -		if (t->gfn == gfn)
> -			return t;
> -	}
> -	return NULL;
> -}
> -
> -static int init_guest_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_guest_page *p,
> -		unsigned long gfn,
> -		int (*handler)(void *, u64, void *, int),
> -		void *data)
> -{
> -	p->oos_page = NULL;
> -	p->write_cnt = 0;
> -
> -	return intel_vgpu_init_page_track(vgpu, &p->track, gfn, handler, data);
> -}
> -
> -static int detach_oos_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_oos_page *oos_page);
> -
> -static void clean_guest_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_guest_page *p)
> -{
> -	if (p->oos_page)
> -		detach_oos_page(vgpu, p->oos_page);
> -
> -	intel_vgpu_clean_page_track(vgpu, &p->track);
> -}
> -
> -static inline int init_shadow_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_shadow_page *p, int type, bool hash)
> -{
> -	struct device *kdev = &vgpu->gvt->dev_priv->drm.pdev->dev;
> -	dma_addr_t daddr;
> -
> -	daddr = dma_map_page(kdev, p->page, 0, 4096, PCI_DMA_BIDIRECTIONAL);
> -	if (dma_mapping_error(kdev, daddr)) {
> -		gvt_vgpu_err("fail to map dma addr\n");
> -		return -EINVAL;
> -	}
> -
> -	p->vaddr = page_address(p->page);
> -	p->type = type;
> -
> -	INIT_HLIST_NODE(&p->node);
> -
> -	p->mfn = daddr >> I915_GTT_PAGE_SHIFT;
> -	if (hash)
> -		hash_add(vgpu->gtt.shadow_page_hash_table, &p->node, p->mfn);
> -	return 0;
> -}
> -
> -static inline void clean_shadow_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_shadow_page *p)
> -{
> -	struct device *kdev = &vgpu->gvt->dev_priv->drm.pdev->dev;
> -
> -	dma_unmap_page(kdev, p->mfn << I915_GTT_PAGE_SHIFT, 4096,
> -			PCI_DMA_BIDIRECTIONAL);
> -
> -	if (!hlist_unhashed(&p->node))
> -		hash_del(&p->node);
> -}
> -
> -static inline struct intel_vgpu_shadow_page *find_shadow_page(
> -		struct intel_vgpu *vgpu, unsigned long mfn)
> -{
> -	struct intel_vgpu_shadow_page *p;
> -
> -	hash_for_each_possible(vgpu->gtt.shadow_page_hash_table,
> -		p, node, mfn) {
> -		if (p->mfn == mfn)
> -			return p;
> -	}
> -	return NULL;
> -}
> -
> -#define page_track_to_guest_page(ptr) \
> -	container_of(ptr, struct intel_vgpu_guest_page, track)
> -
> -#define guest_page_to_ppgtt_spt(ptr) \
> -	container_of(ptr, struct intel_vgpu_ppgtt_spt, guest_page)
> -
> -#define shadow_page_to_ppgtt_spt(ptr) \
> -	container_of(ptr, struct intel_vgpu_ppgtt_spt, shadow_page)
> -
>   static void *alloc_spt(gfp_t gfp_mask)
>   {
>   	struct intel_vgpu_ppgtt_spt *spt;
> @@ -780,57 +627,94 @@ static void free_spt(struct intel_vgpu_ppgtt_spt *spt)
>   	kfree(spt);
>   }
>   
> -static void ppgtt_free_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
> +static int detach_oos_page(struct intel_vgpu *vgpu,
> +		struct intel_vgpu_oos_page *oos_page);
> +
> +static void ppgtt_free_spt(struct intel_vgpu_ppgtt_spt *spt)
>   {
> -	trace_spt_free(spt->vgpu->id, spt, spt->shadow_page.type);
> +	struct device *kdev = &spt->vgpu->gvt->dev_priv->drm.pdev->dev;
>   
> -	clean_shadow_page(spt->vgpu, &spt->shadow_page);
> -	clean_guest_page(spt->vgpu, &spt->guest_page);
> -	list_del_init(&spt->post_shadow_list);
> +	trace_spt_free(spt->vgpu->id, spt, spt->guest_page.type);
> +
> +	dma_unmap_page(kdev, spt->shadow_page.mfn << I915_GTT_PAGE_SHIFT, 4096,
> +		       PCI_DMA_BIDIRECTIONAL);
> +	if (!hlist_unhashed(&spt->node))
> +		hash_del(&spt->node);
> +
> +	if (spt->guest_page.oos_page)
> +		detach_oos_page(spt->vgpu, spt->guest_page.oos_page);
>   
> +	intel_vgpu_unregister_page_track(spt->vgpu, spt->guest_page.gfn);
> +
> +	list_del_init(&spt->post_shadow_list);
>   	free_spt(spt);
>   }
>   
> -static void ppgtt_free_all_shadow_page(struct intel_vgpu *vgpu)
> +static void ppgtt_free_all_spt(struct intel_vgpu *vgpu)
>   {
>   	struct hlist_node *n;
> -	struct intel_vgpu_shadow_page *sp;
> +	struct intel_vgpu_ppgtt_spt *spt;
>   	int i;
>   
> -	hash_for_each_safe(vgpu->gtt.shadow_page_hash_table, i, n, sp, node)
> -		ppgtt_free_shadow_page(shadow_page_to_ppgtt_spt(sp));
> +	hash_for_each_safe(vgpu->gtt.spt_hash_table, i, n, spt, node)
> +		ppgtt_free_spt(spt);
>   }
>   
>   static int ppgtt_handle_guest_write_page_table_bytes(
> -		struct intel_vgpu_guest_page *gpt,
> +		struct intel_vgpu_ppgtt_spt *spt,
>   		u64 pa, void *p_data, int bytes);
>   
> -static int ppgtt_write_protection_handler(void *data, u64 pa,
> -		void *p_data, int bytes)
> +static int ppgtt_write_protection_handler(
> +		struct intel_vgpu_page_track *page_track,
> +		u64 gpa, void *data, int bytes)
>   {
> -	struct intel_vgpu_page_track *t = data;
> -	struct intel_vgpu_guest_page *p = page_track_to_guest_page(t);
> +	struct intel_vgpu_ppgtt_spt *spt = page_track->priv_data;
> +
>   	int ret;
>   
>   	if (bytes != 4 && bytes != 8)
>   		return -EINVAL;
>   
> -	if (!t->tracked)
> -		return -EINVAL;
> -
> -	ret = ppgtt_handle_guest_write_page_table_bytes(p,
> -		pa, p_data, bytes);
> +	ret = ppgtt_handle_guest_write_page_table_bytes(spt, gpa, data, bytes);
>   	if (ret)
>   		return ret;
>   	return ret;
>   }
>   
> +/* Find a spt by guest gfn. */
> +static struct intel_vgpu_ppgtt_spt *intel_vgpu_find_spt_by_gfn(
> +		struct intel_vgpu *vgpu, unsigned long gfn)
> +{
> +	struct intel_vgpu_page_track *track;
> +
> +	track = intel_vgpu_find_page_track(vgpu, gfn);
> +	if (track && track->handler == ppgtt_write_protection_handler)
> +		return track->priv_data;
> +
> +	return NULL;
> +}
> +
> +/* Find the spt by shadow page mfn. */
> +static struct intel_vgpu_ppgtt_spt *intel_vgpu_find_spt_by_mfn(
> +		struct intel_vgpu *vgpu, unsigned long mfn)
> +{
> +	struct intel_vgpu_ppgtt_spt *spt;
> +
> +	hash_for_each_possible(vgpu->gtt.spt_hash_table, spt, node, mfn) {
> +		if (spt->shadow_page.mfn == mfn)
> +			return spt;
> +	}
> +	return NULL;
> +}
> +
>   static int reclaim_one_ppgtt_mm(struct intel_gvt *gvt);
>   
> -static struct intel_vgpu_ppgtt_spt *ppgtt_alloc_shadow_page(
> +static struct intel_vgpu_ppgtt_spt *ppgtt_alloc_spt(
>   		struct intel_vgpu *vgpu, int type, unsigned long gfn)
>   {
> +	struct device *kdev = &vgpu->gvt->dev_priv->drm.pdev->dev;
>   	struct intel_vgpu_ppgtt_spt *spt = NULL;
> +	dma_addr_t daddr;
>   	int ret;
>   
>   retry:
> @@ -844,44 +728,42 @@ static struct intel_vgpu_ppgtt_spt *ppgtt_alloc_shadow_page(
>   	}
>   
>   	spt->vgpu = vgpu;
> -	spt->guest_page_type = type;
>   	atomic_set(&spt->refcount, 1);
>   	INIT_LIST_HEAD(&spt->post_shadow_list);
>   
>   	/*
> -	 * TODO: guest page type may be different with shadow page type,
> -	 *	 when we support PSE page in future.
> +	 * Init shadow_page.
>   	 */
> -	ret = init_shadow_page(vgpu, &spt->shadow_page, type, true);
> -	if (ret) {
> -		gvt_vgpu_err("fail to initialize shadow page for spt\n");
> -		goto err;
> +	spt->shadow_page.type = type;
> +	daddr = dma_map_page(kdev, spt->shadow_page.page,
> +			     0, 4096, PCI_DMA_BIDIRECTIONAL);
> +	if (dma_mapping_error(kdev, daddr)) {
> +		gvt_vgpu_err("fail to map dma addr\n");
> +		free_spt(spt);
> +		return ERR_PTR(-EINVAL);
>   	}
> +	spt->shadow_page.vaddr = page_address(spt->shadow_page.page);
> +	spt->shadow_page.mfn = daddr >> I915_GTT_PAGE_SHIFT;
>   
> -	ret = init_guest_page(vgpu, &spt->guest_page,
> -			gfn, ppgtt_write_protection_handler, NULL);
> +	/*
> +	 * Init guest_page.
> +	 */
> +	spt->guest_page.type = type;
> +	spt->guest_page.gfn = gfn;
> +
> +	ret = intel_vgpu_register_page_track(vgpu, spt->guest_page.gfn,
> +					ppgtt_write_protection_handler, spt);
>   	if (ret) {
> -		gvt_vgpu_err("fail to initialize guest page for spt\n");
> -		goto err;
> +		free_spt(spt);
> +		dma_unmap_page(kdev, daddr, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);
> +		return ERR_PTR(ret);
>   	}
>   
> +	INIT_HLIST_NODE(&spt->node);
> +	hash_add(vgpu->gtt.spt_hash_table, &spt->node, spt->shadow_page.mfn);
> +
>   	trace_spt_alloc(vgpu->id, spt, type, spt->shadow_page.mfn, gfn);
>   	return spt;
> -err:
> -	ppgtt_free_shadow_page(spt);
> -	return ERR_PTR(ret);
> -}
> -
> -static struct intel_vgpu_ppgtt_spt *ppgtt_find_shadow_page(
> -		struct intel_vgpu *vgpu, unsigned long mfn)
> -{
> -	struct intel_vgpu_shadow_page *p = find_shadow_page(vgpu, mfn);
> -
> -	if (p)
> -		return shadow_page_to_ppgtt_spt(p);
> -
> -	gvt_vgpu_err("fail to find ppgtt shadow page: 0x%lx\n", mfn);
> -	return NULL;
>   }
>   
>   #define pt_entry_size_shift(spt) \
> @@ -900,7 +782,7 @@ static struct intel_vgpu_ppgtt_spt *ppgtt_find_shadow_page(
>   		if (!ppgtt_get_shadow_entry(spt, e, i) && \
>   		    spt->vgpu->gvt->gtt.pte_ops->test_present(e))
>   
> -static void ppgtt_get_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
> +static void ppgtt_get_spt(struct intel_vgpu_ppgtt_spt *spt)
>   {
>   	int v = atomic_read(&spt->refcount);
>   
> @@ -909,9 +791,9 @@ static void ppgtt_get_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	atomic_inc(&spt->refcount);
>   }
>   
> -static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt);
> +static int ppgtt_invalidate_spt(struct intel_vgpu_ppgtt_spt *spt);
>   
> -static int ppgtt_invalidate_shadow_page_by_shadow_entry(struct intel_vgpu *vgpu,
> +static int ppgtt_invalidate_spt_by_shadow_entry(struct intel_vgpu *vgpu,
>   		struct intel_gvt_gtt_entry *e)
>   {
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
> @@ -927,16 +809,16 @@ static int ppgtt_invalidate_shadow_page_by_shadow_entry(struct intel_vgpu *vgpu,
>   			vgpu->gtt.scratch_pt[cur_pt_type].page_mfn)
>   			return 0;
>   	}
> -	s = ppgtt_find_shadow_page(vgpu, ops->get_pfn(e));
> +	s = intel_vgpu_find_spt_by_mfn(vgpu, ops->get_pfn(e));
>   	if (!s) {
>   		gvt_vgpu_err("fail to find shadow page: mfn: 0x%lx\n",
>   				ops->get_pfn(e));
>   		return -ENXIO;
>   	}
> -	return ppgtt_invalidate_shadow_page(s);
> +	return ppgtt_invalidate_spt(s);
>   }
>   
> -static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
> +static int ppgtt_invalidate_spt(struct intel_vgpu_ppgtt_spt *spt)
>   {
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	struct intel_gvt_gtt_entry e;
> @@ -945,7 +827,7 @@ static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	int v = atomic_read(&spt->refcount);
>   
>   	trace_spt_change(spt->vgpu->id, "die", spt,
> -			spt->guest_page.track.gfn, spt->shadow_page.type);
> +			spt->guest_page.gfn, spt->shadow_page.type);
>   
>   	trace_spt_refcount(spt->vgpu->id, "dec", spt, v, (v - 1));
>   
> @@ -968,7 +850,7 @@ static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   		case GTT_TYPE_PPGTT_PDP_ENTRY:
>   		case GTT_TYPE_PPGTT_PDE_ENTRY:
>   			gvt_vdbg_mm("invalidate PMUL4/PDP/PDE entry\n");
> -			ret = ppgtt_invalidate_shadow_page_by_shadow_entry(
> +			ret = ppgtt_invalidate_spt_by_shadow_entry(
>   					spt->vgpu, &e);
>   			if (ret)
>   				goto fail;
> @@ -979,8 +861,8 @@ static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	}
>   release:
>   	trace_spt_change(spt->vgpu->id, "release", spt,
> -			spt->guest_page.track.gfn, spt->shadow_page.type);
> -	ppgtt_free_shadow_page(spt);
> +			 spt->guest_page.gfn, spt->shadow_page.type);
> +	ppgtt_free_spt(spt);
>   	return 0;
>   fail:
>   	gvt_vgpu_err("fail: shadow page %p shadow entry 0x%llx type %d\n",
> @@ -988,49 +870,44 @@ static int ppgtt_invalidate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	return ret;
>   }
>   
> -static int ppgtt_populate_shadow_page(struct intel_vgpu_ppgtt_spt *spt);
> +static int ppgtt_populate_spt(struct intel_vgpu_ppgtt_spt *spt);
>   
> -static struct intel_vgpu_ppgtt_spt *ppgtt_populate_shadow_page_by_guest_entry(
> +static struct intel_vgpu_ppgtt_spt *ppgtt_populate_spt_by_guest_entry(
>   		struct intel_vgpu *vgpu, struct intel_gvt_gtt_entry *we)
>   {
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
> -	struct intel_vgpu_ppgtt_spt *s = NULL;
> -	struct intel_vgpu_guest_page *g;
> -	struct intel_vgpu_page_track *t;
> +	struct intel_vgpu_ppgtt_spt *spt = NULL;
>   	int ret;
>   
>   	GEM_BUG_ON(!gtt_type_is_pt(get_next_pt_type(we->type)));
>   
> -	t = intel_vgpu_find_tracked_page(vgpu, ops->get_pfn(we));
> -	if (t) {
> -		g = page_track_to_guest_page(t);
> -		s = guest_page_to_ppgtt_spt(g);
> -		ppgtt_get_shadow_page(s);
> -	} else {
> +	spt = intel_vgpu_find_spt_by_gfn(vgpu, ops->get_pfn(we));
> +	if (spt)
> +		ppgtt_get_spt(spt);
> +	else {
>   		int type = get_next_pt_type(we->type);
>   
> -		s = ppgtt_alloc_shadow_page(vgpu, type, ops->get_pfn(we));
> -		if (IS_ERR(s)) {
> -			ret = PTR_ERR(s);
> +		spt = ppgtt_alloc_spt(vgpu, type, ops->get_pfn(we));
> +		if (IS_ERR(spt)) {
> +			ret = PTR_ERR(spt);
>   			goto fail;
>   		}
>   
> -		ret = intel_gvt_hypervisor_enable_page_track(vgpu,
> -				&s->guest_page.track);
> +		ret = intel_vgpu_enable_page_track(vgpu, spt->guest_page.gfn);
>   		if (ret)
>   			goto fail;
>   
> -		ret = ppgtt_populate_shadow_page(s);
> +		ret = ppgtt_populate_spt(spt);
>   		if (ret)
>   			goto fail;
>   
> -		trace_spt_change(vgpu->id, "new", s, s->guest_page.track.gfn,
> -			s->shadow_page.type);
> +		trace_spt_change(vgpu->id, "new", spt, spt->guest_page.gfn,
> +				 spt->shadow_page.type);
>   	}
> -	return s;
> +	return spt;
>   fail:
>   	gvt_vgpu_err("fail: shadow page %p guest entry 0x%llx type %d\n",
> -			s, we->val64, we->type);
> +		     spt, we->val64, we->type);
>   	return ERR_PTR(ret);
>   }
>   
> @@ -1080,7 +957,7 @@ static int ppgtt_populate_shadow_entry(struct intel_vgpu *vgpu,
>   	return 0;
>   }
>   
> -static int ppgtt_populate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
> +static int ppgtt_populate_spt(struct intel_vgpu_ppgtt_spt *spt)
>   {
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	struct intel_vgpu_ppgtt_spt *s;
> @@ -1089,12 +966,11 @@ static int ppgtt_populate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	int ret;
>   
>   	trace_spt_change(spt->vgpu->id, "born", spt,
> -			spt->guest_page.track.gfn, spt->shadow_page.type);
> +			 spt->guest_page.gfn, spt->shadow_page.type);
>   
>   	for_each_present_guest_entry(spt, &ge, i) {
>   		if (gtt_type_is_pt(get_next_pt_type(ge.type))) {
> -			s = ppgtt_populate_shadow_page_by_guest_entry(vgpu,
> -								      &ge);
> +			s = ppgtt_populate_spt_by_guest_entry(vgpu, &ge);
>   			if (IS_ERR(s)) {
>   				ret = PTR_ERR(s);
>   				goto fail;
> @@ -1115,17 +991,15 @@ static int ppgtt_populate_shadow_page(struct intel_vgpu_ppgtt_spt *spt)
>   	return ret;
>   }
>   
> -static int ppgtt_handle_guest_entry_removal(struct intel_vgpu_guest_page *gpt,
> +static int ppgtt_handle_guest_entry_removal(struct intel_vgpu_ppgtt_spt *spt,
>   		struct intel_gvt_gtt_entry *se, unsigned long index)
>   {
> -	struct intel_vgpu_ppgtt_spt *spt = guest_page_to_ppgtt_spt(gpt);
> -	struct intel_vgpu_shadow_page *sp = &spt->shadow_page;
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
>   	int ret;
>   
> -	trace_gpt_change(spt->vgpu->id, "remove", spt, sp->type, se->val64,
> -			 index);
> +	trace_spt_guest_change(spt->vgpu->id, "remove", spt,
> +			       spt->shadow_page.type, se->val64, index);
>   
>   	gvt_vdbg_mm("destroy old shadow entry, type %d, index %lu, value %llx\n",
>   		    se->type, index, se->val64);
> @@ -1133,18 +1007,19 @@ static int ppgtt_handle_guest_entry_removal(struct intel_vgpu_guest_page *gpt,
>   	if (!ops->test_present(se))
>   		return 0;
>   
> -	if (ops->get_pfn(se) == vgpu->gtt.scratch_pt[sp->type].page_mfn)
> +	if (ops->get_pfn(se) ==
> +	    vgpu->gtt.scratch_pt[spt->shadow_page.type].page_mfn)
>   		return 0;
>   
>   	if (gtt_type_is_pt(get_next_pt_type(se->type))) {
>   		struct intel_vgpu_ppgtt_spt *s =
> -			ppgtt_find_shadow_page(vgpu, ops->get_pfn(se));
> +			intel_vgpu_find_spt_by_mfn(vgpu, ops->get_pfn(se));
>   		if (!s) {
>   			gvt_vgpu_err("fail to find guest page\n");
>   			ret = -ENXIO;
>   			goto fail;
>   		}
> -		ret = ppgtt_invalidate_shadow_page(s);
> +		ret = ppgtt_invalidate_spt(s);
>   		if (ret)
>   			goto fail;
>   	}
> @@ -1155,24 +1030,22 @@ static int ppgtt_handle_guest_entry_removal(struct intel_vgpu_guest_page *gpt,
>   	return ret;
>   }
>   
> -static int ppgtt_handle_guest_entry_add(struct intel_vgpu_guest_page *gpt,
> +static int ppgtt_handle_guest_entry_add(struct intel_vgpu_ppgtt_spt *spt,
>   		struct intel_gvt_gtt_entry *we, unsigned long index)
>   {
> -	struct intel_vgpu_ppgtt_spt *spt = guest_page_to_ppgtt_spt(gpt);
> -	struct intel_vgpu_shadow_page *sp = &spt->shadow_page;
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	struct intel_gvt_gtt_entry m;
>   	struct intel_vgpu_ppgtt_spt *s;
>   	int ret;
>   
> -	trace_gpt_change(spt->vgpu->id, "add", spt, sp->type,
> -		we->val64, index);
> +	trace_spt_guest_change(spt->vgpu->id, "add", spt, spt->shadow_page.type,
> +			       we->val64, index);
>   
>   	gvt_vdbg_mm("add shadow entry: type %d, index %lu, value %llx\n",
>   		    we->type, index, we->val64);
>   
>   	if (gtt_type_is_pt(get_next_pt_type(we->type))) {
> -		s = ppgtt_populate_shadow_page_by_guest_entry(vgpu, we);
> +		s = ppgtt_populate_spt_by_guest_entry(vgpu, we);
>   		if (IS_ERR(s)) {
>   			ret = PTR_ERR(s);
>   			goto fail;
> @@ -1198,30 +1071,29 @@ static int sync_oos_page(struct intel_vgpu *vgpu,
>   	const struct intel_gvt_device_info *info = &vgpu->gvt->device_info;
>   	struct intel_gvt *gvt = vgpu->gvt;
>   	struct intel_gvt_gtt_pte_ops *ops = gvt->gtt.pte_ops;
> -	struct intel_vgpu_ppgtt_spt *spt =
> -		guest_page_to_ppgtt_spt(oos_page->guest_page);
> +	struct intel_vgpu_ppgtt_spt *spt = oos_page->spt;
>   	struct intel_gvt_gtt_entry old, new;
>   	int index;
>   	int ret;
>   
>   	trace_oos_change(vgpu->id, "sync", oos_page->id,
> -			oos_page->guest_page, spt->guest_page_type);
> +			 spt, spt->guest_page.type);
>   
> -	old.type = new.type = get_entry_type(spt->guest_page_type);
> +	old.type = new.type = get_entry_type(spt->guest_page.type);
>   	old.val64 = new.val64 = 0;
>   
>   	for (index = 0; index < (I915_GTT_PAGE_SIZE >>
>   				info->gtt_entry_size_shift); index++) {
>   		ops->get_entry(oos_page->mem, &old, index, false, 0, vgpu);
>   		ops->get_entry(NULL, &new, index, true,
> -			oos_page->guest_page->track.gfn << PAGE_SHIFT, vgpu);
> +			       spt->guest_page.gfn << PAGE_SHIFT, vgpu);
>   
>   		if (old.val64 == new.val64
>   			&& !test_and_clear_bit(index, spt->post_shadow_bitmap))
>   			continue;
>   
>   		trace_oos_sync(vgpu->id, oos_page->id,
> -				oos_page->guest_page, spt->guest_page_type,
> +				spt, spt->guest_page.type,
>   				new.val64, index);
>   
>   		ret = ppgtt_populate_shadow_entry(vgpu, spt, index, &new);
> @@ -1231,7 +1103,7 @@ static int sync_oos_page(struct intel_vgpu *vgpu,
>   		ops->set_entry(oos_page->mem, &new, index, false, 0, vgpu);
>   	}
>   
> -	oos_page->guest_page->write_cnt = 0;
> +	spt->guest_page.write_cnt = 0;
>   	list_del_init(&spt->post_shadow_list);
>   	return 0;
>   }
> @@ -1240,15 +1112,14 @@ static int detach_oos_page(struct intel_vgpu *vgpu,
>   		struct intel_vgpu_oos_page *oos_page)
>   {
>   	struct intel_gvt *gvt = vgpu->gvt;
> -	struct intel_vgpu_ppgtt_spt *spt =
> -		guest_page_to_ppgtt_spt(oos_page->guest_page);
> +	struct intel_vgpu_ppgtt_spt *spt = oos_page->spt;
>   
>   	trace_oos_change(vgpu->id, "detach", oos_page->id,
> -			oos_page->guest_page, spt->guest_page_type);
> +			 spt, spt->guest_page.type);
>   
> -	oos_page->guest_page->write_cnt = 0;
> -	oos_page->guest_page->oos_page = NULL;
> -	oos_page->guest_page = NULL;
> +	spt->guest_page.write_cnt = 0;
> +	spt->guest_page.oos_page = NULL;
> +	oos_page->spt = NULL;
>   
>   	list_del_init(&oos_page->vm_list);
>   	list_move_tail(&oos_page->list, &gvt->gtt.oos_page_free_list_head);
> @@ -1256,51 +1127,49 @@ static int detach_oos_page(struct intel_vgpu *vgpu,
>   	return 0;
>   }
>   
> -static int attach_oos_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_oos_page *oos_page,
> -		struct intel_vgpu_guest_page *gpt)
> +static int attach_oos_page(struct intel_vgpu_oos_page *oos_page,
> +		struct intel_vgpu_ppgtt_spt *spt)
>   {
> -	struct intel_gvt *gvt = vgpu->gvt;
> +	struct intel_gvt *gvt = spt->vgpu->gvt;
>   	int ret;
>   
> -	ret = intel_gvt_hypervisor_read_gpa(vgpu,
> -			gpt->track.gfn << I915_GTT_PAGE_SHIFT,
> +	ret = intel_gvt_hypervisor_read_gpa(spt->vgpu,
> +			spt->guest_page.gfn << I915_GTT_PAGE_SHIFT,
>   			oos_page->mem, I915_GTT_PAGE_SIZE);
>   	if (ret)
>   		return ret;
>   
> -	oos_page->guest_page = gpt;
> -	gpt->oos_page = oos_page;
> +	oos_page->spt = spt;
> +	spt->guest_page.oos_page = oos_page;
>   
>   	list_move_tail(&oos_page->list, &gvt->gtt.oos_page_use_list_head);
>   
> -	trace_oos_change(vgpu->id, "attach", gpt->oos_page->id,
> -			gpt, guest_page_to_ppgtt_spt(gpt)->guest_page_type);
> +	trace_oos_change(spt->vgpu->id, "attach", oos_page->id,
> +			 spt, spt->guest_page.type);
>   	return 0;
>   }
>   
> -static int ppgtt_set_guest_page_sync(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_guest_page *gpt)
> +static int ppgtt_set_guest_page_sync(struct intel_vgpu_ppgtt_spt *spt)
>   {
> +	struct intel_vgpu_oos_page *oos_page = spt->guest_page.oos_page;
>   	int ret;
>   
> -	ret = intel_gvt_hypervisor_enable_page_track(vgpu, &gpt->track);
> +	ret = intel_vgpu_enable_page_track(spt->vgpu, spt->guest_page.gfn);
>   	if (ret)
>   		return ret;
>   
> -	trace_oos_change(vgpu->id, "set page sync", gpt->oos_page->id,
> -			gpt, guest_page_to_ppgtt_spt(gpt)->guest_page_type);
> +	trace_oos_change(spt->vgpu->id, "set page sync", oos_page->id,
> +			 spt, spt->guest_page.type);
>   
> -	list_del_init(&gpt->oos_page->vm_list);
> -	return sync_oos_page(vgpu, gpt->oos_page);
> +	list_del_init(&oos_page->vm_list);
> +	return sync_oos_page(spt->vgpu, oos_page);
>   }
>   
> -static int ppgtt_allocate_oos_page(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_guest_page *gpt)
> +static int ppgtt_allocate_oos_page(struct intel_vgpu_ppgtt_spt *spt)
>   {
> -	struct intel_gvt *gvt = vgpu->gvt;
> +	struct intel_gvt *gvt = spt->vgpu->gvt;
>   	struct intel_gvt_gtt *gtt = &gvt->gtt;
> -	struct intel_vgpu_oos_page *oos_page = gpt->oos_page;
> +	struct intel_vgpu_oos_page *oos_page = spt->guest_page.oos_page;
>   	int ret;
>   
>   	WARN(oos_page, "shadow PPGTT page has already has a oos page\n");
> @@ -1308,31 +1177,30 @@ static int ppgtt_allocate_oos_page(struct intel_vgpu *vgpu,
>   	if (list_empty(&gtt->oos_page_free_list_head)) {
>   		oos_page = container_of(gtt->oos_page_use_list_head.next,
>   			struct intel_vgpu_oos_page, list);
> -		ret = ppgtt_set_guest_page_sync(vgpu, oos_page->guest_page);
> +		ret = ppgtt_set_guest_page_sync(oos_page->spt);
>   		if (ret)
>   			return ret;
> -		ret = detach_oos_page(vgpu, oos_page);
> +		ret = detach_oos_page(spt->vgpu, oos_page);
>   		if (ret)
>   			return ret;
>   	} else
>   		oos_page = container_of(gtt->oos_page_free_list_head.next,
>   			struct intel_vgpu_oos_page, list);
> -	return attach_oos_page(vgpu, oos_page, gpt);
> +	return attach_oos_page(oos_page, spt);
>   }
>   
> -static int ppgtt_set_guest_page_oos(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_guest_page *gpt)
> +static int ppgtt_set_guest_page_oos(struct intel_vgpu_ppgtt_spt *spt)
>   {
> -	struct intel_vgpu_oos_page *oos_page = gpt->oos_page;
> +	struct intel_vgpu_oos_page *oos_page = spt->guest_page.oos_page;
>   
>   	if (WARN(!oos_page, "shadow PPGTT page should have a oos page\n"))
>   		return -EINVAL;
>   
> -	trace_oos_change(vgpu->id, "set page out of sync", gpt->oos_page->id,
> -			gpt, guest_page_to_ppgtt_spt(gpt)->guest_page_type);
> +	trace_oos_change(spt->vgpu->id, "set page out of sync", oos_page->id,
> +			 spt, spt->guest_page.type);
>   
> -	list_add_tail(&oos_page->vm_list, &vgpu->gtt.oos_page_list_head);
> -	return intel_gvt_hypervisor_disable_page_track(vgpu, &gpt->track);
> +	list_add_tail(&oos_page->vm_list, &spt->vgpu->gtt.oos_page_list_head);
> +	return intel_vgpu_disable_page_track(spt->vgpu, spt->guest_page.gfn);
>   }
>   
>   /**
> @@ -1357,7 +1225,7 @@ int intel_vgpu_sync_oos_pages(struct intel_vgpu *vgpu)
>   	list_for_each_safe(pos, n, &vgpu->gtt.oos_page_list_head) {
>   		oos_page = container_of(pos,
>   				struct intel_vgpu_oos_page, vm_list);
> -		ret = ppgtt_set_guest_page_sync(vgpu, oos_page->guest_page);
> +		ret = ppgtt_set_guest_page_sync(oos_page->spt);
>   		if (ret)
>   			return ret;
>   	}
> @@ -1368,10 +1236,9 @@ int intel_vgpu_sync_oos_pages(struct intel_vgpu *vgpu)
>    * The heart of PPGTT shadow page table.
>    */
>   static int ppgtt_handle_guest_write_page_table(
> -		struct intel_vgpu_guest_page *gpt,
> +		struct intel_vgpu_ppgtt_spt *spt,
>   		struct intel_gvt_gtt_entry *we, unsigned long index)
>   {
> -	struct intel_vgpu_ppgtt_spt *spt = guest_page_to_ppgtt_spt(gpt);
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	int type = spt->shadow_page.type;
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
> @@ -1389,12 +1256,12 @@ static int ppgtt_handle_guest_write_page_table(
>   	ppgtt_get_shadow_entry(spt, &old_se, index);
>   
>   	if (new_present) {
> -		ret = ppgtt_handle_guest_entry_add(gpt, we, index);
> +		ret = ppgtt_handle_guest_entry_add(spt, we, index);
>   		if (ret)
>   			goto fail;
>   	}
>   
> -	ret = ppgtt_handle_guest_entry_removal(gpt, &old_se, index);
> +	ret = ppgtt_handle_guest_entry_removal(spt, &old_se, index);
>   	if (ret)
>   		goto fail;
>   
> @@ -1412,12 +1279,11 @@ static int ppgtt_handle_guest_write_page_table(
>   
>   
>   
> -static inline bool can_do_out_of_sync(struct intel_vgpu_guest_page *gpt)
> +static inline bool can_do_out_of_sync(struct intel_vgpu_ppgtt_spt *spt)
>   {
>   	return enable_out_of_sync
> -		&& gtt_type_is_pte_pt(
> -			guest_page_to_ppgtt_spt(gpt)->guest_page_type)
> -		&& gpt->write_cnt >= 2;
> +		&& gtt_type_is_pte_pt(spt->guest_page.type)
> +		&& spt->guest_page.write_cnt >= 2;
>   }
>   
>   static void ppgtt_set_post_shadow(struct intel_vgpu_ppgtt_spt *spt,
> @@ -1457,8 +1323,8 @@ int intel_vgpu_flush_post_shadow(struct intel_vgpu *vgpu)
>   				GTT_ENTRY_NUM_IN_ONE_PAGE) {
>   			ppgtt_get_guest_entry(spt, &ge, index);
>   
> -			ret = ppgtt_handle_guest_write_page_table(
> -					&spt->guest_page, &ge, index);
> +			ret = ppgtt_handle_guest_write_page_table(spt,
> +							&ge, index);
>   			if (ret)
>   				return ret;
>   			clear_bit(index, spt->post_shadow_bitmap);
> @@ -1469,10 +1335,9 @@ int intel_vgpu_flush_post_shadow(struct intel_vgpu *vgpu)
>   }
>   
>   static int ppgtt_handle_guest_write_page_table_bytes(
> -		struct intel_vgpu_guest_page *gpt,
> +		struct intel_vgpu_ppgtt_spt *spt,
>   		u64 pa, void *p_data, int bytes)
>   {
> -	struct intel_vgpu_ppgtt_spt *spt = guest_page_to_ppgtt_spt(gpt);
>   	struct intel_vgpu *vgpu = spt->vgpu;
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
>   	const struct intel_gvt_device_info *info = &vgpu->gvt->device_info;
> @@ -1487,13 +1352,13 @@ static int ppgtt_handle_guest_write_page_table_bytes(
>   	ops->test_pse(&we);
>   
>   	if (bytes == info->gtt_entry_size) {
> -		ret = ppgtt_handle_guest_write_page_table(gpt, &we, index);
> +		ret = ppgtt_handle_guest_write_page_table(spt, &we, index);
>   		if (ret)
>   			return ret;
>   	} else {
>   		if (!test_bit(index, spt->post_shadow_bitmap)) {
>   			ppgtt_get_shadow_entry(spt, &se, index);
> -			ret = ppgtt_handle_guest_entry_removal(gpt, &se, index);
> +			ret = ppgtt_handle_guest_entry_removal(spt, &se, index);
>   			if (ret)
>   				return ret;
>   		}
> @@ -1504,17 +1369,17 @@ static int ppgtt_handle_guest_write_page_table_bytes(
>   	if (!enable_out_of_sync)
>   		return 0;
>   
> -	gpt->write_cnt++;
> +	spt->guest_page.write_cnt++;
>   
> -	if (gpt->oos_page)
> -		ops->set_entry(gpt->oos_page->mem, &we, index,
> +	if (spt->guest_page.oos_page)
> +		ops->set_entry(spt->guest_page.oos_page->mem, &we, index,
>   				false, 0, vgpu);
>   
> -	if (can_do_out_of_sync(gpt)) {
> -		if (!gpt->oos_page)
> -			ppgtt_allocate_oos_page(vgpu, gpt);
> +	if (can_do_out_of_sync(spt)) {
> +		if (!spt->guest_page.oos_page)
> +			ppgtt_allocate_oos_page(spt);
>   
> -		ret = ppgtt_set_guest_page_oos(vgpu, gpt);
> +		ret = ppgtt_set_guest_page_oos(spt);
>   		if (ret < 0)
>   			return ret;
>   	}
> @@ -1539,12 +1404,12 @@ static void invalidate_ppgtt_mm(struct intel_vgpu_mm *mm)
>   		if (!ops->test_present(&se))
>   			continue;
>   
> -		ppgtt_invalidate_shadow_page_by_shadow_entry(vgpu, &se);
> +		ppgtt_invalidate_spt_by_shadow_entry(vgpu, &se);
>   		se.val64 = 0;
>   		ppgtt_set_shadow_root_entry(mm, &se, index);
>   
> -		trace_gpt_change(vgpu->id, "destroy root pointer",
> -				 NULL, se.type, se.val64, index);
> +		trace_spt_guest_change(vgpu->id, "destroy root pointer",
> +				       NULL, se.type, se.val64, index);
>   	}
>   
>   	mm->ppgtt_mm.shadowed = false;
> @@ -1572,10 +1437,10 @@ static int shadow_ppgtt_mm(struct intel_vgpu_mm *mm)
>   		if (!ops->test_present(&ge))
>   			continue;
>   
> -		trace_gpt_change(vgpu->id, __func__, NULL,
> -				ge.type, ge.val64, index);
> +		trace_spt_guest_change(vgpu->id, __func__, NULL,
> +				       ge.type, ge.val64, index);
>   
> -		spt = ppgtt_populate_shadow_page_by_guest_entry(vgpu, &ge);
> +		spt = ppgtt_populate_spt_by_guest_entry(vgpu, &ge);
>   		if (IS_ERR(spt)) {
>   			gvt_vgpu_err("fail to populate guest root pointer\n");
>   			ret = PTR_ERR(spt);
> @@ -1584,8 +1449,8 @@ static int shadow_ppgtt_mm(struct intel_vgpu_mm *mm)
>   		ppgtt_generate_shadow_entry(&se, spt, &ge);
>   		ppgtt_set_shadow_root_entry(mm, &se, index);
>   
> -		trace_gpt_change(vgpu->id, "populate root pointer",
> -				NULL, se.type, se.val64, index);
> +		trace_spt_guest_change(vgpu->id, "populate root pointer",
> +				       NULL, se.type, se.val64, index);
>   	}
>   
>   	return 0;
> @@ -1775,7 +1640,7 @@ static inline int ppgtt_get_next_level_entry(struct intel_vgpu_mm *mm,
>   	struct intel_gvt_gtt_pte_ops *ops = vgpu->gvt->gtt.pte_ops;
>   	struct intel_vgpu_ppgtt_spt *s;
>   
> -	s = ppgtt_find_shadow_page(vgpu, ops->get_pfn(e));
> +	s = intel_vgpu_find_spt_by_mfn(vgpu, ops->get_pfn(e));
>   	if (!s)
>   		return -ENXIO;
>   
> @@ -1986,39 +1851,6 @@ int intel_vgpu_emulate_ggtt_mmio_write(struct intel_vgpu *vgpu,
>   	return ret;
>   }
>   
> -int intel_vgpu_write_protect_handler(struct intel_vgpu *vgpu, u64 pa,
> -				     void *p_data, unsigned int bytes)
> -{
> -	struct intel_gvt *gvt = vgpu->gvt;
> -	int ret = 0;
> -
> -	if (atomic_read(&vgpu->gtt.n_tracked_guest_page)) {
> -		struct intel_vgpu_page_track *t;
> -
> -		mutex_lock(&gvt->lock);
> -
> -		t = intel_vgpu_find_tracked_page(vgpu, pa >> PAGE_SHIFT);
> -		if (t) {
> -			if (unlikely(vgpu->failsafe)) {
> -				/* remove write protection to prevent furture traps */
> -				intel_vgpu_clean_page_track(vgpu, t);
> -			} else {
> -				ret = t->handler(t, pa, p_data, bytes);
> -				if (ret) {
> -					gvt_err("guest page write error %d, "
> -						"gfn 0x%lx, pa 0x%llx, "
> -						"var 0x%x, len %d\n",
> -						ret, t->gfn, pa,
> -						*(u32 *)p_data, bytes);
> -				}
> -			}
> -		}
> -		mutex_unlock(&gvt->lock);
> -	}
> -	return ret;
> -}
> -
> -
>   static int alloc_scratch_pages(struct intel_vgpu *vgpu,
>   		intel_gvt_gtt_type_t type)
>   {
> @@ -2133,8 +1965,7 @@ int intel_vgpu_init_gtt(struct intel_vgpu *vgpu)
>   {
>   	struct intel_vgpu_gtt *gtt = &vgpu->gtt;
>   
> -	hash_init(gtt->tracked_guest_page_hash_table);
> -	hash_init(gtt->shadow_page_hash_table);
> +	hash_init(gtt->spt_hash_table);
>   
>   	INIT_LIST_HEAD(&gtt->ppgtt_mm_list_head);
>   	INIT_LIST_HEAD(&gtt->oos_page_list_head);
> @@ -2183,7 +2014,7 @@ static void intel_vgpu_destroy_ggtt_mm(struct intel_vgpu *vgpu)
>    */
>   void intel_vgpu_clean_gtt(struct intel_vgpu *vgpu)
>   {
> -	ppgtt_free_all_shadow_page(vgpu);
> +	ppgtt_free_all_spt(vgpu);
>   	release_scratch_page_tree(vgpu);
>   
>   	intel_vgpu_destroy_all_ppgtt_mm(vgpu);
> @@ -2451,7 +2282,7 @@ void intel_vgpu_reset_ggtt(struct intel_vgpu *vgpu)
>    */
>   void intel_vgpu_reset_gtt(struct intel_vgpu *vgpu)
>   {
> -	ppgtt_free_all_shadow_page(vgpu);
> +	ppgtt_free_all_spt(vgpu);
>   
>   	/* Shadow pages are only created when there is no page
>   	 * table tracking data, so remove page tracking data after
> diff --git a/drivers/gpu/drm/i915/gvt/gtt.h b/drivers/gpu/drm/i915/gvt/gtt.h
> index 4533e10..32504c0 100644
> --- a/drivers/gpu/drm/i915/gvt/gtt.h
> +++ b/drivers/gpu/drm/i915/gvt/gtt.h
> @@ -179,9 +179,7 @@ struct intel_vgpu_gtt {
>   	struct intel_vgpu_mm *ggtt_mm;
>   	unsigned long active_ppgtt_mm_bitmap;
>   	struct list_head ppgtt_mm_list_head;
> -	DECLARE_HASHTABLE(shadow_page_hash_table, INTEL_GVT_GTT_HASH_BITS);
> -	DECLARE_HASHTABLE(tracked_guest_page_hash_table, INTEL_GVT_GTT_HASH_BITS);
> -	atomic_t n_tracked_guest_page;
> +	DECLARE_HASHTABLE(spt_hash_table, INTEL_GVT_GTT_HASH_BITS);
>   	struct list_head oos_page_list_head;
>   	struct list_head post_shadow_list_head;
>   	struct intel_vgpu_scratch_pt scratch_pt[GTT_TYPE_MAX];
> @@ -200,30 +198,8 @@ extern struct intel_vgpu_mm *intel_gvt_find_ppgtt_mm(struct intel_vgpu *vgpu,
>   
>   struct intel_vgpu_oos_page;
>   
> -struct intel_vgpu_shadow_page {
> -	void *vaddr;
> -	struct page *page;
> -	int type;
> -	struct hlist_node node;
> -	unsigned long mfn;
> -};
> -
> -struct intel_vgpu_page_track {
> -	struct hlist_node node;
> -	bool tracked;
> -	unsigned long gfn;
> -	int (*handler)(void *, u64, void *, int);
> -	void *data;
> -};
> -
> -struct intel_vgpu_guest_page {
> -	struct intel_vgpu_page_track track;
> -	unsigned long write_cnt;
> -	struct intel_vgpu_oos_page *oos_page;
> -};
> -
>   struct intel_vgpu_oos_page {
> -	struct intel_vgpu_guest_page *guest_page;
> +	struct intel_vgpu_ppgtt_spt *spt;
>   	struct list_head list;
>   	struct list_head vm_list;
>   	int id;
> @@ -232,27 +208,29 @@ struct intel_vgpu_oos_page {
>   
>   #define GTT_ENTRY_NUM_IN_ONE_PAGE 512
>   
> +/* Represent a vgpu shadow page table. */
>   struct intel_vgpu_ppgtt_spt {
> -	struct intel_vgpu_shadow_page shadow_page;
> -	struct intel_vgpu_guest_page guest_page;
> -	int guest_page_type;
>   	atomic_t refcount;
>   	struct intel_vgpu *vgpu;
> -	DECLARE_BITMAP(post_shadow_bitmap, GTT_ENTRY_NUM_IN_ONE_PAGE);
> -	struct list_head post_shadow_list;
> -};
> +	struct hlist_node node;
>   
> -int intel_vgpu_init_page_track(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t,
> -		unsigned long gfn,
> -		int (*handler)(void *gp, u64, void *, int),
> -		void *data);
> +	struct {
> +		intel_gvt_gtt_type_t type;
> +		void *vaddr;
> +		struct page *page;
> +		unsigned long mfn;
> +	} shadow_page;
>   
> -void intel_vgpu_clean_page_track(struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t);
> +	struct {
> +		intel_gvt_gtt_type_t type;
> +		unsigned long gfn;
> +		unsigned long write_cnt;
> +		struct intel_vgpu_oos_page *oos_page;
> +	} guest_page;
>   
> -struct intel_vgpu_page_track *intel_vgpu_find_tracked_page(
> -		struct intel_vgpu *vgpu, unsigned long gfn);
> +	DECLARE_BITMAP(post_shadow_bitmap, GTT_ENTRY_NUM_IN_ONE_PAGE);
> +	struct list_head post_shadow_list;
> +};
>   
>   int intel_vgpu_sync_oos_pages(struct intel_vgpu *vgpu);
>   
> @@ -279,7 +257,4 @@ int intel_vgpu_emulate_ggtt_mmio_read(struct intel_vgpu *vgpu,
>   int intel_vgpu_emulate_ggtt_mmio_write(struct intel_vgpu *vgpu,
>   	unsigned int off, void *p_data, unsigned int bytes);
>   
> -int intel_vgpu_write_protect_handler(struct intel_vgpu *vgpu, u64 pa,
> -				     void *p_data, unsigned int bytes);
> -
>   #endif /* _GVT_GTT_H_ */
> diff --git a/drivers/gpu/drm/i915/gvt/gvt.c b/drivers/gpu/drm/i915/gvt/gvt.c
> index fac54f3..61bd14f 100644
> --- a/drivers/gpu/drm/i915/gvt/gvt.c
> +++ b/drivers/gpu/drm/i915/gvt/gvt.c
> @@ -183,7 +183,7 @@ static const struct intel_gvt_ops intel_gvt_ops = {
>   	.get_gvt_attrs = intel_get_gvt_attrs,
>   	.vgpu_query_plane = intel_vgpu_query_plane,
>   	.vgpu_get_dmabuf = intel_vgpu_get_dmabuf,
> -	.write_protect_handler = intel_vgpu_write_protect_handler,
> +	.write_protect_handler = intel_vgpu_page_track_handler,
>   };
>   
>   /**
> diff --git a/drivers/gpu/drm/i915/gvt/gvt.h b/drivers/gpu/drm/i915/gvt/gvt.h
> index 7dc7a80..b9224ab 100644
> --- a/drivers/gpu/drm/i915/gvt/gvt.h
> +++ b/drivers/gpu/drm/i915/gvt/gvt.h
> @@ -48,6 +48,7 @@
>   #include "cmd_parser.h"
>   #include "fb_decoder.h"
>   #include "dmabuf.h"
> +#include "page_track.h"
>   
>   #define GVT_MAX_VGPU 8
>   
> @@ -192,6 +193,7 @@ struct intel_vgpu {
>   	struct intel_vgpu_opregion opregion;
>   	struct intel_vgpu_display display;
>   	struct intel_vgpu_submission submission;
> +	struct radix_tree_root page_track_tree;
>   	u32 hws_pga[I915_NUM_ENGINES];
>   
>   	struct dentry *debugfs;
> diff --git a/drivers/gpu/drm/i915/gvt/mpt.h b/drivers/gpu/drm/i915/gvt/mpt.h
> index ca8005a..a66de36 100644
> --- a/drivers/gpu/drm/i915/gvt/mpt.h
> +++ b/drivers/gpu/drm/i915/gvt/mpt.h
> @@ -154,53 +154,41 @@ static inline unsigned long intel_gvt_hypervisor_virt_to_mfn(void *p)
>   }
>   
>   /**
> - * intel_gvt_hypervisor_enable - set a guest page to write-protected
> - * @vgpu: a vGPU
> - * @t: page track data structure
> + * intel_gvt_hypervisor_set_wp_page - set a guest page to write-protected
> + * @spt: a spt
>    *
>    * Returns:
>    * Zero on success, negative error code if failed.
>    */
> -static inline int intel_gvt_hypervisor_enable_page_track(
> -		struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t)
> +static inline int intel_gvt_hypervisor_set_wp_page(
> +		struct intel_vgpu *vgpu, unsigned long gfn)
>   {
>   	int ret;
>   
> -	if (t->tracked)
> -		return 0;
> -
> -	ret = intel_gvt_host.mpt->set_wp_page(vgpu->handle, t->gfn);
> +	ret = intel_gvt_host.mpt->set_wp_page(vgpu->handle, gfn);
>   	if (ret)
>   		return ret;
> -	t->tracked = true;
> -	atomic_inc(&vgpu->gtt.n_tracked_guest_page);
> +
>   	return 0;
>   }
>   
>   /**
> - * intel_gvt_hypervisor_disable_page_track - remove the write-protection of a
> + * intel_gvt_hypervisor_unset_wp_page - remove the write-protection of a
>    * guest page
> - * @vgpu: a vGPU
> - * @t: page track data structure
> + * @spt: a spt
>    *
>    * Returns:
>    * Zero on success, negative error code if failed.
>    */
> -static inline int intel_gvt_hypervisor_disable_page_track(
> -		struct intel_vgpu *vgpu,
> -		struct intel_vgpu_page_track *t)
> +static inline int intel_gvt_hypervisor_unset_wp_page(
> +		struct intel_vgpu *vgpu, unsigned long gfn)
>   {
>   	int ret;
>   
> -	if (!t->tracked)
> -		return 0;
> -
> -	ret = intel_gvt_host.mpt->unset_wp_page(vgpu->handle, t->gfn);
> +	ret = intel_gvt_host.mpt->unset_wp_page(vgpu->handle, gfn);
>   	if (ret)
>   		return ret;
> -	t->tracked = false;
> -	atomic_dec(&vgpu->gtt.n_tracked_guest_page);
> +
>   	return 0;
>   }
>   
> diff --git a/drivers/gpu/drm/i915/gvt/page_track.c b/drivers/gpu/drm/i915/gvt/page_track.c
> new file mode 100644
> index 0000000..546b777
> --- /dev/null
> +++ b/drivers/gpu/drm/i915/gvt/page_track.c
> @@ -0,0 +1,181 @@
> +/*
> + * Copyright(c) 2011-2017 Intel Corporation. All rights reserved.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
> + * SOFTWARE.
> + */
> +#include "i915_drv.h"
> +#include "gvt.h"
> +
> +/**
> + * intel_vgpu_find_page_track - find page track rcord of guest page
> + * @vgpu: a vGPU
> + * @gfn: the gfn of guest page
> + *
> + * Returns:
> + * A pointer to struct intel_vgpu_page_track if found, else NULL returned.
> + */
> +struct intel_vgpu_page_track *intel_vgpu_find_page_track(
> +		struct intel_vgpu *vgpu, unsigned long gfn)
> +{
> +	return radix_tree_lookup(&vgpu->page_track_tree, gfn);
> +}
> +
> +/**
> + * intel_vgpu_register_page_track - register a guest page to be tacked
> + * @vgpu: a vGPU
> + * @gfn: the gfn of guest page
> + *
> + * Returns:
> + * zero on success, negative error code if failed.
> + */
> +int intel_vgpu_register_page_track(struct intel_vgpu *vgpu, unsigned long gfn,
> +		gvt_page_track_handler_t handler, void *priv)
> +{
> +	struct intel_vgpu_page_track *track;
> +	int ret;
> +
> +	track = intel_vgpu_find_page_track(vgpu, gfn);
> +	if (track)
> +		return -EEXIST;
> +
> +	track = kzalloc(sizeof(*track), GFP_KERNEL);
> +	if (!track)
> +		return -ENOMEM;
> +
> +	track->handler = handler;
> +	track->priv_data = priv;
> +
> +	ret = radix_tree_insert(&vgpu->page_track_tree, gfn, track);
> +	if (ret) {
> +		kfree(track);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +/**
> + * intel_vgpu_unregister_page_track - unregister the tracked guest page
> + * @vgpu: a vGPU
> + * @gfn: the gfn of guest page
> + *
> + */
> +void intel_vgpu_unregister_page_track(struct intel_vgpu *vgpu,
> +		unsigned long gfn)
> +{
> +	struct intel_vgpu_page_track *track;
> +
> +	track = radix_tree_delete(&vgpu->page_track_tree, gfn);
> +	if (track) {
> +		if (track->tracked)
> +			intel_gvt_hypervisor_unset_wp_page(vgpu, gfn);
> +		kfree(track);
> +	}
> +}
> +
> +/**
> + * intel_vgpu_enable_page_track - set write-protection on guest page
> + * @vgpu: a vGPU
> + * @gfn: the gfn of guest page
> + *
> + * Returns:
> + * zero on success, negative error code if failed.
> + */
> +int intel_vgpu_enable_page_track(struct intel_vgpu *vgpu, unsigned long gfn)
> +{
> +	struct intel_vgpu_page_track *track;
> +	int ret;
> +
> +	track = intel_vgpu_find_page_track(vgpu, gfn);
> +	if (!track)
> +		return -ENXIO;
> +
> +	if (track->tracked)
> +		return 0;
> +
> +	ret = intel_gvt_hypervisor_set_wp_page(vgpu, gfn);
> +	if (ret)
> +		return ret;
> +	track->tracked = true;
> +	return 0;
> +}
> +
> +/**
> + * intel_vgpu_enable_page_track - cancel write-protection on guest page
> + * @vgpu: a vGPU
> + * @gfn: the gfn of guest page
> + *
> + * Returns:
> + * zero on success, negative error code if failed.
> + */
> +int intel_vgpu_disable_page_track(struct intel_vgpu *vgpu, unsigned long gfn)
> +{
> +	struct intel_vgpu_page_track *track;
> +	int ret;
> +
> +	track = intel_vgpu_find_page_track(vgpu, gfn);
> +	if (!track)
> +		return -ENXIO;
> +
> +	if (!track->tracked)
> +		return 0;
> +
> +	ret = intel_gvt_hypervisor_unset_wp_page(vgpu, gfn);
> +	if (ret)
> +		return ret;
> +	track->tracked = false;
> +	return 0;
> +}
> +
> +/**
> + * intel_vgpu_page_track_handler - called when write to write-protected page
> + * @vgpu: a vGPU
> + * @gpa: the gpa of this write
> + * @data: the writed data
> + * @bytes: the length of this write
> + *
> + * Returns:
> + * zero on success, negative error code if failed.
> + */
> +int intel_vgpu_page_track_handler(struct intel_vgpu *vgpu, u64 gpa,
> +		void *data, unsigned int bytes)
> +{
> +	struct intel_gvt *gvt = vgpu->gvt;
> +	struct intel_vgpu_page_track *page_track;
> +	int ret = 0;
> +
> +	mutex_lock(&gvt->lock);
> +
> +	page_track = intel_vgpu_find_page_track(vgpu, gpa >> PAGE_SHIFT);
> +	if (!page_track)
> +		return 0;
> +
> +	if (unlikely(vgpu->failsafe)) {
> +		/* Remove write protection to prevent furture traps. */
> +		intel_vgpu_disable_page_track(vgpu, gpa >> PAGE_SHIFT);
> +	} else {
> +		ret = page_track->handler(page_track, gpa, data, bytes);
> +		if (ret)
> +			gvt_err("guest page write error, gpa %llx\n", gpa);
> +	}
> +
> +	mutex_unlock(&gvt->lock);
> +	return ret;
> +}
> diff --git a/drivers/gpu/drm/i915/gvt/page_track.h b/drivers/gpu/drm/i915/gvt/page_track.h
> new file mode 100644
> index 0000000..1cb29fb
> --- /dev/null
> +++ b/drivers/gpu/drm/i915/gvt/page_track.h
> @@ -0,0 +1,54 @@
> +/*
> + * Copyright(c) 2011-2017 Intel Corporation. All rights reserved.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
> + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
> + * SOFTWARE.
> + *
> + */
> +
> +#ifndef _GVT_PAGE_TRACK_H_
> +#define _GVT_PAGE_TRACK_H_
> +
> +struct intel_vgpu_page_track;
> +
> +typedef int (*gvt_page_track_handler_t)(
> +			struct intel_vgpu_page_track *page_track,
> +			u64 gpa, void *data, int bytes);
> +
> +/* Track record for a write-protected guest page. */
> +struct intel_vgpu_page_track {
> +	gvt_page_track_handler_t handler;
> +	bool tracked;
> +	void *priv_data;
> +};
> +
> +struct intel_vgpu_page_track *intel_vgpu_find_page_track(
> +		struct intel_vgpu *vgpu, unsigned long gfn);
> +int intel_vgpu_register_page_track(struct intel_vgpu *vgpu,
> +		unsigned long gfn, gvt_page_track_handler_t handler,
> +		void *priv);
> +void intel_vgpu_unregister_page_track(struct intel_vgpu *vgpu,
> +		unsigned long gfn);
> +int intel_vgpu_enable_page_track(struct intel_vgpu *vgpu, unsigned long gfn);
> +int intel_vgpu_disable_page_track(struct intel_vgpu *vgpu, unsigned long gfn);
> +
> +int intel_vgpu_page_track_handler(struct intel_vgpu *vgpu, u64 gpa,
> +		void *data, unsigned int bytes);
> +
> +#endif
> diff --git a/drivers/gpu/drm/i915/gvt/trace.h b/drivers/gpu/drm/i915/gvt/trace.h
> index 5a060da..5c3f416 100644
> --- a/drivers/gpu/drm/i915/gvt/trace.h
> +++ b/drivers/gpu/drm/i915/gvt/trace.h
> @@ -41,16 +41,16 @@
>   
>   TRACE_EVENT(spt_alloc,
>   	TP_PROTO(int id, void *spt, int type, unsigned long mfn,
> -		unsigned long gpt_gfn),
> +		unsigned long gfn),
>   
> -	TP_ARGS(id, spt, type, mfn, gpt_gfn),
> +	TP_ARGS(id, spt, type, mfn, gfn),
>   
>   	TP_STRUCT__entry(
>   		__field(int, id)
>   		__field(void *, spt)
>   		__field(int, type)
>   		__field(unsigned long, mfn)
> -		__field(unsigned long, gpt_gfn)
> +		__field(unsigned long, gfn)
>   		),
>   
>   	TP_fast_assign(
> @@ -58,7 +58,7 @@ TRACE_EVENT(spt_alloc,
>   		__entry->spt = spt;
>   		__entry->type = type;
>   		__entry->mfn = mfn;
> -		__entry->gpt_gfn = gpt_gfn;
> +		__entry->gfn = gfn;
>   	),
>   
>   	TP_printk("VM%d [alloc] spt %p type %d mfn 0x%lx gfn 0x%lx\n",
> @@ -66,7 +66,7 @@ TRACE_EVENT(spt_alloc,
>   		__entry->spt,
>   		__entry->type,
>   		__entry->mfn,
> -		__entry->gpt_gfn)
> +		__entry->gfn)
>   );
>   
>   TRACE_EVENT(spt_free,
> @@ -168,7 +168,7 @@ TRACE_EVENT(spt_change,
>   	TP_printk("%s", __entry->buf)
>   );
>   
> -TRACE_EVENT(gpt_change,
> +TRACE_EVENT(spt_guest_change,
>   	TP_PROTO(int id, const char *tag, void *spt, int type, u64 v,
>   		unsigned long index),
>   
> @@ -188,9 +188,9 @@ TRACE_EVENT(gpt_change,
>   );
>   
>   TRACE_EVENT(oos_change,
> -	TP_PROTO(int id, const char *tag, int page_id, void *gpt, int type),
> +	TP_PROTO(int id, const char *tag, int page_id, void *spt, int type),
>   
> -	TP_ARGS(id, tag, page_id, gpt, type),
> +	TP_ARGS(id, tag, page_id, spt, type),
>   
>   	TP_STRUCT__entry(
>   		__array(char, buf, MAX_BUF_LEN)
> @@ -198,27 +198,27 @@ TRACE_EVENT(oos_change,
>   
>   	TP_fast_assign(
>   		snprintf(__entry->buf, MAX_BUF_LEN,
> -		"VM%d [oos %s] page id %d gpt %p type %d\n",
> -			id, tag, page_id, gpt, type);
> +			"VM%d [oos %s] page id %d spt %p type %d\n",
> +			id, tag, page_id, spt, type);
>   	),
>   
>   	TP_printk("%s", __entry->buf)
>   );
>   
>   TRACE_EVENT(oos_sync,
> -	TP_PROTO(int id, int page_id, void *gpt, int type, u64 v,
> +	TP_PROTO(int id, int page_id, void *spt, int type, u64 v,
>   		unsigned long index),
>   
> -	TP_ARGS(id, page_id, gpt, type, v, index),
> +	TP_ARGS(id, page_id, spt, type, v, index),
>   
>   	TP_STRUCT__entry(
>   		__array(char, buf, MAX_BUF_LEN)
>   	),
>   
>   	TP_fast_assign(
> -	snprintf(__entry->buf, MAX_BUF_LEN,
> -	"VM%d [oos sync] page id %d gpt %p type %d entry 0x%llx index 0x%lx\n",
> -				id, page_id, gpt, type, v, index);
> +		snprintf(__entry->buf, MAX_BUF_LEN,
> +			"VM%d [oos sync] page id %d spt %p type %d entry 0x%llx index 0x%lx\n",
> +			id, page_id, spt, type, v, index);
>   	),
>   
>   	TP_printk("%s", __entry->buf)
> diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
> index 4688619..46d1f01 100644
> --- a/drivers/gpu/drm/i915/gvt/vgpu.c
> +++ b/drivers/gpu/drm/i915/gvt/vgpu.c
> @@ -352,6 +352,7 @@ static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
>   	vgpu->gvt = gvt;
>   	vgpu->sched_ctl.weight = param->weight;
>   	INIT_LIST_HEAD(&vgpu->dmabuf_obj_list_head);
> +	INIT_RADIX_TREE(&vgpu->page_track_tree, GFP_KERNEL);
>   	idr_init(&vgpu->object_idr);
>   	intel_vgpu_init_cfg_space(vgpu, param->primary);
>   
> 


More information about the intel-gvt-dev mailing list