1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #include <dirent.h> 3 #include <errno.h> 4 #include <fcntl.h> 5 #include <linux/ctype.h> 6 #include <linux/kernel.h> 7 #include <linux/string.h> 8 #include <linux/zalloc.h> 9 #include <string.h> 10 #include <stdlib.h> 11 #include <sys/types.h> 12 #include <unistd.h> 13 #include <subcmd/exec-cmd.h> 14 #include <subcmd/parse-options.h> 15 #include <sys/wait.h> 16 #include <sys/stat.h> 17 #include <api/io.h> 18 #include "builtin.h" 19 #include "tests-scripts.h" 20 #include "color.h" 21 #include "debug.h" 22 #include "hist.h" 23 #include "intlist.h" 24 #include "string2.h" 25 #include "symbol.h" 26 #include "tests.h" 27 #include "util/rlimit.h" 28 #include "util/util.h" 29 30 static int shell_tests__dir_fd(void) 31 { 32 struct stat st; 33 char path[PATH_MAX], path2[PATH_MAX], *exec_path; 34 static const char * const devel_dirs[] = { 35 "./tools/perf/tests/shell", 36 "./tests/shell", 37 "./source/tests/shell" 38 }; 39 int fd; 40 char *p; 41 42 for (size_t i = 0; i < ARRAY_SIZE(devel_dirs); ++i) { 43 fd = open(devel_dirs[i], O_PATH); 44 45 if (fd >= 0) 46 return fd; 47 } 48 49 /* Use directory of executable */ 50 if (readlink("/proc/self/exe", path2, sizeof path2) < 0) 51 return -1; 52 /* Follow another level of symlink if there */ 53 if (lstat(path2, &st) == 0 && (st.st_mode & S_IFMT) == S_IFLNK) { 54 scnprintf(path, sizeof(path), path2); 55 if (readlink(path, path2, sizeof path2) < 0) 56 return -1; 57 } 58 /* Get directory */ 59 p = strrchr(path2, '/'); 60 if (p) 61 *p = 0; 62 scnprintf(path, sizeof(path), "%s/tests/shell", path2); 63 fd = open(path, O_PATH); 64 if (fd >= 0) 65 return fd; 66 scnprintf(path, sizeof(path), "%s/source/tests/shell", path2); 67 fd = open(path, O_PATH); 68 if (fd >= 0) 69 return fd; 70 71 /* Then installed path. */ 72 exec_path = get_argv_exec_path(); 73 scnprintf(path, sizeof(path), "%s/tests/shell", exec_path); 74 free(exec_path); 75 return open(path, O_PATH); 76 } 77 78 static char *shell_test__description(int dir_fd, const char *name) 79 { 80 struct io io; 81 char buf[128], desc[256]; 82 int ch, pos = 0; 83 84 io__init(&io, openat(dir_fd, name, O_RDONLY), buf, sizeof(buf)); 85 if (io.fd < 0) 86 return NULL; 87 88 /* Skip first line - should be #!/bin/sh Shebang */ 89 if (io__get_char(&io) != '#') 90 goto err_out; 91 if (io__get_char(&io) != '!') 92 goto err_out; 93 do { 94 ch = io__get_char(&io); 95 if (ch < 0) 96 goto err_out; 97 } while (ch != '\n'); 98 99 do { 100 ch = io__get_char(&io); 101 if (ch < 0) 102 goto err_out; 103 } while (ch == '#' || isspace(ch)); 104 while (ch > 0 && ch != '\n') { 105 desc[pos++] = ch; 106 if (pos >= (int)sizeof(desc) - 1) 107 break; 108 ch = io__get_char(&io); 109 } 110 while (pos > 0 && isspace(desc[--pos])) 111 ; 112 desc[++pos] = '\0'; 113 close(io.fd); 114 return strdup(desc); 115 err_out: 116 close(io.fd); 117 return NULL; 118 } 119 120 /* Is this full file path a shell script */ 121 static bool is_shell_script(int dir_fd, const char *path) 122 { 123 const char *ext; 124 125 ext = strrchr(path, '.'); 126 if (!ext) 127 return false; 128 if (!strcmp(ext, ".sh")) { /* Has .sh extension */ 129 if (faccessat(dir_fd, path, R_OK | X_OK, 0) == 0) /* Is executable */ 130 return true; 131 } 132 return false; 133 } 134 135 /* Is this file in this dir a shell script (for test purposes) */ 136 static bool is_test_script(int dir_fd, const char *name) 137 { 138 return is_shell_script(dir_fd, name); 139 } 140 141 /* Duplicate a string and fall over and die if we run out of memory */ 142 static char *strdup_check(const char *str) 143 { 144 char *newstr; 145 146 newstr = strdup(str); 147 if (!newstr) { 148 pr_err("Out of memory while duplicating test script string\n"); 149 abort(); 150 } 151 return newstr; 152 } 153 154 static int shell_test__run(struct test_suite *test, int subtest __maybe_unused) 155 { 156 const char *file = test->priv; 157 int err; 158 char *cmd = NULL; 159 160 if (asprintf(&cmd, "%s%s", file, verbose ? " -v" : "") < 0) 161 return TEST_FAIL; 162 err = system(cmd); 163 free(cmd); 164 if (!err) 165 return TEST_OK; 166 167 return WEXITSTATUS(err) == 2 ? TEST_SKIP : TEST_FAIL; 168 } 169 170 static void append_script(int dir_fd, const char *name, char *desc, 171 struct test_suite ***result, 172 size_t *result_sz) 173 { 174 char filename[PATH_MAX], link[128]; 175 struct test_suite *test_suite, **result_tmp; 176 struct test_case *tests; 177 size_t len; 178 char *exclusive; 179 180 snprintf(link, sizeof(link), "/proc/%d/fd/%d", getpid(), dir_fd); 181 len = readlink(link, filename, sizeof(filename)); 182 if (len < 0) { 183 pr_err("Failed to readlink %s", link); 184 return; 185 } 186 filename[len++] = '/'; 187 strcpy(&filename[len], name); 188 189 tests = calloc(2, sizeof(*tests)); 190 if (!tests) { 191 pr_err("Out of memory while building script test suite list\n"); 192 return; 193 } 194 tests[0].name = strdup_check(name); 195 exclusive = strstr(desc, " (exclusive)"); 196 if (exclusive != NULL) { 197 tests[0].exclusive = true; 198 exclusive[0] = '\0'; 199 } 200 tests[0].desc = strdup_check(desc); 201 tests[0].run_case = shell_test__run; 202 test_suite = zalloc(sizeof(*test_suite)); 203 if (!test_suite) { 204 pr_err("Out of memory while building script test suite list\n"); 205 free(tests); 206 return; 207 } 208 test_suite->desc = desc; 209 test_suite->test_cases = tests; 210 test_suite->priv = strdup_check(filename); 211 /* Realloc is good enough, though we could realloc by chunks, not that 212 * anyone will ever measure performance here */ 213 result_tmp = realloc(*result, (*result_sz + 1) * sizeof(*result_tmp)); 214 if (result_tmp == NULL) { 215 pr_err("Out of memory while building script test suite list\n"); 216 free(tests); 217 free(test_suite); 218 return; 219 } 220 /* Add file to end and NULL terminate the struct array */ 221 *result = result_tmp; 222 (*result)[*result_sz] = test_suite; 223 (*result_sz)++; 224 } 225 226 static void append_scripts_in_dir(int dir_fd, 227 struct test_suite ***result, 228 size_t *result_sz) 229 { 230 struct dirent **entlist; 231 struct dirent *ent; 232 int n_dirs, i; 233 234 /* List files, sorted by alpha */ 235 n_dirs = scandirat(dir_fd, ".", &entlist, NULL, alphasort); 236 if (n_dirs == -1) 237 return; 238 for (i = 0; i < n_dirs && (ent = entlist[i]); i++) { 239 int fd; 240 241 if (ent->d_name[0] == '.') 242 continue; /* Skip hidden files */ 243 if (is_test_script(dir_fd, ent->d_name)) { /* It's a test */ 244 char *desc = shell_test__description(dir_fd, ent->d_name); 245 246 if (desc) /* It has a desc line - valid script */ 247 append_script(dir_fd, ent->d_name, desc, result, result_sz); 248 continue; 249 } 250 if (ent->d_type != DT_DIR) { 251 struct stat st; 252 253 if (ent->d_type != DT_UNKNOWN) 254 continue; 255 fstatat(dir_fd, ent->d_name, &st, 0); 256 if (!S_ISDIR(st.st_mode)) 257 continue; 258 } 259 if (strncmp(ent->d_name, "base_", 5) == 0) 260 continue; /* Skip scripts that have a separate driver. */ 261 fd = openat(dir_fd, ent->d_name, O_PATH); 262 append_scripts_in_dir(fd, result, result_sz); 263 } 264 for (i = 0; i < n_dirs; i++) /* Clean up */ 265 zfree(&entlist[i]); 266 free(entlist); 267 } 268 269 struct test_suite **create_script_test_suites(void) 270 { 271 struct test_suite **result = NULL, **result_tmp; 272 size_t result_sz = 0; 273 int dir_fd = shell_tests__dir_fd(); /* Walk dir */ 274 275 /* 276 * Append scripts if fd is good, otherwise return a NULL terminated zero 277 * length array. 278 */ 279 if (dir_fd >= 0) 280 append_scripts_in_dir(dir_fd, &result, &result_sz); 281 282 result_tmp = realloc(result, (result_sz + 1) * sizeof(*result_tmp)); 283 if (result_tmp == NULL) { 284 pr_err("Out of memory while building script test suite list\n"); 285 abort(); 286 } 287 /* NULL terminate the test suite array. */ 288 result = result_tmp; 289 result[result_sz] = NULL; 290 if (dir_fd >= 0) 291 close(dir_fd); 292 return result; 293 } 294