tools/perf/util/util.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "util.h"
   3 #include "debug.h"
   4 #include "event.h"
   5 #include <api/fs/fs.h>
   6 #include <sys/stat.h>
   7 #include <sys/utsname.h>
   8 #include <dirent.h>
   9 #include <fcntl.h>
  10 #include <inttypes.h>
  11 #include <signal.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <errno.h>
  16 #include <limits.h>
  17 #include <linux/capability.h>
  18 #include <linux/kernel.h>
  19 #include <linux/log2.h>
  20 #include <linux/time64.h>
  21 #include <linux/overflow.h>
  22 #include <unistd.h>
  23 #include "cap.h"
  24 #include "strlist.h"
  25 #include "string2.h"
  26
  27 /*
  28  * XXX We need to find a better place for these things...
  29  */
  30
  31 const char *input_name;
  32
  33 bool perf_singlethreaded = true;
  34
  35 void perf_set_singlethreaded(void)
  36 {
  37         perf_singlethreaded = true;
  38 }
  39
  40 void perf_set_multithreaded(void)
  41 {
  42         perf_singlethreaded = false;
  43 }
  44
  45 int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH;
  46 int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK;
  47
  48 int sysctl__max_stack(void)
  49 {
  50         int value;
  51
  52         if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0)
  53                 sysctl_perf_event_max_stack = value;
  54
  55         if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0)
  56                 sysctl_perf_event_max_contexts_per_stack = value;
  57
  58         return sysctl_perf_event_max_stack;
  59 }
  60
  61 bool sysctl__nmi_watchdog_enabled(void)
  62 {
  63         static bool cached;
  64         static bool nmi_watchdog;
  65         int value;
  66
  67         if (cached)
  68                 return nmi_watchdog;
  69
  70         if (sysctl__read_int("kernel/nmi_watchdog", &value) < 0)
  71                 return false;
  72
  73         nmi_watchdog = (value > 0) ? true : false;
  74         cached = true;
  75
  76         return nmi_watchdog;
  77 }
  78
  79 bool test_attr__enabled;
  80
  81 bool perf_host  = true;
  82 bool perf_guest = false;
  83
  84 void event_attr_init(struct perf_event_attr *attr)
  85 {
  86         if (!perf_host)
  87                 attr->exclude_host  = 1;
  88         if (!perf_guest)
  89                 attr->exclude_guest = 1;
  90         /* to capture ABI version */
  91         attr->size = sizeof(*attr);
  92 }
  93
  94 int mkdir_p(char *path, mode_t mode)
  95 {
  96         struct stat st;
  97         int err;
  98         char *d = path;
  99
 100         if (*d != '/')
 101                 return -1;
 102
 103         if (stat(path, &st) == 0)
 104                 return 0;
 105
 106         while (*++d == '/');
 107
 108         while ((d = strchr(d, '/'))) {
 109                 *d = '\0';
 110                 err = stat(path, &st) && mkdir(path, mode);
 111                 *d++ = '/';
 112                 if (err)
 113                         return -1;
 114                 while (*d == '/')
 115                         ++d;
 116         }
 117         return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
 118 }
 119
 120 static bool match_pat(char *file, const char **pat)
 121 {
 122         int i = 0;
 123
 124         if (!pat)
 125                 return true;
 126
 127         while (pat[i]) {
 128                 if (strglobmatch(file, pat[i]))
 129                         return true;
 130
 131                 i++;
 132         }
 133
 134         return false;
 135 }
 136
 137 /*
 138  * The depth specify how deep the removal will go.
 139  * 0       - will remove only files under the 'path' directory
 140  * 1 .. x  - will dive in x-level deep under the 'path' directory
 141  *
 142  * If specified the pat is array of string patterns ended with NULL,
 143  * which are checked upon every file/directory found. Only matching
 144  * ones are removed.
 145  *
 146  * The function returns:
 147  *    0 on success
 148  *   -1 on removal failure with errno set
 149  *   -2 on pattern failure
 150  */
 151 static int rm_rf_depth_pat(const char *path, int depth, const char **pat)
 152 {
 153         DIR *dir;
 154         int ret;
 155         struct dirent *d;
 156         char namebuf[PATH_MAX];
 157         struct stat statbuf;
 158
 159         /* Do not fail if there's no file. */
 160         ret = lstat(path, &statbuf);
 161         if (ret)
 162                 return 0;
 163
 164         /* Try to remove any file we get. */
 165         if (!(statbuf.st_mode & S_IFDIR))
 166                 return unlink(path);
 167
 168         /* We have directory in path. */
 169         dir = opendir(path);
 170         if (dir == NULL)
 171                 return -1;
 172
 173         while ((d = readdir(dir)) != NULL && !ret) {
 174
 175                 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
 176                         continue;
 177
 178                 if (!match_pat(d->d_name, pat)) {
 179                         ret =  -2;
 180                         break;
 181                 }
 182
 183                 scnprintf(namebuf, sizeof(namebuf), "%s/%s",
 184                           path, d->d_name);
 185
 186                 /* We have to check symbolic link itself */
 187                 ret = lstat(namebuf, &statbuf);
 188                 if (ret < 0) {
 189                         pr_debug("stat failed: %s\n", namebuf);
 190                         break;
 191                 }
 192
 193                 if (S_ISDIR(statbuf.st_mode))
 194                         ret = depth ? rm_rf_depth_pat(namebuf, depth - 1, pat) : 0;
 195                 else
 196                         ret = unlink(namebuf);
 197         }
 198         closedir(dir);
 199
 200         if (ret < 0)
 201                 return ret;
 202
 203         return rmdir(path);
 204 }
 205
 206 static int rm_rf_a_kcore_dir(const char *path, const char *name)
 207 {
 208         char kcore_dir_path[PATH_MAX];
 209         const char *pat[] = {
 210                 "kcore",
 211                 "kallsyms",
 212                 "modules",
 213                 NULL,
 214         };
 215
 216         snprintf(kcore_dir_path, sizeof(kcore_dir_path), "%s/%s", path, name);
 217
 218         return rm_rf_depth_pat(kcore_dir_path, 0, pat);
 219 }
 220
 221 static bool kcore_dir_filter(const char *name __maybe_unused, struct dirent *d)
 222 {
 223         const char *pat[] = {
 224                 "kcore_dir",
 225                 "kcore_dir__[1-9]*",
 226                 NULL,
 227         };
 228
 229         return match_pat(d->d_name, pat);
 230 }
 231
 232 static int rm_rf_kcore_dir(const char *path)
 233 {
 234         struct strlist *kcore_dirs;
 235         struct str_node *nd;
 236         int ret;
 237
 238         kcore_dirs = lsdir(path, kcore_dir_filter);
 239
 240         if (!kcore_dirs)
 241                 return 0;
 242
 243         strlist__for_each_entry(nd, kcore_dirs) {
 244                 ret = rm_rf_a_kcore_dir(path, nd->s);
 245                 if (ret)
 246                         return ret;
 247         }
 248
 249         strlist__delete(kcore_dirs);
 250
 251         return 0;
 252 }
 253
 254 int rm_rf_perf_data(const char *path)
 255 {
 256         const char *pat[] = {
 257                 "data",
 258                 "data.*",
 259                 NULL,
 260         };
 261
 262         rm_rf_kcore_dir(path);
 263
 264         return rm_rf_depth_pat(path, 0, pat);
 265 }
 266
 267 int rm_rf(const char *path)
 268 {
 269         return rm_rf_depth_pat(path, INT_MAX, NULL);
 270 }
 271
 272 /* A filter which removes dot files */
 273 bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d)
 274 {
 275         return d->d_name[0] != '.';
 276 }
 277
 278 /* lsdir reads a directory and store it in strlist */
 279 struct strlist *lsdir(const char *name,
 280                       bool (*filter)(const char *, struct dirent *))
 281 {
 282         struct strlist *list = NULL;
 283         DIR *dir;
 284         struct dirent *d;
 285
 286         dir = opendir(name);
 287         if (!dir)
 288                 return NULL;
 289
 290         list = strlist__new(NULL, NULL);
 291         if (!list) {
 292                 errno = ENOMEM;
 293                 goto out;
 294         }
 295
 296         while ((d = readdir(dir)) != NULL) {
 297                 if (!filter || filter(name, d))
 298                         strlist__add(list, d->d_name);
 299         }
 300
 301 out:
 302         closedir(dir);
 303         return list;
 304 }
 305
 306 size_t hex_width(u64 v)
 307 {
 308         size_t n = 1;
 309
 310         while ((v >>= 4))
 311                 ++n;
 312
 313         return n;
 314 }
 315
 316 int perf_event_paranoid(void)
 317 {
 318         int value;
 319
 320         if (sysctl__read_int("kernel/perf_event_paranoid", &value))
 321                 return INT_MAX;
 322
 323         return value;
 324 }
 325
 326 bool perf_event_paranoid_check(int max_level)
 327 {
 328         return perf_cap__capable(CAP_SYS_ADMIN) ||
 329                         perf_cap__capable(CAP_PERFMON) ||
 330                         perf_event_paranoid() <= max_level;
 331 }
 332
 333 static int
 334 fetch_ubuntu_kernel_version(unsigned int *puint)
 335 {
 336         ssize_t len;
 337         size_t line_len = 0;
 338         char *ptr, *line = NULL;
 339         int version, patchlevel, sublevel, err;
 340         FILE *vsig;
 341
 342         if (!puint)
 343                 return 0;
 344
 345         vsig = fopen("/proc/version_signature", "r");
 346         if (!vsig) {
 347                 pr_debug("Open /proc/version_signature failed: %s\n",
 348                          strerror(errno));
 349                 return -1;
 350         }
 351
 352         len = getline(&line, &line_len, vsig);
 353         fclose(vsig);
 354         err = -1;
 355         if (len <= 0) {
 356                 pr_debug("Reading from /proc/version_signature failed: %s\n",
 357                          strerror(errno));
 358                 goto errout;
 359         }
 360
 361         ptr = strrchr(line, ' ');
 362         if (!ptr) {
 363                 pr_debug("Parsing /proc/version_signature failed: %s\n", line);
 364                 goto errout;
 365         }
 366
 367         err = sscanf(ptr + 1, "%d.%d.%d",
 368                      &version, &patchlevel, &sublevel);
 369         if (err != 3) {
 370                 pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n",
 371                          line);
 372                 goto errout;
 373         }
 374
 375         *puint = (version << 16) + (patchlevel << 8) + sublevel;
 376         err = 0;
 377 errout:
 378         free(line);
 379         return err;
 380 }
 381
 382 int
 383 fetch_kernel_version(unsigned int *puint, char *str,
 384                      size_t str_size)
 385 {
 386         struct utsname utsname;
 387         int version, patchlevel, sublevel, err;
 388         bool int_ver_ready = false;
 389
 390         if (access("/proc/version_signature", R_OK) == 0)
 391                 if (!fetch_ubuntu_kernel_version(puint))
 392                         int_ver_ready = true;
 393
 394         if (uname(&utsname))
 395                 return -1;
 396
 397         if (str && str_size) {
 398                 strncpy(str, utsname.release, str_size);
 399                 str[str_size - 1] = '\0';
 400         }
 401
 402         if (!puint || int_ver_ready)
 403                 return 0;
 404
 405         err = sscanf(utsname.release, "%d.%d.%d",
 406                      &version, &patchlevel, &sublevel);
 407
 408         if (err != 3) {
 409                 pr_debug("Unable to get kernel version from uname '%s'\n",
 410                          utsname.release);
 411                 return -1;
 412         }
 413
 414         *puint = (version << 16) + (patchlevel << 8) + sublevel;
 415         return 0;
 416 }
 417
 418 int perf_tip(char **strp, const char *dirpath)
 419 {
 420         struct strlist *tips;
 421         struct str_node *node;
 422         struct strlist_config conf = {
 423                 .dirname = dirpath,
 424                 .file_only = true,
 425         };
 426         int ret = 0;
 427
 428         *strp = NULL;
 429         tips = strlist__new("tips.txt", &conf);
 430         if (tips == NULL)
 431                 return -errno;
 432
 433         if (strlist__nr_entries(tips) == 0)
 434                 goto out;
 435
 436         node = strlist__entry(tips, random() % strlist__nr_entries(tips));
 437         if (asprintf(strp, "Tip: %s", node->s) < 0)
 438                 ret = -ENOMEM;
 439
 440 out:
 441         strlist__delete(tips);
 442
 443         return ret;
 444 }
 445
 446 char *perf_exe(char *buf, int len)
 447 {
 448         int n = readlink("/proc/self/exe", buf, len);
 449         if (n > 0) {
 450                 buf[n] = 0;
 451                 return buf;
 452         }
 453         return strcpy(buf, "perf");
 454 }
 455
 456 void perf_debuginfod_setup(struct perf_debuginfod *di)
 457 {
 458         /*
 459          * By default '!di->set' we clear DEBUGINFOD_URLS, so debuginfod
 460          * processing is not triggered, otherwise we set it to 'di->urls'
 461          * value. If 'di->urls' is "system" we keep DEBUGINFOD_URLS value.
 462          */
 463         if (!di->set)
 464                 setenv("DEBUGINFOD_URLS", "", 1);
 465         else if (di->urls && strcmp(di->urls, "system"))
 466                 setenv("DEBUGINFOD_URLS", di->urls, 1);
 467
 468         pr_debug("DEBUGINFOD_URLS=%s\n", getenv("DEBUGINFOD_URLS"));
 469
 470 #ifndef HAVE_DEBUGINFOD_SUPPORT
 471         if (di->set)
 472                 pr_warning("WARNING: debuginfod support requested, but perf is not built with it\n");
 473 #endif
 474 }
 475
 476 /*
 477  * Return a new filename prepended with task's root directory if it's in
 478  * a chroot.  Callers should free the returned string.
 479  */
 480 char *filename_with_chroot(int pid, const char *filename)
 481 {
 482         char buf[PATH_MAX];
 483         char proc_root[32];
 484         char *new_name = NULL;
 485         int ret;
 486
 487         scnprintf(proc_root, sizeof(proc_root), "/proc/%d/root", pid);
 488         ret = readlink(proc_root, buf, sizeof(buf) - 1);
 489         if (ret <= 0)
 490                 return NULL;
 491
 492         /* readlink(2) does not append a null byte to buf */
 493         buf[ret] = '\0';
 494
 495         if (!strcmp(buf, "/"))
 496                 return NULL;
 497
 498         if (strstr(buf, "(deleted)"))
 499                 return NULL;
 500
 501         if (asprintf(&new_name, "%s/%s", buf, filename) < 0)
 502                 return NULL;
 503
 504         return new_name;
 505 }
 506
 507 /*
 508  * Reallocate an array *arr of size *arr_sz so that it is big enough to contain
 509  * x elements of size msz, initializing new entries to *init_val or zero if
 510  * init_val is NULL
 511  */
 512 int do_realloc_array_as_needed(void **arr, size_t *arr_sz, size_t x, size_t msz, const void *init_val)
 513 {
 514         size_t new_sz = *arr_sz;
 515         void *new_arr;
 516         size_t i;
 517
 518         if (!new_sz)
 519                 new_sz = msz >= 64 ? 1 : roundup(64, msz); /* Start with at least 64 bytes */
 520         while (x >= new_sz) {
 521                 if (check_mul_overflow(new_sz, (size_t)2, &new_sz))
 522                         return -ENOMEM;
 523         }
 524         if (new_sz == *arr_sz)
 525                 return 0;
 526         new_arr = calloc(new_sz, msz);
 527         if (!new_arr)
 528                 return -ENOMEM;
 529         if (*arr_sz)
 530                 memcpy(new_arr, *arr, *arr_sz * msz);
 531         if (init_val) {
 532                 for (i = *arr_sz; i < new_sz; i++)
 533                         memcpy(new_arr + (i * msz), init_val, msz);
 534         }
 535         *arr = new_arr;
 536         *arr_sz = new_sz;
 537         return 0;
 538 }
 539
 540 #ifndef HAVE_SCHED_GETCPU_SUPPORT
 541 int sched_getcpu(void)
 542 {
 543 #ifdef __NR_getcpu
 544         unsigned int cpu;
 545         int err = syscall(__NR_getcpu, &cpu, NULL, NULL);
 546
 547         if (!err)
 548                 return cpu;
 549 #else
 550         errno = ENOSYS;
 551 #endif
 552         return -1;
 553 }
 554 #endif