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 386b368cd4SJérôme Glisse #if defined(CONFIG_DEVICE_PRIVATE) || defined(CONFIG_DEVICE_PUBLIC) 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); 446b368cd4SJérôme Glisse #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */ 457b2d55d2SJérôme Glisse 467b2d55d2SJérôme Glisse 476b368cd4SJérôme Glisse #if IS_ENABLED(CONFIG_HMM_MIRROR) 48c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops; 49c0b12405SJérôme Glisse 50133ff0eaSJérôme Glisse /* 51133ff0eaSJérôme Glisse * struct hmm - HMM per mm struct 52133ff0eaSJérôme Glisse * 53133ff0eaSJérôme Glisse * @mm: mm struct this HMM struct is bound to 54da4c3c73SJérôme Glisse * @lock: lock protecting ranges list 55c0b12405SJérôme Glisse * @sequence: we track updates to the CPU page table with a sequence number 56da4c3c73SJérôme Glisse * @ranges: list of range being snapshotted 57c0b12405SJérôme Glisse * @mirrors: list of mirrors for this mm 58c0b12405SJérôme Glisse * @mmu_notifier: mmu notifier to track updates to CPU page table 59c0b12405SJérôme Glisse * @mirrors_sem: read/write semaphore protecting the mirrors list 60133ff0eaSJérôme Glisse */ 61133ff0eaSJérôme Glisse struct hmm { 62133ff0eaSJérôme Glisse struct mm_struct *mm; 63da4c3c73SJérôme Glisse spinlock_t lock; 64c0b12405SJérôme Glisse atomic_t sequence; 65da4c3c73SJérôme Glisse struct list_head ranges; 66c0b12405SJérôme Glisse struct list_head mirrors; 67c0b12405SJérôme Glisse struct mmu_notifier mmu_notifier; 68c0b12405SJérôme Glisse struct rw_semaphore mirrors_sem; 69133ff0eaSJérôme Glisse }; 70133ff0eaSJérôme Glisse 71133ff0eaSJérôme Glisse /* 72133ff0eaSJérôme Glisse * hmm_register - register HMM against an mm (HMM internal) 73133ff0eaSJérôme Glisse * 74133ff0eaSJérôme Glisse * @mm: mm struct to attach to 75133ff0eaSJérôme Glisse * 76133ff0eaSJérôme Glisse * This is not intended to be used directly by device drivers. It allocates an 77133ff0eaSJérôme Glisse * HMM struct if mm does not have one, and initializes it. 78133ff0eaSJérôme Glisse */ 79133ff0eaSJérôme Glisse static struct hmm *hmm_register(struct mm_struct *mm) 80133ff0eaSJérôme Glisse { 81c0b12405SJérôme Glisse struct hmm *hmm = READ_ONCE(mm->hmm); 82c0b12405SJérôme Glisse bool cleanup = false; 83133ff0eaSJérôme Glisse 84133ff0eaSJérôme Glisse /* 85133ff0eaSJérôme Glisse * The hmm struct can only be freed once the mm_struct goes away, 86133ff0eaSJérôme Glisse * hence we should always have pre-allocated an new hmm struct 87133ff0eaSJérôme Glisse * above. 88133ff0eaSJérôme Glisse */ 89c0b12405SJérôme Glisse if (hmm) 90c0b12405SJérôme Glisse return hmm; 91c0b12405SJérôme Glisse 92c0b12405SJérôme Glisse hmm = kmalloc(sizeof(*hmm), GFP_KERNEL); 93c0b12405SJérôme Glisse if (!hmm) 94c0b12405SJérôme Glisse return NULL; 95c0b12405SJérôme Glisse INIT_LIST_HEAD(&hmm->mirrors); 96c0b12405SJérôme Glisse init_rwsem(&hmm->mirrors_sem); 97c0b12405SJérôme Glisse atomic_set(&hmm->sequence, 0); 98c0b12405SJérôme Glisse hmm->mmu_notifier.ops = NULL; 99da4c3c73SJérôme Glisse INIT_LIST_HEAD(&hmm->ranges); 100da4c3c73SJérôme Glisse spin_lock_init(&hmm->lock); 101c0b12405SJérôme Glisse hmm->mm = mm; 102c0b12405SJérôme Glisse 103c0b12405SJérôme Glisse /* 104c0b12405SJérôme Glisse * We should only get here if hold the mmap_sem in write mode ie on 105c0b12405SJérôme Glisse * registration of first mirror through hmm_mirror_register() 106c0b12405SJérôme Glisse */ 107c0b12405SJérôme Glisse hmm->mmu_notifier.ops = &hmm_mmu_notifier_ops; 108c0b12405SJérôme Glisse if (__mmu_notifier_register(&hmm->mmu_notifier, mm)) { 109c0b12405SJérôme Glisse kfree(hmm); 110c0b12405SJérôme Glisse return NULL; 111c0b12405SJérôme Glisse } 112c0b12405SJérôme Glisse 113c0b12405SJérôme Glisse spin_lock(&mm->page_table_lock); 114c0b12405SJérôme Glisse if (!mm->hmm) 115c0b12405SJérôme Glisse mm->hmm = hmm; 116c0b12405SJérôme Glisse else 117c0b12405SJérôme Glisse cleanup = true; 118c0b12405SJérôme Glisse spin_unlock(&mm->page_table_lock); 119c0b12405SJérôme Glisse 120c0b12405SJérôme Glisse if (cleanup) { 121c0b12405SJérôme Glisse mmu_notifier_unregister(&hmm->mmu_notifier, mm); 122c0b12405SJérôme Glisse kfree(hmm); 123c0b12405SJérôme Glisse } 124c0b12405SJérôme Glisse 125133ff0eaSJérôme Glisse return mm->hmm; 126133ff0eaSJérôme Glisse } 127133ff0eaSJérôme Glisse 128133ff0eaSJérôme Glisse void hmm_mm_destroy(struct mm_struct *mm) 129133ff0eaSJérôme Glisse { 130133ff0eaSJérôme Glisse kfree(mm->hmm); 131133ff0eaSJérôme Glisse } 132c0b12405SJérôme Glisse 133c0b12405SJérôme Glisse static void hmm_invalidate_range(struct hmm *hmm, 134c0b12405SJérôme Glisse enum hmm_update_type action, 135c0b12405SJérôme Glisse unsigned long start, 136c0b12405SJérôme Glisse unsigned long end) 137c0b12405SJérôme Glisse { 138c0b12405SJérôme Glisse struct hmm_mirror *mirror; 139da4c3c73SJérôme Glisse struct hmm_range *range; 140da4c3c73SJérôme Glisse 141da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 142da4c3c73SJérôme Glisse list_for_each_entry(range, &hmm->ranges, list) { 143da4c3c73SJérôme Glisse unsigned long addr, idx, npages; 144da4c3c73SJérôme Glisse 145da4c3c73SJérôme Glisse if (end < range->start || start >= range->end) 146da4c3c73SJérôme Glisse continue; 147da4c3c73SJérôme Glisse 148da4c3c73SJérôme Glisse range->valid = false; 149da4c3c73SJérôme Glisse addr = max(start, range->start); 150da4c3c73SJérôme Glisse idx = (addr - range->start) >> PAGE_SHIFT; 151da4c3c73SJérôme Glisse npages = (min(range->end, end) - addr) >> PAGE_SHIFT; 152da4c3c73SJérôme Glisse memset(&range->pfns[idx], 0, sizeof(*range->pfns) * npages); 153da4c3c73SJérôme Glisse } 154da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 155c0b12405SJérôme Glisse 156c0b12405SJérôme Glisse down_read(&hmm->mirrors_sem); 157c0b12405SJérôme Glisse list_for_each_entry(mirror, &hmm->mirrors, list) 158c0b12405SJérôme Glisse mirror->ops->sync_cpu_device_pagetables(mirror, action, 159c0b12405SJérôme Glisse start, end); 160c0b12405SJérôme Glisse up_read(&hmm->mirrors_sem); 161c0b12405SJérôme Glisse } 162c0b12405SJérôme Glisse 163e1401513SRalph Campbell static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm) 164e1401513SRalph Campbell { 165e1401513SRalph Campbell struct hmm_mirror *mirror; 166e1401513SRalph Campbell struct hmm *hmm = mm->hmm; 167e1401513SRalph Campbell 168e1401513SRalph Campbell down_write(&hmm->mirrors_sem); 169e1401513SRalph Campbell mirror = list_first_entry_or_null(&hmm->mirrors, struct hmm_mirror, 170e1401513SRalph Campbell list); 171e1401513SRalph Campbell while (mirror) { 172e1401513SRalph Campbell list_del_init(&mirror->list); 173e1401513SRalph Campbell if (mirror->ops->release) { 174e1401513SRalph Campbell /* 175e1401513SRalph Campbell * Drop mirrors_sem so callback can wait on any pending 176e1401513SRalph Campbell * work that might itself trigger mmu_notifier callback 177e1401513SRalph Campbell * and thus would deadlock with us. 178e1401513SRalph Campbell */ 179e1401513SRalph Campbell up_write(&hmm->mirrors_sem); 180e1401513SRalph Campbell mirror->ops->release(mirror); 181e1401513SRalph Campbell down_write(&hmm->mirrors_sem); 182e1401513SRalph Campbell } 183e1401513SRalph Campbell mirror = list_first_entry_or_null(&hmm->mirrors, 184e1401513SRalph Campbell struct hmm_mirror, list); 185e1401513SRalph Campbell } 186e1401513SRalph Campbell up_write(&hmm->mirrors_sem); 187e1401513SRalph Campbell } 188e1401513SRalph Campbell 189c0b12405SJérôme Glisse static void hmm_invalidate_range_start(struct mmu_notifier *mn, 190c0b12405SJérôme Glisse struct mm_struct *mm, 191c0b12405SJérôme Glisse unsigned long start, 192c0b12405SJérôme Glisse unsigned long end) 193c0b12405SJérôme Glisse { 194c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 195c0b12405SJérôme Glisse 196c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 197c0b12405SJérôme Glisse 198c0b12405SJérôme Glisse atomic_inc(&hmm->sequence); 199c0b12405SJérôme Glisse } 200c0b12405SJérôme Glisse 201c0b12405SJérôme Glisse static void hmm_invalidate_range_end(struct mmu_notifier *mn, 202c0b12405SJérôme Glisse struct mm_struct *mm, 203c0b12405SJérôme Glisse unsigned long start, 204c0b12405SJérôme Glisse unsigned long end) 205c0b12405SJérôme Glisse { 206c0b12405SJérôme Glisse struct hmm *hmm = mm->hmm; 207c0b12405SJérôme Glisse 208c0b12405SJérôme Glisse VM_BUG_ON(!hmm); 209c0b12405SJérôme Glisse 210c0b12405SJérôme Glisse hmm_invalidate_range(mm->hmm, HMM_UPDATE_INVALIDATE, start, end); 211c0b12405SJérôme Glisse } 212c0b12405SJérôme Glisse 213c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops = { 214e1401513SRalph Campbell .release = hmm_release, 215c0b12405SJérôme Glisse .invalidate_range_start = hmm_invalidate_range_start, 216c0b12405SJérôme Glisse .invalidate_range_end = hmm_invalidate_range_end, 217c0b12405SJérôme Glisse }; 218c0b12405SJérôme Glisse 219c0b12405SJérôme Glisse /* 220c0b12405SJérôme Glisse * hmm_mirror_register() - register a mirror against an mm 221c0b12405SJérôme Glisse * 222c0b12405SJérôme Glisse * @mirror: new mirror struct to register 223c0b12405SJérôme Glisse * @mm: mm to register against 224c0b12405SJérôme Glisse * 225c0b12405SJérôme Glisse * To start mirroring a process address space, the device driver must register 226c0b12405SJérôme Glisse * an HMM mirror struct. 227c0b12405SJérôme Glisse * 228c0b12405SJérôme Glisse * THE mm->mmap_sem MUST BE HELD IN WRITE MODE ! 229c0b12405SJérôme Glisse */ 230c0b12405SJérôme Glisse int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm) 231c0b12405SJérôme Glisse { 232c0b12405SJérôme Glisse /* Sanity check */ 233c0b12405SJérôme Glisse if (!mm || !mirror || !mirror->ops) 234c0b12405SJérôme Glisse return -EINVAL; 235c0b12405SJérôme Glisse 236c01cbba2SJérôme Glisse again: 237c0b12405SJérôme Glisse mirror->hmm = hmm_register(mm); 238c0b12405SJérôme Glisse if (!mirror->hmm) 239c0b12405SJérôme Glisse return -ENOMEM; 240c0b12405SJérôme Glisse 241c0b12405SJérôme Glisse down_write(&mirror->hmm->mirrors_sem); 242c01cbba2SJérôme Glisse if (mirror->hmm->mm == NULL) { 243c01cbba2SJérôme Glisse /* 244c01cbba2SJérôme Glisse * A racing hmm_mirror_unregister() is about to destroy the hmm 245c01cbba2SJérôme Glisse * struct. Try again to allocate a new one. 246c01cbba2SJérôme Glisse */ 247c01cbba2SJérôme Glisse up_write(&mirror->hmm->mirrors_sem); 248c01cbba2SJérôme Glisse mirror->hmm = NULL; 249c01cbba2SJérôme Glisse goto again; 250c01cbba2SJérôme Glisse } else { 251c0b12405SJérôme Glisse list_add(&mirror->list, &mirror->hmm->mirrors); 252c0b12405SJérôme Glisse up_write(&mirror->hmm->mirrors_sem); 253c01cbba2SJérôme Glisse } 254c0b12405SJérôme Glisse 255c0b12405SJérôme Glisse return 0; 256c0b12405SJérôme Glisse } 257c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_register); 258c0b12405SJérôme Glisse 259c0b12405SJérôme Glisse /* 260c0b12405SJérôme Glisse * hmm_mirror_unregister() - unregister a mirror 261c0b12405SJérôme Glisse * 262c0b12405SJérôme Glisse * @mirror: new mirror struct to register 263c0b12405SJérôme Glisse * 264c0b12405SJérôme Glisse * Stop mirroring a process address space, and cleanup. 265c0b12405SJérôme Glisse */ 266c0b12405SJérôme Glisse void hmm_mirror_unregister(struct hmm_mirror *mirror) 267c0b12405SJérôme Glisse { 268c01cbba2SJérôme Glisse bool should_unregister = false; 269c01cbba2SJérôme Glisse struct mm_struct *mm; 270c01cbba2SJérôme Glisse struct hmm *hmm; 271c0b12405SJérôme Glisse 272c01cbba2SJérôme Glisse if (mirror->hmm == NULL) 273c01cbba2SJérôme Glisse return; 274c01cbba2SJérôme Glisse 275c01cbba2SJérôme Glisse hmm = mirror->hmm; 276c0b12405SJérôme Glisse down_write(&hmm->mirrors_sem); 277e1401513SRalph Campbell list_del_init(&mirror->list); 278c01cbba2SJérôme Glisse should_unregister = list_empty(&hmm->mirrors); 279c01cbba2SJérôme Glisse mirror->hmm = NULL; 280c01cbba2SJérôme Glisse mm = hmm->mm; 281c01cbba2SJérôme Glisse hmm->mm = NULL; 282c0b12405SJérôme Glisse up_write(&hmm->mirrors_sem); 283c01cbba2SJérôme Glisse 284c01cbba2SJérôme Glisse if (!should_unregister || mm == NULL) 285c01cbba2SJérôme Glisse return; 286c01cbba2SJérôme Glisse 287c01cbba2SJérôme Glisse spin_lock(&mm->page_table_lock); 288c01cbba2SJérôme Glisse if (mm->hmm == hmm) 289c01cbba2SJérôme Glisse mm->hmm = NULL; 290c01cbba2SJérôme Glisse spin_unlock(&mm->page_table_lock); 291c01cbba2SJérôme Glisse 292c01cbba2SJérôme Glisse mmu_notifier_unregister_no_release(&hmm->mmu_notifier, mm); 293c01cbba2SJérôme Glisse kfree(hmm); 294c0b12405SJérôme Glisse } 295c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_unregister); 296da4c3c73SJérôme Glisse 29774eee180SJérôme Glisse struct hmm_vma_walk { 29874eee180SJérôme Glisse struct hmm_range *range; 29974eee180SJérôme Glisse unsigned long last; 30074eee180SJérôme Glisse bool fault; 30174eee180SJérôme Glisse bool block; 30274eee180SJérôme Glisse bool write; 30374eee180SJérôme Glisse }; 30474eee180SJérôme Glisse 30574eee180SJérôme Glisse static int hmm_vma_do_fault(struct mm_walk *walk, 30674eee180SJérôme Glisse unsigned long addr, 307ff05c0c6SJérôme Glisse uint64_t *pfn) 30874eee180SJérôme Glisse { 30974eee180SJérôme Glisse unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_REMOTE; 31074eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 31174eee180SJérôme Glisse struct vm_area_struct *vma = walk->vma; 31274eee180SJérôme Glisse int r; 31374eee180SJérôme Glisse 31474eee180SJérôme Glisse flags |= hmm_vma_walk->block ? 0 : FAULT_FLAG_ALLOW_RETRY; 31574eee180SJérôme Glisse flags |= hmm_vma_walk->write ? FAULT_FLAG_WRITE : 0; 31674eee180SJérôme Glisse r = handle_mm_fault(vma, addr, flags); 31774eee180SJérôme Glisse if (r & VM_FAULT_RETRY) 31874eee180SJérôme Glisse return -EBUSY; 31974eee180SJérôme Glisse if (r & VM_FAULT_ERROR) { 32074eee180SJérôme Glisse *pfn = HMM_PFN_ERROR; 32174eee180SJérôme Glisse return -EFAULT; 32274eee180SJérôme Glisse } 32374eee180SJérôme Glisse 32474eee180SJérôme Glisse return -EAGAIN; 32574eee180SJérôme Glisse } 32674eee180SJérôme Glisse 327da4c3c73SJérôme Glisse static int hmm_pfns_bad(unsigned long addr, 328da4c3c73SJérôme Glisse unsigned long end, 329da4c3c73SJérôme Glisse struct mm_walk *walk) 330da4c3c73SJérôme Glisse { 331c719547fSJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 332c719547fSJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 333ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 334da4c3c73SJérôme Glisse unsigned long i; 335da4c3c73SJérôme Glisse 336da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 337da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) 338da4c3c73SJérôme Glisse pfns[i] = HMM_PFN_ERROR; 339da4c3c73SJérôme Glisse 340da4c3c73SJérôme Glisse return 0; 341da4c3c73SJérôme Glisse } 342da4c3c73SJérôme Glisse 3435504ed29SJérôme Glisse /* 3445504ed29SJérôme Glisse * hmm_vma_walk_hole() - handle a range lacking valid pmd or pte(s) 3455504ed29SJérôme Glisse * @start: range virtual start address (inclusive) 3465504ed29SJérôme Glisse * @end: range virtual end address (exclusive) 3475504ed29SJérôme Glisse * @walk: mm_walk structure 3485504ed29SJérôme Glisse * Returns: 0 on success, -EAGAIN after page fault, or page fault error 3495504ed29SJérôme Glisse * 3505504ed29SJérôme Glisse * This function will be called whenever pmd_none() or pte_none() returns true, 3515504ed29SJérôme Glisse * or whenever there is no page directory covering the virtual address range. 3525504ed29SJérôme Glisse */ 353da4c3c73SJérôme Glisse static int hmm_vma_walk_hole(unsigned long addr, 354da4c3c73SJérôme Glisse unsigned long end, 355da4c3c73SJérôme Glisse struct mm_walk *walk) 356da4c3c73SJérôme Glisse { 35774eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 35874eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 359ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 360da4c3c73SJérôme Glisse unsigned long i; 361da4c3c73SJérôme Glisse 36274eee180SJérôme Glisse hmm_vma_walk->last = addr; 363da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 36474eee180SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, i++) { 365da4c3c73SJérôme Glisse pfns[i] = 0; 36674eee180SJérôme Glisse if (hmm_vma_walk->fault) { 36774eee180SJérôme Glisse int ret; 368da4c3c73SJérôme Glisse 36974eee180SJérôme Glisse ret = hmm_vma_do_fault(walk, addr, &pfns[i]); 37074eee180SJérôme Glisse if (ret != -EAGAIN) 37174eee180SJérôme Glisse return ret; 37274eee180SJérôme Glisse } 37374eee180SJérôme Glisse } 37474eee180SJérôme Glisse 37574eee180SJérôme Glisse return hmm_vma_walk->fault ? -EAGAIN : 0; 376da4c3c73SJérôme Glisse } 377da4c3c73SJérôme Glisse 378*53f5c3f4SJérôme Glisse static int hmm_vma_handle_pmd(struct mm_walk *walk, 379*53f5c3f4SJérôme Glisse unsigned long addr, 380*53f5c3f4SJérôme Glisse unsigned long end, 381*53f5c3f4SJérôme Glisse uint64_t *pfns, 382*53f5c3f4SJérôme Glisse pmd_t pmd) 383*53f5c3f4SJérôme Glisse { 384*53f5c3f4SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 385*53f5c3f4SJérôme Glisse unsigned long pfn, i; 386*53f5c3f4SJérôme Glisse uint64_t flag = 0; 387*53f5c3f4SJérôme Glisse 388*53f5c3f4SJérôme Glisse if (pmd_protnone(pmd)) 389*53f5c3f4SJérôme Glisse return hmm_vma_walk_hole(addr, end, walk); 390*53f5c3f4SJérôme Glisse 391*53f5c3f4SJérôme Glisse if ((hmm_vma_walk->fault & hmm_vma_walk->write) && !pmd_write(pmd)) 392*53f5c3f4SJérôme Glisse return hmm_vma_walk_hole(addr, end, walk); 393*53f5c3f4SJérôme Glisse 394*53f5c3f4SJérôme Glisse pfn = pmd_pfn(pmd) + pte_index(addr); 395*53f5c3f4SJérôme Glisse flag |= pmd_write(pmd) ? HMM_PFN_WRITE : 0; 396*53f5c3f4SJérôme Glisse for (i = 0; addr < end; addr += PAGE_SIZE, i++, pfn++) 397*53f5c3f4SJérôme Glisse pfns[i] = hmm_pfn_from_pfn(pfn) | flag; 398*53f5c3f4SJérôme Glisse hmm_vma_walk->last = end; 399*53f5c3f4SJérôme Glisse return 0; 400*53f5c3f4SJérôme Glisse } 401*53f5c3f4SJérôme Glisse 402*53f5c3f4SJérôme Glisse static int hmm_vma_handle_pte(struct mm_walk *walk, unsigned long addr, 403*53f5c3f4SJérôme Glisse unsigned long end, pmd_t *pmdp, pte_t *ptep, 404*53f5c3f4SJérôme Glisse uint64_t *pfn) 405*53f5c3f4SJérôme Glisse { 406*53f5c3f4SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 407*53f5c3f4SJérôme Glisse struct vm_area_struct *vma = walk->vma; 408*53f5c3f4SJérôme Glisse pte_t pte = *ptep; 409*53f5c3f4SJérôme Glisse 410*53f5c3f4SJérôme Glisse *pfn = 0; 411*53f5c3f4SJérôme Glisse 412*53f5c3f4SJérôme Glisse if (pte_none(pte)) { 413*53f5c3f4SJérôme Glisse *pfn = 0; 414*53f5c3f4SJérôme Glisse if (hmm_vma_walk->fault) 415*53f5c3f4SJérôme Glisse goto fault; 416*53f5c3f4SJérôme Glisse return 0; 417*53f5c3f4SJérôme Glisse } 418*53f5c3f4SJérôme Glisse 419*53f5c3f4SJérôme Glisse if (!pte_present(pte)) { 420*53f5c3f4SJérôme Glisse swp_entry_t entry = pte_to_swp_entry(pte); 421*53f5c3f4SJérôme Glisse 422*53f5c3f4SJérôme Glisse if (!non_swap_entry(entry)) { 423*53f5c3f4SJérôme Glisse if (hmm_vma_walk->fault) 424*53f5c3f4SJérôme Glisse goto fault; 425*53f5c3f4SJérôme Glisse return 0; 426*53f5c3f4SJérôme Glisse } 427*53f5c3f4SJérôme Glisse 428*53f5c3f4SJérôme Glisse /* 429*53f5c3f4SJérôme Glisse * This is a special swap entry, ignore migration, use 430*53f5c3f4SJérôme Glisse * device and report anything else as error. 431*53f5c3f4SJérôme Glisse */ 432*53f5c3f4SJérôme Glisse if (is_device_private_entry(entry)) { 433*53f5c3f4SJérôme Glisse *pfn = hmm_pfn_from_pfn(swp_offset(entry)); 434*53f5c3f4SJérôme Glisse if (is_write_device_private_entry(entry)) { 435*53f5c3f4SJérôme Glisse *pfn |= HMM_PFN_WRITE; 436*53f5c3f4SJérôme Glisse } else if ((hmm_vma_walk->fault & hmm_vma_walk->write)) 437*53f5c3f4SJérôme Glisse goto fault; 438*53f5c3f4SJérôme Glisse *pfn |= HMM_PFN_DEVICE_PRIVATE; 439*53f5c3f4SJérôme Glisse return 0; 440*53f5c3f4SJérôme Glisse } 441*53f5c3f4SJérôme Glisse 442*53f5c3f4SJérôme Glisse if (is_migration_entry(entry)) { 443*53f5c3f4SJérôme Glisse if (hmm_vma_walk->fault) { 444*53f5c3f4SJérôme Glisse pte_unmap(ptep); 445*53f5c3f4SJérôme Glisse hmm_vma_walk->last = addr; 446*53f5c3f4SJérôme Glisse migration_entry_wait(vma->vm_mm, 447*53f5c3f4SJérôme Glisse pmdp, addr); 448*53f5c3f4SJérôme Glisse return -EAGAIN; 449*53f5c3f4SJérôme Glisse } 450*53f5c3f4SJérôme Glisse return 0; 451*53f5c3f4SJérôme Glisse } 452*53f5c3f4SJérôme Glisse 453*53f5c3f4SJérôme Glisse /* Report error for everything else */ 454*53f5c3f4SJérôme Glisse *pfn = HMM_PFN_ERROR; 455*53f5c3f4SJérôme Glisse return -EFAULT; 456*53f5c3f4SJérôme Glisse } 457*53f5c3f4SJérôme Glisse 458*53f5c3f4SJérôme Glisse if ((hmm_vma_walk->fault & hmm_vma_walk->write) && !pte_write(pte)) 459*53f5c3f4SJérôme Glisse goto fault; 460*53f5c3f4SJérôme Glisse 461*53f5c3f4SJérôme Glisse *pfn = hmm_pfn_from_pfn(pte_pfn(pte)); 462*53f5c3f4SJérôme Glisse *pfn |= pte_write(pte) ? HMM_PFN_WRITE : 0; 463*53f5c3f4SJérôme Glisse return 0; 464*53f5c3f4SJérôme Glisse 465*53f5c3f4SJérôme Glisse fault: 466*53f5c3f4SJérôme Glisse pte_unmap(ptep); 467*53f5c3f4SJérôme Glisse /* Fault any virtual address we were asked to fault */ 468*53f5c3f4SJérôme Glisse return hmm_vma_walk_hole(addr, end, walk); 469*53f5c3f4SJérôme Glisse } 470*53f5c3f4SJérôme Glisse 471da4c3c73SJérôme Glisse static int hmm_vma_walk_pmd(pmd_t *pmdp, 472da4c3c73SJérôme Glisse unsigned long start, 473da4c3c73SJérôme Glisse unsigned long end, 474da4c3c73SJérôme Glisse struct mm_walk *walk) 475da4c3c73SJérôme Glisse { 47674eee180SJérôme Glisse struct hmm_vma_walk *hmm_vma_walk = walk->private; 47774eee180SJérôme Glisse struct hmm_range *range = hmm_vma_walk->range; 478ff05c0c6SJérôme Glisse uint64_t *pfns = range->pfns; 479da4c3c73SJérôme Glisse unsigned long addr = start, i; 480da4c3c73SJérôme Glisse pte_t *ptep; 481da4c3c73SJérôme Glisse 482da4c3c73SJérôme Glisse i = (addr - range->start) >> PAGE_SHIFT; 483da4c3c73SJérôme Glisse 484da4c3c73SJérôme Glisse again: 485da4c3c73SJérôme Glisse if (pmd_none(*pmdp)) 486da4c3c73SJérôme Glisse return hmm_vma_walk_hole(start, end, walk); 487da4c3c73SJérôme Glisse 488*53f5c3f4SJérôme Glisse if (pmd_huge(*pmdp) && (range->vma->vm_flags & VM_HUGETLB)) 489da4c3c73SJérôme Glisse return hmm_pfns_bad(start, end, walk); 490da4c3c73SJérôme Glisse 491da4c3c73SJérôme Glisse if (pmd_devmap(*pmdp) || pmd_trans_huge(*pmdp)) { 492da4c3c73SJérôme Glisse pmd_t pmd; 493da4c3c73SJérôme Glisse 494da4c3c73SJérôme Glisse /* 495da4c3c73SJérôme Glisse * No need to take pmd_lock here, even if some other threads 496da4c3c73SJérôme Glisse * is splitting the huge pmd we will get that event through 497da4c3c73SJérôme Glisse * mmu_notifier callback. 498da4c3c73SJérôme Glisse * 499da4c3c73SJérôme Glisse * So just read pmd value and check again its a transparent 500da4c3c73SJérôme Glisse * huge or device mapping one and compute corresponding pfn 501da4c3c73SJérôme Glisse * values. 502da4c3c73SJérôme Glisse */ 503da4c3c73SJérôme Glisse pmd = pmd_read_atomic(pmdp); 504da4c3c73SJérôme Glisse barrier(); 505da4c3c73SJérôme Glisse if (!pmd_devmap(pmd) && !pmd_trans_huge(pmd)) 506da4c3c73SJérôme Glisse goto again; 507da4c3c73SJérôme Glisse 508*53f5c3f4SJérôme Glisse return hmm_vma_handle_pmd(walk, addr, end, &pfns[i], pmd); 509da4c3c73SJérôme Glisse } 510da4c3c73SJérôme Glisse 511da4c3c73SJérôme Glisse if (pmd_bad(*pmdp)) 512da4c3c73SJérôme Glisse return hmm_pfns_bad(start, end, walk); 513da4c3c73SJérôme Glisse 514da4c3c73SJérôme Glisse ptep = pte_offset_map(pmdp, addr); 515da4c3c73SJérôme Glisse for (; addr < end; addr += PAGE_SIZE, ptep++, i++) { 516*53f5c3f4SJérôme Glisse int r; 517da4c3c73SJérôme Glisse 518*53f5c3f4SJérôme Glisse r = hmm_vma_handle_pte(walk, addr, end, pmdp, ptep, &pfns[i]); 519*53f5c3f4SJérôme Glisse if (r) { 520*53f5c3f4SJérôme Glisse /* hmm_vma_handle_pte() did unmap pte directory */ 52174eee180SJérôme Glisse hmm_vma_walk->last = addr; 522*53f5c3f4SJérôme Glisse return r; 52374eee180SJérôme Glisse } 524da4c3c73SJérôme Glisse } 525da4c3c73SJérôme Glisse pte_unmap(ptep - 1); 526da4c3c73SJérôme Glisse 527*53f5c3f4SJérôme Glisse hmm_vma_walk->last = addr; 528da4c3c73SJérôme Glisse return 0; 529da4c3c73SJérôme Glisse } 530da4c3c73SJérôme Glisse 53133cd47dcSJérôme Glisse static void hmm_pfns_clear(uint64_t *pfns, 53233cd47dcSJérôme Glisse unsigned long addr, 53333cd47dcSJérôme Glisse unsigned long end) 53433cd47dcSJérôme Glisse { 53533cd47dcSJérôme Glisse for (; addr < end; addr += PAGE_SIZE, pfns++) 53633cd47dcSJérôme Glisse *pfns = 0; 53733cd47dcSJérôme Glisse } 53833cd47dcSJérôme Glisse 539855ce7d2SJérôme Glisse static void hmm_pfns_special(struct hmm_range *range) 540855ce7d2SJérôme Glisse { 541855ce7d2SJérôme Glisse unsigned long addr = range->start, i = 0; 542855ce7d2SJérôme Glisse 543855ce7d2SJérôme Glisse for (; addr < range->end; addr += PAGE_SIZE, i++) 544855ce7d2SJérôme Glisse range->pfns[i] = HMM_PFN_SPECIAL; 545855ce7d2SJérôme Glisse } 546855ce7d2SJérôme Glisse 547da4c3c73SJérôme Glisse /* 548da4c3c73SJérôme Glisse * hmm_vma_get_pfns() - snapshot CPU page table for a range of virtual addresses 54908232a45SJérôme Glisse * @range: range being snapshotted 55086586a41SJérôme Glisse * Returns: -EINVAL if invalid argument, -ENOMEM out of memory, -EPERM invalid 55186586a41SJérôme Glisse * vma permission, 0 success 552da4c3c73SJérôme Glisse * 553da4c3c73SJérôme Glisse * This snapshots the CPU page table for a range of virtual addresses. Snapshot 554da4c3c73SJérôme Glisse * validity is tracked by range struct. See hmm_vma_range_done() for further 555da4c3c73SJérôme Glisse * information. 556da4c3c73SJérôme Glisse * 557da4c3c73SJérôme Glisse * The range struct is initialized here. It tracks the CPU page table, but only 558da4c3c73SJérôme Glisse * if the function returns success (0), in which case the caller must then call 559da4c3c73SJérôme Glisse * hmm_vma_range_done() to stop CPU page table update tracking on this range. 560da4c3c73SJérôme Glisse * 561da4c3c73SJérôme Glisse * NOT CALLING hmm_vma_range_done() IF FUNCTION RETURNS 0 WILL LEAD TO SERIOUS 562da4c3c73SJérôme Glisse * MEMORY CORRUPTION ! YOU HAVE BEEN WARNED ! 563da4c3c73SJérôme Glisse */ 56408232a45SJérôme Glisse int hmm_vma_get_pfns(struct hmm_range *range) 565da4c3c73SJérôme Glisse { 56608232a45SJérôme Glisse struct vm_area_struct *vma = range->vma; 56774eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 568da4c3c73SJérôme Glisse struct mm_walk mm_walk; 569da4c3c73SJérôme Glisse struct hmm *hmm; 570da4c3c73SJérôme Glisse 571da4c3c73SJérôme Glisse /* Sanity check, this really should not happen ! */ 57208232a45SJérôme Glisse if (range->start < vma->vm_start || range->start >= vma->vm_end) 573da4c3c73SJérôme Glisse return -EINVAL; 57408232a45SJérôme Glisse if (range->end < vma->vm_start || range->end > vma->vm_end) 575da4c3c73SJérôme Glisse return -EINVAL; 576da4c3c73SJérôme Glisse 577da4c3c73SJérôme Glisse hmm = hmm_register(vma->vm_mm); 578da4c3c73SJérôme Glisse if (!hmm) 579da4c3c73SJérôme Glisse return -ENOMEM; 580da4c3c73SJérôme Glisse /* Caller must have registered a mirror, via hmm_mirror_register() ! */ 581da4c3c73SJérôme Glisse if (!hmm->mmu_notifier.ops) 582da4c3c73SJérôme Glisse return -EINVAL; 583da4c3c73SJérôme Glisse 584855ce7d2SJérôme Glisse /* FIXME support hugetlb fs */ 585855ce7d2SJérôme Glisse if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL)) { 586855ce7d2SJérôme Glisse hmm_pfns_special(range); 587855ce7d2SJérôme Glisse return -EINVAL; 588855ce7d2SJérôme Glisse } 589855ce7d2SJérôme Glisse 59086586a41SJérôme Glisse if (!(vma->vm_flags & VM_READ)) { 59186586a41SJérôme Glisse /* 59286586a41SJérôme Glisse * If vma do not allow read access, then assume that it does 59386586a41SJérôme Glisse * not allow write access, either. Architecture that allow 59486586a41SJérôme Glisse * write without read access are not supported by HMM, because 59586586a41SJérôme Glisse * operations such has atomic access would not work. 59686586a41SJérôme Glisse */ 59786586a41SJérôme Glisse hmm_pfns_clear(range->pfns, range->start, range->end); 59886586a41SJérôme Glisse return -EPERM; 59986586a41SJérôme Glisse } 60086586a41SJérôme Glisse 601da4c3c73SJérôme Glisse /* Initialize range to track CPU page table update */ 602da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 603da4c3c73SJérôme Glisse range->valid = true; 604da4c3c73SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 605da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 606da4c3c73SJérôme Glisse 60774eee180SJérôme Glisse hmm_vma_walk.fault = false; 60874eee180SJérôme Glisse hmm_vma_walk.range = range; 60974eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 61074eee180SJérôme Glisse 611da4c3c73SJérôme Glisse mm_walk.vma = vma; 612da4c3c73SJérôme Glisse mm_walk.mm = vma->vm_mm; 613da4c3c73SJérôme Glisse mm_walk.pte_entry = NULL; 614da4c3c73SJérôme Glisse mm_walk.test_walk = NULL; 615da4c3c73SJérôme Glisse mm_walk.hugetlb_entry = NULL; 616da4c3c73SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 617da4c3c73SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 618da4c3c73SJérôme Glisse 61908232a45SJérôme Glisse walk_page_range(range->start, range->end, &mm_walk); 620da4c3c73SJérôme Glisse return 0; 621da4c3c73SJérôme Glisse } 622da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_get_pfns); 623da4c3c73SJérôme Glisse 624da4c3c73SJérôme Glisse /* 625da4c3c73SJérôme Glisse * hmm_vma_range_done() - stop tracking change to CPU page table over a range 626da4c3c73SJérôme Glisse * @range: range being tracked 627da4c3c73SJérôme Glisse * Returns: false if range data has been invalidated, true otherwise 628da4c3c73SJérôme Glisse * 629da4c3c73SJérôme Glisse * Range struct is used to track updates to the CPU page table after a call to 630da4c3c73SJérôme Glisse * either hmm_vma_get_pfns() or hmm_vma_fault(). Once the device driver is done 631da4c3c73SJérôme Glisse * using the data, or wants to lock updates to the data it got from those 632da4c3c73SJérôme Glisse * functions, it must call the hmm_vma_range_done() function, which will then 633da4c3c73SJérôme Glisse * stop tracking CPU page table updates. 634da4c3c73SJérôme Glisse * 635da4c3c73SJérôme Glisse * Note that device driver must still implement general CPU page table update 636da4c3c73SJérôme Glisse * tracking either by using hmm_mirror (see hmm_mirror_register()) or by using 637da4c3c73SJérôme Glisse * the mmu_notifier API directly. 638da4c3c73SJérôme Glisse * 639da4c3c73SJérôme Glisse * CPU page table update tracking done through hmm_range is only temporary and 640da4c3c73SJérôme Glisse * to be used while trying to duplicate CPU page table contents for a range of 641da4c3c73SJérôme Glisse * virtual addresses. 642da4c3c73SJérôme Glisse * 643da4c3c73SJérôme Glisse * There are two ways to use this : 644da4c3c73SJérôme Glisse * again: 64508232a45SJérôme Glisse * hmm_vma_get_pfns(range); or hmm_vma_fault(...); 646da4c3c73SJérôme Glisse * trans = device_build_page_table_update_transaction(pfns); 647da4c3c73SJérôme Glisse * device_page_table_lock(); 64808232a45SJérôme Glisse * if (!hmm_vma_range_done(range)) { 649da4c3c73SJérôme Glisse * device_page_table_unlock(); 650da4c3c73SJérôme Glisse * goto again; 651da4c3c73SJérôme Glisse * } 652da4c3c73SJérôme Glisse * device_commit_transaction(trans); 653da4c3c73SJérôme Glisse * device_page_table_unlock(); 654da4c3c73SJérôme Glisse * 655da4c3c73SJérôme Glisse * Or: 65608232a45SJérôme Glisse * hmm_vma_get_pfns(range); or hmm_vma_fault(...); 657da4c3c73SJérôme Glisse * device_page_table_lock(); 65808232a45SJérôme Glisse * hmm_vma_range_done(range); 65908232a45SJérôme Glisse * device_update_page_table(range->pfns); 660da4c3c73SJérôme Glisse * device_page_table_unlock(); 661da4c3c73SJérôme Glisse */ 66208232a45SJérôme Glisse bool hmm_vma_range_done(struct hmm_range *range) 663da4c3c73SJérôme Glisse { 664da4c3c73SJérôme Glisse unsigned long npages = (range->end - range->start) >> PAGE_SHIFT; 665da4c3c73SJérôme Glisse struct hmm *hmm; 666da4c3c73SJérôme Glisse 667da4c3c73SJérôme Glisse if (range->end <= range->start) { 668da4c3c73SJérôme Glisse BUG(); 669da4c3c73SJérôme Glisse return false; 670da4c3c73SJérôme Glisse } 671da4c3c73SJérôme Glisse 67208232a45SJérôme Glisse hmm = hmm_register(range->vma->vm_mm); 673da4c3c73SJérôme Glisse if (!hmm) { 674da4c3c73SJérôme Glisse memset(range->pfns, 0, sizeof(*range->pfns) * npages); 675da4c3c73SJérôme Glisse return false; 676da4c3c73SJérôme Glisse } 677da4c3c73SJérôme Glisse 678da4c3c73SJérôme Glisse spin_lock(&hmm->lock); 679da4c3c73SJérôme Glisse list_del_rcu(&range->list); 680da4c3c73SJérôme Glisse spin_unlock(&hmm->lock); 681da4c3c73SJérôme Glisse 682da4c3c73SJérôme Glisse return range->valid; 683da4c3c73SJérôme Glisse } 684da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_range_done); 68574eee180SJérôme Glisse 68674eee180SJérôme Glisse /* 68774eee180SJérôme Glisse * hmm_vma_fault() - try to fault some address in a virtual address range 68808232a45SJérôme Glisse * @range: range being faulted 68974eee180SJérôme Glisse * @write: is it a write fault 69074eee180SJérôme Glisse * @block: allow blocking on fault (if true it sleeps and do not drop mmap_sem) 69174eee180SJérôme Glisse * Returns: 0 success, error otherwise (-EAGAIN means mmap_sem have been drop) 69274eee180SJérôme Glisse * 69374eee180SJérôme Glisse * This is similar to a regular CPU page fault except that it will not trigger 69474eee180SJérôme Glisse * any memory migration if the memory being faulted is not accessible by CPUs. 69574eee180SJérôme Glisse * 696ff05c0c6SJérôme Glisse * On error, for one virtual address in the range, the function will mark the 697ff05c0c6SJérôme Glisse * corresponding HMM pfn entry with an error flag. 69874eee180SJérôme Glisse * 69974eee180SJérôme Glisse * Expected use pattern: 70074eee180SJérôme Glisse * retry: 70174eee180SJérôme Glisse * down_read(&mm->mmap_sem); 70274eee180SJérôme Glisse * // Find vma and address device wants to fault, initialize hmm_pfn_t 70374eee180SJérôme Glisse * // array accordingly 70408232a45SJérôme Glisse * ret = hmm_vma_fault(range, write, block); 70574eee180SJérôme Glisse * switch (ret) { 70674eee180SJérôme Glisse * case -EAGAIN: 70708232a45SJérôme Glisse * hmm_vma_range_done(range); 70874eee180SJérôme Glisse * // You might want to rate limit or yield to play nicely, you may 70974eee180SJérôme Glisse * // also commit any valid pfn in the array assuming that you are 71074eee180SJérôme Glisse * // getting true from hmm_vma_range_monitor_end() 71174eee180SJérôme Glisse * goto retry; 71274eee180SJérôme Glisse * case 0: 71374eee180SJérôme Glisse * break; 71486586a41SJérôme Glisse * case -ENOMEM: 71586586a41SJérôme Glisse * case -EINVAL: 71686586a41SJérôme Glisse * case -EPERM: 71774eee180SJérôme Glisse * default: 71874eee180SJérôme Glisse * // Handle error ! 71974eee180SJérôme Glisse * up_read(&mm->mmap_sem) 72074eee180SJérôme Glisse * return; 72174eee180SJérôme Glisse * } 72274eee180SJérôme Glisse * // Take device driver lock that serialize device page table update 72374eee180SJérôme Glisse * driver_lock_device_page_table_update(); 72408232a45SJérôme Glisse * hmm_vma_range_done(range); 72574eee180SJérôme Glisse * // Commit pfns we got from hmm_vma_fault() 72674eee180SJérôme Glisse * driver_unlock_device_page_table_update(); 72774eee180SJérôme Glisse * up_read(&mm->mmap_sem) 72874eee180SJérôme Glisse * 72974eee180SJérôme Glisse * YOU MUST CALL hmm_vma_range_done() AFTER THIS FUNCTION RETURN SUCCESS (0) 73074eee180SJérôme Glisse * BEFORE FREEING THE range struct OR YOU WILL HAVE SERIOUS MEMORY CORRUPTION ! 73174eee180SJérôme Glisse * 73274eee180SJérôme Glisse * YOU HAVE BEEN WARNED ! 73374eee180SJérôme Glisse */ 73408232a45SJérôme Glisse int hmm_vma_fault(struct hmm_range *range, bool write, bool block) 73574eee180SJérôme Glisse { 73608232a45SJérôme Glisse struct vm_area_struct *vma = range->vma; 73708232a45SJérôme Glisse unsigned long start = range->start; 73874eee180SJérôme Glisse struct hmm_vma_walk hmm_vma_walk; 73974eee180SJérôme Glisse struct mm_walk mm_walk; 74074eee180SJérôme Glisse struct hmm *hmm; 74174eee180SJérôme Glisse int ret; 74274eee180SJérôme Glisse 74374eee180SJérôme Glisse /* Sanity check, this really should not happen ! */ 74408232a45SJérôme Glisse if (range->start < vma->vm_start || range->start >= vma->vm_end) 74574eee180SJérôme Glisse return -EINVAL; 74608232a45SJérôme Glisse if (range->end < vma->vm_start || range->end > vma->vm_end) 74774eee180SJérôme Glisse return -EINVAL; 74874eee180SJérôme Glisse 74974eee180SJérôme Glisse hmm = hmm_register(vma->vm_mm); 75074eee180SJérôme Glisse if (!hmm) { 75108232a45SJérôme Glisse hmm_pfns_clear(range->pfns, range->start, range->end); 75274eee180SJérôme Glisse return -ENOMEM; 75374eee180SJérôme Glisse } 75474eee180SJérôme Glisse /* Caller must have registered a mirror using hmm_mirror_register() */ 75574eee180SJérôme Glisse if (!hmm->mmu_notifier.ops) 75674eee180SJérôme Glisse return -EINVAL; 75774eee180SJérôme Glisse 758855ce7d2SJérôme Glisse /* FIXME support hugetlb fs */ 759855ce7d2SJérôme Glisse if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL)) { 760855ce7d2SJérôme Glisse hmm_pfns_special(range); 761855ce7d2SJérôme Glisse return -EINVAL; 762855ce7d2SJérôme Glisse } 763855ce7d2SJérôme Glisse 76486586a41SJérôme Glisse if (!(vma->vm_flags & VM_READ)) { 76586586a41SJérôme Glisse /* 76686586a41SJérôme Glisse * If vma do not allow read access, then assume that it does 76786586a41SJérôme Glisse * not allow write access, either. Architecture that allow 76886586a41SJérôme Glisse * write without read access are not supported by HMM, because 76986586a41SJérôme Glisse * operations such has atomic access would not work. 77086586a41SJérôme Glisse */ 77186586a41SJérôme Glisse hmm_pfns_clear(range->pfns, range->start, range->end); 77286586a41SJérôme Glisse return -EPERM; 77386586a41SJérôme Glisse } 77474eee180SJérôme Glisse 77586586a41SJérôme Glisse /* Initialize range to track CPU page table update */ 77686586a41SJérôme Glisse spin_lock(&hmm->lock); 77786586a41SJérôme Glisse range->valid = true; 77886586a41SJérôme Glisse list_add_rcu(&range->list, &hmm->ranges); 77986586a41SJérôme Glisse spin_unlock(&hmm->lock); 78086586a41SJérôme Glisse 78174eee180SJérôme Glisse hmm_vma_walk.fault = true; 78274eee180SJérôme Glisse hmm_vma_walk.write = write; 78374eee180SJérôme Glisse hmm_vma_walk.block = block; 78474eee180SJérôme Glisse hmm_vma_walk.range = range; 78574eee180SJérôme Glisse mm_walk.private = &hmm_vma_walk; 78674eee180SJérôme Glisse hmm_vma_walk.last = range->start; 78774eee180SJérôme Glisse 78874eee180SJérôme Glisse mm_walk.vma = vma; 78974eee180SJérôme Glisse mm_walk.mm = vma->vm_mm; 79074eee180SJérôme Glisse mm_walk.pte_entry = NULL; 79174eee180SJérôme Glisse mm_walk.test_walk = NULL; 79274eee180SJérôme Glisse mm_walk.hugetlb_entry = NULL; 79374eee180SJérôme Glisse mm_walk.pmd_entry = hmm_vma_walk_pmd; 79474eee180SJérôme Glisse mm_walk.pte_hole = hmm_vma_walk_hole; 79574eee180SJérôme Glisse 79674eee180SJérôme Glisse do { 79708232a45SJérôme Glisse ret = walk_page_range(start, range->end, &mm_walk); 79874eee180SJérôme Glisse start = hmm_vma_walk.last; 79974eee180SJérôme Glisse } while (ret == -EAGAIN); 80074eee180SJérôme Glisse 80174eee180SJérôme Glisse if (ret) { 80274eee180SJérôme Glisse unsigned long i; 80374eee180SJérôme Glisse 80474eee180SJérôme Glisse i = (hmm_vma_walk.last - range->start) >> PAGE_SHIFT; 80508232a45SJérôme Glisse hmm_pfns_clear(&range->pfns[i], hmm_vma_walk.last, range->end); 80608232a45SJérôme Glisse hmm_vma_range_done(range); 80774eee180SJérôme Glisse } 80874eee180SJérôme Glisse return ret; 80974eee180SJérôme Glisse } 81074eee180SJérôme Glisse EXPORT_SYMBOL(hmm_vma_fault); 811c0b12405SJérôme Glisse #endif /* IS_ENABLED(CONFIG_HMM_MIRROR) */ 8124ef589dcSJérôme Glisse 8134ef589dcSJérôme Glisse 814df6ad698SJérôme Glisse #if IS_ENABLED(CONFIG_DEVICE_PRIVATE) || IS_ENABLED(CONFIG_DEVICE_PUBLIC) 8154ef589dcSJérôme Glisse struct page *hmm_vma_alloc_locked_page(struct vm_area_struct *vma, 8164ef589dcSJérôme Glisse unsigned long addr) 8174ef589dcSJérôme Glisse { 8184ef589dcSJérôme Glisse struct page *page; 8194ef589dcSJérôme Glisse 8204ef589dcSJérôme Glisse page = alloc_page_vma(GFP_HIGHUSER, vma, addr); 8214ef589dcSJérôme Glisse if (!page) 8224ef589dcSJérôme Glisse return NULL; 8234ef589dcSJérôme Glisse lock_page(page); 8244ef589dcSJérôme Glisse return page; 8254ef589dcSJérôme Glisse } 8264ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_vma_alloc_locked_page); 8274ef589dcSJérôme Glisse 8284ef589dcSJérôme Glisse 8294ef589dcSJérôme Glisse static void hmm_devmem_ref_release(struct percpu_ref *ref) 8304ef589dcSJérôme Glisse { 8314ef589dcSJérôme Glisse struct hmm_devmem *devmem; 8324ef589dcSJérôme Glisse 8334ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 8344ef589dcSJérôme Glisse complete(&devmem->completion); 8354ef589dcSJérôme Glisse } 8364ef589dcSJérôme Glisse 8374ef589dcSJérôme Glisse static void hmm_devmem_ref_exit(void *data) 8384ef589dcSJérôme Glisse { 8394ef589dcSJérôme Glisse struct percpu_ref *ref = data; 8404ef589dcSJérôme Glisse struct hmm_devmem *devmem; 8414ef589dcSJérôme Glisse 8424ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 8434ef589dcSJérôme Glisse percpu_ref_exit(ref); 8444ef589dcSJérôme Glisse devm_remove_action(devmem->device, &hmm_devmem_ref_exit, data); 8454ef589dcSJérôme Glisse } 8464ef589dcSJérôme Glisse 8474ef589dcSJérôme Glisse static void hmm_devmem_ref_kill(void *data) 8484ef589dcSJérôme Glisse { 8494ef589dcSJérôme Glisse struct percpu_ref *ref = data; 8504ef589dcSJérôme Glisse struct hmm_devmem *devmem; 8514ef589dcSJérôme Glisse 8524ef589dcSJérôme Glisse devmem = container_of(ref, struct hmm_devmem, ref); 8534ef589dcSJérôme Glisse percpu_ref_kill(ref); 8544ef589dcSJérôme Glisse wait_for_completion(&devmem->completion); 8554ef589dcSJérôme Glisse devm_remove_action(devmem->device, &hmm_devmem_ref_kill, data); 8564ef589dcSJérôme Glisse } 8574ef589dcSJérôme Glisse 8584ef589dcSJérôme Glisse static int hmm_devmem_fault(struct vm_area_struct *vma, 8594ef589dcSJérôme Glisse unsigned long addr, 8604ef589dcSJérôme Glisse const struct page *page, 8614ef589dcSJérôme Glisse unsigned int flags, 8624ef589dcSJérôme Glisse pmd_t *pmdp) 8634ef589dcSJérôme Glisse { 8644ef589dcSJérôme Glisse struct hmm_devmem *devmem = page->pgmap->data; 8654ef589dcSJérôme Glisse 8664ef589dcSJérôme Glisse return devmem->ops->fault(devmem, vma, addr, page, flags, pmdp); 8674ef589dcSJérôme Glisse } 8684ef589dcSJérôme Glisse 8694ef589dcSJérôme Glisse static void hmm_devmem_free(struct page *page, void *data) 8704ef589dcSJérôme Glisse { 8714ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 8724ef589dcSJérôme Glisse 8734ef589dcSJérôme Glisse devmem->ops->free(devmem, page); 8744ef589dcSJérôme Glisse } 8754ef589dcSJérôme Glisse 8764ef589dcSJérôme Glisse static DEFINE_MUTEX(hmm_devmem_lock); 8774ef589dcSJérôme Glisse static RADIX_TREE(hmm_devmem_radix, GFP_KERNEL); 8784ef589dcSJérôme Glisse 8794ef589dcSJérôme Glisse static void hmm_devmem_radix_release(struct resource *resource) 8804ef589dcSJérôme Glisse { 881fec11bc0SColin Ian King resource_size_t key, align_start, align_size; 8824ef589dcSJérôme Glisse 8834ef589dcSJérôme Glisse align_start = resource->start & ~(PA_SECTION_SIZE - 1); 8844ef589dcSJérôme Glisse align_size = ALIGN(resource_size(resource), PA_SECTION_SIZE); 8854ef589dcSJérôme Glisse 8864ef589dcSJérôme Glisse mutex_lock(&hmm_devmem_lock); 8874ef589dcSJérôme Glisse for (key = resource->start; 8884ef589dcSJérôme Glisse key <= resource->end; 8894ef589dcSJérôme Glisse key += PA_SECTION_SIZE) 8904ef589dcSJérôme Glisse radix_tree_delete(&hmm_devmem_radix, key >> PA_SECTION_SHIFT); 8914ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 8924ef589dcSJérôme Glisse } 8934ef589dcSJérôme Glisse 8944ef589dcSJérôme Glisse static void hmm_devmem_release(struct device *dev, void *data) 8954ef589dcSJérôme Glisse { 8964ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 8974ef589dcSJérôme Glisse struct resource *resource = devmem->resource; 8984ef589dcSJérôme Glisse unsigned long start_pfn, npages; 8994ef589dcSJérôme Glisse struct zone *zone; 9004ef589dcSJérôme Glisse struct page *page; 9014ef589dcSJérôme Glisse 9024ef589dcSJérôme Glisse if (percpu_ref_tryget_live(&devmem->ref)) { 9034ef589dcSJérôme Glisse dev_WARN(dev, "%s: page mapping is still live!\n", __func__); 9044ef589dcSJérôme Glisse percpu_ref_put(&devmem->ref); 9054ef589dcSJérôme Glisse } 9064ef589dcSJérôme Glisse 9074ef589dcSJérôme Glisse /* pages are dead and unused, undo the arch mapping */ 9084ef589dcSJérôme Glisse start_pfn = (resource->start & ~(PA_SECTION_SIZE - 1)) >> PAGE_SHIFT; 9094ef589dcSJérôme Glisse npages = ALIGN(resource_size(resource), PA_SECTION_SIZE) >> PAGE_SHIFT; 9104ef589dcSJérôme Glisse 9114ef589dcSJérôme Glisse page = pfn_to_page(start_pfn); 9124ef589dcSJérôme Glisse zone = page_zone(page); 9134ef589dcSJérôme Glisse 9144ef589dcSJérôme Glisse mem_hotplug_begin(); 915d3df0a42SJérôme Glisse if (resource->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY) 916da024512SChristoph Hellwig __remove_pages(zone, start_pfn, npages, NULL); 917d3df0a42SJérôme Glisse else 918d3df0a42SJérôme Glisse arch_remove_memory(start_pfn << PAGE_SHIFT, 919da024512SChristoph Hellwig npages << PAGE_SHIFT, NULL); 9204ef589dcSJérôme Glisse mem_hotplug_done(); 9214ef589dcSJérôme Glisse 9224ef589dcSJérôme Glisse hmm_devmem_radix_release(resource); 9234ef589dcSJérôme Glisse } 9244ef589dcSJérôme Glisse 9254ef589dcSJérôme Glisse static struct hmm_devmem *hmm_devmem_find(resource_size_t phys) 9264ef589dcSJérôme Glisse { 9274ef589dcSJérôme Glisse WARN_ON_ONCE(!rcu_read_lock_held()); 9284ef589dcSJérôme Glisse 9294ef589dcSJérôme Glisse return radix_tree_lookup(&hmm_devmem_radix, phys >> PA_SECTION_SHIFT); 9304ef589dcSJérôme Glisse } 9314ef589dcSJérôme Glisse 9324ef589dcSJérôme Glisse static int hmm_devmem_pages_create(struct hmm_devmem *devmem) 9334ef589dcSJérôme Glisse { 9344ef589dcSJérôme Glisse resource_size_t key, align_start, align_size, align_end; 9354ef589dcSJérôme Glisse struct device *device = devmem->device; 9364ef589dcSJérôme Glisse int ret, nid, is_ram; 9374ef589dcSJérôme Glisse unsigned long pfn; 9384ef589dcSJérôme Glisse 9394ef589dcSJérôme Glisse align_start = devmem->resource->start & ~(PA_SECTION_SIZE - 1); 9404ef589dcSJérôme Glisse align_size = ALIGN(devmem->resource->start + 9414ef589dcSJérôme Glisse resource_size(devmem->resource), 9424ef589dcSJérôme Glisse PA_SECTION_SIZE) - align_start; 9434ef589dcSJérôme Glisse 9444ef589dcSJérôme Glisse is_ram = region_intersects(align_start, align_size, 9454ef589dcSJérôme Glisse IORESOURCE_SYSTEM_RAM, 9464ef589dcSJérôme Glisse IORES_DESC_NONE); 9474ef589dcSJérôme Glisse if (is_ram == REGION_MIXED) { 9484ef589dcSJérôme Glisse WARN_ONCE(1, "%s attempted on mixed region %pr\n", 9494ef589dcSJérôme Glisse __func__, devmem->resource); 9504ef589dcSJérôme Glisse return -ENXIO; 9514ef589dcSJérôme Glisse } 9524ef589dcSJérôme Glisse if (is_ram == REGION_INTERSECTS) 9534ef589dcSJérôme Glisse return -ENXIO; 9544ef589dcSJérôme Glisse 955d3df0a42SJérôme Glisse if (devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY) 956d3df0a42SJérôme Glisse devmem->pagemap.type = MEMORY_DEVICE_PUBLIC; 957d3df0a42SJérôme Glisse else 9584ef589dcSJérôme Glisse devmem->pagemap.type = MEMORY_DEVICE_PRIVATE; 959d3df0a42SJérôme Glisse 960e7744aa2SLogan Gunthorpe devmem->pagemap.res = *devmem->resource; 9614ef589dcSJérôme Glisse devmem->pagemap.page_fault = hmm_devmem_fault; 9624ef589dcSJérôme Glisse devmem->pagemap.page_free = hmm_devmem_free; 9634ef589dcSJérôme Glisse devmem->pagemap.dev = devmem->device; 9644ef589dcSJérôme Glisse devmem->pagemap.ref = &devmem->ref; 9654ef589dcSJérôme Glisse devmem->pagemap.data = devmem; 9664ef589dcSJérôme Glisse 9674ef589dcSJérôme Glisse mutex_lock(&hmm_devmem_lock); 9684ef589dcSJérôme Glisse align_end = align_start + align_size - 1; 9694ef589dcSJérôme Glisse for (key = align_start; key <= align_end; key += PA_SECTION_SIZE) { 9704ef589dcSJérôme Glisse struct hmm_devmem *dup; 9714ef589dcSJérôme Glisse 9724ef589dcSJérôme Glisse rcu_read_lock(); 9734ef589dcSJérôme Glisse dup = hmm_devmem_find(key); 9744ef589dcSJérôme Glisse rcu_read_unlock(); 9754ef589dcSJérôme Glisse if (dup) { 9764ef589dcSJérôme Glisse dev_err(device, "%s: collides with mapping for %s\n", 9774ef589dcSJérôme Glisse __func__, dev_name(dup->device)); 9784ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 9794ef589dcSJérôme Glisse ret = -EBUSY; 9804ef589dcSJérôme Glisse goto error; 9814ef589dcSJérôme Glisse } 9824ef589dcSJérôme Glisse ret = radix_tree_insert(&hmm_devmem_radix, 9834ef589dcSJérôme Glisse key >> PA_SECTION_SHIFT, 9844ef589dcSJérôme Glisse devmem); 9854ef589dcSJérôme Glisse if (ret) { 9864ef589dcSJérôme Glisse dev_err(device, "%s: failed: %d\n", __func__, ret); 9874ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 9884ef589dcSJérôme Glisse goto error_radix; 9894ef589dcSJérôme Glisse } 9904ef589dcSJérôme Glisse } 9914ef589dcSJérôme Glisse mutex_unlock(&hmm_devmem_lock); 9924ef589dcSJérôme Glisse 9934ef589dcSJérôme Glisse nid = dev_to_node(device); 9944ef589dcSJérôme Glisse if (nid < 0) 9954ef589dcSJérôme Glisse nid = numa_mem_id(); 9964ef589dcSJérôme Glisse 9974ef589dcSJérôme Glisse mem_hotplug_begin(); 9984ef589dcSJérôme Glisse /* 9994ef589dcSJérôme Glisse * For device private memory we call add_pages() as we only need to 10004ef589dcSJérôme Glisse * allocate and initialize struct page for the device memory. More- 10014ef589dcSJérôme Glisse * over the device memory is un-accessible thus we do not want to 10024ef589dcSJérôme Glisse * create a linear mapping for the memory like arch_add_memory() 10034ef589dcSJérôme Glisse * would do. 1004d3df0a42SJérôme Glisse * 1005d3df0a42SJérôme Glisse * For device public memory, which is accesible by the CPU, we do 1006d3df0a42SJérôme Glisse * want the linear mapping and thus use arch_add_memory(). 10074ef589dcSJérôme Glisse */ 1008d3df0a42SJérôme Glisse if (devmem->pagemap.type == MEMORY_DEVICE_PUBLIC) 100924e6d5a5SChristoph Hellwig ret = arch_add_memory(nid, align_start, align_size, NULL, 101024e6d5a5SChristoph Hellwig false); 1011d3df0a42SJérôme Glisse else 10124ef589dcSJérôme Glisse ret = add_pages(nid, align_start >> PAGE_SHIFT, 101324e6d5a5SChristoph Hellwig align_size >> PAGE_SHIFT, NULL, false); 10144ef589dcSJérôme Glisse if (ret) { 10154ef589dcSJérôme Glisse mem_hotplug_done(); 10164ef589dcSJérôme Glisse goto error_add_memory; 10174ef589dcSJérôme Glisse } 10184ef589dcSJérôme Glisse move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE], 10194ef589dcSJérôme Glisse align_start >> PAGE_SHIFT, 1020a99583e7SChristoph Hellwig align_size >> PAGE_SHIFT, NULL); 10214ef589dcSJérôme Glisse mem_hotplug_done(); 10224ef589dcSJérôme Glisse 10234ef589dcSJérôme Glisse for (pfn = devmem->pfn_first; pfn < devmem->pfn_last; pfn++) { 10244ef589dcSJérôme Glisse struct page *page = pfn_to_page(pfn); 10254ef589dcSJérôme Glisse 10264ef589dcSJérôme Glisse page->pgmap = &devmem->pagemap; 10274ef589dcSJérôme Glisse } 10284ef589dcSJérôme Glisse return 0; 10294ef589dcSJérôme Glisse 10304ef589dcSJérôme Glisse error_add_memory: 10314ef589dcSJérôme Glisse untrack_pfn(NULL, PHYS_PFN(align_start), align_size); 10324ef589dcSJérôme Glisse error_radix: 10334ef589dcSJérôme Glisse hmm_devmem_radix_release(devmem->resource); 10344ef589dcSJérôme Glisse error: 10354ef589dcSJérôme Glisse return ret; 10364ef589dcSJérôme Glisse } 10374ef589dcSJérôme Glisse 10384ef589dcSJérôme Glisse static int hmm_devmem_match(struct device *dev, void *data, void *match_data) 10394ef589dcSJérôme Glisse { 10404ef589dcSJérôme Glisse struct hmm_devmem *devmem = data; 10414ef589dcSJérôme Glisse 10424ef589dcSJérôme Glisse return devmem->resource == match_data; 10434ef589dcSJérôme Glisse } 10444ef589dcSJérôme Glisse 10454ef589dcSJérôme Glisse static void hmm_devmem_pages_remove(struct hmm_devmem *devmem) 10464ef589dcSJérôme Glisse { 10474ef589dcSJérôme Glisse devres_release(devmem->device, &hmm_devmem_release, 10484ef589dcSJérôme Glisse &hmm_devmem_match, devmem->resource); 10494ef589dcSJérôme Glisse } 10504ef589dcSJérôme Glisse 10514ef589dcSJérôme Glisse /* 10524ef589dcSJérôme Glisse * hmm_devmem_add() - hotplug ZONE_DEVICE memory for device memory 10534ef589dcSJérôme Glisse * 10544ef589dcSJérôme Glisse * @ops: memory event device driver callback (see struct hmm_devmem_ops) 10554ef589dcSJérôme Glisse * @device: device struct to bind the resource too 10564ef589dcSJérôme Glisse * @size: size in bytes of the device memory to add 10574ef589dcSJérôme Glisse * Returns: pointer to new hmm_devmem struct ERR_PTR otherwise 10584ef589dcSJérôme Glisse * 10594ef589dcSJérôme Glisse * This function first finds an empty range of physical address big enough to 10604ef589dcSJérôme Glisse * contain the new resource, and then hotplugs it as ZONE_DEVICE memory, which 10614ef589dcSJérôme Glisse * in turn allocates struct pages. It does not do anything beyond that; all 10624ef589dcSJérôme Glisse * events affecting the memory will go through the various callbacks provided 10634ef589dcSJérôme Glisse * by hmm_devmem_ops struct. 10644ef589dcSJérôme Glisse * 10654ef589dcSJérôme Glisse * Device driver should call this function during device initialization and 10664ef589dcSJérôme Glisse * is then responsible of memory management. HMM only provides helpers. 10674ef589dcSJérôme Glisse */ 10684ef589dcSJérôme Glisse struct hmm_devmem *hmm_devmem_add(const struct hmm_devmem_ops *ops, 10694ef589dcSJérôme Glisse struct device *device, 10704ef589dcSJérôme Glisse unsigned long size) 10714ef589dcSJérôme Glisse { 10724ef589dcSJérôme Glisse struct hmm_devmem *devmem; 10734ef589dcSJérôme Glisse resource_size_t addr; 10744ef589dcSJérôme Glisse int ret; 10754ef589dcSJérôme Glisse 10764ef589dcSJérôme Glisse static_branch_enable(&device_private_key); 10774ef589dcSJérôme Glisse 10784ef589dcSJérôme Glisse devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem), 10794ef589dcSJérôme Glisse GFP_KERNEL, dev_to_node(device)); 10804ef589dcSJérôme Glisse if (!devmem) 10814ef589dcSJérôme Glisse return ERR_PTR(-ENOMEM); 10824ef589dcSJérôme Glisse 10834ef589dcSJérôme Glisse init_completion(&devmem->completion); 10844ef589dcSJérôme Glisse devmem->pfn_first = -1UL; 10854ef589dcSJérôme Glisse devmem->pfn_last = -1UL; 10864ef589dcSJérôme Glisse devmem->resource = NULL; 10874ef589dcSJérôme Glisse devmem->device = device; 10884ef589dcSJérôme Glisse devmem->ops = ops; 10894ef589dcSJérôme Glisse 10904ef589dcSJérôme Glisse ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release, 10914ef589dcSJérôme Glisse 0, GFP_KERNEL); 10924ef589dcSJérôme Glisse if (ret) 10934ef589dcSJérôme Glisse goto error_percpu_ref; 10944ef589dcSJérôme Glisse 10954ef589dcSJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref); 10964ef589dcSJérôme Glisse if (ret) 10974ef589dcSJérôme Glisse goto error_devm_add_action; 10984ef589dcSJérôme Glisse 10994ef589dcSJérôme Glisse size = ALIGN(size, PA_SECTION_SIZE); 11004ef589dcSJérôme Glisse addr = min((unsigned long)iomem_resource.end, 11014ef589dcSJérôme Glisse (1UL << MAX_PHYSMEM_BITS) - 1); 11024ef589dcSJérôme Glisse addr = addr - size + 1UL; 11034ef589dcSJérôme Glisse 11044ef589dcSJérôme Glisse /* 11054ef589dcSJérôme Glisse * FIXME add a new helper to quickly walk resource tree and find free 11064ef589dcSJérôme Glisse * range 11074ef589dcSJérôme Glisse * 11084ef589dcSJérôme Glisse * FIXME what about ioport_resource resource ? 11094ef589dcSJérôme Glisse */ 11104ef589dcSJérôme Glisse for (; addr > size && addr >= iomem_resource.start; addr -= size) { 11114ef589dcSJérôme Glisse ret = region_intersects(addr, size, 0, IORES_DESC_NONE); 11124ef589dcSJérôme Glisse if (ret != REGION_DISJOINT) 11134ef589dcSJérôme Glisse continue; 11144ef589dcSJérôme Glisse 11154ef589dcSJérôme Glisse devmem->resource = devm_request_mem_region(device, addr, size, 11164ef589dcSJérôme Glisse dev_name(device)); 11174ef589dcSJérôme Glisse if (!devmem->resource) { 11184ef589dcSJérôme Glisse ret = -ENOMEM; 11194ef589dcSJérôme Glisse goto error_no_resource; 11204ef589dcSJérôme Glisse } 11214ef589dcSJérôme Glisse break; 11224ef589dcSJérôme Glisse } 11234ef589dcSJérôme Glisse if (!devmem->resource) { 11244ef589dcSJérôme Glisse ret = -ERANGE; 11254ef589dcSJérôme Glisse goto error_no_resource; 11264ef589dcSJérôme Glisse } 11274ef589dcSJérôme Glisse 11284ef589dcSJérôme Glisse devmem->resource->desc = IORES_DESC_DEVICE_PRIVATE_MEMORY; 11294ef589dcSJérôme Glisse devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT; 11304ef589dcSJérôme Glisse devmem->pfn_last = devmem->pfn_first + 11314ef589dcSJérôme Glisse (resource_size(devmem->resource) >> PAGE_SHIFT); 11324ef589dcSJérôme Glisse 11334ef589dcSJérôme Glisse ret = hmm_devmem_pages_create(devmem); 11344ef589dcSJérôme Glisse if (ret) 11354ef589dcSJérôme Glisse goto error_pages; 11364ef589dcSJérôme Glisse 11374ef589dcSJérôme Glisse devres_add(device, devmem); 11384ef589dcSJérôme Glisse 11394ef589dcSJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref); 11404ef589dcSJérôme Glisse if (ret) { 11414ef589dcSJérôme Glisse hmm_devmem_remove(devmem); 11424ef589dcSJérôme Glisse return ERR_PTR(ret); 11434ef589dcSJérôme Glisse } 11444ef589dcSJérôme Glisse 11454ef589dcSJérôme Glisse return devmem; 11464ef589dcSJérôme Glisse 11474ef589dcSJérôme Glisse error_pages: 11484ef589dcSJérôme Glisse devm_release_mem_region(device, devmem->resource->start, 11494ef589dcSJérôme Glisse resource_size(devmem->resource)); 11504ef589dcSJérôme Glisse error_no_resource: 11514ef589dcSJérôme Glisse error_devm_add_action: 11524ef589dcSJérôme Glisse hmm_devmem_ref_kill(&devmem->ref); 11534ef589dcSJérôme Glisse hmm_devmem_ref_exit(&devmem->ref); 11544ef589dcSJérôme Glisse error_percpu_ref: 11554ef589dcSJérôme Glisse devres_free(devmem); 11564ef589dcSJérôme Glisse return ERR_PTR(ret); 11574ef589dcSJérôme Glisse } 11584ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add); 11594ef589dcSJérôme Glisse 1160d3df0a42SJérôme Glisse struct hmm_devmem *hmm_devmem_add_resource(const struct hmm_devmem_ops *ops, 1161d3df0a42SJérôme Glisse struct device *device, 1162d3df0a42SJérôme Glisse struct resource *res) 1163d3df0a42SJérôme Glisse { 1164d3df0a42SJérôme Glisse struct hmm_devmem *devmem; 1165d3df0a42SJérôme Glisse int ret; 1166d3df0a42SJérôme Glisse 1167d3df0a42SJérôme Glisse if (res->desc != IORES_DESC_DEVICE_PUBLIC_MEMORY) 1168d3df0a42SJérôme Glisse return ERR_PTR(-EINVAL); 1169d3df0a42SJérôme Glisse 1170d3df0a42SJérôme Glisse static_branch_enable(&device_private_key); 1171d3df0a42SJérôme Glisse 1172d3df0a42SJérôme Glisse devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem), 1173d3df0a42SJérôme Glisse GFP_KERNEL, dev_to_node(device)); 1174d3df0a42SJérôme Glisse if (!devmem) 1175d3df0a42SJérôme Glisse return ERR_PTR(-ENOMEM); 1176d3df0a42SJérôme Glisse 1177d3df0a42SJérôme Glisse init_completion(&devmem->completion); 1178d3df0a42SJérôme Glisse devmem->pfn_first = -1UL; 1179d3df0a42SJérôme Glisse devmem->pfn_last = -1UL; 1180d3df0a42SJérôme Glisse devmem->resource = res; 1181d3df0a42SJérôme Glisse devmem->device = device; 1182d3df0a42SJérôme Glisse devmem->ops = ops; 1183d3df0a42SJérôme Glisse 1184d3df0a42SJérôme Glisse ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release, 1185d3df0a42SJérôme Glisse 0, GFP_KERNEL); 1186d3df0a42SJérôme Glisse if (ret) 1187d3df0a42SJérôme Glisse goto error_percpu_ref; 1188d3df0a42SJérôme Glisse 1189d3df0a42SJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref); 1190d3df0a42SJérôme Glisse if (ret) 1191d3df0a42SJérôme Glisse goto error_devm_add_action; 1192d3df0a42SJérôme Glisse 1193d3df0a42SJérôme Glisse 1194d3df0a42SJérôme Glisse devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT; 1195d3df0a42SJérôme Glisse devmem->pfn_last = devmem->pfn_first + 1196d3df0a42SJérôme Glisse (resource_size(devmem->resource) >> PAGE_SHIFT); 1197d3df0a42SJérôme Glisse 1198d3df0a42SJérôme Glisse ret = hmm_devmem_pages_create(devmem); 1199d3df0a42SJérôme Glisse if (ret) 1200d3df0a42SJérôme Glisse goto error_devm_add_action; 1201d3df0a42SJérôme Glisse 1202d3df0a42SJérôme Glisse devres_add(device, devmem); 1203d3df0a42SJérôme Glisse 1204d3df0a42SJérôme Glisse ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref); 1205d3df0a42SJérôme Glisse if (ret) { 1206d3df0a42SJérôme Glisse hmm_devmem_remove(devmem); 1207d3df0a42SJérôme Glisse return ERR_PTR(ret); 1208d3df0a42SJérôme Glisse } 1209d3df0a42SJérôme Glisse 1210d3df0a42SJérôme Glisse return devmem; 1211d3df0a42SJérôme Glisse 1212d3df0a42SJérôme Glisse error_devm_add_action: 1213d3df0a42SJérôme Glisse hmm_devmem_ref_kill(&devmem->ref); 1214d3df0a42SJérôme Glisse hmm_devmem_ref_exit(&devmem->ref); 1215d3df0a42SJérôme Glisse error_percpu_ref: 1216d3df0a42SJérôme Glisse devres_free(devmem); 1217d3df0a42SJérôme Glisse return ERR_PTR(ret); 1218d3df0a42SJérôme Glisse } 1219d3df0a42SJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add_resource); 1220d3df0a42SJérôme Glisse 12214ef589dcSJérôme Glisse /* 12224ef589dcSJérôme Glisse * hmm_devmem_remove() - remove device memory (kill and free ZONE_DEVICE) 12234ef589dcSJérôme Glisse * 12244ef589dcSJérôme Glisse * @devmem: hmm_devmem struct use to track and manage the ZONE_DEVICE memory 12254ef589dcSJérôme Glisse * 12264ef589dcSJérôme Glisse * This will hot-unplug memory that was hotplugged by hmm_devmem_add on behalf 12274ef589dcSJérôme Glisse * of the device driver. It will free struct page and remove the resource that 12284ef589dcSJérôme Glisse * reserved the physical address range for this device memory. 12294ef589dcSJérôme Glisse */ 12304ef589dcSJérôme Glisse void hmm_devmem_remove(struct hmm_devmem *devmem) 12314ef589dcSJérôme Glisse { 12324ef589dcSJérôme Glisse resource_size_t start, size; 12334ef589dcSJérôme Glisse struct device *device; 1234d3df0a42SJérôme Glisse bool cdm = false; 12354ef589dcSJérôme Glisse 12364ef589dcSJérôme Glisse if (!devmem) 12374ef589dcSJérôme Glisse return; 12384ef589dcSJérôme Glisse 12394ef589dcSJérôme Glisse device = devmem->device; 12404ef589dcSJérôme Glisse start = devmem->resource->start; 12414ef589dcSJérôme Glisse size = resource_size(devmem->resource); 12424ef589dcSJérôme Glisse 1243d3df0a42SJérôme Glisse cdm = devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY; 12444ef589dcSJérôme Glisse hmm_devmem_ref_kill(&devmem->ref); 12454ef589dcSJérôme Glisse hmm_devmem_ref_exit(&devmem->ref); 12464ef589dcSJérôme Glisse hmm_devmem_pages_remove(devmem); 12474ef589dcSJérôme Glisse 1248d3df0a42SJérôme Glisse if (!cdm) 12494ef589dcSJérôme Glisse devm_release_mem_region(device, start, size); 12504ef589dcSJérôme Glisse } 12514ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_remove); 1252858b54daSJérôme Glisse 1253858b54daSJérôme Glisse /* 1254858b54daSJérôme Glisse * A device driver that wants to handle multiple devices memory through a 1255858b54daSJérôme Glisse * single fake device can use hmm_device to do so. This is purely a helper 1256858b54daSJérôme Glisse * and it is not needed to make use of any HMM functionality. 1257858b54daSJérôme Glisse */ 1258858b54daSJérôme Glisse #define HMM_DEVICE_MAX 256 1259858b54daSJérôme Glisse 1260858b54daSJérôme Glisse static DECLARE_BITMAP(hmm_device_mask, HMM_DEVICE_MAX); 1261858b54daSJérôme Glisse static DEFINE_SPINLOCK(hmm_device_lock); 1262858b54daSJérôme Glisse static struct class *hmm_device_class; 1263858b54daSJérôme Glisse static dev_t hmm_device_devt; 1264858b54daSJérôme Glisse 1265858b54daSJérôme Glisse static void hmm_device_release(struct device *device) 1266858b54daSJérôme Glisse { 1267858b54daSJérôme Glisse struct hmm_device *hmm_device; 1268858b54daSJérôme Glisse 1269858b54daSJérôme Glisse hmm_device = container_of(device, struct hmm_device, device); 1270858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1271858b54daSJérôme Glisse clear_bit(hmm_device->minor, hmm_device_mask); 1272858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1273858b54daSJérôme Glisse 1274858b54daSJérôme Glisse kfree(hmm_device); 1275858b54daSJérôme Glisse } 1276858b54daSJérôme Glisse 1277858b54daSJérôme Glisse struct hmm_device *hmm_device_new(void *drvdata) 1278858b54daSJérôme Glisse { 1279858b54daSJérôme Glisse struct hmm_device *hmm_device; 1280858b54daSJérôme Glisse 1281858b54daSJérôme Glisse hmm_device = kzalloc(sizeof(*hmm_device), GFP_KERNEL); 1282858b54daSJérôme Glisse if (!hmm_device) 1283858b54daSJérôme Glisse return ERR_PTR(-ENOMEM); 1284858b54daSJérôme Glisse 1285858b54daSJérôme Glisse spin_lock(&hmm_device_lock); 1286858b54daSJérôme Glisse hmm_device->minor = find_first_zero_bit(hmm_device_mask, HMM_DEVICE_MAX); 1287858b54daSJérôme Glisse if (hmm_device->minor >= HMM_DEVICE_MAX) { 1288858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1289858b54daSJérôme Glisse kfree(hmm_device); 1290858b54daSJérôme Glisse return ERR_PTR(-EBUSY); 1291858b54daSJérôme Glisse } 1292858b54daSJérôme Glisse set_bit(hmm_device->minor, hmm_device_mask); 1293858b54daSJérôme Glisse spin_unlock(&hmm_device_lock); 1294858b54daSJérôme Glisse 1295858b54daSJérôme Glisse dev_set_name(&hmm_device->device, "hmm_device%d", hmm_device->minor); 1296858b54daSJérôme Glisse hmm_device->device.devt = MKDEV(MAJOR(hmm_device_devt), 1297858b54daSJérôme Glisse hmm_device->minor); 1298858b54daSJérôme Glisse hmm_device->device.release = hmm_device_release; 1299858b54daSJérôme Glisse dev_set_drvdata(&hmm_device->device, drvdata); 1300858b54daSJérôme Glisse hmm_device->device.class = hmm_device_class; 1301858b54daSJérôme Glisse device_initialize(&hmm_device->device); 1302858b54daSJérôme Glisse 1303858b54daSJérôme Glisse return hmm_device; 1304858b54daSJérôme Glisse } 1305858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_new); 1306858b54daSJérôme Glisse 1307858b54daSJérôme Glisse void hmm_device_put(struct hmm_device *hmm_device) 1308858b54daSJérôme Glisse { 1309858b54daSJérôme Glisse put_device(&hmm_device->device); 1310858b54daSJérôme Glisse } 1311858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_put); 1312858b54daSJérôme Glisse 1313858b54daSJérôme Glisse static int __init hmm_init(void) 1314858b54daSJérôme Glisse { 1315858b54daSJérôme Glisse int ret; 1316858b54daSJérôme Glisse 1317858b54daSJérôme Glisse ret = alloc_chrdev_region(&hmm_device_devt, 0, 1318858b54daSJérôme Glisse HMM_DEVICE_MAX, 1319858b54daSJérôme Glisse "hmm_device"); 1320858b54daSJérôme Glisse if (ret) 1321858b54daSJérôme Glisse return ret; 1322858b54daSJérôme Glisse 1323858b54daSJérôme Glisse hmm_device_class = class_create(THIS_MODULE, "hmm_device"); 1324858b54daSJérôme Glisse if (IS_ERR(hmm_device_class)) { 1325858b54daSJérôme Glisse unregister_chrdev_region(hmm_device_devt, HMM_DEVICE_MAX); 1326858b54daSJérôme Glisse return PTR_ERR(hmm_device_class); 1327858b54daSJérôme Glisse } 1328858b54daSJérôme Glisse return 0; 1329858b54daSJérôme Glisse } 1330858b54daSJérôme Glisse 1331858b54daSJérôme Glisse device_initcall(hmm_init); 1332df6ad698SJérôme Glisse #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */ 1333