1 /* 2 * Copyright(c) 2015, 2016 Intel Corporation. 3 * 4 * This file is provided under a dual BSD/GPLv2 license. When using or 5 * redistributing this file, you may do so under either license. 6 * 7 * GPL LICENSE SUMMARY 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * BSD LICENSE 19 * 20 * Redistribution and use in source and binary forms, with or without 21 * modification, are permitted provided that the following conditions 22 * are met: 23 * 24 * - Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * - Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in 28 * the documentation and/or other materials provided with the 29 * distribution. 30 * - Neither the name of Intel Corporation nor the names of its 31 * contributors may be used to endorse or promote products derived 32 * from this software without specific prior written permission. 33 * 34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 45 * 46 */ 47 48 #include <linux/mm.h> 49 #include <linux/sched.h> 50 #include <linux/device.h> 51 #include <linux/module.h> 52 53 #include "hfi.h" 54 55 static unsigned long cache_size = 256; 56 module_param(cache_size, ulong, S_IRUGO | S_IWUSR); 57 MODULE_PARM_DESC(cache_size, "Send and receive side cache size limit (in MB)"); 58 59 /* 60 * Determine whether the caller can pin pages. 61 * 62 * This function should be used in the implementation of buffer caches. 63 * The cache implementation should call this function prior to attempting 64 * to pin buffer pages in order to determine whether they should do so. 65 * The function computes cache limits based on the configured ulimit and 66 * cache size. Use of this function is especially important for caches 67 * which are not limited in any other way (e.g. by HW resources) and, thus, 68 * could keeping caching buffers. 69 * 70 */ 71 bool hfi1_can_pin_pages(struct hfi1_devdata *dd, u32 nlocked, u32 npages) 72 { 73 unsigned long ulimit = rlimit(RLIMIT_MEMLOCK), pinned, cache_limit, 74 size = (cache_size * (1UL << 20)); /* convert to bytes */ 75 unsigned usr_ctxts = dd->num_rcv_contexts - dd->first_user_ctxt; 76 bool can_lock = capable(CAP_IPC_LOCK); 77 78 /* 79 * Calculate per-cache size. The calculation below uses only a quarter 80 * of the available per-context limit. This leaves space for other 81 * pinning. Should we worry about shared ctxts? 82 */ 83 cache_limit = (ulimit / usr_ctxts) / 4; 84 85 /* If ulimit isn't set to "unlimited" and is smaller than cache_size. */ 86 if (ulimit != (-1UL) && size > cache_limit) 87 size = cache_limit; 88 89 /* Convert to number of pages */ 90 size = DIV_ROUND_UP(size, PAGE_SIZE); 91 92 down_read(¤t->mm->mmap_sem); 93 pinned = current->mm->pinned_vm; 94 up_read(¤t->mm->mmap_sem); 95 96 /* First, check the absolute limit against all pinned pages. */ 97 if (pinned + npages >= ulimit && !can_lock) 98 return false; 99 100 return ((nlocked + npages) <= size) || can_lock; 101 } 102 103 int hfi1_acquire_user_pages(unsigned long vaddr, size_t npages, bool writable, 104 struct page **pages) 105 { 106 int ret; 107 108 ret = get_user_pages_fast(vaddr, npages, writable, pages); 109 if (ret < 0) 110 return ret; 111 112 down_write(¤t->mm->mmap_sem); 113 current->mm->pinned_vm += ret; 114 up_write(¤t->mm->mmap_sem); 115 116 return ret; 117 } 118 119 void hfi1_release_user_pages(struct mm_struct *mm, struct page **p, 120 size_t npages, bool dirty) 121 { 122 size_t i; 123 124 for (i = 0; i < npages; i++) { 125 if (dirty) 126 set_page_dirty_lock(p[i]); 127 put_page(p[i]); 128 } 129 130 if (mm) { /* during close after signal, mm can be NULL */ 131 down_write(&mm->mmap_sem); 132 mm->pinned_vm -= npages; 133 up_write(&mm->mmap_sem); 134 } 135 } 136