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 * 14f813f219SJé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 386b368cd4SJérôme Glisse #if IS_ENABLED(CONFIG_HMM_MIRROR) 39c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops; 40c0b12405SJérôme Glisse 41133ff0eaSJérôme Glisse /* 42133ff0eaSJérôme Glisse * struct hmm - HMM per mm struct 43133ff0eaSJérôme Glisse * 44133ff0eaSJérôme Glisse * @mm: mm struct this HMM struct is bound to 45da4c3c73SJérôme Glisse * @lock: lock protecting ranges list 46da4c3c73SJérôme Glisse * @ranges: list of range being snapshotted 47c0b12405SJérôme Glisse * @mirrors: list of mirrors for this mm 48c0b12405SJérôme Glisse * @mmu_notifier: mmu notifier to track updates to CPU page table 49c0b12405SJérôme Glisse * @mirrors_sem: read/write semaphore protecting the mirrors list 50133ff0eaSJérôme Glisse */ 51133ff0eaSJérôme Glisse struct hmm { 52133ff0eaSJérôme Glisse struct mm_struct *mm; 53da4c3c73SJérôme Glisse spinlock_t lock; 54da4c3c73SJérôme Glisse struct list_head ranges; 55c0b12405SJérôme Glisse struct list_head mirrors; 56c0b12405SJérôme Glisse struct mmu_notifier mmu_notifier; 57c0b12405SJérôme Glisse struct rw_semaphore mirrors_sem; 58133ff0eaSJérôme Glisse }; 59133ff0eaSJérôme Glisse 60133ff0eaSJérôme Glisse /* 61133ff0eaSJérôme Glisse * hmm_register - register HMM against an mm (HMM internal) 62133ff0eaSJérôme Glisse * 63133ff0eaSJérôme Glisse * @mm: mm struct to attach to 64133ff0eaSJérôme Glisse * 65133ff0eaSJérôme Glisse * This is not intended to be used directly by device drivers. It allocates an 66133ff0eaSJérôme Glisse * HMM struct if mm does not have one, and initializes it. 67133ff0eaSJérôme Glisse */ 68133ff0eaSJérôme Glisse static struct hmm *hmm_register(struct mm_struct *mm) 69133ff0eaSJérôme Glisse { 70c0b12405SJérôme Glisse struct hmm *hmm = READ_ONCE(mm->hmm); 71c0b12405SJérôme Glisse bool cleanup = false; 72133ff0eaSJérôme Glisse 73133ff0eaSJérôme Glisse /* 74133ff0eaSJérôme Glisse * The hmm struct can only be freed once the mm_struct goes away, 75133ff0eaSJérôme Glisse * hence we should always have pre-allocated an new hmm struct 76133ff0eaSJérôme Glisse * above. 77133ff0eaSJérôme Glisse */ 78c0b12405SJérôme Glisse if (hmm) 79c0b12405SJérôme Glisse return hmm; 80c0b12405SJérôme Glisse 81c0b12405SJérôme Glisse hmm = kmalloc(sizeof(*hmm), GFP_KERNEL); 82c0b12405SJérôme Glisse if (!hmm) 83c0b12405SJérôme Glisse return NULL; 84c0b12405SJérôme Glisse INIT_LIST_HEAD(&hmm->mirrors); 85c0b12405SJérôme Glisse init_rwsem(&hmm->mirrors_sem); 86c0b12405SJérôme Glisse hmm->mmu_notifier.ops = NULL; 87da4c3c73SJérôme Glisse INIT_LIST_HEAD(&hmm->ranges); 88da4c3c73SJérôme Glisse spin_lock_init(&hmm->lock); 89c0b12405SJérôme Glisse hmm->mm = mm; 90c0b12405SJérôme Glisse 91c0b12405SJérôme Glisse spin_lock(&mm->page_table_lock); 92c0b12405SJérôme Glisse if (!mm->hmm) 93c0b12405SJérôme Glisse mm->hmm = hmm; 94c0b12405SJérôme Glisse else 95c0b12405SJérôme Glisse cleanup = true; 96c0b12405SJérôme Glisse spin_unlock(&mm->page_table_lock); 97c0b12405SJérôme Glisse 9886a2d598SRalph Campbell if (cleanup) 9986a2d598SRalph Campbell goto error; 10086a2d598SRalph Campbell 10186a2d598SRalph Campbell /* 10286a2d598SRalph Campbell * We should only get here if hold the mmap_sem in write mode ie on 10386a2d598SRalph Campbell * registration of first mirror through hmm_mirror_register() 10486a2d598SRalph Campbell */ 10586a2d598SRalph Campbell hmm->mmu_notifier.ops = &hmm_mmu_notifier_ops; 10686a2d598SRalph Campbell if (__mmu_notifier_register(&hmm->mmu_notifier, mm)) 10786a2d598SRalph Campbell goto error_mm; 108c0b12405SJérôme Glisse 109133ff0eaSJérôme Glisse return mm->hmm; 11086a2d598SRalph Campbell 11186a2d598SRalph Campbell error_mm: 11286a2d598SRalph Campbell spin_lock(&mm->page_table_lock); 11386a2d598SRalph Campbell if (mm->hmm == hmm) 11486a2d598SRalph Campbell mm->hmm = NULL; 11586a2d598SRalph Campbell spin_unlock(&mm->page_table_lock); 11686a2d598SRalph Campbell error: 11786a2d598SRalph Campbell kfree(hmm); 11886a2d598SRalph Campbell return NULL; 119133ff0eaSJérôme Glisse } 120133ff0eaSJérôme Glisse 121133ff0eaSJérôme Glisse void hmm_mm_destroy(struct mm_struct *mm) 122133ff0eaSJérôme Glisse { 123133ff0eaSJérôme Glisse kfree(mm->hmm); 124133ff0eaSJérôme Glisse } 125c0b12405SJérôme Glisse 126ec131b2dSJérôme Glisse static int hmm_invalidate_range(struct hmm *hmm, bool device, 12744532d4cSJérôme Glisse const struct hmm_update *update) 128c0b12405SJérôme Glisse { 129c0b12405SJérôme Glisse struct hmm_mirror *mirror; 130da4c3c73SJérôme Glisse struct hmm_range *range; 131da4c3c73SJérôme Glisse 132da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 133da4c3c73SJérôme Glisse list_for_each_entry(range, &hmm->ranges, list) { 134da4c3c73SJérôme Glisse unsigned long addr, idx, npages; 135da4c3c73SJérôme Glisse 13644532d4cSJérôme Glisse if (update->end < range->start || update->start >= range->end) 137da4c3c73SJérôme Glisse continue; 138da4c3c73SJérôme Glisse 139da4c3c73SJérôme Glisse range->valid = false; 14044532d4cSJérôme Glisse addr = max(update->start, range->start); 141da4c3c73SJérôme Glisse idx = (addr - range->start) >> PAGE_SHIFT; 14244532d4cSJérôme Glisse npages = (min(range->end, update->end) - addr) >> PAGE_SHIFT; 143da4c3c73SJérôme Glisse memset(&range->pfns[idx], 0, sizeof(*range->pfns) * npages); 144da4c3c73SJérôme Glisse } 145da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 146c0b12405SJérôme Glisse 147ec131b2dSJérôme Glisse if (!device) 148ec131b2dSJérôme Glisse return 0; 149ec131b2dSJérôme Glisse 150c0b12405SJérôme Glisse down_read(&hmm->mirrors_sem); 15144532d4cSJérôme Glisse list_for_each_entry(mirror, &hmm->mirrors, list) { 15244532d4cSJérôme Glisse int ret; 15344532d4cSJérôme Glisse 15444532d4cSJérôme Glisse ret = mirror->ops->sync_cpu_device_pagetables(mirror, update); 15544532d4cSJérôme Glisse if (!update->blockable && ret == -EAGAIN) { 156c0b12405SJérôme Glisse up_read(&hmm->mirrors_sem); 15744532d4cSJérôme Glisse return -EAGAIN; 15844532d4cSJérôme Glisse } 15944532d4cSJérôme Glisse } 16044532d4cSJérôme Glisse up_read(&hmm->mirrors_sem); 16144532d4cSJérôme Glisse 16244532d4cSJérôme Glisse return 0; 163c0b12405SJérôme Glisse } 164c0b12405SJérôme Glisse 165e1401513SRalph Campbell static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) 166e1401513SRalph Campbell { 167e1401513SRalph Campbell struct hmm_mirror *mirror; 168e1401513SRalph Campbell struct hmm *hmm = mm->hmm; 169e1401513SRalph Campbell 170e1401513SRalph Campbell down_write(&hmm->mirrors_sem); 171e1401513SRalph Campbell mirror = list_first_entry_or_null(&hmm->mirrors, struct hmm_mirror, 172e1401513SRalph Campbell list); 173e1401513SRalph Campbell while (mirror) { 174e1401513SRalph Campbell list_del_init(&mirror->list); 175e1401513SRalph Campbell if (mirror->ops->release) { 176e1401513SRalph Campbell /* 177e1401513SRalph Campbell * Drop mirrors_sem so callback can wait on any pending 178e1401513SRalph Campbell * work that might itself trigger mmu_notifier callback 179e1401513SRalph Campbell * and thus would deadlock with us. 180e1401513SRalph Campbell */ 181e1401513SRalph Campbell up_write(&hmm->mirrors_sem); 182e1401513SRalph Campbell mirror->ops->release(mirror); 183e1401513SRalph Campbell down_write(&hmm->mirrors_sem); 184e1401513SRalph Campbell } 185e1401513SRalph Campbell mirror = list_first_entry_or_null(&hmm->mirrors, 186e1401513SRalph Campbell struct hmm_mirror, list); 187e1401513SRalph Campbell } 188e1401513SRalph Campbell up_write(&hmm->mirrors_sem); 189e1401513SRalph Campbell } 190e1401513SRalph Campbell 19193065ac7SMichal Hocko static int hmm_invalidate_range_start(struct mmu_notifier *mn, 192c0b12405SJérôme Glisse struct mm_struct *mm, 193c0b12405SJérôme Glisse unsigned long start, 19493065ac7SMichal Hocko unsigned long end, 19593065ac7SMichal Hocko bool blockable) 196c0b12405SJérôme Glisse { 197ec131b2dSJérôme Glisse struct hmm_update update; 198c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 199c0b12405SJérôme Glisse 200c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 201c0b12405SJérôme Glisse 202ec131b2dSJérôme Glisse update.start = start; 203ec131b2dSJérôme Glisse update.end = end; 204ec131b2dSJérôme Glisse update.event = HMM_UPDATE_INVALIDATE; 205ec131b2dSJérôme Glisse update.blockable = blockable; 206ec131b2dSJérôme Glisse return hmm_invalidate_range(hmm, true, &update); 207c0b12405SJérôme Glisse } 208c0b12405SJérôme Glisse 209c0b12405SJérôme Glisse static void hmm_invalidate_range_end(struct mmu_notifier *mn, 210c0b12405SJérôme Glisse struct mm_struct *mm, 211c0b12405SJérôme Glisse unsigned long start, 212c0b12405SJérôme Glisse unsigned long end) 213c0b12405SJérôme Glisse { 21444532d4cSJérôme Glisse struct hmm_update update; 215c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 216c0b12405SJérôme Glisse 217c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 218c0b12405SJérôme Glisse 21944532d4cSJérôme Glisse update.start = start; 22044532d4cSJérôme Glisse update.end = end; 22144532d4cSJérôme Glisse update.event = HMM_UPDATE_INVALIDATE; 22244532d4cSJérôme Glisse update.blockable = true; 223ec131b2dSJérôme Glisse hmm_invalidate_range(hmm, false, &update); 224c0b12405SJérôme Glisse } 225c0b12405SJérôme Glisse 226c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops = { 227e1401513SRalph Campbell .release = hmm_release, 228c0b12405SJérôme Glisse .invalidate_range_start = hmm_invalidate_range_start, 229c0b12405SJérôme Glisse .invalidate_range_end = hmm_invalidate_range_end, 230c0b12405SJérôme Glisse }; 231c0b12405SJérôme Glisse 232c0b12405SJérôme Glisse /* 233c0b12405SJérôme Glisse * hmm_mirror_register() - register a mirror against an mm 234c0b12405SJérôme Glisse * 235c0b12405SJérôme Glisse * @mirror: new mirror struct to register 236c0b12405SJérôme Glisse * @mm: mm to register against 237c0b12405SJérôme Glisse * 238c0b12405SJérôme Glisse * To start mirroring a process address space, the device driver must register 239c0b12405SJérôme Glisse * an HMM mirror struct. 240c0b12405SJérôme Glisse * 241c0b12405SJérôme Glisse * THE mm->mmap_sem MUST BE HELD IN WRITE MODE ! 242c0b12405SJérôme Glisse */ 243c0b12405SJérôme Glisse int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) 244c0b12405SJérôme Glisse { 245c0b12405SJérôme Glisse /* Sanity check */ 246c0b12405SJérôme Glisse if (!mm || !mirror || !mirror->ops) 247c0b12405SJérôme Glisse return -EINVAL; 248c0b12405SJérôme Glisse 249c01cbba2SJérôme Glisse again: 250c0b12405SJérôme Glisse mirror->hmm = hmm_register(mm); 251c0b12405SJérôme Glisse if (!mirror->hmm) 252c0b12405SJérôme Glisse return -ENOMEM; 253c0b12405SJérôme Glisse 254c0b12405SJérôme Glisse down_write(&mirror->hmm->mirrors_sem); 255c01cbba2SJérôme Glisse if (mirror->hmm->mm == NULL) { 256c01cbba2SJérôme Glisse /* 257c01cbba2SJérôme Glisse * A racing hmm_mirror_unregister() is about to destroy the hmm 258c01cbba2SJérôme Glisse * struct. Try again to allocate a new one. 259c01cbba2SJérôme Glisse */ 260c01cbba2SJérôme Glisse up_write(&mirror->hmm->mirrors_sem); 261c01cbba2SJérôme Glisse mirror->hmm = NULL; 262c01cbba2SJérôme Glisse goto again; 263c01cbba2SJérôme Glisse } else { 264c0b12405SJérôme Glisse list_add(&mirror->list, &mirror->hmm->mirrors); 265c0b12405SJérôme Glisse up_write(&mirror->hmm->mirrors_sem); 266c01cbba2SJérôme Glisse } 267c0b12405SJérôme Glisse 268c0b12405SJérôme Glisse return 0; 269c0b12405SJérôme Glisse } 270c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_register); 271c0b12405SJérôme Glisse 272c0b12405SJérôme Glisse /* 273c0b12405SJérôme Glisse * hmm_mirror_unregister() - unregister a mirror 274c0b12405SJérôme Glisse * 275c0b12405SJérôme Glisse * @mirror: new mirror struct to register 276c0b12405SJérôme Glisse * 277c0b12405SJérôme Glisse * Stop mirroring a process address space, and cleanup. 278c0b12405SJérôme Glisse */ 279c0b12405SJérôme Glisse void hmm_mirror_unregister(struct hmm_mirror *mirror) 280c0b12405SJérôme Glisse { 281c01cbba2SJérôme Glisse bool should_unregister = false; 282c01cbba2SJérôme Glisse struct mm_struct *mm; 283c01cbba2SJérôme Glisse struct hmm *hmm; 284c0b12405SJérôme Glisse 285c01cbba2SJérôme Glisse if (mirror->hmm == NULL) 286c01cbba2SJérôme Glisse return; 287c01cbba2SJérôme Glisse 288c01cbba2SJérôme Glisse hmm = mirror->hmm; 289c0b12405SJérôme Glisse down_write(&hmm->mirrors_sem); 290e1401513SRalph Campbell list_del_init(&mirror->list); 291c01cbba2SJérôme Glisse should_unregister = list_empty(&hmm->mirrors); 292c01cbba2SJérôme Glisse mirror->hmm = NULL; 293c01cbba2SJérôme Glisse mm = hmm->mm; 294c01cbba2SJérôme Glisse hmm->mm = NULL; 295c0b12405SJérôme Glisse up_write(&hmm->mirrors_sem); 296c01cbba2SJérôme Glisse 297c01cbba2SJérôme Glisse if (!should_unregister || mm == NULL) 298c01cbba2SJérôme Glisse return; 299c01cbba2SJérôme Glisse 30086a2d598SRalph Campbell mmu_notifier_unregister_no_release(&hmm->mmu_notifier, mm); 30186a2d598SRalph Campbell 302c01cbba2SJérôme Glisse spin_lock(&mm->page_table_lock); 303c01cbba2SJérôme Glisse if (mm->hmm == hmm) 304c01cbba2SJérôme Glisse mm->hmm = NULL; 305c01cbba2SJérôme Glisse spin_unlock(&mm->page_table_lock); 306c01cbba2SJérôme Glisse 307c01cbba2SJérôme Glisse kfree(hmm); 308c0b12405SJérôme Glisse } 309c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_unregister); 310da4c3c73SJérôme Glisse 31174eee180SJérôme Glisse struct hmm_vma_walk { 31274eee180SJérôme Glisse struct hmm_range *range; 31374eee180SJérôme Glisse unsigned long last; 31474eee180SJérôme Glisse bool fault; 31574eee180SJérôme Glisse bool block; 31674eee180SJérôme Glisse }; 31774eee180SJérôme Glisse 3182aee09d8SJérôme Glisse static int hmm_vma_do_fault(struct mm_walk *walk, unsigned long addr, 3192aee09d8SJérôme Glisse bool write_fault, uint64_t *pfn) 32074eee180SJérôme Glisse { 32174eee180SJérôme Glisse unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_REMOTE; 32274eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 323f88a1e90SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 32474eee180SJérôme Glisse struct vm_area_struct *vma = walk->vma; 32550a7ca3cSSouptick Joarder vm_fault_t ret; 32674eee180SJérôme Glisse 32774eee180SJérôme Glisse flags |= hmm_vma_walk->block ? 0 : FAULT_FLAG_ALLOW_RETRY; 3282aee09d8SJérôme Glisse flags |= write_fault ? FAULT_FLAG_WRITE : 0; 32950a7ca3cSSouptick Joarder ret = handle_mm_fault(vma, addr, flags); 33050a7ca3cSSouptick Joarder if (ret & VM_FAULT_RETRY) 33174eee180SJérôme Glisse return -EBUSY; 33250a7ca3cSSouptick Joarder if (ret & VM_FAULT_ERROR) { 333f88a1e90SJérôme Glisse *pfn = range->values[HMM_PFN_ERROR]; 33474eee180SJérôme Glisse return -EFAULT; 33574eee180SJérôme Glisse } 33674eee180SJérôme Glisse 33774eee180SJérôme Glisse return -EAGAIN; 33874eee180SJérôme Glisse } 33974eee180SJérôme Glisse 340da4c3c73SJérôme Glisse static int hmm_pfns_bad(unsigned long addr, 341da4c3c73SJérôme Glisse unsigned long end, 342da4c3c73SJérôme Glisse struct mm_walk *walk) 343da4c3c73SJérôme Glisse { 344c719547fSJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 345c719547fSJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 346ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 347da4c3c73SJérôme Glisse unsigned long i; 348da4c3c73SJérôme Glisse 349da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 350da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) 351f88a1e90SJérôme Glisse pfns[i] = range->values[HMM_PFN_ERROR]; 352da4c3c73SJérôme Glisse 353da4c3c73SJérôme Glisse return 0; 354da4c3c73SJérôme Glisse } 355da4c3c73SJérôme Glisse 3565504ed29SJérôme Glisse /* 3575504ed29SJérôme Glisse * hmm_vma_walk_hole() - handle a range lacking valid pmd or pte(s) 3585504ed29SJérôme Glisse * @start: range virtual start address (inclusive) 3595504ed29SJérôme Glisse * @end: range virtual end address (exclusive) 3602aee09d8SJérôme Glisse * @fault: should we fault or not ? 3612aee09d8SJérôme Glisse * @write_fault: write fault ? 3625504ed29SJérôme Glisse * @walk: mm_walk structure 3635504ed29SJérôme Glisse * Returns: 0 on success, -EAGAIN after page fault, or page fault error 3645504ed29SJérôme Glisse * 3655504ed29SJérôme Glisse * This function will be called whenever pmd_none() or pte_none() returns true, 3665504ed29SJérôme Glisse * or whenever there is no page directory covering the virtual address range. 3675504ed29SJérôme Glisse */ 3682aee09d8SJérôme Glisse static int hmm_vma_walk_hole_(unsigned long addr, unsigned long end, 3692aee09d8SJérôme Glisse bool fault, bool write_fault, 370da4c3c73SJérôme Glisse struct mm_walk *walk) 371da4c3c73SJérôme Glisse { 37274eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 37374eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 374ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 375da4c3c73SJérôme Glisse unsigned long i; 376da4c3c73SJérôme Glisse 37774eee180SJérôme Glisse hmm_vma_walk->last = addr; 378da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 37974eee180SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) { 380f88a1e90SJérôme Glisse pfns[i] = range->values[HMM_PFN_NONE]; 3812aee09d8SJérôme Glisse if (fault || write_fault) { 38274eee180SJérôme Glisse int ret; 383da4c3c73SJérôme Glisse 3842aee09d8SJérôme Glisse ret = hmm_vma_do_fault(walk, addr, write_fault, 3852aee09d8SJérôme Glisse &pfns[i]); 38674eee180SJérôme Glisse if (ret != -EAGAIN) 38774eee180SJérôme Glisse return ret; 38874eee180SJérôme Glisse } 38974eee180SJérôme Glisse } 39074eee180SJérôme Glisse 3912aee09d8SJérôme Glisse return (fault || write_fault) ? -EAGAIN : 0; 3922aee09d8SJérôme Glisse } 3932aee09d8SJérôme Glisse 3942aee09d8SJérôme Glisse static inline void hmm_pte_need_fault(const struct hmm_vma_walk *hmm_vma_walk, 3952aee09d8SJérôme Glisse uint64_t pfns, uint64_t cpu_flags, 3962aee09d8SJérôme Glisse bool *fault, bool *write_fault) 3972aee09d8SJérôme Glisse { 398f88a1e90SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 399f88a1e90SJérôme Glisse 4002aee09d8SJérôme Glisse *fault = *write_fault = false; 4012aee09d8SJérôme Glisse if (!hmm_vma_walk->fault) 4022aee09d8SJérôme Glisse return; 4032aee09d8SJérôme Glisse 4042aee09d8SJérôme Glisse /* We aren't ask to do anything ... */ 405f88a1e90SJérôme Glisse if (!(pfns & range->flags[HMM_PFN_VALID])) 4062aee09d8SJérôme Glisse return; 407f88a1e90SJérôme Glisse /* If this is device memory than only fault if explicitly requested */ 408f88a1e90SJérôme Glisse if ((cpu_flags & range->flags[HMM_PFN_DEVICE_PRIVATE])) { 409f88a1e90SJérôme Glisse /* Do we fault on device memory ? */ 410f88a1e90SJérôme Glisse if (pfns & range->flags[HMM_PFN_DEVICE_PRIVATE]) { 411f88a1e90SJérôme Glisse *write_fault = pfns & range->flags[HMM_PFN_WRITE]; 412f88a1e90SJérôme Glisse *fault = true; 413f88a1e90SJérôme Glisse } 4142aee09d8SJérôme Glisse return; 4152aee09d8SJérôme Glisse } 416f88a1e90SJérôme Glisse 417f88a1e90SJérôme Glisse /* If CPU page table is not valid then we need to fault */ 418f88a1e90SJérôme Glisse *fault = !(cpu_flags & range->flags[HMM_PFN_VALID]); 419f88a1e90SJérôme Glisse /* Need to write fault ? */ 420f88a1e90SJérôme Glisse if ((pfns & range->flags[HMM_PFN_WRITE]) && 421f88a1e90SJérôme Glisse !(cpu_flags & range->flags[HMM_PFN_WRITE])) { 422f88a1e90SJérôme Glisse *write_fault = true; 4232aee09d8SJérôme Glisse *fault = true; 4242aee09d8SJérôme Glisse } 4252aee09d8SJérôme Glisse } 4262aee09d8SJérôme Glisse 4272aee09d8SJérôme Glisse static void hmm_range_need_fault(const struct hmm_vma_walk *hmm_vma_walk, 4282aee09d8SJérôme Glisse const uint64_t *pfns, unsigned long npages, 4292aee09d8SJérôme Glisse uint64_t cpu_flags, bool *fault, 4302aee09d8SJérôme Glisse bool *write_fault) 4312aee09d8SJérôme Glisse { 4322aee09d8SJérôme Glisse unsigned long i; 4332aee09d8SJérôme Glisse 4342aee09d8SJérôme Glisse if (!hmm_vma_walk->fault) { 4352aee09d8SJérôme Glisse *fault = *write_fault = false; 4362aee09d8SJérôme Glisse return; 4372aee09d8SJérôme Glisse } 4382aee09d8SJérôme Glisse 4392aee09d8SJérôme Glisse for (i = 0; i < npages; ++i) { 4402aee09d8SJérôme Glisse hmm_pte_need_fault(hmm_vma_walk, pfns[i], cpu_flags, 4412aee09d8SJérôme Glisse fault, write_fault); 4422aee09d8SJérôme Glisse if ((*fault) || (*write_fault)) 4432aee09d8SJérôme Glisse return; 4442aee09d8SJérôme Glisse } 4452aee09d8SJérôme Glisse } 4462aee09d8SJérôme Glisse 4472aee09d8SJérôme Glisse static int hmm_vma_walk_hole(unsigned long addr, unsigned long end, 4482aee09d8SJérôme Glisse struct mm_walk *walk) 4492aee09d8SJérôme Glisse { 4502aee09d8SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 4512aee09d8SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 4522aee09d8SJérôme Glisse bool fault, write_fault; 4532aee09d8SJérôme Glisse unsigned long i, npages; 4542aee09d8SJérôme Glisse uint64_t *pfns; 4552aee09d8SJérôme Glisse 4562aee09d8SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 4572aee09d8SJérôme Glisse npages = (end - addr) >> PAGE_SHIFT; 4582aee09d8SJérôme Glisse pfns = &range->pfns[i]; 4592aee09d8SJérôme Glisse hmm_range_need_fault(hmm_vma_walk, pfns, npages, 4602aee09d8SJérôme Glisse 0, &fault, &write_fault); 4612aee09d8SJérôme Glisse return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk); 4622aee09d8SJérôme Glisse } 4632aee09d8SJérôme Glisse 464f88a1e90SJérôme Glisse static inline uint64_t pmd_to_hmm_pfn_flags(struct hmm_range *range, pmd_t pmd) 4652aee09d8SJérôme Glisse { 4662aee09d8SJérôme Glisse if (pmd_protnone(pmd)) 4672aee09d8SJérôme Glisse return 0; 468f88a1e90SJérôme Glisse return pmd_write(pmd) ? range->flags[HMM_PFN_VALID] | 469f88a1e90SJérôme Glisse range->flags[HMM_PFN_WRITE] : 470f88a1e90SJérôme Glisse range->flags[HMM_PFN_VALID]; 471da4c3c73SJérôme Glisse } 472da4c3c73SJérôme Glisse 47353f5c3f4SJérôme Glisse static int hmm_vma_handle_pmd(struct mm_walk *walk, 47453f5c3f4SJérôme Glisse unsigned long addr, 47553f5c3f4SJérôme Glisse unsigned long end, 47653f5c3f4SJérôme Glisse uint64_t *pfns, 47753f5c3f4SJérôme Glisse pmd_t pmd) 47853f5c3f4SJérôme Glisse { 47953f5c3f4SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 480f88a1e90SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 4812aee09d8SJérôme Glisse unsigned long pfn, npages, i; 4822aee09d8SJérôme Glisse bool fault, write_fault; 483f88a1e90SJérôme Glisse uint64_t cpu_flags; 48453f5c3f4SJérôme Glisse 4852aee09d8SJérôme Glisse npages = (end - addr) >> PAGE_SHIFT; 486f88a1e90SJérôme Glisse cpu_flags = pmd_to_hmm_pfn_flags(range, pmd); 4872aee09d8SJérôme Glisse hmm_range_need_fault(hmm_vma_walk, pfns, npages, cpu_flags, 4882aee09d8SJérôme Glisse &fault, &write_fault); 48953f5c3f4SJérôme Glisse 4902aee09d8SJérôme Glisse if (pmd_protnone(pmd) || fault || write_fault) 4912aee09d8SJérôme Glisse return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk); 49253f5c3f4SJérôme Glisse 49353f5c3f4SJérôme Glisse pfn = pmd_pfn(pmd) + pte_index(addr); 49453f5c3f4SJérôme Glisse for (i = 0; addr < end; addr += PAGE_SIZE, i++, pfn++) 495f88a1e90SJérôme Glisse pfns[i] = hmm_pfn_from_pfn(range, pfn) | cpu_flags; 49653f5c3f4SJérôme Glisse hmm_vma_walk->last = end; 49753f5c3f4SJérôme Glisse return 0; 49853f5c3f4SJérôme Glisse } 49953f5c3f4SJérôme Glisse 500f88a1e90SJérôme Glisse static inline uint64_t pte_to_hmm_pfn_flags(struct hmm_range *range, pte_t pte) 5012aee09d8SJérôme Glisse { 5022aee09d8SJérôme Glisse if (pte_none(pte) || !pte_present(pte)) 5032aee09d8SJérôme Glisse return 0; 504f88a1e90SJérôme Glisse return pte_write(pte) ? range->flags[HMM_PFN_VALID] | 505f88a1e90SJérôme Glisse range->flags[HMM_PFN_WRITE] : 506f88a1e90SJérôme Glisse range->flags[HMM_PFN_VALID]; 5072aee09d8SJérôme Glisse } 5082aee09d8SJérôme Glisse 50953f5c3f4SJérôme Glisse static int hmm_vma_handle_pte(struct mm_walk *walk, unsigned long addr, 51053f5c3f4SJérôme Glisse unsigned long end, pmd_t *pmdp, pte_t *ptep, 51153f5c3f4SJérôme Glisse uint64_t *pfn) 51253f5c3f4SJérôme Glisse { 51353f5c3f4SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 514f88a1e90SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 51553f5c3f4SJérôme Glisse struct vm_area_struct *vma = walk->vma; 5162aee09d8SJérôme Glisse bool fault, write_fault; 5172aee09d8SJérôme Glisse uint64_t cpu_flags; 51853f5c3f4SJérôme Glisse pte_t pte = *ptep; 519f88a1e90SJérôme Glisse uint64_t orig_pfn = *pfn; 52053f5c3f4SJérôme Glisse 521f88a1e90SJérôme Glisse *pfn = range->values[HMM_PFN_NONE]; 522f88a1e90SJérôme Glisse cpu_flags = pte_to_hmm_pfn_flags(range, pte); 523f88a1e90SJérôme Glisse hmm_pte_need_fault(hmm_vma_walk, orig_pfn, cpu_flags, 5242aee09d8SJérôme Glisse &fault, &write_fault); 52553f5c3f4SJérôme Glisse 52653f5c3f4SJérôme Glisse if (pte_none(pte)) { 5272aee09d8SJérôme Glisse if (fault || write_fault) 52853f5c3f4SJérôme Glisse goto fault; 52953f5c3f4SJérôme Glisse return 0; 53053f5c3f4SJérôme Glisse } 53153f5c3f4SJérôme Glisse 53253f5c3f4SJérôme Glisse if (!pte_present(pte)) { 53353f5c3f4SJérôme Glisse swp_entry_t entry = pte_to_swp_entry(pte); 53453f5c3f4SJérôme Glisse 53553f5c3f4SJérôme Glisse if (!non_swap_entry(entry)) { 5362aee09d8SJérôme Glisse if (fault || write_fault) 53753f5c3f4SJérôme Glisse goto fault; 53853f5c3f4SJérôme Glisse return 0; 53953f5c3f4SJérôme Glisse } 54053f5c3f4SJérôme Glisse 54153f5c3f4SJérôme Glisse /* 54253f5c3f4SJérôme Glisse * This is a special swap entry, ignore migration, use 54353f5c3f4SJérôme Glisse * device and report anything else as error. 54453f5c3f4SJérôme Glisse */ 54553f5c3f4SJérôme Glisse if (is_device_private_entry(entry)) { 546f88a1e90SJérôme Glisse cpu_flags = range->flags[HMM_PFN_VALID] | 547f88a1e90SJérôme Glisse range->flags[HMM_PFN_DEVICE_PRIVATE]; 5482aee09d8SJérôme Glisse cpu_flags |= is_write_device_private_entry(entry) ? 549f88a1e90SJérôme Glisse range->flags[HMM_PFN_WRITE] : 0; 550f88a1e90SJérôme Glisse hmm_pte_need_fault(hmm_vma_walk, orig_pfn, cpu_flags, 551f88a1e90SJérôme Glisse &fault, &write_fault); 552f88a1e90SJérôme Glisse if (fault || write_fault) 553f88a1e90SJérôme Glisse goto fault; 554f88a1e90SJérôme Glisse *pfn = hmm_pfn_from_pfn(range, swp_offset(entry)); 555f88a1e90SJérôme Glisse *pfn |= cpu_flags; 55653f5c3f4SJérôme Glisse return 0; 55753f5c3f4SJérôme Glisse } 55853f5c3f4SJérôme Glisse 55953f5c3f4SJérôme Glisse if (is_migration_entry(entry)) { 5602aee09d8SJérôme Glisse if (fault || write_fault) { 56153f5c3f4SJérôme Glisse pte_unmap(ptep); 56253f5c3f4SJérôme Glisse hmm_vma_walk->last = addr; 56353f5c3f4SJérôme Glisse migration_entry_wait(vma->vm_mm, 56453f5c3f4SJérôme Glisse pmdp, addr); 56553f5c3f4SJérôme Glisse return -EAGAIN; 56653f5c3f4SJérôme Glisse } 56753f5c3f4SJérôme Glisse return 0; 56853f5c3f4SJérôme Glisse } 56953f5c3f4SJérôme Glisse 57053f5c3f4SJérôme Glisse /* Report error for everything else */ 571f88a1e90SJérôme Glisse *pfn = range->values[HMM_PFN_ERROR]; 57253f5c3f4SJérôme Glisse return -EFAULT; 57353f5c3f4SJérôme Glisse } 57453f5c3f4SJérôme Glisse 5752aee09d8SJérôme Glisse if (fault || write_fault) 57653f5c3f4SJérôme Glisse goto fault; 57753f5c3f4SJérôme Glisse 578f88a1e90SJérôme Glisse *pfn = hmm_pfn_from_pfn(range, pte_pfn(pte)) | cpu_flags; 57953f5c3f4SJérôme Glisse return 0; 58053f5c3f4SJérôme Glisse 58153f5c3f4SJérôme Glisse fault: 58253f5c3f4SJérôme Glisse pte_unmap(ptep); 58353f5c3f4SJérôme Glisse /* Fault any virtual address we were asked to fault */ 5842aee09d8SJérôme Glisse return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk); 58553f5c3f4SJérôme Glisse } 58653f5c3f4SJérôme Glisse 587da4c3c73SJérôme Glisse static int hmm_vma_walk_pmd(pmd_t *pmdp, 588da4c3c73SJérôme Glisse unsigned long start, 589da4c3c73SJérôme Glisse unsigned long end, 590da4c3c73SJérôme Glisse struct mm_walk *walk) 591da4c3c73SJérôme Glisse { 59274eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 59374eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 594d08faca0SJérôme Glisse struct vm_area_struct *vma = walk->vma; 595ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 596da4c3c73SJérôme Glisse unsigned long addr = start, i; 597da4c3c73SJérôme Glisse pte_t *ptep; 598da4c3c73SJérôme Glisse pmd_t pmd; 599da4c3c73SJérôme Glisse 600d08faca0SJérôme Glisse 601d08faca0SJérôme Glisse again: 602d08faca0SJérôme Glisse pmd = READ_ONCE(*pmdp); 603d08faca0SJérôme Glisse if (pmd_none(pmd)) 604d08faca0SJérôme Glisse return hmm_vma_walk_hole(start, end, walk); 605d08faca0SJérôme Glisse 606d08faca0SJérôme Glisse if (pmd_huge(pmd) && (range->vma->vm_flags & VM_HUGETLB)) 607d08faca0SJérôme Glisse return hmm_pfns_bad(start, end, walk); 608d08faca0SJérôme Glisse 609d08faca0SJérôme Glisse if (thp_migration_supported() && is_pmd_migration_entry(pmd)) { 610d08faca0SJérôme Glisse bool fault, write_fault; 611d08faca0SJérôme Glisse unsigned long npages; 612d08faca0SJérôme Glisse uint64_t *pfns; 613d08faca0SJérôme Glisse 614d08faca0SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 615d08faca0SJérôme Glisse npages = (end - addr) >> PAGE_SHIFT; 616d08faca0SJérôme Glisse pfns = &range->pfns[i]; 617d08faca0SJérôme Glisse 618d08faca0SJérôme Glisse hmm_range_need_fault(hmm_vma_walk, pfns, npages, 619d08faca0SJérôme Glisse 0, &fault, &write_fault); 620d08faca0SJérôme Glisse if (fault || write_fault) { 621d08faca0SJérôme Glisse hmm_vma_walk->last = addr; 622d08faca0SJérôme Glisse pmd_migration_entry_wait(vma->vm_mm, pmdp); 623d08faca0SJérôme Glisse return -EAGAIN; 624d08faca0SJérôme Glisse } 625d08faca0SJérôme Glisse return 0; 626d08faca0SJérôme Glisse } else if (!pmd_present(pmd)) 627d08faca0SJérôme Glisse return hmm_pfns_bad(start, end, walk); 628d08faca0SJérôme Glisse 629d08faca0SJérôme Glisse if (pmd_devmap(pmd) || pmd_trans_huge(pmd)) { 630da4c3c73SJérôme Glisse /* 631da4c3c73SJérôme Glisse * No need to take pmd_lock here, even if some other threads 632da4c3c73SJérôme Glisse * is splitting the huge pmd we will get that event through 633da4c3c73SJérôme Glisse * mmu_notifier callback. 634da4c3c73SJérôme Glisse * 635da4c3c73SJérôme Glisse * So just read pmd value and check again its a transparent 636da4c3c73SJérôme Glisse * huge or device mapping one and compute corresponding pfn 637da4c3c73SJérôme Glisse * values. 638da4c3c73SJérôme Glisse */ 639da4c3c73SJérôme Glisse pmd = pmd_read_atomic(pmdp); 640da4c3c73SJérôme Glisse barrier(); 641da4c3c73SJérôme Glisse if (!pmd_devmap(pmd) && !pmd_trans_huge(pmd)) 642da4c3c73SJérôme Glisse goto again; 643da4c3c73SJérôme Glisse 644d08faca0SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 64553f5c3f4SJérôme Glisse return hmm_vma_handle_pmd(walk, addr, end, &pfns[i], pmd); 646da4c3c73SJérôme Glisse } 647da4c3c73SJérôme Glisse 648d08faca0SJérôme Glisse /* 649d08faca0SJérôme Glisse * We have handled all the valid case above ie either none, migration, 650d08faca0SJérôme Glisse * huge or transparent huge. At this point either it is a valid pmd 651d08faca0SJérôme Glisse * entry pointing to pte directory or it is a bad pmd that will not 652d08faca0SJérôme Glisse * recover. 653d08faca0SJérôme Glisse */ 654d08faca0SJérôme Glisse if (pmd_bad(pmd)) 655da4c3c73SJérôme Glisse return hmm_pfns_bad(start, end, walk); 656da4c3c73SJérôme Glisse 657da4c3c73SJérôme Glisse ptep = pte_offset_map(pmdp, addr); 658d08faca0SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 659da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, ptep++, i++) { 66053f5c3f4SJérôme Glisse int r; 661da4c3c73SJérôme Glisse 66253f5c3f4SJérôme Glisse r = hmm_vma_handle_pte(walk, addr, end, pmdp, ptep, &pfns[i]); 66353f5c3f4SJérôme Glisse if (r) { 66453f5c3f4SJérôme Glisse /* hmm_vma_handle_pte() did unmap pte directory */ 66574eee180SJérôme Glisse hmm_vma_walk->last = addr; 66653f5c3f4SJérôme Glisse return r; 66774eee180SJérôme Glisse } 668da4c3c73SJérôme Glisse } 669da4c3c73SJérôme Glisse pte_unmap(ptep - 1); 670da4c3c73SJérôme Glisse 67153f5c3f4SJérôme Glisse hmm_vma_walk->last = addr; 672da4c3c73SJérôme Glisse return 0; 673da4c3c73SJérôme Glisse } 674da4c3c73SJérôme Glisse 675f88a1e90SJérôme Glisse static void hmm_pfns_clear(struct hmm_range *range, 676f88a1e90SJérôme Glisse uint64_t *pfns, 67733cd47dcSJérôme Glisse unsigned long addr, 67833cd47dcSJérôme Glisse unsigned long end) 67933cd47dcSJérôme Glisse { 68033cd47dcSJérôme Glisse for (; addr < end; addr += PAGE_SIZE, pfns++) 681f88a1e90SJérôme Glisse *pfns = range->values[HMM_PFN_NONE]; 68233cd47dcSJérôme Glisse } 68333cd47dcSJérôme Glisse 684855ce7d2SJérôme Glisse static void hmm_pfns_special(struct hmm_range *range) 685855ce7d2SJérôme Glisse { 686855ce7d2SJérôme Glisse unsigned long addr = range->start, i = 0; 687855ce7d2SJérôme Glisse 688855ce7d2SJérôme Glisse for (; addr < range->end; addr += PAGE_SIZE, i++) 689f88a1e90SJérôme Glisse range->pfns[i] = range->values[HMM_PFN_SPECIAL]; 690855ce7d2SJérôme Glisse } 691855ce7d2SJérôme Glisse 692da4c3c73SJérôme Glisse /* 693da4c3c73SJérôme Glisse * hmm_vma_get_pfns() - snapshot CPU page table for a range of virtual addresses 69408232a45SJérôme Glisse * @range: range being snapshotted 69586586a41SJérôme Glisse * Returns: -EINVAL if invalid argument, -ENOMEM out of memory, -EPERM invalid 69686586a41SJérôme Glisse * vma permission, 0 success 697da4c3c73SJérôme Glisse * 698da4c3c73SJérôme Glisse * This snapshots the CPU page table for a range of virtual addresses. Snapshot 699da4c3c73SJérôme Glisse * validity is tracked by range struct. See hmm_vma_range_done() for further 700da4c3c73SJérôme Glisse * information. 701da4c3c73SJérôme Glisse * 702da4c3c73SJérôme Glisse * The range struct is initialized here. It tracks the CPU page table, but only 703da4c3c73SJérôme Glisse * if the function returns success (0), in which case the caller must then call 704da4c3c73SJérôme Glisse * hmm_vma_range_done() to stop CPU page table update tracking on this range. 705da4c3c73SJérôme Glisse * 706da4c3c73SJérôme Glisse * NOT CALLING hmm_vma_range_done() IF FUNCTION RETURNS 0 WILL LEAD TO SERIOUS 707da4c3c73SJérôme Glisse * MEMORY CORRUPTION ! YOU HAVE BEEN WARNED ! 708da4c3c73SJérôme Glisse */ 70908232a45SJérôme Glisse int hmm_vma_get_pfns(struct hmm_range *range) 710da4c3c73SJérôme Glisse { 71108232a45SJérôme Glisse struct vm_area_struct *vma = range->vma; 71274eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 713da4c3c73SJérôme Glisse struct mm_walk mm_walk; 714da4c3c73SJérôme Glisse struct hmm *hmm; 715da4c3c73SJérôme Glisse 716da4c3c73SJérôme Glisse /* Sanity check, this really should not happen ! */ 71708232a45SJérôme Glisse if (range->start < vma->vm_start || range->start >= vma->vm_end) 718da4c3c73SJérôme Glisse return -EINVAL; 71908232a45SJérôme Glisse if (range->end < vma->vm_start || range->end > vma->vm_end) 720da4c3c73SJérôme Glisse return -EINVAL; 721da4c3c73SJérôme Glisse 722da4c3c73SJérôme Glisse hmm = hmm_register(vma->vm_mm); 723da4c3c73SJérôme Glisse if (!hmm) 724da4c3c73SJérôme Glisse return -ENOMEM; 725da4c3c73SJérôme Glisse /* Caller must have registered a mirror, via hmm_mirror_register() ! */ 726da4c3c73SJérôme Glisse if (!hmm->mmu_notifier.ops) 727da4c3c73SJérôme Glisse return -EINVAL; 728da4c3c73SJérôme Glisse 729855ce7d2SJérôme Glisse /* FIXME support hugetlb fs */ 730e1fb4a08SDave Jiang if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL) || 731e1fb4a08SDave Jiang vma_is_dax(vma)) { 732855ce7d2SJérôme Glisse hmm_pfns_special(range); 733855ce7d2SJérôme Glisse return -EINVAL; 734855ce7d2SJérôme Glisse } 735855ce7d2SJérôme Glisse 73686586a41SJérôme Glisse if (!(vma->vm_flags & VM_READ)) { 73786586a41SJérôme Glisse /* 73886586a41SJérôme Glisse * If vma do not allow read access, then assume that it does 73986586a41SJérôme Glisse * not allow write access, either. Architecture that allow 74086586a41SJérôme Glisse * write without read access are not supported by HMM, because 74186586a41SJérôme Glisse * operations such has atomic access would not work. 74286586a41SJérôme Glisse */ 743f88a1e90SJérôme Glisse hmm_pfns_clear(range, range->pfns, range->start, range->end); 74486586a41SJérôme Glisse return -EPERM; 74586586a41SJérôme Glisse } 74686586a41SJérôme Glisse 747da4c3c73SJérôme Glisse /* Initialize range to track CPU page table update */ 748da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 749da4c3c73SJérôme Glisse range->valid = true; 750da4c3c73SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 751da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 752da4c3c73SJérôme Glisse 75374eee180SJérôme Glisse hmm_vma_walk.fault = false; 75474eee180SJérôme Glisse hmm_vma_walk.range = range; 75574eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 75674eee180SJérôme Glisse 757da4c3c73SJérôme Glisse mm_walk.vma = vma; 758da4c3c73SJérôme Glisse mm_walk.mm = vma->vm_mm; 759da4c3c73SJérôme Glisse mm_walk.pte_entry = NULL; 760da4c3c73SJérôme Glisse mm_walk.test_walk = NULL; 761da4c3c73SJérôme Glisse mm_walk.hugetlb_entry = NULL; 762da4c3c73SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 763da4c3c73SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 764da4c3c73SJérôme Glisse 76508232a45SJérôme Glisse walk_page_range(range->start, range->end, &mm_walk); 766da4c3c73SJérôme Glisse return 0; 767da4c3c73SJérôme Glisse } 768da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_get_pfns); 769da4c3c73SJérôme Glisse 770da4c3c73SJérôme Glisse /* 771da4c3c73SJérôme Glisse * hmm_vma_range_done() - stop tracking change to CPU page table over a range 772da4c3c73SJérôme Glisse * @range: range being tracked 773da4c3c73SJérôme Glisse * Returns: false if range data has been invalidated, true otherwise 774da4c3c73SJérôme Glisse * 775da4c3c73SJérôme Glisse * Range struct is used to track updates to the CPU page table after a call to 776da4c3c73SJérôme Glisse * either hmm_vma_get_pfns() or hmm_vma_fault(). Once the device driver is done 777da4c3c73SJérôme Glisse * using the data, or wants to lock updates to the data it got from those 778da4c3c73SJérôme Glisse * functions, it must call the hmm_vma_range_done() function, which will then 779da4c3c73SJérôme Glisse * stop tracking CPU page table updates. 780da4c3c73SJérôme Glisse * 781da4c3c73SJérôme Glisse * Note that device driver must still implement general CPU page table update 782da4c3c73SJérôme Glisse * tracking either by using hmm_mirror (see hmm_mirror_register()) or by using 783da4c3c73SJérôme Glisse * the mmu_notifier API directly. 784da4c3c73SJérôme Glisse * 785da4c3c73SJérôme Glisse * CPU page table update tracking done through hmm_range is only temporary and 786da4c3c73SJérôme Glisse * to be used while trying to duplicate CPU page table contents for a range of 787da4c3c73SJérôme Glisse * virtual addresses. 788da4c3c73SJérôme Glisse * 789da4c3c73SJérôme Glisse * There are two ways to use this : 790da4c3c73SJérôme Glisse * again: 79108232a45SJérôme Glisse * hmm_vma_get_pfns(range); or hmm_vma_fault(...); 792da4c3c73SJérôme Glisse * trans = device_build_page_table_update_transaction(pfns); 793da4c3c73SJérôme Glisse * device_page_table_lock(); 79408232a45SJérôme Glisse * if (!hmm_vma_range_done(range)) { 795da4c3c73SJérôme Glisse * device_page_table_unlock(); 796da4c3c73SJérôme Glisse * goto again; 797da4c3c73SJérôme Glisse * } 798da4c3c73SJérôme Glisse * device_commit_transaction(trans); 799da4c3c73SJérôme Glisse * device_page_table_unlock(); 800da4c3c73SJérôme Glisse * 801da4c3c73SJérôme Glisse * Or: 80208232a45SJérôme Glisse * hmm_vma_get_pfns(range); or hmm_vma_fault(...); 803da4c3c73SJérôme Glisse * device_page_table_lock(); 80408232a45SJérôme Glisse * hmm_vma_range_done(range); 80508232a45SJérôme Glisse * device_update_page_table(range->pfns); 806da4c3c73SJérôme Glisse * device_page_table_unlock(); 807da4c3c73SJérôme Glisse */ 80808232a45SJérôme Glisse bool hmm_vma_range_done(struct hmm_range *range) 809da4c3c73SJérôme Glisse { 810da4c3c73SJérôme Glisse unsigned long npages = (range->end - range->start) >> PAGE_SHIFT; 811da4c3c73SJérôme Glisse struct hmm *hmm; 812da4c3c73SJérôme Glisse 813da4c3c73SJérôme Glisse if (range->end <= range->start) { 814da4c3c73SJérôme Glisse BUG(); 815da4c3c73SJérôme Glisse return false; 816da4c3c73SJérôme Glisse } 817da4c3c73SJérôme Glisse 81808232a45SJérôme Glisse hmm = hmm_register(range->vma->vm_mm); 819da4c3c73SJérôme Glisse if (!hmm) { 820da4c3c73SJérôme Glisse memset(range->pfns, 0, sizeof(*range->pfns) * npages); 821da4c3c73SJérôme Glisse return false; 822da4c3c73SJérôme Glisse } 823da4c3c73SJérôme Glisse 824da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 825da4c3c73SJérôme Glisse list_del_rcu(&range->list); 826da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 827da4c3c73SJérôme Glisse 828da4c3c73SJérôme Glisse return range->valid; 829da4c3c73SJérôme Glisse } 830da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_range_done); 83174eee180SJérôme Glisse 83274eee180SJérôme Glisse /* 83374eee180SJérôme Glisse * hmm_vma_fault() - try to fault some address in a virtual address range 83408232a45SJérôme Glisse * @range: range being faulted 83574eee180SJérôme Glisse * @block: allow blocking on fault (if true it sleeps and do not drop mmap_sem) 83674eee180SJérôme Glisse * Returns: 0 success, error otherwise (-EAGAIN means mmap_sem have been drop) 83774eee180SJérôme Glisse * 83874eee180SJérôme Glisse * This is similar to a regular CPU page fault except that it will not trigger 83974eee180SJérôme Glisse * any memory migration if the memory being faulted is not accessible by CPUs. 84074eee180SJérôme Glisse * 841ff05c0c6SJérôme Glisse * On error, for one virtual address in the range, the function will mark the 842ff05c0c6SJérôme Glisse * corresponding HMM pfn entry with an error flag. 84374eee180SJérôme Glisse * 84474eee180SJérôme Glisse * Expected use pattern: 84574eee180SJérôme Glisse * retry: 84674eee180SJérôme Glisse * down_read(&mm->mmap_sem); 84774eee180SJérôme Glisse * // Find vma and address device wants to fault, initialize hmm_pfn_t 84874eee180SJérôme Glisse * // array accordingly 84908232a45SJérôme Glisse * ret = hmm_vma_fault(range, write, block); 85074eee180SJérôme Glisse * switch (ret) { 85174eee180SJérôme Glisse * case -EAGAIN: 85208232a45SJérôme Glisse * hmm_vma_range_done(range); 85374eee180SJérôme Glisse * // You might want to rate limit or yield to play nicely, you may 85474eee180SJérôme Glisse * // also commit any valid pfn in the array assuming that you are 85574eee180SJérôme Glisse * // getting true from hmm_vma_range_monitor_end() 85674eee180SJérôme Glisse * goto retry; 85774eee180SJérôme Glisse * case 0: 85874eee180SJérôme Glisse * break; 85986586a41SJérôme Glisse * case -ENOMEM: 86086586a41SJérôme Glisse * case -EINVAL: 86186586a41SJérôme Glisse * case -EPERM: 86274eee180SJérôme Glisse * default: 86374eee180SJérôme Glisse * // Handle error ! 86474eee180SJérôme Glisse * up_read(&mm->mmap_sem) 86574eee180SJérôme Glisse * return; 86674eee180SJérôme Glisse * } 86774eee180SJérôme Glisse * // Take device driver lock that serialize device page table update 86874eee180SJérôme Glisse * driver_lock_device_page_table_update(); 86908232a45SJérôme Glisse * hmm_vma_range_done(range); 87074eee180SJérôme Glisse * // Commit pfns we got from hmm_vma_fault() 87174eee180SJérôme Glisse * driver_unlock_device_page_table_update(); 87274eee180SJérôme Glisse * up_read(&mm->mmap_sem) 87374eee180SJérôme Glisse * 87474eee180SJérôme Glisse * YOU MUST CALL hmm_vma_range_done() AFTER THIS FUNCTION RETURN SUCCESS (0) 87574eee180SJérôme Glisse * BEFORE FREEING THE range struct OR YOU WILL HAVE SERIOUS MEMORY CORRUPTION ! 87674eee180SJérôme Glisse * 87774eee180SJérôme Glisse * YOU HAVE BEEN WARNED ! 87874eee180SJérôme Glisse */ 8792aee09d8SJérôme Glisse int hmm_vma_fault(struct hmm_range *range, bool block) 88074eee180SJérôme Glisse { 88108232a45SJérôme Glisse struct vm_area_struct *vma = range->vma; 88208232a45SJérôme Glisse unsigned long start = range->start; 88374eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 88474eee180SJérôme Glisse struct mm_walk mm_walk; 88574eee180SJérôme Glisse struct hmm *hmm; 88674eee180SJérôme Glisse int ret; 88774eee180SJérôme Glisse 88874eee180SJérôme Glisse /* Sanity check, this really should not happen ! */ 88908232a45SJérôme Glisse if (range->start < vma->vm_start || range->start >= vma->vm_end) 89074eee180SJérôme Glisse return -EINVAL; 89108232a45SJérôme Glisse if (range->end < vma->vm_start || range->end > vma->vm_end) 89274eee180SJérôme Glisse return -EINVAL; 89374eee180SJérôme Glisse 89474eee180SJérôme Glisse hmm = hmm_register(vma->vm_mm); 89574eee180SJérôme Glisse if (!hmm) { 896f88a1e90SJérôme Glisse hmm_pfns_clear(range, range->pfns, range->start, range->end); 89774eee180SJérôme Glisse return -ENOMEM; 89874eee180SJérôme Glisse } 89974eee180SJérôme Glisse /* Caller must have registered a mirror using hmm_mirror_register() */ 90074eee180SJérôme Glisse if (!hmm->mmu_notifier.ops) 90174eee180SJérôme Glisse return -EINVAL; 90274eee180SJérôme Glisse 903855ce7d2SJérôme Glisse /* FIXME support hugetlb fs */ 904e1fb4a08SDave Jiang if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL) || 905e1fb4a08SDave Jiang vma_is_dax(vma)) { 906855ce7d2SJérôme Glisse hmm_pfns_special(range); 907855ce7d2SJérôme Glisse return -EINVAL; 908855ce7d2SJérôme Glisse } 909855ce7d2SJérôme Glisse 91086586a41SJérôme Glisse if (!(vma->vm_flags & VM_READ)) { 91186586a41SJérôme Glisse /* 91286586a41SJérôme Glisse * If vma do not allow read access, then assume that it does 91386586a41SJérôme Glisse * not allow write access, either. Architecture that allow 91486586a41SJérôme Glisse * write without read access are not supported by HMM, because 91586586a41SJérôme Glisse * operations such has atomic access would not work. 91686586a41SJérôme Glisse */ 917f88a1e90SJérôme Glisse hmm_pfns_clear(range, range->pfns, range->start, range->end); 91886586a41SJérôme Glisse return -EPERM; 91986586a41SJérôme Glisse } 92074eee180SJérôme Glisse 92186586a41SJérôme Glisse /* Initialize range to track CPU page table update */ 92286586a41SJérôme Glisse spin_lock(&hmm->lock); 92386586a41SJérôme Glisse range->valid = true; 92486586a41SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 92586586a41SJérôme Glisse spin_unlock(&hmm->lock); 92686586a41SJérôme Glisse 92774eee180SJérôme Glisse hmm_vma_walk.fault = true; 92874eee180SJérôme Glisse hmm_vma_walk.block = block; 92974eee180SJérôme Glisse hmm_vma_walk.range = range; 93074eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 93174eee180SJérôme Glisse hmm_vma_walk.last = range->start; 93274eee180SJérôme Glisse 93374eee180SJérôme Glisse mm_walk.vma = vma; 93474eee180SJérôme Glisse mm_walk.mm = vma->vm_mm; 93574eee180SJérôme Glisse mm_walk.pte_entry = NULL; 93674eee180SJérôme Glisse mm_walk.test_walk = NULL; 93774eee180SJérôme Glisse mm_walk.hugetlb_entry = NULL; 93874eee180SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 93974eee180SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 94074eee180SJérôme Glisse 94174eee180SJérôme Glisse do { 94208232a45SJérôme Glisse ret = walk_page_range(start, range->end, &mm_walk); 94374eee180SJérôme Glisse start = hmm_vma_walk.last; 94474eee180SJérôme Glisse } while (ret == -EAGAIN); 94574eee180SJérôme Glisse 94674eee180SJérôme Glisse if (ret) { 94774eee180SJérôme Glisse unsigned long i; 94874eee180SJérôme Glisse 94974eee180SJérôme Glisse i = (hmm_vma_walk.last - range->start) >> PAGE_SHIFT; 950f88a1e90SJérôme Glisse hmm_pfns_clear(range, &range->pfns[i], hmm_vma_walk.last, 951f88a1e90SJérôme Glisse range->end); 95208232a45SJérôme Glisse hmm_vma_range_done(range); 95374eee180SJérôme Glisse } 95474eee180SJérôme Glisse return ret; 95574eee180SJérôme Glisse } 95674eee180SJérôme Glisse EXPORT_SYMBOL(hmm_vma_fault); 957c0b12405SJérôme Glisse #endif /* IS_ENABLED(CONFIG_HMM_MIRROR) */ 9584ef589dcSJérôme Glisse 9594ef589dcSJérôme Glisse 960df6ad698SJérôme Glisse #if IS_ENABLED(CONFIG_DEVICE_PRIVATE) || IS_ENABLED(CONFIG_DEVICE_PUBLIC) 9614ef589dcSJérôme Glisse struct page *hmm_vma_alloc_locked_page(struct vm_area_struct *vma, 9624ef589dcSJérôme Glisse unsigned long addr) 9634ef589dcSJérôme Glisse { 9644ef589dcSJérôme Glisse struct page *page; 9654ef589dcSJérôme Glisse 9664ef589dcSJérôme Glisse page = alloc_page_vma(GFP_HIGHUSER, vma, addr); 9674ef589dcSJérôme Glisse if (!page) 9684ef589dcSJérôme Glisse return NULL; 9694ef589dcSJérôme Glisse lock_page(page); 9704ef589dcSJérôme Glisse return page; 9714ef589dcSJérôme Glisse } 9724ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_vma_alloc_locked_page); 9734ef589dcSJérôme Glisse 9744ef589dcSJérôme Glisse 9754ef589dcSJérôme Glisse static void hmm_devmem_ref_release(struct percpu_ref *ref) 9764ef589dcSJérôme Glisse { 9774ef589dcSJérôme Glisse struct hmm_devmem *devmem; 9784ef589dcSJérôme Glisse 9794ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 9804ef589dcSJérôme Glisse complete(&devmem->completion); 9814ef589dcSJérôme Glisse } 9824ef589dcSJérôme Glisse 9834ef589dcSJérôme Glisse static void hmm_devmem_ref_exit(void *data) 9844ef589dcSJérôme Glisse { 9854ef589dcSJérôme Glisse struct percpu_ref *ref = data; 9864ef589dcSJérôme Glisse struct hmm_devmem *devmem; 9874ef589dcSJérôme Glisse 9884ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 989*bbecd94eSDan Williams wait_for_completion(&devmem->completion); 9904ef589dcSJérôme Glisse percpu_ref_exit(ref); 9914ef589dcSJérôme Glisse } 9924ef589dcSJérôme Glisse 993*bbecd94eSDan Williams static void hmm_devmem_ref_kill(struct percpu_ref *ref) 9944ef589dcSJérôme Glisse { 9954ef589dcSJérôme Glisse struct hmm_devmem *devmem; 9964ef589dcSJérôme Glisse 9974ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 9984ef589dcSJérôme Glisse percpu_ref_kill(ref); 9994ef589dcSJérôme Glisse } 10004ef589dcSJérôme Glisse 10014ef589dcSJérôme Glisse static int hmm_devmem_fault(struct vm_area_struct *vma, 10024ef589dcSJérôme Glisse unsigned long addr, 10034ef589dcSJérôme Glisse const struct page *page, 10044ef589dcSJérôme Glisse unsigned int flags, 10054ef589dcSJérôme Glisse pmd_t *pmdp) 10064ef589dcSJérôme Glisse { 10074ef589dcSJérôme Glisse struct hmm_devmem *devmem = page->pgmap->data; 10084ef589dcSJérôme Glisse 10094ef589dcSJérôme Glisse return devmem->ops->fault(devmem, vma, addr, page, flags, pmdp); 10104ef589dcSJérôme Glisse } 10114ef589dcSJérôme Glisse 10124ef589dcSJérôme Glisse static void hmm_devmem_free(struct page *page, void *data) 10134ef589dcSJérôme Glisse { 10144ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 10154ef589dcSJérôme Glisse 10162fa147bdSDan Williams page->mapping = NULL; 10172fa147bdSDan Williams 10184ef589dcSJérôme Glisse devmem->ops->free(devmem, page); 10194ef589dcSJérôme Glisse } 10204ef589dcSJérôme Glisse 10214ef589dcSJérôme Glisse /* 10224ef589dcSJérôme Glisse * hmm_devmem_add() - hotplug ZONE_DEVICE memory for device memory 10234ef589dcSJérôme Glisse * 10244ef589dcSJérôme Glisse * @ops: memory event device driver callback (see struct hmm_devmem_ops) 10254ef589dcSJérôme Glisse * @device: device struct to bind the resource too 10264ef589dcSJérôme Glisse * @size: size in bytes of the device memory to add 10274ef589dcSJérôme Glisse * Returns: pointer to new hmm_devmem struct ERR_PTR otherwise 10284ef589dcSJérôme Glisse * 10294ef589dcSJérôme Glisse * This function first finds an empty range of physical address big enough to 10304ef589dcSJérôme Glisse * contain the new resource, and then hotplugs it as ZONE_DEVICE memory, which 10314ef589dcSJérôme Glisse * in turn allocates struct pages. It does not do anything beyond that; all 10324ef589dcSJérôme Glisse * events affecting the memory will go through the various callbacks provided 10334ef589dcSJérôme Glisse * by hmm_devmem_ops struct. 10344ef589dcSJérôme Glisse * 10354ef589dcSJérôme Glisse * Device driver should call this function during device initialization and 10364ef589dcSJérôme Glisse * is then responsible of memory management. HMM only provides helpers. 10374ef589dcSJérôme Glisse */ 10384ef589dcSJérôme Glisse struct hmm_devmem *hmm_devmem_add(const struct hmm_devmem_ops *ops, 10394ef589dcSJérôme Glisse struct device *device, 10404ef589dcSJérôme Glisse unsigned long size) 10414ef589dcSJérôme Glisse { 10424ef589dcSJérôme Glisse struct hmm_devmem *devmem; 10434ef589dcSJérôme Glisse resource_size_t addr; 1044*bbecd94eSDan Williams void *result; 10454ef589dcSJérôme Glisse int ret; 10464ef589dcSJérôme Glisse 1047e7638488SDan Williams dev_pagemap_get_ops(); 10484ef589dcSJérôme Glisse 104958ef15b7SDan Williams devmem = devm_kzalloc(device, sizeof(*devmem), GFP_KERNEL); 10504ef589dcSJérôme Glisse if (!devmem) 10514ef589dcSJérôme Glisse return ERR_PTR(-ENOMEM); 10524ef589dcSJérôme Glisse 10534ef589dcSJérôme Glisse init_completion(&devmem->completion); 10544ef589dcSJérôme Glisse devmem->pfn_first = -1UL; 10554ef589dcSJérôme Glisse devmem->pfn_last = -1UL; 10564ef589dcSJérôme Glisse devmem->resource = NULL; 10574ef589dcSJérôme Glisse devmem->device = device; 10584ef589dcSJérôme Glisse devmem->ops = ops; 10594ef589dcSJérôme Glisse 10604ef589dcSJérôme Glisse ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release, 10614ef589dcSJérôme Glisse 0, GFP_KERNEL); 10624ef589dcSJérôme Glisse if (ret) 106358ef15b7SDan Williams return ERR_PTR(ret); 10644ef589dcSJérôme Glisse 106558ef15b7SDan Williams ret = devm_add_action_or_reset(device, hmm_devmem_ref_exit, &devmem->ref); 10664ef589dcSJérôme Glisse if (ret) 106758ef15b7SDan Williams return ERR_PTR(ret); 10684ef589dcSJérôme Glisse 10694ef589dcSJérôme Glisse size = ALIGN(size, PA_SECTION_SIZE); 10704ef589dcSJérôme Glisse addr = min((unsigned long)iomem_resource.end, 10714ef589dcSJérôme Glisse (1UL << MAX_PHYSMEM_BITS) - 1); 10724ef589dcSJérôme Glisse addr = addr - size + 1UL; 10734ef589dcSJérôme Glisse 10744ef589dcSJérôme Glisse /* 10754ef589dcSJérôme Glisse * FIXME add a new helper to quickly walk resource tree and find free 10764ef589dcSJérôme Glisse * range 10774ef589dcSJérôme Glisse * 10784ef589dcSJérôme Glisse * FIXME what about ioport_resource resource ? 10794ef589dcSJérôme Glisse */ 10804ef589dcSJérôme Glisse for (; addr > size && addr >= iomem_resource.start; addr -= size) { 10814ef589dcSJérôme Glisse ret = region_intersects(addr, size, 0, IORES_DESC_NONE); 10824ef589dcSJérôme Glisse if (ret != REGION_DISJOINT) 10834ef589dcSJérôme Glisse continue; 10844ef589dcSJérôme Glisse 10854ef589dcSJérôme Glisse devmem->resource = devm_request_mem_region(device, addr, size, 10864ef589dcSJérôme Glisse dev_name(device)); 108758ef15b7SDan Williams if (!devmem->resource) 108858ef15b7SDan Williams return ERR_PTR(-ENOMEM); 10894ef589dcSJérôme Glisse break; 10904ef589dcSJérôme Glisse } 109158ef15b7SDan Williams if (!devmem->resource) 109258ef15b7SDan Williams return ERR_PTR(-ERANGE); 10934ef589dcSJérôme Glisse 10944ef589dcSJérôme Glisse devmem->resource->desc = IORES_DESC_DEVICE_PRIVATE_MEMORY; 10954ef589dcSJérôme Glisse devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT; 10964ef589dcSJérôme Glisse devmem->pfn_last = devmem->pfn_first + 10974ef589dcSJérôme Glisse (resource_size(devmem->resource) >> PAGE_SHIFT); 10984ef589dcSJérôme Glisse 1099*bbecd94eSDan Williams devmem->pagemap.type = MEMORY_DEVICE_PRIVATE; 1100*bbecd94eSDan Williams devmem->pagemap.res = *devmem->resource; 1101*bbecd94eSDan Williams devmem->pagemap.page_fault = hmm_devmem_fault; 1102*bbecd94eSDan Williams devmem->pagemap.page_free = hmm_devmem_free; 1103*bbecd94eSDan Williams devmem->pagemap.altmap_valid = false; 1104*bbecd94eSDan Williams devmem->pagemap.ref = &devmem->ref; 1105*bbecd94eSDan Williams devmem->pagemap.data = devmem; 1106*bbecd94eSDan Williams devmem->pagemap.kill = hmm_devmem_ref_kill; 110758ef15b7SDan Williams 1108*bbecd94eSDan Williams result = devm_memremap_pages(devmem->device, &devmem->pagemap); 1109*bbecd94eSDan Williams if (IS_ERR(result)) 1110*bbecd94eSDan Williams return result; 11114ef589dcSJérôme Glisse return devmem; 11124ef589dcSJérôme Glisse } 11134ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add); 11144ef589dcSJérôme Glisse 1115d3df0a42SJérôme Glisse struct hmm_devmem *hmm_devmem_add_resource(const struct hmm_devmem_ops *ops, 1116d3df0a42SJérôme Glisse struct device *device, 1117d3df0a42SJérôme Glisse struct resource *res) 1118d3df0a42SJérôme Glisse { 1119d3df0a42SJérôme Glisse struct hmm_devmem *devmem; 1120*bbecd94eSDan Williams void *result; 1121d3df0a42SJérôme Glisse int ret; 1122d3df0a42SJérôme Glisse 1123d3df0a42SJérôme Glisse if (res->desc != IORES_DESC_DEVICE_PUBLIC_MEMORY) 1124d3df0a42SJérôme Glisse return ERR_PTR(-EINVAL); 1125d3df0a42SJérôme Glisse 1126e7638488SDan Williams dev_pagemap_get_ops(); 1127d3df0a42SJérôme Glisse 112858ef15b7SDan Williams devmem = devm_kzalloc(device, sizeof(*devmem), GFP_KERNEL); 1129d3df0a42SJérôme Glisse if (!devmem) 1130d3df0a42SJérôme Glisse return ERR_PTR(-ENOMEM); 1131d3df0a42SJérôme Glisse 1132d3df0a42SJérôme Glisse init_completion(&devmem->completion); 1133d3df0a42SJérôme Glisse devmem->pfn_first = -1UL; 1134d3df0a42SJérôme Glisse devmem->pfn_last = -1UL; 1135d3df0a42SJérôme Glisse devmem->resource = res; 1136d3df0a42SJérôme Glisse devmem->device = device; 1137d3df0a42SJérôme Glisse devmem->ops = ops; 1138d3df0a42SJérôme Glisse 1139d3df0a42SJérôme Glisse ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release, 1140d3df0a42SJérôme Glisse 0, GFP_KERNEL); 1141d3df0a42SJérôme Glisse if (ret) 114258ef15b7SDan Williams return ERR_PTR(ret); 1143d3df0a42SJérôme Glisse 114458ef15b7SDan Williams ret = devm_add_action_or_reset(device, hmm_devmem_ref_exit, 114558ef15b7SDan Williams &devmem->ref); 1146d3df0a42SJérôme Glisse if (ret) 114758ef15b7SDan Williams return ERR_PTR(ret); 1148d3df0a42SJérôme Glisse 1149d3df0a42SJérôme Glisse devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT; 1150d3df0a42SJérôme Glisse devmem->pfn_last = devmem->pfn_first + 1151d3df0a42SJérôme Glisse (resource_size(devmem->resource) >> PAGE_SHIFT); 1152d3df0a42SJérôme Glisse 1153*bbecd94eSDan Williams devmem->pagemap.type = MEMORY_DEVICE_PUBLIC; 1154*bbecd94eSDan Williams devmem->pagemap.res = *devmem->resource; 1155*bbecd94eSDan Williams devmem->pagemap.page_fault = hmm_devmem_fault; 1156*bbecd94eSDan Williams devmem->pagemap.page_free = hmm_devmem_free; 1157*bbecd94eSDan Williams devmem->pagemap.altmap_valid = false; 1158*bbecd94eSDan Williams devmem->pagemap.ref = &devmem->ref; 1159*bbecd94eSDan Williams devmem->pagemap.data = devmem; 1160*bbecd94eSDan Williams devmem->pagemap.kill = hmm_devmem_ref_kill; 116158ef15b7SDan Williams 1162*bbecd94eSDan Williams result = devm_memremap_pages(devmem->device, &devmem->pagemap); 1163*bbecd94eSDan Williams if (IS_ERR(result)) 1164*bbecd94eSDan Williams return result; 1165d3df0a42SJérôme Glisse return devmem; 1166d3df0a42SJérôme Glisse } 1167d3df0a42SJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add_resource); 1168d3df0a42SJérôme Glisse 11694ef589dcSJérôme Glisse /* 1170858b54daSJérôme Glisse * A device driver that wants to handle multiple devices memory through a 1171858b54daSJérôme Glisse * single fake device can use hmm_device to do so. This is purely a helper 1172858b54daSJérôme Glisse * and it is not needed to make use of any HMM functionality. 1173858b54daSJérôme Glisse */ 1174858b54daSJérôme Glisse #define HMM_DEVICE_MAX 256 1175858b54daSJérôme Glisse 1176858b54daSJérôme Glisse static DECLARE_BITMAP(hmm_device_mask, HMM_DEVICE_MAX); 1177858b54daSJérôme Glisse static DEFINE_SPINLOCK(hmm_device_lock); 1178858b54daSJérôme Glisse static struct class *hmm_device_class; 1179858b54daSJérôme Glisse static dev_t hmm_device_devt; 1180858b54daSJérôme Glisse 1181858b54daSJérôme Glisse static void hmm_device_release(struct device *device) 1182858b54daSJérôme Glisse { 1183858b54daSJérôme Glisse struct hmm_device *hmm_device; 1184858b54daSJérôme Glisse 1185858b54daSJérôme Glisse hmm_device = container_of(device, struct hmm_device, device); 1186858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1187858b54daSJérôme Glisse clear_bit(hmm_device->minor, hmm_device_mask); 1188858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1189858b54daSJérôme Glisse 1190858b54daSJérôme Glisse kfree(hmm_device); 1191858b54daSJérôme Glisse } 1192858b54daSJérôme Glisse 1193858b54daSJérôme Glisse struct hmm_device *hmm_device_new(void *drvdata) 1194858b54daSJérôme Glisse { 1195858b54daSJérôme Glisse struct hmm_device *hmm_device; 1196858b54daSJérôme Glisse 1197858b54daSJérôme Glisse hmm_device = kzalloc(sizeof(*hmm_device), GFP_KERNEL); 1198858b54daSJérôme Glisse if (!hmm_device) 1199858b54daSJérôme Glisse return ERR_PTR(-ENOMEM); 1200858b54daSJérôme Glisse 1201858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1202858b54daSJérôme Glisse hmm_device->minor = find_first_zero_bit(hmm_device_mask, HMM_DEVICE_MAX); 1203858b54daSJérôme Glisse if (hmm_device->minor >= HMM_DEVICE_MAX) { 1204858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1205858b54daSJérôme Glisse kfree(hmm_device); 1206858b54daSJérôme Glisse return ERR_PTR(-EBUSY); 1207858b54daSJérôme Glisse } 1208858b54daSJérôme Glisse set_bit(hmm_device->minor, hmm_device_mask); 1209858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1210858b54daSJérôme Glisse 1211858b54daSJérôme Glisse dev_set_name(&hmm_device->device, "hmm_device%d", hmm_device->minor); 1212858b54daSJérôme Glisse hmm_device->device.devt = MKDEV(MAJOR(hmm_device_devt), 1213858b54daSJérôme Glisse hmm_device->minor); 1214858b54daSJérôme Glisse hmm_device->device.release = hmm_device_release; 1215858b54daSJérôme Glisse dev_set_drvdata(&hmm_device->device, drvdata); 1216858b54daSJérôme Glisse hmm_device->device.class = hmm_device_class; 1217858b54daSJérôme Glisse device_initialize(&hmm_device->device); 1218858b54daSJérôme Glisse 1219858b54daSJérôme Glisse return hmm_device; 1220858b54daSJérôme Glisse } 1221858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_new); 1222858b54daSJérôme Glisse 1223858b54daSJérôme Glisse void hmm_device_put(struct hmm_device *hmm_device) 1224858b54daSJérôme Glisse { 1225858b54daSJérôme Glisse put_device(&hmm_device->device); 1226858b54daSJérôme Glisse } 1227858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_put); 1228858b54daSJérôme Glisse 1229858b54daSJérôme Glisse static int __init hmm_init(void) 1230858b54daSJérôme Glisse { 1231858b54daSJérôme Glisse int ret; 1232858b54daSJérôme Glisse 1233858b54daSJérôme Glisse ret = alloc_chrdev_region(&hmm_device_devt, 0, 1234858b54daSJérôme Glisse HMM_DEVICE_MAX, 1235858b54daSJérôme Glisse "hmm_device"); 1236858b54daSJérôme Glisse if (ret) 1237858b54daSJérôme Glisse return ret; 1238858b54daSJérôme Glisse 1239858b54daSJérôme Glisse hmm_device_class = class_create(THIS_MODULE, "hmm_device"); 1240858b54daSJérôme Glisse if (IS_ERR(hmm_device_class)) { 1241858b54daSJérôme Glisse unregister_chrdev_region(hmm_device_devt, HMM_DEVICE_MAX); 1242858b54daSJérôme Glisse return PTR_ERR(hmm_device_class); 1243858b54daSJérôme Glisse } 1244858b54daSJérôme Glisse return 0; 1245858b54daSJérôme Glisse } 1246858b54daSJérôme Glisse 1247858b54daSJérôme Glisse device_initcall(hmm_init); 1248df6ad698SJérôme Glisse #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */ 1249