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 "builtin.h"
18 #include "builtin-test-list.h"
19 #include "color.h"
20 #include "debug.h"
21 #include "hist.h"
22 #include "intlist.h"
23 #include "string2.h"
24 #include "symbol.h"
25 #include "tests.h"
26 #include "util/rlimit.h"
27
28
29 /*
30 * As this is a singleton built once for the run of the process, there is
31 * no value in trying to free it and just let it stay around until process
32 * exits when it's cleaned up.
33 */
34 static size_t files_num = 0;
35 static struct script_file *files = NULL;
36 static int files_max_width = 0;
37
shell_tests__dir(char * path,size_t size)38 static const char *shell_tests__dir(char *path, size_t size)
39 {
40 const char *devel_dirs[] = { "./tools/perf/tests", "./tests", };
41 char *exec_path;
42 unsigned int i;
43
44 for (i = 0; i < ARRAY_SIZE(devel_dirs); ++i) {
45 struct stat st;
46
47 if (!lstat(devel_dirs[i], &st)) {
48 scnprintf(path, size, "%s/shell", devel_dirs[i]);
49 if (!lstat(devel_dirs[i], &st))
50 return path;
51 }
52 }
53
54 /* Then installed path. */
55 exec_path = get_argv_exec_path();
56 scnprintf(path, size, "%s/tests/shell", exec_path);
57 free(exec_path);
58 return path;
59 }
60
shell_test__description(char * description,size_t size,const char * path,const char * name)61 static const char *shell_test__description(char *description, size_t size,
62 const char *path, const char *name)
63 {
64 FILE *fp;
65 char filename[PATH_MAX];
66 int ch;
67
68 path__join(filename, sizeof(filename), path, name);
69 fp = fopen(filename, "r");
70 if (!fp)
71 return NULL;
72
73 /* Skip first line - should be #!/bin/sh Shebang */
74 do {
75 ch = fgetc(fp);
76 } while (ch != EOF && ch != '\n');
77
78 description = fgets(description, size, fp);
79 fclose(fp);
80
81 /* Assume first char on line is omment everything after that desc */
82 return description ? strim(description + 1) : NULL;
83 }
84
85 /* Is this full file path a shell script */
is_shell_script(const char * path)86 static bool is_shell_script(const char *path)
87 {
88 const char *ext;
89
90 ext = strrchr(path, '.');
91 if (!ext)
92 return false;
93 if (!strcmp(ext, ".sh")) { /* Has .sh extension */
94 if (access(path, R_OK | X_OK) == 0) /* Is executable */
95 return true;
96 }
97 return false;
98 }
99
100 /* Is this file in this dir a shell script (for test purposes) */
is_test_script(const char * path,const char * name)101 static bool is_test_script(const char *path, const char *name)
102 {
103 char filename[PATH_MAX];
104
105 path__join(filename, sizeof(filename), path, name);
106 if (!is_shell_script(filename)) return false;
107 return true;
108 }
109
110 /* Duplicate a string and fall over and die if we run out of memory */
strdup_check(const char * str)111 static char *strdup_check(const char *str)
112 {
113 char *newstr;
114
115 newstr = strdup(str);
116 if (!newstr) {
117 pr_err("Out of memory while duplicating test script string\n");
118 abort();
119 }
120 return newstr;
121 }
122
append_script(const char * dir,const char * file,const char * desc)123 static void append_script(const char *dir, const char *file, const char *desc)
124 {
125 struct script_file *files_tmp;
126 size_t files_num_tmp;
127 int width;
128
129 files_num_tmp = files_num + 1;
130 if (files_num_tmp >= SIZE_MAX) {
131 pr_err("Too many script files\n");
132 abort();
133 }
134 /* Realloc is good enough, though we could realloc by chunks, not that
135 * anyone will ever measure performance here */
136 files_tmp = realloc(files,
137 (files_num_tmp + 1) * sizeof(struct script_file));
138 if (files_tmp == NULL) {
139 pr_err("Out of memory while building test list\n");
140 abort();
141 }
142 /* Add file to end and NULL terminate the struct array */
143 files = files_tmp;
144 files_num = files_num_tmp;
145 files[files_num - 1].dir = strdup_check(dir);
146 files[files_num - 1].file = strdup_check(file);
147 files[files_num - 1].desc = strdup_check(desc);
148 files[files_num].dir = NULL;
149 files[files_num].file = NULL;
150 files[files_num].desc = NULL;
151
152 width = strlen(desc); /* Track max width of desc */
153 if (width > files_max_width)
154 files_max_width = width;
155 }
156
append_scripts_in_dir(const char * path)157 static void append_scripts_in_dir(const char *path)
158 {
159 struct dirent **entlist;
160 struct dirent *ent;
161 int n_dirs, i;
162 char filename[PATH_MAX];
163
164 /* List files, sorted by alpha */
165 n_dirs = scandir(path, &entlist, NULL, alphasort);
166 if (n_dirs == -1)
167 return;
168 for (i = 0; i < n_dirs && (ent = entlist[i]); i++) {
169 if (ent->d_name[0] == '.')
170 continue; /* Skip hidden files */
171 if (is_test_script(path, ent->d_name)) { /* It's a test */
172 char bf[256];
173 const char *desc = shell_test__description
174 (bf, sizeof(bf), path, ent->d_name);
175
176 if (desc) /* It has a desc line - valid script */
177 append_script(path, ent->d_name, desc);
178 } else if (is_directory(path, ent)) { /* Scan the subdir */
179 path__join(filename, sizeof(filename),
180 path, ent->d_name);
181 append_scripts_in_dir(filename);
182 }
183 }
184 for (i = 0; i < n_dirs; i++) /* Clean up */
185 zfree(&entlist[i]);
186 free(entlist);
187 }
188
list_script_files(void)189 const struct script_file *list_script_files(void)
190 {
191 char path_dir[PATH_MAX];
192 const char *path;
193
194 if (files)
195 return files; /* Singleton - we already know our list */
196
197 path = shell_tests__dir(path_dir, sizeof(path_dir)); /* Walk dir */
198 append_scripts_in_dir(path);
199
200 return files;
201 }
202
list_script_max_width(void)203 int list_script_max_width(void)
204 {
205 list_script_files(); /* Ensure we have scanned all scripts */
206 return files_max_width;
207 }
208