~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/mm/mmu_context_iommu.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  IOMMU helpers in MMU context.
  3  *
  4  *  Copyright (C) 2015 IBM Corp. <aik@ozlabs.ru>
  5  *
  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.
 10  *
 11  */
 12 
 13 #include <linux/sched.h>
 14 #include <linux/slab.h>
 15 #include <linux/rculist.h>
 16 #include <linux/vmalloc.h>
 17 #include <linux/mutex.h>
 18 #include <asm/mmu_context.h>
 19 
 20 static DEFINE_MUTEX(mem_list_mutex);
 21 
 22 struct mm_iommu_table_group_mem_t {
 23         struct list_head next;
 24         struct rcu_head rcu;
 25         unsigned long used;
 26         atomic64_t mapped;
 27         u64 ua;                 /* userspace address */
 28         u64 entries;            /* number of entries in hpas[] */
 29         u64 *hpas;              /* vmalloc'ed */
 30 };
 31 
 32 static long mm_iommu_adjust_locked_vm(struct mm_struct *mm,
 33                 unsigned long npages, bool incr)
 34 {
 35         long ret = 0, locked, lock_limit;
 36 
 37         if (!npages)
 38                 return 0;
 39 
 40         down_write(&mm->mmap_sem);
 41 
 42         if (incr) {
 43                 locked = mm->locked_vm + npages;
 44                 lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
 45                 if (locked > lock_limit && !capable(CAP_IPC_LOCK))
 46                         ret = -ENOMEM;
 47                 else
 48                         mm->locked_vm += npages;
 49         } else {
 50                 if (WARN_ON_ONCE(npages > mm->locked_vm))
 51                         npages = mm->locked_vm;
 52                 mm->locked_vm -= npages;
 53         }
 54 
 55         pr_debug("[%d] RLIMIT_MEMLOCK HASH64 %c%ld %ld/%ld\n",
 56                         current->pid,
 57                         incr ? '+' : '-',
 58                         npages << PAGE_SHIFT,
 59                         mm->locked_vm << PAGE_SHIFT,
 60                         rlimit(RLIMIT_MEMLOCK));
 61         up_write(&mm->mmap_sem);
 62 
 63         return ret;
 64 }
 65 
 66 bool mm_iommu_preregistered(void)
 67 {
 68         if (!current || !current->mm)
 69                 return false;
 70 
 71         return !list_empty(&current->mm->context.iommu_group_mem_list);
 72 }
 73 EXPORT_SYMBOL_GPL(mm_iommu_preregistered);
 74 
 75 long mm_iommu_get(unsigned long ua, unsigned long entries,
 76                 struct mm_iommu_table_group_mem_t **pmem)
 77 {
 78         struct mm_iommu_table_group_mem_t *mem;
 79         long i, j, ret = 0, locked_entries = 0;
 80         struct page *page = NULL;
 81 
 82         if (!current || !current->mm)
 83                 return -ESRCH; /* process exited */
 84 
 85         mutex_lock(&mem_list_mutex);
 86 
 87         list_for_each_entry_rcu(mem, &current->mm->context.iommu_group_mem_list,
 88                         next) {
 89                 if ((mem->ua == ua) && (mem->entries == entries)) {
 90                         ++mem->used;
 91                         *pmem = mem;
 92                         goto unlock_exit;
 93                 }
 94 
 95                 /* Overlap? */
 96                 if ((mem->ua < (ua + (entries << PAGE_SHIFT))) &&
 97                                 (ua < (mem->ua +
 98                                        (mem->entries << PAGE_SHIFT)))) {
 99                         ret = -EINVAL;
100                         goto unlock_exit;
101                 }
102 
103         }
104 
105         ret = mm_iommu_adjust_locked_vm(current->mm, entries, true);
106         if (ret)
107                 goto unlock_exit;
108 
109         locked_entries = entries;
110 
111         mem = kzalloc(sizeof(*mem), GFP_KERNEL);
112         if (!mem) {
113                 ret = -ENOMEM;
114                 goto unlock_exit;
115         }
116 
117         mem->hpas = vzalloc(entries * sizeof(mem->hpas[0]));
118         if (!mem->hpas) {
119                 kfree(mem);
120                 ret = -ENOMEM;
121                 goto unlock_exit;
122         }
123 
124         for (i = 0; i < entries; ++i) {
125                 if (1 != get_user_pages_fast(ua + (i << PAGE_SHIFT),
126                                         1/* pages */, 1/* iswrite */, &page)) {
127                         for (j = 0; j < i; ++j)
128                                 put_page(pfn_to_page(
129                                                 mem->hpas[j] >> PAGE_SHIFT));
130                         vfree(mem->hpas);
131                         kfree(mem);
132                         ret = -EFAULT;
133                         goto unlock_exit;
134                 }
135 
136                 mem->hpas[i] = page_to_pfn(page) << PAGE_SHIFT;
137         }
138 
139         atomic64_set(&mem->mapped, 1);
140         mem->used = 1;
141         mem->ua = ua;
142         mem->entries = entries;
143         *pmem = mem;
144 
145         list_add_rcu(&mem->next, &current->mm->context.iommu_group_mem_list);
146 
147 unlock_exit:
148         if (locked_entries && ret)
149                 mm_iommu_adjust_locked_vm(current->mm, locked_entries, false);
150 
151         mutex_unlock(&mem_list_mutex);
152 
153         return ret;
154 }
155 EXPORT_SYMBOL_GPL(mm_iommu_get);
156 
157 static void mm_iommu_unpin(struct mm_iommu_table_group_mem_t *mem)
158 {
159         long i;
160         struct page *page = NULL;
161 
162         for (i = 0; i < mem->entries; ++i) {
163                 if (!mem->hpas[i])
164                         continue;
165 
166                 page = pfn_to_page(mem->hpas[i] >> PAGE_SHIFT);
167                 if (!page)
168                         continue;
169 
170                 put_page(page);
171                 mem->hpas[i] = 0;
172         }
173 }
174 
175 static void mm_iommu_do_free(struct mm_iommu_table_group_mem_t *mem)
176 {
177 
178         mm_iommu_unpin(mem);
179         vfree(mem->hpas);
180         kfree(mem);
181 }
182 
183 static void mm_iommu_free(struct rcu_head *head)
184 {
185         struct mm_iommu_table_group_mem_t *mem = container_of(head,
186                         struct mm_iommu_table_group_mem_t, rcu);
187 
188         mm_iommu_do_free(mem);
189 }
190 
191 static void mm_iommu_release(struct mm_iommu_table_group_mem_t *mem)
192 {
193         list_del_rcu(&mem->next);
194         mm_iommu_adjust_locked_vm(current->mm, mem->entries, false);
195         call_rcu(&mem->rcu, mm_iommu_free);
196 }
197 
198 long mm_iommu_put(struct mm_iommu_table_group_mem_t *mem)
199 {
200         long ret = 0;
201 
202         if (!current || !current->mm)
203                 return -ESRCH; /* process exited */
204 
205         mutex_lock(&mem_list_mutex);
206 
207         if (mem->used == 0) {
208                 ret = -ENOENT;
209                 goto unlock_exit;
210         }
211 
212         --mem->used;
213         /* There are still users, exit */
214         if (mem->used)
215                 goto unlock_exit;
216 
217         /* Are there still mappings? */
218         if (atomic_cmpxchg(&mem->mapped, 1, 0) != 1) {
219                 ++mem->used;
220                 ret = -EBUSY;
221                 goto unlock_exit;
222         }
223 
224         /* @mapped became 0 so now mappings are disabled, release the region */
225         mm_iommu_release(mem);
226 
227 unlock_exit:
228         mutex_unlock(&mem_list_mutex);
229 
230         return ret;
231 }
232 EXPORT_SYMBOL_GPL(mm_iommu_put);
233 
234 struct mm_iommu_table_group_mem_t *mm_iommu_lookup(unsigned long ua,
235                 unsigned long size)
236 {
237         struct mm_iommu_table_group_mem_t *mem, *ret = NULL;
238 
239         list_for_each_entry_rcu(mem,
240                         &current->mm->context.iommu_group_mem_list,
241                         next) {
242                 if ((mem->ua <= ua) &&
243                                 (ua + size <= mem->ua +
244                                  (mem->entries << PAGE_SHIFT))) {
245                         ret = mem;
246                         break;
247                 }
248         }
249 
250         return ret;
251 }
252 EXPORT_SYMBOL_GPL(mm_iommu_lookup);
253 
254 struct mm_iommu_table_group_mem_t *mm_iommu_find(unsigned long ua,
255                 unsigned long entries)
256 {
257         struct mm_iommu_table_group_mem_t *mem, *ret = NULL;
258 
259         list_for_each_entry_rcu(mem,
260                         &current->mm->context.iommu_group_mem_list,
261                         next) {
262                 if ((mem->ua == ua) && (mem->entries == entries)) {
263                         ret = mem;
264                         break;
265                 }
266         }
267 
268         return ret;
269 }
270 EXPORT_SYMBOL_GPL(mm_iommu_find);
271 
272 long mm_iommu_ua_to_hpa(struct mm_iommu_table_group_mem_t *mem,
273                 unsigned long ua, unsigned long *hpa)
274 {
275         const long entry = (ua - mem->ua) >> PAGE_SHIFT;
276         u64 *va = &mem->hpas[entry];
277 
278         if (entry >= mem->entries)
279                 return -EFAULT;
280 
281         *hpa = *va | (ua & ~PAGE_MASK);
282 
283         return 0;
284 }
285 EXPORT_SYMBOL_GPL(mm_iommu_ua_to_hpa);
286 
287 long mm_iommu_mapped_inc(struct mm_iommu_table_group_mem_t *mem)
288 {
289         if (atomic64_inc_not_zero(&mem->mapped))
290                 return 0;
291 
292         /* Last mm_iommu_put() has been called, no more mappings allowed() */
293         return -ENXIO;
294 }
295 EXPORT_SYMBOL_GPL(mm_iommu_mapped_inc);
296 
297 void mm_iommu_mapped_dec(struct mm_iommu_table_group_mem_t *mem)
298 {
299         atomic64_add_unless(&mem->mapped, -1, 1);
300 }
301 EXPORT_SYMBOL_GPL(mm_iommu_mapped_dec);
302 
303 void mm_iommu_init(mm_context_t *ctx)
304 {
305         INIT_LIST_HEAD_RCU(&ctx->iommu_group_mem_list);
306 }
307 
308 void mm_iommu_cleanup(mm_context_t *ctx)
309 {
310         struct mm_iommu_table_group_mem_t *mem, *tmp;
311 
312         list_for_each_entry_safe(mem, tmp, &ctx->iommu_group_mem_list, next) {
313                 list_del_rcu(&mem->next);
314                 mm_iommu_do_free(mem);
315         }
316 }
317 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp