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 <unistd.h> 22 #include "cap.h" 23 #include "strlist.h" 24 #include "string2.h" 25 26 /* 27 * XXX We need to find a better place for these things... 28 */ 29 30 bool perf_singlethreaded = true; 31 32 void perf_set_singlethreaded(void) 33 { 34 perf_singlethreaded = true; 35 } 36 37 void perf_set_multithreaded(void) 38 { 39 perf_singlethreaded = false; 40 } 41 42 int sysctl_perf_event_max_stack = PERF_MAX_STACK_DEPTH; 43 int sysctl_perf_event_max_contexts_per_stack = PERF_MAX_CONTEXTS_PER_STACK; 44 45 int sysctl__max_stack(void) 46 { 47 int value; 48 49 if (sysctl__read_int("kernel/perf_event_max_stack", &value) == 0) 50 sysctl_perf_event_max_stack = value; 51 52 if (sysctl__read_int("kernel/perf_event_max_contexts_per_stack", &value) == 0) 53 sysctl_perf_event_max_contexts_per_stack = value; 54 55 return sysctl_perf_event_max_stack; 56 } 57 58 bool test_attr__enabled; 59 60 bool perf_host = true; 61 bool perf_guest = false; 62 63 void event_attr_init(struct perf_event_attr *attr) 64 { 65 if (!perf_host) 66 attr->exclude_host = 1; 67 if (!perf_guest) 68 attr->exclude_guest = 1; 69 /* to capture ABI version */ 70 attr->size = sizeof(*attr); 71 } 72 73 int mkdir_p(char *path, mode_t mode) 74 { 75 struct stat st; 76 int err; 77 char *d = path; 78 79 if (*d != '/') 80 return -1; 81 82 if (stat(path, &st) == 0) 83 return 0; 84 85 while (*++d == '/'); 86 87 while ((d = strchr(d, '/'))) { 88 *d = '\0'; 89 err = stat(path, &st) && mkdir(path, mode); 90 *d++ = '/'; 91 if (err) 92 return -1; 93 while (*d == '/') 94 ++d; 95 } 96 return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0; 97 } 98 99 static bool match_pat(char *file, const char **pat) 100 { 101 int i = 0; 102 103 if (!pat) 104 return true; 105 106 while (pat[i]) { 107 if (strglobmatch(file, pat[i])) 108 return true; 109 110 i++; 111 } 112 113 return false; 114 } 115 116 /* 117 * The depth specify how deep the removal will go. 118 * 0 - will remove only files under the 'path' directory 119 * 1 .. x - will dive in x-level deep under the 'path' directory 120 * 121 * If specified the pat is array of string patterns ended with NULL, 122 * which are checked upon every file/directory found. Only matching 123 * ones are removed. 124 * 125 * The function returns: 126 * 0 on success 127 * -1 on removal failure with errno set 128 * -2 on pattern failure 129 */ 130 static int rm_rf_depth_pat(const char *path, int depth, const char **pat) 131 { 132 DIR *dir; 133 int ret; 134 struct dirent *d; 135 char namebuf[PATH_MAX]; 136 struct stat statbuf; 137 138 /* Do not fail if there's no file. */ 139 ret = lstat(path, &statbuf); 140 if (ret) 141 return 0; 142 143 /* Try to remove any file we get. */ 144 if (!(statbuf.st_mode & S_IFDIR)) 145 return unlink(path); 146 147 /* We have directory in path. */ 148 dir = opendir(path); 149 if (dir == NULL) 150 return -1; 151 152 while ((d = readdir(dir)) != NULL && !ret) { 153 154 if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, "..")) 155 continue; 156 157 if (!match_pat(d->d_name, pat)) { 158 ret = -2; 159 break; 160 } 161 162 scnprintf(namebuf, sizeof(namebuf), "%s/%s", 163 path, d->d_name); 164 165 /* We have to check symbolic link itself */ 166 ret = lstat(namebuf, &statbuf); 167 if (ret < 0) { 168 pr_debug("stat failed: %s\n", namebuf); 169 break; 170 } 171 172 if (S_ISDIR(statbuf.st_mode)) 173 ret = depth ? rm_rf_depth_pat(namebuf, depth - 1, pat) : 0; 174 else 175 ret = unlink(namebuf); 176 } 177 closedir(dir); 178 179 if (ret < 0) 180 return ret; 181 182 return rmdir(path); 183 } 184 185 static int rm_rf_kcore_dir(const char *path) 186 { 187 char kcore_dir_path[PATH_MAX]; 188 const char *pat[] = { 189 "kcore", 190 "kallsyms", 191 "modules", 192 NULL, 193 }; 194 195 snprintf(kcore_dir_path, sizeof(kcore_dir_path), "%s/kcore_dir", path); 196 197 return rm_rf_depth_pat(kcore_dir_path, 0, pat); 198 } 199 200 int rm_rf_perf_data(const char *path) 201 { 202 const char *pat[] = { 203 "data", 204 "data.*", 205 NULL, 206 }; 207 208 rm_rf_kcore_dir(path); 209 210 return rm_rf_depth_pat(path, 0, pat); 211 } 212 213 int rm_rf(const char *path) 214 { 215 return rm_rf_depth_pat(path, INT_MAX, NULL); 216 } 217 218 /* A filter which removes dot files */ 219 bool lsdir_no_dot_filter(const char *name __maybe_unused, struct dirent *d) 220 { 221 return d->d_name[0] != '.'; 222 } 223 224 /* lsdir reads a directory and store it in strlist */ 225 struct strlist *lsdir(const char *name, 226 bool (*filter)(const char *, struct dirent *)) 227 { 228 struct strlist *list = NULL; 229 DIR *dir; 230 struct dirent *d; 231 232 dir = opendir(name); 233 if (!dir) 234 return NULL; 235 236 list = strlist__new(NULL, NULL); 237 if (!list) { 238 errno = ENOMEM; 239 goto out; 240 } 241 242 while ((d = readdir(dir)) != NULL) { 243 if (!filter || filter(name, d)) 244 strlist__add(list, d->d_name); 245 } 246 247 out: 248 closedir(dir); 249 return list; 250 } 251 252 size_t hex_width(u64 v) 253 { 254 size_t n = 1; 255 256 while ((v >>= 4)) 257 ++n; 258 259 return n; 260 } 261 262 int perf_event_paranoid(void) 263 { 264 int value; 265 266 if (sysctl__read_int("kernel/perf_event_paranoid", &value)) 267 return INT_MAX; 268 269 return value; 270 } 271 272 bool perf_event_paranoid_check(int max_level) 273 { 274 return perf_cap__capable(CAP_SYS_ADMIN) || 275 perf_event_paranoid() <= max_level; 276 } 277 278 static int 279 fetch_ubuntu_kernel_version(unsigned int *puint) 280 { 281 ssize_t len; 282 size_t line_len = 0; 283 char *ptr, *line = NULL; 284 int version, patchlevel, sublevel, err; 285 FILE *vsig; 286 287 if (!puint) 288 return 0; 289 290 vsig = fopen("/proc/version_signature", "r"); 291 if (!vsig) { 292 pr_debug("Open /proc/version_signature failed: %s\n", 293 strerror(errno)); 294 return -1; 295 } 296 297 len = getline(&line, &line_len, vsig); 298 fclose(vsig); 299 err = -1; 300 if (len <= 0) { 301 pr_debug("Reading from /proc/version_signature failed: %s\n", 302 strerror(errno)); 303 goto errout; 304 } 305 306 ptr = strrchr(line, ' '); 307 if (!ptr) { 308 pr_debug("Parsing /proc/version_signature failed: %s\n", line); 309 goto errout; 310 } 311 312 err = sscanf(ptr + 1, "%d.%d.%d", 313 &version, &patchlevel, &sublevel); 314 if (err != 3) { 315 pr_debug("Unable to get kernel version from /proc/version_signature '%s'\n", 316 line); 317 goto errout; 318 } 319 320 *puint = (version << 16) + (patchlevel << 8) + sublevel; 321 err = 0; 322 errout: 323 free(line); 324 return err; 325 } 326 327 int 328 fetch_kernel_version(unsigned int *puint, char *str, 329 size_t str_size) 330 { 331 struct utsname utsname; 332 int version, patchlevel, sublevel, err; 333 bool int_ver_ready = false; 334 335 if (access("/proc/version_signature", R_OK) == 0) 336 if (!fetch_ubuntu_kernel_version(puint)) 337 int_ver_ready = true; 338 339 if (uname(&utsname)) 340 return -1; 341 342 if (str && str_size) { 343 strncpy(str, utsname.release, str_size); 344 str[str_size - 1] = '\0'; 345 } 346 347 if (!puint || int_ver_ready) 348 return 0; 349 350 err = sscanf(utsname.release, "%d.%d.%d", 351 &version, &patchlevel, &sublevel); 352 353 if (err != 3) { 354 pr_debug("Unable to get kernel version from uname '%s'\n", 355 utsname.release); 356 return -1; 357 } 358 359 *puint = (version << 16) + (patchlevel << 8) + sublevel; 360 return 0; 361 } 362 363 const char *perf_tip(const char *dirpath) 364 { 365 struct strlist *tips; 366 struct str_node *node; 367 char *tip = NULL; 368 struct strlist_config conf = { 369 .dirname = dirpath, 370 .file_only = true, 371 }; 372 373 tips = strlist__new("tips.txt", &conf); 374 if (tips == NULL) 375 return errno == ENOENT ? NULL : 376 "Tip: check path of tips.txt or get more memory! ;-p"; 377 378 if (strlist__nr_entries(tips) == 0) 379 goto out; 380 381 node = strlist__entry(tips, random() % strlist__nr_entries(tips)); 382 if (asprintf(&tip, "Tip: %s", node->s) < 0) 383 tip = (char *)"Tip: get more memory! ;-)"; 384 385 out: 386 strlist__delete(tips); 387 388 return tip; 389 } 390 391 char *perf_exe(char *buf, int len) 392 { 393 int n = readlink("/proc/self/exe", buf, len); 394 if (n > 0) { 395 buf[n] = 0; 396 return buf; 397 } 398 return strcpy(buf, "perf"); 399 } 400