xref: /linux/mm/hmm.c (revision 86a2d59841ab0b147ffc1b7b3041af87927cf312)
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
46c0b12405SJérôme Glisse  * @sequence: we track updates to the CPU page table with a sequence number
47da4c3c73SJérôme Glisse  * @ranges: list of range being snapshotted
48c0b12405SJérôme Glisse  * @mirrors: list of mirrors for this mm
49c0b12405SJérôme Glisse  * @mmu_notifier: mmu notifier to track updates to CPU page table
50c0b12405SJérôme Glisse  * @mirrors_sem: read/write semaphore protecting the mirrors list
51133ff0eaSJérôme Glisse  */
52133ff0eaSJérôme Glisse struct hmm {
53133ff0eaSJérôme Glisse 	struct mm_struct	*mm;
54da4c3c73SJérôme Glisse 	spinlock_t		lock;
55c0b12405SJérôme Glisse 	atomic_t		sequence;
56da4c3c73SJérôme Glisse 	struct list_head	ranges;
57c0b12405SJérôme Glisse 	struct list_head	mirrors;
58c0b12405SJérôme Glisse 	struct mmu_notifier	mmu_notifier;
59c0b12405SJérôme Glisse 	struct rw_semaphore	mirrors_sem;
60133ff0eaSJérôme Glisse };
61133ff0eaSJérôme Glisse 
62133ff0eaSJérôme Glisse /*
63133ff0eaSJérôme Glisse  * hmm_register - register HMM against an mm (HMM internal)
64133ff0eaSJérôme Glisse  *
65133ff0eaSJérôme Glisse  * @mm: mm struct to attach to
66133ff0eaSJérôme Glisse  *
67133ff0eaSJérôme Glisse  * This is not intended to be used directly by device drivers. It allocates an
68133ff0eaSJérôme Glisse  * HMM struct if mm does not have one, and initializes it.
69133ff0eaSJérôme Glisse  */
70133ff0eaSJérôme Glisse static struct hmm *hmm_register(struct mm_struct *mm)
71133ff0eaSJérôme Glisse {
72c0b12405SJérôme Glisse 	struct hmm *hmm = READ_ONCE(mm->hmm);
73c0b12405SJérôme Glisse 	bool cleanup = false;
74133ff0eaSJérôme Glisse 
75133ff0eaSJérôme Glisse 	/*
76133ff0eaSJérôme Glisse 	 * The hmm struct can only be freed once the mm_struct goes away,
77133ff0eaSJérôme Glisse 	 * hence we should always have pre-allocated an new hmm struct
78133ff0eaSJérôme Glisse 	 * above.
79133ff0eaSJérôme Glisse 	 */
80c0b12405SJérôme Glisse 	if (hmm)
81c0b12405SJérôme Glisse 		return hmm;
82c0b12405SJérôme Glisse 
83c0b12405SJérôme Glisse 	hmm = kmalloc(sizeof(*hmm), GFP_KERNEL);
84c0b12405SJérôme Glisse 	if (!hmm)
85c0b12405SJérôme Glisse 		return NULL;
86c0b12405SJérôme Glisse 	INIT_LIST_HEAD(&hmm->mirrors);
87c0b12405SJérôme Glisse 	init_rwsem(&hmm->mirrors_sem);
88c0b12405SJérôme Glisse 	atomic_set(&hmm->sequence, 0);
89c0b12405SJérôme Glisse 	hmm->mmu_notifier.ops = NULL;
90da4c3c73SJérôme Glisse 	INIT_LIST_HEAD(&hmm->ranges);
91da4c3c73SJérôme Glisse 	spin_lock_init(&hmm->lock);
92c0b12405SJérôme Glisse 	hmm->mm = mm;
93c0b12405SJérôme Glisse 
94c0b12405SJérôme Glisse 	spin_lock(&mm->page_table_lock);
95c0b12405SJérôme Glisse 	if (!mm->hmm)
96c0b12405SJérôme Glisse 		mm->hmm = hmm;
97c0b12405SJérôme Glisse 	else
98c0b12405SJérôme Glisse 		cleanup = true;
99c0b12405SJérôme Glisse 	spin_unlock(&mm->page_table_lock);
100c0b12405SJérôme Glisse 
101*86a2d598SRalph Campbell 	if (cleanup)
102*86a2d598SRalph Campbell 		goto error;
103*86a2d598SRalph Campbell 
104*86a2d598SRalph Campbell 	/*
105*86a2d598SRalph Campbell 	 * We should only get here if hold the mmap_sem in write mode ie on
106*86a2d598SRalph Campbell 	 * registration of first mirror through hmm_mirror_register()
107*86a2d598SRalph Campbell 	 */
108*86a2d598SRalph Campbell 	hmm->mmu_notifier.ops = &hmm_mmu_notifier_ops;
109*86a2d598SRalph Campbell 	if (__mmu_notifier_register(&hmm->mmu_notifier, mm))
110*86a2d598SRalph Campbell 		goto error_mm;
111c0b12405SJérôme Glisse 
112133ff0eaSJérôme Glisse 	return mm->hmm;
113*86a2d598SRalph Campbell 
114*86a2d598SRalph Campbell error_mm:
115*86a2d598SRalph Campbell 	spin_lock(&mm->page_table_lock);
116*86a2d598SRalph Campbell 	if (mm->hmm == hmm)
117*86a2d598SRalph Campbell 		mm->hmm = NULL;
118*86a2d598SRalph Campbell 	spin_unlock(&mm->page_table_lock);
119*86a2d598SRalph Campbell error:
120*86a2d598SRalph Campbell 	kfree(hmm);
121*86a2d598SRalph Campbell 	return NULL;
122133ff0eaSJérôme Glisse }
123133ff0eaSJérôme Glisse 
124133ff0eaSJérôme Glisse void hmm_mm_destroy(struct mm_struct *mm)
125133ff0eaSJérôme Glisse {
126133ff0eaSJérôme Glisse 	kfree(mm->hmm);
127133ff0eaSJérôme Glisse }
128c0b12405SJérôme Glisse 
129c0b12405SJérôme Glisse static void hmm_invalidate_range(struct hmm *hmm,
130c0b12405SJérôme Glisse 				 enum hmm_update_type action,
131c0b12405SJérôme Glisse 				 unsigned long start,
132c0b12405SJérôme Glisse 				 unsigned long end)
133c0b12405SJérôme Glisse {
134c0b12405SJérôme Glisse 	struct hmm_mirror *mirror;
135da4c3c73SJérôme Glisse 	struct hmm_range *range;
136da4c3c73SJérôme Glisse 
137da4c3c73SJérôme Glisse 	spin_lock(&hmm->lock);
138da4c3c73SJérôme Glisse 	list_for_each_entry(range, &hmm->ranges, list) {
139da4c3c73SJérôme Glisse 		unsigned long addr, idx, npages;
140da4c3c73SJérôme Glisse 
141da4c3c73SJérôme Glisse 		if (end < range->start || start >= range->end)
142da4c3c73SJérôme Glisse 			continue;
143da4c3c73SJérôme Glisse 
144da4c3c73SJérôme Glisse 		range->valid = false;
145da4c3c73SJérôme Glisse 		addr = max(start, range->start);
146da4c3c73SJérôme Glisse 		idx = (addr - range->start) >> PAGE_SHIFT;
147da4c3c73SJérôme Glisse 		npages = (min(range->end, end) - addr) >> PAGE_SHIFT;
148da4c3c73SJérôme Glisse 		memset(&range->pfns[idx], 0, sizeof(*range->pfns) * npages);
149da4c3c73SJérôme Glisse 	}
150da4c3c73SJérôme Glisse 	spin_unlock(&hmm->lock);
151c0b12405SJérôme Glisse 
152c0b12405SJérôme Glisse 	down_read(&hmm->mirrors_sem);
153c0b12405SJérôme Glisse 	list_for_each_entry(mirror, &hmm->mirrors, list)
154c0b12405SJérôme Glisse 		mirror->ops->sync_cpu_device_pagetables(mirror, action,
155c0b12405SJérôme Glisse 							start, end);
156c0b12405SJérôme Glisse 	up_read(&hmm->mirrors_sem);
157c0b12405SJérôme Glisse }
158c0b12405SJérôme Glisse 
159e1401513SRalph Campbell static void hmm_release(struct mmu_notifier *mn, struct mm_struct *mm)
160e1401513SRalph Campbell {
161e1401513SRalph Campbell 	struct hmm_mirror *mirror;
162e1401513SRalph Campbell 	struct hmm *hmm = mm->hmm;
163e1401513SRalph Campbell 
164e1401513SRalph Campbell 	down_write(&hmm->mirrors_sem);
165e1401513SRalph Campbell 	mirror = list_first_entry_or_null(&hmm->mirrors, struct hmm_mirror,
166e1401513SRalph Campbell 					  list);
167e1401513SRalph Campbell 	while (mirror) {
168e1401513SRalph Campbell 		list_del_init(&mirror->list);
169e1401513SRalph Campbell 		if (mirror->ops->release) {
170e1401513SRalph Campbell 			/*
171e1401513SRalph Campbell 			 * Drop mirrors_sem so callback can wait on any pending
172e1401513SRalph Campbell 			 * work that might itself trigger mmu_notifier callback
173e1401513SRalph Campbell 			 * and thus would deadlock with us.
174e1401513SRalph Campbell 			 */
175e1401513SRalph Campbell 			up_write(&hmm->mirrors_sem);
176e1401513SRalph Campbell 			mirror->ops->release(mirror);
177e1401513SRalph Campbell 			down_write(&hmm->mirrors_sem);
178e1401513SRalph Campbell 		}
179e1401513SRalph Campbell 		mirror = list_first_entry_or_null(&hmm->mirrors,
180e1401513SRalph Campbell 						  struct hmm_mirror, list);
181e1401513SRalph Campbell 	}
182e1401513SRalph Campbell 	up_write(&hmm->mirrors_sem);
183e1401513SRalph Campbell }
184e1401513SRalph Campbell 
18593065ac7SMichal Hocko static int hmm_invalidate_range_start(struct mmu_notifier *mn,
186c0b12405SJérôme Glisse 				       struct mm_struct *mm,
187c0b12405SJérôme Glisse 				       unsigned long start,
18893065ac7SMichal Hocko 				       unsigned long end,
18993065ac7SMichal Hocko 				       bool blockable)
190c0b12405SJérôme Glisse {
191c0b12405SJérôme Glisse 	struct hmm *hmm = mm->hmm;
192c0b12405SJérôme Glisse 
193c0b12405SJérôme Glisse 	VM_BUG_ON(!hmm);
194c0b12405SJérôme Glisse 
195c0b12405SJérôme Glisse 	atomic_inc(&hmm->sequence);
19693065ac7SMichal Hocko 
19793065ac7SMichal Hocko 	return 0;
198c0b12405SJérôme Glisse }
199c0b12405SJérôme Glisse 
200c0b12405SJérôme Glisse static void hmm_invalidate_range_end(struct mmu_notifier *mn,
201c0b12405SJérôme Glisse 				     struct mm_struct *mm,
202c0b12405SJérôme Glisse 				     unsigned long start,
203c0b12405SJérôme Glisse 				     unsigned long end)
204c0b12405SJérôme Glisse {
205c0b12405SJérôme Glisse 	struct hmm *hmm = mm->hmm;
206c0b12405SJérôme Glisse 
207c0b12405SJérôme Glisse 	VM_BUG_ON(!hmm);
208c0b12405SJérôme Glisse 
209c0b12405SJérôme Glisse 	hmm_invalidate_range(mm->hmm, HMM_UPDATE_INVALIDATE, start, end);
210c0b12405SJérôme Glisse }
211c0b12405SJérôme Glisse 
212c0b12405SJérôme Glisse static const struct mmu_notifier_ops hmm_mmu_notifier_ops = {
213e1401513SRalph Campbell 	.release		= hmm_release,
214c0b12405SJérôme Glisse 	.invalidate_range_start	= hmm_invalidate_range_start,
215c0b12405SJérôme Glisse 	.invalidate_range_end	= hmm_invalidate_range_end,
216c0b12405SJérôme Glisse };
217c0b12405SJérôme Glisse 
218c0b12405SJérôme Glisse /*
219c0b12405SJérôme Glisse  * hmm_mirror_register() - register a mirror against an mm
220c0b12405SJérôme Glisse  *
221c0b12405SJérôme Glisse  * @mirror: new mirror struct to register
222c0b12405SJérôme Glisse  * @mm: mm to register against
223c0b12405SJérôme Glisse  *
224c0b12405SJérôme Glisse  * To start mirroring a process address space, the device driver must register
225c0b12405SJérôme Glisse  * an HMM mirror struct.
226c0b12405SJérôme Glisse  *
227c0b12405SJérôme Glisse  * THE mm->mmap_sem MUST BE HELD IN WRITE MODE !
228c0b12405SJérôme Glisse  */
229c0b12405SJérôme Glisse int hmm_mirror_register(struct hmm_mirror *mirror, struct mm_struct *mm)
230c0b12405SJérôme Glisse {
231c0b12405SJérôme Glisse 	/* Sanity check */
232c0b12405SJérôme Glisse 	if (!mm || !mirror || !mirror->ops)
233c0b12405SJérôme Glisse 		return -EINVAL;
234c0b12405SJérôme Glisse 
235c01cbba2SJérôme Glisse again:
236c0b12405SJérôme Glisse 	mirror->hmm = hmm_register(mm);
237c0b12405SJérôme Glisse 	if (!mirror->hmm)
238c0b12405SJérôme Glisse 		return -ENOMEM;
239c0b12405SJérôme Glisse 
240c0b12405SJérôme Glisse 	down_write(&mirror->hmm->mirrors_sem);
241c01cbba2SJérôme Glisse 	if (mirror->hmm->mm == NULL) {
242c01cbba2SJérôme Glisse 		/*
243c01cbba2SJérôme Glisse 		 * A racing hmm_mirror_unregister() is about to destroy the hmm
244c01cbba2SJérôme Glisse 		 * struct. Try again to allocate a new one.
245c01cbba2SJérôme Glisse 		 */
246c01cbba2SJérôme Glisse 		up_write(&mirror->hmm->mirrors_sem);
247c01cbba2SJérôme Glisse 		mirror->hmm = NULL;
248c01cbba2SJérôme Glisse 		goto again;
249c01cbba2SJérôme Glisse 	} else {
250c0b12405SJérôme Glisse 		list_add(&mirror->list, &mirror->hmm->mirrors);
251c0b12405SJérôme Glisse 		up_write(&mirror->hmm->mirrors_sem);
252c01cbba2SJérôme Glisse 	}
253c0b12405SJérôme Glisse 
254c0b12405SJérôme Glisse 	return 0;
255c0b12405SJérôme Glisse }
256c0b12405SJérôme Glisse EXPORT_SYMBOL(hmm_mirror_register);
257c0b12405SJérôme Glisse 
258c0b12405SJérôme Glisse /*
259c0b12405SJérôme Glisse  * hmm_mirror_unregister() - unregister a mirror
260c0b12405SJérôme Glisse  *
261c0b12405SJérôme Glisse  * @mirror: new mirror struct to register
262c0b12405SJérôme Glisse  *
263c0b12405SJérôme Glisse  * Stop mirroring a process address space, and cleanup.
264c0b12405SJérôme Glisse  */
265c0b12405SJérôme Glisse void hmm_mirror_unregister(struct hmm_mirror *mirror)
266c0b12405SJérôme Glisse {
267c01cbba2SJérôme Glisse 	bool should_unregister = false;
268c01cbba2SJérôme Glisse 	struct mm_struct *mm;
269c01cbba2SJérôme Glisse 	struct hmm *hmm;
270c0b12405SJérôme Glisse 
271c01cbba2SJérôme Glisse 	if (mirror->hmm == NULL)
272c01cbba2SJérôme Glisse 		return;
273c01cbba2SJérôme Glisse 
274c01cbba2SJérôme Glisse 	hmm = mirror->hmm;
275c0b12405SJérôme Glisse 	down_write(&hmm->mirrors_sem);
276e1401513SRalph Campbell 	list_del_init(&mirror->list);
277c01cbba2SJérôme Glisse 	should_unregister = list_empty(&hmm->mirrors);
278c01cbba2SJérôme Glisse 	mirror->hmm = NULL;
279c01cbba2SJérôme Glisse 	mm = hmm->mm;
280c01cbba2SJérôme Glisse 	hmm->mm = NULL;
281c0b12405SJérôme Glisse 	up_write(&hmm->mirrors_sem);
282c01cbba2SJérôme Glisse 
283c01cbba2SJérôme Glisse 	if (!should_unregister || mm == NULL)
284c01cbba2SJérôme Glisse 		return;
285c01cbba2SJérôme Glisse 
286*86a2d598SRalph Campbell 	mmu_notifier_unregister_no_release(&hmm->mmu_notifier, mm);
287*86a2d598SRalph Campbell 
288c01cbba2SJérôme Glisse 	spin_lock(&mm->page_table_lock);
289c01cbba2SJérôme Glisse 	if (mm->hmm == hmm)
290c01cbba2SJérôme Glisse 		mm->hmm = NULL;
291c01cbba2SJérôme Glisse 	spin_unlock(&mm->page_table_lock);
292c01cbba2SJérôme Glisse 
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 };
30374eee180SJérôme Glisse 
3042aee09d8SJérôme Glisse static int hmm_vma_do_fault(struct mm_walk *walk, unsigned long addr,
3052aee09d8SJérôme Glisse 			    bool write_fault, uint64_t *pfn)
30674eee180SJérôme Glisse {
30774eee180SJérôme Glisse 	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_REMOTE;
30874eee180SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
309f88a1e90SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
31074eee180SJérôme Glisse 	struct vm_area_struct *vma = walk->vma;
31150a7ca3cSSouptick Joarder 	vm_fault_t ret;
31274eee180SJérôme Glisse 
31374eee180SJérôme Glisse 	flags |= hmm_vma_walk->block ? 0 : FAULT_FLAG_ALLOW_RETRY;
3142aee09d8SJérôme Glisse 	flags |= write_fault ? FAULT_FLAG_WRITE : 0;
31550a7ca3cSSouptick Joarder 	ret = handle_mm_fault(vma, addr, flags);
31650a7ca3cSSouptick Joarder 	if (ret & VM_FAULT_RETRY)
31774eee180SJérôme Glisse 		return -EBUSY;
31850a7ca3cSSouptick Joarder 	if (ret & VM_FAULT_ERROR) {
319f88a1e90SJérôme Glisse 		*pfn = range->values[HMM_PFN_ERROR];
32074eee180SJérôme Glisse 		return -EFAULT;
32174eee180SJérôme Glisse 	}
32274eee180SJérôme Glisse 
32374eee180SJérôme Glisse 	return -EAGAIN;
32474eee180SJérôme Glisse }
32574eee180SJérôme Glisse 
326da4c3c73SJérôme Glisse static int hmm_pfns_bad(unsigned long addr,
327da4c3c73SJérôme Glisse 			unsigned long end,
328da4c3c73SJérôme Glisse 			struct mm_walk *walk)
329da4c3c73SJérôme Glisse {
330c719547fSJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
331c719547fSJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
332ff05c0c6SJérôme Glisse 	uint64_t *pfns = range->pfns;
333da4c3c73SJérôme Glisse 	unsigned long i;
334da4c3c73SJérôme Glisse 
335da4c3c73SJérôme Glisse 	i = (addr - range->start) >> PAGE_SHIFT;
336da4c3c73SJérôme Glisse 	for (; addr < end; addr += PAGE_SIZE, i++)
337f88a1e90SJérôme Glisse 		pfns[i] = range->values[HMM_PFN_ERROR];
338da4c3c73SJérôme Glisse 
339da4c3c73SJérôme Glisse 	return 0;
340da4c3c73SJérôme Glisse }
341da4c3c73SJérôme Glisse 
3425504ed29SJérôme Glisse /*
3435504ed29SJérôme Glisse  * hmm_vma_walk_hole() - handle a range lacking valid pmd or pte(s)
3445504ed29SJérôme Glisse  * @start: range virtual start address (inclusive)
3455504ed29SJérôme Glisse  * @end: range virtual end address (exclusive)
3462aee09d8SJérôme Glisse  * @fault: should we fault or not ?
3472aee09d8SJérôme Glisse  * @write_fault: write fault ?
3485504ed29SJérôme Glisse  * @walk: mm_walk structure
3495504ed29SJérôme Glisse  * Returns: 0 on success, -EAGAIN after page fault, or page fault error
3505504ed29SJérôme Glisse  *
3515504ed29SJérôme Glisse  * This function will be called whenever pmd_none() or pte_none() returns true,
3525504ed29SJérôme Glisse  * or whenever there is no page directory covering the virtual address range.
3535504ed29SJérôme Glisse  */
3542aee09d8SJérôme Glisse static int hmm_vma_walk_hole_(unsigned long addr, unsigned long end,
3552aee09d8SJérôme Glisse 			      bool fault, bool write_fault,
356da4c3c73SJérôme Glisse 			      struct mm_walk *walk)
357da4c3c73SJérôme Glisse {
35874eee180SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
35974eee180SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
360ff05c0c6SJérôme Glisse 	uint64_t *pfns = range->pfns;
361da4c3c73SJérôme Glisse 	unsigned long i;
362da4c3c73SJérôme Glisse 
36374eee180SJérôme Glisse 	hmm_vma_walk->last = addr;
364da4c3c73SJérôme Glisse 	i = (addr - range->start) >> PAGE_SHIFT;
36574eee180SJérôme Glisse 	for (; addr < end; addr += PAGE_SIZE, i++) {
366f88a1e90SJérôme Glisse 		pfns[i] = range->values[HMM_PFN_NONE];
3672aee09d8SJérôme Glisse 		if (fault || write_fault) {
36874eee180SJérôme Glisse 			int ret;
369da4c3c73SJérôme Glisse 
3702aee09d8SJérôme Glisse 			ret = hmm_vma_do_fault(walk, addr, write_fault,
3712aee09d8SJérôme Glisse 					       &pfns[i]);
37274eee180SJérôme Glisse 			if (ret != -EAGAIN)
37374eee180SJérôme Glisse 				return ret;
37474eee180SJérôme Glisse 		}
37574eee180SJérôme Glisse 	}
37674eee180SJérôme Glisse 
3772aee09d8SJérôme Glisse 	return (fault || write_fault) ? -EAGAIN : 0;
3782aee09d8SJérôme Glisse }
3792aee09d8SJérôme Glisse 
3802aee09d8SJérôme Glisse static inline void hmm_pte_need_fault(const struct hmm_vma_walk *hmm_vma_walk,
3812aee09d8SJérôme Glisse 				      uint64_t pfns, uint64_t cpu_flags,
3822aee09d8SJérôme Glisse 				      bool *fault, bool *write_fault)
3832aee09d8SJérôme Glisse {
384f88a1e90SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
385f88a1e90SJérôme Glisse 
3862aee09d8SJérôme Glisse 	*fault = *write_fault = false;
3872aee09d8SJérôme Glisse 	if (!hmm_vma_walk->fault)
3882aee09d8SJérôme Glisse 		return;
3892aee09d8SJérôme Glisse 
3902aee09d8SJérôme Glisse 	/* We aren't ask to do anything ... */
391f88a1e90SJérôme Glisse 	if (!(pfns & range->flags[HMM_PFN_VALID]))
3922aee09d8SJérôme Glisse 		return;
393f88a1e90SJérôme Glisse 	/* If this is device memory than only fault if explicitly requested */
394f88a1e90SJérôme Glisse 	if ((cpu_flags & range->flags[HMM_PFN_DEVICE_PRIVATE])) {
395f88a1e90SJérôme Glisse 		/* Do we fault on device memory ? */
396f88a1e90SJérôme Glisse 		if (pfns & range->flags[HMM_PFN_DEVICE_PRIVATE]) {
397f88a1e90SJérôme Glisse 			*write_fault = pfns & range->flags[HMM_PFN_WRITE];
398f88a1e90SJérôme Glisse 			*fault = true;
399f88a1e90SJérôme Glisse 		}
4002aee09d8SJérôme Glisse 		return;
4012aee09d8SJérôme Glisse 	}
402f88a1e90SJérôme Glisse 
403f88a1e90SJérôme Glisse 	/* If CPU page table is not valid then we need to fault */
404f88a1e90SJérôme Glisse 	*fault = !(cpu_flags & range->flags[HMM_PFN_VALID]);
405f88a1e90SJérôme Glisse 	/* Need to write fault ? */
406f88a1e90SJérôme Glisse 	if ((pfns & range->flags[HMM_PFN_WRITE]) &&
407f88a1e90SJérôme Glisse 	    !(cpu_flags & range->flags[HMM_PFN_WRITE])) {
408f88a1e90SJérôme Glisse 		*write_fault = true;
4092aee09d8SJérôme Glisse 		*fault = true;
4102aee09d8SJérôme Glisse 	}
4112aee09d8SJérôme Glisse }
4122aee09d8SJérôme Glisse 
4132aee09d8SJérôme Glisse static void hmm_range_need_fault(const struct hmm_vma_walk *hmm_vma_walk,
4142aee09d8SJérôme Glisse 				 const uint64_t *pfns, unsigned long npages,
4152aee09d8SJérôme Glisse 				 uint64_t cpu_flags, bool *fault,
4162aee09d8SJérôme Glisse 				 bool *write_fault)
4172aee09d8SJérôme Glisse {
4182aee09d8SJérôme Glisse 	unsigned long i;
4192aee09d8SJérôme Glisse 
4202aee09d8SJérôme Glisse 	if (!hmm_vma_walk->fault) {
4212aee09d8SJérôme Glisse 		*fault = *write_fault = false;
4222aee09d8SJérôme Glisse 		return;
4232aee09d8SJérôme Glisse 	}
4242aee09d8SJérôme Glisse 
4252aee09d8SJérôme Glisse 	for (i = 0; i < npages; ++i) {
4262aee09d8SJérôme Glisse 		hmm_pte_need_fault(hmm_vma_walk, pfns[i], cpu_flags,
4272aee09d8SJérôme Glisse 				   fault, write_fault);
4282aee09d8SJérôme Glisse 		if ((*fault) || (*write_fault))
4292aee09d8SJérôme Glisse 			return;
4302aee09d8SJérôme Glisse 	}
4312aee09d8SJérôme Glisse }
4322aee09d8SJérôme Glisse 
4332aee09d8SJérôme Glisse static int hmm_vma_walk_hole(unsigned long addr, unsigned long end,
4342aee09d8SJérôme Glisse 			     struct mm_walk *walk)
4352aee09d8SJérôme Glisse {
4362aee09d8SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
4372aee09d8SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
4382aee09d8SJérôme Glisse 	bool fault, write_fault;
4392aee09d8SJérôme Glisse 	unsigned long i, npages;
4402aee09d8SJérôme Glisse 	uint64_t *pfns;
4412aee09d8SJérôme Glisse 
4422aee09d8SJérôme Glisse 	i = (addr - range->start) >> PAGE_SHIFT;
4432aee09d8SJérôme Glisse 	npages = (end - addr) >> PAGE_SHIFT;
4442aee09d8SJérôme Glisse 	pfns = &range->pfns[i];
4452aee09d8SJérôme Glisse 	hmm_range_need_fault(hmm_vma_walk, pfns, npages,
4462aee09d8SJérôme Glisse 			     0, &fault, &write_fault);
4472aee09d8SJérôme Glisse 	return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk);
4482aee09d8SJérôme Glisse }
4492aee09d8SJérôme Glisse 
450f88a1e90SJérôme Glisse static inline uint64_t pmd_to_hmm_pfn_flags(struct hmm_range *range, pmd_t pmd)
4512aee09d8SJérôme Glisse {
4522aee09d8SJérôme Glisse 	if (pmd_protnone(pmd))
4532aee09d8SJérôme Glisse 		return 0;
454f88a1e90SJérôme Glisse 	return pmd_write(pmd) ? range->flags[HMM_PFN_VALID] |
455f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_WRITE] :
456f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_VALID];
457da4c3c73SJérôme Glisse }
458da4c3c73SJérôme Glisse 
45953f5c3f4SJérôme Glisse static int hmm_vma_handle_pmd(struct mm_walk *walk,
46053f5c3f4SJérôme Glisse 			      unsigned long addr,
46153f5c3f4SJérôme Glisse 			      unsigned long end,
46253f5c3f4SJérôme Glisse 			      uint64_t *pfns,
46353f5c3f4SJérôme Glisse 			      pmd_t pmd)
46453f5c3f4SJérôme Glisse {
46553f5c3f4SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
466f88a1e90SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
4672aee09d8SJérôme Glisse 	unsigned long pfn, npages, i;
4682aee09d8SJérôme Glisse 	bool fault, write_fault;
469f88a1e90SJérôme Glisse 	uint64_t cpu_flags;
47053f5c3f4SJérôme Glisse 
4712aee09d8SJérôme Glisse 	npages = (end - addr) >> PAGE_SHIFT;
472f88a1e90SJérôme Glisse 	cpu_flags = pmd_to_hmm_pfn_flags(range, pmd);
4732aee09d8SJérôme Glisse 	hmm_range_need_fault(hmm_vma_walk, pfns, npages, cpu_flags,
4742aee09d8SJérôme Glisse 			     &fault, &write_fault);
47553f5c3f4SJérôme Glisse 
4762aee09d8SJérôme Glisse 	if (pmd_protnone(pmd) || fault || write_fault)
4772aee09d8SJérôme Glisse 		return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk);
47853f5c3f4SJérôme Glisse 
47953f5c3f4SJérôme Glisse 	pfn = pmd_pfn(pmd) + pte_index(addr);
48053f5c3f4SJérôme Glisse 	for (i = 0; addr < end; addr += PAGE_SIZE, i++, pfn++)
481f88a1e90SJérôme Glisse 		pfns[i] = hmm_pfn_from_pfn(range, pfn) | cpu_flags;
48253f5c3f4SJérôme Glisse 	hmm_vma_walk->last = end;
48353f5c3f4SJérôme Glisse 	return 0;
48453f5c3f4SJérôme Glisse }
48553f5c3f4SJérôme Glisse 
486f88a1e90SJérôme Glisse static inline uint64_t pte_to_hmm_pfn_flags(struct hmm_range *range, pte_t pte)
4872aee09d8SJérôme Glisse {
4882aee09d8SJérôme Glisse 	if (pte_none(pte) || !pte_present(pte))
4892aee09d8SJérôme Glisse 		return 0;
490f88a1e90SJérôme Glisse 	return pte_write(pte) ? range->flags[HMM_PFN_VALID] |
491f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_WRITE] :
492f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_VALID];
4932aee09d8SJérôme Glisse }
4942aee09d8SJérôme Glisse 
49553f5c3f4SJérôme Glisse static int hmm_vma_handle_pte(struct mm_walk *walk, unsigned long addr,
49653f5c3f4SJérôme Glisse 			      unsigned long end, pmd_t *pmdp, pte_t *ptep,
49753f5c3f4SJérôme Glisse 			      uint64_t *pfn)
49853f5c3f4SJérôme Glisse {
49953f5c3f4SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
500f88a1e90SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
50153f5c3f4SJérôme Glisse 	struct vm_area_struct *vma = walk->vma;
5022aee09d8SJérôme Glisse 	bool fault, write_fault;
5032aee09d8SJérôme Glisse 	uint64_t cpu_flags;
50453f5c3f4SJérôme Glisse 	pte_t pte = *ptep;
505f88a1e90SJérôme Glisse 	uint64_t orig_pfn = *pfn;
50653f5c3f4SJérôme Glisse 
507f88a1e90SJérôme Glisse 	*pfn = range->values[HMM_PFN_NONE];
508f88a1e90SJérôme Glisse 	cpu_flags = pte_to_hmm_pfn_flags(range, pte);
509f88a1e90SJérôme Glisse 	hmm_pte_need_fault(hmm_vma_walk, orig_pfn, cpu_flags,
5102aee09d8SJérôme Glisse 			   &fault, &write_fault);
51153f5c3f4SJérôme Glisse 
51253f5c3f4SJérôme Glisse 	if (pte_none(pte)) {
5132aee09d8SJérôme Glisse 		if (fault || write_fault)
51453f5c3f4SJérôme Glisse 			goto fault;
51553f5c3f4SJérôme Glisse 		return 0;
51653f5c3f4SJérôme Glisse 	}
51753f5c3f4SJérôme Glisse 
51853f5c3f4SJérôme Glisse 	if (!pte_present(pte)) {
51953f5c3f4SJérôme Glisse 		swp_entry_t entry = pte_to_swp_entry(pte);
52053f5c3f4SJérôme Glisse 
52153f5c3f4SJérôme Glisse 		if (!non_swap_entry(entry)) {
5222aee09d8SJérôme Glisse 			if (fault || write_fault)
52353f5c3f4SJérôme Glisse 				goto fault;
52453f5c3f4SJérôme Glisse 			return 0;
52553f5c3f4SJérôme Glisse 		}
52653f5c3f4SJérôme Glisse 
52753f5c3f4SJérôme Glisse 		/*
52853f5c3f4SJérôme Glisse 		 * This is a special swap entry, ignore migration, use
52953f5c3f4SJérôme Glisse 		 * device and report anything else as error.
53053f5c3f4SJérôme Glisse 		 */
53153f5c3f4SJérôme Glisse 		if (is_device_private_entry(entry)) {
532f88a1e90SJérôme Glisse 			cpu_flags = range->flags[HMM_PFN_VALID] |
533f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_DEVICE_PRIVATE];
5342aee09d8SJérôme Glisse 			cpu_flags |= is_write_device_private_entry(entry) ?
535f88a1e90SJérôme Glisse 				range->flags[HMM_PFN_WRITE] : 0;
536f88a1e90SJérôme Glisse 			hmm_pte_need_fault(hmm_vma_walk, orig_pfn, cpu_flags,
537f88a1e90SJérôme Glisse 					   &fault, &write_fault);
538f88a1e90SJérôme Glisse 			if (fault || write_fault)
539f88a1e90SJérôme Glisse 				goto fault;
540f88a1e90SJérôme Glisse 			*pfn = hmm_pfn_from_pfn(range, swp_offset(entry));
541f88a1e90SJérôme Glisse 			*pfn |= cpu_flags;
54253f5c3f4SJérôme Glisse 			return 0;
54353f5c3f4SJérôme Glisse 		}
54453f5c3f4SJérôme Glisse 
54553f5c3f4SJérôme Glisse 		if (is_migration_entry(entry)) {
5462aee09d8SJérôme Glisse 			if (fault || write_fault) {
54753f5c3f4SJérôme Glisse 				pte_unmap(ptep);
54853f5c3f4SJérôme Glisse 				hmm_vma_walk->last = addr;
54953f5c3f4SJérôme Glisse 				migration_entry_wait(vma->vm_mm,
55053f5c3f4SJérôme Glisse 						     pmdp, addr);
55153f5c3f4SJérôme Glisse 				return -EAGAIN;
55253f5c3f4SJérôme Glisse 			}
55353f5c3f4SJérôme Glisse 			return 0;
55453f5c3f4SJérôme Glisse 		}
55553f5c3f4SJérôme Glisse 
55653f5c3f4SJérôme Glisse 		/* Report error for everything else */
557f88a1e90SJérôme Glisse 		*pfn = range->values[HMM_PFN_ERROR];
55853f5c3f4SJérôme Glisse 		return -EFAULT;
55953f5c3f4SJérôme Glisse 	}
56053f5c3f4SJérôme Glisse 
5612aee09d8SJérôme Glisse 	if (fault || write_fault)
56253f5c3f4SJérôme Glisse 		goto fault;
56353f5c3f4SJérôme Glisse 
564f88a1e90SJérôme Glisse 	*pfn = hmm_pfn_from_pfn(range, pte_pfn(pte)) | cpu_flags;
56553f5c3f4SJérôme Glisse 	return 0;
56653f5c3f4SJérôme Glisse 
56753f5c3f4SJérôme Glisse fault:
56853f5c3f4SJérôme Glisse 	pte_unmap(ptep);
56953f5c3f4SJérôme Glisse 	/* Fault any virtual address we were asked to fault */
5702aee09d8SJérôme Glisse 	return hmm_vma_walk_hole_(addr, end, fault, write_fault, walk);
57153f5c3f4SJérôme Glisse }
57253f5c3f4SJérôme Glisse 
573da4c3c73SJérôme Glisse static int hmm_vma_walk_pmd(pmd_t *pmdp,
574da4c3c73SJérôme Glisse 			    unsigned long start,
575da4c3c73SJérôme Glisse 			    unsigned long end,
576da4c3c73SJérôme Glisse 			    struct mm_walk *walk)
577da4c3c73SJérôme Glisse {
57874eee180SJérôme Glisse 	struct hmm_vma_walk *hmm_vma_walk = walk->private;
57974eee180SJérôme Glisse 	struct hmm_range *range = hmm_vma_walk->range;
580ff05c0c6SJérôme Glisse 	uint64_t *pfns = range->pfns;
581da4c3c73SJérôme Glisse 	unsigned long addr = start, i;
582da4c3c73SJérôme Glisse 	pte_t *ptep;
583da4c3c73SJérôme Glisse 
584da4c3c73SJérôme Glisse 	i = (addr - range->start) >> PAGE_SHIFT;
585da4c3c73SJérôme Glisse 
586da4c3c73SJérôme Glisse again:
587da4c3c73SJérôme Glisse 	if (pmd_none(*pmdp))
588da4c3c73SJérôme Glisse 		return hmm_vma_walk_hole(start, end, walk);
589da4c3c73SJérôme Glisse 
59053f5c3f4SJérôme Glisse 	if (pmd_huge(*pmdp) && (range->vma->vm_flags & VM_HUGETLB))
591da4c3c73SJérôme Glisse 		return hmm_pfns_bad(start, end, walk);
592da4c3c73SJérôme Glisse 
593da4c3c73SJérôme Glisse 	if (pmd_devmap(*pmdp) || pmd_trans_huge(*pmdp)) {
594da4c3c73SJérôme Glisse 		pmd_t pmd;
595da4c3c73SJérôme Glisse 
596da4c3c73SJérôme Glisse 		/*
597da4c3c73SJérôme Glisse 		 * No need to take pmd_lock here, even if some other threads
598da4c3c73SJérôme Glisse 		 * is splitting the huge pmd we will get that event through
599da4c3c73SJérôme Glisse 		 * mmu_notifier callback.
600da4c3c73SJérôme Glisse 		 *
601da4c3c73SJérôme Glisse 		 * So just read pmd value and check again its a transparent
602da4c3c73SJérôme Glisse 		 * huge or device mapping one and compute corresponding pfn
603da4c3c73SJérôme Glisse 		 * values.
604da4c3c73SJérôme Glisse 		 */
605da4c3c73SJérôme Glisse 		pmd = pmd_read_atomic(pmdp);
606da4c3c73SJérôme Glisse 		barrier();
607da4c3c73SJérôme Glisse 		if (!pmd_devmap(pmd) && !pmd_trans_huge(pmd))
608da4c3c73SJérôme Glisse 			goto again;
609da4c3c73SJérôme Glisse 
61053f5c3f4SJérôme Glisse 		return hmm_vma_handle_pmd(walk, addr, end, &pfns[i], pmd);
611da4c3c73SJérôme Glisse 	}
612da4c3c73SJérôme Glisse 
613da4c3c73SJérôme Glisse 	if (pmd_bad(*pmdp))
614da4c3c73SJérôme Glisse 		return hmm_pfns_bad(start, end, walk);
615da4c3c73SJérôme Glisse 
616da4c3c73SJérôme Glisse 	ptep = pte_offset_map(pmdp, addr);
617da4c3c73SJérôme Glisse 	for (; addr < end; addr += PAGE_SIZE, ptep++, i++) {
61853f5c3f4SJérôme Glisse 		int r;
619da4c3c73SJérôme Glisse 
62053f5c3f4SJérôme Glisse 		r = hmm_vma_handle_pte(walk, addr, end, pmdp, ptep, &pfns[i]);
62153f5c3f4SJérôme Glisse 		if (r) {
62253f5c3f4SJérôme Glisse 			/* hmm_vma_handle_pte() did unmap pte directory */
62374eee180SJérôme Glisse 			hmm_vma_walk->last = addr;
62453f5c3f4SJérôme Glisse 			return r;
62574eee180SJérôme Glisse 		}
626da4c3c73SJérôme Glisse 	}
627da4c3c73SJérôme Glisse 	pte_unmap(ptep - 1);
628da4c3c73SJérôme Glisse 
62953f5c3f4SJérôme Glisse 	hmm_vma_walk->last = addr;
630da4c3c73SJérôme Glisse 	return 0;
631da4c3c73SJérôme Glisse }
632da4c3c73SJérôme Glisse 
633f88a1e90SJérôme Glisse static void hmm_pfns_clear(struct hmm_range *range,
634f88a1e90SJérôme Glisse 			   uint64_t *pfns,
63533cd47dcSJérôme Glisse 			   unsigned long addr,
63633cd47dcSJérôme Glisse 			   unsigned long end)
63733cd47dcSJérôme Glisse {
63833cd47dcSJérôme Glisse 	for (; addr < end; addr += PAGE_SIZE, pfns++)
639f88a1e90SJérôme Glisse 		*pfns = range->values[HMM_PFN_NONE];
64033cd47dcSJérôme Glisse }
64133cd47dcSJérôme Glisse 
642855ce7d2SJérôme Glisse static void hmm_pfns_special(struct hmm_range *range)
643855ce7d2SJérôme Glisse {
644855ce7d2SJérôme Glisse 	unsigned long addr = range->start, i = 0;
645855ce7d2SJérôme Glisse 
646855ce7d2SJérôme Glisse 	for (; addr < range->end; addr += PAGE_SIZE, i++)
647f88a1e90SJérôme Glisse 		range->pfns[i] = range->values[HMM_PFN_SPECIAL];
648855ce7d2SJérôme Glisse }
649855ce7d2SJérôme Glisse 
650da4c3c73SJérôme Glisse /*
651da4c3c73SJérôme Glisse  * hmm_vma_get_pfns() - snapshot CPU page table for a range of virtual addresses
65208232a45SJérôme Glisse  * @range: range being snapshotted
65386586a41SJérôme Glisse  * Returns: -EINVAL if invalid argument, -ENOMEM out of memory, -EPERM invalid
65486586a41SJérôme Glisse  *          vma permission, 0 success
655da4c3c73SJérôme Glisse  *
656da4c3c73SJérôme Glisse  * This snapshots the CPU page table for a range of virtual addresses. Snapshot
657da4c3c73SJérôme Glisse  * validity is tracked by range struct. See hmm_vma_range_done() for further
658da4c3c73SJérôme Glisse  * information.
659da4c3c73SJérôme Glisse  *
660da4c3c73SJérôme Glisse  * The range struct is initialized here. It tracks the CPU page table, but only
661da4c3c73SJérôme Glisse  * if the function returns success (0), in which case the caller must then call
662da4c3c73SJérôme Glisse  * hmm_vma_range_done() to stop CPU page table update tracking on this range.
663da4c3c73SJérôme Glisse  *
664da4c3c73SJérôme Glisse  * NOT CALLING hmm_vma_range_done() IF FUNCTION RETURNS 0 WILL LEAD TO SERIOUS
665da4c3c73SJérôme Glisse  * MEMORY CORRUPTION ! YOU HAVE BEEN WARNED !
666da4c3c73SJérôme Glisse  */
66708232a45SJérôme Glisse int hmm_vma_get_pfns(struct hmm_range *range)
668da4c3c73SJérôme Glisse {
66908232a45SJérôme Glisse 	struct vm_area_struct *vma = range->vma;
67074eee180SJérôme Glisse 	struct hmm_vma_walk hmm_vma_walk;
671da4c3c73SJérôme Glisse 	struct mm_walk mm_walk;
672da4c3c73SJérôme Glisse 	struct hmm *hmm;
673da4c3c73SJérôme Glisse 
674da4c3c73SJérôme Glisse 	/* Sanity check, this really should not happen ! */
67508232a45SJérôme Glisse 	if (range->start < vma->vm_start || range->start >= vma->vm_end)
676da4c3c73SJérôme Glisse 		return -EINVAL;
67708232a45SJérôme Glisse 	if (range->end < vma->vm_start || range->end > vma->vm_end)
678da4c3c73SJérôme Glisse 		return -EINVAL;
679da4c3c73SJérôme Glisse 
680da4c3c73SJérôme Glisse 	hmm = hmm_register(vma->vm_mm);
681da4c3c73SJérôme Glisse 	if (!hmm)
682da4c3c73SJérôme Glisse 		return -ENOMEM;
683da4c3c73SJérôme Glisse 	/* Caller must have registered a mirror, via hmm_mirror_register() ! */
684da4c3c73SJérôme Glisse 	if (!hmm->mmu_notifier.ops)
685da4c3c73SJérôme Glisse 		return -EINVAL;
686da4c3c73SJérôme Glisse 
687855ce7d2SJérôme Glisse 	/* FIXME support hugetlb fs */
688e1fb4a08SDave Jiang 	if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL) ||
689e1fb4a08SDave Jiang 			vma_is_dax(vma)) {
690855ce7d2SJérôme Glisse 		hmm_pfns_special(range);
691855ce7d2SJérôme Glisse 		return -EINVAL;
692855ce7d2SJérôme Glisse 	}
693855ce7d2SJérôme Glisse 
69486586a41SJérôme Glisse 	if (!(vma->vm_flags & VM_READ)) {
69586586a41SJérôme Glisse 		/*
69686586a41SJérôme Glisse 		 * If vma do not allow read access, then assume that it does
69786586a41SJérôme Glisse 		 * not allow write access, either. Architecture that allow
69886586a41SJérôme Glisse 		 * write without read access are not supported by HMM, because
69986586a41SJérôme Glisse 		 * operations such has atomic access would not work.
70086586a41SJérôme Glisse 		 */
701f88a1e90SJérôme Glisse 		hmm_pfns_clear(range, range->pfns, range->start, range->end);
70286586a41SJérôme Glisse 		return -EPERM;
70386586a41SJérôme Glisse 	}
70486586a41SJérôme Glisse 
705da4c3c73SJérôme Glisse 	/* Initialize range to track CPU page table update */
706da4c3c73SJérôme Glisse 	spin_lock(&hmm->lock);
707da4c3c73SJérôme Glisse 	range->valid = true;
708da4c3c73SJérôme Glisse 	list_add_rcu(&range->list, &hmm->ranges);
709da4c3c73SJérôme Glisse 	spin_unlock(&hmm->lock);
710da4c3c73SJérôme Glisse 
71174eee180SJérôme Glisse 	hmm_vma_walk.fault = false;
71274eee180SJérôme Glisse 	hmm_vma_walk.range = range;
71374eee180SJérôme Glisse 	mm_walk.private = &hmm_vma_walk;
71474eee180SJérôme Glisse 
715da4c3c73SJérôme Glisse 	mm_walk.vma = vma;
716da4c3c73SJérôme Glisse 	mm_walk.mm = vma->vm_mm;
717da4c3c73SJérôme Glisse 	mm_walk.pte_entry = NULL;
718da4c3c73SJérôme Glisse 	mm_walk.test_walk = NULL;
719da4c3c73SJérôme Glisse 	mm_walk.hugetlb_entry = NULL;
720da4c3c73SJérôme Glisse 	mm_walk.pmd_entry = hmm_vma_walk_pmd;
721da4c3c73SJérôme Glisse 	mm_walk.pte_hole = hmm_vma_walk_hole;
722da4c3c73SJérôme Glisse 
72308232a45SJérôme Glisse 	walk_page_range(range->start, range->end, &mm_walk);
724da4c3c73SJérôme Glisse 	return 0;
725da4c3c73SJérôme Glisse }
726da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_get_pfns);
727da4c3c73SJérôme Glisse 
728da4c3c73SJérôme Glisse /*
729da4c3c73SJérôme Glisse  * hmm_vma_range_done() - stop tracking change to CPU page table over a range
730da4c3c73SJérôme Glisse  * @range: range being tracked
731da4c3c73SJérôme Glisse  * Returns: false if range data has been invalidated, true otherwise
732da4c3c73SJérôme Glisse  *
733da4c3c73SJérôme Glisse  * Range struct is used to track updates to the CPU page table after a call to
734da4c3c73SJérôme Glisse  * either hmm_vma_get_pfns() or hmm_vma_fault(). Once the device driver is done
735da4c3c73SJérôme Glisse  * using the data,  or wants to lock updates to the data it got from those
736da4c3c73SJérôme Glisse  * functions, it must call the hmm_vma_range_done() function, which will then
737da4c3c73SJérôme Glisse  * stop tracking CPU page table updates.
738da4c3c73SJérôme Glisse  *
739da4c3c73SJérôme Glisse  * Note that device driver must still implement general CPU page table update
740da4c3c73SJérôme Glisse  * tracking either by using hmm_mirror (see hmm_mirror_register()) or by using
741da4c3c73SJérôme Glisse  * the mmu_notifier API directly.
742da4c3c73SJérôme Glisse  *
743da4c3c73SJérôme Glisse  * CPU page table update tracking done through hmm_range is only temporary and
744da4c3c73SJérôme Glisse  * to be used while trying to duplicate CPU page table contents for a range of
745da4c3c73SJérôme Glisse  * virtual addresses.
746da4c3c73SJérôme Glisse  *
747da4c3c73SJérôme Glisse  * There are two ways to use this :
748da4c3c73SJérôme Glisse  * again:
74908232a45SJérôme Glisse  *   hmm_vma_get_pfns(range); or hmm_vma_fault(...);
750da4c3c73SJérôme Glisse  *   trans = device_build_page_table_update_transaction(pfns);
751da4c3c73SJérôme Glisse  *   device_page_table_lock();
75208232a45SJérôme Glisse  *   if (!hmm_vma_range_done(range)) {
753da4c3c73SJérôme Glisse  *     device_page_table_unlock();
754da4c3c73SJérôme Glisse  *     goto again;
755da4c3c73SJérôme Glisse  *   }
756da4c3c73SJérôme Glisse  *   device_commit_transaction(trans);
757da4c3c73SJérôme Glisse  *   device_page_table_unlock();
758da4c3c73SJérôme Glisse  *
759da4c3c73SJérôme Glisse  * Or:
76008232a45SJérôme Glisse  *   hmm_vma_get_pfns(range); or hmm_vma_fault(...);
761da4c3c73SJérôme Glisse  *   device_page_table_lock();
76208232a45SJérôme Glisse  *   hmm_vma_range_done(range);
76308232a45SJérôme Glisse  *   device_update_page_table(range->pfns);
764da4c3c73SJérôme Glisse  *   device_page_table_unlock();
765da4c3c73SJérôme Glisse  */
76608232a45SJérôme Glisse bool hmm_vma_range_done(struct hmm_range *range)
767da4c3c73SJérôme Glisse {
768da4c3c73SJérôme Glisse 	unsigned long npages = (range->end - range->start) >> PAGE_SHIFT;
769da4c3c73SJérôme Glisse 	struct hmm *hmm;
770da4c3c73SJérôme Glisse 
771da4c3c73SJérôme Glisse 	if (range->end <= range->start) {
772da4c3c73SJérôme Glisse 		BUG();
773da4c3c73SJérôme Glisse 		return false;
774da4c3c73SJérôme Glisse 	}
775da4c3c73SJérôme Glisse 
77608232a45SJérôme Glisse 	hmm = hmm_register(range->vma->vm_mm);
777da4c3c73SJérôme Glisse 	if (!hmm) {
778da4c3c73SJérôme Glisse 		memset(range->pfns, 0, sizeof(*range->pfns) * npages);
779da4c3c73SJérôme Glisse 		return false;
780da4c3c73SJérôme Glisse 	}
781da4c3c73SJérôme Glisse 
782da4c3c73SJérôme Glisse 	spin_lock(&hmm->lock);
783da4c3c73SJérôme Glisse 	list_del_rcu(&range->list);
784da4c3c73SJérôme Glisse 	spin_unlock(&hmm->lock);
785da4c3c73SJérôme Glisse 
786da4c3c73SJérôme Glisse 	return range->valid;
787da4c3c73SJérôme Glisse }
788da4c3c73SJérôme Glisse EXPORT_SYMBOL(hmm_vma_range_done);
78974eee180SJérôme Glisse 
79074eee180SJérôme Glisse /*
79174eee180SJérôme Glisse  * hmm_vma_fault() - try to fault some address in a virtual address range
79208232a45SJérôme Glisse  * @range: range being faulted
79374eee180SJérôme Glisse  * @block: allow blocking on fault (if true it sleeps and do not drop mmap_sem)
79474eee180SJérôme Glisse  * Returns: 0 success, error otherwise (-EAGAIN means mmap_sem have been drop)
79574eee180SJérôme Glisse  *
79674eee180SJérôme Glisse  * This is similar to a regular CPU page fault except that it will not trigger
79774eee180SJérôme Glisse  * any memory migration if the memory being faulted is not accessible by CPUs.
79874eee180SJérôme Glisse  *
799ff05c0c6SJérôme Glisse  * On error, for one virtual address in the range, the function will mark the
800ff05c0c6SJérôme Glisse  * corresponding HMM pfn entry with an error flag.
80174eee180SJérôme Glisse  *
80274eee180SJérôme Glisse  * Expected use pattern:
80374eee180SJérôme Glisse  * retry:
80474eee180SJérôme Glisse  *   down_read(&mm->mmap_sem);
80574eee180SJérôme Glisse  *   // Find vma and address device wants to fault, initialize hmm_pfn_t
80674eee180SJérôme Glisse  *   // array accordingly
80708232a45SJérôme Glisse  *   ret = hmm_vma_fault(range, write, block);
80874eee180SJérôme Glisse  *   switch (ret) {
80974eee180SJérôme Glisse  *   case -EAGAIN:
81008232a45SJérôme Glisse  *     hmm_vma_range_done(range);
81174eee180SJérôme Glisse  *     // You might want to rate limit or yield to play nicely, you may
81274eee180SJérôme Glisse  *     // also commit any valid pfn in the array assuming that you are
81374eee180SJérôme Glisse  *     // getting true from hmm_vma_range_monitor_end()
81474eee180SJérôme Glisse  *     goto retry;
81574eee180SJérôme Glisse  *   case 0:
81674eee180SJérôme Glisse  *     break;
81786586a41SJérôme Glisse  *   case -ENOMEM:
81886586a41SJérôme Glisse  *   case -EINVAL:
81986586a41SJérôme Glisse  *   case -EPERM:
82074eee180SJérôme Glisse  *   default:
82174eee180SJérôme Glisse  *     // Handle error !
82274eee180SJérôme Glisse  *     up_read(&mm->mmap_sem)
82374eee180SJérôme Glisse  *     return;
82474eee180SJérôme Glisse  *   }
82574eee180SJérôme Glisse  *   // Take device driver lock that serialize device page table update
82674eee180SJérôme Glisse  *   driver_lock_device_page_table_update();
82708232a45SJérôme Glisse  *   hmm_vma_range_done(range);
82874eee180SJérôme Glisse  *   // Commit pfns we got from hmm_vma_fault()
82974eee180SJérôme Glisse  *   driver_unlock_device_page_table_update();
83074eee180SJérôme Glisse  *   up_read(&mm->mmap_sem)
83174eee180SJérôme Glisse  *
83274eee180SJérôme Glisse  * YOU MUST CALL hmm_vma_range_done() AFTER THIS FUNCTION RETURN SUCCESS (0)
83374eee180SJérôme Glisse  * BEFORE FREEING THE range struct OR YOU WILL HAVE SERIOUS MEMORY CORRUPTION !
83474eee180SJérôme Glisse  *
83574eee180SJérôme Glisse  * YOU HAVE BEEN WARNED !
83674eee180SJérôme Glisse  */
8372aee09d8SJérôme Glisse int hmm_vma_fault(struct hmm_range *range, bool block)
83874eee180SJérôme Glisse {
83908232a45SJérôme Glisse 	struct vm_area_struct *vma = range->vma;
84008232a45SJérôme Glisse 	unsigned long start = range->start;
84174eee180SJérôme Glisse 	struct hmm_vma_walk hmm_vma_walk;
84274eee180SJérôme Glisse 	struct mm_walk mm_walk;
84374eee180SJérôme Glisse 	struct hmm *hmm;
84474eee180SJérôme Glisse 	int ret;
84574eee180SJérôme Glisse 
84674eee180SJérôme Glisse 	/* Sanity check, this really should not happen ! */
84708232a45SJérôme Glisse 	if (range->start < vma->vm_start || range->start >= vma->vm_end)
84874eee180SJérôme Glisse 		return -EINVAL;
84908232a45SJérôme Glisse 	if (range->end < vma->vm_start || range->end > vma->vm_end)
85074eee180SJérôme Glisse 		return -EINVAL;
85174eee180SJérôme Glisse 
85274eee180SJérôme Glisse 	hmm = hmm_register(vma->vm_mm);
85374eee180SJérôme Glisse 	if (!hmm) {
854f88a1e90SJérôme Glisse 		hmm_pfns_clear(range, range->pfns, range->start, range->end);
85574eee180SJérôme Glisse 		return -ENOMEM;
85674eee180SJérôme Glisse 	}
85774eee180SJérôme Glisse 	/* Caller must have registered a mirror using hmm_mirror_register() */
85874eee180SJérôme Glisse 	if (!hmm->mmu_notifier.ops)
85974eee180SJérôme Glisse 		return -EINVAL;
86074eee180SJérôme Glisse 
861855ce7d2SJérôme Glisse 	/* FIXME support hugetlb fs */
862e1fb4a08SDave Jiang 	if (is_vm_hugetlb_page(vma) || (vma->vm_flags & VM_SPECIAL) ||
863e1fb4a08SDave Jiang 			vma_is_dax(vma)) {
864855ce7d2SJérôme Glisse 		hmm_pfns_special(range);
865855ce7d2SJérôme Glisse 		return -EINVAL;
866855ce7d2SJérôme Glisse 	}
867855ce7d2SJérôme Glisse 
86886586a41SJérôme Glisse 	if (!(vma->vm_flags & VM_READ)) {
86986586a41SJérôme Glisse 		/*
87086586a41SJérôme Glisse 		 * If vma do not allow read access, then assume that it does
87186586a41SJérôme Glisse 		 * not allow write access, either. Architecture that allow
87286586a41SJérôme Glisse 		 * write without read access are not supported by HMM, because
87386586a41SJérôme Glisse 		 * operations such has atomic access would not work.
87486586a41SJérôme Glisse 		 */
875f88a1e90SJérôme Glisse 		hmm_pfns_clear(range, range->pfns, range->start, range->end);
87686586a41SJérôme Glisse 		return -EPERM;
87786586a41SJérôme Glisse 	}
87874eee180SJérôme Glisse 
87986586a41SJérôme Glisse 	/* Initialize range to track CPU page table update */
88086586a41SJérôme Glisse 	spin_lock(&hmm->lock);
88186586a41SJérôme Glisse 	range->valid = true;
88286586a41SJérôme Glisse 	list_add_rcu(&range->list, &hmm->ranges);
88386586a41SJérôme Glisse 	spin_unlock(&hmm->lock);
88486586a41SJérôme Glisse 
88574eee180SJérôme Glisse 	hmm_vma_walk.fault = true;
88674eee180SJérôme Glisse 	hmm_vma_walk.block = block;
88774eee180SJérôme Glisse 	hmm_vma_walk.range = range;
88874eee180SJérôme Glisse 	mm_walk.private = &hmm_vma_walk;
88974eee180SJérôme Glisse 	hmm_vma_walk.last = range->start;
89074eee180SJérôme Glisse 
89174eee180SJérôme Glisse 	mm_walk.vma = vma;
89274eee180SJérôme Glisse 	mm_walk.mm = vma->vm_mm;
89374eee180SJérôme Glisse 	mm_walk.pte_entry = NULL;
89474eee180SJérôme Glisse 	mm_walk.test_walk = NULL;
89574eee180SJérôme Glisse 	mm_walk.hugetlb_entry = NULL;
89674eee180SJérôme Glisse 	mm_walk.pmd_entry = hmm_vma_walk_pmd;
89774eee180SJérôme Glisse 	mm_walk.pte_hole = hmm_vma_walk_hole;
89874eee180SJérôme Glisse 
89974eee180SJérôme Glisse 	do {
90008232a45SJérôme Glisse 		ret = walk_page_range(start, range->end, &mm_walk);
90174eee180SJérôme Glisse 		start = hmm_vma_walk.last;
90274eee180SJérôme Glisse 	} while (ret == -EAGAIN);
90374eee180SJérôme Glisse 
90474eee180SJérôme Glisse 	if (ret) {
90574eee180SJérôme Glisse 		unsigned long i;
90674eee180SJérôme Glisse 
90774eee180SJérôme Glisse 		i = (hmm_vma_walk.last - range->start) >> PAGE_SHIFT;
908f88a1e90SJérôme Glisse 		hmm_pfns_clear(range, &range->pfns[i], hmm_vma_walk.last,
909f88a1e90SJérôme Glisse 			       range->end);
91008232a45SJérôme Glisse 		hmm_vma_range_done(range);
91174eee180SJérôme Glisse 	}
91274eee180SJérôme Glisse 	return ret;
91374eee180SJérôme Glisse }
91474eee180SJérôme Glisse EXPORT_SYMBOL(hmm_vma_fault);
915c0b12405SJérôme Glisse #endif /* IS_ENABLED(CONFIG_HMM_MIRROR) */
9164ef589dcSJérôme Glisse 
9174ef589dcSJérôme Glisse 
918df6ad698SJérôme Glisse #if IS_ENABLED(CONFIG_DEVICE_PRIVATE) ||  IS_ENABLED(CONFIG_DEVICE_PUBLIC)
9194ef589dcSJérôme Glisse struct page *hmm_vma_alloc_locked_page(struct vm_area_struct *vma,
9204ef589dcSJérôme Glisse 				       unsigned long addr)
9214ef589dcSJérôme Glisse {
9224ef589dcSJérôme Glisse 	struct page *page;
9234ef589dcSJérôme Glisse 
9244ef589dcSJérôme Glisse 	page = alloc_page_vma(GFP_HIGHUSER, vma, addr);
9254ef589dcSJérôme Glisse 	if (!page)
9264ef589dcSJérôme Glisse 		return NULL;
9274ef589dcSJérôme Glisse 	lock_page(page);
9284ef589dcSJérôme Glisse 	return page;
9294ef589dcSJérôme Glisse }
9304ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_vma_alloc_locked_page);
9314ef589dcSJérôme Glisse 
9324ef589dcSJérôme Glisse 
9334ef589dcSJérôme Glisse static void hmm_devmem_ref_release(struct percpu_ref *ref)
9344ef589dcSJérôme Glisse {
9354ef589dcSJérôme Glisse 	struct hmm_devmem *devmem;
9364ef589dcSJérôme Glisse 
9374ef589dcSJérôme Glisse 	devmem = container_of(ref, struct hmm_devmem, ref);
9384ef589dcSJérôme Glisse 	complete(&devmem->completion);
9394ef589dcSJérôme Glisse }
9404ef589dcSJérôme Glisse 
9414ef589dcSJérôme Glisse static void hmm_devmem_ref_exit(void *data)
9424ef589dcSJérôme Glisse {
9434ef589dcSJérôme Glisse 	struct percpu_ref *ref = data;
9444ef589dcSJérôme Glisse 	struct hmm_devmem *devmem;
9454ef589dcSJérôme Glisse 
9464ef589dcSJérôme Glisse 	devmem = container_of(ref, struct hmm_devmem, ref);
9474ef589dcSJérôme Glisse 	percpu_ref_exit(ref);
9484ef589dcSJérôme Glisse 	devm_remove_action(devmem->device, &hmm_devmem_ref_exit, data);
9494ef589dcSJérôme Glisse }
9504ef589dcSJérôme Glisse 
9514ef589dcSJérôme Glisse static void hmm_devmem_ref_kill(void *data)
9524ef589dcSJérôme Glisse {
9534ef589dcSJérôme Glisse 	struct percpu_ref *ref = data;
9544ef589dcSJérôme Glisse 	struct hmm_devmem *devmem;
9554ef589dcSJérôme Glisse 
9564ef589dcSJérôme Glisse 	devmem = container_of(ref, struct hmm_devmem, ref);
9574ef589dcSJérôme Glisse 	percpu_ref_kill(ref);
9584ef589dcSJérôme Glisse 	wait_for_completion(&devmem->completion);
9594ef589dcSJérôme Glisse 	devm_remove_action(devmem->device, &hmm_devmem_ref_kill, data);
9604ef589dcSJérôme Glisse }
9614ef589dcSJérôme Glisse 
9624ef589dcSJérôme Glisse static int hmm_devmem_fault(struct vm_area_struct *vma,
9634ef589dcSJérôme Glisse 			    unsigned long addr,
9644ef589dcSJérôme Glisse 			    const struct page *page,
9654ef589dcSJérôme Glisse 			    unsigned int flags,
9664ef589dcSJérôme Glisse 			    pmd_t *pmdp)
9674ef589dcSJérôme Glisse {
9684ef589dcSJérôme Glisse 	struct hmm_devmem *devmem = page->pgmap->data;
9694ef589dcSJérôme Glisse 
9704ef589dcSJérôme Glisse 	return devmem->ops->fault(devmem, vma, addr, page, flags, pmdp);
9714ef589dcSJérôme Glisse }
9724ef589dcSJérôme Glisse 
9734ef589dcSJérôme Glisse static void hmm_devmem_free(struct page *page, void *data)
9744ef589dcSJérôme Glisse {
9754ef589dcSJérôme Glisse 	struct hmm_devmem *devmem = data;
9764ef589dcSJérôme Glisse 
9772fa147bdSDan Williams 	page->mapping = NULL;
9782fa147bdSDan Williams 
9794ef589dcSJérôme Glisse 	devmem->ops->free(devmem, page);
9804ef589dcSJérôme Glisse }
9814ef589dcSJérôme Glisse 
9824ef589dcSJérôme Glisse static DEFINE_MUTEX(hmm_devmem_lock);
9834ef589dcSJérôme Glisse static RADIX_TREE(hmm_devmem_radix, GFP_KERNEL);
9844ef589dcSJérôme Glisse 
9854ef589dcSJérôme Glisse static void hmm_devmem_radix_release(struct resource *resource)
9864ef589dcSJérôme Glisse {
9871e926419SColin Ian King 	resource_size_t key;
9884ef589dcSJérôme Glisse 
9894ef589dcSJérôme Glisse 	mutex_lock(&hmm_devmem_lock);
9904ef589dcSJérôme Glisse 	for (key = resource->start;
9914ef589dcSJérôme Glisse 	     key <= resource->end;
9924ef589dcSJérôme Glisse 	     key += PA_SECTION_SIZE)
9934ef589dcSJérôme Glisse 		radix_tree_delete(&hmm_devmem_radix, key >> PA_SECTION_SHIFT);
9944ef589dcSJérôme Glisse 	mutex_unlock(&hmm_devmem_lock);
9954ef589dcSJérôme Glisse }
9964ef589dcSJérôme Glisse 
9974ef589dcSJérôme Glisse static void hmm_devmem_release(struct device *dev, void *data)
9984ef589dcSJérôme Glisse {
9994ef589dcSJérôme Glisse 	struct hmm_devmem *devmem = data;
10004ef589dcSJérôme Glisse 	struct resource *resource = devmem->resource;
10014ef589dcSJérôme Glisse 	unsigned long start_pfn, npages;
10024ef589dcSJérôme Glisse 	struct zone *zone;
10034ef589dcSJérôme Glisse 	struct page *page;
10044ef589dcSJérôme Glisse 
10054ef589dcSJérôme Glisse 	if (percpu_ref_tryget_live(&devmem->ref)) {
10064ef589dcSJérôme Glisse 		dev_WARN(dev, "%s: page mapping is still live!\n", __func__);
10074ef589dcSJérôme Glisse 		percpu_ref_put(&devmem->ref);
10084ef589dcSJérôme Glisse 	}
10094ef589dcSJérôme Glisse 
10104ef589dcSJérôme Glisse 	/* pages are dead and unused, undo the arch mapping */
10114ef589dcSJérôme Glisse 	start_pfn = (resource->start & ~(PA_SECTION_SIZE - 1)) >> PAGE_SHIFT;
10124ef589dcSJérôme Glisse 	npages = ALIGN(resource_size(resource), PA_SECTION_SIZE) >> PAGE_SHIFT;
10134ef589dcSJérôme Glisse 
10144ef589dcSJérôme Glisse 	page = pfn_to_page(start_pfn);
10154ef589dcSJérôme Glisse 	zone = page_zone(page);
10164ef589dcSJérôme Glisse 
10174ef589dcSJérôme Glisse 	mem_hotplug_begin();
1018d3df0a42SJérôme Glisse 	if (resource->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY)
1019da024512SChristoph Hellwig 		__remove_pages(zone, start_pfn, npages, NULL);
1020d3df0a42SJérôme Glisse 	else
1021d3df0a42SJérôme Glisse 		arch_remove_memory(start_pfn << PAGE_SHIFT,
1022da024512SChristoph Hellwig 				   npages << PAGE_SHIFT, NULL);
10234ef589dcSJérôme Glisse 	mem_hotplug_done();
10244ef589dcSJérôme Glisse 
10254ef589dcSJérôme Glisse 	hmm_devmem_radix_release(resource);
10264ef589dcSJérôme Glisse }
10274ef589dcSJérôme Glisse 
10284ef589dcSJérôme Glisse static int hmm_devmem_pages_create(struct hmm_devmem *devmem)
10294ef589dcSJérôme Glisse {
10304ef589dcSJérôme Glisse 	resource_size_t key, align_start, align_size, align_end;
10314ef589dcSJérôme Glisse 	struct device *device = devmem->device;
10324ef589dcSJérôme Glisse 	int ret, nid, is_ram;
10334ef589dcSJérôme Glisse 
10344ef589dcSJérôme Glisse 	align_start = devmem->resource->start & ~(PA_SECTION_SIZE - 1);
10354ef589dcSJérôme Glisse 	align_size = ALIGN(devmem->resource->start +
10364ef589dcSJérôme Glisse 			   resource_size(devmem->resource),
10374ef589dcSJérôme Glisse 			   PA_SECTION_SIZE) - align_start;
10384ef589dcSJérôme Glisse 
10394ef589dcSJérôme Glisse 	is_ram = region_intersects(align_start, align_size,
10404ef589dcSJérôme Glisse 				   IORESOURCE_SYSTEM_RAM,
10414ef589dcSJérôme Glisse 				   IORES_DESC_NONE);
10424ef589dcSJérôme Glisse 	if (is_ram == REGION_MIXED) {
10434ef589dcSJérôme Glisse 		WARN_ONCE(1, "%s attempted on mixed region %pr\n",
10444ef589dcSJérôme Glisse 				__func__, devmem->resource);
10454ef589dcSJérôme Glisse 		return -ENXIO;
10464ef589dcSJérôme Glisse 	}
10474ef589dcSJérôme Glisse 	if (is_ram == REGION_INTERSECTS)
10484ef589dcSJérôme Glisse 		return -ENXIO;
10494ef589dcSJérôme Glisse 
1050d3df0a42SJérôme Glisse 	if (devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY)
1051d3df0a42SJérôme Glisse 		devmem->pagemap.type = MEMORY_DEVICE_PUBLIC;
1052d3df0a42SJérôme Glisse 	else
10534ef589dcSJérôme Glisse 		devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
1054d3df0a42SJérôme Glisse 
1055e7744aa2SLogan Gunthorpe 	devmem->pagemap.res = *devmem->resource;
10564ef589dcSJérôme Glisse 	devmem->pagemap.page_fault = hmm_devmem_fault;
10574ef589dcSJérôme Glisse 	devmem->pagemap.page_free = hmm_devmem_free;
10584ef589dcSJérôme Glisse 	devmem->pagemap.dev = devmem->device;
10594ef589dcSJérôme Glisse 	devmem->pagemap.ref = &devmem->ref;
10604ef589dcSJérôme Glisse 	devmem->pagemap.data = devmem;
10614ef589dcSJérôme Glisse 
10624ef589dcSJérôme Glisse 	mutex_lock(&hmm_devmem_lock);
10634ef589dcSJérôme Glisse 	align_end = align_start + align_size - 1;
10644ef589dcSJérôme Glisse 	for (key = align_start; key <= align_end; key += PA_SECTION_SIZE) {
10654ef589dcSJérôme Glisse 		struct hmm_devmem *dup;
10664ef589dcSJérôme Glisse 
106718be460eSTejun Heo 		dup = radix_tree_lookup(&hmm_devmem_radix,
106818be460eSTejun Heo 					key >> PA_SECTION_SHIFT);
10694ef589dcSJérôme Glisse 		if (dup) {
10704ef589dcSJérôme Glisse 			dev_err(device, "%s: collides with mapping for %s\n",
10714ef589dcSJérôme Glisse 				__func__, dev_name(dup->device));
10724ef589dcSJérôme Glisse 			mutex_unlock(&hmm_devmem_lock);
10734ef589dcSJérôme Glisse 			ret = -EBUSY;
10744ef589dcSJérôme Glisse 			goto error;
10754ef589dcSJérôme Glisse 		}
10764ef589dcSJérôme Glisse 		ret = radix_tree_insert(&hmm_devmem_radix,
10774ef589dcSJérôme Glisse 					key >> PA_SECTION_SHIFT,
10784ef589dcSJérôme Glisse 					devmem);
10794ef589dcSJérôme Glisse 		if (ret) {
10804ef589dcSJérôme Glisse 			dev_err(device, "%s: failed: %d\n", __func__, ret);
10814ef589dcSJérôme Glisse 			mutex_unlock(&hmm_devmem_lock);
10824ef589dcSJérôme Glisse 			goto error_radix;
10834ef589dcSJérôme Glisse 		}
10844ef589dcSJérôme Glisse 	}
10854ef589dcSJérôme Glisse 	mutex_unlock(&hmm_devmem_lock);
10864ef589dcSJérôme Glisse 
10874ef589dcSJérôme Glisse 	nid = dev_to_node(device);
10884ef589dcSJérôme Glisse 	if (nid < 0)
10894ef589dcSJérôme Glisse 		nid = numa_mem_id();
10904ef589dcSJérôme Glisse 
10914ef589dcSJérôme Glisse 	mem_hotplug_begin();
10924ef589dcSJérôme Glisse 	/*
10934ef589dcSJérôme Glisse 	 * For device private memory we call add_pages() as we only need to
10944ef589dcSJérôme Glisse 	 * allocate and initialize struct page for the device memory. More-
10954ef589dcSJérôme Glisse 	 * over the device memory is un-accessible thus we do not want to
10964ef589dcSJérôme Glisse 	 * create a linear mapping for the memory like arch_add_memory()
10974ef589dcSJérôme Glisse 	 * would do.
1098d3df0a42SJérôme Glisse 	 *
1099d3df0a42SJérôme Glisse 	 * For device public memory, which is accesible by the CPU, we do
1100d3df0a42SJérôme Glisse 	 * want the linear mapping and thus use arch_add_memory().
11014ef589dcSJérôme Glisse 	 */
1102d3df0a42SJérôme Glisse 	if (devmem->pagemap.type == MEMORY_DEVICE_PUBLIC)
110324e6d5a5SChristoph Hellwig 		ret = arch_add_memory(nid, align_start, align_size, NULL,
110424e6d5a5SChristoph Hellwig 				false);
1105d3df0a42SJérôme Glisse 	else
11064ef589dcSJérôme Glisse 		ret = add_pages(nid, align_start >> PAGE_SHIFT,
110724e6d5a5SChristoph Hellwig 				align_size >> PAGE_SHIFT, NULL, false);
11084ef589dcSJérôme Glisse 	if (ret) {
11094ef589dcSJérôme Glisse 		mem_hotplug_done();
11104ef589dcSJérôme Glisse 		goto error_add_memory;
11114ef589dcSJérôme Glisse 	}
11124ef589dcSJérôme Glisse 	move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
11134ef589dcSJérôme Glisse 				align_start >> PAGE_SHIFT,
1114a99583e7SChristoph Hellwig 				align_size >> PAGE_SHIFT, NULL);
11154ef589dcSJérôme Glisse 	mem_hotplug_done();
11164ef589dcSJérôme Glisse 
1117966cf44fSAlexander Duyck 	/*
1118966cf44fSAlexander Duyck 	 * Initialization of the pages has been deferred until now in order
1119966cf44fSAlexander Duyck 	 * to allow us to do the work while not holding the hotplug lock.
1120966cf44fSAlexander Duyck 	 */
1121966cf44fSAlexander Duyck 	memmap_init_zone_device(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
1122966cf44fSAlexander Duyck 				align_start >> PAGE_SHIFT,
1123966cf44fSAlexander Duyck 				align_size >> PAGE_SHIFT, &devmem->pagemap);
11244ef589dcSJérôme Glisse 
11254ef589dcSJérôme Glisse 	return 0;
11264ef589dcSJérôme Glisse 
11274ef589dcSJérôme Glisse error_add_memory:
11284ef589dcSJérôme Glisse 	untrack_pfn(NULL, PHYS_PFN(align_start), align_size);
11294ef589dcSJérôme Glisse error_radix:
11304ef589dcSJérôme Glisse 	hmm_devmem_radix_release(devmem->resource);
11314ef589dcSJérôme Glisse error:
11324ef589dcSJérôme Glisse 	return ret;
11334ef589dcSJérôme Glisse }
11344ef589dcSJérôme Glisse 
11354ef589dcSJérôme Glisse static int hmm_devmem_match(struct device *dev, void *data, void *match_data)
11364ef589dcSJérôme Glisse {
11374ef589dcSJérôme Glisse 	struct hmm_devmem *devmem = data;
11384ef589dcSJérôme Glisse 
11394ef589dcSJérôme Glisse 	return devmem->resource == match_data;
11404ef589dcSJérôme Glisse }
11414ef589dcSJérôme Glisse 
11424ef589dcSJérôme Glisse static void hmm_devmem_pages_remove(struct hmm_devmem *devmem)
11434ef589dcSJérôme Glisse {
11444ef589dcSJérôme Glisse 	devres_release(devmem->device, &hmm_devmem_release,
11454ef589dcSJérôme Glisse 		       &hmm_devmem_match, devmem->resource);
11464ef589dcSJérôme Glisse }
11474ef589dcSJérôme Glisse 
11484ef589dcSJérôme Glisse /*
11494ef589dcSJérôme Glisse  * hmm_devmem_add() - hotplug ZONE_DEVICE memory for device memory
11504ef589dcSJérôme Glisse  *
11514ef589dcSJérôme Glisse  * @ops: memory event device driver callback (see struct hmm_devmem_ops)
11524ef589dcSJérôme Glisse  * @device: device struct to bind the resource too
11534ef589dcSJérôme Glisse  * @size: size in bytes of the device memory to add
11544ef589dcSJérôme Glisse  * Returns: pointer to new hmm_devmem struct ERR_PTR otherwise
11554ef589dcSJérôme Glisse  *
11564ef589dcSJérôme Glisse  * This function first finds an empty range of physical address big enough to
11574ef589dcSJérôme Glisse  * contain the new resource, and then hotplugs it as ZONE_DEVICE memory, which
11584ef589dcSJérôme Glisse  * in turn allocates struct pages. It does not do anything beyond that; all
11594ef589dcSJérôme Glisse  * events affecting the memory will go through the various callbacks provided
11604ef589dcSJérôme Glisse  * by hmm_devmem_ops struct.
11614ef589dcSJérôme Glisse  *
11624ef589dcSJérôme Glisse  * Device driver should call this function during device initialization and
11634ef589dcSJérôme Glisse  * is then responsible of memory management. HMM only provides helpers.
11644ef589dcSJérôme Glisse  */
11654ef589dcSJérôme Glisse struct hmm_devmem *hmm_devmem_add(const struct hmm_devmem_ops *ops,
11664ef589dcSJérôme Glisse 				  struct device *device,
11674ef589dcSJérôme Glisse 				  unsigned long size)
11684ef589dcSJérôme Glisse {
11694ef589dcSJérôme Glisse 	struct hmm_devmem *devmem;
11704ef589dcSJérôme Glisse 	resource_size_t addr;
11714ef589dcSJérôme Glisse 	int ret;
11724ef589dcSJérôme Glisse 
1173e7638488SDan Williams 	dev_pagemap_get_ops();
11744ef589dcSJérôme Glisse 
11754ef589dcSJérôme Glisse 	devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem),
11764ef589dcSJérôme Glisse 				   GFP_KERNEL, dev_to_node(device));
11774ef589dcSJérôme Glisse 	if (!devmem)
11784ef589dcSJérôme Glisse 		return ERR_PTR(-ENOMEM);
11794ef589dcSJérôme Glisse 
11804ef589dcSJérôme Glisse 	init_completion(&devmem->completion);
11814ef589dcSJérôme Glisse 	devmem->pfn_first = -1UL;
11824ef589dcSJérôme Glisse 	devmem->pfn_last = -1UL;
11834ef589dcSJérôme Glisse 	devmem->resource = NULL;
11844ef589dcSJérôme Glisse 	devmem->device = device;
11854ef589dcSJérôme Glisse 	devmem->ops = ops;
11864ef589dcSJérôme Glisse 
11874ef589dcSJérôme Glisse 	ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release,
11884ef589dcSJérôme Glisse 			      0, GFP_KERNEL);
11894ef589dcSJérôme Glisse 	if (ret)
11904ef589dcSJérôme Glisse 		goto error_percpu_ref;
11914ef589dcSJérôme Glisse 
11924ef589dcSJérôme Glisse 	ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref);
11934ef589dcSJérôme Glisse 	if (ret)
11944ef589dcSJérôme Glisse 		goto error_devm_add_action;
11954ef589dcSJérôme Glisse 
11964ef589dcSJérôme Glisse 	size = ALIGN(size, PA_SECTION_SIZE);
11974ef589dcSJérôme Glisse 	addr = min((unsigned long)iomem_resource.end,
11984ef589dcSJérôme Glisse 		   (1UL << MAX_PHYSMEM_BITS) - 1);
11994ef589dcSJérôme Glisse 	addr = addr - size + 1UL;
12004ef589dcSJérôme Glisse 
12014ef589dcSJérôme Glisse 	/*
12024ef589dcSJérôme Glisse 	 * FIXME add a new helper to quickly walk resource tree and find free
12034ef589dcSJérôme Glisse 	 * range
12044ef589dcSJérôme Glisse 	 *
12054ef589dcSJérôme Glisse 	 * FIXME what about ioport_resource resource ?
12064ef589dcSJérôme Glisse 	 */
12074ef589dcSJérôme Glisse 	for (; addr > size && addr >= iomem_resource.start; addr -= size) {
12084ef589dcSJérôme Glisse 		ret = region_intersects(addr, size, 0, IORES_DESC_NONE);
12094ef589dcSJérôme Glisse 		if (ret != REGION_DISJOINT)
12104ef589dcSJérôme Glisse 			continue;
12114ef589dcSJérôme Glisse 
12124ef589dcSJérôme Glisse 		devmem->resource = devm_request_mem_region(device, addr, size,
12134ef589dcSJérôme Glisse 							   dev_name(device));
12144ef589dcSJérôme Glisse 		if (!devmem->resource) {
12154ef589dcSJérôme Glisse 			ret = -ENOMEM;
12164ef589dcSJérôme Glisse 			goto error_no_resource;
12174ef589dcSJérôme Glisse 		}
12184ef589dcSJérôme Glisse 		break;
12194ef589dcSJérôme Glisse 	}
12204ef589dcSJérôme Glisse 	if (!devmem->resource) {
12214ef589dcSJérôme Glisse 		ret = -ERANGE;
12224ef589dcSJérôme Glisse 		goto error_no_resource;
12234ef589dcSJérôme Glisse 	}
12244ef589dcSJérôme Glisse 
12254ef589dcSJérôme Glisse 	devmem->resource->desc = IORES_DESC_DEVICE_PRIVATE_MEMORY;
12264ef589dcSJérôme Glisse 	devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT;
12274ef589dcSJérôme Glisse 	devmem->pfn_last = devmem->pfn_first +
12284ef589dcSJérôme Glisse 			   (resource_size(devmem->resource) >> PAGE_SHIFT);
12294ef589dcSJérôme Glisse 
12304ef589dcSJérôme Glisse 	ret = hmm_devmem_pages_create(devmem);
12314ef589dcSJérôme Glisse 	if (ret)
12324ef589dcSJérôme Glisse 		goto error_pages;
12334ef589dcSJérôme Glisse 
12344ef589dcSJérôme Glisse 	devres_add(device, devmem);
12354ef589dcSJérôme Glisse 
12364ef589dcSJérôme Glisse 	ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref);
12374ef589dcSJérôme Glisse 	if (ret) {
12384ef589dcSJérôme Glisse 		hmm_devmem_remove(devmem);
12394ef589dcSJérôme Glisse 		return ERR_PTR(ret);
12404ef589dcSJérôme Glisse 	}
12414ef589dcSJérôme Glisse 
12424ef589dcSJérôme Glisse 	return devmem;
12434ef589dcSJérôme Glisse 
12444ef589dcSJérôme Glisse error_pages:
12454ef589dcSJérôme Glisse 	devm_release_mem_region(device, devmem->resource->start,
12464ef589dcSJérôme Glisse 				resource_size(devmem->resource));
12474ef589dcSJérôme Glisse error_no_resource:
12484ef589dcSJérôme Glisse error_devm_add_action:
12494ef589dcSJérôme Glisse 	hmm_devmem_ref_kill(&devmem->ref);
12504ef589dcSJérôme Glisse 	hmm_devmem_ref_exit(&devmem->ref);
12514ef589dcSJérôme Glisse error_percpu_ref:
12524ef589dcSJérôme Glisse 	devres_free(devmem);
12534ef589dcSJérôme Glisse 	return ERR_PTR(ret);
12544ef589dcSJérôme Glisse }
12554ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add);
12564ef589dcSJérôme Glisse 
1257d3df0a42SJérôme Glisse struct hmm_devmem *hmm_devmem_add_resource(const struct hmm_devmem_ops *ops,
1258d3df0a42SJérôme Glisse 					   struct device *device,
1259d3df0a42SJérôme Glisse 					   struct resource *res)
1260d3df0a42SJérôme Glisse {
1261d3df0a42SJérôme Glisse 	struct hmm_devmem *devmem;
1262d3df0a42SJérôme Glisse 	int ret;
1263d3df0a42SJérôme Glisse 
1264d3df0a42SJérôme Glisse 	if (res->desc != IORES_DESC_DEVICE_PUBLIC_MEMORY)
1265d3df0a42SJérôme Glisse 		return ERR_PTR(-EINVAL);
1266d3df0a42SJérôme Glisse 
1267e7638488SDan Williams 	dev_pagemap_get_ops();
1268d3df0a42SJérôme Glisse 
1269d3df0a42SJérôme Glisse 	devmem = devres_alloc_node(&hmm_devmem_release, sizeof(*devmem),
1270d3df0a42SJérôme Glisse 				   GFP_KERNEL, dev_to_node(device));
1271d3df0a42SJérôme Glisse 	if (!devmem)
1272d3df0a42SJérôme Glisse 		return ERR_PTR(-ENOMEM);
1273d3df0a42SJérôme Glisse 
1274d3df0a42SJérôme Glisse 	init_completion(&devmem->completion);
1275d3df0a42SJérôme Glisse 	devmem->pfn_first = -1UL;
1276d3df0a42SJérôme Glisse 	devmem->pfn_last = -1UL;
1277d3df0a42SJérôme Glisse 	devmem->resource = res;
1278d3df0a42SJérôme Glisse 	devmem->device = device;
1279d3df0a42SJérôme Glisse 	devmem->ops = ops;
1280d3df0a42SJérôme Glisse 
1281d3df0a42SJérôme Glisse 	ret = percpu_ref_init(&devmem->ref, &hmm_devmem_ref_release,
1282d3df0a42SJérôme Glisse 			      0, GFP_KERNEL);
1283d3df0a42SJérôme Glisse 	if (ret)
1284d3df0a42SJérôme Glisse 		goto error_percpu_ref;
1285d3df0a42SJérôme Glisse 
1286d3df0a42SJérôme Glisse 	ret = devm_add_action(device, hmm_devmem_ref_exit, &devmem->ref);
1287d3df0a42SJérôme Glisse 	if (ret)
1288d3df0a42SJérôme Glisse 		goto error_devm_add_action;
1289d3df0a42SJérôme Glisse 
1290d3df0a42SJérôme Glisse 
1291d3df0a42SJérôme Glisse 	devmem->pfn_first = devmem->resource->start >> PAGE_SHIFT;
1292d3df0a42SJérôme Glisse 	devmem->pfn_last = devmem->pfn_first +
1293d3df0a42SJérôme Glisse 			   (resource_size(devmem->resource) >> PAGE_SHIFT);
1294d3df0a42SJérôme Glisse 
1295d3df0a42SJérôme Glisse 	ret = hmm_devmem_pages_create(devmem);
1296d3df0a42SJérôme Glisse 	if (ret)
1297d3df0a42SJérôme Glisse 		goto error_devm_add_action;
1298d3df0a42SJérôme Glisse 
1299d3df0a42SJérôme Glisse 	devres_add(device, devmem);
1300d3df0a42SJérôme Glisse 
1301d3df0a42SJérôme Glisse 	ret = devm_add_action(device, hmm_devmem_ref_kill, &devmem->ref);
1302d3df0a42SJérôme Glisse 	if (ret) {
1303d3df0a42SJérôme Glisse 		hmm_devmem_remove(devmem);
1304d3df0a42SJérôme Glisse 		return ERR_PTR(ret);
1305d3df0a42SJérôme Glisse 	}
1306d3df0a42SJérôme Glisse 
1307d3df0a42SJérôme Glisse 	return devmem;
1308d3df0a42SJérôme Glisse 
1309d3df0a42SJérôme Glisse error_devm_add_action:
1310d3df0a42SJérôme Glisse 	hmm_devmem_ref_kill(&devmem->ref);
1311d3df0a42SJérôme Glisse 	hmm_devmem_ref_exit(&devmem->ref);
1312d3df0a42SJérôme Glisse error_percpu_ref:
1313d3df0a42SJérôme Glisse 	devres_free(devmem);
1314d3df0a42SJérôme Glisse 	return ERR_PTR(ret);
1315d3df0a42SJérôme Glisse }
1316d3df0a42SJérôme Glisse EXPORT_SYMBOL(hmm_devmem_add_resource);
1317d3df0a42SJérôme Glisse 
13184ef589dcSJérôme Glisse /*
13194ef589dcSJérôme Glisse  * hmm_devmem_remove() - remove device memory (kill and free ZONE_DEVICE)
13204ef589dcSJérôme Glisse  *
13214ef589dcSJérôme Glisse  * @devmem: hmm_devmem struct use to track and manage the ZONE_DEVICE memory
13224ef589dcSJérôme Glisse  *
13234ef589dcSJérôme Glisse  * This will hot-unplug memory that was hotplugged by hmm_devmem_add on behalf
13244ef589dcSJérôme Glisse  * of the device driver. It will free struct page and remove the resource that
13254ef589dcSJérôme Glisse  * reserved the physical address range for this device memory.
13264ef589dcSJérôme Glisse  */
13274ef589dcSJérôme Glisse void hmm_devmem_remove(struct hmm_devmem *devmem)
13284ef589dcSJérôme Glisse {
13294ef589dcSJérôme Glisse 	resource_size_t start, size;
13304ef589dcSJérôme Glisse 	struct device *device;
1331d3df0a42SJérôme Glisse 	bool cdm = false;
13324ef589dcSJérôme Glisse 
13334ef589dcSJérôme Glisse 	if (!devmem)
13344ef589dcSJérôme Glisse 		return;
13354ef589dcSJérôme Glisse 
13364ef589dcSJérôme Glisse 	device = devmem->device;
13374ef589dcSJérôme Glisse 	start = devmem->resource->start;
13384ef589dcSJérôme Glisse 	size = resource_size(devmem->resource);
13394ef589dcSJérôme Glisse 
1340d3df0a42SJérôme Glisse 	cdm = devmem->resource->desc == IORES_DESC_DEVICE_PUBLIC_MEMORY;
13414ef589dcSJérôme Glisse 	hmm_devmem_ref_kill(&devmem->ref);
13424ef589dcSJérôme Glisse 	hmm_devmem_ref_exit(&devmem->ref);
13434ef589dcSJérôme Glisse 	hmm_devmem_pages_remove(devmem);
13444ef589dcSJérôme Glisse 
1345d3df0a42SJérôme Glisse 	if (!cdm)
13464ef589dcSJérôme Glisse 		devm_release_mem_region(device, start, size);
13474ef589dcSJérôme Glisse }
13484ef589dcSJérôme Glisse EXPORT_SYMBOL(hmm_devmem_remove);
1349858b54daSJérôme Glisse 
1350858b54daSJérôme Glisse /*
1351858b54daSJérôme Glisse  * A device driver that wants to handle multiple devices memory through a
1352858b54daSJérôme Glisse  * single fake device can use hmm_device to do so. This is purely a helper
1353858b54daSJérôme Glisse  * and it is not needed to make use of any HMM functionality.
1354858b54daSJérôme Glisse  */
1355858b54daSJérôme Glisse #define HMM_DEVICE_MAX 256
1356858b54daSJérôme Glisse 
1357858b54daSJérôme Glisse static DECLARE_BITMAP(hmm_device_mask, HMM_DEVICE_MAX);
1358858b54daSJérôme Glisse static DEFINE_SPINLOCK(hmm_device_lock);
1359858b54daSJérôme Glisse static struct class *hmm_device_class;
1360858b54daSJérôme Glisse static dev_t hmm_device_devt;
1361858b54daSJérôme Glisse 
1362858b54daSJérôme Glisse static void hmm_device_release(struct device *device)
1363858b54daSJérôme Glisse {
1364858b54daSJérôme Glisse 	struct hmm_device *hmm_device;
1365858b54daSJérôme Glisse 
1366858b54daSJérôme Glisse 	hmm_device = container_of(device, struct hmm_device, device);
1367858b54daSJérôme Glisse 	spin_lock(&hmm_device_lock);
1368858b54daSJérôme Glisse 	clear_bit(hmm_device->minor, hmm_device_mask);
1369858b54daSJérôme Glisse 	spin_unlock(&hmm_device_lock);
1370858b54daSJérôme Glisse 
1371858b54daSJérôme Glisse 	kfree(hmm_device);
1372858b54daSJérôme Glisse }
1373858b54daSJérôme Glisse 
1374858b54daSJérôme Glisse struct hmm_device *hmm_device_new(void *drvdata)
1375858b54daSJérôme Glisse {
1376858b54daSJérôme Glisse 	struct hmm_device *hmm_device;
1377858b54daSJérôme Glisse 
1378858b54daSJérôme Glisse 	hmm_device = kzalloc(sizeof(*hmm_device), GFP_KERNEL);
1379858b54daSJérôme Glisse 	if (!hmm_device)
1380858b54daSJérôme Glisse 		return ERR_PTR(-ENOMEM);
1381858b54daSJérôme Glisse 
1382858b54daSJérôme Glisse 	spin_lock(&hmm_device_lock);
1383858b54daSJérôme Glisse 	hmm_device->minor = find_first_zero_bit(hmm_device_mask, HMM_DEVICE_MAX);
1384858b54daSJérôme Glisse 	if (hmm_device->minor >= HMM_DEVICE_MAX) {
1385858b54daSJérôme Glisse 		spin_unlock(&hmm_device_lock);
1386858b54daSJérôme Glisse 		kfree(hmm_device);
1387858b54daSJérôme Glisse 		return ERR_PTR(-EBUSY);
1388858b54daSJérôme Glisse 	}
1389858b54daSJérôme Glisse 	set_bit(hmm_device->minor, hmm_device_mask);
1390858b54daSJérôme Glisse 	spin_unlock(&hmm_device_lock);
1391858b54daSJérôme Glisse 
1392858b54daSJérôme Glisse 	dev_set_name(&hmm_device->device, "hmm_device%d", hmm_device->minor);
1393858b54daSJérôme Glisse 	hmm_device->device.devt = MKDEV(MAJOR(hmm_device_devt),
1394858b54daSJérôme Glisse 					hmm_device->minor);
1395858b54daSJérôme Glisse 	hmm_device->device.release = hmm_device_release;
1396858b54daSJérôme Glisse 	dev_set_drvdata(&hmm_device->device, drvdata);
1397858b54daSJérôme Glisse 	hmm_device->device.class = hmm_device_class;
1398858b54daSJérôme Glisse 	device_initialize(&hmm_device->device);
1399858b54daSJérôme Glisse 
1400858b54daSJérôme Glisse 	return hmm_device;
1401858b54daSJérôme Glisse }
1402858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_new);
1403858b54daSJérôme Glisse 
1404858b54daSJérôme Glisse void hmm_device_put(struct hmm_device *hmm_device)
1405858b54daSJérôme Glisse {
1406858b54daSJérôme Glisse 	put_device(&hmm_device->device);
1407858b54daSJérôme Glisse }
1408858b54daSJérôme Glisse EXPORT_SYMBOL(hmm_device_put);
1409858b54daSJérôme Glisse 
1410858b54daSJérôme Glisse static int __init hmm_init(void)
1411858b54daSJérôme Glisse {
1412858b54daSJérôme Glisse 	int ret;
1413858b54daSJérôme Glisse 
1414858b54daSJérôme Glisse 	ret = alloc_chrdev_region(&hmm_device_devt, 0,
1415858b54daSJérôme Glisse 				  HMM_DEVICE_MAX,
1416858b54daSJérôme Glisse 				  "hmm_device");
1417858b54daSJérôme Glisse 	if (ret)
1418858b54daSJérôme Glisse 		return ret;
1419858b54daSJérôme Glisse 
1420858b54daSJérôme Glisse 	hmm_device_class = class_create(THIS_MODULE, "hmm_device");
1421858b54daSJérôme Glisse 	if (IS_ERR(hmm_device_class)) {
1422858b54daSJérôme Glisse 		unregister_chrdev_region(hmm_device_devt, HMM_DEVICE_MAX);
1423858b54daSJérôme Glisse 		return PTR_ERR(hmm_device_class);
1424858b54daSJérôme Glisse 	}
1425858b54daSJérôme Glisse 	return 0;
1426858b54daSJérôme Glisse }
1427858b54daSJérôme Glisse 
1428858b54daSJérôme Glisse device_initcall(hmm_init);
1429df6ad698SJérôme Glisse #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
1430