[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(>t->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(>t->ppgtt_mm_list_head);
> INIT_LIST_HEAD(>t->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