1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * builtin-buildid-cache.c 4 * 5 * Builtin buildid-cache command: Manages build-id cache 6 * 7 * Copyright (C) 2010, Red Hat Inc. 8 * Copyright (C) 2010, Arnaldo Carvalho de Melo <acme@redhat.com> 9 */ 10 #include <sys/types.h> 11 #include <sys/time.h> 12 #include <time.h> 13 #include <dirent.h> 14 #include <errno.h> 15 #include <unistd.h> 16 #include "builtin.h" 17 #include "perf.h" 18 #include "namespaces.h" 19 #include "util/cache.h" 20 #include "util/debug.h" 21 #include "util/header.h" 22 #include <subcmd/parse-options.h> 23 #include "util/strlist.h" 24 #include "util/build-id.h" 25 #include "util/session.h" 26 #include "util/symbol.h" 27 #include "util/time-utils.h" 28 29 static int build_id_cache__kcore_buildid(const char *proc_dir, char *sbuildid) 30 { 31 char root_dir[PATH_MAX]; 32 char *p; 33 34 strlcpy(root_dir, proc_dir, sizeof(root_dir)); 35 36 p = strrchr(root_dir, '/'); 37 if (!p) 38 return -1; 39 *p = '\0'; 40 return sysfs__sprintf_build_id(root_dir, sbuildid); 41 } 42 43 static int build_id_cache__kcore_dir(char *dir, size_t sz) 44 { 45 return fetch_current_timestamp(dir, sz); 46 } 47 48 static bool same_kallsyms_reloc(const char *from_dir, char *to_dir) 49 { 50 char from[PATH_MAX]; 51 char to[PATH_MAX]; 52 const char *name; 53 u64 addr1 = 0, addr2 = 0; 54 int i, err = -1; 55 56 scnprintf(from, sizeof(from), "%s/kallsyms", from_dir); 57 scnprintf(to, sizeof(to), "%s/kallsyms", to_dir); 58 59 for (i = 0; (name = ref_reloc_sym_names[i]) != NULL; i++) { 60 err = kallsyms__get_function_start(from, name, &addr1); 61 if (!err) 62 break; 63 } 64 65 if (err) 66 return false; 67 68 if (kallsyms__get_function_start(to, name, &addr2)) 69 return false; 70 71 return addr1 == addr2; 72 } 73 74 static int build_id_cache__kcore_existing(const char *from_dir, char *to_dir, 75 size_t to_dir_sz) 76 { 77 char from[PATH_MAX]; 78 char to[PATH_MAX]; 79 char to_subdir[PATH_MAX]; 80 struct dirent *dent; 81 int ret = -1; 82 DIR *d; 83 84 d = opendir(to_dir); 85 if (!d) 86 return -1; 87 88 scnprintf(from, sizeof(from), "%s/modules", from_dir); 89 90 while (1) { 91 dent = readdir(d); 92 if (!dent) 93 break; 94 if (dent->d_type != DT_DIR) 95 continue; 96 scnprintf(to, sizeof(to), "%s/%s/modules", to_dir, 97 dent->d_name); 98 scnprintf(to_subdir, sizeof(to_subdir), "%s/%s", 99 to_dir, dent->d_name); 100 if (!compare_proc_modules(from, to) && 101 same_kallsyms_reloc(from_dir, to_subdir)) { 102 strlcpy(to_dir, to_subdir, to_dir_sz); 103 ret = 0; 104 break; 105 } 106 } 107 108 closedir(d); 109 110 return ret; 111 } 112 113 static int build_id_cache__add_kcore(const char *filename, bool force) 114 { 115 char dir[32], sbuildid[SBUILD_ID_SIZE]; 116 char from_dir[PATH_MAX], to_dir[PATH_MAX]; 117 char *p; 118 119 strlcpy(from_dir, filename, sizeof(from_dir)); 120 121 p = strrchr(from_dir, '/'); 122 if (!p || strcmp(p + 1, "kcore")) 123 return -1; 124 *p = '\0'; 125 126 if (build_id_cache__kcore_buildid(from_dir, sbuildid) < 0) 127 return -1; 128 129 scnprintf(to_dir, sizeof(to_dir), "%s/%s/%s", 130 buildid_dir, DSO__NAME_KCORE, sbuildid); 131 132 if (!force && 133 !build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) { 134 pr_debug("same kcore found in %s\n", to_dir); 135 return 0; 136 } 137 138 if (build_id_cache__kcore_dir(dir, sizeof(dir))) 139 return -1; 140 141 scnprintf(to_dir, sizeof(to_dir), "%s/%s/%s/%s", 142 buildid_dir, DSO__NAME_KCORE, sbuildid, dir); 143 144 if (mkdir_p(to_dir, 0755)) 145 return -1; 146 147 if (kcore_copy(from_dir, to_dir)) { 148 /* Remove YYYYmmddHHMMSShh directory */ 149 if (!rmdir(to_dir)) { 150 p = strrchr(to_dir, '/'); 151 if (p) 152 *p = '\0'; 153 /* Try to remove buildid directory */ 154 if (!rmdir(to_dir)) { 155 p = strrchr(to_dir, '/'); 156 if (p) 157 *p = '\0'; 158 /* Try to remove [kernel.kcore] directory */ 159 rmdir(to_dir); 160 } 161 } 162 return -1; 163 } 164 165 pr_debug("kcore added to build-id cache directory %s\n", to_dir); 166 167 return 0; 168 } 169 170 static int build_id_cache__add_file(const char *filename, struct nsinfo *nsi) 171 { 172 char sbuild_id[SBUILD_ID_SIZE]; 173 u8 build_id[BUILD_ID_SIZE]; 174 int err; 175 struct nscookie nsc; 176 177 nsinfo__mountns_enter(nsi, &nsc); 178 err = filename__read_build_id(filename, &build_id, sizeof(build_id)); 179 nsinfo__mountns_exit(&nsc); 180 if (err < 0) { 181 pr_debug("Couldn't read a build-id in %s\n", filename); 182 return -1; 183 } 184 185 build_id__sprintf(build_id, sizeof(build_id), sbuild_id); 186 err = build_id_cache__add_s(sbuild_id, filename, nsi, 187 false, false); 188 pr_debug("Adding %s %s: %s\n", sbuild_id, filename, 189 err ? "FAIL" : "Ok"); 190 return err; 191 } 192 193 static int build_id_cache__remove_file(const char *filename, struct nsinfo *nsi) 194 { 195 u8 build_id[BUILD_ID_SIZE]; 196 char sbuild_id[SBUILD_ID_SIZE]; 197 struct nscookie nsc; 198 199 int err; 200 201 nsinfo__mountns_enter(nsi, &nsc); 202 err = filename__read_build_id(filename, &build_id, sizeof(build_id)); 203 nsinfo__mountns_exit(&nsc); 204 if (err < 0) { 205 pr_debug("Couldn't read a build-id in %s\n", filename); 206 return -1; 207 } 208 209 build_id__sprintf(build_id, sizeof(build_id), sbuild_id); 210 err = build_id_cache__remove_s(sbuild_id); 211 pr_debug("Removing %s %s: %s\n", sbuild_id, filename, 212 err ? "FAIL" : "Ok"); 213 214 return err; 215 } 216 217 static int build_id_cache__purge_path(const char *pathname, struct nsinfo *nsi) 218 { 219 struct strlist *list; 220 struct str_node *pos; 221 int err; 222 223 err = build_id_cache__list_build_ids(pathname, nsi, &list); 224 if (err) 225 goto out; 226 227 strlist__for_each_entry(pos, list) { 228 err = build_id_cache__remove_s(pos->s); 229 pr_debug("Removing %s %s: %s\n", pos->s, pathname, 230 err ? "FAIL" : "Ok"); 231 if (err) 232 break; 233 } 234 strlist__delete(list); 235 236 out: 237 pr_debug("Purging %s: %s\n", pathname, err ? "FAIL" : "Ok"); 238 239 return err; 240 } 241 242 static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused) 243 { 244 char filename[PATH_MAX]; 245 u8 build_id[BUILD_ID_SIZE]; 246 247 if (dso__build_id_filename(dso, filename, sizeof(filename), false) && 248 filename__read_build_id(filename, build_id, 249 sizeof(build_id)) != sizeof(build_id)) { 250 if (errno == ENOENT) 251 return false; 252 253 pr_warning("Problems with %s file, consider removing it from the cache\n", 254 filename); 255 } else if (memcmp(dso->build_id, build_id, sizeof(dso->build_id))) { 256 pr_warning("Problems with %s file, consider removing it from the cache\n", 257 filename); 258 } 259 260 return true; 261 } 262 263 static int build_id_cache__fprintf_missing(struct perf_session *session, FILE *fp) 264 { 265 perf_session__fprintf_dsos_buildid(session, fp, dso__missing_buildid_cache, 0); 266 return 0; 267 } 268 269 static int build_id_cache__update_file(const char *filename, struct nsinfo *nsi) 270 { 271 u8 build_id[BUILD_ID_SIZE]; 272 char sbuild_id[SBUILD_ID_SIZE]; 273 struct nscookie nsc; 274 275 int err; 276 277 nsinfo__mountns_enter(nsi, &nsc); 278 err = filename__read_build_id(filename, &build_id, sizeof(build_id)); 279 nsinfo__mountns_exit(&nsc); 280 if (err < 0) { 281 pr_debug("Couldn't read a build-id in %s\n", filename); 282 return -1; 283 } 284 err = 0; 285 286 build_id__sprintf(build_id, sizeof(build_id), sbuild_id); 287 if (build_id_cache__cached(sbuild_id)) 288 err = build_id_cache__remove_s(sbuild_id); 289 290 if (!err) 291 err = build_id_cache__add_s(sbuild_id, filename, nsi, false, 292 false); 293 294 pr_debug("Updating %s %s: %s\n", sbuild_id, filename, 295 err ? "FAIL" : "Ok"); 296 297 return err; 298 } 299 300 int cmd_buildid_cache(int argc, const char **argv) 301 { 302 struct strlist *list; 303 struct str_node *pos; 304 int ret = 0; 305 int ns_id = -1; 306 bool force = false; 307 char const *add_name_list_str = NULL, 308 *remove_name_list_str = NULL, 309 *purge_name_list_str = NULL, 310 *missing_filename = NULL, 311 *update_name_list_str = NULL, 312 *kcore_filename = NULL; 313 char sbuf[STRERR_BUFSIZE]; 314 315 struct perf_data data = { 316 .mode = PERF_DATA_MODE_READ, 317 }; 318 struct perf_session *session = NULL; 319 struct nsinfo *nsi = NULL; 320 321 const struct option buildid_cache_options[] = { 322 OPT_STRING('a', "add", &add_name_list_str, 323 "file list", "file(s) to add"), 324 OPT_STRING('k', "kcore", &kcore_filename, 325 "file", "kcore file to add"), 326 OPT_STRING('r', "remove", &remove_name_list_str, "file list", 327 "file(s) to remove"), 328 OPT_STRING('p', "purge", &purge_name_list_str, "file list", 329 "file(s) to remove (remove old caches too)"), 330 OPT_STRING('M', "missing", &missing_filename, "file", 331 "to find missing build ids in the cache"), 332 OPT_BOOLEAN('f', "force", &force, "don't complain, do it"), 333 OPT_STRING('u', "update", &update_name_list_str, "file list", 334 "file(s) to update"), 335 OPT_INCR('v', "verbose", &verbose, "be more verbose"), 336 OPT_INTEGER(0, "target-ns", &ns_id, "target pid for namespace context"), 337 OPT_END() 338 }; 339 const char * const buildid_cache_usage[] = { 340 "perf buildid-cache [<options>]", 341 NULL 342 }; 343 344 argc = parse_options(argc, argv, buildid_cache_options, 345 buildid_cache_usage, 0); 346 347 if (argc || (!add_name_list_str && !kcore_filename && 348 !remove_name_list_str && !purge_name_list_str && 349 !missing_filename && !update_name_list_str)) 350 usage_with_options(buildid_cache_usage, buildid_cache_options); 351 352 if (ns_id > 0) 353 nsi = nsinfo__new(ns_id); 354 355 if (missing_filename) { 356 data.file.path = missing_filename; 357 data.force = force; 358 359 session = perf_session__new(&data, false, NULL); 360 if (session == NULL) 361 return -1; 362 } 363 364 if (symbol__init(session ? &session->header.env : NULL) < 0) 365 goto out; 366 367 setup_pager(); 368 369 if (add_name_list_str) { 370 list = strlist__new(add_name_list_str, NULL); 371 if (list) { 372 strlist__for_each_entry(pos, list) 373 if (build_id_cache__add_file(pos->s, nsi)) { 374 if (errno == EEXIST) { 375 pr_debug("%s already in the cache\n", 376 pos->s); 377 continue; 378 } 379 pr_warning("Couldn't add %s: %s\n", 380 pos->s, str_error_r(errno, sbuf, sizeof(sbuf))); 381 } 382 383 strlist__delete(list); 384 } 385 } 386 387 if (remove_name_list_str) { 388 list = strlist__new(remove_name_list_str, NULL); 389 if (list) { 390 strlist__for_each_entry(pos, list) 391 if (build_id_cache__remove_file(pos->s, nsi)) { 392 if (errno == ENOENT) { 393 pr_debug("%s wasn't in the cache\n", 394 pos->s); 395 continue; 396 } 397 pr_warning("Couldn't remove %s: %s\n", 398 pos->s, str_error_r(errno, sbuf, sizeof(sbuf))); 399 } 400 401 strlist__delete(list); 402 } 403 } 404 405 if (purge_name_list_str) { 406 list = strlist__new(purge_name_list_str, NULL); 407 if (list) { 408 strlist__for_each_entry(pos, list) 409 if (build_id_cache__purge_path(pos->s, nsi)) { 410 if (errno == ENOENT) { 411 pr_debug("%s wasn't in the cache\n", 412 pos->s); 413 continue; 414 } 415 pr_warning("Couldn't remove %s: %s\n", 416 pos->s, str_error_r(errno, sbuf, sizeof(sbuf))); 417 } 418 419 strlist__delete(list); 420 } 421 } 422 423 if (missing_filename) 424 ret = build_id_cache__fprintf_missing(session, stdout); 425 426 if (update_name_list_str) { 427 list = strlist__new(update_name_list_str, NULL); 428 if (list) { 429 strlist__for_each_entry(pos, list) 430 if (build_id_cache__update_file(pos->s, nsi)) { 431 if (errno == ENOENT) { 432 pr_debug("%s wasn't in the cache\n", 433 pos->s); 434 continue; 435 } 436 pr_warning("Couldn't update %s: %s\n", 437 pos->s, str_error_r(errno, sbuf, sizeof(sbuf))); 438 } 439 440 strlist__delete(list); 441 } 442 } 443 444 if (kcore_filename && build_id_cache__add_kcore(kcore_filename, force)) 445 pr_warning("Couldn't add %s\n", kcore_filename); 446 447 out: 448 perf_session__delete(session); 449 nsinfo__zput(nsi); 450 451 return ret; 452 } 453