strace: Remove the ability to write to Qstrace
[akaros.git] / kern / drivers / net / udrvr / umem.c
1 /*
2  * Copyright (c) 2005 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Cisco Systems.  All rights reserved.
4  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  */
34
35 #if 0   /* AKAROS */
36 #include <linux/mm.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/sched.h>
39 #include <linux/export.h>
40 #include <linux/hugetlb.h>
41 #include <linux/dma-attrs.h>
42 #include <linux/slab.h>
43 #include <rdma/ib_umem_odp.h>
44 #endif  /* AKAROS */
45
46 #include "uverbs.h"
47
48
49 #if 1   /* AKAROS */
50 #define DEFINE_DMA_ATTRS(x)     struct dma_attrs x
51 #define dma_set_attr(a, b)      do {} while(0)
52 #define can_do_mlock()          1
53 #define get_task_pid(p, t)      NULL
54 #define put_pid(p)              do {} while(0)
55 #define ib_umem_odp_get(c, u)   ({ BUG(); -1; })
56 #endif  /* AKAROS */
57
58 static void __ib_umem_release(struct ib_device *dev, struct ib_umem *umem, int dirty)
59 {
60         struct scatterlist *sg;
61         struct page *page;
62         int i;
63
64         if (umem->nmap > 0)
65                 ib_dma_unmap_sg(dev, umem->sg_head.sgl,
66                                 umem->nmap,
67                                 DMA_BIDIRECTIONAL);
68
69         for_each_sg(umem->sg_head.sgl, sg, umem->npages, i) {
70
71                 page = sg_page(sg);
72                 if (umem->writable && dirty)
73                         set_page_dirty_lock(page);
74                 put_page(page);
75         }
76
77         sg_free_table(&umem->sg_head);
78         return;
79
80 }
81
82 /**
83  * ib_umem_get - Pin and DMA map userspace memory.
84  *
85  * If access flags indicate ODP memory, avoid pinning. Instead, stores
86  * the mm for future page fault handling in conjunction with MMU notifiers.
87  *
88  * @context: userspace context to pin memory for
89  * @addr: userspace virtual address to start at
90  * @size: length of region to pin
91  * @access: IB_ACCESS_xxx flags for memory being pinned
92  * @dmasync: flush in-flight DMA when the memory region is written
93  */
94 struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
95                             size_t size, int access, int dmasync)
96 {
97         struct ib_umem *umem;
98         struct page **page_list;
99         struct vm_area_struct **vma_list;
100         unsigned long locked;
101         unsigned long lock_limit;
102         unsigned long cur_base;
103         unsigned long npages;
104         int ret;
105         int i;
106         DEFINE_DMA_ATTRS(attrs);
107         struct scatterlist *sg, *sg_list_start;
108         int need_release = 0;
109
110         if (dmasync)
111                 dma_set_attr(DMA_ATTR_WRITE_BARRIER, &attrs);
112
113         if (!size)
114                 return ERR_PTR(-EINVAL);
115
116         /*
117          * If the combination of the addr and size requested for this memory
118          * region causes an integer overflow, return error.
119          */
120         if (((addr + size) < addr) ||
121             PAGE_ALIGN(addr + size) < (addr + size))
122                 return ERR_PTR(-EINVAL);
123
124         if (!can_do_mlock())
125                 return ERR_PTR(-EPERM);
126
127         umem = kzalloc(sizeof *umem, GFP_KERNEL);
128         if (!umem)
129                 return ERR_PTR(-ENOMEM);
130
131         umem->context   = context;
132         umem->length    = size;
133         umem->address   = addr;
134         umem->page_size = PAGE_SIZE;
135         umem->pid       = get_task_pid(current, PIDTYPE_PID);
136         /*
137          * We ask for writable memory if any of the following
138          * access flags are set.  "Local write" and "remote write"
139          * obviously require write access.  "Remote atomic" can do
140          * things like fetch and add, which will modify memory, and
141          * "MW bind" can change permissions by binding a window.
142          */
143         umem->writable  = !!(access &
144                 (IB_ACCESS_LOCAL_WRITE   | IB_ACCESS_REMOTE_WRITE |
145                  IB_ACCESS_REMOTE_ATOMIC | IB_ACCESS_MW_BIND));
146
147         if (access & IB_ACCESS_ON_DEMAND) {
148                 ret = ib_umem_odp_get(context, umem);
149                 if (ret) {
150                         kfree(umem);
151                         return ERR_PTR(ret);
152                 }
153                 return umem;
154         }
155
156         umem->odp_data = NULL;
157
158 #if 0   /* AKAROS */
159         /* We assume the memory is from hugetlb until proved otherwise */
160         umem->hugetlb   = 1;
161
162         page_list = (struct page **) __get_free_page(GFP_KERNEL);
163         if (!page_list) {
164                 kfree(umem);
165                 return ERR_PTR(-ENOMEM);
166         }
167
168         /*
169          * if we can't alloc the vma_list, it's not so bad;
170          * just assume the memory is not hugetlb memory
171          */
172         vma_list = (struct vm_area_struct **) __get_free_page(GFP_KERNEL);
173         if (!vma_list)
174                 umem->hugetlb = 0;
175
176         npages = ib_umem_num_pages(umem);
177
178         down_write(&current->mm->mmap_sem);
179
180         locked     = npages + current->mm->pinned_vm;
181         lock_limit = rlimit(RLIMIT_MEMLOCK) >> PAGE_SHIFT;
182
183         if ((locked > lock_limit) && !capable(CAP_IPC_LOCK)) {
184                 ret = -ENOMEM;
185                 goto out;
186         }
187 #else   /* AKAROS */
188         struct page *pptr;
189         npages = ib_umem_num_pages(umem);
190         vma_list = NULL;
191         page_list = &pptr;
192 #endif  /* AKAROS */
193
194         cur_base = addr & PAGE_MASK;
195
196         if (npages == 0) {
197                 ret = -EINVAL;
198                 goto out;
199         }
200
201         ret = sg_alloc_table(&umem->sg_head, npages, GFP_KERNEL);
202         if (ret)
203                 goto out;
204
205         need_release = 1;
206         sg_list_start = umem->sg_head.sgl;
207
208         while (npages) {
209                 ret = get_user_pages(current, current->mm, cur_base,
210                                      min_t(unsigned long, npages,
211                                            PAGE_SIZE / sizeof (struct page *)),
212                                      1, !umem->writable, page_list, vma_list);
213
214                 if (ret < 0)
215                         goto out;
216
217                 umem->npages += ret;
218                 cur_base += ret * PAGE_SIZE;
219                 npages   -= ret;
220
221                 for_each_sg(sg_list_start, sg, ret, i) {
222                         if (vma_list && !is_vm_hugetlb_page(vma_list[i]))
223                                 umem->hugetlb = 0;
224
225                         sg_set_page(sg, page_list[i], PAGE_SIZE, 0);
226                 }
227
228                 /* preparing for next loop */
229                 sg_list_start = sg;
230         }
231
232         umem->nmap = ib_dma_map_sg_attrs(context->device,
233                                   umem->sg_head.sgl,
234                                   umem->npages,
235                                   DMA_BIDIRECTIONAL,
236                                   &attrs);
237
238         if (umem->nmap <= 0) {
239                 ret = -ENOMEM;
240                 goto out;
241         }
242
243         ret = 0;
244
245 out:
246         if (ret < 0) {
247                 if (need_release)
248                         __ib_umem_release(context->device, umem, 0);
249                 put_pid(umem->pid);
250                 kfree(umem);
251 #if 1   /* AKAROS */
252         }
253 #else   /* AKAROS */
254         } else
255                 current->mm->pinned_vm = locked;
256
257         up_write(&current->mm->mmap_sem);
258         if (vma_list)
259                 free_page((unsigned long) vma_list);
260         free_page((unsigned long) page_list);
261 #endif  /* AKAROS */
262
263         return ret < 0 ? ERR_PTR(ret) : umem;
264 }
265 EXPORT_SYMBOL(ib_umem_get);
266
267 #if 0   /* AKAROS */
268 static void ib_umem_account(struct work_struct *work)
269 {
270         struct ib_umem *umem = container_of(work, struct ib_umem, work);
271
272         down_write(&umem->mm->mmap_sem);
273         umem->mm->pinned_vm -= umem->diff;
274         up_write(&umem->mm->mmap_sem);
275         mmput(umem->mm);
276         kfree(umem);
277 }
278
279 /**
280  * ib_umem_release - release memory pinned with ib_umem_get
281  * @umem: umem struct to release
282  */
283 void ib_umem_release(struct ib_umem *umem)
284 {
285         struct ib_ucontext *context = umem->context;
286         struct mm_struct *mm;
287         struct task_struct *task;
288         unsigned long diff;
289
290         if (umem->odp_data) {
291                 ib_umem_odp_release(umem);
292                 return;
293         }
294
295         __ib_umem_release(umem->context->device, umem, 1);
296
297         task = get_pid_task(umem->pid, PIDTYPE_PID);
298         put_pid(umem->pid);
299         if (!task)
300                 goto out;
301         mm = get_task_mm(task);
302         put_task_struct(task);
303         if (!mm)
304                 goto out;
305
306         diff = ib_umem_num_pages(umem);
307
308         /*
309          * We may be called with the mm's mmap_sem already held.  This
310          * can happen when a userspace munmap() is the call that drops
311          * the last reference to our file and calls our release
312          * method.  If there are memory regions to destroy, we'll end
313          * up here and not be able to take the mmap_sem.  In that case
314          * we defer the vm_locked accounting to the system workqueue.
315          */
316         if (context->closing) {
317                 if (!down_write_trylock(&mm->mmap_sem)) {
318                         INIT_WORK(&umem->work, ib_umem_account);
319                         umem->mm   = mm;
320                         umem->diff = diff;
321
322                         queue_work(ib_wq, &umem->work);
323                         return;
324                 }
325         } else
326                 down_write(&mm->mmap_sem);
327
328         mm->pinned_vm -= diff;
329         up_write(&mm->mmap_sem);
330         mmput(mm);
331 out:
332         kfree(umem);
333 }
334 EXPORT_SYMBOL(ib_umem_release);
335 #else   /* AKAROS */
336 void ib_umem_release(struct ib_umem *umem)
337 {
338         __ib_umem_release(umem->context->device, umem, 1);
339         kfree(umem);
340 }
341 #endif  /* AKAROS */
342
343 int ib_umem_page_count(struct ib_umem *umem)
344 {
345         int shift;
346         int i;
347         int n;
348         struct scatterlist *sg;
349
350         if (umem->odp_data)
351                 return ib_umem_num_pages(umem);
352
353         shift = ilog2(umem->page_size);
354
355         n = 0;
356         for_each_sg(umem->sg_head.sgl, sg, umem->nmap, i)
357                 n += sg_dma_len(sg) >> shift;
358
359         return n;
360 }
361 EXPORT_SYMBOL(ib_umem_page_count);
362
363 #if 0   /* AKAROS */
364 /*
365  * Copy from the given ib_umem's pages to the given buffer.
366  *
367  * umem - the umem to copy from
368  * offset - offset to start copying from
369  * dst - destination buffer
370  * length - buffer length
371  *
372  * Returns 0 on success, or an error code.
373  */
374 int ib_umem_copy_from(void *dst, struct ib_umem *umem, size_t offset,
375                       size_t length)
376 {
377         size_t end = offset + length;
378         int ret;
379
380         if (offset > umem->length || length > umem->length - offset) {
381                 pr_err("ib_umem_copy_from not in range. offset: %zd umem length: %zd end: %zd\n",
382                        offset, umem->length, end);
383                 return -EINVAL;
384         }
385
386         ret = sg_pcopy_to_buffer(umem->sg_head.sgl, umem->nmap, dst, length,
387                                  offset + ib_umem_offset(umem));
388
389         if (ret < 0)
390                 return ret;
391         else if (ret != length)
392                 return -EINVAL;
393         else
394                 return 0;
395 }
396 EXPORT_SYMBOL(ib_umem_copy_from);
397 #endif  /* AKAROS */