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
shell_tests__dir_fd(void)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
shell_test__description(int dir_fd,const char * name)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 */
is_shell_script(int dir_fd,const char * path)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) */
is_test_script(int dir_fd,const char * name)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 */
strdup_check(const char * str)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
shell_test__run(struct test_suite * test,int subtest __maybe_unused)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
append_script(int dir_fd,const char * name,char * desc,struct test_suite *** result,size_t * result_sz)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
179 snprintf(link, sizeof(link), "/proc/%d/fd/%d", getpid(), dir_fd);
180 len = readlink(link, filename, sizeof(filename));
181 if (len < 0) {
182 pr_err("Failed to readlink %s", link);
183 return;
184 }
185 filename[len++] = '/';
186 strcpy(&filename[len], name);
187
188 tests = calloc(2, sizeof(*tests));
189 if (!tests) {
190 pr_err("Out of memory while building script test suite list\n");
191 return;
192 }
193 tests[0].name = strdup_check(name);
194 tests[0].desc = strdup_check(desc);
195 tests[0].run_case = shell_test__run;
196
197 test_suite = zalloc(sizeof(*test_suite));
198 if (!test_suite) {
199 pr_err("Out of memory while building script test suite list\n");
200 free(tests);
201 return;
202 }
203 test_suite->desc = desc;
204 test_suite->test_cases = tests;
205 test_suite->priv = strdup_check(filename);
206 /* Realloc is good enough, though we could realloc by chunks, not that
207 * anyone will ever measure performance here */
208 result_tmp = realloc(*result, (*result_sz + 1) * sizeof(*result_tmp));
209 if (result_tmp == NULL) {
210 pr_err("Out of memory while building script test suite list\n");
211 free(tests);
212 free(test_suite);
213 return;
214 }
215 /* Add file to end and NULL terminate the struct array */
216 *result = result_tmp;
217 (*result)[*result_sz] = test_suite;
218 (*result_sz)++;
219 }
220
append_scripts_in_dir(int dir_fd,struct test_suite *** result,size_t * result_sz)221 static void append_scripts_in_dir(int dir_fd,
222 struct test_suite ***result,
223 size_t *result_sz)
224 {
225 struct dirent **entlist;
226 struct dirent *ent;
227 int n_dirs, i;
228
229 /* List files, sorted by alpha */
230 n_dirs = scandirat(dir_fd, ".", &entlist, NULL, alphasort);
231 if (n_dirs == -1)
232 return;
233 for (i = 0; i < n_dirs && (ent = entlist[i]); i++) {
234 int fd;
235
236 if (ent->d_name[0] == '.')
237 continue; /* Skip hidden files */
238 if (is_test_script(dir_fd, ent->d_name)) { /* It's a test */
239 char *desc = shell_test__description(dir_fd, ent->d_name);
240
241 if (desc) /* It has a desc line - valid script */
242 append_script(dir_fd, ent->d_name, desc, result, result_sz);
243 continue;
244 }
245 if (ent->d_type != DT_DIR) {
246 struct stat st;
247
248 if (ent->d_type != DT_UNKNOWN)
249 continue;
250 fstatat(dir_fd, ent->d_name, &st, 0);
251 if (!S_ISDIR(st.st_mode))
252 continue;
253 }
254 if (strncmp(ent->d_name, "base_", 5) == 0)
255 continue; /* Skip scripts that have a separate driver. */
256 fd = openat(dir_fd, ent->d_name, O_PATH);
257 append_scripts_in_dir(fd, result, result_sz);
258 }
259 for (i = 0; i < n_dirs; i++) /* Clean up */
260 zfree(&entlist[i]);
261 free(entlist);
262 }
263
create_script_test_suites(void)264 struct test_suite **create_script_test_suites(void)
265 {
266 struct test_suite **result = NULL, **result_tmp;
267 size_t result_sz = 0;
268 int dir_fd = shell_tests__dir_fd(); /* Walk dir */
269
270 /*
271 * Append scripts if fd is good, otherwise return a NULL terminated zero
272 * length array.
273 */
274 if (dir_fd >= 0)
275 append_scripts_in_dir(dir_fd, &result, &result_sz);
276
277 result_tmp = realloc(result, (result_sz + 1) * sizeof(*result_tmp));
278 if (result_tmp == NULL) {
279 pr_err("Out of memory while building script test suite list\n");
280 abort();
281 }
282 /* NULL terminate the test suite array. */
283 result = result_tmp;
284 result[result_sz] = NULL;
285 if (dir_fd >= 0)
286 close(dir_fd);
287 return result;
288 }
289