1133ff0eaSJérôme Glisse /* 2133ff0eaSJérôme Glisse * Copyright 2013 Red Hat Inc. 3133ff0eaSJérôme Glisse * 4133ff0eaSJérôme Glisse * This program is free software; you can redistribute it and/or modify 5133ff0eaSJérôme Glisse * it under the terms of the GNU General Public License as published by 6133ff0eaSJérôme Glisse * the Free Software Foundation; either version 2 of the License, or 7133ff0eaSJérôme Glisse * (at your option) any later version. 8133ff0eaSJérôme Glisse * 9133ff0eaSJérôme Glisse * This program is distributed in the hope that it will be useful, 10133ff0eaSJérôme Glisse * but WITHOUT ANY WARRANTY; without even the implied warranty of 11133ff0eaSJérôme Glisse * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12133ff0eaSJérôme Glisse * GNU General Public License for more details. 13133ff0eaSJérôme Glisse * 14133ff0eaSJérôme Glisse * Authors: Jérôme Glisse <jglisse@redhat.com> 15133ff0eaSJérôme Glisse */ 16133ff0eaSJérôme Glisse /* 17133ff0eaSJérôme Glisse * Refer to include/linux/hmm.h for information about heterogeneous memory 18133ff0eaSJérôme Glisse * management or HMM for short. 19133ff0eaSJérôme Glisse */ 20133ff0eaSJérôme Glisse #include <linux/mm.h> 21133ff0eaSJérôme Glisse #include <linux/hmm.h> 22858b54daSJérôme Glisse #include <linux/init.h> 23da4c3c73SJérôme Glisse #include <linux/rmap.h> 24da4c3c73SJérôme Glisse #include <linux/swap.h> 25133ff0eaSJérôme Glisse #include <linux/slab.h> 26133ff0eaSJérôme Glisse #include <linux/sched.h> 274ef589dcSJérôme Glisse #include <linux/mmzone.h> 284ef589dcSJérôme Glisse #include <linux/pagemap.h> 29da4c3c73SJérôme Glisse #include <linux/swapops.h> 30da4c3c73SJérôme Glisse #include <linux/hugetlb.h> 314ef589dcSJérôme Glisse #include <linux/memremap.h> 327b2d55d2SJérôme Glisse #include <linux/jump_label.h> 33c0b12405SJérôme Glisse #include <linux/mmu_notifier.h> 344ef589dcSJérôme Glisse #include <linux/memory_hotplug.h> 354ef589dcSJérôme Glisse 364ef589dcSJérôme Glisse #define PA_SECTION_SIZE (1UL << PA_SECTION_SHIFT) 37133ff0eaSJérôme Glisse 38133ff0eaSJérôme Glisse 397b2d55d2SJérôme Glisse /* 407b2d55d2SJérôme Glisse * Device private memory see HMM (Documentation/vm/hmm.txt) or hmm.h 417b2d55d2SJérôme Glisse */ 427b2d55d2SJérôme Glisse DEFINE_STATIC_KEY_FALSE(device_private_key); 437b2d55d2SJérôme Glisse EXPORT_SYMBOL(device_private_key); 447b2d55d2SJérôme Glisse 457b2d55d2SJérôme Glisse 46133ff0eaSJérôme Glisse #ifdef CONFIG_HMM 47c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops; 48c0b12405SJérôme Glisse 49133ff0eaSJérôme Glisse /* 50133ff0eaSJérôme Glisse * struct hmm - HMM per mm struct 51133ff0eaSJérôme Glisse * 52133ff0eaSJérôme Glisse * @mm: mm struct this HMM struct is bound to 53da4c3c73SJérôme Glisse * @lock: lock protecting ranges list 54c0b12405SJérôme Glisse * @sequence: we track updates to the CPU page table with a sequence number 55da4c3c73SJérôme Glisse * @ranges: list of range being snapshotted 56c0b12405SJérôme Glisse * @mirrors: list of mirrors for this mm 57c0b12405SJérôme Glisse * @mmu_notifier: mmu notifier to track updates to CPU page table 58c0b12405SJérôme Glisse * @mirrors_sem: read/write semaphore protecting the mirrors list 59133ff0eaSJérôme Glisse */ 60133ff0eaSJérôme Glisse struct hmm { 61133ff0eaSJérôme Glisse struct mm_struct *mm; 62da4c3c73SJérôme Glisse spinlock_t lock; 63c0b12405SJérôme Glisse atomic_t sequence; 64da4c3c73SJérôme Glisse struct list_head ranges; 65c0b12405SJérôme Glisse struct list_head mirrors; 66c0b12405SJérôme Glisse struct mmu_notifier mmu_notifier; 67c0b12405SJérôme Glisse struct rw_semaphore mirrors_sem; 68133ff0eaSJérôme Glisse }; 69133ff0eaSJérôme Glisse 70133ff0eaSJérôme Glisse /* 71133ff0eaSJérôme Glisse * hmm_register - register HMM against an mm (HMM internal) 72133ff0eaSJérôme Glisse * 73133ff0eaSJérôme Glisse * @mm: mm struct to attach to 74133ff0eaSJérôme Glisse * 75133ff0eaSJérôme Glisse * This is not intended to be used directly by device drivers. It allocates an 76133ff0eaSJérôme Glisse * HMM struct if mm does not have one, and initializes it. 77133ff0eaSJérôme Glisse */ 78133ff0eaSJérôme Glisse static struct hmm *hmm_register(struct mm_struct *mm) 79133ff0eaSJérôme Glisse { 80c0b12405SJérôme Glisse struct hmm *hmm = READ_ONCE(mm->hmm); 81c0b12405SJérôme Glisse bool cleanup = false; 82133ff0eaSJérôme Glisse 83133ff0eaSJérôme Glisse /* 84133ff0eaSJérôme Glisse * The hmm struct can only be freed once the mm_struct goes away, 85133ff0eaSJérôme Glisse * hence we should always have pre-allocated an new hmm struct 86133ff0eaSJérôme Glisse * above. 87133ff0eaSJérôme Glisse */ 88c0b12405SJérôme Glisse if (hmm) 89c0b12405SJérôme Glisse return hmm; 90c0b12405SJérôme Glisse 91c0b12405SJérôme Glisse hmm = kmalloc(sizeof(*hmm), GFP_KERNEL); 92c0b12405SJérôme Glisse if (!hmm) 93c0b12405SJérôme Glisse return NULL; 94c0b12405SJérôme Glisse INIT_LIST_HEAD(&hmm->mirrors); 95c0b12405SJérôme Glisse init_rwsem(&hmm->mirrors_sem); 96c0b12405SJérôme Glisse atomic_set(&hmm->sequence, 0); 97c0b12405SJérôme Glisse hmm->mmu_notifier.ops = NULL; 98da4c3c73SJérôme Glisse INIT_LIST_HEAD(&hmm->ranges); 99da4c3c73SJérôme Glisse spin_lock_init(&hmm->lock); 100c0b12405SJérôme Glisse hmm->mm = mm; 101c0b12405SJérôme Glisse 102c0b12405SJérôme Glisse /* 103c0b12405SJérôme Glisse * We should only get here if hold the mmap_sem in write mode ie on 104c0b12405SJérôme Glisse * registration of first mirror through hmm_mirror_register() 105c0b12405SJérôme Glisse */ 106c0b12405SJérôme Glisse hmm->mmu_notifier.ops = &hmm_mmu_notifier_ops; 107c0b12405SJérôme Glisse if (__mmu_notifier_register(&hmm->mmu_notifier, mm)) { 108c0b12405SJérôme Glisse kfree(hmm); 109c0b12405SJérôme Glisse return NULL; 110c0b12405SJérôme Glisse } 111c0b12405SJérôme Glisse 112c0b12405SJérôme Glisse spin_lock(&mm->page_table_lock); 113c0b12405SJérôme Glisse if (!mm->hmm) 114c0b12405SJérôme Glisse mm->hmm = hmm; 115c0b12405SJérôme Glisse else 116c0b12405SJérôme Glisse cleanup = true; 117c0b12405SJérôme Glisse spin_unlock(&mm->page_table_lock); 118c0b12405SJérôme Glisse 119c0b12405SJérôme Glisse if (cleanup) { 120c0b12405SJérôme Glisse mmu_notifier_unregister(&hmm->mmu_notifier, mm); 121c0b12405SJérôme Glisse kfree(hmm); 122c0b12405SJérôme Glisse } 123c0b12405SJérôme Glisse 124133ff0eaSJérôme Glisse return mm->hmm; 125133ff0eaSJérôme Glisse } 126133ff0eaSJérôme Glisse 127133ff0eaSJérôme Glisse void hmm_mm_destroy(struct mm_struct *mm) 128133ff0eaSJérôme Glisse { 129133ff0eaSJérôme Glisse kfree(mm->hmm); 130133ff0eaSJérôme Glisse } 131133ff0eaSJérôme Glisse #endif /* CONFIG_HMM */ 132c0b12405SJérôme Glisse 133c0b12405SJérôme Glisse #if IS_ENABLED(CONFIG_HMM_MIRROR) 134c0b12405SJérôme Glisse static void hmm_invalidate_range(struct hmm *hmm, 135c0b12405SJérôme Glisse enum hmm_update_type action, 136c0b12405SJérôme Glisse unsigned long start, 137c0b12405SJérôme Glisse unsigned long end) 138c0b12405SJérôme Glisse { 139c0b12405SJérôme Glisse struct hmm_mirror *mirror; 140da4c3c73SJérôme Glisse struct hmm_range *range; 141da4c3c73SJérôme Glisse 142da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 143da4c3c73SJérôme Glisse list_for_each_entry(range, &hmm->ranges, list) { 144da4c3c73SJérôme Glisse unsigned long addr, idx, npages; 145da4c3c73SJérôme Glisse 146da4c3c73SJérôme Glisse if (end < range->start || start >= range->end) 147da4c3c73SJérôme Glisse continue; 148da4c3c73SJérôme Glisse 149da4c3c73SJérôme Glisse range->valid = false; 150da4c3c73SJérôme Glisse addr = max(start, range->start); 151da4c3c73SJérôme Glisse idx = (addr - range->start) >> PAGE_SHIFT; 152da4c3c73SJérôme Glisse npages = (min(range->end, end) - addr) >> PAGE_SHIFT; 153da4c3c73SJérôme Glisse memset(&range->pfns[idx], 0, sizeof(*range->pfns) * npages); 154da4c3c73SJérôme Glisse } 155da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 156c0b12405SJérôme Glisse 157c0b12405SJérôme Glisse down_read(&hmm->mirrors_sem); 158c0b12405SJérôme Glisse list_for_each_entry(mirror, &hmm->mirrors, list) 159c0b12405SJérôme Glisse mirror->ops->sync_cpu_device_pagetables(mirror, action, 160c0b12405SJérôme Glisse start, end); 161c0b12405SJérôme Glisse up_read(&hmm->mirrors_sem); 162c0b12405SJérôme Glisse } 163c0b12405SJérôme Glisse 164c0b12405SJérôme Glisse static void hmm_invalidate_range_start(struct mmu_notifier *mn, 165c0b12405SJérôme Glisse struct mm_struct *mm, 166c0b12405SJérôme Glisse unsigned long start, 167c0b12405SJérôme Glisse unsigned long end) 168c0b12405SJérôme Glisse { 169c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 170c0b12405SJérôme Glisse 171c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 172c0b12405SJérôme Glisse 173c0b12405SJérôme Glisse atomic_inc(&hmm->sequence); 174c0b12405SJérôme Glisse } 175c0b12405SJérôme Glisse 176c0b12405SJérôme Glisse static void hmm_invalidate_range_end(struct mmu_notifier *mn, 177c0b12405SJérôme Glisse struct mm_struct *mm, 178c0b12405SJérôme Glisse unsigned long start, 179c0b12405SJérôme Glisse unsigned long end) 180c0b12405SJérôme Glisse { 181c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 182c0b12405SJérôme Glisse 183c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 184c0b12405SJérôme Glisse 185c0b12405SJérôme Glisse hmm_invalidate_range(mm->hmm, HMM_UPDATE_INVALIDATE, start, end); 186c0b12405SJérôme Glisse } 187c0b12405SJérôme Glisse 188c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops = { 189c0b12405SJérôme Glisse .invalidate_range_start = hmm_invalidate_range_start, 190c0b12405SJérôme Glisse .invalidate_range_end = hmm_invalidate_range_end, 191c0b12405SJérôme Glisse }; 192c0b12405SJérôme Glisse 193c0b12405SJérôme Glisse /* 194c0b12405SJérôme Glisse * hmm_mirror_register() - register a mirror against an mm 195c0b12405SJérôme Glisse * 196c0b12405SJérôme Glisse * @mirror: new mirror struct to register 197c0b12405SJérôme Glisse * @mm: mm to register against 198c0b12405SJérôme Glisse * 199c0b12405SJérôme Glisse * To start mirroring a process address space, the device driver must register 200c0b12405SJérôme Glisse * an HMM mirror struct. 201c0b12405SJérôme Glisse * 202c0b12405SJérôme Glisse * THE mm->mmap_sem MUST BE HELD IN WRITE MODE ! 203c0b12405SJérôme Glisse */ 204c0b12405SJérôme Glisse int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) 205c0b12405SJérôme Glisse { 206c0b12405SJérôme Glisse /* Sanity check */ 207c0b12405SJérôme Glisse if (!mm || !mirror || !mirror->ops) 208c0b12405SJérôme Glisse return -EINVAL; 209c0b12405SJérôme Glisse 210c0b12405SJérôme Glisse mirror->hmm = hmm_register(mm); 211c0b12405SJérôme Glisse if (!mirror->hmm) 212c0b12405SJérôme Glisse return -ENOMEM; 213c0b12405SJérôme Glisse 214c0b12405SJérôme Glisse down_write(&mirror->hmm->mirrors_sem); 215c0b12405SJérôme Glisse list_add(&mirror->list, &mirror->hmm->mirrors); 216c0b12405SJérôme Glisse up_write(&mirror->hmm->mirrors_sem); 217c0b12405SJérôme Glisse 218c0b12405SJérôme Glisse return 0; 219c0b12405SJérôme Glisse } 220c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_register); 221c0b12405SJérôme Glisse 222c0b12405SJérôme Glisse /* 223c0b12405SJérôme Glisse * hmm_mirror_unregister() - unregister a mirror 224c0b12405SJérôme Glisse * 225c0b12405SJérôme Glisse * @mirror: new mirror struct to register 226c0b12405SJérôme Glisse * 227c0b12405SJérôme Glisse * Stop mirroring a process address space, and cleanup. 228c0b12405SJérôme Glisse */ 229c0b12405SJérôme Glisse void hmm_mirror_unregister(struct hmm_mirror *mirror) 230c0b12405SJérôme Glisse { 231c0b12405SJérôme Glisse struct hmm *hmm = mirror->hmm; 232c0b12405SJérôme Glisse 233c0b12405SJérôme Glisse down_write(&hmm->mirrors_sem); 234c0b12405SJérôme Glisse list_del(&mirror->list); 235c0b12405SJérôme Glisse up_write(&hmm->mirrors_sem); 236c0b12405SJérôme Glisse } 237c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_unregister); 238da4c3c73SJérôme Glisse 23974eee180SJérôme Glisse struct hmm_vma_walk { 24074eee180SJérôme Glisse struct hmm_range *range; 24174eee180SJérôme Glisse unsigned long last; 24274eee180SJérôme Glisse bool fault; 24374eee180SJérôme Glisse bool block; 24474eee180SJérôme Glisse bool write; 24574eee180SJérôme Glisse }; 24674eee180SJérôme Glisse 24774eee180SJérôme Glisse static int hmm_vma_do_fault(struct mm_walk *walk, 24874eee180SJérôme Glisse unsigned long addr, 24974eee180SJérôme Glisse hmm_pfn_t *pfn) 25074eee180SJérôme Glisse { 25174eee180SJérôme Glisse unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_REMOTE; 25274eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 25374eee180SJérôme Glisse struct vm_area_struct *vma = walk->vma; 25474eee180SJérôme Glisse int r; 25574eee180SJérôme Glisse 25674eee180SJérôme Glisse flags |= hmm_vma_walk->block ? 0 : FAULT_FLAG_ALLOW_RETRY; 25774eee180SJérôme Glisse flags |= hmm_vma_walk->write ? FAULT_FLAG_WRITE : 0; 25874eee180SJérôme Glisse r = handle_mm_fault(vma, addr, flags); 25974eee180SJérôme Glisse if (r & VM_FAULT_RETRY) 26074eee180SJérôme Glisse return -EBUSY; 26174eee180SJérôme Glisse if (r & VM_FAULT_ERROR) { 26274eee180SJérôme Glisse *pfn = HMM_PFN_ERROR; 26374eee180SJérôme Glisse return -EFAULT; 26474eee180SJérôme Glisse } 26574eee180SJérôme Glisse 26674eee180SJérôme Glisse return -EAGAIN; 26774eee180SJérôme Glisse } 26874eee180SJérôme Glisse 269da4c3c73SJérôme Glisse static void hmm_pfns_special(hmm_pfn_t *pfns, 270da4c3c73SJérôme Glisse unsigned long addr, 271da4c3c73SJérôme Glisse unsigned long end) 272da4c3c73SJérôme Glisse { 273da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, pfns++) 274da4c3c73SJérôme Glisse *pfns = HMM_PFN_SPECIAL; 275da4c3c73SJérôme Glisse } 276da4c3c73SJérôme Glisse 277da4c3c73SJérôme Glisse static int hmm_pfns_bad(unsigned long addr, 278da4c3c73SJérôme Glisse unsigned long end, 279da4c3c73SJérôme Glisse struct mm_walk *walk) 280da4c3c73SJérôme Glisse { 281da4c3c73SJérôme Glisse struct hmm_range *range = walk->private; 282da4c3c73SJérôme Glisse hmm_pfn_t *pfns = range->pfns; 283da4c3c73SJérôme Glisse unsigned long i; 284da4c3c73SJérôme Glisse 285da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 286da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) 287da4c3c73SJérôme Glisse pfns[i] = HMM_PFN_ERROR; 288da4c3c73SJérôme Glisse 289da4c3c73SJérôme Glisse return 0; 290da4c3c73SJérôme Glisse } 291da4c3c73SJérôme Glisse 29274eee180SJérôme Glisse static void hmm_pfns_clear(hmm_pfn_t *pfns, 29374eee180SJérôme Glisse unsigned long addr, 29474eee180SJérôme Glisse unsigned long end) 29574eee180SJérôme Glisse { 29674eee180SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, pfns++) 29774eee180SJérôme Glisse *pfns = 0; 29874eee180SJérôme Glisse } 29974eee180SJérôme Glisse 300da4c3c73SJérôme Glisse static int hmm_vma_walk_hole(unsigned long addr, 301da4c3c73SJérôme Glisse unsigned long end, 302da4c3c73SJérôme Glisse struct mm_walk *walk) 303da4c3c73SJérôme Glisse { 30474eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 30574eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 306da4c3c73SJérôme Glisse hmm_pfn_t *pfns = range->pfns; 307da4c3c73SJérôme Glisse unsigned long i; 308da4c3c73SJérôme Glisse 30974eee180SJérôme Glisse hmm_vma_walk->last = addr; 310da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 31174eee180SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) { 312da4c3c73SJérôme Glisse pfns[i] = HMM_PFN_EMPTY; 31374eee180SJérôme Glisse if (hmm_vma_walk->fault) { 31474eee180SJérôme Glisse int ret; 315da4c3c73SJérôme Glisse 31674eee180SJérôme Glisse ret = hmm_vma_do_fault(walk, addr, &pfns[i]); 31774eee180SJérôme Glisse if (ret != -EAGAIN) 31874eee180SJérôme Glisse return ret; 31974eee180SJérôme Glisse } 32074eee180SJérôme Glisse } 32174eee180SJérôme Glisse 32274eee180SJérôme Glisse return hmm_vma_walk->fault ? -EAGAIN : 0; 323da4c3c73SJérôme Glisse } 324da4c3c73SJérôme Glisse 325da4c3c73SJérôme Glisse static int hmm_vma_walk_clear(unsigned long addr, 326da4c3c73SJérôme Glisse unsigned long end, 327da4c3c73SJérôme Glisse struct mm_walk *walk) 328da4c3c73SJérôme Glisse { 32974eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 33074eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 331da4c3c73SJérôme Glisse hmm_pfn_t *pfns = range->pfns; 332da4c3c73SJérôme Glisse unsigned long i; 333da4c3c73SJérôme Glisse 33474eee180SJérôme Glisse hmm_vma_walk->last = addr; 335da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 33674eee180SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) { 337da4c3c73SJérôme Glisse pfns[i] = 0; 33874eee180SJérôme Glisse if (hmm_vma_walk->fault) { 33974eee180SJérôme Glisse int ret; 340da4c3c73SJérôme Glisse 34174eee180SJérôme Glisse ret = hmm_vma_do_fault(walk, addr, &pfns[i]); 34274eee180SJérôme Glisse if (ret != -EAGAIN) 34374eee180SJérôme Glisse return ret; 34474eee180SJérôme Glisse } 34574eee180SJérôme Glisse } 34674eee180SJérôme Glisse 34774eee180SJérôme Glisse return hmm_vma_walk->fault ? -EAGAIN : 0; 348da4c3c73SJérôme Glisse } 349da4c3c73SJérôme Glisse 350da4c3c73SJérôme Glisse static int hmm_vma_walk_pmd(pmd_t *pmdp, 351da4c3c73SJérôme Glisse unsigned long start, 352da4c3c73SJérôme Glisse unsigned long end, 353da4c3c73SJérôme Glisse struct mm_walk *walk) 354da4c3c73SJérôme Glisse { 35574eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 35674eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 357da4c3c73SJérôme Glisse struct vm_area_struct *vma = walk->vma; 358da4c3c73SJérôme Glisse hmm_pfn_t *pfns = range->pfns; 359da4c3c73SJérôme Glisse unsigned long addr = start, i; 36074eee180SJérôme Glisse bool write_fault; 361da4c3c73SJérôme Glisse hmm_pfn_t flag; 362da4c3c73SJérôme Glisse pte_t *ptep; 363da4c3c73SJérôme Glisse 364da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 365da4c3c73SJérôme Glisse flag = vma->vm_flags & VM_READ ? HMM_PFN_READ : 0; 36674eee180SJérôme Glisse write_fault = hmm_vma_walk->fault & hmm_vma_walk->write; 367da4c3c73SJérôme Glisse 368da4c3c73SJérôme Glisse again: 369da4c3c73SJérôme Glisse if (pmd_none(*pmdp)) 370da4c3c73SJérôme Glisse return hmm_vma_walk_hole(start, end, walk); 371da4c3c73SJérôme Glisse 372da4c3c73SJérôme Glisse if (pmd_huge(*pmdp) && vma->vm_flags & VM_HUGETLB) 373da4c3c73SJérôme Glisse return hmm_pfns_bad(start, end, walk); 374da4c3c73SJérôme Glisse 375da4c3c73SJérôme Glisse if (pmd_devmap(*pmdp) || pmd_trans_huge(*pmdp)) { 376da4c3c73SJérôme Glisse unsigned long pfn; 377da4c3c73SJérôme Glisse pmd_t pmd; 378da4c3c73SJérôme Glisse 379da4c3c73SJérôme Glisse /* 380da4c3c73SJérôme Glisse * No need to take pmd_lock here, even if some other threads 381da4c3c73SJérôme Glisse * is splitting the huge pmd we will get that event through 382da4c3c73SJérôme Glisse * mmu_notifier callback. 383da4c3c73SJérôme Glisse * 384da4c3c73SJérôme Glisse * So just read pmd value and check again its a transparent 385da4c3c73SJérôme Glisse * huge or device mapping one and compute corresponding pfn 386da4c3c73SJérôme Glisse * values. 387da4c3c73SJérôme Glisse */ 388da4c3c73SJérôme Glisse pmd = pmd_read_atomic(pmdp); 389da4c3c73SJérôme Glisse barrier(); 390da4c3c73SJérôme Glisse if (!pmd_devmap(pmd) && !pmd_trans_huge(pmd)) 391da4c3c73SJérôme Glisse goto again; 392da4c3c73SJérôme Glisse if (pmd_protnone(pmd)) 393da4c3c73SJérôme Glisse return hmm_vma_walk_clear(start, end, walk); 394da4c3c73SJérôme Glisse 39574eee180SJérôme Glisse if (write_fault && !pmd_write(pmd)) 39674eee180SJérôme Glisse return hmm_vma_walk_clear(start, end, walk); 39774eee180SJérôme Glisse 398da4c3c73SJérôme Glisse pfn = pmd_pfn(pmd) + pte_index(addr); 399da4c3c73SJérôme Glisse flag |= pmd_write(pmd) ? HMM_PFN_WRITE : 0; 400da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++, pfn++) 401da4c3c73SJérôme Glisse pfns[i] = hmm_pfn_t_from_pfn(pfn) | flag; 402da4c3c73SJérôme Glisse return 0; 403da4c3c73SJérôme Glisse } 404da4c3c73SJérôme Glisse 405da4c3c73SJérôme Glisse if (pmd_bad(*pmdp)) 406da4c3c73SJérôme Glisse return hmm_pfns_bad(start, end, walk); 407da4c3c73SJérôme Glisse 408da4c3c73SJérôme Glisse ptep = pte_offset_map(pmdp, addr); 409da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, ptep++, i++) { 410da4c3c73SJérôme Glisse pte_t pte = *ptep; 411da4c3c73SJérôme Glisse 412da4c3c73SJérôme Glisse pfns[i] = 0; 413da4c3c73SJérôme Glisse 41474eee180SJérôme Glisse if (pte_none(pte)) { 415da4c3c73SJérôme Glisse pfns[i] = HMM_PFN_EMPTY; 41674eee180SJérôme Glisse if (hmm_vma_walk->fault) 41774eee180SJérôme Glisse goto fault; 418da4c3c73SJérôme Glisse continue; 419da4c3c73SJérôme Glisse } 420da4c3c73SJérôme Glisse 42174eee180SJérôme Glisse if (!pte_present(pte)) { 42274eee180SJérôme Glisse swp_entry_t entry; 42374eee180SJérôme Glisse 42474eee180SJérôme Glisse if (!non_swap_entry(entry)) { 42574eee180SJérôme Glisse if (hmm_vma_walk->fault) 42674eee180SJérôme Glisse goto fault; 42774eee180SJérôme Glisse continue; 42874eee180SJérôme Glisse } 42974eee180SJérôme Glisse 43074eee180SJérôme Glisse entry = pte_to_swp_entry(pte); 43174eee180SJérôme Glisse 43274eee180SJérôme Glisse /* 43374eee180SJérôme Glisse * This is a special swap entry, ignore migration, use 43474eee180SJérôme Glisse * device and report anything else as error. 43574eee180SJérôme Glisse */ 4364ef589dcSJérôme Glisse if (is_device_private_entry(entry)) { 4374ef589dcSJérôme Glisse pfns[i] = hmm_pfn_t_from_pfn(swp_offset(entry)); 4384ef589dcSJérôme Glisse if (is_write_device_private_entry(entry)) { 4394ef589dcSJérôme Glisse pfns[i] |= HMM_PFN_WRITE; 4404ef589dcSJérôme Glisse } else if (write_fault) 4414ef589dcSJérôme Glisse goto fault; 4424ef589dcSJérôme Glisse pfns[i] |= HMM_PFN_DEVICE_UNADDRESSABLE; 4434ef589dcSJérôme Glisse pfns[i] |= flag; 4444ef589dcSJérôme Glisse } else if (is_migration_entry(entry)) { 44574eee180SJérôme Glisse if (hmm_vma_walk->fault) { 44674eee180SJérôme Glisse pte_unmap(ptep); 44774eee180SJérôme Glisse hmm_vma_walk->last = addr; 44874eee180SJérôme Glisse migration_entry_wait(vma->vm_mm, 44974eee180SJérôme Glisse pmdp, addr); 45074eee180SJérôme Glisse return -EAGAIN; 45174eee180SJérôme Glisse } 45274eee180SJérôme Glisse continue; 45374eee180SJérôme Glisse } else { 45474eee180SJérôme Glisse /* Report error for everything else */ 45574eee180SJérôme Glisse pfns[i] = HMM_PFN_ERROR; 45674eee180SJérôme Glisse } 45774eee180SJérôme Glisse continue; 45874eee180SJérôme Glisse } 45974eee180SJérôme Glisse 46074eee180SJérôme Glisse if (write_fault && !pte_write(pte)) 46174eee180SJérôme Glisse goto fault; 46274eee180SJérôme Glisse 463da4c3c73SJérôme Glisse pfns[i] = hmm_pfn_t_from_pfn(pte_pfn(pte)) | flag; 464da4c3c73SJérôme Glisse pfns[i] |= pte_write(pte) ? HMM_PFN_WRITE : 0; 46574eee180SJérôme Glisse continue; 46674eee180SJérôme Glisse 46774eee180SJérôme Glisse fault: 46874eee180SJérôme Glisse pte_unmap(ptep); 46974eee180SJérôme Glisse /* Fault all pages in range */ 47074eee180SJérôme Glisse return hmm_vma_walk_clear(start, end, walk); 471da4c3c73SJérôme Glisse } 472da4c3c73SJérôme Glisse pte_unmap(ptep - 1); 473da4c3c73SJérôme Glisse 474da4c3c73SJérôme Glisse return 0; 475da4c3c73SJérôme Glisse } 476da4c3c73SJérôme Glisse 477da4c3c73SJérôme Glisse /* 478da4c3c73SJérôme Glisse * hmm_vma_get_pfns() - snapshot CPU page table for a range of virtual addresses 479da4c3c73SJérôme Glisse * @vma: virtual memory area containing the virtual address range 480da4c3c73SJérôme Glisse * @range: used to track snapshot validity 481da4c3c73SJérôme Glisse * @start: range virtual start address (inclusive) 482da4c3c73SJérôme Glisse * @end: range virtual end address (exclusive) 483da4c3c73SJérôme Glisse * @entries: array of hmm_pfn_t: provided by the caller, filled in by function 484da4c3c73SJérôme Glisse * Returns: -EINVAL if invalid argument, -ENOMEM out of memory, 0 success 485da4c3c73SJérôme Glisse * 486da4c3c73SJérôme Glisse * This snapshots the CPU page table for a range of virtual addresses. Snapshot 487da4c3c73SJérôme Glisse * validity is tracked by range struct. See hmm_vma_range_done() for further 488da4c3c73SJérôme Glisse * information. 489da4c3c73SJérôme Glisse * 490da4c3c73SJérôme Glisse * The range struct is initialized here. It tracks the CPU page table, but only 491da4c3c73SJérôme Glisse * if the function returns success (0), in which case the caller must then call 492da4c3c73SJérôme Glisse * hmm_vma_range_done() to stop CPU page table update tracking on this range. 493da4c3c73SJérôme Glisse * 494da4c3c73SJérôme Glisse * NOT CALLING hmm_vma_range_done() IF FUNCTION RETURNS 0 WILL LEAD TO SERIOUS 495da4c3c73SJérôme Glisse * MEMORY CORRUPTION ! YOU HAVE BEEN WARNED ! 496da4c3c73SJérôme Glisse */ 497da4c3c73SJérôme Glisse int hmm_vma_get_pfns(struct vm_area_struct *vma, 498da4c3c73SJérôme Glisse struct hmm_range *range, 499da4c3c73SJérôme Glisse unsigned long start, 500da4c3c73SJérôme Glisse unsigned long end, 501da4c3c73SJérôme Glisse hmm_pfn_t *pfns) 502da4c3c73SJérôme Glisse { 50374eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 504da4c3c73SJérôme Glisse struct mm_walk mm_walk; 505da4c3c73SJérôme Glisse struct hmm *hmm; 506da4c3c73SJérôme Glisse 507da4c3c73SJérôme Glisse /* FIXME support hugetlb fs */ 508da4c3c73SJérôme Glisse if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL)) { 509da4c3c73SJérôme Glisse hmm_pfns_special(pfns, start, end); 510da4c3c73SJérôme Glisse return -EINVAL; 511da4c3c73SJérôme Glisse } 512da4c3c73SJérôme Glisse 513da4c3c73SJérôme Glisse /* Sanity check, this really should not happen ! */ 514da4c3c73SJérôme Glisse if (start < vma->vm_start || start >= vma->vm_end) 515da4c3c73SJérôme Glisse return -EINVAL; 516da4c3c73SJérôme Glisse if (end < vma->vm_start || end > vma->vm_end) 517da4c3c73SJérôme Glisse return -EINVAL; 518da4c3c73SJérôme Glisse 519da4c3c73SJérôme Glisse hmm = hmm_register(vma->vm_mm); 520da4c3c73SJérôme Glisse if (!hmm) 521da4c3c73SJérôme Glisse return -ENOMEM; 522da4c3c73SJérôme Glisse /* Caller must have registered a mirror, via hmm_mirror_register() ! */ 523da4c3c73SJérôme Glisse if (!hmm->mmu_notifier.ops) 524da4c3c73SJérôme Glisse return -EINVAL; 525da4c3c73SJérôme Glisse 526da4c3c73SJérôme Glisse /* Initialize range to track CPU page table update */ 527da4c3c73SJérôme Glisse range->start = start; 528da4c3c73SJérôme Glisse range->pfns = pfns; 529da4c3c73SJérôme Glisse range->end = end; 530da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 531da4c3c73SJérôme Glisse range->valid = true; 532da4c3c73SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 533da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 534da4c3c73SJérôme Glisse 53574eee180SJérôme Glisse hmm_vma_walk.fault = false; 53674eee180SJérôme Glisse hmm_vma_walk.range = range; 53774eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 53874eee180SJérôme Glisse 539da4c3c73SJérôme Glisse mm_walk.vma = vma; 540da4c3c73SJérôme Glisse mm_walk.mm = vma->vm_mm; 541da4c3c73SJérôme Glisse mm_walk.pte_entry = NULL; 542da4c3c73SJérôme Glisse mm_walk.test_walk = NULL; 543da4c3c73SJérôme Glisse mm_walk.hugetlb_entry = NULL; 544da4c3c73SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 545da4c3c73SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 546da4c3c73SJérôme Glisse 547da4c3c73SJérôme Glisse walk_page_range(start, end, &mm_walk); 548da4c3c73SJérôme Glisse return 0; 549da4c3c73SJérôme Glisse } 550da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_get_pfns); 551da4c3c73SJérôme Glisse 552da4c3c73SJérôme Glisse /* 553da4c3c73SJérôme Glisse * hmm_vma_range_done() - stop tracking change to CPU page table over a range 554da4c3c73SJérôme Glisse * @vma: virtual memory area containing the virtual address range 555da4c3c73SJérôme Glisse * @range: range being tracked 556da4c3c73SJérôme Glisse * Returns: false if range data has been invalidated, true otherwise 557da4c3c73SJérôme Glisse * 558da4c3c73SJérôme Glisse * Range struct is used to track updates to the CPU page table after a call to 559da4c3c73SJérôme Glisse * either hmm_vma_get_pfns() or hmm_vma_fault(). Once the device driver is done 560da4c3c73SJérôme Glisse * using the data, or wants to lock updates to the data it got from those 561da4c3c73SJérôme Glisse * functions, it must call the hmm_vma_range_done() function, which will then 562da4c3c73SJérôme Glisse * stop tracking CPU page table updates. 563da4c3c73SJérôme Glisse * 564da4c3c73SJérôme Glisse * Note that device driver must still implement general CPU page table update 565da4c3c73SJérôme Glisse * tracking either by using hmm_mirror (see hmm_mirror_register()) or by using 566da4c3c73SJérôme Glisse * the mmu_notifier API directly. 567da4c3c73SJérôme Glisse * 568da4c3c73SJérôme Glisse * CPU page table update tracking done through hmm_range is only temporary and 569da4c3c73SJérôme Glisse * to be used while trying to duplicate CPU page table contents for a range of 570da4c3c73SJérôme Glisse * virtual addresses. 571da4c3c73SJérôme Glisse * 572da4c3c73SJérôme Glisse * There are two ways to use this : 573da4c3c73SJérôme Glisse * again: 57474eee180SJérôme Glisse * hmm_vma_get_pfns(vma, range, start, end, pfns); or hmm_vma_fault(...); 575da4c3c73SJérôme Glisse * trans = device_build_page_table_update_transaction(pfns); 576da4c3c73SJérôme Glisse * device_page_table_lock(); 577da4c3c73SJérôme Glisse * if (!hmm_vma_range_done(vma, range)) { 578da4c3c73SJérôme Glisse * device_page_table_unlock(); 579da4c3c73SJérôme Glisse * goto again; 580da4c3c73SJérôme Glisse * } 581da4c3c73SJérôme Glisse * device_commit_transaction(trans); 582da4c3c73SJérôme Glisse * device_page_table_unlock(); 583da4c3c73SJérôme Glisse * 584da4c3c73SJérôme Glisse * Or: 58574eee180SJérôme Glisse * hmm_vma_get_pfns(vma, range, start, end, pfns); or hmm_vma_fault(...); 586da4c3c73SJérôme Glisse * device_page_table_lock(); 587da4c3c73SJérôme Glisse * hmm_vma_range_done(vma, range); 588da4c3c73SJérôme Glisse * device_update_page_table(pfns); 589da4c3c73SJérôme Glisse * device_page_table_unlock(); 590da4c3c73SJérôme Glisse */ 591da4c3c73SJérôme Glisse bool hmm_vma_range_done(struct vm_area_struct *vma, struct hmm_range *range) 592da4c3c73SJérôme Glisse { 593da4c3c73SJérôme Glisse unsigned long npages = (range->end - range->start) >> PAGE_SHIFT; 594da4c3c73SJérôme Glisse struct hmm *hmm; 595da4c3c73SJérôme Glisse 596da4c3c73SJérôme Glisse if (range->end <= range->start) { 597da4c3c73SJérôme Glisse BUG(); 598da4c3c73SJérôme Glisse return false; 599da4c3c73SJérôme Glisse } 600da4c3c73SJérôme Glisse 601da4c3c73SJérôme Glisse hmm = hmm_register(vma->vm_mm); 602da4c3c73SJérôme Glisse if (!hmm) { 603da4c3c73SJérôme Glisse memset(range->pfns, 0, sizeof(*range->pfns) * npages); 604da4c3c73SJérôme Glisse return false; 605da4c3c73SJérôme Glisse } 606da4c3c73SJérôme Glisse 607da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 608da4c3c73SJérôme Glisse list_del_rcu(&range->list); 609da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 610da4c3c73SJérôme Glisse 611da4c3c73SJérôme Glisse return range->valid; 612da4c3c73SJérôme Glisse } 613da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_range_done); 61474eee180SJérôme Glisse 61574eee180SJérôme Glisse /* 61674eee180SJérôme Glisse * hmm_vma_fault() - try to fault some address in a virtual address range 61774eee180SJérôme Glisse * @vma: virtual memory area containing the virtual address range 61874eee180SJérôme Glisse * @range: use to track pfns array content validity 61974eee180SJérôme Glisse * @start: fault range virtual start address (inclusive) 62074eee180SJérôme Glisse * @end: fault range virtual end address (exclusive) 62174eee180SJérôme Glisse * @pfns: array of hmm_pfn_t, only entry with fault flag set will be faulted 62274eee180SJérôme Glisse * @write: is it a write fault 62374eee180SJérôme Glisse * @block: allow blocking on fault (if true it sleeps and do not drop mmap_sem) 62474eee180SJérôme Glisse * Returns: 0 success, error otherwise (-EAGAIN means mmap_sem have been drop) 62574eee180SJérôme Glisse * 62674eee180SJérôme Glisse * This is similar to a regular CPU page fault except that it will not trigger 62774eee180SJérôme Glisse * any memory migration if the memory being faulted is not accessible by CPUs. 62874eee180SJérôme Glisse * 62974eee180SJérôme Glisse * On error, for one virtual address in the range, the function will set the 63074eee180SJérôme Glisse * hmm_pfn_t error flag for the corresponding pfn entry. 63174eee180SJérôme Glisse * 63274eee180SJérôme Glisse * Expected use pattern: 63374eee180SJérôme Glisse * retry: 63474eee180SJérôme Glisse * down_read(&mm->mmap_sem); 63574eee180SJérôme Glisse * // Find vma and address device wants to fault, initialize hmm_pfn_t 63674eee180SJérôme Glisse * // array accordingly 63774eee180SJérôme Glisse * ret = hmm_vma_fault(vma, start, end, pfns, allow_retry); 63874eee180SJérôme Glisse * switch (ret) { 63974eee180SJérôme Glisse * case -EAGAIN: 64074eee180SJérôme Glisse * hmm_vma_range_done(vma, range); 64174eee180SJérôme Glisse * // You might want to rate limit or yield to play nicely, you may 64274eee180SJérôme Glisse * // also commit any valid pfn in the array assuming that you are 64374eee180SJérôme Glisse * // getting true from hmm_vma_range_monitor_end() 64474eee180SJérôme Glisse * goto retry; 64574eee180SJérôme Glisse * case 0: 64674eee180SJérôme Glisse * break; 64774eee180SJérôme Glisse * default: 64874eee180SJérôme Glisse * // Handle error ! 64974eee180SJérôme Glisse * up_read(&mm->mmap_sem) 65074eee180SJérôme Glisse * return; 65174eee180SJérôme Glisse * } 65274eee180SJérôme Glisse * // Take device driver lock that serialize device page table update 65374eee180SJérôme Glisse * driver_lock_device_page_table_update(); 65474eee180SJérôme Glisse * hmm_vma_range_done(vma, range); 65574eee180SJérôme Glisse * // Commit pfns we got from hmm_vma_fault() 65674eee180SJérôme Glisse * driver_unlock_device_page_table_update(); 65774eee180SJérôme Glisse * up_read(&mm->mmap_sem) 65874eee180SJérôme Glisse * 65974eee180SJérôme Glisse * YOU MUST CALL hmm_vma_range_done() AFTER THIS FUNCTION RETURN SUCCESS (0) 66074eee180SJérôme Glisse * BEFORE FREEING THE range struct OR YOU WILL HAVE SERIOUS MEMORY CORRUPTION ! 66174eee180SJérôme Glisse * 66274eee180SJérôme Glisse * YOU HAVE BEEN WARNED ! 66374eee180SJérôme Glisse */ 66474eee180SJérôme Glisse int hmm_vma_fault(struct vm_area_struct *vma, 66574eee180SJérôme Glisse struct hmm_range *range, 66674eee180SJérôme Glisse unsigned long start, 66774eee180SJérôme Glisse unsigned long end, 66874eee180SJérôme Glisse hmm_pfn_t *pfns, 66974eee180SJérôme Glisse bool write, 67074eee180SJérôme Glisse bool block) 67174eee180SJérôme Glisse { 67274eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 67374eee180SJérôme Glisse struct mm_walk mm_walk; 67474eee180SJérôme Glisse struct hmm *hmm; 67574eee180SJérôme Glisse int ret; 67674eee180SJérôme Glisse 67774eee180SJérôme Glisse /* Sanity check, this really should not happen ! */ 67874eee180SJérôme Glisse if (start < vma->vm_start || start >= vma->vm_end) 67974eee180SJérôme Glisse return -EINVAL; 68074eee180SJérôme Glisse if (end < vma->vm_start || end > vma->vm_end) 68174eee180SJérôme Glisse return -EINVAL; 68274eee180SJérôme Glisse 68374eee180SJérôme Glisse hmm = hmm_register(vma->vm_mm); 68474eee180SJérôme Glisse if (!hmm) { 68574eee180SJérôme Glisse hmm_pfns_clear(pfns, start, end); 68674eee180SJérôme Glisse return -ENOMEM; 68774eee180SJérôme Glisse } 68874eee180SJérôme Glisse /* Caller must have registered a mirror using hmm_mirror_register() */ 68974eee180SJérôme Glisse if (!hmm->mmu_notifier.ops) 69074eee180SJérôme Glisse return -EINVAL; 69174eee180SJérôme Glisse 69274eee180SJérôme Glisse /* Initialize range to track CPU page table update */ 69374eee180SJérôme Glisse range->start = start; 69474eee180SJérôme Glisse range->pfns = pfns; 69574eee180SJérôme Glisse range->end = end; 69674eee180SJérôme Glisse spin_lock(&hmm->lock); 69774eee180SJérôme Glisse range->valid = true; 69874eee180SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 69974eee180SJérôme Glisse spin_unlock(&hmm->lock); 70074eee180SJérôme Glisse 70174eee180SJérôme Glisse /* FIXME support hugetlb fs */ 70274eee180SJérôme Glisse if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL)) { 70374eee180SJérôme Glisse hmm_pfns_special(pfns, start, end); 70474eee180SJérôme Glisse return 0; 70574eee180SJérôme Glisse } 70674eee180SJérôme Glisse 70774eee180SJérôme Glisse hmm_vma_walk.fault = true; 70874eee180SJérôme Glisse hmm_vma_walk.write = write; 70974eee180SJérôme Glisse hmm_vma_walk.block = block; 71074eee180SJérôme Glisse hmm_vma_walk.range = range; 71174eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 71274eee180SJérôme Glisse hmm_vma_walk.last = range->start; 71374eee180SJérôme Glisse 71474eee180SJérôme Glisse mm_walk.vma = vma; 71574eee180SJérôme Glisse mm_walk.mm = vma->vm_mm; 71674eee180SJérôme Glisse mm_walk.pte_entry = NULL; 71774eee180SJérôme Glisse mm_walk.test_walk = NULL; 71874eee180SJérôme Glisse mm_walk.hugetlb_entry = NULL; 71974eee180SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 72074eee180SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 72174eee180SJérôme Glisse 72274eee180SJérôme Glisse do { 72374eee180SJérôme Glisse ret = walk_page_range(start, end, &mm_walk); 72474eee180SJérôme Glisse start = hmm_vma_walk.last; 72574eee180SJérôme Glisse } while (ret == -EAGAIN); 72674eee180SJérôme Glisse 72774eee180SJérôme Glisse if (ret) { 72874eee180SJérôme Glisse unsigned long i; 72974eee180SJérôme Glisse 73074eee180SJérôme Glisse i = (hmm_vma_walk.last - range->start) >> PAGE_SHIFT; 73174eee180SJérôme Glisse hmm_pfns_clear(&pfns[i], hmm_vma_walk.last, end); 73274eee180SJérôme Glisse hmm_vma_range_done(vma, range); 73374eee180SJérôme Glisse } 73474eee180SJérôme Glisse return ret; 73574eee180SJérôme Glisse } 73674eee180SJérôme Glisse EXPORT_SYMBOL(hmm_vma_fault); 737c0b12405SJérôme Glisse #endif /* IS_ENABLED(CONFIG_HMM_MIRROR) */ 7384ef589dcSJérôme Glisse 7394ef589dcSJérôme Glisse 740*df6ad698SJérôme Glisse #if IS_ENABLED(CONFIG_DEVICE_PRIVATE) || IS_ENABLED(CONFIG_DEVICE_PUBLIC) 7414ef589dcSJérôme Glisse struct page *hmm_vma_alloc_locked_page(struct vm_area_struct *vma, 7424ef589dcSJérôme Glisse unsigned long addr) 7434ef589dcSJérôme Glisse { 7444ef589dcSJérôme Glisse struct page *page; 7454ef589dcSJérôme Glisse 7464ef589dcSJérôme Glisse page = alloc_page_vma(GFP_HIGHUSER, vma, addr); 7474ef589dcSJérôme Glisse if (!page) 7484ef589dcSJérôme Glisse return NULL; 7494ef589dcSJérôme Glisse lock_page(page); 7504ef589dcSJérôme Glisse return page; 7514ef589dcSJérôme Glisse } 7524ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_vma_alloc_locked_page); 7534ef589dcSJérôme Glisse 7544ef589dcSJérôme Glisse 7554ef589dcSJérôme Glisse static void hmm_devmem_ref_release(struct percpu_ref *ref) 7564ef589dcSJérôme Glisse { 7574ef589dcSJérôme Glisse struct hmm_devmem *devmem; 7584ef589dcSJérôme Glisse 7594ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 7604ef589dcSJérôme Glisse complete(&devmem->completion); 7614ef589dcSJérôme Glisse } 7624ef589dcSJérôme Glisse 7634ef589dcSJérôme Glisse static void hmm_devmem_ref_exit(void *data) 7644ef589dcSJérôme Glisse { 7654ef589dcSJérôme Glisse struct percpu_ref *ref = data; 7664ef589dcSJérôme Glisse struct hmm_devmem *devmem; 7674ef589dcSJérôme Glisse 7684ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 7694ef589dcSJérôme Glisse percpu_ref_exit(ref); 7704ef589dcSJérôme Glisse devm_remove_action(devmem->device, &hmm_devmem_ref_exit, data); 7714ef589dcSJérôme Glisse } 7724ef589dcSJérôme Glisse 7734ef589dcSJérôme Glisse static void hmm_devmem_ref_kill(void *data) 7744ef589dcSJérôme Glisse { 7754ef589dcSJérôme Glisse struct percpu_ref *ref = data; 7764ef589dcSJérôme Glisse struct hmm_devmem *devmem; 7774ef589dcSJérôme Glisse 7784ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 7794ef589dcSJérôme Glisse percpu_ref_kill(ref); 7804ef589dcSJérôme Glisse wait_for_completion(&devmem->completion); 7814ef589dcSJérôme Glisse devm_remove_action(devmem->device, &hmm_devmem_ref_kill, data); 7824ef589dcSJérôme Glisse } 7834ef589dcSJérôme Glisse 7844ef589dcSJérôme Glisse static int hmm_devmem_fault(struct vm_area_struct *vma, 7854ef589dcSJérôme Glisse unsigned long addr, 7864ef589dcSJérôme Glisse const struct page *page, 7874ef589dcSJérôme Glisse unsigned int flags, 7884ef589dcSJérôme Glisse pmd_t *pmdp) 7894ef589dcSJérôme Glisse { 7904ef589dcSJérôme Glisse struct hmm_devmem *devmem = page->pgmap->data; 7914ef589dcSJérôme Glisse 7924ef589dcSJérôme Glisse return devmem->ops->fault(devmem, vma, addr, page, flags, pmdp); 7934ef589dcSJérôme Glisse } 7944ef589dcSJérôme Glisse 7954ef589dcSJérôme Glisse static void hmm_devmem_free(struct page *page, void *data) 7964ef589dcSJérôme Glisse { 7974ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 7984ef589dcSJérôme Glisse 7994ef589dcSJérôme Glisse devmem->ops->free(devmem, page); 8004ef589dcSJérôme Glisse } 8014ef589dcSJérôme Glisse 8024ef589dcSJérôme Glisse static DEFINE_MUTEX(hmm_devmem_lock); 8034ef589dcSJérôme Glisse static RADIX_TREE(hmm_devmem_radix, GFP_KERNEL); 8044ef589dcSJérôme Glisse 8054ef589dcSJérôme Glisse static void hmm_devmem_radix_release(struct resource *resource) 8064ef589dcSJérôme Glisse { 8074ef589dcSJérôme Glisse resource_size_t key, align_start, align_size, align_end; 8084ef589dcSJérôme Glisse 8094ef589dcSJérôme Glisse align_start = resource->start & ~(PA_SECTION_SIZE - 1); 8104ef589dcSJérôme Glisse align_size = ALIGN(resource_size(resource), PA_SECTION_SIZE); 8114ef589dcSJérôme Glisse align_end = align_start + align_size - 1; 8124ef589dcSJérôme Glisse 8134ef589dcSJérôme Glisse mutex_lock(&hmm_devmem_lock); 8144ef589dcSJérôme Glisse for (key = resource->start; 8154ef589dcSJérôme Glisse key <= resource->end; 8164ef589dcSJérôme Glisse key += PA_SECTION_SIZE) 8174ef589dcSJérôme Glisse radix_tree_delete(&hmm_devmem_radix, key >> PA_SECTION_SHIFT); 8184ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 8194ef589dcSJérôme Glisse } 8204ef589dcSJérôme Glisse 8214ef589dcSJérôme Glisse static void hmm_devmem_release(struct device *dev, void *data) 8224ef589dcSJérôme Glisse { 8234ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 8244ef589dcSJérôme Glisse struct resource *resource = devmem->resource; 8254ef589dcSJérôme Glisse unsigned long start_pfn, npages; 8264ef589dcSJérôme Glisse struct zone *zone; 8274ef589dcSJérôme Glisse struct page *page; 8284ef589dcSJérôme Glisse 8294ef589dcSJérôme Glisse if (percpu_ref_tryget_live(&devmem->ref)) { 8304ef589dcSJérôme Glisse dev_WARN(dev, "%s: page mapping is still live!\n", __func__); 8314ef589dcSJérôme Glisse percpu_ref_put(&devmem->ref); 8324ef589dcSJérôme Glisse } 8334ef589dcSJérôme Glisse 8344ef589dcSJérôme Glisse /* pages are dead and unused, undo the arch mapping */ 8354ef589dcSJérôme Glisse start_pfn = (resource->start & ~(PA_SECTION_SIZE - 1)) >> PAGE_SHIFT; 8364ef589dcSJérôme Glisse npages = ALIGN(resource_size(resource), PA_SECTION_SIZE) >> PAGE_SHIFT; 8374ef589dcSJérôme Glisse 8384ef589dcSJérôme Glisse page = pfn_to_page(start_pfn); 8394ef589dcSJérôme Glisse zone = page_zone(page); 8404ef589dcSJérôme Glisse 8414ef589dcSJérôme Glisse mem_hotplug_begin(); 8424ef589dcSJérôme Glisse __remove_pages(zone, start_pfn, npages); 8434ef589dcSJérôme Glisse mem_hotplug_done(); 8444ef589dcSJérôme Glisse 8454ef589dcSJérôme Glisse hmm_devmem_radix_release(resource); 8464ef589dcSJérôme Glisse } 8474ef589dcSJérôme Glisse 8484ef589dcSJérôme Glisse static struct hmm_devmem *hmm_devmem_find(resource_size_t phys) 8494ef589dcSJérôme Glisse { 8504ef589dcSJérôme Glisse WARN_ON_ONCE(!rcu_read_lock_held()); 8514ef589dcSJérôme Glisse 8524ef589dcSJérôme Glisse return radix_tree_lookup(&hmm_devmem_radix, phys >> PA_SECTION_SHIFT); 8534ef589dcSJérôme Glisse } 8544ef589dcSJérôme Glisse 8554ef589dcSJérôme Glisse static int hmm_devmem_pages_create(struct hmm_devmem *devmem) 8564ef589dcSJérôme Glisse { 8574ef589dcSJérôme Glisse resource_size_t key, align_start, align_size, align_end; 8584ef589dcSJérôme Glisse struct device *device = devmem->device; 8594ef589dcSJérôme Glisse int ret, nid, is_ram; 8604ef589dcSJérôme Glisse unsigned long pfn; 8614ef589dcSJérôme Glisse 8624ef589dcSJérôme Glisse align_start = devmem->resource->start & ~(PA_SECTION_SIZE - 1); 8634ef589dcSJérôme Glisse align_size = ALIGN(devmem->resource->start + 8644ef589dcSJérôme Glisse resource_size(devmem->resource), 8654ef589dcSJérôme Glisse PA_SECTION_SIZE) - align_start; 8664ef589dcSJérôme Glisse 8674ef589dcSJérôme Glisse is_ram = region_intersects(align_start, align_size, 8684ef589dcSJérôme Glisse IORESOURCE_SYSTEM_RAM, 8694ef589dcSJérôme Glisse IORES_DESC_NONE); 8704ef589dcSJérôme Glisse if (is_ram == REGION_MIXED) { 8714ef589dcSJérôme Glisse WARN_ONCE(1, "%s attempted on mixed region %pr\n", 8724ef589dcSJérôme Glisse __func__, devmem->resource); 8734ef589dcSJérôme Glisse return -ENXIO; 8744ef589dcSJérôme Glisse } 8754ef589dcSJérôme Glisse if (is_ram == REGION_INTERSECTS) 8764ef589dcSJérôme Glisse return -ENXIO; 8774ef589dcSJérôme Glisse 8784ef589dcSJérôme Glisse devmem->pagemap.type = MEMORY_DEVICE_PRIVATE; 8794ef589dcSJérôme Glisse devmem->pagemap.res = devmem->resource; 8804ef589dcSJérôme Glisse devmem->pagemap.page_fault = hmm_devmem_fault; 8814ef589dcSJérôme Glisse devmem->pagemap.page_free = hmm_devmem_free; 8824ef589dcSJérôme Glisse devmem->pagemap.dev = devmem->device; 8834ef589dcSJérôme Glisse devmem->pagemap.ref = &devmem->ref; 8844ef589dcSJérôme Glisse devmem->pagemap.data = devmem; 8854ef589dcSJérôme Glisse 8864ef589dcSJérôme Glisse mutex_lock(&hmm_devmem_lock); 8874ef589dcSJérôme Glisse align_end = align_start + align_size - 1; 8884ef589dcSJérôme Glisse for (key = align_start; key <= align_end; key += PA_SECTION_SIZE) { 8894ef589dcSJérôme Glisse struct hmm_devmem *dup; 8904ef589dcSJérôme Glisse 8914ef589dcSJérôme Glisse rcu_read_lock(); 8924ef589dcSJérôme Glisse dup = hmm_devmem_find(key); 8934ef589dcSJérôme Glisse rcu_read_unlock(); 8944ef589dcSJérôme Glisse if (dup) { 8954ef589dcSJérôme Glisse dev_err(device, "%s: collides with mapping for %s\n", 8964ef589dcSJérôme Glisse __func__, dev_name(dup->device)); 8974ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 8984ef589dcSJérôme Glisse ret = -EBUSY; 8994ef589dcSJérôme Glisse goto error; 9004ef589dcSJérôme Glisse } 9014ef589dcSJérôme Glisse ret = radix_tree_insert(&hmm_devmem_radix, 9024ef589dcSJérôme Glisse key >> PA_SECTION_SHIFT, 9034ef589dcSJérôme Glisse devmem); 9044ef589dcSJérôme Glisse if (ret) { 9054ef589dcSJérôme Glisse dev_err(device, "%s: failed: %d\n", __func__, ret); 9064ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 9074ef589dcSJérôme Glisse goto error_radix; 9084ef589dcSJérôme Glisse } 9094ef589dcSJérôme Glisse } 9104ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 9114ef589dcSJérôme Glisse 9124ef589dcSJérôme Glisse nid = dev_to_node(device); 9134ef589dcSJérôme Glisse if (nid < 0) 9144ef589dcSJérôme Glisse nid = numa_mem_id(); 9154ef589dcSJérôme Glisse 9164ef589dcSJérôme Glisse mem_hotplug_begin(); 9174ef589dcSJérôme Glisse /* 9184ef589dcSJérôme Glisse * For device private memory we call add_pages() as we only need to 9194ef589dcSJérôme Glisse * allocate and initialize struct page for the device memory. More- 9204ef589dcSJérôme Glisse * over the device memory is un-accessible thus we do not want to 9214ef589dcSJérôme Glisse * create a linear mapping for the memory like arch_add_memory() 9224ef589dcSJérôme Glisse * would do. 9234ef589dcSJérôme Glisse */ 9244ef589dcSJérôme Glisse ret = add_pages(nid, align_start >> PAGE_SHIFT, 9254ef589dcSJérôme Glisse align_size >> PAGE_SHIFT, false); 9264ef589dcSJérôme Glisse if (ret) { 9274ef589dcSJérôme Glisse mem_hotplug_done(); 9284ef589dcSJérôme Glisse goto error_add_memory; 9294ef589dcSJérôme Glisse } 9304ef589dcSJérôme Glisse move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE], 9314ef589dcSJérôme Glisse align_start >> PAGE_SHIFT, 9324ef589dcSJérôme Glisse align_size >> PAGE_SHIFT); 9334ef589dcSJérôme Glisse mem_hotplug_done(); 9344ef589dcSJérôme Glisse 9354ef589dcSJérôme Glisse for (pfn = devmem->pfn_first; pfn < devmem->pfn_last; pfn++) { 9364ef589dcSJérôme Glisse struct page *page = pfn_to_page(pfn); 9374ef589dcSJérôme Glisse 9384ef589dcSJérôme Glisse page->pgmap = &devmem->pagemap; 9394ef589dcSJérôme Glisse } 9404ef589dcSJérôme Glisse return 0; 9414ef589dcSJérôme Glisse 9424ef589dcSJérôme Glisse error_add_memory: 9434ef589dcSJérôme Glisse untrack_pfn(NULL, PHYS_PFN(align_start), align_size); 9444ef589dcSJérôme Glisse error_radix: 9454ef589dcSJérôme Glisse hmm_devmem_radix_release(devmem->resource); 9464ef589dcSJérôme Glisse error: 9474ef589dcSJérôme Glisse return ret; 9484ef589dcSJérôme Glisse } 9494ef589dcSJérôme Glisse 9504ef589dcSJérôme Glisse static int hmm_devmem_match(struct device *dev, void *data, void *match_data) 9514ef589dcSJérôme Glisse { 9524ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 9534ef589dcSJérôme Glisse 9544ef589dcSJérôme Glisse return devmem->resource == match_data; 9554ef589dcSJérôme Glisse } 9564ef589dcSJérôme Glisse 9574ef589dcSJérôme Glisse static void hmm_devmem_pages_remove(struct hmm_devmem *devmem) 9584ef589dcSJérôme Glisse { 9594ef589dcSJérôme Glisse devres_release(devmem->device, &hmm_devmem_release, 9604ef589dcSJérôme Glisse &hmm_devmem_match, devmem->resource); 9614ef589dcSJérôme Glisse } 9624ef589dcSJérôme Glisse 9634ef589dcSJérôme Glisse /* 9644ef589dcSJérôme Glisse * hmm_devmem_add() - hotplug ZONE_DEVICE memory for device memory 9654ef589dcSJérôme Glisse * 9664ef589dcSJérôme Glisse * @ops: memory event device driver callback (see struct hmm_devmem_ops) 9674ef589dcSJérôme Glisse * @device: device struct to bind the resource too 9684ef589dcSJérôme Glisse * @size: size in bytes of the device memory to add 9694ef589dcSJérôme Glisse * Returns: pointer to new hmm_devmem struct ERR_PTR otherwise 9704ef589dcSJérôme Glisse * 9714ef589dcSJérôme Glisse * This function first finds an empty range of physical address big enough to 9724ef589dcSJérôme Glisse * contain the new resource, and then hotplugs it as ZONE_DEVICE memory, which 9734ef589dcSJérôme Glisse * in turn allocates struct pages. It does not do anything beyond that; all 9744ef589dcSJérôme Glisse * events affecting the memory will go through the various callbacks provided 9754ef589dcSJérôme Glisse * by hmm_devmem_ops struct. 9764ef589dcSJérôme Glisse * 9774ef589dcSJérôme Glisse * Device driver should call this function during device initialization and 9784ef589dcSJérôme Glisse * is then responsible of memory management. HMM only provides helpers. 9794ef589dcSJérôme Glisse */ 9804ef589dcSJérôme Glisse struct hmm_devmem *hmm_devmem_add(const struct hmm_devmem_ops *ops, 9814ef589dcSJérôme Glisse struct device *device, 9824ef589dcSJérôme Glisse unsigned long size) 9834ef589dcSJérôme Glisse { 9844ef589dcSJérôme Glisse struct hmm_devmem *devmem; 9854ef589dcSJérôme Glisse resource_size_t addr; 9864ef589dcSJérôme Glisse int ret; 9874ef589dcSJérôme Glisse 9884ef589dcSJérôme Glisse static_branch_enable(&device_private_key); 9894ef589dcSJérôme Glisse 9904ef589dcSJérôme Glisse devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem), 9914ef589dcSJérôme Glisse GFP_KERNEL, dev_to_node(device)); 9924ef589dcSJérôme Glisse if (!devmem) 9934ef589dcSJérôme Glisse return ERR_PTR(-ENOMEM); 9944ef589dcSJérôme Glisse 9954ef589dcSJérôme Glisse init_completion(&devmem->completion); 9964ef589dcSJérôme Glisse devmem->pfn_first = -1UL; 9974ef589dcSJérôme Glisse devmem->pfn_last = -1UL; 9984ef589dcSJérôme Glisse devmem->resource = NULL; 9994ef589dcSJérôme Glisse devmem->device = device; 10004ef589dcSJérôme Glisse devmem->ops = ops; 10014ef589dcSJérôme Glisse 10024ef589dcSJérôme Glisse ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release, 10034ef589dcSJérôme Glisse 0, GFP_KERNEL); 10044ef589dcSJérôme Glisse if (ret) 10054ef589dcSJérôme Glisse goto error_percpu_ref; 10064ef589dcSJérôme Glisse 10074ef589dcSJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref); 10084ef589dcSJérôme Glisse if (ret) 10094ef589dcSJérôme Glisse goto error_devm_add_action; 10104ef589dcSJérôme Glisse 10114ef589dcSJérôme Glisse size = ALIGN(size, PA_SECTION_SIZE); 10124ef589dcSJérôme Glisse addr = min((unsigned long)iomem_resource.end, 10134ef589dcSJérôme Glisse (1UL << MAX_PHYSMEM_BITS) - 1); 10144ef589dcSJérôme Glisse addr = addr - size + 1UL; 10154ef589dcSJérôme Glisse 10164ef589dcSJérôme Glisse /* 10174ef589dcSJérôme Glisse * FIXME add a new helper to quickly walk resource tree and find free 10184ef589dcSJérôme Glisse * range 10194ef589dcSJérôme Glisse * 10204ef589dcSJérôme Glisse * FIXME what about ioport_resource resource ? 10214ef589dcSJérôme Glisse */ 10224ef589dcSJérôme Glisse for (; addr > size && addr >= iomem_resource.start; addr -= size) { 10234ef589dcSJérôme Glisse ret = region_intersects(addr, size, 0, IORES_DESC_NONE); 10244ef589dcSJérôme Glisse if (ret != REGION_DISJOINT) 10254ef589dcSJérôme Glisse continue; 10264ef589dcSJérôme Glisse 10274ef589dcSJérôme Glisse devmem->resource = devm_request_mem_region(device, addr, size, 10284ef589dcSJérôme Glisse dev_name(device)); 10294ef589dcSJérôme Glisse if (!devmem->resource) { 10304ef589dcSJérôme Glisse ret = -ENOMEM; 10314ef589dcSJérôme Glisse goto error_no_resource; 10324ef589dcSJérôme Glisse } 10334ef589dcSJérôme Glisse break; 10344ef589dcSJérôme Glisse } 10354ef589dcSJérôme Glisse if (!devmem->resource) { 10364ef589dcSJérôme Glisse ret = -ERANGE; 10374ef589dcSJérôme Glisse goto error_no_resource; 10384ef589dcSJérôme Glisse } 10394ef589dcSJérôme Glisse 10404ef589dcSJérôme Glisse devmem->resource->desc = IORES_DESC_DEVICE_PRIVATE_MEMORY; 10414ef589dcSJérôme Glisse devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT; 10424ef589dcSJérôme Glisse devmem->pfn_last = devmem->pfn_first + 10434ef589dcSJérôme Glisse (resource_size(devmem->resource) >> PAGE_SHIFT); 10444ef589dcSJérôme Glisse 10454ef589dcSJérôme Glisse ret = hmm_devmem_pages_create(devmem); 10464ef589dcSJérôme Glisse if (ret) 10474ef589dcSJérôme Glisse goto error_pages; 10484ef589dcSJérôme Glisse 10494ef589dcSJérôme Glisse devres_add(device, devmem); 10504ef589dcSJérôme Glisse 10514ef589dcSJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref); 10524ef589dcSJérôme Glisse if (ret) { 10534ef589dcSJérôme Glisse hmm_devmem_remove(devmem); 10544ef589dcSJérôme Glisse return ERR_PTR(ret); 10554ef589dcSJérôme Glisse } 10564ef589dcSJérôme Glisse 10574ef589dcSJérôme Glisse return devmem; 10584ef589dcSJérôme Glisse 10594ef589dcSJérôme Glisse error_pages: 10604ef589dcSJérôme Glisse devm_release_mem_region(device, devmem->resource->start, 10614ef589dcSJérôme Glisse resource_size(devmem->resource)); 10624ef589dcSJérôme Glisse error_no_resource: 10634ef589dcSJérôme Glisse error_devm_add_action: 10644ef589dcSJérôme Glisse hmm_devmem_ref_kill(&devmem->ref); 10654ef589dcSJérôme Glisse hmm_devmem_ref_exit(&devmem->ref); 10664ef589dcSJérôme Glisse error_percpu_ref: 10674ef589dcSJérôme Glisse devres_free(devmem); 10684ef589dcSJérôme Glisse return ERR_PTR(ret); 10694ef589dcSJérôme Glisse } 10704ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add); 10714ef589dcSJérôme Glisse 10724ef589dcSJérôme Glisse /* 10734ef589dcSJérôme Glisse * hmm_devmem_remove() - remove device memory (kill and free ZONE_DEVICE) 10744ef589dcSJérôme Glisse * 10754ef589dcSJérôme Glisse * @devmem: hmm_devmem struct use to track and manage the ZONE_DEVICE memory 10764ef589dcSJérôme Glisse * 10774ef589dcSJérôme Glisse * This will hot-unplug memory that was hotplugged by hmm_devmem_add on behalf 10784ef589dcSJérôme Glisse * of the device driver. It will free struct page and remove the resource that 10794ef589dcSJérôme Glisse * reserved the physical address range for this device memory. 10804ef589dcSJérôme Glisse */ 10814ef589dcSJérôme Glisse void hmm_devmem_remove(struct hmm_devmem *devmem) 10824ef589dcSJérôme Glisse { 10834ef589dcSJérôme Glisse resource_size_t start, size; 10844ef589dcSJérôme Glisse struct device *device; 10854ef589dcSJérôme Glisse 10864ef589dcSJérôme Glisse if (!devmem) 10874ef589dcSJérôme Glisse return; 10884ef589dcSJérôme Glisse 10894ef589dcSJérôme Glisse device = devmem->device; 10904ef589dcSJérôme Glisse start = devmem->resource->start; 10914ef589dcSJérôme Glisse size = resource_size(devmem->resource); 10924ef589dcSJérôme Glisse 10934ef589dcSJérôme Glisse hmm_devmem_ref_kill(&devmem->ref); 10944ef589dcSJérôme Glisse hmm_devmem_ref_exit(&devmem->ref); 10954ef589dcSJérôme Glisse hmm_devmem_pages_remove(devmem); 10964ef589dcSJérôme Glisse 10974ef589dcSJérôme Glisse devm_release_mem_region(device, start, size); 10984ef589dcSJérôme Glisse } 10994ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_remove); 1100858b54daSJérôme Glisse 1101858b54daSJérôme Glisse /* 1102858b54daSJérôme Glisse * A device driver that wants to handle multiple devices memory through a 1103858b54daSJérôme Glisse * single fake device can use hmm_device to do so. This is purely a helper 1104858b54daSJérôme Glisse * and it is not needed to make use of any HMM functionality. 1105858b54daSJérôme Glisse */ 1106858b54daSJérôme Glisse #define HMM_DEVICE_MAX 256 1107858b54daSJérôme Glisse 1108858b54daSJérôme Glisse static DECLARE_BITMAP(hmm_device_mask, HMM_DEVICE_MAX); 1109858b54daSJérôme Glisse static DEFINE_SPINLOCK(hmm_device_lock); 1110858b54daSJérôme Glisse static struct class *hmm_device_class; 1111858b54daSJérôme Glisse static dev_t hmm_device_devt; 1112858b54daSJérôme Glisse 1113858b54daSJérôme Glisse static void hmm_device_release(struct device *device) 1114858b54daSJérôme Glisse { 1115858b54daSJérôme Glisse struct hmm_device *hmm_device; 1116858b54daSJérôme Glisse 1117858b54daSJérôme Glisse hmm_device = container_of(device, struct hmm_device, device); 1118858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1119858b54daSJérôme Glisse clear_bit(hmm_device->minor, hmm_device_mask); 1120858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1121858b54daSJérôme Glisse 1122858b54daSJérôme Glisse kfree(hmm_device); 1123858b54daSJérôme Glisse } 1124858b54daSJérôme Glisse 1125858b54daSJérôme Glisse struct hmm_device *hmm_device_new(void *drvdata) 1126858b54daSJérôme Glisse { 1127858b54daSJérôme Glisse struct hmm_device *hmm_device; 1128858b54daSJérôme Glisse 1129858b54daSJérôme Glisse hmm_device = kzalloc(sizeof(*hmm_device), GFP_KERNEL); 1130858b54daSJérôme Glisse if (!hmm_device) 1131858b54daSJérôme Glisse return ERR_PTR(-ENOMEM); 1132858b54daSJérôme Glisse 1133858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1134858b54daSJérôme Glisse hmm_device->minor = find_first_zero_bit(hmm_device_mask, HMM_DEVICE_MAX); 1135858b54daSJérôme Glisse if (hmm_device->minor >= HMM_DEVICE_MAX) { 1136858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1137858b54daSJérôme Glisse kfree(hmm_device); 1138858b54daSJérôme Glisse return ERR_PTR(-EBUSY); 1139858b54daSJérôme Glisse } 1140858b54daSJérôme Glisse set_bit(hmm_device->minor, hmm_device_mask); 1141858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1142858b54daSJérôme Glisse 1143858b54daSJérôme Glisse dev_set_name(&hmm_device->device, "hmm_device%d", hmm_device->minor); 1144858b54daSJérôme Glisse hmm_device->device.devt = MKDEV(MAJOR(hmm_device_devt), 1145858b54daSJérôme Glisse hmm_device->minor); 1146858b54daSJérôme Glisse hmm_device->device.release = hmm_device_release; 1147858b54daSJérôme Glisse dev_set_drvdata(&hmm_device->device, drvdata); 1148858b54daSJérôme Glisse hmm_device->device.class = hmm_device_class; 1149858b54daSJérôme Glisse device_initialize(&hmm_device->device); 1150858b54daSJérôme Glisse 1151858b54daSJérôme Glisse return hmm_device; 1152858b54daSJérôme Glisse } 1153858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_new); 1154858b54daSJérôme Glisse 1155858b54daSJérôme Glisse void hmm_device_put(struct hmm_device *hmm_device) 1156858b54daSJérôme Glisse { 1157858b54daSJérôme Glisse put_device(&hmm_device->device); 1158858b54daSJérôme Glisse } 1159858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_put); 1160858b54daSJérôme Glisse 1161858b54daSJérôme Glisse static int __init hmm_init(void) 1162858b54daSJérôme Glisse { 1163858b54daSJérôme Glisse int ret; 1164858b54daSJérôme Glisse 1165858b54daSJérôme Glisse ret = alloc_chrdev_region(&hmm_device_devt, 0, 1166858b54daSJérôme Glisse HMM_DEVICE_MAX, 1167858b54daSJérôme Glisse "hmm_device"); 1168858b54daSJérôme Glisse if (ret) 1169858b54daSJérôme Glisse return ret; 1170858b54daSJérôme Glisse 1171858b54daSJérôme Glisse hmm_device_class = class_create(THIS_MODULE, "hmm_device"); 1172858b54daSJérôme Glisse if (IS_ERR(hmm_device_class)) { 1173858b54daSJérôme Glisse unregister_chrdev_region(hmm_device_devt, HMM_DEVICE_MAX); 1174858b54daSJérôme Glisse return PTR_ERR(hmm_device_class); 1175858b54daSJérôme Glisse } 1176858b54daSJérôme Glisse return 0; 1177858b54daSJérôme Glisse } 1178858b54daSJérôme Glisse 1179858b54daSJérôme Glisse device_initcall(hmm_init); 1180*df6ad698SJérôme Glisse #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */ 1181