Author | Tokens | Token Proportion | Commits | Commit Proportion |
---|---|---|---|---|
Roman Gushchin | 1775 | 97.10% | 2 | 20.00% |
Johannes Weiner | 33 | 1.81% | 2 | 20.00% |
Lucas Karpinski | 11 | 0.60% | 2 | 20.00% |
Shuah Khan | 3 | 0.16% | 1 | 10.00% |
Tianchen Ding | 2 | 0.11% | 1 | 10.00% |
Michal Hocko | 2 | 0.11% | 1 | 10.00% |
John Hubbard | 2 | 0.11% | 1 | 10.00% |
Total | 1828 | 10 |
// SPDX-License-Identifier: GPL-2.0 #define _GNU_SOURCE #include <linux/limits.h> #include <fcntl.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <sys/wait.h> #include <errno.h> #include <sys/sysinfo.h> #include <pthread.h> #include "../kselftest.h" #include "cgroup_util.h" /* * Memory cgroup charging is performed using percpu batches 64 pages * big (look at MEMCG_CHARGE_BATCH), whereas memory.stat is exact. So * the maximum discrepancy between charge and vmstat entries is number * of cpus multiplied by 64 pages. */ #define MAX_VMSTAT_ERROR (4096 * 64 * get_nprocs()) static int alloc_dcache(const char *cgroup, void *arg) { unsigned long i; struct stat st; char buf[128]; for (i = 0; i < (unsigned long)arg; i++) { snprintf(buf, sizeof(buf), "/something-non-existent-with-a-long-name-%64lu-%d", i, getpid()); stat(buf, &st); } return 0; } /* * This test allocates 100000 of negative dentries with long names. * Then it checks that "slab" in memory.stat is larger than 1M. * Then it sets memory.high to 1M and checks that at least 1/2 * of slab memory has been reclaimed. */ static int test_kmem_basic(const char *root) { int ret = KSFT_FAIL; char *cg = NULL; long slab0, slab1, current; cg = cg_name(root, "kmem_basic_test"); if (!cg) goto cleanup; if (cg_create(cg)) goto cleanup; if (cg_run(cg, alloc_dcache, (void *)100000)) goto cleanup; slab0 = cg_read_key_long(cg, "memory.stat", "slab "); if (slab0 < (1 << 20)) goto cleanup; cg_write(cg, "memory.high", "1M"); /* wait for RCU freeing */ sleep(1); slab1 = cg_read_key_long(cg, "memory.stat", "slab "); if (slab1 < 0) goto cleanup; current = cg_read_long(cg, "memory.current"); if (current < 0) goto cleanup; if (slab1 < slab0 / 2 && current < slab0 / 2) ret = KSFT_PASS; cleanup: cg_destroy(cg); free(cg); return ret; } static void *alloc_kmem_fn(void *arg) { alloc_dcache(NULL, (void *)100); return NULL; } static int alloc_kmem_smp(const char *cgroup, void *arg) { int nr_threads = 2 * get_nprocs(); pthread_t *tinfo; unsigned long i; int ret = -1; tinfo = calloc(nr_threads, sizeof(pthread_t)); if (tinfo == NULL) return -1; for (i = 0; i < nr_threads; i++) { if (pthread_create(&tinfo[i], NULL, &alloc_kmem_fn, (void *)i)) { free(tinfo); return -1; } } for (i = 0; i < nr_threads; i++) { ret = pthread_join(tinfo[i], NULL); if (ret) break; } free(tinfo); return ret; } static int cg_run_in_subcgroups(const char *parent, int (*fn)(const char *cgroup, void *arg), void *arg, int times) { char *child; int i; for (i = 0; i < times; i++) { child = cg_name_indexed(parent, "child", i); if (!child) return -1; if (cg_create(child)) { cg_destroy(child); free(child); return -1; } if (cg_run(child, fn, NULL)) { cg_destroy(child); free(child); return -1; } cg_destroy(child); free(child); } return 0; } /* * The test creates and destroys a large number of cgroups. In each cgroup it * allocates some slab memory (mostly negative dentries) using 2 * NR_CPUS * threads. Then it checks the sanity of numbers on the parent level: * the total size of the cgroups should be roughly equal to * anon + file + kernel + sock. */ static int test_kmem_memcg_deletion(const char *root) { long current, anon, file, kernel, sock, sum; int ret = KSFT_FAIL; char *parent; parent = cg_name(root, "kmem_memcg_deletion_test"); if (!parent) goto cleanup; if (cg_create(parent)) goto cleanup; if (cg_write(parent, "cgroup.subtree_control", "+memory")) goto cleanup; if (cg_run_in_subcgroups(parent, alloc_kmem_smp, NULL, 100)) goto cleanup; current = cg_read_long(parent, "memory.current"); anon = cg_read_key_long(parent, "memory.stat", "anon "); file = cg_read_key_long(parent, "memory.stat", "file "); kernel = cg_read_key_long(parent, "memory.stat", "kernel "); sock = cg_read_key_long(parent, "memory.stat", "sock "); if (current < 0 || anon < 0 || file < 0 || kernel < 0 || sock < 0) goto cleanup; sum = anon + file + kernel + sock; if (labs(sum - current) < MAX_VMSTAT_ERROR) { ret = KSFT_PASS; } else { printf("memory.current = %ld\n", current); printf("anon + file + kernel + sock = %ld\n", sum); printf("anon = %ld\n", anon); printf("file = %ld\n", file); printf("kernel = %ld\n", kernel); printf("sock = %ld\n", sock); } cleanup: cg_destroy(parent); free(parent); return ret; } /* * The test reads the entire /proc/kpagecgroup. If the operation went * successfully (and the kernel didn't panic), the test is treated as passed. */ static int test_kmem_proc_kpagecgroup(const char *root) { unsigned long buf[128]; int ret = KSFT_FAIL; ssize_t len; int fd; fd = open("/proc/kpagecgroup", O_RDONLY); if (fd < 0) return ret; do { len = read(fd, buf, sizeof(buf)); } while (len > 0); if (len == 0) ret = KSFT_PASS; close(fd); return ret; } static void *pthread_wait_fn(void *arg) { sleep(100); return NULL; } static int spawn_1000_threads(const char *cgroup, void *arg) { int nr_threads = 1000; pthread_t *tinfo; unsigned long i; long stack; int ret = -1; tinfo = calloc(nr_threads, sizeof(pthread_t)); if (tinfo == NULL) return -1; for (i = 0; i < nr_threads; i++) { if (pthread_create(&tinfo[i], NULL, &pthread_wait_fn, (void *)i)) { free(tinfo); return(-1); } } stack = cg_read_key_long(cgroup, "memory.stat", "kernel_stack "); if (stack >= 4096 * 1000) ret = 0; free(tinfo); return ret; } /* * The test spawns a process, which spawns 1000 threads. Then it checks * that memory.stat's kernel_stack is at least 1000 pages large. */ static int test_kmem_kernel_stacks(const char *root) { int ret = KSFT_FAIL; char *cg = NULL; cg = cg_name(root, "kmem_kernel_stacks_test"); if (!cg) goto cleanup; if (cg_create(cg)) goto cleanup; if (cg_run(cg, spawn_1000_threads, NULL)) goto cleanup; ret = KSFT_PASS; cleanup: cg_destroy(cg); free(cg); return ret; } /* * This test sequentionally creates 30 child cgroups, allocates some * kernel memory in each of them, and deletes them. Then it checks * that the number of dying cgroups on the parent level is 0. */ static int test_kmem_dead_cgroups(const char *root) { int ret = KSFT_FAIL; char *parent; long dead; int i; parent = cg_name(root, "kmem_dead_cgroups_test"); if (!parent) goto cleanup; if (cg_create(parent)) goto cleanup; if (cg_write(parent, "cgroup.subtree_control", "+memory")) goto cleanup; if (cg_run_in_subcgroups(parent, alloc_dcache, (void *)100, 30)) goto cleanup; for (i = 0; i < 5; i++) { dead = cg_read_key_long(parent, "cgroup.stat", "nr_dying_descendants "); if (dead == 0) { ret = KSFT_PASS; break; } /* * Reclaiming cgroups might take some time, * let's wait a bit and repeat. */ sleep(1); } cleanup: cg_destroy(parent); free(parent); return ret; } /* * This test creates a sub-tree with 1000 memory cgroups. * Then it checks that the memory.current on the parent level * is greater than 0 and approximates matches the percpu value * from memory.stat. */ static int test_percpu_basic(const char *root) { int ret = KSFT_FAIL; char *parent, *child; long current, percpu; int i; parent = cg_name(root, "percpu_basic_test"); if (!parent) goto cleanup; if (cg_create(parent)) goto cleanup; if (cg_write(parent, "cgroup.subtree_control", "+memory")) goto cleanup; for (i = 0; i < 1000; i++) { child = cg_name_indexed(parent, "child", i); if (!child) return -1; if (cg_create(child)) goto cleanup_children; free(child); } current = cg_read_long(parent, "memory.current"); percpu = cg_read_key_long(parent, "memory.stat", "percpu "); if (current > 0 && percpu > 0 && labs(current - percpu) < MAX_VMSTAT_ERROR) ret = KSFT_PASS; else printf("memory.current %ld\npercpu %ld\n", current, percpu); cleanup_children: for (i = 0; i < 1000; i++) { child = cg_name_indexed(parent, "child", i); cg_destroy(child); free(child); } cleanup: cg_destroy(parent); free(parent); return ret; } #define T(x) { x, #x } struct kmem_test { int (*fn)(const char *root); const char *name; } tests[] = { T(test_kmem_basic), T(test_kmem_memcg_deletion), T(test_kmem_proc_kpagecgroup), T(test_kmem_kernel_stacks), T(test_kmem_dead_cgroups), T(test_percpu_basic), }; #undef T int main(int argc, char **argv) { char root[PATH_MAX]; int i, ret = EXIT_SUCCESS; if (cg_find_unified_root(root, sizeof(root), NULL)) ksft_exit_skip("cgroup v2 isn't mounted\n"); /* * Check that memory controller is available: * memory is listed in cgroup.controllers */ if (cg_read_strstr(root, "cgroup.controllers", "memory")) ksft_exit_skip("memory controller isn't available\n"); if (cg_read_strstr(root, "cgroup.subtree_control", "memory")) if (cg_write(root, "cgroup.subtree_control", "+memory")) ksft_exit_skip("Failed to set memory controller\n"); for (i = 0; i < ARRAY_SIZE(tests); i++) { switch (tests[i].fn(root)) { case KSFT_PASS: ksft_test_result_pass("%s\n", tests[i].name); break; case KSFT_SKIP: ksft_test_result_skip("%s\n", tests[i].name); break; default: ret = EXIT_FAILURE; ksft_test_result_fail("%s\n", tests[i].name); break; } } return ret; }
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with Cregit http://github.com/cregit/cregit
Version 2.0-RC1