2 * IOMMU helpers in MMU context.
4 * Copyright (C) 2015 IBM Corp. <aik@ozlabs.ru>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
13 #include <linux/sched/signal.h>
14 #include <linux/slab.h>
15 #include <linux/rculist.h>
16 #include <linux/vmalloc.h>
17 #include <linux/mutex.h>
18 #include <linux/migrate.h>
19 #include <linux/hugetlb.h>
20 #include <linux/swap.h>
21 #include <asm/mmu_context.h>
22 #include <asm/pte-walk.h>
24 static DEFINE_MUTEX(mem_list_mutex);
26 struct mm_iommu_table_group_mem_t {
27 struct list_head next;
31 unsigned int pageshift;
32 u64 ua; /* userspace address */
33 u64 entries; /* number of entries in hpas[] */
34 u64 *hpas; /* vmalloc'ed */
37 static long mm_iommu_adjust_locked_vm(struct mm_struct *mm,
38 unsigned long npages, bool incr)
40 long ret = 0, locked, lock_limit;
45 down_write(&mm->mmap_sem);
48 locked = mm->locked_vm + npages;
49 lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
50 if (locked > lock_limit && !capable(CAP_IPC_LOCK))
53 mm->locked_vm += npages;
55 if (WARN_ON_ONCE(npages > mm->locked_vm))
56 npages = mm->locked_vm;
57 mm->locked_vm -= npages;
60 pr_debug("[%d] RLIMIT_MEMLOCK HASH64 %c%ld %ld/%ld\n",
61 current ? current->pid : 0,
64 mm->locked_vm << PAGE_SHIFT,
65 rlimit(RLIMIT_MEMLOCK));
66 up_write(&mm->mmap_sem);
71 bool mm_iommu_preregistered(struct mm_struct *mm)
73 return !list_empty(&mm->context.iommu_group_mem_list);
75 EXPORT_SYMBOL_GPL(mm_iommu_preregistered);
78 * Taken from alloc_migrate_target with changes to remove CMA allocations
80 struct page *new_iommu_non_cma_page(struct page *page, unsigned long private,
83 gfp_t gfp_mask = GFP_USER;
84 struct page *new_page;
86 if (PageCompound(page))
89 if (PageHighMem(page))
90 gfp_mask |= __GFP_HIGHMEM;
93 * We don't want the allocation to force an OOM if possibe
95 new_page = alloc_page(gfp_mask | __GFP_NORETRY | __GFP_NOWARN);
99 static int mm_iommu_move_page_from_cma(struct page *page)
102 LIST_HEAD(cma_migrate_pages);
104 /* Ignore huge pages for now */
105 if (PageCompound(page))
109 ret = isolate_lru_page(page);
113 list_add(&page->lru, &cma_migrate_pages);
114 put_page(page); /* Drop the gup reference */
116 ret = migrate_pages(&cma_migrate_pages, new_iommu_non_cma_page,
117 NULL, 0, MIGRATE_SYNC, MR_CMA);
119 if (!list_empty(&cma_migrate_pages))
120 putback_movable_pages(&cma_migrate_pages);
126 long mm_iommu_get(struct mm_struct *mm, unsigned long ua, unsigned long entries,
127 struct mm_iommu_table_group_mem_t **pmem)
129 struct mm_iommu_table_group_mem_t *mem;
130 long i, j, ret = 0, locked_entries = 0;
131 unsigned int pageshift;
133 unsigned long cur_ua;
134 struct page *page = NULL;
136 mutex_lock(&mem_list_mutex);
138 list_for_each_entry_rcu(mem, &mm->context.iommu_group_mem_list,
140 if ((mem->ua == ua) && (mem->entries == entries)) {
147 if ((mem->ua < (ua + (entries << PAGE_SHIFT))) &&
149 (mem->entries << PAGE_SHIFT)))) {
156 ret = mm_iommu_adjust_locked_vm(mm, entries, true);
160 locked_entries = entries;
162 mem = kzalloc(sizeof(*mem), GFP_KERNEL);
169 * For a starting point for a maximum page size calculation
170 * we use @ua and @entries natural alignment to allow IOMMU pages
171 * smaller than huge pages but still bigger than PAGE_SIZE.
173 mem->pageshift = __ffs(ua | (entries << PAGE_SHIFT));
174 mem->hpas = vzalloc(entries * sizeof(mem->hpas[0]));
181 for (i = 0; i < entries; ++i) {
182 cur_ua = ua + (i << PAGE_SHIFT);
183 if (1 != get_user_pages_fast(cur_ua,
184 1/* pages */, 1/* iswrite */, &page)) {
186 for (j = 0; j < i; ++j)
187 put_page(pfn_to_page(mem->hpas[j] >>
194 * If we get a page from the CMA zone, since we are going to
195 * be pinning these entries, we might as well move them out
196 * of the CMA zone if possible. NOTE: faulting in + migration
197 * can be expensive. Batching can be considered later
199 if (is_migrate_cma_page(page)) {
200 if (mm_iommu_move_page_from_cma(page))
202 if (1 != get_user_pages_fast(cur_ua,
203 1/* pages */, 1/* iswrite */,
206 for (j = 0; j < i; ++j)
207 put_page(pfn_to_page(mem->hpas[j] >>
215 pageshift = PAGE_SHIFT;
216 if (mem->pageshift > PAGE_SHIFT && PageCompound(page)) {
218 struct page *head = compound_head(page);
219 unsigned int compshift = compound_order(head);
220 unsigned int pteshift;
222 local_irq_save(flags); /* disables as well */
223 pte = find_linux_pte(mm->pgd, cur_ua, NULL, &pteshift);
225 /* Double check it is still the same pinned page */
226 if (pte && pte_page(*pte) == head &&
227 pteshift == compshift + PAGE_SHIFT)
228 pageshift = max_t(unsigned int, pteshift,
230 local_irq_restore(flags);
232 mem->pageshift = min(mem->pageshift, pageshift);
233 mem->hpas[i] = page_to_pfn(page) << PAGE_SHIFT;
236 atomic64_set(&mem->mapped, 1);
239 mem->entries = entries;
242 list_add_rcu(&mem->next, &mm->context.iommu_group_mem_list);
245 if (locked_entries && ret)
246 mm_iommu_adjust_locked_vm(mm, locked_entries, false);
248 mutex_unlock(&mem_list_mutex);
252 EXPORT_SYMBOL_GPL(mm_iommu_get);
254 static void mm_iommu_unpin(struct mm_iommu_table_group_mem_t *mem)
257 struct page *page = NULL;
259 for (i = 0; i < mem->entries; ++i) {
263 page = pfn_to_page(mem->hpas[i] >> PAGE_SHIFT);
272 static void mm_iommu_do_free(struct mm_iommu_table_group_mem_t *mem)
280 static void mm_iommu_free(struct rcu_head *head)
282 struct mm_iommu_table_group_mem_t *mem = container_of(head,
283 struct mm_iommu_table_group_mem_t, rcu);
285 mm_iommu_do_free(mem);
288 static void mm_iommu_release(struct mm_iommu_table_group_mem_t *mem)
290 list_del_rcu(&mem->next);
291 call_rcu(&mem->rcu, mm_iommu_free);
294 long mm_iommu_put(struct mm_struct *mm, struct mm_iommu_table_group_mem_t *mem)
298 mutex_lock(&mem_list_mutex);
300 if (mem->used == 0) {
306 /* There are still users, exit */
310 /* Are there still mappings? */
311 if (atomic_cmpxchg(&mem->mapped, 1, 0) != 1) {
317 /* @mapped became 0 so now mappings are disabled, release the region */
318 mm_iommu_release(mem);
320 mm_iommu_adjust_locked_vm(mm, mem->entries, false);
323 mutex_unlock(&mem_list_mutex);
327 EXPORT_SYMBOL_GPL(mm_iommu_put);
329 struct mm_iommu_table_group_mem_t *mm_iommu_lookup(struct mm_struct *mm,
330 unsigned long ua, unsigned long size)
332 struct mm_iommu_table_group_mem_t *mem, *ret = NULL;
334 list_for_each_entry_rcu(mem, &mm->context.iommu_group_mem_list, next) {
335 if ((mem->ua <= ua) &&
336 (ua + size <= mem->ua +
337 (mem->entries << PAGE_SHIFT))) {
345 EXPORT_SYMBOL_GPL(mm_iommu_lookup);
347 struct mm_iommu_table_group_mem_t *mm_iommu_lookup_rm(struct mm_struct *mm,
348 unsigned long ua, unsigned long size)
350 struct mm_iommu_table_group_mem_t *mem, *ret = NULL;
352 list_for_each_entry_lockless(mem, &mm->context.iommu_group_mem_list,
354 if ((mem->ua <= ua) &&
355 (ua + size <= mem->ua +
356 (mem->entries << PAGE_SHIFT))) {
364 EXPORT_SYMBOL_GPL(mm_iommu_lookup_rm);
366 struct mm_iommu_table_group_mem_t *mm_iommu_find(struct mm_struct *mm,
367 unsigned long ua, unsigned long entries)
369 struct mm_iommu_table_group_mem_t *mem, *ret = NULL;
371 list_for_each_entry_rcu(mem, &mm->context.iommu_group_mem_list, next) {
372 if ((mem->ua == ua) && (mem->entries == entries)) {
380 EXPORT_SYMBOL_GPL(mm_iommu_find);
382 long mm_iommu_ua_to_hpa(struct mm_iommu_table_group_mem_t *mem,
383 unsigned long ua, unsigned int pageshift, unsigned long *hpa)
385 const long entry = (ua - mem->ua) >> PAGE_SHIFT;
386 u64 *va = &mem->hpas[entry];
388 if (entry >= mem->entries)
391 if (pageshift > mem->pageshift)
394 *hpa = *va | (ua & ~PAGE_MASK);
398 EXPORT_SYMBOL_GPL(mm_iommu_ua_to_hpa);
400 long mm_iommu_ua_to_hpa_rm(struct mm_iommu_table_group_mem_t *mem,
401 unsigned long ua, unsigned int pageshift, unsigned long *hpa)
403 const long entry = (ua - mem->ua) >> PAGE_SHIFT;
404 void *va = &mem->hpas[entry];
407 if (entry >= mem->entries)
410 if (pageshift > mem->pageshift)
413 pa = (void *) vmalloc_to_phys(va);
417 *hpa = *pa | (ua & ~PAGE_MASK);
421 EXPORT_SYMBOL_GPL(mm_iommu_ua_to_hpa_rm);
423 long mm_iommu_mapped_inc(struct mm_iommu_table_group_mem_t *mem)
425 if (atomic64_inc_not_zero(&mem->mapped))
428 /* Last mm_iommu_put() has been called, no more mappings allowed() */
431 EXPORT_SYMBOL_GPL(mm_iommu_mapped_inc);
433 void mm_iommu_mapped_dec(struct mm_iommu_table_group_mem_t *mem)
435 atomic64_add_unless(&mem->mapped, -1, 1);
437 EXPORT_SYMBOL_GPL(mm_iommu_mapped_dec);
439 void mm_iommu_init(struct mm_struct *mm)
441 INIT_LIST_HEAD_RCU(&mm->context.iommu_group_mem_list);