104 lines · c
1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause2/*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 13static unsigned long cache_size = 256;14module_param(cache_size, ulong, S_IRUGO | S_IWUSR);15MODULE_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 attempting22 * to pin buffer pages in order to determine whether they should do so.23 * The function computes cache limits based on the configured ulimit and24 * cache size. Use of this function is especially important for caches25 * which are not limited in any other way (e.g. by HW resources) and, thus,26 * could keeping caching buffers.27 *28 */29bool 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 memory45 * 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 HFI52 * caches. This fraction is then equally distributed among all53 * existing user contexts. Note that if RLIMIT_MEMLOCK is54 * 'unlimited' (-1), the value of this limit will be > 2^42 pages55 * (2^64 / 2^12 / 2^8 / 2^2).56 *57 * The effectiveness of this check may be reduced if I/O occurs on58 * some user contexts before all user contexts are created. This59 * check assumes that this process is the only one using this60 * context (e.g., the corresponding fd was not passed to another61 * process for concurrent access) as there is no per-context,62 * per-process tracking of pinned pages. It also assumes that each63 * 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 80int 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 95void 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