You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
295 lines
6.5 KiB
295 lines
6.5 KiB
// 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;
|
|
}
|