tools/testing/selftests/vm/mlock-random-test.c - arm/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0
 /*
  * It tests the mlock/mlock2() when they are invoked
  * on randomly memory region.
  */
 #include <unistd.h>
 #include <sys/resource.h>
 #include <sys/capability.h>
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <string.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <time.h>
 #include "mlock2.h"

 #define CHUNK_UNIT (128 * 1024)
 #define MLOCK_RLIMIT_SIZE (CHUNK_UNIT * 2)
 #define MLOCK_WITHIN_LIMIT_SIZE CHUNK_UNIT
 #define MLOCK_OUTOF_LIMIT_SIZE (CHUNK_UNIT * 3)

 #define TEST_LOOP 100
 #define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))

 int set_cap_limits(rlim_t max)
 {
 	struct rlimit new;
 	cap_t cap = cap_init();

 	new.rlim_cur = max;
 	new.rlim_max = max;
 	if (setrlimit(RLIMIT_MEMLOCK, &new)) {
 		perror("setrlimit() returns error\n");
 		return -1;
 	}

 	/* drop capabilities including CAP_IPC_LOCK */
 	if (cap_set_proc(cap)) {
 		perror("cap_set_proc() returns error\n");
 		return -2;
 	}

 	return 0;
 }

 int get_proc_locked_vm_size(void)
 {
 	FILE *f;
 	int ret = -1;
 	char line[1024] = {0};
 	unsigned long lock_size = 0;

 	f = fopen("/proc/self/status", "r");
 	if (!f) {
 		perror("fopen");
 		return -1;
 	}

 	while (fgets(line, 1024, f)) {
 		if (strstr(line, "VmLck")) {
 			ret = sscanf(line, "VmLck:\t%8lu kB", &lock_size);
 			if (ret <= 0) {
 				printf("sscanf() on VmLck error: %s: %d\n",
 						line, ret);
 				fclose(f);
 				return -1;
 			}
 			fclose(f);
 			return (int)(lock_size << 10);
 		}
 	}

 	perror("cann't parse VmLck in /proc/self/status\n");
 	fclose(f);
 	return -1;
 }

 /*
  * Get the MMUPageSize of the memory region including input
  * address from proc file.
  *
  * return value: on error case, 0 will be returned.
  * Otherwise the page size(in bytes) is returned.
  */
 int get_proc_page_size(unsigned long addr)
 {
 	FILE *smaps;
 	char *line;
 	unsigned long mmupage_size = 0;
 	size_t size;

 	smaps = seek_to_smaps_entry(addr);
 	if (!smaps) {
 		printf("Unable to parse /proc/self/smaps\n");
 		return 0;
 	}

 	while (getline(&line, &size, smaps) > 0) {
 		if (!strstr(line, "MMUPageSize")) {
 			free(line);
 			line = NULL;
 			size = 0;
 			continue;
 		}

 		/* found the MMUPageSize of this section */
 		if (sscanf(line, "MMUPageSize:    %8lu kB",
 					&mmupage_size) < 1) {
 			printf("Unable to parse smaps entry for Size:%s\n",
 					line);
 			break;
 		}

 	}
 	free(line);
 	if (smaps)
 		fclose(smaps);
 	return mmupage_size << 10;
 }

 /*
  * Test mlock/mlock2() on provided memory chunk.
  * It expects the mlock/mlock2() to be successful (within rlimit)
  *
  * With allocated memory chunk [p, p + alloc_size), this
  * test will choose start/len randomly to perform mlock/mlock2
  * [start, start +  len] memory range. The range is within range
  * of the allocated chunk.
  *
  * The memory region size alloc_size is within the rlimit.
  * So we always expect a success of mlock/mlock2.
  *
  * VmLck is assumed to be 0 before this test.
  *
  *    return value: 0 - success
  *    else: failure
  */
 int test_mlock_within_limit(char *p, int alloc_size)
 {
 	int i;
 	int ret = 0;
 	int locked_vm_size = 0;
 	struct rlimit cur;
 	int page_size = 0;

 	getrlimit(RLIMIT_MEMLOCK, &cur);
 	if (cur.rlim_cur < alloc_size) {
 		printf("alloc_size[%d] < %u rlimit,lead to mlock failure\n",
 				alloc_size, (unsigned int)cur.rlim_cur);
 		return -1;
 	}

 	srand(time(NULL));
 	for (i = 0; i < TEST_LOOP; i++) {
 		/*
 		 * - choose mlock/mlock2 randomly
 		 * - choose lock_size randomly but lock_size < alloc_size
 		 * - choose start_offset randomly but p+start_offset+lock_size
 		 *   < p+alloc_size
 		 */
 		int is_mlock = !!(rand() % 2);
 		int lock_size = rand() % alloc_size;
 		int start_offset = rand() % (alloc_size - lock_size);

 		if (is_mlock)
 			ret = mlock(p + start_offset, lock_size);
 		else
 			ret = mlock2_(p + start_offset, lock_size,
 				       MLOCK_ONFAULT);

 		if (ret) {
 			printf("%s() failure at |%p(%d)| mlock:|%p(%d)|\n",
 					is_mlock ? "mlock" : "mlock2",
 					p, alloc_size,
 					p + start_offset, lock_size);
 			return ret;
 		}
 	}

 	/*
 	 * Check VmLck left by the tests.
 	 */
 	locked_vm_size = get_proc_locked_vm_size();
 	page_size = get_proc_page_size((unsigned long)p);
 	if (page_size == 0) {
 		printf("cannot get proc MMUPageSize\n");
 		return -1;
 	}

 	if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size) {
 		printf("test_mlock_within_limit() left VmLck:%d on %d chunk\n",
 				locked_vm_size, alloc_size);
 		return -1;
 	}

 	return 0;
 }


 /*
  * We expect the mlock/mlock2() to be fail (outof limitation)
  *
  * With allocated memory chunk [p, p + alloc_size), this
  * test will randomly choose start/len and perform mlock/mlock2
  * on [start, start+len] range.
  *
  * The memory region size alloc_size is above the rlimit.
  * And the len to be locked is higher than rlimit.
  * So we always expect a failure of mlock/mlock2.
  * No locked page number should be increased as a side effect.
  *
  *    return value: 0 - success
  *    else: failure
  */
 int test_mlock_outof_limit(char *p, int alloc_size)
 {
 	int i;
 	int ret = 0;
 	int locked_vm_size = 0, old_locked_vm_size = 0;
 	struct rlimit cur;

 	getrlimit(RLIMIT_MEMLOCK, &cur);
 	if (cur.rlim_cur >= alloc_size) {
 		printf("alloc_size[%d] >%u rlimit, violates test condition\n",
 				alloc_size, (unsigned int)cur.rlim_cur);
 		return -1;
 	}

 	old_locked_vm_size = get_proc_locked_vm_size();
 	srand(time(NULL));
 	for (i = 0; i < TEST_LOOP; i++) {
 		int is_mlock = !!(rand() % 2);
 		int lock_size = (rand() % (alloc_size - cur.rlim_cur))
 			+ cur.rlim_cur;
 		int start_offset = rand() % (alloc_size - lock_size);

 		if (is_mlock)
 			ret = mlock(p + start_offset, lock_size);
 		else
 			ret = mlock2_(p + start_offset, lock_size,
 					MLOCK_ONFAULT);
 		if (ret == 0) {
 			printf("%s() succeeds? on %p(%d) mlock%p(%d)\n",
 					is_mlock ? "mlock" : "mlock2",
 					p, alloc_size,
 					p + start_offset, lock_size);
 			return -1;
 		}
 	}

 	locked_vm_size = get_proc_locked_vm_size();
 	if (locked_vm_size != old_locked_vm_size) {
 		printf("tests leads to new mlocked page: old[%d], new[%d]\n",
 				old_locked_vm_size,
 				locked_vm_size);
 		return -1;
 	}

 	return 0;
 }

 int main(int argc, char **argv)
 {
 	char *p = NULL;
 	int ret = 0;

 	if (set_cap_limits(MLOCK_RLIMIT_SIZE))
 		return -1;

 	p = malloc(MLOCK_WITHIN_LIMIT_SIZE);
 	if (p == NULL) {
 		perror("malloc() failure\n");
 		return -1;
 	}
 	ret = test_mlock_within_limit(p, MLOCK_WITHIN_LIMIT_SIZE);
 	if (ret)
 		return ret;
 	munlock(p, MLOCK_WITHIN_LIMIT_SIZE);
 	free(p);


 	p = malloc(MLOCK_OUTOF_LIMIT_SIZE);
 	if (p == NULL) {
 		perror("malloc() failure\n");
 		return -1;
 	}
 	ret = test_mlock_outof_limit(p, MLOCK_OUTOF_LIMIT_SIZE);
 	if (ret)
 		return ret;
 	munlock(p, MLOCK_OUTOF_LIMIT_SIZE);
 	free(p);

 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0
	/*
	* It tests the mlock/mlock2() when they are invoked
	* on randomly memory region.
	*/
	#include <unistd.h>
	#include <sys/resource.h>
	#include <sys/capability.h>
	#include <sys/mman.h>
	#include <fcntl.h>
	#include <string.h>
	#include <sys/ipc.h>
	#include <sys/shm.h>
	#include <time.h>
	#include "mlock2.h"

	#define CHUNK_UNIT (128 * 1024)
	#define MLOCK_RLIMIT_SIZE (CHUNK_UNIT * 2)
	#define MLOCK_WITHIN_LIMIT_SIZE CHUNK_UNIT
	#define MLOCK_OUTOF_LIMIT_SIZE (CHUNK_UNIT * 3)

	#define TEST_LOOP 100
	#define PAGE_ALIGN(size, ps) (((size) + ((ps) - 1)) & ~((ps) - 1))

	int set_cap_limits(rlim_t max)
	{
	struct rlimit new;
	cap_t cap = cap_init();

	new.rlim_cur = max;
	new.rlim_max = max;
	if (setrlimit(RLIMIT_MEMLOCK, &new)) {
	perror("setrlimit() returns error\n");
	return -1;
	}

	/* drop capabilities including CAP_IPC_LOCK */
	if (cap_set_proc(cap)) {
	perror("cap_set_proc() returns error\n");
	return -2;
	}

	return 0;
	}

	int get_proc_locked_vm_size(void)
	{
	FILE *f;
	int ret = -1;
	char line[1024] = {0};
	unsigned long lock_size = 0;

	f = fopen("/proc/self/status", "r");
	if (!f) {
	perror("fopen");
	return -1;
	}

	while (fgets(line, 1024, f)) {
	if (strstr(line, "VmLck")) {
	ret = sscanf(line, "VmLck:\t%8lu kB", &lock_size);
	if (ret <= 0) {
	printf("sscanf() on VmLck error: %s: %d\n",
	line, ret);
	fclose(f);
	return -1;
	}
	fclose(f);
	return (int)(lock_size << 10);
	}
	}

	perror("cann't parse VmLck in /proc/self/status\n");
	fclose(f);
	return -1;
	}

	/*
	* Get the MMUPageSize of the memory region including input
	* address from proc file.
	*
	* return value: on error case, 0 will be returned.
	* Otherwise the page size(in bytes) is returned.
	*/
	int get_proc_page_size(unsigned long addr)
	{
	FILE *smaps;
	char *line;
	unsigned long mmupage_size = 0;
	size_t size;

	smaps = seek_to_smaps_entry(addr);
	if (!smaps) {
	printf("Unable to parse /proc/self/smaps\n");
	return 0;
	}

	while (getline(&line, &size, smaps) > 0) {
	if (!strstr(line, "MMUPageSize")) {
	free(line);
	line = NULL;
	size = 0;
	continue;
	}

	/* found the MMUPageSize of this section */
	if (sscanf(line, "MMUPageSize: %8lu kB",
	&mmupage_size) < 1) {
	printf("Unable to parse smaps entry for Size:%s\n",
	line);
	break;
	}

	}
	free(line);
	if (smaps)
	fclose(smaps);
	return mmupage_size << 10;
	}

	/*
	* Test mlock/mlock2() on provided memory chunk.
	* It expects the mlock/mlock2() to be successful (within rlimit)
	*
	* With allocated memory chunk [p, p + alloc_size), this
	* test will choose start/len randomly to perform mlock/mlock2
	* [start, start + len] memory range. The range is within range
	* of the allocated chunk.
	*
	* The memory region size alloc_size is within the rlimit.
	* So we always expect a success of mlock/mlock2.
	*
	* VmLck is assumed to be 0 before this test.
	*
	* return value: 0 - success
	* else: failure
	*/
	int test_mlock_within_limit(char *p, int alloc_size)
	{
	int i;
	int ret = 0;
	int locked_vm_size = 0;
	struct rlimit cur;
	int page_size = 0;

	getrlimit(RLIMIT_MEMLOCK, &cur);
	if (cur.rlim_cur < alloc_size) {
	printf("alloc_size[%d] < %u rlimit,lead to mlock failure\n",
	alloc_size, (unsigned int)cur.rlim_cur);
	return -1;
	}

	srand(time(NULL));
	for (i = 0; i < TEST_LOOP; i++) {
	/*
	* - choose mlock/mlock2 randomly
	* - choose lock_size randomly but lock_size < alloc_size
	* - choose start_offset randomly but p+start_offset+lock_size
	* < p+alloc_size
	*/
	int is_mlock = !!(rand() % 2);
	int lock_size = rand() % alloc_size;
	int start_offset = rand() % (alloc_size - lock_size);

	if (is_mlock)
	ret = mlock(p + start_offset, lock_size);
	else
	ret = mlock2_(p + start_offset, lock_size,
	MLOCK_ONFAULT);

	if (ret) {
	printf("%s() failure at \|%p(%d)\| mlock:\|%p(%d)\|\n",
	is_mlock ? "mlock" : "mlock2",
	p, alloc_size,
	p + start_offset, lock_size);
	return ret;
	}
	}

	/*
	* Check VmLck left by the tests.
	*/
	locked_vm_size = get_proc_locked_vm_size();
	page_size = get_proc_page_size((unsigned long)p);
	if (page_size == 0) {
	printf("cannot get proc MMUPageSize\n");
	return -1;
	}

	if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size) {
	printf("test_mlock_within_limit() left VmLck:%d on %d chunk\n",
	locked_vm_size, alloc_size);
	return -1;
	}

	return 0;
	}


	/*
	* We expect the mlock/mlock2() to be fail (outof limitation)
	*
	* With allocated memory chunk [p, p + alloc_size), this
	* test will randomly choose start/len and perform mlock/mlock2
	* on [start, start+len] range.
	*
	* The memory region size alloc_size is above the rlimit.
	* And the len to be locked is higher than rlimit.
	* So we always expect a failure of mlock/mlock2.
	* No locked page number should be increased as a side effect.
	*
	* return value: 0 - success
	* else: failure
	*/
	int test_mlock_outof_limit(char *p, int alloc_size)
	{
	int i;
	int ret = 0;
	int locked_vm_size = 0, old_locked_vm_size = 0;
	struct rlimit cur;

	getrlimit(RLIMIT_MEMLOCK, &cur);
	if (cur.rlim_cur >= alloc_size) {
	printf("alloc_size[%d] >%u rlimit, violates test condition\n",
	alloc_size, (unsigned int)cur.rlim_cur);
	return -1;
	}

	old_locked_vm_size = get_proc_locked_vm_size();
	srand(time(NULL));
	for (i = 0; i < TEST_LOOP; i++) {
	int is_mlock = !!(rand() % 2);
	int lock_size = (rand() % (alloc_size - cur.rlim_cur))
	+ cur.rlim_cur;
	int start_offset = rand() % (alloc_size - lock_size);

	if (is_mlock)
	ret = mlock(p + start_offset, lock_size);
	else
	ret = mlock2_(p + start_offset, lock_size,
	MLOCK_ONFAULT);
	if (ret == 0) {
	printf("%s() succeeds? on %p(%d) mlock%p(%d)\n",
	is_mlock ? "mlock" : "mlock2",
	p, alloc_size,
	p + start_offset, lock_size);
	return -1;
	}
	}

	locked_vm_size = get_proc_locked_vm_size();
	if (locked_vm_size != old_locked_vm_size) {
	printf("tests leads to new mlocked page: old[%d], new[%d]\n",
	old_locked_vm_size,
	locked_vm_size);
	return -1;
	}

	return 0;
	}

	int main(int argc, char **argv)
	{
	char *p = NULL;
	int ret = 0;

	if (set_cap_limits(MLOCK_RLIMIT_SIZE))
	return -1;

	p = malloc(MLOCK_WITHIN_LIMIT_SIZE);
	if (p == NULL) {
	perror("malloc() failure\n");
	return -1;
	}
	ret = test_mlock_within_limit(p, MLOCK_WITHIN_LIMIT_SIZE);
	if (ret)
	return ret;
	munlock(p, MLOCK_WITHIN_LIMIT_SIZE);
	free(p);


	p = malloc(MLOCK_OUTOF_LIMIT_SIZE);
	if (p == NULL) {
	perror("malloc() failure\n");
	return -1;
	}
	ret = test_mlock_outof_limit(p, MLOCK_OUTOF_LIMIT_SIZE);
	if (ret)
	return ret;
	munlock(p, MLOCK_OUTOF_LIMIT_SIZE);
	free(p);

	return 0;
	}