drivers/gpu/drm/vmwgfx/vmwgfx_page_dirty.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright 2019-2023 VMware, Inc., Palo Alto, CA., USA
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27 #include "vmwgfx_bo.h"
  28 #include "vmwgfx_drv.h"
  29
  30 /*
  31  * Different methods for tracking dirty:
  32  * VMW_BO_DIRTY_PAGETABLE - Scan the pagetable for hardware dirty bits
  33  * VMW_BO_DIRTY_MKWRITE - Write-protect page table entries and record write-
  34  * accesses in the VM mkwrite() callback
  35  */
  36 enum vmw_bo_dirty_method {
  37         VMW_BO_DIRTY_PAGETABLE,
  38         VMW_BO_DIRTY_MKWRITE,
  39 };
  40
  41 /*
  42  * No dirtied pages at scan trigger a transition to the _MKWRITE method,
  43  * similarly a certain percentage of dirty pages trigger a transition to
  44  * the _PAGETABLE method. How many triggers should we wait for before
  45  * changing method?
  46  */
  47 #define VMW_DIRTY_NUM_CHANGE_TRIGGERS 2
  48
  49 /* Percentage to trigger a transition to the _PAGETABLE method */
  50 #define VMW_DIRTY_PERCENTAGE 10
  51
  52 /**
  53  * struct vmw_bo_dirty - Dirty information for buffer objects
  54  * @start: First currently dirty bit
  55  * @end: Last currently dirty bit + 1
  56  * @method: The currently used dirty method
  57  * @change_count: Number of consecutive method change triggers
  58  * @ref_count: Reference count for this structure
  59  * @bitmap_size: The size of the bitmap in bits. Typically equal to the
  60  * nuber of pages in the bo.
  61  * @bitmap: A bitmap where each bit represents a page. A set bit means a
  62  * dirty page.
  63  */
  64 struct vmw_bo_dirty {
  65         unsigned long start;
  66         unsigned long end;
  67         enum vmw_bo_dirty_method method;
  68         unsigned int change_count;
  69         unsigned int ref_count;
  70         unsigned long bitmap_size;
  71         unsigned long bitmap[];
  72 };
  73
  74 /**
  75  * vmw_bo_dirty_scan_pagetable - Perform a pagetable scan for dirty bits
  76  * @vbo: The buffer object to scan
  77  *
  78  * Scans the pagetable for dirty bits. Clear those bits and modify the
  79  * dirty structure with the results. This function may change the
  80  * dirty-tracking method.
  81  */
  82 static void vmw_bo_dirty_scan_pagetable(struct vmw_bo *vbo)
  83 {
  84         struct vmw_bo_dirty *dirty = vbo->dirty;
  85         pgoff_t offset = drm_vma_node_start(&vbo->tbo.base.vma_node);
  86         struct address_space *mapping = vbo->tbo.bdev->dev_mapping;
  87         pgoff_t num_marked;
  88
  89         num_marked = clean_record_shared_mapping_range
  90                 (mapping,
  91                  offset, dirty->bitmap_size,
  92                  offset, &dirty->bitmap[0],
  93                  &dirty->start, &dirty->end);
  94         if (num_marked == 0)
  95                 dirty->change_count++;
  96         else
  97                 dirty->change_count = 0;
  98
  99         if (dirty->change_count > VMW_DIRTY_NUM_CHANGE_TRIGGERS) {
 100                 dirty->change_count = 0;
 101                 dirty->method = VMW_BO_DIRTY_MKWRITE;
 102                 wp_shared_mapping_range(mapping,
 103                                         offset, dirty->bitmap_size);
 104                 clean_record_shared_mapping_range(mapping,
 105                                                   offset, dirty->bitmap_size,
 106                                                   offset, &dirty->bitmap[0],
 107                                                   &dirty->start, &dirty->end);
 108         }
 109 }
 110
 111 /**
 112  * vmw_bo_dirty_scan_mkwrite - Reset the mkwrite dirty-tracking method
 113  * @vbo: The buffer object to scan
 114  *
 115  * Write-protect pages written to so that consecutive write accesses will
 116  * trigger a call to mkwrite.
 117  *
 118  * This function may change the dirty-tracking method.
 119  */
 120 static void vmw_bo_dirty_scan_mkwrite(struct vmw_bo *vbo)
 121 {
 122         struct vmw_bo_dirty *dirty = vbo->dirty;
 123         unsigned long offset = drm_vma_node_start(&vbo->tbo.base.vma_node);
 124         struct address_space *mapping = vbo->tbo.bdev->dev_mapping;
 125         pgoff_t num_marked;
 126
 127         if (dirty->end <= dirty->start)
 128                 return;
 129
 130         num_marked = wp_shared_mapping_range(vbo->tbo.bdev->dev_mapping,
 131                                              dirty->start + offset,
 132                                              dirty->end - dirty->start);
 133
 134         if (100UL * num_marked / dirty->bitmap_size >
 135             VMW_DIRTY_PERCENTAGE)
 136                 dirty->change_count++;
 137         else
 138                 dirty->change_count = 0;
 139
 140         if (dirty->change_count > VMW_DIRTY_NUM_CHANGE_TRIGGERS) {
 141                 pgoff_t start = 0;
 142                 pgoff_t end = dirty->bitmap_size;
 143
 144                 dirty->method = VMW_BO_DIRTY_PAGETABLE;
 145                 clean_record_shared_mapping_range(mapping, offset, end, offset,
 146                                                   &dirty->bitmap[0],
 147                                                   &start, &end);
 148                 bitmap_clear(&dirty->bitmap[0], 0, dirty->bitmap_size);
 149                 if (dirty->start < dirty->end)
 150                         bitmap_set(&dirty->bitmap[0], dirty->start,
 151                                    dirty->end - dirty->start);
 152                 dirty->change_count = 0;
 153         }
 154 }
 155
 156 /**
 157  * vmw_bo_dirty_scan - Scan for dirty pages and add them to the dirty
 158  * tracking structure
 159  * @vbo: The buffer object to scan
 160  *
 161  * This function may change the dirty tracking method.
 162  */
 163 void vmw_bo_dirty_scan(struct vmw_bo *vbo)
 164 {
 165         struct vmw_bo_dirty *dirty = vbo->dirty;
 166
 167         if (dirty->method == VMW_BO_DIRTY_PAGETABLE)
 168                 vmw_bo_dirty_scan_pagetable(vbo);
 169         else
 170                 vmw_bo_dirty_scan_mkwrite(vbo);
 171 }
 172
 173 /**
 174  * vmw_bo_dirty_pre_unmap - write-protect and pick up dirty pages before
 175  * an unmap_mapping_range operation.
 176  * @vbo: The buffer object,
 177  * @start: First page of the range within the buffer object.
 178  * @end: Last page of the range within the buffer object + 1.
 179  *
 180  * If we're using the _PAGETABLE scan method, we may leak dirty pages
 181  * when calling unmap_mapping_range(). This function makes sure we pick
 182  * up all dirty pages.
 183  */
 184 static void vmw_bo_dirty_pre_unmap(struct vmw_bo *vbo,
 185                                    pgoff_t start, pgoff_t end)
 186 {
 187         struct vmw_bo_dirty *dirty = vbo->dirty;
 188         unsigned long offset = drm_vma_node_start(&vbo->tbo.base.vma_node);
 189         struct address_space *mapping = vbo->tbo.bdev->dev_mapping;
 190
 191         if (dirty->method != VMW_BO_DIRTY_PAGETABLE || start >= end)
 192                 return;
 193
 194         wp_shared_mapping_range(mapping, start + offset, end - start);
 195         clean_record_shared_mapping_range(mapping, start + offset,
 196                                           end - start, offset,
 197                                           &dirty->bitmap[0], &dirty->start,
 198                                           &dirty->end);
 199 }
 200
 201 /**
 202  * vmw_bo_dirty_unmap - Clear all ptes pointing to a range within a bo
 203  * @vbo: The buffer object,
 204  * @start: First page of the range within the buffer object.
 205  * @end: Last page of the range within the buffer object + 1.
 206  *
 207  * This is similar to ttm_bo_unmap_virtual() except it takes a subrange.
 208  */
 209 void vmw_bo_dirty_unmap(struct vmw_bo *vbo,
 210                         pgoff_t start, pgoff_t end)
 211 {
 212         unsigned long offset = drm_vma_node_start(&vbo->tbo.base.vma_node);
 213         struct address_space *mapping = vbo->tbo.bdev->dev_mapping;
 214
 215         vmw_bo_dirty_pre_unmap(vbo, start, end);
 216         unmap_shared_mapping_range(mapping, (offset + start) << PAGE_SHIFT,
 217                                    (loff_t) (end - start) << PAGE_SHIFT);
 218 }
 219
 220 /**
 221  * vmw_bo_dirty_add - Add a dirty-tracking user to a buffer object
 222  * @vbo: The buffer object
 223  *
 224  * This function registers a dirty-tracking user to a buffer object.
 225  * A user can be for example a resource or a vma in a special user-space
 226  * mapping.
 227  *
 228  * Return: Zero on success, -ENOMEM on memory allocation failure.
 229  */
 230 int vmw_bo_dirty_add(struct vmw_bo *vbo)
 231 {
 232         struct vmw_bo_dirty *dirty = vbo->dirty;
 233         pgoff_t num_pages = PFN_UP(vbo->tbo.resource->size);
 234         size_t size;
 235         int ret;
 236
 237         if (dirty) {
 238                 dirty->ref_count++;
 239                 return 0;
 240         }
 241
 242         size = sizeof(*dirty) + BITS_TO_LONGS(num_pages) * sizeof(long);
 243         dirty = kvzalloc(size, GFP_KERNEL);
 244         if (!dirty) {
 245                 ret = -ENOMEM;
 246                 goto out_no_dirty;
 247         }
 248
 249         dirty->bitmap_size = num_pages;
 250         dirty->start = dirty->bitmap_size;
 251         dirty->end = 0;
 252         dirty->ref_count = 1;
 253         if (num_pages < PAGE_SIZE / sizeof(pte_t)) {
 254                 dirty->method = VMW_BO_DIRTY_PAGETABLE;
 255         } else {
 256                 struct address_space *mapping = vbo->tbo.bdev->dev_mapping;
 257                 pgoff_t offset = drm_vma_node_start(&vbo->tbo.base.vma_node);
 258
 259                 dirty->method = VMW_BO_DIRTY_MKWRITE;
 260
 261                 /* Write-protect and then pick up already dirty bits */
 262                 wp_shared_mapping_range(mapping, offset, num_pages);
 263                 clean_record_shared_mapping_range(mapping, offset, num_pages,
 264                                                   offset,
 265                                                   &dirty->bitmap[0],
 266                                                   &dirty->start, &dirty->end);
 267         }
 268
 269         vbo->dirty = dirty;
 270
 271         return 0;
 272
 273 out_no_dirty:
 274         return ret;
 275 }
 276
 277 /**
 278  * vmw_bo_dirty_release - Release a dirty-tracking user from a buffer object
 279  * @vbo: The buffer object
 280  *
 281  * This function releases a dirty-tracking user from a buffer object.
 282  * If the reference count reaches zero, then the dirty-tracking object is
 283  * freed and the pointer to it cleared.
 284  *
 285  * Return: Zero on success, -ENOMEM on memory allocation failure.
 286  */
 287 void vmw_bo_dirty_release(struct vmw_bo *vbo)
 288 {
 289         struct vmw_bo_dirty *dirty = vbo->dirty;
 290
 291         if (dirty && --dirty->ref_count == 0) {
 292                 kvfree(dirty);
 293                 vbo->dirty = NULL;
 294         }
 295 }
 296
 297 /**
 298  * vmw_bo_dirty_transfer_to_res - Pick up a resource's dirty region from
 299  * its backing mob.
 300  * @res: The resource
 301  *
 302  * This function will pick up all dirty ranges affecting the resource from
 303  * it's backup mob, and call vmw_resource_dirty_update() once for each
 304  * range. The transferred ranges will be cleared from the backing mob's
 305  * dirty tracking.
 306  */
 307 void vmw_bo_dirty_transfer_to_res(struct vmw_resource *res)
 308 {
 309         struct vmw_bo *vbo = res->guest_memory_bo;
 310         struct vmw_bo_dirty *dirty = vbo->dirty;
 311         pgoff_t start, cur, end;
 312         unsigned long res_start = res->guest_memory_offset;
 313         unsigned long res_end = res->guest_memory_offset + res->guest_memory_size;
 314
 315         WARN_ON_ONCE(res_start & ~PAGE_MASK);
 316         res_start >>= PAGE_SHIFT;
 317         res_end = DIV_ROUND_UP(res_end, PAGE_SIZE);
 318
 319         if (res_start >= dirty->end || res_end <= dirty->start)
 320                 return;
 321
 322         cur = max(res_start, dirty->start);
 323         res_end = max(res_end, dirty->end);
 324         while (cur < res_end) {
 325                 unsigned long num;
 326
 327                 start = find_next_bit(&dirty->bitmap[0], res_end, cur);
 328                 if (start >= res_end)
 329                         break;
 330
 331                 end = find_next_zero_bit(&dirty->bitmap[0], res_end, start + 1);
 332                 cur = end + 1;
 333                 num = end - start;
 334                 bitmap_clear(&dirty->bitmap[0], start, num);
 335                 vmw_resource_dirty_update(res, start, end);
 336         }
 337
 338         if (res_start <= dirty->start && res_end > dirty->start)
 339                 dirty->start = res_end;
 340         if (res_start < dirty->end && res_end >= dirty->end)
 341                 dirty->end = res_start;
 342 }
 343
 344 /**
 345  * vmw_bo_dirty_clear_res - Clear a resource's dirty region from
 346  * its backing mob.
 347  * @res: The resource
 348  *
 349  * This function will clear all dirty ranges affecting the resource from
 350  * it's backup mob's dirty tracking.
 351  */
 352 void vmw_bo_dirty_clear_res(struct vmw_resource *res)
 353 {
 354         unsigned long res_start = res->guest_memory_offset;
 355         unsigned long res_end = res->guest_memory_offset + res->guest_memory_size;
 356         struct vmw_bo *vbo = res->guest_memory_bo;
 357         struct vmw_bo_dirty *dirty = vbo->dirty;
 358
 359         res_start >>= PAGE_SHIFT;
 360         res_end = DIV_ROUND_UP(res_end, PAGE_SIZE);
 361
 362         if (res_start >= dirty->end || res_end <= dirty->start)
 363                 return;
 364
 365         res_start = max(res_start, dirty->start);
 366         res_end = min(res_end, dirty->end);
 367         bitmap_clear(&dirty->bitmap[0], res_start, res_end - res_start);
 368
 369         if (res_start <= dirty->start && res_end > dirty->start)
 370                 dirty->start = res_end;
 371         if (res_start < dirty->end && res_end >= dirty->end)
 372                 dirty->end = res_start;
 373 }
 374
 375 vm_fault_t vmw_bo_vm_mkwrite(struct vm_fault *vmf)
 376 {
 377         struct vm_area_struct *vma = vmf->vma;
 378         struct ttm_buffer_object *bo = (struct ttm_buffer_object *)
 379             vma->vm_private_data;
 380         vm_fault_t ret;
 381         unsigned long page_offset;
 382         unsigned int save_flags;
 383         struct vmw_bo *vbo = to_vmw_bo(&bo->base);
 384
 385         /*
 386          * mkwrite() doesn't handle the VM_FAULT_RETRY return value correctly.
 387          * So make sure the TTM helpers are aware.
 388          */
 389         save_flags = vmf->flags;
 390         vmf->flags &= ~FAULT_FLAG_ALLOW_RETRY;
 391         ret = ttm_bo_vm_reserve(bo, vmf);
 392         vmf->flags = save_flags;
 393         if (ret)
 394                 return ret;
 395
 396         page_offset = vmf->pgoff - drm_vma_node_start(&bo->base.vma_node);
 397         if (unlikely(page_offset >= PFN_UP(bo->resource->size))) {
 398                 ret = VM_FAULT_SIGBUS;
 399                 goto out_unlock;
 400         }
 401
 402         if (vbo->dirty && vbo->dirty->method == VMW_BO_DIRTY_MKWRITE &&
 403             !test_bit(page_offset, &vbo->dirty->bitmap[0])) {
 404                 struct vmw_bo_dirty *dirty = vbo->dirty;
 405
 406                 __set_bit(page_offset, &dirty->bitmap[0]);
 407                 dirty->start = min(dirty->start, page_offset);
 408                 dirty->end = max(dirty->end, page_offset + 1);
 409         }
 410
 411 out_unlock:
 412         dma_resv_unlock(bo->base.resv);
 413         return ret;
 414 }
 415
 416 vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf)
 417 {
 418         struct vm_area_struct *vma = vmf->vma;
 419         struct ttm_buffer_object *bo = (struct ttm_buffer_object *)
 420             vma->vm_private_data;
 421         struct vmw_bo *vbo = to_vmw_bo(&bo->base);
 422         pgoff_t num_prefault;
 423         pgprot_t prot;
 424         vm_fault_t ret;
 425
 426         ret = ttm_bo_vm_reserve(bo, vmf);
 427         if (ret)
 428                 return ret;
 429
 430         num_prefault = (vma->vm_flags & VM_RAND_READ) ? 1 :
 431                 TTM_BO_VM_NUM_PREFAULT;
 432
 433         if (vbo->dirty) {
 434                 pgoff_t allowed_prefault;
 435                 unsigned long page_offset;
 436
 437                 page_offset = vmf->pgoff -
 438                         drm_vma_node_start(&bo->base.vma_node);
 439                 if (page_offset >= PFN_UP(bo->resource->size) ||
 440                     vmw_resources_clean(vbo, page_offset,
 441                                         page_offset + PAGE_SIZE,
 442                                         &allowed_prefault)) {
 443                         ret = VM_FAULT_SIGBUS;
 444                         goto out_unlock;
 445                 }
 446
 447                 num_prefault = min(num_prefault, allowed_prefault);
 448         }
 449
 450         /*
 451          * If we don't track dirty using the MKWRITE method, make sure
 452          * sure the page protection is write-enabled so we don't get
 453          * a lot of unnecessary write faults.
 454          */
 455         if (vbo->dirty && vbo->dirty->method == VMW_BO_DIRTY_MKWRITE)
 456                 prot = vm_get_page_prot(vma->vm_flags & ~VM_SHARED);
 457         else
 458                 prot = vm_get_page_prot(vma->vm_flags);
 459
 460         ret = ttm_bo_vm_fault_reserved(vmf, prot, num_prefault);
 461         if (ret == VM_FAULT_RETRY && !(vmf->flags & FAULT_FLAG_RETRY_NOWAIT))
 462                 return ret;
 463
 464 out_unlock:
 465         dma_resv_unlock(bo->base.resv);
 466
 467         return ret;
 468 }