Skip to content

Commit 3f58981

Browse files
brettcreeleyAlex Williamson
brettcreeley
authored and
Alex Williamson
committed
vfio/pds: Move and rename region specific info
An upcoming change in this series will add support for multiple regions. To prepare for that, move region specific information into struct pds_vfio_region and rename the members for readability. This will reduce the size of the patch that actually implements multiple region support. Signed-off-by: Brett Creeley <brett.creeley@amd.com> Signed-off-by: Shannon Nelson <shannon.nelson@amd.com> Link: https://lore.kernel.org/r/20231117001207.2793-4-brett.creeley@amd.com Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
1 parent 3b8f7a2 commit 3f58981

2 files changed

Lines changed: 50 additions & 45 deletions

File tree

‎drivers/vfio/pci/pds/dirty.c‎

Lines changed: 42 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -85,18 +85,18 @@ static int pds_vfio_dirty_alloc_bitmaps(struct pds_vfio_dirty *dirty,
8585
return -ENOMEM;
8686
}
8787

88-
dirty->host_seq.bmp = host_seq_bmp;
89-
dirty->host_ack.bmp = host_ack_bmp;
88+
dirty->region.host_seq.bmp = host_seq_bmp;
89+
dirty->region.host_ack.bmp = host_ack_bmp;
9090

9191
return 0;
9292
}
9393

9494
static void pds_vfio_dirty_free_bitmaps(struct pds_vfio_dirty *dirty)
9595
{
96-
vfree(dirty->host_seq.bmp);
97-
vfree(dirty->host_ack.bmp);
98-
dirty->host_seq.bmp = NULL;
99-
dirty->host_ack.bmp = NULL;
96+
vfree(dirty->region.host_seq.bmp);
97+
vfree(dirty->region.host_ack.bmp);
98+
dirty->region.host_seq.bmp = NULL;
99+
dirty->region.host_ack.bmp = NULL;
100100
}
101101

102102
static void __pds_vfio_dirty_free_sgl(struct pds_vfio_pci_device *pds_vfio,
@@ -105,21 +105,21 @@ static void __pds_vfio_dirty_free_sgl(struct pds_vfio_pci_device *pds_vfio,
105105
struct pci_dev *pdev = pds_vfio->vfio_coredev.pdev;
106106
struct device *pdsc_dev = &pci_physfn(pdev)->dev;
107107

108-
dma_unmap_single(pdsc_dev, dirty->sgl_addr,
109-
dirty->num_sge * sizeof(struct pds_lm_sg_elem),
108+
dma_unmap_single(pdsc_dev, dirty->region.sgl_addr,
109+
dirty->region.num_sge * sizeof(struct pds_lm_sg_elem),
110110
DMA_BIDIRECTIONAL);
111-
kfree(dirty->sgl);
111+
kfree(dirty->region.sgl);
112112

113-
dirty->num_sge = 0;
114-
dirty->sgl = NULL;
115-
dirty->sgl_addr = 0;
113+
dirty->region.num_sge = 0;
114+
dirty->region.sgl = NULL;
115+
dirty->region.sgl_addr = 0;
116116
}
117117

118118
static void pds_vfio_dirty_free_sgl(struct pds_vfio_pci_device *pds_vfio)
119119
{
120120
struct pds_vfio_dirty *dirty = &pds_vfio->dirty;
121121

122-
if (dirty->sgl)
122+
if (dirty->region.sgl)
123123
__pds_vfio_dirty_free_sgl(pds_vfio, dirty);
124124
}
125125

@@ -147,9 +147,9 @@ static int pds_vfio_dirty_alloc_sgl(struct pds_vfio_pci_device *pds_vfio,
147147
return -EIO;
148148
}
149149

150-
dirty->sgl = sgl;
151-
dirty->num_sge = max_sge;
152-
dirty->sgl_addr = sgl_addr;
150+
dirty->region.sgl = sgl;
151+
dirty->region.num_sge = max_sge;
152+
dirty->region.sgl_addr = sgl_addr;
153153

154154
return 0;
155155
}
@@ -267,9 +267,9 @@ static int pds_vfio_dirty_enable(struct pds_vfio_pci_device *pds_vfio,
267267
goto out_free_bitmaps;
268268
}
269269

270-
dirty->region_start = region_start;
271-
dirty->region_size = region_size;
272-
dirty->region_page_size = region_page_size;
270+
dirty->region.start = region_start;
271+
dirty->region.size = region_size;
272+
dirty->region.page_size = region_page_size;
273273
pds_vfio_dirty_set_enabled(pds_vfio);
274274

275275
pds_vfio_print_guest_region_info(pds_vfio, max_regions);
@@ -304,11 +304,10 @@ static int pds_vfio_dirty_seq_ack(struct pds_vfio_pci_device *pds_vfio,
304304
u32 offset, u32 bmp_bytes, bool read_seq)
305305
{
306306
const char *bmp_type_str = read_seq ? "read_seq" : "write_ack";
307+
struct pds_vfio_region *region = &pds_vfio->dirty.region;
307308
u8 dma_dir = read_seq ? DMA_FROM_DEVICE : DMA_TO_DEVICE;
308309
struct pci_dev *pdev = pds_vfio->vfio_coredev.pdev;
309310
struct device *pdsc_dev = &pci_physfn(pdev)->dev;
310-
struct pds_vfio_dirty *dirty = &pds_vfio->dirty;
311-
struct pds_lm_sg_elem *sgl;
312311
unsigned long long npages;
313312
struct sg_table sg_table;
314313
struct scatterlist *sg;
@@ -355,25 +354,24 @@ static int pds_vfio_dirty_seq_ack(struct pds_vfio_pci_device *pds_vfio,
355354
if (err)
356355
goto out_free_sg_table;
357356

358-
sgl = pds_vfio->dirty.sgl;
359357
for_each_sgtable_dma_sg(&sg_table, sg, i) {
360-
struct pds_lm_sg_elem *sg_elem = &sgl[i];
358+
struct pds_lm_sg_elem *sg_elem = &region->sgl[i];
361359

362360
sg_elem->addr = cpu_to_le64(sg_dma_address(sg));
363361
sg_elem->len = cpu_to_le32(sg_dma_len(sg));
364362
}
365363

366364
num_sge = sg_table.nents;
367365
size = num_sge * sizeof(struct pds_lm_sg_elem);
368-
dma_sync_single_for_device(pdsc_dev, dirty->sgl_addr, size, dma_dir);
369-
err = pds_vfio_dirty_seq_ack_cmd(pds_vfio, dirty->sgl_addr, num_sge,
366+
dma_sync_single_for_device(pdsc_dev, region->sgl_addr, size, dma_dir);
367+
err = pds_vfio_dirty_seq_ack_cmd(pds_vfio, region->sgl_addr, num_sge,
370368
offset, bmp_bytes, read_seq);
371369
if (err)
372370
dev_err(&pdev->dev,
373371
"Dirty bitmap %s failed offset %u bmp_bytes %u num_sge %u DMA 0x%llx: %pe\n",
374372
bmp_type_str, offset, bmp_bytes,
375-
num_sge, dirty->sgl_addr, ERR_PTR(err));
376-
dma_sync_single_for_cpu(pdsc_dev, dirty->sgl_addr, size, dma_dir);
373+
num_sge, region->sgl_addr, ERR_PTR(err));
374+
dma_sync_single_for_cpu(pdsc_dev, region->sgl_addr, size, dma_dir);
377375

378376
dma_unmap_sgtable(pdsc_dev, &sg_table, dma_dir, 0);
379377
out_free_sg_table:
@@ -387,30 +385,34 @@ static int pds_vfio_dirty_seq_ack(struct pds_vfio_pci_device *pds_vfio,
387385
static int pds_vfio_dirty_write_ack(struct pds_vfio_pci_device *pds_vfio,
388386
u32 offset, u32 len)
389387
{
390-
return pds_vfio_dirty_seq_ack(pds_vfio, &pds_vfio->dirty.host_ack,
388+
struct pds_vfio_region *region = &pds_vfio->dirty.region;
389+
390+
return pds_vfio_dirty_seq_ack(pds_vfio, &region->host_ack,
391391
offset, len, WRITE_ACK);
392392
}
393393

394394
static int pds_vfio_dirty_read_seq(struct pds_vfio_pci_device *pds_vfio,
395395
u32 offset, u32 len)
396396
{
397-
return pds_vfio_dirty_seq_ack(pds_vfio, &pds_vfio->dirty.host_seq,
397+
struct pds_vfio_region *region = &pds_vfio->dirty.region;
398+
399+
return pds_vfio_dirty_seq_ack(pds_vfio, &region->host_seq,
398400
offset, len, READ_SEQ);
399401
}
400402

401403
static int pds_vfio_dirty_process_bitmaps(struct pds_vfio_pci_device *pds_vfio,
402404
struct iova_bitmap *dirty_bitmap,
403405
u32 bmp_offset, u32 len_bytes)
404406
{
405-
u64 page_size = pds_vfio->dirty.region_page_size;
406-
u64 region_start = pds_vfio->dirty.region_start;
407+
u64 page_size = pds_vfio->dirty.region.page_size;
408+
u64 region_start = pds_vfio->dirty.region.start;
407409
u32 bmp_offset_bit;
408410
__le64 *seq, *ack;
409411
int dword_count;
410412

411413
dword_count = len_bytes / sizeof(u64);
412-
seq = (__le64 *)((u64)pds_vfio->dirty.host_seq.bmp + bmp_offset);
413-
ack = (__le64 *)((u64)pds_vfio->dirty.host_ack.bmp + bmp_offset);
414+
seq = (__le64 *)((u64)pds_vfio->dirty.region.host_seq.bmp + bmp_offset);
415+
ack = (__le64 *)((u64)pds_vfio->dirty.region.host_ack.bmp + bmp_offset);
414416
bmp_offset_bit = bmp_offset * 8;
415417

416418
for (int i = 0; i < dword_count; i++) {
@@ -451,34 +453,33 @@ static int pds_vfio_dirty_sync(struct pds_vfio_pci_device *pds_vfio,
451453
return -EINVAL;
452454
}
453455

454-
pages = DIV_ROUND_UP(length, pds_vfio->dirty.region_page_size);
456+
pages = DIV_ROUND_UP(length, pds_vfio->dirty.region.page_size);
455457
bitmap_size =
456458
round_up(pages, sizeof(u64) * BITS_PER_BYTE) / BITS_PER_BYTE;
457459

458460
dev_dbg(dev,
459461
"vf%u: iova 0x%lx length %lu page_size %llu pages %llu bitmap_size %llu\n",
460-
pds_vfio->vf_id, iova, length, pds_vfio->dirty.region_page_size,
462+
pds_vfio->vf_id, iova, length, pds_vfio->dirty.region.page_size,
461463
pages, bitmap_size);
462464

463-
if (!length || ((iova - dirty->region_start + length) > dirty->region_size)) {
465+
if (!length || ((iova - dirty->region.start + length) > dirty->region.size)) {
464466
dev_err(dev, "Invalid iova 0x%lx and/or length 0x%lx to sync\n",
465467
iova, length);
466468
return -EINVAL;
467469
}
468470

469471
/* bitmap is modified in 64 bit chunks */
470-
bmp_bytes = ALIGN(DIV_ROUND_UP(length / dirty->region_page_size,
471-
sizeof(u64)),
472-
sizeof(u64));
472+
bmp_bytes = ALIGN(DIV_ROUND_UP(length / dirty->region.page_size,
473+
sizeof(u64)), sizeof(u64));
473474
if (bmp_bytes != bitmap_size) {
474475
dev_err(dev,
475476
"Calculated bitmap bytes %llu not equal to bitmap size %llu\n",
476477
bmp_bytes, bitmap_size);
477478
return -EINVAL;
478479
}
479480

480-
bmp_offset = DIV_ROUND_UP((iova - dirty->region_start) /
481-
dirty->region_page_size, sizeof(u64));
481+
bmp_offset = DIV_ROUND_UP((iova - dirty->region.start) /
482+
dirty->region.page_size, sizeof(u64));
482483

483484
dev_dbg(dev,
484485
"Syncing dirty bitmap, iova 0x%lx length 0x%lx, bmp_offset %llu bmp_bytes %llu\n",

‎drivers/vfio/pci/pds/dirty.h‎

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,19 @@ struct pds_vfio_bmp_info {
99
u32 bmp_bytes;
1010
};
1111

12-
struct pds_vfio_dirty {
12+
struct pds_vfio_region {
1313
struct pds_vfio_bmp_info host_seq;
1414
struct pds_vfio_bmp_info host_ack;
15-
u64 region_size;
16-
u64 region_start;
17-
u64 region_page_size;
15+
u64 size;
16+
u64 start;
17+
u64 page_size;
1818
struct pds_lm_sg_elem *sgl;
1919
dma_addr_t sgl_addr;
2020
u16 num_sge;
21+
};
22+
23+
struct pds_vfio_dirty {
24+
struct pds_vfio_region region;
2125
bool is_enabled;
2226
};
2327

0 commit comments

Comments
 (0)