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
 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 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 */
 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 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
 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}