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