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