virt/kvm/guest_memfd.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <linux/backing-dev.h>
   3 #include <linux/falloc.h>
   4 #include <linux/kvm_host.h>
   5 #include <linux/pagemap.h>
   6 #include <linux/anon_inodes.h>
   7
   8 #include "kvm_mm.h"
   9
  10 struct kvm_gmem {
  11         struct kvm *kvm;
  12         struct xarray bindings;
  13         struct list_head entry;
  14 };
  15
  16 /**
  17  * folio_file_pfn - like folio_file_page, but return a pfn.
  18  * @folio: The folio which contains this index.
  19  * @index: The index we want to look up.
  20  *
  21  * Return: The pfn for this index.
  22  */
  23 static inline kvm_pfn_t folio_file_pfn(struct folio *folio, pgoff_t index)
  24 {
  25         return folio_pfn(folio) + (index & (folio_nr_pages(folio) - 1));
  26 }
  27
  28 static int __kvm_gmem_prepare_folio(struct kvm *kvm, struct kvm_memory_slot *slot,
  29                                     pgoff_t index, struct folio *folio)
  30 {
  31 #ifdef CONFIG_HAVE_KVM_ARCH_GMEM_PREPARE
  32         kvm_pfn_t pfn = folio_file_pfn(folio, index);
  33         gfn_t gfn = slot->base_gfn + index - slot->gmem.pgoff;
  34         int rc = kvm_arch_gmem_prepare(kvm, gfn, pfn, folio_order(folio));
  35         if (rc) {
  36                 pr_warn_ratelimited("gmem: Failed to prepare folio for index %lx GFN %llx PFN %llx error %d.\n",
  37                                     index, gfn, pfn, rc);
  38                 return rc;
  39         }
  40 #endif
  41
  42         return 0;
  43 }
  44
  45 static inline void kvm_gmem_mark_prepared(struct folio *folio)
  46 {
  47         folio_mark_uptodate(folio);
  48 }
  49
  50 /*
  51  * Process @folio, which contains @gfn, so that the guest can use it.
  52  * The folio must be locked and the gfn must be contained in @slot.
  53  * On successful return the guest sees a zero page so as to avoid
  54  * leaking host data and the up-to-date flag is set.
  55  */
  56 static int kvm_gmem_prepare_folio(struct kvm *kvm, struct kvm_memory_slot *slot,
  57                                   gfn_t gfn, struct folio *folio)
  58 {
  59         unsigned long nr_pages, i;
  60         pgoff_t index;
  61         int r;
  62
  63         nr_pages = folio_nr_pages(folio);
  64         for (i = 0; i < nr_pages; i++)
  65                 clear_highpage(folio_page(folio, i));
  66
  67         /*
  68          * Preparing huge folios should always be safe, since it should
  69          * be possible to split them later if needed.
  70          *
  71          * Right now the folio order is always going to be zero, but the
  72          * code is ready for huge folios.  The only assumption is that
  73          * the base pgoff of memslots is naturally aligned with the
  74          * requested page order, ensuring that huge folios can also use
  75          * huge page table entries for GPA->HPA mapping.
  76          *
  77          * The order will be passed when creating the guest_memfd, and
  78          * checked when creating memslots.
  79          */
  80         WARN_ON(!IS_ALIGNED(slot->gmem.pgoff, 1 << folio_order(folio)));
  81         index = gfn - slot->base_gfn + slot->gmem.pgoff;
  82         index = ALIGN_DOWN(index, 1 << folio_order(folio));
  83         r = __kvm_gmem_prepare_folio(kvm, slot, index, folio);
  84         if (!r)
  85                 kvm_gmem_mark_prepared(folio);
  86
  87         return r;
  88 }
  89
  90 /*
  91  * Returns a locked folio on success.  The caller is responsible for
  92  * setting the up-to-date flag before the memory is mapped into the guest.
  93  * There is no backing storage for the memory, so the folio will remain
  94  * up-to-date until it's removed.
  95  *
  96  * Ignore accessed, referenced, and dirty flags.  The memory is
  97  * unevictable and there is no storage to write back to.
  98  */
  99 static struct folio *kvm_gmem_get_folio(struct inode *inode, pgoff_t index)
 100 {
 101         /* TODO: Support huge pages. */
 102         return filemap_grab_folio(inode->i_mapping, index);
 103 }
 104
 105 static void kvm_gmem_invalidate_begin(struct kvm_gmem *gmem, pgoff_t start,
 106                                       pgoff_t end)
 107 {
 108         bool flush = false, found_memslot = false;
 109         struct kvm_memory_slot *slot;
 110         struct kvm *kvm = gmem->kvm;
 111         unsigned long index;
 112
 113         xa_for_each_range(&gmem->bindings, index, slot, start, end - 1) {
 114                 pgoff_t pgoff = slot->gmem.pgoff;
 115
 116                 struct kvm_gfn_range gfn_range = {
 117                         .start = slot->base_gfn + max(pgoff, start) - pgoff,
 118                         .end = slot->base_gfn + min(pgoff + slot->npages, end) - pgoff,
 119                         .slot = slot,
 120                         .may_block = true,
 121                         /* guest memfd is relevant to only private mappings. */
 122                         .attr_filter = KVM_FILTER_PRIVATE,
 123                 };
 124
 125                 if (!found_memslot) {
 126                         found_memslot = true;
 127
 128                         KVM_MMU_LOCK(kvm);
 129                         kvm_mmu_invalidate_begin(kvm);
 130                 }
 131
 132                 flush |= kvm_mmu_unmap_gfn_range(kvm, &gfn_range);
 133         }
 134
 135         if (flush)
 136                 kvm_flush_remote_tlbs(kvm);
 137
 138         if (found_memslot)
 139                 KVM_MMU_UNLOCK(kvm);
 140 }
 141
 142 static void kvm_gmem_invalidate_end(struct kvm_gmem *gmem, pgoff_t start,
 143                                     pgoff_t end)
 144 {
 145         struct kvm *kvm = gmem->kvm;
 146
 147         if (xa_find(&gmem->bindings, &start, end - 1, XA_PRESENT)) {
 148                 KVM_MMU_LOCK(kvm);
 149                 kvm_mmu_invalidate_end(kvm);
 150                 KVM_MMU_UNLOCK(kvm);
 151         }
 152 }
 153
 154 static long kvm_gmem_punch_hole(struct inode *inode, loff_t offset, loff_t len)
 155 {
 156         struct list_head *gmem_list = &inode->i_mapping->i_private_list;
 157         pgoff_t start = offset >> PAGE_SHIFT;
 158         pgoff_t end = (offset + len) >> PAGE_SHIFT;
 159         struct kvm_gmem *gmem;
 160
 161         /*
 162          * Bindings must be stable across invalidation to ensure the start+end
 163          * are balanced.
 164          */
 165         filemap_invalidate_lock(inode->i_mapping);
 166
 167         list_for_each_entry(gmem, gmem_list, entry)
 168                 kvm_gmem_invalidate_begin(gmem, start, end);
 169
 170         truncate_inode_pages_range(inode->i_mapping, offset, offset + len - 1);
 171
 172         list_for_each_entry(gmem, gmem_list, entry)
 173                 kvm_gmem_invalidate_end(gmem, start, end);
 174
 175         filemap_invalidate_unlock(inode->i_mapping);
 176
 177         return 0;
 178 }
 179
 180 static long kvm_gmem_allocate(struct inode *inode, loff_t offset, loff_t len)
 181 {
 182         struct address_space *mapping = inode->i_mapping;
 183         pgoff_t start, index, end;
 184         int r;
 185
 186         /* Dedicated guest is immutable by default. */
 187         if (offset + len > i_size_read(inode))
 188                 return -EINVAL;
 189
 190         filemap_invalidate_lock_shared(mapping);
 191
 192         start = offset >> PAGE_SHIFT;
 193         end = (offset + len) >> PAGE_SHIFT;
 194
 195         r = 0;
 196         for (index = start; index < end; ) {
 197                 struct folio *folio;
 198
 199                 if (signal_pending(current)) {
 200                         r = -EINTR;
 201                         break;
 202                 }
 203
 204                 folio = kvm_gmem_get_folio(inode, index);
 205                 if (IS_ERR(folio)) {
 206                         r = PTR_ERR(folio);
 207                         break;
 208                 }
 209
 210                 index = folio_next_index(folio);
 211
 212                 folio_unlock(folio);
 213                 folio_put(folio);
 214
 215                 /* 64-bit only, wrapping the index should be impossible. */
 216                 if (WARN_ON_ONCE(!index))
 217                         break;
 218
 219                 cond_resched();
 220         }
 221
 222         filemap_invalidate_unlock_shared(mapping);
 223
 224         return r;
 225 }
 226
 227 static long kvm_gmem_fallocate(struct file *file, int mode, loff_t offset,
 228                                loff_t len)
 229 {
 230         int ret;
 231
 232         if (!(mode & FALLOC_FL_KEEP_SIZE))
 233                 return -EOPNOTSUPP;
 234
 235         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
 236                 return -EOPNOTSUPP;
 237
 238         if (!PAGE_ALIGNED(offset) || !PAGE_ALIGNED(len))
 239                 return -EINVAL;
 240
 241         if (mode & FALLOC_FL_PUNCH_HOLE)
 242                 ret = kvm_gmem_punch_hole(file_inode(file), offset, len);
 243         else
 244                 ret = kvm_gmem_allocate(file_inode(file), offset, len);
 245
 246         if (!ret)
 247                 file_modified(file);
 248         return ret;
 249 }
 250
 251 static int kvm_gmem_release(struct inode *inode, struct file *file)
 252 {
 253         struct kvm_gmem *gmem = file->private_data;
 254         struct kvm_memory_slot *slot;
 255         struct kvm *kvm = gmem->kvm;
 256         unsigned long index;
 257
 258         /*
 259          * Prevent concurrent attempts to *unbind* a memslot.  This is the last
 260          * reference to the file and thus no new bindings can be created, but
 261          * dereferencing the slot for existing bindings needs to be protected
 262          * against memslot updates, specifically so that unbind doesn't race
 263          * and free the memslot (kvm_gmem_get_file() will return NULL).
 264          *
 265          * Since .release is called only when the reference count is zero,
 266          * after which file_ref_get() and get_file_active() fail,
 267          * kvm_gmem_get_pfn() cannot be using the file concurrently.
 268          * file_ref_put() provides a full barrier, and get_file_active() the
 269          * matching acquire barrier.
 270          */
 271         mutex_lock(&kvm->slots_lock);
 272
 273         filemap_invalidate_lock(inode->i_mapping);
 274
 275         xa_for_each(&gmem->bindings, index, slot)
 276                 WRITE_ONCE(slot->gmem.file, NULL);
 277
 278         /*
 279          * All in-flight operations are gone and new bindings can be created.
 280          * Zap all SPTEs pointed at by this file.  Do not free the backing
 281          * memory, as its lifetime is associated with the inode, not the file.
 282          */
 283         kvm_gmem_invalidate_begin(gmem, 0, -1ul);
 284         kvm_gmem_invalidate_end(gmem, 0, -1ul);
 285
 286         list_del(&gmem->entry);
 287
 288         filemap_invalidate_unlock(inode->i_mapping);
 289
 290         mutex_unlock(&kvm->slots_lock);
 291
 292         xa_destroy(&gmem->bindings);
 293         kfree(gmem);
 294
 295         kvm_put_kvm(kvm);
 296
 297         return 0;
 298 }
 299
 300 static inline struct file *kvm_gmem_get_file(struct kvm_memory_slot *slot)
 301 {
 302         /*
 303          * Do not return slot->gmem.file if it has already been closed;
 304          * there might be some time between the last fput() and when
 305          * kvm_gmem_release() clears slot->gmem.file.
 306          */
 307         return get_file_active(&slot->gmem.file);
 308 }
 309
 310 static pgoff_t kvm_gmem_get_index(struct kvm_memory_slot *slot, gfn_t gfn)
 311 {
 312         return gfn - slot->base_gfn + slot->gmem.pgoff;
 313 }
 314
 315 static struct file_operations kvm_gmem_fops = {
 316         .open           = generic_file_open,
 317         .release        = kvm_gmem_release,
 318         .fallocate      = kvm_gmem_fallocate,
 319 };
 320
 321 void kvm_gmem_init(struct module *module)
 322 {
 323         kvm_gmem_fops.owner = module;
 324 }
 325
 326 static int kvm_gmem_migrate_folio(struct address_space *mapping,
 327                                   struct folio *dst, struct folio *src,
 328                                   enum migrate_mode mode)
 329 {
 330         WARN_ON_ONCE(1);
 331         return -EINVAL;
 332 }
 333
 334 static int kvm_gmem_error_folio(struct address_space *mapping, struct folio *folio)
 335 {
 336         struct list_head *gmem_list = &mapping->i_private_list;
 337         struct kvm_gmem *gmem;
 338         pgoff_t start, end;
 339
 340         filemap_invalidate_lock_shared(mapping);
 341
 342         start = folio->index;
 343         end = start + folio_nr_pages(folio);
 344
 345         list_for_each_entry(gmem, gmem_list, entry)
 346                 kvm_gmem_invalidate_begin(gmem, start, end);
 347
 348         /*
 349          * Do not truncate the range, what action is taken in response to the
 350          * error is userspace's decision (assuming the architecture supports
 351          * gracefully handling memory errors).  If/when the guest attempts to
 352          * access a poisoned page, kvm_gmem_get_pfn() will return -EHWPOISON,
 353          * at which point KVM can either terminate the VM or propagate the
 354          * error to userspace.
 355          */
 356
 357         list_for_each_entry(gmem, gmem_list, entry)
 358                 kvm_gmem_invalidate_end(gmem, start, end);
 359
 360         filemap_invalidate_unlock_shared(mapping);
 361
 362         return MF_DELAYED;
 363 }
 364
 365 #ifdef CONFIG_HAVE_KVM_ARCH_GMEM_INVALIDATE
 366 static void kvm_gmem_free_folio(struct folio *folio)
 367 {
 368         struct page *page = folio_page(folio, 0);
 369         kvm_pfn_t pfn = page_to_pfn(page);
 370         int order = folio_order(folio);
 371
 372         kvm_arch_gmem_invalidate(pfn, pfn + (1ul << order));
 373 }
 374 #endif
 375
 376 static const struct address_space_operations kvm_gmem_aops = {
 377         .dirty_folio = noop_dirty_folio,
 378         .migrate_folio  = kvm_gmem_migrate_folio,
 379         .error_remove_folio = kvm_gmem_error_folio,
 380 #ifdef CONFIG_HAVE_KVM_ARCH_GMEM_INVALIDATE
 381         .free_folio = kvm_gmem_free_folio,
 382 #endif
 383 };
 384
 385 static int kvm_gmem_getattr(struct mnt_idmap *idmap, const struct path *path,
 386                             struct kstat *stat, u32 request_mask,
 387                             unsigned int query_flags)
 388 {
 389         struct inode *inode = path->dentry->d_inode;
 390
 391         generic_fillattr(idmap, request_mask, inode, stat);
 392         return 0;
 393 }
 394
 395 static int kvm_gmem_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
 396                             struct iattr *attr)
 397 {
 398         return -EINVAL;
 399 }
 400 static const struct inode_operations kvm_gmem_iops = {
 401         .getattr        = kvm_gmem_getattr,
 402         .setattr        = kvm_gmem_setattr,
 403 };
 404
 405 static int __kvm_gmem_create(struct kvm *kvm, loff_t size, u64 flags)
 406 {
 407         const char *anon_name = "[kvm-gmem]";
 408         struct kvm_gmem *gmem;
 409         struct inode *inode;
 410         struct file *file;
 411         int fd, err;
 412
 413         fd = get_unused_fd_flags(0);
 414         if (fd < 0)
 415                 return fd;
 416
 417         gmem = kzalloc(sizeof(*gmem), GFP_KERNEL);
 418         if (!gmem) {
 419                 err = -ENOMEM;
 420                 goto err_fd;
 421         }
 422
 423         file = anon_inode_create_getfile(anon_name, &kvm_gmem_fops, gmem,
 424                                          O_RDWR, NULL);
 425         if (IS_ERR(file)) {
 426                 err = PTR_ERR(file);
 427                 goto err_gmem;
 428         }
 429
 430         file->f_flags |= O_LARGEFILE;
 431
 432         inode = file->f_inode;
 433         WARN_ON(file->f_mapping != inode->i_mapping);
 434
 435         inode->i_private = (void *)(unsigned long)flags;
 436         inode->i_op = &kvm_gmem_iops;
 437         inode->i_mapping->a_ops = &kvm_gmem_aops;
 438         inode->i_mode |= S_IFREG;
 439         inode->i_size = size;
 440         mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER);
 441         mapping_set_inaccessible(inode->i_mapping);
 442         /* Unmovable mappings are supposed to be marked unevictable as well. */
 443         WARN_ON_ONCE(!mapping_unevictable(inode->i_mapping));
 444
 445         kvm_get_kvm(kvm);
 446         gmem->kvm = kvm;
 447         xa_init(&gmem->bindings);
 448         list_add(&gmem->entry, &inode->i_mapping->i_private_list);
 449
 450         fd_install(fd, file);
 451         return fd;
 452
 453 err_gmem:
 454         kfree(gmem);
 455 err_fd:
 456         put_unused_fd(fd);
 457         return err;
 458 }
 459
 460 int kvm_gmem_create(struct kvm *kvm, struct kvm_create_guest_memfd *args)
 461 {
 462         loff_t size = args->size;
 463         u64 flags = args->flags;
 464         u64 valid_flags = 0;
 465
 466         if (flags & ~valid_flags)
 467                 return -EINVAL;
 468
 469         if (size <= 0 || !PAGE_ALIGNED(size))
 470                 return -EINVAL;
 471
 472         return __kvm_gmem_create(kvm, size, flags);
 473 }
 474
 475 int kvm_gmem_bind(struct kvm *kvm, struct kvm_memory_slot *slot,
 476                   unsigned int fd, loff_t offset)
 477 {
 478         loff_t size = slot->npages << PAGE_SHIFT;
 479         unsigned long start, end;
 480         struct kvm_gmem *gmem;
 481         struct inode *inode;
 482         struct file *file;
 483         int r = -EINVAL;
 484
 485         BUILD_BUG_ON(sizeof(gfn_t) != sizeof(slot->gmem.pgoff));
 486
 487         file = fget(fd);
 488         if (!file)
 489                 return -EBADF;
 490
 491         if (file->f_op != &kvm_gmem_fops)
 492                 goto err;
 493
 494         gmem = file->private_data;
 495         if (gmem->kvm != kvm)
 496                 goto err;
 497
 498         inode = file_inode(file);
 499
 500         if (offset < 0 || !PAGE_ALIGNED(offset) ||
 501             offset + size > i_size_read(inode))
 502                 goto err;
 503
 504         filemap_invalidate_lock(inode->i_mapping);
 505
 506         start = offset >> PAGE_SHIFT;
 507         end = start + slot->npages;
 508
 509         if (!xa_empty(&gmem->bindings) &&
 510             xa_find(&gmem->bindings, &start, end - 1, XA_PRESENT)) {
 511                 filemap_invalidate_unlock(inode->i_mapping);
 512                 goto err;
 513         }
 514
 515         /*
 516          * memslots of flag KVM_MEM_GUEST_MEMFD are immutable to change, so
 517          * kvm_gmem_bind() must occur on a new memslot.  Because the memslot
 518          * is not visible yet, kvm_gmem_get_pfn() is guaranteed to see the file.
 519          */
 520         WRITE_ONCE(slot->gmem.file, file);
 521         slot->gmem.pgoff = start;
 522
 523         xa_store_range(&gmem->bindings, start, end - 1, slot, GFP_KERNEL);
 524         filemap_invalidate_unlock(inode->i_mapping);
 525
 526         /*
 527          * Drop the reference to the file, even on success.  The file pins KVM,
 528          * not the other way 'round.  Active bindings are invalidated if the
 529          * file is closed before memslots are destroyed.
 530          */
 531         r = 0;
 532 err:
 533         fput(file);
 534         return r;
 535 }
 536
 537 void kvm_gmem_unbind(struct kvm_memory_slot *slot)
 538 {
 539         unsigned long start = slot->gmem.pgoff;
 540         unsigned long end = start + slot->npages;
 541         struct kvm_gmem *gmem;
 542         struct file *file;
 543
 544         /*
 545          * Nothing to do if the underlying file was already closed (or is being
 546          * closed right now), kvm_gmem_release() invalidates all bindings.
 547          */
 548         file = kvm_gmem_get_file(slot);
 549         if (!file)
 550                 return;
 551
 552         gmem = file->private_data;
 553
 554         filemap_invalidate_lock(file->f_mapping);
 555         xa_store_range(&gmem->bindings, start, end - 1, NULL, GFP_KERNEL);
 556
 557         /*
 558          * synchronize_srcu(&kvm->srcu) ensured that kvm_gmem_get_pfn()
 559          * cannot see this memslot.
 560          */
 561         WRITE_ONCE(slot->gmem.file, NULL);
 562         filemap_invalidate_unlock(file->f_mapping);
 563
 564         fput(file);
 565 }
 566
 567 /* Returns a locked folio on success.  */
 568 static struct folio *__kvm_gmem_get_pfn(struct file *file,
 569                                         struct kvm_memory_slot *slot,
 570                                         pgoff_t index, kvm_pfn_t *pfn,
 571                                         bool *is_prepared, int *max_order)
 572 {
 573         struct file *gmem_file = READ_ONCE(slot->gmem.file);
 574         struct kvm_gmem *gmem = file->private_data;
 575         struct folio *folio;
 576
 577         if (file != gmem_file) {
 578                 WARN_ON_ONCE(gmem_file);
 579                 return ERR_PTR(-EFAULT);
 580         }
 581
 582         gmem = file->private_data;
 583         if (xa_load(&gmem->bindings, index) != slot) {
 584                 WARN_ON_ONCE(xa_load(&gmem->bindings, index));
 585                 return ERR_PTR(-EIO);
 586         }
 587
 588         folio = kvm_gmem_get_folio(file_inode(file), index);
 589         if (IS_ERR(folio))
 590                 return folio;
 591
 592         if (folio_test_hwpoison(folio)) {
 593                 folio_unlock(folio);
 594                 folio_put(folio);
 595                 return ERR_PTR(-EHWPOISON);
 596         }
 597
 598         *pfn = folio_file_pfn(folio, index);
 599         if (max_order)
 600                 *max_order = 0;
 601
 602         *is_prepared = folio_test_uptodate(folio);
 603         return folio;
 604 }
 605
 606 int kvm_gmem_get_pfn(struct kvm *kvm, struct kvm_memory_slot *slot,
 607                      gfn_t gfn, kvm_pfn_t *pfn, struct page **page,
 608                      int *max_order)
 609 {
 610         pgoff_t index = kvm_gmem_get_index(slot, gfn);
 611         struct file *file = kvm_gmem_get_file(slot);
 612         struct folio *folio;
 613         bool is_prepared = false;
 614         int r = 0;
 615
 616         if (!file)
 617                 return -EFAULT;
 618
 619         folio = __kvm_gmem_get_pfn(file, slot, index, pfn, &is_prepared, max_order);
 620         if (IS_ERR(folio)) {
 621                 r = PTR_ERR(folio);
 622                 goto out;
 623         }
 624
 625         if (!is_prepared)
 626                 r = kvm_gmem_prepare_folio(kvm, slot, gfn, folio);
 627
 628         folio_unlock(folio);
 629
 630         if (!r)
 631                 *page = folio_file_page(folio, index);
 632         else
 633                 folio_put(folio);
 634
 635 out:
 636         fput(file);
 637         return r;
 638 }
 639 EXPORT_SYMBOL_GPL(kvm_gmem_get_pfn);
 640
 641 #ifdef CONFIG_KVM_GENERIC_PRIVATE_MEM
 642 long kvm_gmem_populate(struct kvm *kvm, gfn_t start_gfn, void __user *src, long npages,
 643                        kvm_gmem_populate_cb post_populate, void *opaque)
 644 {
 645         struct file *file;
 646         struct kvm_memory_slot *slot;
 647         void __user *p;
 648
 649         int ret = 0, max_order;
 650         long i;
 651
 652         lockdep_assert_held(&kvm->slots_lock);
 653         if (npages < 0)
 654                 return -EINVAL;
 655
 656         slot = gfn_to_memslot(kvm, start_gfn);
 657         if (!kvm_slot_can_be_private(slot))
 658                 return -EINVAL;
 659
 660         file = kvm_gmem_get_file(slot);
 661         if (!file)
 662                 return -EFAULT;
 663
 664         filemap_invalidate_lock(file->f_mapping);
 665
 666         npages = min_t(ulong, slot->npages - (start_gfn - slot->base_gfn), npages);
 667         for (i = 0; i < npages; i += (1 << max_order)) {
 668                 struct folio *folio;
 669                 gfn_t gfn = start_gfn + i;
 670                 pgoff_t index = kvm_gmem_get_index(slot, gfn);
 671                 bool is_prepared = false;
 672                 kvm_pfn_t pfn;
 673
 674                 if (signal_pending(current)) {
 675                         ret = -EINTR;
 676                         break;
 677                 }
 678
 679                 folio = __kvm_gmem_get_pfn(file, slot, index, &pfn, &is_prepared, &max_order);
 680                 if (IS_ERR(folio)) {
 681                         ret = PTR_ERR(folio);
 682                         break;
 683                 }
 684
 685                 if (is_prepared) {
 686                         folio_unlock(folio);
 687                         folio_put(folio);
 688                         ret = -EEXIST;
 689                         break;
 690                 }
 691
 692                 folio_unlock(folio);
 693                 WARN_ON(!IS_ALIGNED(gfn, 1 << max_order) ||
 694                         (npages - i) < (1 << max_order));
 695
 696                 ret = -EINVAL;
 697                 while (!kvm_range_has_memory_attributes(kvm, gfn, gfn + (1 << max_order),
 698                                                         KVM_MEMORY_ATTRIBUTE_PRIVATE,
 699                                                         KVM_MEMORY_ATTRIBUTE_PRIVATE)) {
 700                         if (!max_order)
 701                                 goto put_folio_and_exit;
 702                         max_order--;
 703                 }
 704
 705                 p = src ? src + i * PAGE_SIZE : NULL;
 706                 ret = post_populate(kvm, gfn, pfn, p, max_order, opaque);
 707                 if (!ret)
 708                         kvm_gmem_mark_prepared(folio);
 709
 710 put_folio_and_exit:
 711                 folio_put(folio);
 712                 if (ret)
 713                         break;
 714         }
 715
 716         filemap_invalidate_unlock(file->f_mapping);
 717
 718         fput(file);
 719         return ret && !i ? ret : i;
 720 }
 721 EXPORT_SYMBOL_GPL(kvm_gmem_populate);
 722 #endif