1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* 3 * Copyright(c) 2015-2017 Intel Corporation. 4 */ 5 6 #include <linux/mm.h> 7 #include <linux/sched/signal.h> 8 #include <linux/device.h> 9 #include <linux/module.h> 10 11 #include "hfi.h" 12 13 static unsigned long cache_size = 256; 14 module_param(cache_size, ulong, S_IRUGO | S_IWUSR); 15 MODULE_PARM_DESC(cache_size, "Send and receive side cache size limit (in MB)"); 16 17 /* 18 * Determine whether the caller can pin pages. 19 * 20 * This function should be used in the implementation of buffer caches. 21 * The cache implementation should call this function prior to attempting 22 * to pin buffer pages in order to determine whether they should do so. 23 * The function computes cache limits based on the configured ulimit and 24 * cache size. Use of this function is especially important for caches 25 * which are not limited in any other way (e.g. by HW resources) and, thus, 26 * could keeping caching buffers. 27 * 28 */ 29 bool hfi1_can_pin_pages(struct hfi1_devdata *dd, struct mm_struct *mm, 30 u32 nlocked, u32 npages) 31 { 32 unsigned long ulimit_pages; 33 unsigned long cache_limit_pages; 34 unsigned int usr_ctxts; 35 36 /* 37 * Perform RLIMIT_MEMLOCK based checks unless CAP_IPC_LOCK is present. 38 */ 39 if (!capable(CAP_IPC_LOCK)) { 40 ulimit_pages = 41 DIV_ROUND_DOWN_ULL(rlimit(RLIMIT_MEMLOCK), PAGE_SIZE); 42 43 /* 44 * Pinning these pages would exceed this process's locked memory 45 * limit. 46 */ 47 if (atomic64_read(&mm->pinned_vm) + npages > ulimit_pages) 48 return false; 49 50 /* 51 * Only allow 1/4 of the user's RLIMIT_MEMLOCK to be used for HFI 52 * caches. This fraction is then equally distributed among all 53 * existing user contexts. Note that if RLIMIT_MEMLOCK is 54 * 'unlimited' (-1), the value of this limit will be > 2^42 pages 55 * (2^64 / 2^12 / 2^8 / 2^2). 56 * 57 * The effectiveness of this check may be reduced if I/O occurs on 58 * some user contexts before all user contexts are created. This 59 * check assumes that this process is the only one using this 60 * context (e.g., the corresponding fd was not passed to another 61 * process for concurrent access) as there is no per-context, 62 * per-process tracking of pinned pages. It also assumes that each 63 * user context has only one cache to limit. 64 */ 65 usr_ctxts = dd->num_rcv_contexts - dd->first_dyn_alloc_ctxt; 66 if (nlocked + npages > (ulimit_pages / usr_ctxts / 4)) 67 return false; 68 } 69 70 /* 71 * Pinning these pages would exceed the size limit for this cache. 72 */ 73 cache_limit_pages = cache_size * (1024 * 1024) / PAGE_SIZE; 74 if (nlocked + npages > cache_limit_pages) 75 return false; 76 77 return true; 78 } 79 80 int hfi1_acquire_user_pages(struct mm_struct *mm, unsigned long vaddr, size_t npages, 81 bool writable, struct page **pages) 82 { 83 int ret; 84 unsigned int gup_flags = FOLL_LONGTERM | (writable ? FOLL_WRITE : 0); 85 86 ret = pin_user_pages_fast(vaddr, npages, gup_flags, pages); 87 if (ret < 0) 88 return ret; 89 90 atomic64_add(ret, &mm->pinned_vm); 91 92 return ret; 93 } 94 95 void hfi1_release_user_pages(struct mm_struct *mm, struct page **p, 96 size_t npages, bool dirty) 97 { 98 unpin_user_pages_dirty_lock(p, npages, dirty); 99 100 if (mm) { /* during close after signal, mm can be NULL */ 101 atomic64_sub(npages, &mm->pinned_vm); 102 } 103 } 104