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 int build_id_cache__kcore_existing(const char *from_dir, char *to_dir,
  67                                           size_t to_dir_sz)
  68 {
  69         char from[PATH_MAX];
  70         char to[PATH_MAX];
  71         struct dirent *dent;
  72         int ret = -1;
  73         DIR *d;
  74
  75         d = opendir(to_dir);
  76         if (!d)
  77                 return -1;
  78
  79         scnprintf(from, sizeof(from), "%s/modules", from_dir);
  80
  81         while (1) {
  82                 dent = readdir(d);
  83                 if (!dent)
  84                         break;
  85                 if (dent->d_type != DT_DIR)
  86                         continue;
  87                 scnprintf(to, sizeof(to), "%s/%s/modules", to_dir,
  88                           dent->d_name);
  89                 if (!compare_proc_modules(from, to)) {
  90                         scnprintf(to, sizeof(to), "%s/%s", to_dir,
  91                                   dent->d_name);
  92                         strlcpy(to_dir, to, to_dir_sz);
  93                         ret = 0;
  94                         break;
  95                 }
  96         }
  97
  98         closedir(d);
  99
 100         return ret;
 101 }
 102
 103 static int build_id_cache__add_kcore(const char *filename, const char *debugdir)
 104 {
 105         char dir[32], sbuildid[BUILD_ID_SIZE * 2 + 1];
 106         char from_dir[PATH_MAX], to_dir[PATH_MAX];
 107         char *p;
 108
 109         strlcpy(from_dir, filename, sizeof(from_dir));
 110
 111         p = strrchr(from_dir, '/');
 112         if (!p || strcmp(p + 1, "kcore"))
 113                 return -1;
 114         *p = '\0';
 115
 116         if (build_id_cache__kcore_buildid(from_dir, sbuildid))
 117                 return -1;
 118
 119         scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s",
 120                   debugdir, sbuildid);
 121
 122         if (!build_id_cache__kcore_existing(from_dir, to_dir, sizeof(to_dir))) {
 123                 pr_debug("same kcore found in %s\n", to_dir);
 124                 return 0;
 125         }
 126
 127         if (build_id_cache__kcore_dir(dir, sizeof(dir)))
 128                 return -1;
 129
 130         scnprintf(to_dir, sizeof(to_dir), "%s/[kernel.kcore]/%s/%s",
 131                   debugdir, sbuildid, dir);
 132
 133         if (mkdir_p(to_dir, 0755))
 134                 return -1;
 135
 136         if (kcore_copy(from_dir, to_dir)) {
 137                 /* Remove YYYYmmddHHMMSShh directory */
 138                 if (!rmdir(to_dir)) {
 139                         p = strrchr(to_dir, '/');
 140                         if (p)
 141                                 *p = '\0';
 142                         /* Try to remove buildid directory */
 143                         if (!rmdir(to_dir)) {
 144                                 p = strrchr(to_dir, '/');
 145                                 if (p)
 146                                         *p = '\0';
 147                                 /* Try to remove [kernel.kcore] directory */
 148                                 rmdir(to_dir);
 149                         }
 150                 }
 151                 return -1;
 152         }
 153
 154         pr_debug("kcore added to build-id cache directory %s\n", to_dir);
 155
 156         return 0;
 157 }
 158
 159 static int build_id_cache__add_file(const char *filename, const char *debugdir)
 160 {
 161         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 162         u8 build_id[BUILD_ID_SIZE];
 163         int err;
 164
 165         if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
 166                 pr_debug("Couldn't read a build-id in %s\n", filename);
 167                 return -1;
 168         }
 169
 170         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
 171         err = build_id_cache__add_s(sbuild_id, debugdir, filename,
 172                                     false, false);
 173         if (verbose)
 174                 pr_info("Adding %s %s: %s\n", sbuild_id, filename,
 175                         err ? "FAIL" : "Ok");
 176         return err;
 177 }
 178
 179 static int build_id_cache__remove_file(const char *filename,
 180                                        const char *debugdir)
 181 {
 182         u8 build_id[BUILD_ID_SIZE];
 183         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 184
 185         int err;
 186
 187         if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
 188                 pr_debug("Couldn't read a build-id in %s\n", filename);
 189                 return -1;
 190         }
 191
 192         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
 193         err = build_id_cache__remove_s(sbuild_id, debugdir);
 194         if (verbose)
 195                 pr_info("Removing %s %s: %s\n", sbuild_id, filename,
 196                         err ? "FAIL" : "Ok");
 197
 198         return err;
 199 }
 200
 201 static bool dso__missing_buildid_cache(struct dso *dso, int parm __maybe_unused)
 202 {
 203         char filename[PATH_MAX];
 204         u8 build_id[BUILD_ID_SIZE];
 205
 206         if (dso__build_id_filename(dso, filename, sizeof(filename)) &&
 207             filename__read_build_id(filename, build_id,
 208                                     sizeof(build_id)) != sizeof(build_id)) {
 209                 if (errno == ENOENT)
 210                         return false;
 211
 212                 pr_warning("Problems with %s file, consider removing it from the cache\n",
 213                            filename);
 214         } else if (memcmp(dso->build_id, build_id, sizeof(dso->build_id))) {
 215                 pr_warning("Problems with %s file, consider removing it from the cache\n",
 216                            filename);
 217         }
 218
 219         return true;
 220 }
 221
 222 static int build_id_cache__fprintf_missing(const char *filename, bool force, FILE *fp)
 223 {
 224         struct perf_session *session = perf_session__new(filename, O_RDONLY,
 225                                                          force, false, NULL);
 226         if (session == NULL)
 227                 return -1;
 228
 229         perf_session__fprintf_dsos_buildid(session, fp, dso__missing_buildid_cache, 0);
 230         perf_session__delete(session);
 231
 232         return 0;
 233 }
 234
 235 static int build_id_cache__update_file(const char *filename,
 236                                        const char *debugdir)
 237 {
 238         u8 build_id[BUILD_ID_SIZE];
 239         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 240
 241         int err;
 242
 243         if (filename__read_build_id(filename, &build_id, sizeof(build_id)) < 0) {
 244                 pr_debug("Couldn't read a build-id in %s\n", filename);
 245                 return -1;
 246         }
 247
 248         build_id__sprintf(build_id, sizeof(build_id), sbuild_id);
 249         err = build_id_cache__remove_s(sbuild_id, debugdir);
 250         if (!err) {
 251                 err = build_id_cache__add_s(sbuild_id, debugdir, filename,
 252                                             false, false);
 253         }
 254         if (verbose)
 255                 pr_info("Updating %s %s: %s\n", sbuild_id, filename,
 256                         err ? "FAIL" : "Ok");
 257
 258         return err;
 259 }
 260
 261 int cmd_buildid_cache(int argc, const char **argv,
 262                       const char *prefix __maybe_unused)
 263 {
 264         struct strlist *list;
 265         struct str_node *pos;
 266         int ret = 0;
 267         bool force = false;
 268         char debugdir[PATH_MAX];
 269         char const *add_name_list_str = NULL,
 270                    *remove_name_list_str = NULL,
 271                    *missing_filename = NULL,
 272                    *update_name_list_str = NULL,
 273                    *kcore_filename;
 274
 275         const struct option buildid_cache_options[] = {
 276         OPT_STRING('a', "add", &add_name_list_str,
 277                    "file list", "file(s) to add"),
 278         OPT_STRING('k', "kcore", &kcore_filename,
 279                    "file", "kcore file to add"),
 280         OPT_STRING('r', "remove", &remove_name_list_str, "file list",
 281                     "file(s) to remove"),
 282         OPT_STRING('M', "missing", &missing_filename, "file",
 283                    "to find missing build ids in the cache"),
 284         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
 285         OPT_STRING('u', "update", &update_name_list_str, "file list",
 286                     "file(s) to update"),
 287         OPT_INCR('v', "verbose", &verbose, "be more verbose"),
 288         OPT_END()
 289         };
 290         const char * const buildid_cache_usage[] = {
 291                 "perf buildid-cache [<options>]",
 292                 NULL
 293         };
 294
 295         argc = parse_options(argc, argv, buildid_cache_options,
 296                              buildid_cache_usage, 0);
 297
 298         if (symbol__init() < 0)
 299                 return -1;
 300
 301         setup_pager();
 302
 303         snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
 304
 305         if (add_name_list_str) {
 306                 list = strlist__new(true, add_name_list_str);
 307                 if (list) {
 308                         strlist__for_each(pos, list)
 309                                 if (build_id_cache__add_file(pos->s, debugdir)) {
 310                                         if (errno == EEXIST) {
 311                                                 pr_debug("%s already in the cache\n",
 312                                                          pos->s);
 313                                                 continue;
 314                                         }
 315                                         pr_warning("Couldn't add %s: %s\n",
 316                                                    pos->s, strerror(errno));
 317                                 }
 318
 319                         strlist__delete(list);
 320                 }
 321         }
 322
 323         if (remove_name_list_str) {
 324                 list = strlist__new(true, remove_name_list_str);
 325                 if (list) {
 326                         strlist__for_each(pos, list)
 327                                 if (build_id_cache__remove_file(pos->s, debugdir)) {
 328                                         if (errno == ENOENT) {
 329                                                 pr_debug("%s wasn't in the cache\n",
 330                                                          pos->s);
 331                                                 continue;
 332                                         }
 333                                         pr_warning("Couldn't remove %s: %s\n",
 334                                                    pos->s, strerror(errno));
 335                                 }
 336
 337                         strlist__delete(list);
 338                 }
 339         }
 340
 341         if (missing_filename)
 342                 ret = build_id_cache__fprintf_missing(missing_filename, force, stdout);
 343
 344         if (update_name_list_str) {
 345                 list = strlist__new(true, update_name_list_str);
 346                 if (list) {
 347                         strlist__for_each(pos, list)
 348                                 if (build_id_cache__update_file(pos->s, debugdir)) {
 349                                         if (errno == ENOENT) {
 350                                                 pr_debug("%s wasn't in the cache\n",
 351                                                          pos->s);
 352                                                 continue;
 353                                         }
 354                                         pr_warning("Couldn't update %s: %s\n",
 355                                                    pos->s, strerror(errno));
 356                                 }
 357
 358                         strlist__delete(list);
 359                 }
 360         }
 361
 362         if (kcore_filename &&
 363             build_id_cache__add_kcore(kcore_filename, debugdir))
 364                 pr_warning("Couldn't add %s\n", kcore_filename);
 365
 366         return ret;
 367 }