tools/perf/builtin-buildid-cache.c

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