void intel_gvt_debugfs_init(struct intel_gvt *gvt);
 void intel_gvt_debugfs_clean(struct intel_gvt *gvt);
 
+int intel_gvt_page_track_add(struct intel_vgpu *info, u64 gfn);
+int intel_gvt_page_track_remove(struct intel_vgpu *info, u64 gfn);
+
 #include "trace.h"
 #include "mpt.h"
 
 
 struct intel_gvt_mpt {
        int (*host_init)(struct device *dev, void *gvt);
        void (*host_exit)(struct device *dev, void *gvt);
-       int (*enable_page_track)(struct intel_vgpu *vgpu, u64 gfn);
-       int (*disable_page_track)(struct intel_vgpu *vgpu, u64 gfn);
 
        int (*dma_map_guest_page)(struct intel_vgpu *vgpu, unsigned long gfn,
                                  unsigned long size, dma_addr_t *dma_addr);
 
        intel_gvt_cleanup_vgpu_type_groups((struct intel_gvt *)gvt);
 }
 
-static int kvmgt_page_track_add(struct intel_vgpu *info, u64 gfn)
+int intel_gvt_page_track_add(struct intel_vgpu *info, u64 gfn)
 {
        struct kvm *kvm = info->kvm;
        struct kvm_memory_slot *slot;
        return 0;
 }
 
-static int kvmgt_page_track_remove(struct intel_vgpu *info, u64 gfn)
+int intel_gvt_page_track_remove(struct intel_vgpu *info, u64 gfn)
 {
        struct kvm *kvm = info->kvm;
        struct kvm_memory_slot *slot;
 static const struct intel_gvt_mpt kvmgt_mpt = {
        .host_init = kvmgt_host_init,
        .host_exit = kvmgt_host_exit,
-       .enable_page_track = kvmgt_page_track_add,
-       .disable_page_track = kvmgt_page_track_remove,
        .dma_map_guest_page = kvmgt_dma_map_guest_page,
        .dma_unmap_guest_page = kvmgt_dma_unmap_guest_page,
        .dma_pin_guest_page = kvmgt_dma_pin_guest_page,
 
        intel_gvt_host.mpt->host_exit(dev, gvt);
 }
 
-/**
- * intel_gvt_hypervisor_enable_page_track - track a guest page
- * @vgpu: a vGPU
- * @gfn: the gfn of guest
- *
- * Returns:
- * Zero on success, negative error code if failed.
- */
-static inline int intel_gvt_hypervisor_enable_page_track(
-               struct intel_vgpu *vgpu, unsigned long gfn)
-{
-       return intel_gvt_host.mpt->enable_page_track(vgpu, gfn);
-}
-
-/**
- * intel_gvt_hypervisor_disable_page_track - untrack a guest page
- * @vgpu: a vGPU
- * @gfn: the gfn of guest
- *
- * Returns:
- * Zero on success, negative error code if failed.
- */
-static inline int intel_gvt_hypervisor_disable_page_track(
-               struct intel_vgpu *vgpu, unsigned long gfn)
-{
-       return intel_gvt_host.mpt->disable_page_track(vgpu, gfn);
-}
-
 /**
  * intel_gvt_hypervisor_dma_map_guest_page - setup dma map for guest page
  * @vgpu: a vGPU
 
        track = radix_tree_delete(&vgpu->page_track_tree, gfn);
        if (track) {
                if (track->tracked)
-                       intel_gvt_hypervisor_disable_page_track(vgpu, gfn);
+                       intel_gvt_page_track_remove(vgpu, gfn);
                kfree(track);
        }
 }
        if (track->tracked)
                return 0;
 
-       ret = intel_gvt_hypervisor_enable_page_track(vgpu, gfn);
+       ret = intel_gvt_page_track_add(vgpu, gfn);
        if (ret)
                return ret;
        track->tracked = true;
        if (!track->tracked)
                return 0;
 
-       ret = intel_gvt_hypervisor_disable_page_track(vgpu, gfn);
+       ret = intel_gvt_page_track_remove(vgpu, gfn);
        if (ret)
                return ret;
        track->tracked = false;
 
        if (unlikely(vgpu->failsafe)) {
                /* Remove write protection to prevent furture traps. */
-               intel_vgpu_disable_page_track(vgpu, gpa >> PAGE_SHIFT);
+               intel_gvt_page_track_remove(vgpu, gpa >> PAGE_SHIFT);
        } else {
                ret = page_track->handler(page_track, gpa, data, bytes);
                if (ret)