tools/perf/tests/builtin-test-list.c

   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
  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
  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 */
  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) */
 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 */
 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
 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
 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
 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
 203 int list_script_max_width(void)
 204 {
 205         list_script_files(); /* Ensure we have scanned all scripts */
 206         return files_max_width;
 207 }