Commit 26b4224d authored by Simon Guo's avatar Simon Guo Committed by Linus Torvalds

selftests: expanding more mlock selftest

This patch will randomly perform mlock/mlock2 on a given memory region,
and verify the RLIMIT_MEMLOCK limitation works properly.
Suggested-by: default avatarDavid Rientjes <rientjes@google.com>
Link: http://lkml.kernel.org/r/1473325970-11393-4-git-send-email-wei.guo.simon@gmail.comSigned-off-by: default avatarSimon Guo <wei.guo.simon@gmail.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: "Kirill A. Shutemov" <kirill.shutemov@linux.intel.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Eric B Munson <emunson@akamai.com>
Cc: Simon Guo <wei.guo.simon@gmail.com>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Alexey Klimov <klimov.linux@gmail.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent d5aed9c0
...@@ -10,7 +10,7 @@ BINARIES += on-fault-limit ...@@ -10,7 +10,7 @@ BINARIES += on-fault-limit
BINARIES += thuge-gen BINARIES += thuge-gen
BINARIES += transhuge-stress BINARIES += transhuge-stress
BINARIES += userfaultfd BINARIES += userfaultfd
BINARIES += mlock-intersect-test BINARIES += mlock-random-test
all: $(BINARIES) all: $(BINARIES)
%: %.c %: %.c
...@@ -18,7 +18,7 @@ all: $(BINARIES) ...@@ -18,7 +18,7 @@ all: $(BINARIES)
userfaultfd: userfaultfd.c ../../../../usr/include/linux/kernel.h userfaultfd: userfaultfd.c ../../../../usr/include/linux/kernel.h
$(CC) $(CFLAGS) -O2 -o $@ $< -lpthread $(CC) $(CFLAGS) -O2 -o $@ $< -lpthread
mlock-intersect-test: mlock-intersect-test.c mlock-random-test: mlock-random-test.c
$(CC) $(CFLAGS) -o $@ $< -lcap $(CC) $(CFLAGS) -o $@ $< -lcap
../../../../usr/include/linux/kernel.h: ../../../../usr/include/linux/kernel.h:
......
/*
* It tests the duplicate mlock result:
* - the ulimit of lock page is 64k
* - allocate address area 64k starting from p
* - mlock [p -- p + 30k]
* - Then mlock address [ p -- p + 40k ]
*
* It should succeed since totally we locked
* 40k < 64k limitation.
*
* It should not be run with CAP_IPC_LOCK.
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/resource.h>
#include <sys/capability.h>
#include <sys/mman.h>
#include "mlock2.h"
int main(int argc, char **argv)
{
struct rlimit new;
char *p = NULL;
cap_t cap = cap_init();
int i;
/* drop capabilities including CAP_IPC_LOCK */
if (cap_set_proc(cap))
return -1;
/* set mlock limits to 64k */
new.rlim_cur = 65536;
new.rlim_max = 65536;
setrlimit(RLIMIT_MEMLOCK, &new);
/* test VM_LOCK */
p = malloc(1024 * 64);
if (mlock(p, 1024 * 30)) {
printf("mlock() 30k return failure.\n");
return -1;
}
for (i = 0; i < 10; i++) {
if (mlock(p, 1024 * 40)) {
printf("mlock() #%d 40k returns failure.\n", i);
return -1;
}
}
for (i = 0; i < 10; i++) {
if (mlock2_(p, 1024 * 40, MLOCK_ONFAULT)) {
printf("mlock2_() #%d 40k returns failure.\n", i);
return -1;
}
}
free(p);
/* Test VM_LOCKONFAULT */
p = malloc(1024 * 64);
if (mlock2_(p, 1024 * 30, MLOCK_ONFAULT)) {
printf("mlock2_() 30k return failure.\n");
return -1;
}
for (i = 0; i < 10; i++) {
if (mlock2_(p, 1024 * 40, MLOCK_ONFAULT)) {
printf("mlock2_() #%d 40k returns failure.\n", i);
return -1;
}
}
for (i = 0; i < 10; i++) {
if (mlock(p, 1024 * 40)) {
printf("mlock() #%d 40k returns failure.\n", i);
return -1;
}
}
return 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;
}
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment