Hi, Matt Thanks for reviewing.
On Wed, 2025-12-17 at 17:20 -0800, Matthew Brost wrote: > On Thu, Dec 11, 2025 at 05:59:08PM +0100, Thomas Hellström wrote: > > Support destination migration over interconnect when migrating from > > device-private pages with the same dev_pagemap owner. > > > > Since we now also collect device-private pages to migrate, > > also abort migration if the range to migrate is already > > fully populated with pages from the desired pagemap. > > > > Finally return -EBUSY from drm_pagemap_populate_mm() > > if the migration can't be completed without first migrating all > > pages in the range to system. It is expected that the caller > > will perform that before retrying the call to > > drm_pagemap_populate_mm(). > > > > Assume for now that the drm_pagemap implementation is *not* > > capable of migrating data within the pagemap itself. This > > restriction will be configurable in upcoming patches. > > > > v3: > > - Fix a bug where the p2p dma-address was never used. > > - Postpone enabling destination interconnect migration, > > since xe devices require source interconnect migration to > > ensure the source L2 cache is flushed at migration time. > > - Update the drm_pagemap_migrate_to_devmem() interface to > > pass migration details. > > v4: > > - Define XE_INTERCONNECT_P2P unconditionally (CI) > > - Include a missing header (CI) > > > > Signed-off-by: Thomas Hellström <[email protected]> > > --- > > drivers/gpu/drm/drm_pagemap.c | 188 +++++++++++++++++++++++----- > > ---- > > drivers/gpu/drm/xe/xe_migrate.c | 4 +- > > drivers/gpu/drm/xe/xe_svm.c | 26 +++-- > > drivers/gpu/drm/xe/xe_svm.h | 1 + > > include/drm/drm_pagemap.h | 19 +++- > > 5 files changed, 179 insertions(+), 59 deletions(-) > > > > diff --git a/drivers/gpu/drm/drm_pagemap.c > > b/drivers/gpu/drm/drm_pagemap.c > > index 77f8ea5ed802..56bedb622264 100644 > > --- a/drivers/gpu/drm/drm_pagemap.c > > +++ b/drivers/gpu/drm/drm_pagemap.c > > @@ -206,10 +206,12 @@ static void > > drm_pagemap_get_devmem_page(struct page *page, > > /** > > * drm_pagemap_migrate_map_pages() - Map migration pages for GPU > > SVM migration > > * @dev: The device for which the pages are being mapped > > + * @local_dpagemap: The drm_pagemap pointer of the local > > drm_pagemap. > > * @pagemap_addr: Array to store DMA information corresponding to > > mapped pages > > * @migrate_pfn: Array of migrate page frame numbers to map > > * @npages: Number of pages to map > > * @dir: Direction of data transfer (e.g., DMA_BIDIRECTIONAL) > > + * @mdetails: Details governing the migration behaviour. > > * > > * This function maps pages of memory for migration usage in GPU > > SVM. It > > * iterates over each page frame number provided in @migrate_pfn, > > maps the > > @@ -219,12 +221,15 @@ static void > > drm_pagemap_get_devmem_page(struct page *page, > > * Returns: 0 on success, -EFAULT if an error occurs during > > mapping. > > */ > > static int drm_pagemap_migrate_map_pages(struct device *dev, > > + struct drm_pagemap > > *local_dpagemap, > > struct drm_pagemap_addr > > *pagemap_addr, > > unsigned long > > *migrate_pfn, > > unsigned long npages, > > - enum dma_data_direction > > dir) > > + enum dma_data_direction > > dir, > > + const struct > > drm_pagemap_migrate_details *mdetails) > > { > > unsigned long i; > > + unsigned long num_peer_pages = 0; > > > > for (i = 0; i < npages;) { > > struct page *page = > > migrate_pfn_to_page(migrate_pfn[i]); > > @@ -235,31 +240,50 @@ static int > > drm_pagemap_migrate_map_pages(struct device *dev, > > if (!page) > > goto next; > > > > - if (WARN_ON_ONCE(is_zone_device_page(page))) > > - return -EFAULT; > > - > > folio = page_folio(page); > > order = folio_order(folio); > > > > - dma_addr = dma_map_page(dev, page, 0, > > page_size(page), dir); > > - if (dma_mapping_error(dev, dma_addr)) > > - return -EFAULT; > > + if (is_device_private_page(page)) { > > + struct drm_pagemap_zdd *zdd = page- > > >zone_device_data; > > + struct drm_pagemap *dpagemap = zdd- > > >dpagemap; > > + struct drm_pagemap_addr addr; > > + > > + if (dpagemap == local_dpagemap && > > !mdetails->can_migrate_same_pagemap) > > + goto next; > > > > - pagemap_addr[i] = > > - drm_pagemap_addr_encode(dma_addr, > > - > > DRM_INTERCONNECT_SYSTEM, > > - order, dir); > > + num_peer_pages += NR_PAGES(order); > > + addr = dpagemap->ops->device_map(dpagemap, > > dev, page, order, dir); > > + if (dma_mapping_error(dev, addr.addr)) > > + return -EFAULT; > > + > > + pagemap_addr[i] = addr; > > + } else { > > + dma_addr = dma_map_page(dev, page, 0, > > page_size(page), dir); > > + if (dma_mapping_error(dev, dma_addr)) > > + return -EFAULT; > > + > > + pagemap_addr[i] = > > + drm_pagemap_addr_encode(dma_addr, > > + DRM_INTERC > > ONNECT_SYSTEM, > > + order, > > dir); > > + } > > > > next: > > i += NR_PAGES(order); > > } > > > > + if (num_peer_pages) > > + drm_dbg(local_dpagemap->drm, "Migrating %lu peer > > pages over interconnect.\n", > > + num_peer_pages); > > + > > return 0; > > } > > > > /** > > * drm_pagemap_migrate_unmap_pages() - Unmap pages previously > > mapped for GPU SVM migration > > * @dev: The device for which the pages were mapped > > + * @migrate_pfn: Array of migrate pfns set up for the mapped > > pages. Used to > > + * determine the drm_pagemap of a peer device private page. > > * @pagemap_addr: Array of DMA information corresponding to mapped > > pages > > * @npages: Number of pages to unmap > > * @dir: Direction of data transfer (e.g., DMA_BIDIRECTIONAL) > > @@ -270,16 +294,27 @@ static int > > drm_pagemap_migrate_map_pages(struct device *dev, > > */ > > static void drm_pagemap_migrate_unmap_pages(struct device *dev, > > struct > > drm_pagemap_addr *pagemap_addr, > > + unsigned long > > *migrate_pfn, > > unsigned long npages, > > enum > > dma_data_direction dir) > > { > > unsigned long i; > > > > for (i = 0; i < npages;) { > > - if (!pagemap_addr[i].addr || > > dma_mapping_error(dev, pagemap_addr[i].addr)) > > + struct page *page = > > migrate_pfn_to_page(migrate_pfn[i]); > > + > > + if (!page || !pagemap_addr[i].addr || > > dma_mapping_error(dev, pagemap_addr[i].addr)) > > goto next; > > > > - dma_unmap_page(dev, pagemap_addr[i].addr, > > PAGE_SIZE << pagemap_addr[i].order, dir); > > + if (is_zone_device_page(page)) { > > + struct drm_pagemap_zdd *zdd = page- > > >zone_device_data; > > + struct drm_pagemap *dpagemap = zdd- > > >dpagemap; > > + > > + dpagemap->ops->device_unmap(dpagemap, dev, > > pagemap_addr[i]); > > + } else { > > + dma_unmap_page(dev, pagemap_addr[i].addr, > > + PAGE_SIZE << > > pagemap_addr[i].order, dir); > > + } > > > > next: > > i += NR_PAGES(pagemap_addr[i].order); > > @@ -301,8 +336,7 @@ npages_in_range(unsigned long start, unsigned > > long end) > > * @mm: Pointer to the struct mm_struct. > > * @start: Start of the virtual address range to migrate. > > * @end: End of the virtual address range to migrate. > > - * @timeslice_ms: The time requested for the migrated pagemap > > pages to > > - * be present in @mm before being allowed to be migrated back. > > + * @mdetails: Details to govern the migration. > > * > > * This function migrates the specified virtual address range to > > device memory. > > * It performs the necessary setup and invokes the driver-specific > > operations for > > @@ -320,7 +354,7 @@ npages_in_range(unsigned long start, unsigned > > long end) > > Update kernel doc to indicate devmem_allocation is consumed on > failure? Sure. > > > int drm_pagemap_migrate_to_devmem(struct drm_pagemap_devmem > > *devmem_allocation, > > struct mm_struct *mm, > > unsigned long start, unsigned > > long end, > > - unsigned long timeslice_ms) > > + const struct > > drm_pagemap_migrate_details *mdetails) > > { > > const struct drm_pagemap_devmem_ops *ops = > > devmem_allocation->ops; > > struct drm_pagemap *dpagemap = devmem_allocation- > > >dpagemap; > > @@ -329,9 +363,11 @@ int drm_pagemap_migrate_to_devmem(struct > > drm_pagemap_devmem *devmem_allocation, > > .start = start, > > .end = end, > > .pgmap_owner = pagemap->owner, > > - .flags = MIGRATE_VMA_SELECT_SYSTEM, > > + .flags = MIGRATE_VMA_SELECT_SYSTEM | > > MIGRATE_VMA_SELECT_DEVICE_COHERENT | > > + (mdetails->source_peer_migrates ? 0 : > > MIGRATE_VMA_SELECT_DEVICE_PRIVATE), > > }; > > unsigned long i, npages = npages_in_range(start, end); > > + unsigned long own_pages = 0, migrated_pages = 0; > > struct vm_area_struct *vas; > > struct drm_pagemap_zdd *zdd = NULL; > > struct page **pages; > > @@ -373,8 +409,10 @@ int drm_pagemap_migrate_to_devmem(struct > > drm_pagemap_devmem *devmem_allocation, > > zdd = drm_pagemap_zdd_alloc(dpagemap); > > if (!zdd) { > > err = -ENOMEM; > > - goto err_free; > > + kvfree(buf); > > + goto err_out; > > } > > + zdd->devmem_allocation = devmem_allocation; /* Owns > > ref */ > > > > migrate.vma = vas; > > migrate.src = buf; > > @@ -385,55 +423,111 @@ int drm_pagemap_migrate_to_devmem(struct > > drm_pagemap_devmem *devmem_allocation, > > goto err_free; > > > > if (!migrate.cpages) { > > - err = -EFAULT; > > + /* No pages to migrate. Raced or unknown device > > pages. */ > > + err = -EBUSY; > > goto err_free; > > } > > > > if (migrate.cpages != npages) { > > + /* > > + * Some pages to migrate. But we want to migrate > > all or > > + * nothing. Raced or unknown device pages. > > + */ > > I honestly think this is going to be an issue. Let's say two devices > fault at the same time and both try to migrate simultaneously—neither > side is likely to make forward progress, resulting in the migration > failing even with a retry loop at the caller. > > How about a Xe module-wide migration rwsem? The first call to > drm_pagemap_populate_mm would take it in read mode, and subsequent > attempts would take it in write mode. We can't control CPU-side races > here, but we do have some level of GPU-side control via a lock like > the > one I suggested. > > The other alternative is to restructure our GPU SVM range tree into a > process-wide structure (rather than per-device VM), which locks the > range when servicing a fault and supports multiple sets of pages > attached to the range. This is pretty large work though, so I'd lean > towards some Xe driver side locking first. I agree with your problem statement here, but I don't think it's introduced with this patch nor that it is made worse? Since the functionality around mpages != cpages isn't changed, other than that we try to migrate to system once and retry. In fact with the p2p migration I think the situation is improved upon because since pages on peer devices now will turn up in cpages. One thing missing, though, is that we don't honor the requested migration delay with p2p migration. Will fix that to next version. Since this is not a Xe-only problem, I think the *proper* fix here is in the core migration code and Xe code that needs to be made more robust to guarantee forward progress: 1) Core migration code should use a sleeping page-lock for the first page. 2) On repeated failures gpusvm should reduce the range size to single- page, which is a good remedy also for OOM errors. 3) Core migration code should optionally call migrate_to_ram for unknown foreign device-private pages, rather than to skip them. I think this would guarantee forward progress in the single-page case. Combined with the delayed migration we have for atomics this would hopefully make the no-interconnect / atomic case robust enough. Now if we combine this with get_pages() on *last* attempt accepting *any* mix of system / peer / local pages in other cases, that would also improve on robustness. If we'd temporarily want a hack to address this for our multi-device xe use-cases I think using a driver-wide rwsem or similar like you suggest is the best option. It might be that the validation code is general enough. But I don't think it belongs in this patch but rather as a follow up. > > > err = -EBUSY; > > - goto err_finalize; > > + goto err_aborted_migration; > > + } > > + > > + /* Count device-private pages to migrate */ > > + for (i = 0; i < npages; ++i) { > > + struct page *src_page = > > migrate_pfn_to_page(migrate.src[i]); > > + > > + if (src_page && is_zone_device_page(src_page)) { > > + if (page_pgmap(src_page) == pagemap) > > + own_pages++; > > + } > > In an effort to make the 2M transition easier, can this loop > increment i > and own-pages based on the folio order? Sure. I'll do that in all instances that do not require 4K-page granularity. > > > + } > > + > > + drm_dbg(dpagemap->drm, "Total pages %lu; Own pages: > > %lu.\n", > > + npages, own_pages); > > + if (own_pages == npages) { > > + err = 0; > > + drm_dbg(dpagemap->drm, "Migration wasn't > > necessary.\n"); > > + goto err_aborted_migration; > > + } else if (own_pages && mdetails- > > >can_migrate_same_pagemap) { > > + err = -EBUSY; > > + drm_dbg(dpagemap->drm, "Migration aborted due to > > fragmentation.\n"); > > + goto err_aborted_migration; > > } > > > > err = ops->populate_devmem_pfn(devmem_allocation, npages, > > migrate.dst); > > if (err) > > goto err_finalize; > > > > - err = drm_pagemap_migrate_map_pages(devmem_allocation- > > >dev, pagemap_addr, > > - migrate.src, npages, > > DMA_TO_DEVICE); > > + err = drm_pagemap_migrate_map_pages(devmem_allocation- > > >dev, > > + devmem_allocation- > > >dpagemap, pagemap_addr, > > + migrate.src, npages, > > DMA_TO_DEVICE, > > + mdetails); > > + > > + if (err) { > > + drm_pagemap_migrate_unmap_pages(devmem_allocation- > > >dev, pagemap_addr, > > + migrate.src, > > npages, DMA_TO_DEVICE); > > > > - if (err) > > goto err_finalize; > > + } > > > > + own_pages = 0; > > for (i = 0; i < npages; ++i) { > > struct page *page = pfn_to_page(migrate.dst[i]); > > - > > + struct page *src_page = > > migrate_pfn_to_page(migrate.src[i]); > > + > > + if (unlikely(src_page && > > is_zone_device_page(src_page) && > > + page_pgmap(src_page) == pagemap && > > + !mdetails->can_migrate_same_pagemap)) > > { > > + migrate.dst[i] = 0; > > + pages[i] = NULL; > > + own_pages++; > > + continue; > > + } > > Same as above, I think logic should be based on folio order? > > > pages[i] = page; > > migrate.dst[i] = migrate_pfn(migrate.dst[i]); > > drm_pagemap_get_devmem_page(page, zdd); > > } > > + drm_WARN_ON(dpagemap->drm, !!own_pages); > > > > err = ops->copy_to_devmem(pages, pagemap_addr, npages, > > devmem_allocation- > > >pre_migrate_fence); > > + drm_pagemap_migrate_unmap_pages(devmem_allocation->dev, > > pagemap_addr, > > + migrate.src, npages, > > DMA_TO_DEVICE); > > if (err) > > goto err_finalize; > > > > /* Upon success bind devmem allocation to range and zdd */ > > devmem_allocation->timeslice_expiration = get_jiffies_64() > > + > > - msecs_to_jiffies(timeslice_ms); > > - zdd->devmem_allocation = devmem_allocation; /* Owns > > ref */ > > + msecs_to_jiffies(mdetails->timeslice_ms); > > > > err_finalize: > > if (err) > > drm_pagemap_migration_unlock_put_pages(npages, > > migrate.dst); > > +err_aborted_migration: > > migrate_vma_pages(&migrate); > > + > > + for (i = 0; i < npages; ++i) > > + if (migrate.src[i] & MIGRATE_PFN_MIGRATE) > > + migrated_pages++; > > Again based on folio order? > > > + > > + if (!err && migrated_pages < npages - own_pages) { > > + drm_dbg(dpagemap->drm, "Raced while finalizing > > migration.\n"); > > + err = -EBUSY; > > + } > > + > > migrate_vma_finalize(&migrate); > > - drm_pagemap_migrate_unmap_pages(devmem_allocation->dev, > > pagemap_addr, npages, > > - DMA_TO_DEVICE); > > err_free: > > - if (zdd) > > - drm_pagemap_zdd_put(zdd); > > + drm_pagemap_zdd_put(zdd); > > kvfree(buf); > > + return err; > > + > > err_out: > > + devmem_allocation->ops->devmem_release(devmem_allocation); > > return err; > > } > > EXPORT_SYMBOL_GPL(drm_pagemap_migrate_to_devmem); > > @@ -706,6 +800,7 @@ EXPORT_SYMBOL(drm_pagemap_put); > > int drm_pagemap_evict_to_ram(struct drm_pagemap_devmem > > *devmem_allocation) > > { > > const struct drm_pagemap_devmem_ops *ops = > > devmem_allocation->ops; > > + struct drm_pagemap_migrate_details mdetails = {}; > > unsigned long npages, mpages = 0; > > struct page **pages; > > unsigned long *src, *dst; > > @@ -744,8 +839,10 @@ int drm_pagemap_evict_to_ram(struct > > drm_pagemap_devmem *devmem_allocation) > > if (err || !mpages) > > goto err_finalize; > > > > - err = drm_pagemap_migrate_map_pages(devmem_allocation- > > >dev, pagemap_addr, > > - dst, npages, > > DMA_FROM_DEVICE); > > + err = drm_pagemap_migrate_map_pages(devmem_allocation- > > >dev, > > + devmem_allocation- > > >dpagemap, pagemap_addr, > > + dst, npages, > > DMA_FROM_DEVICE, > > + &mdetails); > > if (err) > > goto err_finalize; > > > > @@ -761,8 +858,9 @@ int drm_pagemap_evict_to_ram(struct > > drm_pagemap_devmem *devmem_allocation) > > drm_pagemap_migration_unlock_put_pages(npages, > > dst); > > migrate_device_pages(src, dst, npages); > > migrate_device_finalize(src, dst, npages); > > - drm_pagemap_migrate_unmap_pages(devmem_allocation->dev, > > pagemap_addr, npages, > > + drm_pagemap_migrate_unmap_pages(devmem_allocation->dev, > > pagemap_addr, dst, npages, > > DMA_FROM_DEVICE); > > + > > err_free: > > kvfree(buf); > > err_out: > > @@ -805,6 +903,7 @@ static int __drm_pagemap_migrate_to_ram(struct > > vm_area_struct *vas, > > MIGRATE_VMA_SELECT_DEVICE_COHERENT, > > .fault_page = page, > > }; > > + struct drm_pagemap_migrate_details mdetails = {}; > > struct drm_pagemap_zdd *zdd; > > const struct drm_pagemap_devmem_ops *ops; > > struct device *dev = NULL; > > @@ -853,19 +952,6 @@ static int __drm_pagemap_migrate_to_ram(struct > > vm_area_struct *vas, > > if (!migrate.cpages) > > goto err_free; > > > > - if (!page) { > > - for (i = 0; i < npages; ++i) { > > - if (!(migrate.src[i] & > > MIGRATE_PFN_MIGRATE)) > > - continue; > > - > > - page = > > migrate_pfn_to_page(migrate.src[i]); > > - break; > > - } > > - > > - if (!page) > > - goto err_finalize; > > - } > > - zdd = page->zone_device_data; > > This isn't actually related to this patch but agree this is some > leftover dead code. You break this out into its own patch. Will do. > > > ops = zdd->devmem_allocation->ops; > > dev = zdd->devmem_allocation->dev; > > > > @@ -875,8 +961,8 @@ static int __drm_pagemap_migrate_to_ram(struct > > vm_area_struct *vas, > > if (err) > > goto err_finalize; > > > > - err = drm_pagemap_migrate_map_pages(dev, pagemap_addr, > > migrate.dst, npages, > > - DMA_FROM_DEVICE); > > + err = drm_pagemap_migrate_map_pages(dev, zdd->dpagemap, > > pagemap_addr, migrate.dst, npages, > > + DMA_FROM_DEVICE, > > &mdetails); > > if (err) > > goto err_finalize; > > > > @@ -893,8 +979,8 @@ static int __drm_pagemap_migrate_to_ram(struct > > vm_area_struct *vas, > > migrate_vma_pages(&migrate); > > migrate_vma_finalize(&migrate); > > if (dev) > > - drm_pagemap_migrate_unmap_pages(dev, pagemap_addr, > > npages, > > - DMA_FROM_DEVICE); > > + drm_pagemap_migrate_unmap_pages(dev, pagemap_addr, > > migrate.dst, > > + npages, > > DMA_FROM_DEVICE); > > err_free: > > kvfree(buf); > > err_out: > > @@ -930,9 +1016,11 @@ static vm_fault_t > > drm_pagemap_migrate_to_ram(struct vm_fault *vmf) > > struct drm_pagemap_zdd *zdd = vmf->page->zone_device_data; > > int err; > > > > + drm_pagemap_zdd_get(zdd); > > Can you explain the extra ref here? The page itself should have a ref > owned by the drm_pagemap_migrate_to_ram caller, right? > > > err = __drm_pagemap_migrate_to_ram(vmf->vma, > > vmf->page, vmf- > > >address, > > zdd->devmem_allocation- > > >size); > > + drm_pagemap_zdd_put(zdd); Right. Good catch. This was added in an early version and I should've removed it. > > > > return err ? VM_FAULT_SIGBUS : 0; > > } > > diff --git a/drivers/gpu/drm/xe/xe_migrate.c > > b/drivers/gpu/drm/xe/xe_migrate.c > > index f3b66b55acfb..4edb41548000 100644 > > --- a/drivers/gpu/drm/xe/xe_migrate.c > > +++ b/drivers/gpu/drm/xe/xe_migrate.c > > @@ -35,6 +35,7 @@ > > #include "xe_sa.h" > > #include "xe_sched_job.h" > > #include "xe_sriov_vf_ccs.h" > > +#include "xe_svm.h" > > #include "xe_sync.h" > > #include "xe_trace_bo.h" > > #include "xe_validation.h" > > @@ -2048,7 +2049,8 @@ static void build_pt_update_batch_sram(struct > > xe_migrate *m, > > u64 pte; > > > > xe_tile_assert(m->tile, sram_addr[i].proto > > == > > - DRM_INTERCONNECT_SYSTEM); > > + DRM_INTERCONNECT_SYSTEM || > > + sram_addr[i].proto == > > XE_INTERCONNECT_P2P); > > xe_tile_assert(m->tile, addr); > > xe_tile_assert(m->tile, > > PAGE_ALIGNED(addr)); > > > > diff --git a/drivers/gpu/drm/xe/xe_svm.c > > b/drivers/gpu/drm/xe/xe_svm.c > > index 22281d69e26a..03cc4a24ce27 100644 > > --- a/drivers/gpu/drm/xe/xe_svm.c > > +++ b/drivers/gpu/drm/xe/xe_svm.c > > @@ -1058,6 +1058,10 @@ static int xe_drm_pagemap_populate_mm(struct > > drm_pagemap *dpagemap, > > unsigned long timeslice_ms) > > { > > struct xe_pagemap *xpagemap = container_of(dpagemap, > > typeof(*xpagemap), dpagemap); > > + struct drm_pagemap_migrate_details mdetails = { > > + .timeslice_ms = timeslice_ms, > > + .source_peer_migrates = 1, > > + }; > > struct xe_vram_region *vr = xe_pagemap_to_vr(xpagemap); > > struct dma_fence *pre_migrate_fence = NULL; > > struct xe_device *xe = vr->xe; > > @@ -1109,10 +1113,9 @@ static int xe_drm_pagemap_populate_mm(struct > > drm_pagemap *dpagemap, > > > > /* Ensure the device has a pm ref while there are > > device pages active. */ > > xe_pm_runtime_get_noresume(xe); > > + /* Consumes the devmem allocation ref. */ > > err = drm_pagemap_migrate_to_devmem(&bo- > > >devmem_allocation, mm, > > - start, end, > > timeslice_ms); > > - if (err) > > - xe_svm_devmem_release(&bo- > > >devmem_allocation); > > + start, end, > > &mdetails); > > xe_bo_unlock(bo); > > xe_bo_put(bo); > > } > > @@ -1628,6 +1631,7 @@ int xe_svm_alloc_vram(struct xe_svm_range > > *range, const struct drm_gpusvm_ctx *c > > struct xe_vm *vm = range_to_vm(&range->base); > > enum drm_gpusvm_scan_result migration_state; > > struct xe_device *xe = vm->xe; > > + int err, retries = 1; > > > > xe_assert(range_to_vm(&range->base)->xe, range- > > >base.pages.flags.migrate_devmem); > > range_debug(range, "ALLOCATE VRAM"); > > @@ -1646,10 +1650,18 @@ int xe_svm_alloc_vram(struct xe_svm_range > > *range, const struct drm_gpusvm_ctx *c > > drm_dbg(&xe->drm, "Request migration to device > > memory on \"%s\".\n", > > dpagemap->drm->unique); > > > > - return drm_pagemap_populate_mm(dpagemap, > > xe_svm_range_start(range), > > - xe_svm_range_end(range), > > - range->base.gpusvm->mm, > > - ctx->timeslice_ms); > > + do { > > + err = drm_pagemap_populate_mm(dpagemap, > > xe_svm_range_start(range), > > + > > xe_svm_range_end(range), > > + range->base.gpusvm- > > >mm, > > + ctx->timeslice_ms); > > + > > + if (err == -EBUSY && retries) > > + drm_gpusvm_range_evict(range->base.gpusvm, > > &range->base); > > With the above commit, here is where I think we need a module > migration > rwsem. Agreed. But I'll add that as a follow up patch. > > > + > > + } while (err == -EBUSY && retries--); > > + > > + return err; > > } > > > > static struct drm_pagemap_addr > > diff --git a/drivers/gpu/drm/xe/xe_svm.h > > b/drivers/gpu/drm/xe/xe_svm.h > > index 50e80bc892b6..b7b8eeacf196 100644 > > --- a/drivers/gpu/drm/xe/xe_svm.h > > +++ b/drivers/gpu/drm/xe/xe_svm.h > > @@ -205,6 +205,7 @@ struct xe_tile; > > struct xe_vram_region; > > > > #define XE_INTERCONNECT_VRAM 1 > > +#define XE_INTERCONNECT_P2P (XE_INTERCONNECT_VRAM + 1) > > > > struct xe_svm_range { > > struct { > > diff --git a/include/drm/drm_pagemap.h b/include/drm/drm_pagemap.h > > index f73afece42ba..46e9c58f09e0 100644 > > --- a/include/drm/drm_pagemap.h > > +++ b/include/drm/drm_pagemap.h > > @@ -317,10 +317,27 @@ struct drm_pagemap_devmem { > > struct dma_fence *pre_migrate_fence; > > }; > > > > +/** > > + * struct drm_pagemap_migrate_details - Details to govern > > migration. > > + * @timeslice_ms: The time requested for the migrated pagemap > > pages to > > + * be present in @mm before being allowed to be migrated back. > > + * @can_migrate_same_pagemap: Whether the copy function as > > indicated by > > + * the @source_peer_migrates flag, can migrate device pages within > > a > > + * single drm_pagemap. > > This is essentially saying 'my copy function is smart enough to skip > pages in the correct placement' or is saying 'my copy function can > copy > pages from one position on my device to another'? It's the latter. The drm_pagemap functionality is currently that if only some pages are in the correct placement with a different devmem_allocation, they are copied and migrated to the new devmem_allocation. This is to avoid fragmentation and partially used devmem_allocations. /Thomas > > I want to make sure I'm getting this right. > > Matt > > > + * @source_peer_migrates: Whether on p2p migration, The source > > drm_pagemap > > + * should use the copy_to_ram() callback rather than the > > destination > > + * drm_pagemap should use the copy_to_devmem() callback. > > + */ > > +struct drm_pagemap_migrate_details { > > + unsigned long timeslice_ms; > > + u32 can_migrate_same_pagemap : 1; > > + u32 source_peer_migrates : 1; > > +}; > > + > > int drm_pagemap_migrate_to_devmem(struct drm_pagemap_devmem > > *devmem_allocation, > > struct mm_struct *mm, > > unsigned long start, unsigned > > long end, > > - unsigned long timeslice_ms); > > + const struct > > drm_pagemap_migrate_details *mdetails); > > > > int drm_pagemap_evict_to_ram(struct drm_pagemap_devmem > > *devmem_allocation); > > > > -- > > 2.51.1 > >
