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