Re: Deadlock on PTEs update for HMM

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Felix,

yes that is exactly my thinking as well. Problem is that getting this to work was much harder than I thought.

We can't use a mutex cause TTM is calling the eviction callback in atomic context. A spinlock doesn't looked like a good idea either because we potentially need to wait for the hardware with a fixed IB pool.

Because of this I've started to rewrite the TTM handling to not call the driver in an atomic context any more, but that took me way longer than expected as well.

I'm currently experimenting with using a trylock driver mutex, that at least that should work for now until we got something better.

Regards,
Christian.

Am 28.11.19 um 21:30 schrieb Felix Kuehling:
Hi Christian,

I'm thinking about this problem, trying to come up with a solution. The fundamental problem is that we need low-overhead access to the page table in the MMU notifier, without much memory management or locking.

There is one "driver lock" that we're supposed to take in the MMU notifier as well as when we update page tables that is prescribed by the HMM documentation (Documentation/vm/hmm.rst). I don't currently see such a lock in amdgpu. We'll probably need to add that anyway, with all the usual precautions about lock dependencies around MMU notifiers. Then we could use that lock to protect page table residency state, in addition to the reservation of the top-level page directory.

We don't want to block eviction of page tables unconditionally, so the MMU notifier must be able to deal with the situation that page tables are not resident at the moment. But the lock can delay page tables from being evicted while an MMU notifier is in progress and protect us from race conditions between MMU notifiers invalidating PTEs, and page tables getting evicted.

amdgpu_vm_bo_invalidate could detect when a page table is being evicted, and update a new "vm_resident" flag inside the amdgpu_vm while holding the "HMM driver lock". If an MMU notifier is in progress, trying to take the "HMM driver lock" will delay the eviction long enough for any pending PTE invalidation to complete.

In the case that page tables are not resident (vm_resident flag is false), it means the GPU is currently not accessing any memory in that amdgpu_vm address space. So we don't need to invalidate the PTEs right away. I think we could implement a deferred invalidation mechanism for this case, that delays the invalidation until the next time the page tables are made resident. amdgpu_amdkfd_gpuvm_restore_process_bos would replay any deferred PTE invalidations after validating the page tables but before restarting the user mode queues for the process. If graphics ever implements page-fault-based memory management, you'd need to do something similar in amdgpu_cs.

Once all that is in place, we should be able to update PTEs in MMU notifiers without reserving the page tables.

If we use SDMA for updating page tables, we may need a pre-allocated IB for use in MMU notifiers. And there is problably other details to be worked out about exactly how we implement the PTE invalidation in MMU notifiers and reflecting that in the state of the amdgpu_vm and amdgpu_bo_va_mapping.

Does this idea sound reasonable to you? Can you think of a simpler solution?

Thanks,
  Felix

On 2019-11-27 10:02 a.m., Christian König wrote:
Hi Alejandro,

yes I'm very aware of this issue, but unfortunately can't give an easy solution either.

I'm working for over a year now on getting this fixed, but unfortunately it turned out that this problem is much bigger than initially thought.

Setting the appropriate GFP flags for the job allocation is actually the trivial part.

The really really hard thing is that we somehow need to add a lock to prevent the page tables from being evicted. And as you also figured out that lock can't be taken easily anywhere else.

I've already wrote a prototype for this, but didn't had time to hammer it into shape for upstreaming yet.

Regards,
Christian.

Am 27.11.19 um 15:55 schrieb Sierra Guiza, Alejandro (Alex):

Hi Christian,

As you know, we’re working on the HMM enablement. Im working on the dGPU page table entries invalidation on the userptr mapping case. Currently, the MMU notifiers handle stops all user mode queues, schedule a delayed worker to re-validate userptr mappings and restart the queues.

Part of the HMM functionality, we need to invalidate the page table entries instead of stopping the queues. At the same time we need to move the revalidation of the userptr mappings into the page fault handler.

We’re seeing a deadlock warning after we try to invalidate the PTEs inside the MMU notifier handler. More specific, when we try to update the BOs to invalidate PTEs using amdgpu_vm_bo_update. This uses kmalloc on the amdgpu_job_alloc which seems to be causing this problem.

Based on @Kuehling, Felix <mailto:Felix.Kuehling@xxxxxxx> comments, kmalloc without any special flags can cause memory reclaim. Doing that inside an MMU notifier is problematic, because an MMU notifier may be called inside a memory-reclaim operation itself. That would result in recursion. Also, reclaim shouldn't be done while holding a lock that can be taken in an MMU notifier for the same reason. If you cause a reclaim while holding that lock, then an MMU notifier called by the reclaim can deadlock trying to take the same lock.

Please let us know if you have any advice to enable this the right way

Thanks in advanced,

Alejandro


_______________________________________________
amd-gfx mailing list
amd-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/amd-gfx

_______________________________________________
amd-gfx mailing list
amd-gfx@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/amd-gfx




[Index of Archives]     [Linux USB Devel]     [Linux Audio Users]     [Yosemite News]     [Linux Kernel]     [Linux SCSI]

  Powered by Linux