Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
KVM: guest_memfd: Rename "struct kvm_gmem" to "struct gmem_file"
Rename the "kvm_gmem" structure to "gmem_file" in anticipation of using
dedicated guest_memfd inodes instead of anonyomous inodes, at which point
the "kvm_gmem" nomenclature becomes quite misleading. In guest_memfd,
inodes are effectively the raw underlying physical storage, and will be
used to track properties of the physical memory, while each gmem file is
effectively a single VM's view of that storage, and is used to track assets
specific to its associated VM, e.g. memslots=>gmem bindings.
Using "kvm_gmem" suggests that the per-VM/per-file structures are _the_
guest_memfd instance, which almost the exact opposite of reality.
Opportunistically rename local variables from "gmem" to "f", again to
avoid confusion once guest_memfd specific inodes come along.
No functional change intended.
Reviewed-by: Ackerley Tng <ackerleytng@google.com>
Tested-by: Ackerley Tng <ackerleytng@google.com>
Reviewed-by: Shivank Garg <shivankg@amd.com>
Tested-by: Shivank Garg <shivankg@amd.com>
Link: https://lore.kernel.org/r/20251016172853.52451-2-seanjc@google.com
Signed-off-by: Sean Christopherson <seanjc@google.com>
+53
-45
+53
-45
virt/kvm/guest_memfd.c
+53
-45
virt/kvm/guest_memfd.c
···
7
7
8
8
#include "kvm_mm.h"
9
9
10
-
struct kvm_gmem {
10
+
/*
11
+
* A guest_memfd instance can be associated multiple VMs, each with its own
12
+
* "view" of the underlying physical memory.
13
+
*
14
+
* The gmem's inode is effectively the raw underlying physical storage, and is
15
+
* used to track properties of the physical memory, while each gmem file is
16
+
* effectively a single VM's view of that storage, and is used to track assets
17
+
* specific to its associated VM, e.g. memslots=>gmem bindings.
18
+
*/
19
+
struct gmem_file {
11
20
struct kvm *kvm;
12
21
struct xarray bindings;
13
22
struct list_head entry;
···
124
115
return KVM_FILTER_PRIVATE;
125
116
}
126
117
127
-
static void __kvm_gmem_invalidate_begin(struct kvm_gmem *gmem, pgoff_t start,
118
+
static void __kvm_gmem_invalidate_begin(struct gmem_file *f, pgoff_t start,
128
119
pgoff_t end,
129
120
enum kvm_gfn_range_filter attr_filter)
130
121
{
131
122
bool flush = false, found_memslot = false;
132
123
struct kvm_memory_slot *slot;
133
-
struct kvm *kvm = gmem->kvm;
124
+
struct kvm *kvm = f->kvm;
134
125
unsigned long index;
135
126
136
-
xa_for_each_range(&gmem->bindings, index, slot, start, end - 1) {
127
+
xa_for_each_range(&f->bindings, index, slot, start, end - 1) {
137
128
pgoff_t pgoff = slot->gmem.pgoff;
138
129
139
130
struct kvm_gfn_range gfn_range = {
···
166
157
{
167
158
struct list_head *gmem_list = &inode->i_mapping->i_private_list;
168
159
enum kvm_gfn_range_filter attr_filter;
169
-
struct kvm_gmem *gmem;
160
+
struct gmem_file *f;
170
161
171
162
attr_filter = kvm_gmem_get_invalidate_filter(inode);
172
163
173
-
list_for_each_entry(gmem, gmem_list, entry)
174
-
__kvm_gmem_invalidate_begin(gmem, start, end, attr_filter);
164
+
list_for_each_entry(f, gmem_list, entry)
165
+
__kvm_gmem_invalidate_begin(f, start, end, attr_filter);
175
166
}
176
167
177
-
static void __kvm_gmem_invalidate_end(struct kvm_gmem *gmem, pgoff_t start,
168
+
static void __kvm_gmem_invalidate_end(struct gmem_file *f, pgoff_t start,
178
169
pgoff_t end)
179
170
{
180
-
struct kvm *kvm = gmem->kvm;
171
+
struct kvm *kvm = f->kvm;
181
172
182
-
if (xa_find(&gmem->bindings, &start, end - 1, XA_PRESENT)) {
173
+
if (xa_find(&f->bindings, &start, end - 1, XA_PRESENT)) {
183
174
KVM_MMU_LOCK(kvm);
184
175
kvm_mmu_invalidate_end(kvm);
185
176
KVM_MMU_UNLOCK(kvm);
···
190
181
pgoff_t end)
191
182
{
192
183
struct list_head *gmem_list = &inode->i_mapping->i_private_list;
193
-
struct kvm_gmem *gmem;
184
+
struct gmem_file *f;
194
185
195
-
list_for_each_entry(gmem, gmem_list, entry)
196
-
__kvm_gmem_invalidate_end(gmem, start, end);
186
+
list_for_each_entry(f, gmem_list, entry)
187
+
__kvm_gmem_invalidate_end(f, start, end);
197
188
}
198
189
199
190
static long kvm_gmem_punch_hole(struct inode *inode, loff_t offset, loff_t len)
···
291
282
292
283
static int kvm_gmem_release(struct inode *inode, struct file *file)
293
284
{
294
-
struct kvm_gmem *gmem = file->private_data;
285
+
struct gmem_file *f = file->private_data;
295
286
struct kvm_memory_slot *slot;
296
-
struct kvm *kvm = gmem->kvm;
287
+
struct kvm *kvm = f->kvm;
297
288
unsigned long index;
298
289
299
290
/*
···
313
304
314
305
filemap_invalidate_lock(inode->i_mapping);
315
306
316
-
xa_for_each(&gmem->bindings, index, slot)
307
+
xa_for_each(&f->bindings, index, slot)
317
308
WRITE_ONCE(slot->gmem.file, NULL);
318
309
319
310
/*
···
321
312
* Zap all SPTEs pointed at by this file. Do not free the backing
322
313
* memory, as its lifetime is associated with the inode, not the file.
323
314
*/
324
-
__kvm_gmem_invalidate_begin(gmem, 0, -1ul,
315
+
__kvm_gmem_invalidate_begin(f, 0, -1ul,
325
316
kvm_gmem_get_invalidate_filter(inode));
326
-
__kvm_gmem_invalidate_end(gmem, 0, -1ul);
317
+
__kvm_gmem_invalidate_end(f, 0, -1ul);
327
318
328
-
list_del(&gmem->entry);
319
+
list_del(&f->entry);
329
320
330
321
filemap_invalidate_unlock(inode->i_mapping);
331
322
332
323
mutex_unlock(&kvm->slots_lock);
333
324
334
-
xa_destroy(&gmem->bindings);
335
-
kfree(gmem);
325
+
xa_destroy(&f->bindings);
326
+
kfree(f);
336
327
337
328
kvm_put_kvm(kvm);
338
329
···
500
491
static int __kvm_gmem_create(struct kvm *kvm, loff_t size, u64 flags)
501
492
{
502
493
const char *anon_name = "[kvm-gmem]";
503
-
struct kvm_gmem *gmem;
494
+
struct gmem_file *f;
504
495
struct inode *inode;
505
496
struct file *file;
506
497
int fd, err;
···
509
500
if (fd < 0)
510
501
return fd;
511
502
512
-
gmem = kzalloc(sizeof(*gmem), GFP_KERNEL);
513
-
if (!gmem) {
503
+
f = kzalloc(sizeof(*f), GFP_KERNEL);
504
+
if (!f) {
514
505
err = -ENOMEM;
515
506
goto err_fd;
516
507
}
517
508
518
-
file = anon_inode_create_getfile(anon_name, &kvm_gmem_fops, gmem,
519
-
O_RDWR, NULL);
509
+
file = anon_inode_create_getfile(anon_name, &kvm_gmem_fops, f, O_RDWR, NULL);
520
510
if (IS_ERR(file)) {
521
511
err = PTR_ERR(file);
522
512
goto err_gmem;
···
537
529
WARN_ON_ONCE(!mapping_unevictable(inode->i_mapping));
538
530
539
531
kvm_get_kvm(kvm);
540
-
gmem->kvm = kvm;
541
-
xa_init(&gmem->bindings);
542
-
list_add(&gmem->entry, &inode->i_mapping->i_private_list);
532
+
f->kvm = kvm;
533
+
xa_init(&f->bindings);
534
+
list_add(&f->entry, &inode->i_mapping->i_private_list);
543
535
544
536
fd_install(fd, file);
545
537
return fd;
546
538
547
539
err_gmem:
548
-
kfree(gmem);
540
+
kfree(f);
549
541
err_fd:
550
542
put_unused_fd(fd);
551
543
return err;
···
570
562
{
571
563
loff_t size = slot->npages << PAGE_SHIFT;
572
564
unsigned long start, end;
573
-
struct kvm_gmem *gmem;
565
+
struct gmem_file *f;
574
566
struct inode *inode;
575
567
struct file *file;
576
568
int r = -EINVAL;
···
584
576
if (file->f_op != &kvm_gmem_fops)
585
577
goto err;
586
578
587
-
gmem = file->private_data;
588
-
if (gmem->kvm != kvm)
579
+
f = file->private_data;
580
+
if (f->kvm != kvm)
589
581
goto err;
590
582
591
583
inode = file_inode(file);
···
599
591
start = offset >> PAGE_SHIFT;
600
592
end = start + slot->npages;
601
593
602
-
if (!xa_empty(&gmem->bindings) &&
603
-
xa_find(&gmem->bindings, &start, end - 1, XA_PRESENT)) {
594
+
if (!xa_empty(&f->bindings) &&
595
+
xa_find(&f->bindings, &start, end - 1, XA_PRESENT)) {
604
596
filemap_invalidate_unlock(inode->i_mapping);
605
597
goto err;
606
598
}
···
615
607
if (kvm_gmem_supports_mmap(inode))
616
608
slot->flags |= KVM_MEMSLOT_GMEM_ONLY;
617
609
618
-
xa_store_range(&gmem->bindings, start, end - 1, slot, GFP_KERNEL);
610
+
xa_store_range(&f->bindings, start, end - 1, slot, GFP_KERNEL);
619
611
filemap_invalidate_unlock(inode->i_mapping);
620
612
621
613
/*
···
633
625
{
634
626
unsigned long start = slot->gmem.pgoff;
635
627
unsigned long end = start + slot->npages;
636
-
struct kvm_gmem *gmem;
628
+
struct gmem_file *f;
637
629
struct file *file;
638
630
639
631
/*
···
644
636
if (!file)
645
637
return;
646
638
647
-
gmem = file->private_data;
639
+
f = file->private_data;
648
640
649
641
filemap_invalidate_lock(file->f_mapping);
650
-
xa_store_range(&gmem->bindings, start, end - 1, NULL, GFP_KERNEL);
642
+
xa_store_range(&f->bindings, start, end - 1, NULL, GFP_KERNEL);
651
643
652
644
/*
653
645
* synchronize_srcu(&kvm->srcu) ensured that kvm_gmem_get_pfn()
···
665
657
pgoff_t index, kvm_pfn_t *pfn,
666
658
bool *is_prepared, int *max_order)
667
659
{
668
-
struct file *gmem_file = READ_ONCE(slot->gmem.file);
669
-
struct kvm_gmem *gmem = file->private_data;
660
+
struct file *slot_file = READ_ONCE(slot->gmem.file);
661
+
struct gmem_file *f = file->private_data;
670
662
struct folio *folio;
671
663
672
-
if (file != gmem_file) {
673
-
WARN_ON_ONCE(gmem_file);
664
+
if (file != slot_file) {
665
+
WARN_ON_ONCE(slot_file);
674
666
return ERR_PTR(-EFAULT);
675
667
}
676
668
677
-
if (xa_load(&gmem->bindings, index) != slot) {
678
-
WARN_ON_ONCE(xa_load(&gmem->bindings, index));
669
+
if (xa_load(&f->bindings, index) != slot) {
670
+
WARN_ON_ONCE(xa_load(&f->bindings, index));
679
671
return ERR_PTR(-EIO);
680
672
}
681
673