arch/x86/kvm/page_track.c

   1 /*
   2  * Support KVM gust page tracking
   3  *
   4  * This feature allows us to track page access in guest. Currently, only
   5  * write access is tracked.
   6  *
   7  * Copyright(C) 2015 Intel Corporation.
   8  *
   9  * Author:
  10  *   Xiao Guangrong <guangrong.xiao@linux.intel.com>
  11  *
  12  * This work is licensed under the terms of the GNU GPL, version 2.  See
  13  * the COPYING file in the top-level directory.
  14  */
  15
  16 #include <linux/kvm_host.h>
  17 #include <linux/rculist.h>
  18
  19 #include <asm/kvm_host.h>
  20 #include <asm/kvm_page_track.h>
  21
  22 #include "mmu.h"
  23
  24 void kvm_page_track_free_memslot(struct kvm_memory_slot *free,
  25                                  struct kvm_memory_slot *dont)
  26 {
  27         int i;
  28
  29         for (i = 0; i < KVM_PAGE_TRACK_MAX; i++)
  30                 if (!dont || free->arch.gfn_track[i] !=
  31                       dont->arch.gfn_track[i]) {
  32                         kvfree(free->arch.gfn_track[i]);
  33                         free->arch.gfn_track[i] = NULL;
  34                 }
  35 }
  36
  37 int kvm_page_track_create_memslot(struct kvm_memory_slot *slot,
  38                                   unsigned long npages)
  39 {
  40         int  i;
  41
  42         for (i = 0; i < KVM_PAGE_TRACK_MAX; i++) {
  43                 slot->arch.gfn_track[i] = kvzalloc(npages *
  44                                             sizeof(*slot->arch.gfn_track[i]), GFP_KERNEL);
  45                 if (!slot->arch.gfn_track[i])
  46                         goto track_free;
  47         }
  48
  49         return 0;
  50
  51 track_free:
  52         kvm_page_track_free_memslot(slot, NULL);
  53         return -ENOMEM;
  54 }
  55
  56 static inline bool page_track_mode_is_valid(enum kvm_page_track_mode mode)
  57 {
  58         if (mode < 0 || mode >= KVM_PAGE_TRACK_MAX)
  59                 return false;
  60
  61         return true;
  62 }
  63
  64 static void update_gfn_track(struct kvm_memory_slot *slot, gfn_t gfn,
  65                              enum kvm_page_track_mode mode, short count)
  66 {
  67         int index, val;
  68
  69         index = gfn_to_index(gfn, slot->base_gfn, PT_PAGE_TABLE_LEVEL);
  70
  71         val = slot->arch.gfn_track[mode][index];
  72
  73         if (WARN_ON(val + count < 0 || val + count > USHRT_MAX))
  74                 return;
  75
  76         slot->arch.gfn_track[mode][index] += count;
  77 }
  78
  79 /*
  80  * add guest page to the tracking pool so that corresponding access on that
  81  * page will be intercepted.
  82  *
  83  * It should be called under the protection both of mmu-lock and kvm->srcu
  84  * or kvm->slots_lock.
  85  *
  86  * @kvm: the guest instance we are interested in.
  87  * @slot: the @gfn belongs to.
  88  * @gfn: the guest page.
  89  * @mode: tracking mode, currently only write track is supported.
  90  */
  91 void kvm_slot_page_track_add_page(struct kvm *kvm,
  92                                   struct kvm_memory_slot *slot, gfn_t gfn,
  93                                   enum kvm_page_track_mode mode)
  94 {
  95
  96         if (WARN_ON(!page_track_mode_is_valid(mode)))
  97                 return;
  98
  99         update_gfn_track(slot, gfn, mode, 1);
 100
 101         /*
 102          * new track stops large page mapping for the
 103          * tracked page.
 104          */
 105         kvm_mmu_gfn_disallow_lpage(slot, gfn);
 106
 107         if (mode == KVM_PAGE_TRACK_WRITE)
 108                 if (kvm_mmu_slot_gfn_write_protect(kvm, slot, gfn))
 109                         kvm_flush_remote_tlbs(kvm);
 110 }
 111 EXPORT_SYMBOL_GPL(kvm_slot_page_track_add_page);
 112
 113 /*
 114  * remove the guest page from the tracking pool which stops the interception
 115  * of corresponding access on that page. It is the opposed operation of
 116  * kvm_slot_page_track_add_page().
 117  *
 118  * It should be called under the protection both of mmu-lock and kvm->srcu
 119  * or kvm->slots_lock.
 120  *
 121  * @kvm: the guest instance we are interested in.
 122  * @slot: the @gfn belongs to.
 123  * @gfn: the guest page.
 124  * @mode: tracking mode, currently only write track is supported.
 125  */
 126 void kvm_slot_page_track_remove_page(struct kvm *kvm,
 127                                      struct kvm_memory_slot *slot, gfn_t gfn,
 128                                      enum kvm_page_track_mode mode)
 129 {
 130         if (WARN_ON(!page_track_mode_is_valid(mode)))
 131                 return;
 132
 133         update_gfn_track(slot, gfn, mode, -1);
 134
 135         /*
 136          * allow large page mapping for the tracked page
 137          * after the tracker is gone.
 138          */
 139         kvm_mmu_gfn_allow_lpage(slot, gfn);
 140 }
 141 EXPORT_SYMBOL_GPL(kvm_slot_page_track_remove_page);
 142
 143 /*
 144  * check if the corresponding access on the specified guest page is tracked.
 145  */
 146 bool kvm_page_track_is_active(struct kvm_vcpu *vcpu, gfn_t gfn,
 147                               enum kvm_page_track_mode mode)
 148 {
 149         struct kvm_memory_slot *slot;
 150         int index;
 151
 152         if (WARN_ON(!page_track_mode_is_valid(mode)))
 153                 return false;
 154
 155         slot = kvm_vcpu_gfn_to_memslot(vcpu, gfn);
 156         if (!slot)
 157                 return false;
 158
 159         index = gfn_to_index(gfn, slot->base_gfn, PT_PAGE_TABLE_LEVEL);
 160         return !!ACCESS_ONCE(slot->arch.gfn_track[mode][index]);
 161 }
 162
 163 void kvm_page_track_cleanup(struct kvm *kvm)
 164 {
 165         struct kvm_page_track_notifier_head *head;
 166
 167         head = &kvm->arch.track_notifier_head;
 168         cleanup_srcu_struct(&head->track_srcu);
 169 }
 170
 171 void kvm_page_track_init(struct kvm *kvm)
 172 {
 173         struct kvm_page_track_notifier_head *head;
 174
 175         head = &kvm->arch.track_notifier_head;
 176         init_srcu_struct(&head->track_srcu);
 177         INIT_HLIST_HEAD(&head->track_notifier_list);
 178 }
 179
 180 /*
 181  * register the notifier so that event interception for the tracked guest
 182  * pages can be received.
 183  */
 184 void
 185 kvm_page_track_register_notifier(struct kvm *kvm,
 186                                  struct kvm_page_track_notifier_node *n)
 187 {
 188         struct kvm_page_track_notifier_head *head;
 189
 190         head = &kvm->arch.track_notifier_head;
 191
 192         spin_lock(&kvm->mmu_lock);
 193         hlist_add_head_rcu(&n->node, &head->track_notifier_list);
 194         spin_unlock(&kvm->mmu_lock);
 195 }
 196 EXPORT_SYMBOL_GPL(kvm_page_track_register_notifier);
 197
 198 /*
 199  * stop receiving the event interception. It is the opposed operation of
 200  * kvm_page_track_register_notifier().
 201  */
 202 void
 203 kvm_page_track_unregister_notifier(struct kvm *kvm,
 204                                    struct kvm_page_track_notifier_node *n)
 205 {
 206         struct kvm_page_track_notifier_head *head;
 207
 208         head = &kvm->arch.track_notifier_head;
 209
 210         spin_lock(&kvm->mmu_lock);
 211         hlist_del_rcu(&n->node);
 212         spin_unlock(&kvm->mmu_lock);
 213         synchronize_srcu(&head->track_srcu);
 214 }
 215 EXPORT_SYMBOL_GPL(kvm_page_track_unregister_notifier);
 216
 217 /*
 218  * Notify the node that write access is intercepted and write emulation is
 219  * finished at this time.
 220  *
 221  * The node should figure out if the written page is the one that node is
 222  * interested in by itself.
 223  */
 224 void kvm_page_track_write(struct kvm_vcpu *vcpu, gpa_t gpa, const u8 *new,
 225                           int bytes)
 226 {
 227         struct kvm_page_track_notifier_head *head;
 228         struct kvm_page_track_notifier_node *n;
 229         int idx;
 230
 231         head = &vcpu->kvm->arch.track_notifier_head;
 232
 233         if (hlist_empty(&head->track_notifier_list))
 234                 return;
 235
 236         idx = srcu_read_lock(&head->track_srcu);
 237         hlist_for_each_entry_rcu(n, &head->track_notifier_list, node)
 238                 if (n->track_write)
 239                         n->track_write(vcpu, gpa, new, bytes, n);
 240         srcu_read_unlock(&head->track_srcu, idx);
 241 }
 242
 243 /*
 244  * Notify the node that memory slot is being removed or moved so that it can
 245  * drop write-protection for the pages in the memory slot.
 246  *
 247  * The node should figure out it has any write-protected pages in this slot
 248  * by itself.
 249  */
 250 void kvm_page_track_flush_slot(struct kvm *kvm, struct kvm_memory_slot *slot)
 251 {
 252         struct kvm_page_track_notifier_head *head;
 253         struct kvm_page_track_notifier_node *n;
 254         int idx;
 255
 256         head = &kvm->arch.track_notifier_head;
 257
 258         if (hlist_empty(&head->track_notifier_list))
 259                 return;
 260
 261         idx = srcu_read_lock(&head->track_srcu);
 262         hlist_for_each_entry_rcu(n, &head->track_notifier_list, node)
 263                 if (n->track_flush_slot)
 264                         n->track_flush_slot(kvm, slot, n);
 265         srcu_read_unlock(&head->track_srcu, idx);
 266 }