~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/kvm/page_track.c

Version: ~ [ linux-5.11 ] ~ [ linux-5.10.17 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.99 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.176 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.221 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.257 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.257 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp