i915/gvt/page_track.c

0001 /*
0002  * Copyright(c) 2011-2017 Intel Corporation. All rights reserved.
0003  *
0004  * Permission is hereby granted, free of charge, to any person obtaining a
0005  * copy of this software and associated documentation files (the "Software"),
0006  * to deal in the Software without restriction, including without limitation
0007  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
0008  * and/or sell copies of the Software, and to permit persons to whom the
0009  * Software is furnished to do so, subject to the following conditions:
0010  *
0011  * The above copyright notice and this permission notice (including the next
0012  * paragraph) shall be included in all copies or substantial portions of the
0013  * Software.
0014  *
0015  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
0016  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
0017  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
0018  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
0019  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
0020  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
0021  * SOFTWARE.
0022  */
0023 #include "i915_drv.h"
0024 #include "gvt.h"
0025
0026 /**
0027  * intel_vgpu_find_page_track - find page track rcord of guest page
0028  * @vgpu: a vGPU
0029  * @gfn: the gfn of guest page
0030  *
0031  * Returns:
0032  * A pointer to struct intel_vgpu_page_track if found, else NULL returned.
0033  */
0034 struct intel_vgpu_page_track *intel_vgpu_find_page_track(
0035         struct intel_vgpu *vgpu, unsigned long gfn)
0036 {
0037     return radix_tree_lookup(&vgpu->page_track_tree, gfn);
0038 }
0039
0040 /**
0041  * intel_vgpu_register_page_track - register a guest page to be tacked
0042  * @vgpu: a vGPU
0043  * @gfn: the gfn of guest page
0044  * @handler: page track handler
0045  * @priv: tracker private
0046  *
0047  * Returns:
0048  * zero on success, negative error code if failed.
0049  */
0050 int intel_vgpu_register_page_track(struct intel_vgpu *vgpu, unsigned long gfn,
0051         gvt_page_track_handler_t handler, void *priv)
0052 {
0053     struct intel_vgpu_page_track *track;
0054     int ret;
0055
0056     track = intel_vgpu_find_page_track(vgpu, gfn);
0057     if (track)
0058         return -EEXIST;
0059
0060     track = kzalloc(sizeof(*track), GFP_KERNEL);
0061     if (!track)
0062         return -ENOMEM;
0063
0064     track->handler = handler;
0065     track->priv_data = priv;
0066
0067     ret = radix_tree_insert(&vgpu->page_track_tree, gfn, track);
0068     if (ret) {
0069         kfree(track);
0070         return ret;
0071     }
0072
0073     return 0;
0074 }
0075
0076 /**
0077  * intel_vgpu_unregister_page_track - unregister the tracked guest page
0078  * @vgpu: a vGPU
0079  * @gfn: the gfn of guest page
0080  *
0081  */
0082 void intel_vgpu_unregister_page_track(struct intel_vgpu *vgpu,
0083         unsigned long gfn)
0084 {
0085     struct intel_vgpu_page_track *track;
0086
0087     track = radix_tree_delete(&vgpu->page_track_tree, gfn);
0088     if (track) {
0089         if (track->tracked)
0090             intel_gvt_page_track_remove(vgpu, gfn);
0091         kfree(track);
0092     }
0093 }
0094
0095 /**
0096  * intel_vgpu_enable_page_track - set write-protection on guest page
0097  * @vgpu: a vGPU
0098  * @gfn: the gfn of guest page
0099  *
0100  * Returns:
0101  * zero on success, negative error code if failed.
0102  */
0103 int intel_vgpu_enable_page_track(struct intel_vgpu *vgpu, unsigned long gfn)
0104 {
0105     struct intel_vgpu_page_track *track;
0106     int ret;
0107
0108     track = intel_vgpu_find_page_track(vgpu, gfn);
0109     if (!track)
0110         return -ENXIO;
0111
0112     if (track->tracked)
0113         return 0;
0114
0115     ret = intel_gvt_page_track_add(vgpu, gfn);
0116     if (ret)
0117         return ret;
0118     track->tracked = true;
0119     return 0;
0120 }
0121
0122 /**
0123  * intel_vgpu_enable_page_track - cancel write-protection on guest page
0124  * @vgpu: a vGPU
0125  * @gfn: the gfn of guest page
0126  *
0127  * Returns:
0128  * zero on success, negative error code if failed.
0129  */
0130 int intel_vgpu_disable_page_track(struct intel_vgpu *vgpu, unsigned long gfn)
0131 {
0132     struct intel_vgpu_page_track *track;
0133     int ret;
0134
0135     track = intel_vgpu_find_page_track(vgpu, gfn);
0136     if (!track)
0137         return -ENXIO;
0138
0139     if (!track->tracked)
0140         return 0;
0141
0142     ret = intel_gvt_page_track_remove(vgpu, gfn);
0143     if (ret)
0144         return ret;
0145     track->tracked = false;
0146     return 0;
0147 }
0148
0149 /**
0150  * intel_vgpu_page_track_handler - called when write to write-protected page
0151  * @vgpu: a vGPU
0152  * @gpa: the gpa of this write
0153  * @data: the writed data
0154  * @bytes: the length of this write
0155  *
0156  * Returns:
0157  * zero on success, negative error code if failed.
0158  */
0159 int intel_vgpu_page_track_handler(struct intel_vgpu *vgpu, u64 gpa,
0160         void *data, unsigned int bytes)
0161 {
0162     struct intel_vgpu_page_track *page_track;
0163     int ret = 0;
0164
0165     mutex_lock(&vgpu->vgpu_lock);
0166
0167     page_track = intel_vgpu_find_page_track(vgpu, gpa >> PAGE_SHIFT);
0168     if (!page_track) {
0169         ret = -ENXIO;
0170         goto out;
0171     }
0172
0173     if (unlikely(vgpu->failsafe)) {
0174         /* Remove write protection to prevent furture traps. */
0175         intel_gvt_page_track_remove(vgpu, gpa >> PAGE_SHIFT);
0176     } else {
0177         ret = page_track->handler(page_track, gpa, data, bytes);
0178         if (ret)
0179             gvt_err("guest page write error, gpa %llx\n", gpa);
0180     }
0181
0182 out:
0183     mutex_unlock(&vgpu->vgpu_lock);
0184     return ret;
0185 }