Commit 541c341d authored by Philip Yang's avatar Philip Yang Committed by Alex Deucher
Browse files

Revert "drm/amdkfd: Use partial migrations in GPU page faults" 



This reverts commit dc427a47.

The change prevents migrating the entire range to VRAM because retry
fault restore_pages map the remaining system memory range to GPUs. It
will work correctly to submit together with partial mapping to GPU
patch later.

Signed-off-by: default avatarPhilip Yang <Philip.Yang@amd.com>
Reviewed-by: default avatarFelix Kuehling <Felix.Kuehling@amd.com>
Signed-off-by: default avatarAlex Deucher <alexander.deucher@amd.com>
parent afaec204

drivers/gpu/drm/amd/amdkfd/kfd_migrate.c

+64 −86
Original line number Diff line number Diff line
@@ -442,10 +442,10 @@ svm_migrate_vma_to_vram(struct kfd_node *node, struct svm_range *prange, 
		goto out_free;

	}

	if (cpages != npages)

		pr_debug("partial migration, 0x%lx/0x%llx pages collected\n",

		pr_debug("partial migration, 0x%lx/0x%llx pages migrated\n",

			 cpages, npages);

	else

		pr_debug("0x%lx pages collected\n", cpages);

		pr_debug("0x%lx pages migrated\n", cpages);



	r = svm_migrate_copy_to_vram(node, prange, &migrate, &mfence, scratch, ttm_res_offset);

	migrate_vma_pages(&migrate);
@@ -479,8 +479,6 @@ svm_migrate_vma_to_vram(struct kfd_node *node, struct svm_range *prange, 
 * svm_migrate_ram_to_vram - migrate svm range from system to device

 * @prange: range structure

 * @best_loc: the device to migrate to

 * @start_mgr: start page to migrate

 * @last_mgr: last page to migrate

 * @mm: the process mm structure

 * @trigger: reason of migration

 *
@@ -491,7 +489,6 @@ svm_migrate_vma_to_vram(struct kfd_node *node, struct svm_range *prange, 
 */

static int

svm_migrate_ram_to_vram(struct svm_range *prange, uint32_t best_loc,

			unsigned long start_mgr, unsigned long last_mgr,

			struct mm_struct *mm, uint32_t trigger)

{

	unsigned long addr, start, end;
@@ -501,30 +498,23 @@ svm_migrate_ram_to_vram(struct svm_range *prange, uint32_t best_loc, 
	unsigned long cpages = 0;

	long r = 0;



	if (!best_loc) {

		pr_debug("svms 0x%p [0x%lx 0x%lx] migrate to sys ram\n",

			prange->svms, start_mgr, last_mgr);

	if (prange->actual_loc == best_loc) {

		pr_debug("svms 0x%p [0x%lx 0x%lx] already on best_loc 0x%x\n",

			 prange->svms, prange->start, prange->last, best_loc);

		return 0;

	}



	if (start_mgr < prange->start || last_mgr > prange->last) {

		pr_debug("range [0x%lx 0x%lx] out prange [0x%lx 0x%lx]\n",

				 start_mgr, last_mgr, prange->start, prange->last);

		return -EFAULT;

	}



	node = svm_range_get_node_by_id(prange, best_loc);

	if (!node) {

		pr_debug("failed to get kfd node by id 0x%x\n", best_loc);

		return -ENODEV;

	}



	pr_debug("svms 0x%p [0x%lx 0x%lx] in [0x%lx 0x%lx] to gpu 0x%x\n",

		prange->svms, start_mgr, last_mgr, prange->start, prange->last,

		best_loc);

	pr_debug("svms 0x%p [0x%lx 0x%lx] to gpu 0x%x\n", prange->svms,

		 prange->start, prange->last, best_loc);



	start = start_mgr << PAGE_SHIFT;

	end = (last_mgr + 1) << PAGE_SHIFT;

	start = prange->start << PAGE_SHIFT;

	end = (prange->last + 1) << PAGE_SHIFT;



	r = svm_range_vram_node_new(node, prange, true);

	if (r) {
@@ -554,11 +544,8 @@ svm_migrate_ram_to_vram(struct svm_range *prange, uint32_t best_loc, 


	if (cpages) {

		prange->actual_loc = best_loc;

		prange->vram_pages = prange->vram_pages + cpages;

	} else if (!prange->actual_loc) {

		/* if no page migrated and all pages from prange are at

		 * sys ram drop svm_bo got from svm_range_vram_node_new

		 */

		svm_range_dma_unmap(prange);

	} else {

		svm_range_vram_node_free(prange);

	}
@@ -676,8 +663,9 @@ svm_migrate_copy_to_ram(struct amdgpu_device *adev, struct svm_range *prange, 
 * Context: Process context, caller hold mmap read lock, prange->migrate_mutex

 *

 * Return:

 *   0 - success with all pages migrated

 *   negative values - indicate error

 *   positive values or zero - number of pages got migrated

 *   positive values - partial migration, number of pages not migrated

 */

static long

svm_migrate_vma_to_ram(struct kfd_node *node, struct svm_range *prange,
@@ -688,7 +676,6 @@ svm_migrate_vma_to_ram(struct kfd_node *node, struct svm_range *prange, 
	uint64_t npages = (end - start) >> PAGE_SHIFT;

	unsigned long upages = npages;

	unsigned long cpages = 0;

	unsigned long mpages = 0;

	struct amdgpu_device *adev = node->adev;

	struct kfd_process_device *pdd;

	struct dma_fence *mfence = NULL;
@@ -738,10 +725,10 @@ svm_migrate_vma_to_ram(struct kfd_node *node, struct svm_range *prange, 
		goto out_free;

	}

	if (cpages != npages)

		pr_debug("partial migration, 0x%lx/0x%llx pages collected\n",

		pr_debug("partial migration, 0x%lx/0x%llx pages migrated\n",

			 cpages, npages);

	else

		pr_debug("0x%lx pages collected\n", cpages);

		pr_debug("0x%lx pages migrated\n", cpages);



	r = svm_migrate_copy_to_ram(adev, prange, &migrate, &mfence,

				    scratch, npages);
@@ -764,21 +751,17 @@ svm_migrate_vma_to_ram(struct kfd_node *node, struct svm_range *prange, 
	kvfree(buf);

out:

	if (!r && cpages) {

		mpages = cpages - upages;

		pdd = svm_range_get_pdd_by_node(prange, node);

		if (pdd)

			WRITE_ONCE(pdd->page_out, pdd->page_out + mpages);

			WRITE_ONCE(pdd->page_out, pdd->page_out + cpages);

	}



	return r ? r : mpages;

	return r ? r : upages;

}



/**

 * svm_migrate_vram_to_ram - migrate svm range from device to system

 * @prange: range structure

 * @mm: process mm, use current->mm if NULL

 * @start_mgr: start page need be migrated to sys ram

 * @last_mgr: last page need be migrated to sys ram

 * @trigger: reason of migration

 * @fault_page: is from vmf->page, svm_migrate_to_ram(), this is CPU page fault callback

 *
@@ -788,7 +771,6 @@ svm_migrate_vma_to_ram(struct kfd_node *node, struct svm_range *prange, 
 * 0 - OK, otherwise error code

 */

int svm_migrate_vram_to_ram(struct svm_range *prange, struct mm_struct *mm,

			    unsigned long start_mgr, unsigned long last_mgr,

			    uint32_t trigger, struct page *fault_page)

{

	struct kfd_node *node;
@@ -796,33 +778,26 @@ int svm_migrate_vram_to_ram(struct svm_range *prange, struct mm_struct *mm, 
	unsigned long addr;

	unsigned long start;

	unsigned long end;

	unsigned long mpages = 0;

	unsigned long upages = 0;

	long r = 0;



	/* this pragne has no any vram page to migrate to sys ram */

	if (!prange->actual_loc) {

		pr_debug("[0x%lx 0x%lx] already migrated to ram\n",

			 prange->start, prange->last);

		return 0;

	}



	if (start_mgr < prange->start || last_mgr > prange->last) {

		pr_debug("range [0x%lx 0x%lx] out prange [0x%lx 0x%lx]\n",

				 start_mgr, last_mgr, prange->start, prange->last);

		return -EFAULT;

	}



	node = svm_range_get_node_by_id(prange, prange->actual_loc);

	if (!node) {

		pr_debug("failed to get kfd node by id 0x%x\n", prange->actual_loc);

		return -ENODEV;

	}

	pr_debug("svms 0x%p prange 0x%p [0x%lx 0x%lx] from gpu 0x%x to ram\n",

		 prange->svms, prange, start_mgr, last_mgr,

		 prange->svms, prange, prange->start, prange->last,

		 prange->actual_loc);



	start = start_mgr << PAGE_SHIFT;

	end = (last_mgr + 1) << PAGE_SHIFT;

	start = prange->start << PAGE_SHIFT;

	end = (prange->last + 1) << PAGE_SHIFT;



	for (addr = start; addr < end;) {

		unsigned long next;
@@ -841,21 +816,14 @@ int svm_migrate_vram_to_ram(struct svm_range *prange, struct mm_struct *mm, 
			pr_debug("failed %ld to migrate prange %p\n", r, prange);

			break;

		} else {

			mpages += r;

			upages += r;

		}

		addr = next;

	}



	if (r >= 0) {

		prange->vram_pages -= mpages;



		/* prange does not have vram page set its actual_loc to system

		 * and drop its svm_bo ref

		 */

		if (prange->vram_pages == 0 && prange->ttm_res) {

			prange->actual_loc = 0;

	if (r >= 0 && !upages) {

		svm_range_vram_node_free(prange);

		}

		prange->actual_loc = 0;

	}



	return r < 0 ? r : 0;
@@ -865,22 +833,16 @@ int svm_migrate_vram_to_ram(struct svm_range *prange, struct mm_struct *mm, 
 * svm_migrate_vram_to_vram - migrate svm range from device to device

 * @prange: range structure

 * @best_loc: the device to migrate to

 * @start: start page need be migrated to sys ram

 * @last: last page need be migrated to sys ram

 * @mm: process mm, use current->mm if NULL

 * @trigger: reason of migration

 *

 * Context: Process context, caller hold mmap read lock, svms lock, prange lock

 *

 * migrate all vram pages in prange to sys ram, then migrate

 * [start, last] pages from sys ram to gpu node best_loc.

 *

 * Return:

 * 0 - OK, otherwise error code

 */

static int

svm_migrate_vram_to_vram(struct svm_range *prange, uint32_t best_loc,

			unsigned long start, unsigned long last,

			 struct mm_struct *mm, uint32_t trigger)

{

	int r, retries = 3;
@@ -893,8 +855,7 @@ svm_migrate_vram_to_vram(struct svm_range *prange, uint32_t best_loc, 
	pr_debug("from gpu 0x%x to gpu 0x%x\n", prange->actual_loc, best_loc);



	do {

		r = svm_migrate_vram_to_ram(prange, mm, prange->start, prange->last,

								trigger, NULL);

		r = svm_migrate_vram_to_ram(prange, mm, trigger, NULL);

		if (r)

			return r;

	} while (prange->actual_loc && --retries);
@@ -902,21 +863,17 @@ svm_migrate_vram_to_vram(struct svm_range *prange, uint32_t best_loc, 
	if (prange->actual_loc)

		return -EDEADLK;



	return svm_migrate_ram_to_vram(prange, best_loc, start, last, mm, trigger);

	return svm_migrate_ram_to_vram(prange, best_loc, mm, trigger);

}



int

svm_migrate_to_vram(struct svm_range *prange, uint32_t best_loc,

			unsigned long start, unsigned long last,

		    struct mm_struct *mm, uint32_t trigger)

{

	if  (!prange->actual_loc || prange->actual_loc == best_loc)

		return svm_migrate_ram_to_vram(prange, best_loc, start, last,

						mm, trigger);



	if  (!prange->actual_loc)

		return svm_migrate_ram_to_vram(prange, best_loc, mm, trigger);

	else

		return svm_migrate_vram_to_vram(prange, best_loc, start, last,

						mm, trigger);

		return svm_migrate_vram_to_vram(prange, best_loc, mm, trigger);



}
@@ -932,9 +889,10 @@ svm_migrate_to_vram(struct svm_range *prange, uint32_t best_loc, 
 */

static vm_fault_t svm_migrate_to_ram(struct vm_fault *vmf)

{

	unsigned long start, last, size;

	unsigned long addr = vmf->address;

	struct svm_range_bo *svm_bo;

	enum svm_work_list_ops op;

	struct svm_range *parent;

	struct svm_range *prange;

	struct kfd_process *p;

	struct mm_struct *mm;
@@ -971,31 +929,51 @@ static vm_fault_t svm_migrate_to_ram(struct vm_fault *vmf) 


	mutex_lock(&p->svms.lock);



	prange = svm_range_from_addr(&p->svms, addr, NULL);

	prange = svm_range_from_addr(&p->svms, addr, &parent);

	if (!prange) {

		pr_debug("failed get range svms 0x%p addr 0x%lx\n", &p->svms, addr);

		r = -EFAULT;

		goto out_unlock_svms;

	}



	mutex_lock(&prange->migrate_mutex);

	mutex_lock(&parent->migrate_mutex);

	if (prange != parent)

		mutex_lock_nested(&prange->migrate_mutex, 1);



	if (!prange->actual_loc)

		goto out_unlock_prange;



	/* Align migration range start and size to granularity size */

	size = 1UL << prange->granularity;

	start = max(ALIGN_DOWN(addr, size), prange->start);

	last = min(ALIGN(addr + 1, size) - 1, prange->last);

	svm_range_lock(parent);

	if (prange != parent)

		mutex_lock_nested(&prange->lock, 1);

	r = svm_range_split_by_granularity(p, mm, addr, parent, prange);

	if (prange != parent)

		mutex_unlock(&prange->lock);

	svm_range_unlock(parent);

	if (r) {

		pr_debug("failed %d to split range by granularity\n", r);

		goto out_unlock_prange;

	}



	r = svm_migrate_vram_to_ram(prange, vmf->vma->vm_mm, start, last,

						KFD_MIGRATE_TRIGGER_PAGEFAULT_CPU, vmf->page);

	r = svm_migrate_vram_to_ram(prange, vmf->vma->vm_mm,

				    KFD_MIGRATE_TRIGGER_PAGEFAULT_CPU,

				    vmf->page);

	if (r)

		pr_debug("failed %d migrate svms 0x%p range 0x%p [0x%lx 0x%lx]\n",

			r, prange->svms, prange, start, last);

			 r, prange->svms, prange, prange->start, prange->last);



	/* xnack on, update mapping on GPUs with ACCESS_IN_PLACE */

	if (p->xnack_enabled && parent == prange)

		op = SVM_OP_UPDATE_RANGE_NOTIFIER_AND_MAP;

	else

		op = SVM_OP_UPDATE_RANGE_NOTIFIER;

	svm_range_add_list_work(&p->svms, parent, mm, op);

	schedule_deferred_list_work(&p->svms);



out_unlock_prange:

	if (prange != parent)

		mutex_unlock(&prange->migrate_mutex);

	mutex_unlock(&parent->migrate_mutex);

out_unlock_svms:

	mutex_unlock(&p->svms.lock);

out_unref_process:

drivers/gpu/drm/amd/amdkfd/kfd_migrate.h

+1 −5
Original line number Diff line number Diff line
@@ -41,13 +41,9 @@ enum MIGRATION_COPY_DIR { 
};



int svm_migrate_to_vram(struct svm_range *prange,  uint32_t best_loc,

			unsigned long start, unsigned long last,

			struct mm_struct *mm, uint32_t trigger);



int svm_migrate_vram_to_ram(struct svm_range *prange, struct mm_struct *mm,

			unsigned long start, unsigned long last,

			    uint32_t trigger, struct page *fault_page);



unsigned long

svm_migrate_addr_to_pfn(struct amdgpu_device *adev, unsigned long addr);

drivers/gpu/drm/amd/amdkfd/kfd_svm.c

+19 −64
Original line number Diff line number Diff line
@@ -158,13 +158,12 @@ svm_is_valid_dma_mapping_addr(struct device *dev, dma_addr_t dma_addr) 
static int

svm_range_dma_map_dev(struct amdgpu_device *adev, struct svm_range *prange,

		      unsigned long offset, unsigned long npages,

		      unsigned long *hmm_pfns, uint32_t gpuidx, uint64_t *vram_pages)

		      unsigned long *hmm_pfns, uint32_t gpuidx)

{

	enum dma_data_direction dir = DMA_BIDIRECTIONAL;

	dma_addr_t *addr = prange->dma_addr[gpuidx];

	struct device *dev = adev->dev;

	struct page *page;

	uint64_t vram_pages_dev;

	int i, r;



	if (!addr) {
@@ -174,7 +173,6 @@ svm_range_dma_map_dev(struct amdgpu_device *adev, struct svm_range *prange, 
		prange->dma_addr[gpuidx] = addr;

	}



	vram_pages_dev = 0;

	addr += offset;

	for (i = 0; i < npages; i++) {

		if (svm_is_valid_dma_mapping_addr(dev, addr[i]))
@@ -184,7 +182,6 @@ svm_range_dma_map_dev(struct amdgpu_device *adev, struct svm_range *prange, 
		if (is_zone_device_page(page)) {

			struct amdgpu_device *bo_adev = prange->svm_bo->node->adev;



			vram_pages_dev++;

			addr[i] = (hmm_pfns[i] << PAGE_SHIFT) +

				   bo_adev->vm_manager.vram_base_offset -

				   bo_adev->kfd.pgmap.range.start;
@@ -201,14 +198,13 @@ svm_range_dma_map_dev(struct amdgpu_device *adev, struct svm_range *prange, 
		pr_debug_ratelimited("dma mapping 0x%llx for page addr 0x%lx\n",

				     addr[i] >> PAGE_SHIFT, page_to_pfn(page));

	}

	*vram_pages = vram_pages_dev;

	return 0;

}



static int

svm_range_dma_map(struct svm_range *prange, unsigned long *bitmap,

		  unsigned long offset, unsigned long npages,

		  unsigned long *hmm_pfns, uint64_t *vram_pages)

		  unsigned long *hmm_pfns)

{

	struct kfd_process *p;

	uint32_t gpuidx;
@@ -227,7 +223,7 @@ svm_range_dma_map(struct svm_range *prange, unsigned long *bitmap, 
		}



		r = svm_range_dma_map_dev(pdd->dev->adev, prange, offset, npages,

					  hmm_pfns, gpuidx, vram_pages);

					  hmm_pfns, gpuidx);

		if (r)

			break;

	}
@@ -353,7 +349,6 @@ svm_range *svm_range_new(struct svm_range_list *svms, uint64_t start, 
	INIT_LIST_HEAD(&prange->child_list);

	atomic_set(&prange->invalid, 0);

	prange->validate_timestamp = 0;

	prange->vram_pages = 0;

	mutex_init(&prange->migrate_mutex);

	mutex_init(&prange->lock);
@@ -400,8 +395,6 @@ static void svm_range_bo_release(struct kref *kref) 
			 prange->start, prange->last);

		mutex_lock(&prange->lock);

		prange->svm_bo = NULL;

		/* prange should not hold vram page now */

		WARN_ON(prange->actual_loc);

		mutex_unlock(&prange->lock);



		spin_lock(&svm_bo->list_lock);
@@ -982,11 +975,6 @@ svm_range_split_nodes(struct svm_range *new, struct svm_range *old, 
	new->svm_bo = svm_range_bo_ref(old->svm_bo);

	new->ttm_res = old->ttm_res;



	/* set new's vram_pages as old range's now, the acurate vram_pages

	 * will be updated during mapping

	 */

	new->vram_pages = min(old->vram_pages, new->npages);



	spin_lock(&new->svm_bo->list_lock);

	list_add(&new->svm_bo_list, &new->svm_bo->range_list);

	spin_unlock(&new->svm_bo->list_lock);
@@ -1630,7 +1618,6 @@ static int svm_range_validate_and_map(struct mm_struct *mm, 
	struct svm_validate_context *ctx;

	unsigned long start, end, addr;

	struct kfd_process *p;

	uint64_t vram_pages;

	void *owner;

	int32_t idx;

	int r = 0;
@@ -1699,13 +1686,11 @@ static int svm_range_validate_and_map(struct mm_struct *mm, 
		}

	}



	vram_pages = 0;

	start = prange->start << PAGE_SHIFT;

	end = (prange->last + 1) << PAGE_SHIFT;

	for (addr = start; !r && addr < end; ) {

		struct hmm_range *hmm_range;

		struct vm_area_struct *vma;

		uint64_t vram_pages_vma;

		unsigned long next = 0;

		unsigned long offset;

		unsigned long npages;
@@ -1734,11 +1719,9 @@ static int svm_range_validate_and_map(struct mm_struct *mm, 
		if (!r) {

			offset = (addr - start) >> PAGE_SHIFT;

			r = svm_range_dma_map(prange, ctx->bitmap, offset, npages,

					      hmm_range->hmm_pfns, &vram_pages_vma);

					      hmm_range->hmm_pfns);

			if (r)

				pr_debug("failed %d to dma map range\n", r);

			else

				vram_pages += vram_pages_vma;

		}



		svm_range_lock(prange);
@@ -1764,19 +1747,6 @@ static int svm_range_validate_and_map(struct mm_struct *mm, 
		addr = next;

	}



	if (addr == end) {

		prange->vram_pages = vram_pages;



		/* if prange does not include any vram page and it

		 * has not released svm_bo drop its svm_bo reference

		 * and set its actaul_loc to sys ram

		 */

		if (!vram_pages && prange->ttm_res) {

			prange->actual_loc = 0;

			svm_range_vram_node_free(prange);

		}

	}



	svm_range_unreserve_bos(ctx);

	if (!r)

		prange->validate_timestamp = ktime_get_boottime();
@@ -2029,7 +1999,6 @@ static struct svm_range *svm_range_clone(struct svm_range *old) 
	new->actual_loc = old->actual_loc;

	new->granularity = old->granularity;

	new->mapped_to_gpu = old->mapped_to_gpu;

	new->vram_pages = old->vram_pages;

	bitmap_copy(new->bitmap_access, old->bitmap_access, MAX_GPU_INSTANCE);

	bitmap_copy(new->bitmap_aip, old->bitmap_aip, MAX_GPU_INSTANCE);
@@ -2937,7 +2906,6 @@ svm_range_restore_pages(struct amdgpu_device *adev, unsigned int pasid, 
			uint32_t vmid, uint32_t node_id,

			uint64_t addr, bool write_fault)

{

	unsigned long start, last, size;

	struct mm_struct *mm = NULL;

	struct svm_range_list *svms;

	struct svm_range *prange;
@@ -3073,35 +3041,32 @@ svm_range_restore_pages(struct amdgpu_device *adev, unsigned int pasid, 
	kfd_smi_event_page_fault_start(node, p->lead_thread->pid, addr,

				       write_fault, timestamp);



	if (prange->actual_loc != 0 || best_loc != 0) {

	if (prange->actual_loc != best_loc) {

		migration = true;

		/* Align migration range start and size to granularity size */

		size = 1UL << prange->granularity;

		start = max_t(unsigned long, ALIGN_DOWN(addr, size), prange->start);

		last = min_t(unsigned long, ALIGN(addr + 1, size) - 1, prange->last);



		if (best_loc) {

			r = svm_migrate_to_vram(prange, best_loc, start, last,

					mm, KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU);

			r = svm_migrate_to_vram(prange, best_loc, mm,

					KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU);

			if (r) {

				pr_debug("svm_migrate_to_vram failed (%d) at %llx, falling back to system memory\n",

					 r, addr);

				/* Fallback to system memory if migration to

				 * VRAM failed

				 */

				if (prange->actual_loc && prange->actual_loc != best_loc)

					r = svm_migrate_vram_to_ram(prange, mm, start, last,

						KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU, NULL);

				if (prange->actual_loc)

					r = svm_migrate_vram_to_ram(prange, mm,

					   KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU,

					   NULL);

				else

					r = 0;

			}

		} else {

			r = svm_migrate_vram_to_ram(prange, mm, start, last,

					KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU, NULL);

			r = svm_migrate_vram_to_ram(prange, mm,

					KFD_MIGRATE_TRIGGER_PAGEFAULT_GPU,

					NULL);

		}

		if (r) {

			pr_debug("failed %d to migrate svms %p [0x%lx 0x%lx]\n",

				 r, svms, start, last);

				 r, svms, prange->start, prange->last);

			goto out_unlock_range;

		}

	}
@@ -3455,24 +3420,18 @@ svm_range_trigger_migration(struct mm_struct *mm, struct svm_range *prange, 
	*migrated = false;

	best_loc = svm_range_best_prefetch_location(prange);



	/* when best_loc is a gpu node and same as prange->actual_loc

	 * we still need do migration as prange->actual_loc !=0 does

	 * not mean all pages in prange are vram. hmm migrate will pick

	 * up right pages during migration.

	 */

	if ((best_loc == KFD_IOCTL_SVM_LOCATION_UNDEFINED) ||

	    (best_loc == 0 && prange->actual_loc == 0))

	if (best_loc == KFD_IOCTL_SVM_LOCATION_UNDEFINED ||

	    best_loc == prange->actual_loc)

		return 0;



	if (!best_loc) {

		r = svm_migrate_vram_to_ram(prange, mm, prange->start, prange->last,

		r = svm_migrate_vram_to_ram(prange, mm,

					KFD_MIGRATE_TRIGGER_PREFETCH, NULL);

		*migrated = !r;

		return r;

	}



	r = svm_migrate_to_vram(prange, best_loc, prange->start, prange->last,

				mm, KFD_MIGRATE_TRIGGER_PREFETCH);

	r = svm_migrate_to_vram(prange, best_loc, mm, KFD_MIGRATE_TRIGGER_PREFETCH);

	*migrated = !r;



	return r;
@@ -3527,11 +3486,7 @@ static void svm_range_evict_svm_bo_worker(struct work_struct *work) 


		mutex_lock(&prange->migrate_mutex);

		do {

			/* migrate all vram pages in this prange to sys ram

			 * after that prange->actual_loc should be zero

			 */

			r = svm_migrate_vram_to_ram(prange, mm,

					prange->start, prange->last,

					KFD_MIGRATE_TRIGGER_TTM_EVICTION, NULL);

		} while (!r && prange->actual_loc && --retries);

drivers/gpu/drm/amd/amdkfd/kfd_svm.h

+1 −5
Original line number Diff line number Diff line
@@ -78,7 +78,6 @@ struct svm_work_list_item { 
 * @update_list:link list node used to add to update_list

 * @mapping:    bo_va mapping structure to create and update GPU page table

 * @npages:     number of pages

 * @vram_pages: vram pages number in this svm_range

 * @dma_addr:   dma mapping address on each GPU for system memory physical page

 * @ttm_res:    vram ttm resource map

 * @offset:     range start offset within mm_nodes
@@ -89,9 +88,7 @@ struct svm_work_list_item { 
 * @flags:      flags defined as KFD_IOCTL_SVM_FLAG_*

 * @perferred_loc: perferred location, 0 for CPU, or GPU id

 * @perfetch_loc: last prefetch location, 0 for CPU, or GPU id

 * @actual_loc: this svm_range location. 0: all pages are from sys ram;

 *              GPU id: this svm_range may include vram pages from GPU with

 *              id actual_loc.

 * @actual_loc: the actual location, 0 for CPU, or GPU id

 * @granularity:migration granularity, log2 num pages

 * @invalid:    not 0 means cpu page table is invalidated

 * @validate_timestamp: system timestamp when range is validated
@@ -115,7 +112,6 @@ struct svm_range { 
	struct list_head		list;

	struct list_head		update_list;

	uint64_t			npages;

	uint64_t			vram_pages;

	dma_addr_t			*dma_addr[MAX_GPU_INSTANCE];

	struct ttm_resource		*ttm_res;

	uint64_t			offset;