1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * It tests the mlock/mlock2() when they are invoked
  4 * on randomly memory region.
  5 */
  6#include <unistd.h>
  7#include <sys/resource.h>
  8#include <sys/capability.h>
  9#include <sys/mman.h>
 10#include <linux/mman.h>
 11#include <fcntl.h>
 12#include <string.h>
 13#include <sys/ipc.h>
 14#include <sys/shm.h>
 15#include <time.h>
 16#include "../kselftest.h"
 17#include "mlock2.h"
 18
 19#define CHUNK_UNIT (128 * 1024)
 20#define MLOCK_RLIMIT_SIZE (CHUNK_UNIT * 2)
 21#define MLOCK_WITHIN_LIMIT_SIZE CHUNK_UNIT
 22#define MLOCK_OUTOF_LIMIT_SIZE (CHUNK_UNIT * 3)
 23
 24#define TEST_LOOP 100
 25#define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))
 26
 27int set_cap_limits(rlim_t max)
 28{
 29	struct rlimit new;
 30	cap_t cap = cap_init();
 31
 32	new.rlim_cur = max;
 33	new.rlim_max = max;
 34	if (setrlimit(RLIMIT_MEMLOCK, &new)) {
 35		ksft_perror("setrlimit() returns error\n");
 36		return -1;
 37	}
 38
 39	/* drop capabilities including CAP_IPC_LOCK */
 40	if (cap_set_proc(cap)) {
 41		ksft_perror("cap_set_proc() returns error\n");
 42		return -1;
 43	}
 44
 45	return 0;
 46}
 47
 48int get_proc_locked_vm_size(void)
 49{
 50	FILE *f;
 51	int ret = -1;
 52	char line[1024] = {0};
 53	unsigned long lock_size = 0;
 54
 55	f = fopen("/proc/self/status", "r");
 56	if (!f)
 57		ksft_exit_fail_msg("fopen: %s\n", strerror(errno));
 58
 59	while (fgets(line, 1024, f)) {
 60		if (strstr(line, "VmLck")) {
 61			ret = sscanf(line, "VmLck:\t%8lu kB", &lock_size);
 62			if (ret <= 0) {
 63				fclose(f);
 64				ksft_exit_fail_msg("sscanf() on VmLck error: %s: %d\n",
 65						   line, ret);
 66			}
 67			fclose(f);
 68			return (int)(lock_size << 10);
 69		}
 70	}
 71
 72	fclose(f);
 73	ksft_exit_fail_msg("cannot parse VmLck in /proc/self/status: %s\n", strerror(errno));
 74	return -1;
 75}
 76
 77/*
 78 * Get the MMUPageSize of the memory region including input
 79 * address from proc file.
 80 *
 81 * return value: on error case, 0 will be returned.
 82 * Otherwise the page size(in bytes) is returned.
 83 */
 84int get_proc_page_size(unsigned long addr)
 85{
 86	FILE *smaps;
 87	char *line;
 88	unsigned long mmupage_size = 0;
 89	size_t size;
 90
 91	smaps = seek_to_smaps_entry(addr);
 92	if (!smaps)
 93		ksft_exit_fail_msg("Unable to parse /proc/self/smaps\n");
 94
 95	while (getline(&line, &size, smaps) > 0) {
 96		if (!strstr(line, "MMUPageSize")) {
 97			free(line);
 98			line = NULL;
 99			size = 0;
100			continue;
101		}
102
103		/* found the MMUPageSize of this section */
104		if (sscanf(line, "MMUPageSize:    %8lu kB", &mmupage_size) < 1)
105			ksft_exit_fail_msg("Unable to parse smaps entry for Size:%s\n",
106					   line);
107
108	}
109	free(line);
110	if (smaps)
111		fclose(smaps);
112	return mmupage_size << 10;
113}
114
115/*
116 * Test mlock/mlock2() on provided memory chunk.
117 * It expects the mlock/mlock2() to be successful (within rlimit)
118 *
119 * With allocated memory chunk [p, p + alloc_size), this
120 * test will choose start/len randomly to perform mlock/mlock2
121 * [start, start +  len] memory range. The range is within range
122 * of the allocated chunk.
123 *
124 * The memory region size alloc_size is within the rlimit.
125 * So we always expect a success of mlock/mlock2.
126 *
127 * VmLck is assumed to be 0 before this test.
128 *
129 *    return value: 0 - success
130 *    else: failure
131 */
132static void test_mlock_within_limit(char *p, int alloc_size)
133{
134	int i;
135	int ret = 0;
136	int locked_vm_size = 0;
137	struct rlimit cur;
138	int page_size = 0;
139
140	getrlimit(RLIMIT_MEMLOCK, &cur);
141	if (cur.rlim_cur < alloc_size)
142		ksft_exit_fail_msg("alloc_size[%d] < %u rlimit,lead to mlock failure\n",
143				   alloc_size, (unsigned int)cur.rlim_cur);
144
145	srand(time(NULL));
146	for (i = 0; i < TEST_LOOP; i++) {
147		/*
148		 * - choose mlock/mlock2 randomly
149		 * - choose lock_size randomly but lock_size < alloc_size
150		 * - choose start_offset randomly but p+start_offset+lock_size
151		 *   < p+alloc_size
152		 */
153		int is_mlock = !!(rand() % 2);
154		int lock_size = rand() % alloc_size;
155		int start_offset = rand() % (alloc_size - lock_size);
156
157		if (is_mlock)
158			ret = mlock(p + start_offset, lock_size);
159		else
160			ret = mlock2_(p + start_offset, lock_size,
161				       MLOCK_ONFAULT);
162
163		if (ret)
164			ksft_exit_fail_msg("%s() failure at |%p(%d)| mlock:|%p(%d)|\n",
165					   is_mlock ? "mlock" : "mlock2",
166					   p, alloc_size,
167					   p + start_offset, lock_size);
168	}
169
170	/*
171	 * Check VmLck left by the tests.
172	 */
173	locked_vm_size = get_proc_locked_vm_size();
174	page_size = get_proc_page_size((unsigned long)p);
175
176	if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size)
177		ksft_exit_fail_msg("%s left VmLck:%d on %d chunk\n",
178				   __func__, locked_vm_size, alloc_size);
179
180	ksft_test_result_pass("%s\n", __func__);
181}
182
183
184/*
185 * We expect the mlock/mlock2() to be fail (outof limitation)
186 *
187 * With allocated memory chunk [p, p + alloc_size), this
188 * test will randomly choose start/len and perform mlock/mlock2
189 * on [start, start+len] range.
190 *
191 * The memory region size alloc_size is above the rlimit.
192 * And the len to be locked is higher than rlimit.
193 * So we always expect a failure of mlock/mlock2.
194 * No locked page number should be increased as a side effect.
195 *
196 *    return value: 0 - success
197 *    else: failure
198 */
199static void test_mlock_outof_limit(char *p, int alloc_size)
200{
201	int i;
202	int ret = 0;
203	int locked_vm_size = 0, old_locked_vm_size = 0;
204	struct rlimit cur;
205
206	getrlimit(RLIMIT_MEMLOCK, &cur);
207	if (cur.rlim_cur >= alloc_size)
208		ksft_exit_fail_msg("alloc_size[%d] >%u rlimit, violates test condition\n",
209				   alloc_size, (unsigned int)cur.rlim_cur);
210
211	old_locked_vm_size = get_proc_locked_vm_size();
212	srand(time(NULL));
213	for (i = 0; i < TEST_LOOP; i++) {
214		int is_mlock = !!(rand() % 2);
215		int lock_size = (rand() % (alloc_size - cur.rlim_cur))
216			+ cur.rlim_cur;
217		int start_offset = rand() % (alloc_size - lock_size);
218
219		if (is_mlock)
220			ret = mlock(p + start_offset, lock_size);
221		else
222			ret = mlock2_(p + start_offset, lock_size,
223					MLOCK_ONFAULT);
224		if (ret == 0)
225			ksft_exit_fail_msg("%s() succeeds? on %p(%d) mlock%p(%d)\n",
226					   is_mlock ? "mlock" : "mlock2",
227					   p, alloc_size, p + start_offset, lock_size);
228	}
229
230	locked_vm_size = get_proc_locked_vm_size();
231	if (locked_vm_size != old_locked_vm_size)
232		ksft_exit_fail_msg("tests leads to new mlocked page: old[%d], new[%d]\n",
233				   old_locked_vm_size,
234				   locked_vm_size);
235
236	ksft_test_result_pass("%s\n", __func__);
237}
238
239int main(int argc, char **argv)
240{
241	char *p = NULL;
242
243	ksft_print_header();
244
245	if (set_cap_limits(MLOCK_RLIMIT_SIZE))
246		ksft_finished();
247
248	ksft_set_plan(2);
249
250	p = malloc(MLOCK_WITHIN_LIMIT_SIZE);
251	if (p == NULL)
252		ksft_exit_fail_msg("malloc() failure: %s\n", strerror(errno));
253
254	test_mlock_within_limit(p, MLOCK_WITHIN_LIMIT_SIZE);
255	munlock(p, MLOCK_WITHIN_LIMIT_SIZE);
256	free(p);
257
258	p = malloc(MLOCK_OUTOF_LIMIT_SIZE);
259	if (p == NULL)
260		ksft_exit_fail_msg("malloc() failure: %s\n", strerror(errno));
261
262	test_mlock_outof_limit(p, MLOCK_OUTOF_LIMIT_SIZE);
263	munlock(p, MLOCK_OUTOF_LIMIT_SIZE);
264	free(p);
265
266	ksft_finished();
267}