1 // SPDX-License-Identifier: GPL-2.0 2 #define _GNU_SOURCE 3 4 #include <linux/limits.h> 5 #include <fcntl.h> 6 #include <stdio.h> 7 #include <stdlib.h> 8 #include <string.h> 9 #include <sys/stat.h> 10 #include <sys/types.h> 11 #include <unistd.h> 12 #include <sys/wait.h> 13 #include <errno.h> 14 #include <sys/sysinfo.h> 15 #include <pthread.h> 16 17 #include "../kselftest.h" 18 #include "cgroup_util.h" 19 20 21 /* 22 * Memory cgroup charging is performed using percpu batches 64 pages 23 * big (look at MEMCG_CHARGE_BATCH), whereas memory.stat is exact. So 24 * the maximum discrepancy between charge and vmstat entries is number 25 * of cpus multiplied by 64 pages. 26 */ 27 #define MAX_VMSTAT_ERROR (4096 * 64 * get_nprocs()) 28 29 30 static int alloc_dcache(const char *cgroup, void *arg) 31 { 32 unsigned long i; 33 struct stat st; 34 char buf[128]; 35 36 for (i = 0; i < (unsigned long)arg; i++) { 37 snprintf(buf, sizeof(buf), 38 "/something-non-existent-with-a-long-name-%64lu-%d", 39 i, getpid()); 40 stat(buf, &st); 41 } 42 43 return 0; 44 } 45 46 /* 47 * This test allocates 100000 of negative dentries with long names. 48 * Then it checks that "slab" in memory.stat is larger than 1M. 49 * Then it sets memory.high to 1M and checks that at least 1/2 50 * of slab memory has been reclaimed. 51 */ 52 static int test_kmem_basic(const char *root) 53 { 54 int ret = KSFT_FAIL; 55 char *cg = NULL; 56 long slab0, slab1, current; 57 58 cg = cg_name(root, "kmem_basic_test"); 59 if (!cg) 60 goto cleanup; 61 62 if (cg_create(cg)) 63 goto cleanup; 64 65 if (cg_run(cg, alloc_dcache, (void *)100000)) 66 goto cleanup; 67 68 slab0 = cg_read_key_long(cg, "memory.stat", "slab "); 69 if (slab0 < (1 << 20)) 70 goto cleanup; 71 72 cg_write(cg, "memory.high", "1M"); 73 74 /* wait for RCU freeing */ 75 sleep(1); 76 77 slab1 = cg_read_key_long(cg, "memory.stat", "slab "); 78 if (slab1 < 0) 79 goto cleanup; 80 81 current = cg_read_long(cg, "memory.current"); 82 if (current < 0) 83 goto cleanup; 84 85 if (slab1 < slab0 / 2 && current < slab0 / 2) 86 ret = KSFT_PASS; 87 cleanup: 88 cg_destroy(cg); 89 free(cg); 90 91 return ret; 92 } 93 94 static void *alloc_kmem_fn(void *arg) 95 { 96 alloc_dcache(NULL, (void *)100); 97 return NULL; 98 } 99 100 static int alloc_kmem_smp(const char *cgroup, void *arg) 101 { 102 int nr_threads = 2 * get_nprocs(); 103 pthread_t *tinfo; 104 unsigned long i; 105 int ret = -1; 106 107 tinfo = calloc(nr_threads, sizeof(pthread_t)); 108 if (tinfo == NULL) 109 return -1; 110 111 for (i = 0; i < nr_threads; i++) { 112 if (pthread_create(&tinfo[i], NULL, &alloc_kmem_fn, 113 (void *)i)) { 114 free(tinfo); 115 return -1; 116 } 117 } 118 119 for (i = 0; i < nr_threads; i++) { 120 ret = pthread_join(tinfo[i], NULL); 121 if (ret) 122 break; 123 } 124 125 free(tinfo); 126 return ret; 127 } 128 129 static int cg_run_in_subcgroups(const char *parent, 130 int (*fn)(const char *cgroup, void *arg), 131 void *arg, int times) 132 { 133 char *child; 134 int i; 135 136 for (i = 0; i < times; i++) { 137 child = cg_name_indexed(parent, "child", i); 138 if (!child) 139 return -1; 140 141 if (cg_create(child)) { 142 cg_destroy(child); 143 free(child); 144 return -1; 145 } 146 147 if (cg_run(child, fn, NULL)) { 148 cg_destroy(child); 149 free(child); 150 return -1; 151 } 152 153 cg_destroy(child); 154 free(child); 155 } 156 157 return 0; 158 } 159 160 /* 161 * The test creates and destroys a large number of cgroups. In each cgroup it 162 * allocates some slab memory (mostly negative dentries) using 2 * NR_CPUS 163 * threads. Then it checks the sanity of numbers on the parent level: 164 * the total size of the cgroups should be roughly equal to 165 * anon + file + kernel + sock. 166 */ 167 static int test_kmem_memcg_deletion(const char *root) 168 { 169 long current, anon, file, kernel, sock, sum; 170 int ret = KSFT_FAIL; 171 char *parent; 172 173 parent = cg_name(root, "kmem_memcg_deletion_test"); 174 if (!parent) 175 goto cleanup; 176 177 if (cg_create(parent)) 178 goto cleanup; 179 180 if (cg_write(parent, "cgroup.subtree_control", "+memory")) 181 goto cleanup; 182 183 if (cg_run_in_subcgroups(parent, alloc_kmem_smp, NULL, 100)) 184 goto cleanup; 185 186 current = cg_read_long(parent, "memory.current"); 187 anon = cg_read_key_long(parent, "memory.stat", "anon "); 188 file = cg_read_key_long(parent, "memory.stat", "file "); 189 kernel = cg_read_key_long(parent, "memory.stat", "kernel "); 190 sock = cg_read_key_long(parent, "memory.stat", "sock "); 191 if (current < 0 || anon < 0 || file < 0 || kernel < 0 || sock < 0) 192 goto cleanup; 193 194 sum = anon + file + kernel + sock; 195 if (abs(sum - current) < MAX_VMSTAT_ERROR) { 196 ret = KSFT_PASS; 197 } else { 198 printf("memory.current = %ld\n", current); 199 printf("anon + file + kernel + sock = %ld\n", sum); 200 printf("anon = %ld\n", anon); 201 printf("file = %ld\n", file); 202 printf("kernel = %ld\n", kernel); 203 printf("sock = %ld\n", sock); 204 } 205 206 cleanup: 207 cg_destroy(parent); 208 free(parent); 209 210 return ret; 211 } 212 213 /* 214 * The test reads the entire /proc/kpagecgroup. If the operation went 215 * successfully (and the kernel didn't panic), the test is treated as passed. 216 */ 217 static int test_kmem_proc_kpagecgroup(const char *root) 218 { 219 unsigned long buf[128]; 220 int ret = KSFT_FAIL; 221 ssize_t len; 222 int fd; 223 224 fd = open("/proc/kpagecgroup", O_RDONLY); 225 if (fd < 0) 226 return ret; 227 228 do { 229 len = read(fd, buf, sizeof(buf)); 230 } while (len > 0); 231 232 if (len == 0) 233 ret = KSFT_PASS; 234 235 close(fd); 236 return ret; 237 } 238 239 static void *pthread_wait_fn(void *arg) 240 { 241 sleep(100); 242 return NULL; 243 } 244 245 static int spawn_1000_threads(const char *cgroup, void *arg) 246 { 247 int nr_threads = 1000; 248 pthread_t *tinfo; 249 unsigned long i; 250 long stack; 251 int ret = -1; 252 253 tinfo = calloc(nr_threads, sizeof(pthread_t)); 254 if (tinfo == NULL) 255 return -1; 256 257 for (i = 0; i < nr_threads; i++) { 258 if (pthread_create(&tinfo[i], NULL, &pthread_wait_fn, 259 (void *)i)) { 260 free(tinfo); 261 return(-1); 262 } 263 } 264 265 stack = cg_read_key_long(cgroup, "memory.stat", "kernel_stack "); 266 if (stack >= 4096 * 1000) 267 ret = 0; 268 269 free(tinfo); 270 return ret; 271 } 272 273 /* 274 * The test spawns a process, which spawns 1000 threads. Then it checks 275 * that memory.stat's kernel_stack is at least 1000 pages large. 276 */ 277 static int test_kmem_kernel_stacks(const char *root) 278 { 279 int ret = KSFT_FAIL; 280 char *cg = NULL; 281 282 cg = cg_name(root, "kmem_kernel_stacks_test"); 283 if (!cg) 284 goto cleanup; 285 286 if (cg_create(cg)) 287 goto cleanup; 288 289 if (cg_run(cg, spawn_1000_threads, NULL)) 290 goto cleanup; 291 292 ret = KSFT_PASS; 293 cleanup: 294 cg_destroy(cg); 295 free(cg); 296 297 return ret; 298 } 299 300 /* 301 * This test sequentionally creates 30 child cgroups, allocates some 302 * kernel memory in each of them, and deletes them. Then it checks 303 * that the number of dying cgroups on the parent level is 0. 304 */ 305 static int test_kmem_dead_cgroups(const char *root) 306 { 307 int ret = KSFT_FAIL; 308 char *parent; 309 long dead; 310 int i; 311 312 parent = cg_name(root, "kmem_dead_cgroups_test"); 313 if (!parent) 314 goto cleanup; 315 316 if (cg_create(parent)) 317 goto cleanup; 318 319 if (cg_write(parent, "cgroup.subtree_control", "+memory")) 320 goto cleanup; 321 322 if (cg_run_in_subcgroups(parent, alloc_dcache, (void *)100, 30)) 323 goto cleanup; 324 325 for (i = 0; i < 5; i++) { 326 dead = cg_read_key_long(parent, "cgroup.stat", 327 "nr_dying_descendants "); 328 if (dead == 0) { 329 ret = KSFT_PASS; 330 break; 331 } 332 /* 333 * Reclaiming cgroups might take some time, 334 * let's wait a bit and repeat. 335 */ 336 sleep(1); 337 } 338 339 cleanup: 340 cg_destroy(parent); 341 free(parent); 342 343 return ret; 344 } 345 346 /* 347 * This test creates a sub-tree with 1000 memory cgroups. 348 * Then it checks that the memory.current on the parent level 349 * is greater than 0 and approximates matches the percpu value 350 * from memory.stat. 351 */ 352 static int test_percpu_basic(const char *root) 353 { 354 int ret = KSFT_FAIL; 355 char *parent, *child; 356 long current, percpu; 357 int i; 358 359 parent = cg_name(root, "percpu_basic_test"); 360 if (!parent) 361 goto cleanup; 362 363 if (cg_create(parent)) 364 goto cleanup; 365 366 if (cg_write(parent, "cgroup.subtree_control", "+memory")) 367 goto cleanup; 368 369 for (i = 0; i < 1000; i++) { 370 child = cg_name_indexed(parent, "child", i); 371 if (!child) 372 return -1; 373 374 if (cg_create(child)) 375 goto cleanup_children; 376 377 free(child); 378 } 379 380 current = cg_read_long(parent, "memory.current"); 381 percpu = cg_read_key_long(parent, "memory.stat", "percpu "); 382 383 if (current > 0 && percpu > 0 && abs(current - percpu) < 384 MAX_VMSTAT_ERROR) 385 ret = KSFT_PASS; 386 else 387 printf("memory.current %ld\npercpu %ld\n", 388 current, percpu); 389 390 cleanup_children: 391 for (i = 0; i < 1000; i++) { 392 child = cg_name_indexed(parent, "child", i); 393 cg_destroy(child); 394 free(child); 395 } 396 397 cleanup: 398 cg_destroy(parent); 399 free(parent); 400 401 return ret; 402 } 403 404 #define T(x) { x, #x } 405 struct kmem_test { 406 int (*fn)(const char *root); 407 const char *name; 408 } tests[] = { 409 T(test_kmem_basic), 410 T(test_kmem_memcg_deletion), 411 T(test_kmem_proc_kpagecgroup), 412 T(test_kmem_kernel_stacks), 413 T(test_kmem_dead_cgroups), 414 T(test_percpu_basic), 415 }; 416 #undef T 417 418 int main(int argc, char **argv) 419 { 420 char root[PATH_MAX]; 421 int i, ret = EXIT_SUCCESS; 422 423 if (cg_find_unified_root(root, sizeof(root))) 424 ksft_exit_skip("cgroup v2 isn't mounted\n"); 425 426 /* 427 * Check that memory controller is available: 428 * memory is listed in cgroup.controllers 429 */ 430 if (cg_read_strstr(root, "cgroup.controllers", "memory")) 431 ksft_exit_skip("memory controller isn't available\n"); 432 433 if (cg_read_strstr(root, "cgroup.subtree_control", "memory")) 434 if (cg_write(root, "cgroup.subtree_control", "+memory")) 435 ksft_exit_skip("Failed to set memory controller\n"); 436 437 for (i = 0; i < ARRAY_SIZE(tests); i++) { 438 switch (tests[i].fn(root)) { 439 case KSFT_PASS: 440 ksft_test_result_pass("%s\n", tests[i].name); 441 break; 442 case KSFT_SKIP: 443 ksft_test_result_skip("%s\n", tests[i].name); 444 break; 445 default: 446 ret = EXIT_FAILURE; 447 ksft_test_result_fail("%s\n", tests[i].name); 448 break; 449 } 450 } 451 452 return ret; 453 } 454