1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Test soft offline behavior for HugeTLB pages: 4 * - if enable_soft_offline = 0, hugepages should stay intact and soft 5 * offlining failed with EOPNOTSUPP. 6 * - if enable_soft_offline = 1, a hugepage should be dissolved and 7 * nr_hugepages/free_hugepages should be reduced by 1. 8 * 9 * The test allocates 8 default hugepages 10 */ 11 12 #define _GNU_SOURCE 13 #include <errno.h> 14 #include <stdlib.h> 15 #include <stdio.h> 16 #include <string.h> 17 #include <unistd.h> 18 19 #include <linux/magic.h> 20 #include <linux/memfd.h> 21 #include <sys/mman.h> 22 #include <sys/statfs.h> 23 #include <sys/types.h> 24 25 #include "kselftest.h" 26 #include "hugepage_settings.h" 27 28 #ifndef MADV_SOFT_OFFLINE 29 #define MADV_SOFT_OFFLINE 101 30 #endif 31 32 #define EPREFIX " !!! " 33 34 static int do_soft_offline(int fd, size_t len, int expect_errno) 35 { 36 char *filemap = NULL; 37 char *hwp_addr = NULL; 38 const unsigned long pagesize = getpagesize(); 39 int ret = 0; 40 41 if (ftruncate(fd, len) < 0) { 42 ksft_perror(EPREFIX "ftruncate to len failed"); 43 return -1; 44 } 45 46 filemap = mmap(NULL, len, PROT_READ | PROT_WRITE, 47 MAP_SHARED | MAP_POPULATE, fd, 0); 48 if (filemap == MAP_FAILED) { 49 ksft_perror(EPREFIX "mmap failed"); 50 ret = -1; 51 goto untruncate; 52 } 53 54 memset(filemap, 0xab, len); 55 ksft_print_msg("Allocated %#lx bytes of hugetlb pages\n", len); 56 57 hwp_addr = filemap + len / 2; 58 ret = madvise(hwp_addr, pagesize, MADV_SOFT_OFFLINE); 59 ksft_print_msg("MADV_SOFT_OFFLINE %p ret=%d, errno=%d\n", 60 hwp_addr, ret, errno); 61 if (ret != 0) 62 ksft_perror(EPREFIX "madvise failed"); 63 64 if (errno == expect_errno) 65 ret = 0; 66 else { 67 ksft_print_msg("MADV_SOFT_OFFLINE should ret %d\n", 68 expect_errno); 69 ret = -1; 70 } 71 72 munmap(filemap, len); 73 untruncate: 74 if (ftruncate(fd, 0) < 0) 75 ksft_perror(EPREFIX "ftruncate back to 0 failed"); 76 77 return ret; 78 } 79 80 static int set_enable_soft_offline(int value) 81 { 82 char cmd[256] = {0}; 83 FILE *cmdfile = NULL; 84 85 if (value != 0 && value != 1) 86 return -EINVAL; 87 88 sprintf(cmd, "echo %d > /proc/sys/vm/enable_soft_offline", value); 89 cmdfile = popen(cmd, "r"); 90 91 if (cmdfile) 92 ksft_print_msg("enable_soft_offline => %d\n", value); 93 else { 94 ksft_perror(EPREFIX "failed to set enable_soft_offline"); 95 return errno; 96 } 97 98 pclose(cmdfile); 99 return 0; 100 } 101 102 static int create_hugetlbfs_file(struct statfs *file_stat) 103 { 104 int fd; 105 106 fd = memfd_create("hugetlb_tmp", MFD_HUGETLB); 107 if (fd < 0) { 108 ksft_perror(EPREFIX "could not open hugetlbfs file"); 109 return -1; 110 } 111 112 memset(file_stat, 0, sizeof(*file_stat)); 113 if (fstatfs(fd, file_stat)) { 114 ksft_perror(EPREFIX "fstatfs failed"); 115 goto close; 116 } 117 if (file_stat->f_type != HUGETLBFS_MAGIC) { 118 ksft_print_msg(EPREFIX "not hugetlbfs file\n"); 119 goto close; 120 } 121 122 return fd; 123 close: 124 close(fd); 125 return -1; 126 } 127 128 static void test_soft_offline_common(int enable_soft_offline) 129 { 130 int fd; 131 int expect_errno = enable_soft_offline ? 0 : EOPNOTSUPP; 132 struct statfs file_stat; 133 unsigned long hugepagesize_kb = 0; 134 unsigned long nr_hugepages_before = 0; 135 unsigned long nr_hugepages_after = 0; 136 int ret; 137 138 ksft_print_msg("Test soft-offline when enabled_soft_offline=%d\n", 139 enable_soft_offline); 140 141 fd = create_hugetlbfs_file(&file_stat); 142 if (fd < 0) 143 ksft_exit_fail_msg("Failed to create hugetlbfs file\n"); 144 145 hugepagesize_kb = file_stat.f_bsize / 1024; 146 ksft_print_msg("Hugepagesize is %ldkB\n", hugepagesize_kb); 147 148 if (set_enable_soft_offline(enable_soft_offline) != 0) { 149 close(fd); 150 ksft_exit_fail_msg("Failed to set enable_soft_offline\n"); 151 } 152 153 nr_hugepages_before = hugetlb_nr_default_pages(); 154 155 ksft_print_msg("Before MADV_SOFT_OFFLINE nr_hugepages=%ld\n", 156 nr_hugepages_before); 157 158 ret = do_soft_offline(fd, 2 * file_stat.f_bsize, expect_errno); 159 160 nr_hugepages_after = hugetlb_nr_default_pages(); 161 162 ksft_print_msg("After MADV_SOFT_OFFLINE nr_hugepages=%ld\n", 163 nr_hugepages_after); 164 165 // No need for the hugetlbfs file from now on. 166 close(fd); 167 168 if (enable_soft_offline) { 169 if (nr_hugepages_before != nr_hugepages_after + 1) { 170 ksft_test_result_fail("MADV_SOFT_OFFLINE should reduced 1 hugepage\n"); 171 return; 172 } 173 } else { 174 if (nr_hugepages_before != nr_hugepages_after) { 175 ksft_test_result_fail("MADV_SOFT_OFFLINE reduced %lu hugepages\n", 176 nr_hugepages_before - nr_hugepages_after); 177 return; 178 } 179 } 180 181 ksft_test_result(ret == 0, 182 "Test soft-offline when enabled_soft_offline=%d\n", 183 enable_soft_offline); 184 } 185 186 int main(int argc, char **argv) 187 { 188 ksft_print_header(); 189 190 if (!hugetlb_setup_default(8)) 191 ksft_exit_skip("not enough hugetlb pages\n"); 192 193 ksft_set_plan(2); 194 195 test_soft_offline_common(1); 196 test_soft_offline_common(0); 197 198 ksft_finished(); 199 } 200