tools/testing/selftests/mm/mlock-random-test.c

   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
  27 int 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
  48 int 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  */
  84 int 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  */
 132 static 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  */
 199 static 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
 239 int 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 }