tools/perf/util/dsos.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include "debug.h"
   3 #include "dsos.h"
   4 #include "dso.h"
   5 #include "util.h"
   6 #include "vdso.h"
   7 #include "namespaces.h"
   8 #include <errno.h>
   9 #include <libgen.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <symbol.h> // filename__read_build_id
  13 #include <unistd.h>
  14
  15 static int __dso_id__cmp(struct dso_id *a, struct dso_id *b)
  16 {
  17         if (a->maj > b->maj) return -1;
  18         if (a->maj < b->maj) return 1;
  19
  20         if (a->min > b->min) return -1;
  21         if (a->min < b->min) return 1;
  22
  23         if (a->ino > b->ino) return -1;
  24         if (a->ino < b->ino) return 1;
  25
  26         /*
  27          * Synthesized MMAP events have zero ino_generation, avoid comparing
  28          * them with MMAP events with actual ino_generation.
  29          *
  30          * I found it harmful because the mismatch resulted in a new
  31          * dso that did not have a build ID whereas the original dso did have a
  32          * build ID. The build ID was essential because the object was not found
  33          * otherwise. - Adrian
  34          */
  35         if (a->ino_generation && b->ino_generation) {
  36                 if (a->ino_generation > b->ino_generation) return -1;
  37                 if (a->ino_generation < b->ino_generation) return 1;
  38         }
  39
  40         return 0;
  41 }
  42
  43 static bool dso_id__empty(struct dso_id *id)
  44 {
  45         if (!id)
  46                 return true;
  47
  48         return !id->maj && !id->min && !id->ino && !id->ino_generation;
  49 }
  50
  51 static void dso__inject_id(struct dso *dso, struct dso_id *id)
  52 {
  53         dso->id.maj = id->maj;
  54         dso->id.min = id->min;
  55         dso->id.ino = id->ino;
  56         dso->id.ino_generation = id->ino_generation;
  57 }
  58
  59 static int dso_id__cmp(struct dso_id *a, struct dso_id *b)
  60 {
  61         /*
  62          * The second is always dso->id, so zeroes if not set, assume passing
  63          * NULL for a means a zeroed id
  64          */
  65         if (dso_id__empty(a) || dso_id__empty(b))
  66                 return 0;
  67
  68         return __dso_id__cmp(a, b);
  69 }
  70
  71 int dso__cmp_id(struct dso *a, struct dso *b)
  72 {
  73         return __dso_id__cmp(&a->id, &b->id);
  74 }
  75
  76 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
  77 {
  78         bool have_build_id = false;
  79         struct dso *pos;
  80         struct nscookie nsc;
  81
  82         list_for_each_entry(pos, head, node) {
  83                 if (with_hits && !pos->hit && !dso__is_vdso(pos))
  84                         continue;
  85                 if (pos->has_build_id) {
  86                         have_build_id = true;
  87                         continue;
  88                 }
  89                 nsinfo__mountns_enter(pos->nsinfo, &nsc);
  90                 if (filename__read_build_id(pos->long_name, &pos->bid) > 0) {
  91                         have_build_id     = true;
  92                         pos->has_build_id = true;
  93                 } else if (errno == ENOENT && pos->nsinfo) {
  94                         char *new_name = filename_with_chroot(pos->nsinfo->pid,
  95                                                               pos->long_name);
  96
  97                         if (new_name && filename__read_build_id(new_name,
  98                                                                 &pos->bid) > 0) {
  99                                 have_build_id = true;
 100                                 pos->has_build_id = true;
 101                         }
 102                         free(new_name);
 103                 }
 104                 nsinfo__mountns_exit(&nsc);
 105         }
 106
 107         return have_build_id;
 108 }
 109
 110 static int __dso__cmp_long_name(const char *long_name, struct dso_id *id, struct dso *b)
 111 {
 112         int rc = strcmp(long_name, b->long_name);
 113         return rc ?: dso_id__cmp(id, &b->id);
 114 }
 115
 116 static int __dso__cmp_short_name(const char *short_name, struct dso_id *id, struct dso *b)
 117 {
 118         int rc = strcmp(short_name, b->short_name);
 119         return rc ?: dso_id__cmp(id, &b->id);
 120 }
 121
 122 static int dso__cmp_short_name(struct dso *a, struct dso *b)
 123 {
 124         return __dso__cmp_short_name(a->short_name, &a->id, b);
 125 }
 126
 127 /*
 128  * Find a matching entry and/or link current entry to RB tree.
 129  * Either one of the dso or name parameter must be non-NULL or the
 130  * function will not work.
 131  */
 132 struct dso *__dsos__findnew_link_by_longname_id(struct rb_root *root, struct dso *dso,
 133                                                 const char *name, struct dso_id *id)
 134 {
 135         struct rb_node **p = &root->rb_node;
 136         struct rb_node  *parent = NULL;
 137
 138         if (!name)
 139                 name = dso->long_name;
 140         /*
 141          * Find node with the matching name
 142          */
 143         while (*p) {
 144                 struct dso *this = rb_entry(*p, struct dso, rb_node);
 145                 int rc = __dso__cmp_long_name(name, id, this);
 146
 147                 parent = *p;
 148                 if (rc == 0) {
 149                         /*
 150                          * In case the new DSO is a duplicate of an existing
 151                          * one, print a one-time warning & put the new entry
 152                          * at the end of the list of duplicates.
 153                          */
 154                         if (!dso || (dso == this))
 155                                 return this;    /* Find matching dso */
 156                         /*
 157                          * The core kernel DSOs may have duplicated long name.
 158                          * In this case, the short name should be different.
 159                          * Comparing the short names to differentiate the DSOs.
 160                          */
 161                         rc = dso__cmp_short_name(dso, this);
 162                         if (rc == 0) {
 163                                 pr_err("Duplicated dso name: %s\n", name);
 164                                 return NULL;
 165                         }
 166                 }
 167                 if (rc < 0)
 168                         p = &parent->rb_left;
 169                 else
 170                         p = &parent->rb_right;
 171         }
 172         if (dso) {
 173                 /* Add new node and rebalance tree */
 174                 rb_link_node(&dso->rb_node, parent, p);
 175                 rb_insert_color(&dso->rb_node, root);
 176                 dso->root = root;
 177         }
 178         return NULL;
 179 }
 180
 181 void __dsos__add(struct dsos *dsos, struct dso *dso)
 182 {
 183         list_add_tail(&dso->node, &dsos->head);
 184         __dsos__findnew_link_by_longname_id(&dsos->root, dso, NULL, &dso->id);
 185         /*
 186          * It is now in the linked list, grab a reference, then garbage collect
 187          * this when needing memory, by looking at LRU dso instances in the
 188          * list with atomic_read(&dso->refcnt) == 1, i.e. no references
 189          * anywhere besides the one for the list, do, under a lock for the
 190          * list: remove it from the list, then a dso__put(), that probably will
 191          * be the last and will then call dso__delete(), end of life.
 192          *
 193          * That, or at the end of the 'struct machine' lifetime, when all
 194          * 'struct dso' instances will be removed from the list, in
 195          * dsos__exit(), if they have no other reference from some other data
 196          * structure.
 197          *
 198          * E.g.: after processing a 'perf.data' file and storing references
 199          * to objects instantiated while processing events, we will have
 200          * references to the 'thread', 'map', 'dso' structs all from 'struct
 201          * hist_entry' instances, but we may not need anything not referenced,
 202          * so we might as well call machines__exit()/machines__delete() and
 203          * garbage collect it.
 204          */
 205         dso__get(dso);
 206 }
 207
 208 void dsos__add(struct dsos *dsos, struct dso *dso)
 209 {
 210         down_write(&dsos->lock);
 211         __dsos__add(dsos, dso);
 212         up_write(&dsos->lock);
 213 }
 214
 215 static struct dso *__dsos__findnew_by_longname_id(struct rb_root *root, const char *name, struct dso_id *id)
 216 {
 217         return __dsos__findnew_link_by_longname_id(root, NULL, name, id);
 218 }
 219
 220 static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, struct dso_id *id, bool cmp_short)
 221 {
 222         struct dso *pos;
 223
 224         if (cmp_short) {
 225                 list_for_each_entry(pos, &dsos->head, node)
 226                         if (__dso__cmp_short_name(name, id, pos) == 0)
 227                                 return pos;
 228                 return NULL;
 229         }
 230         return __dsos__findnew_by_longname_id(&dsos->root, name, id);
 231 }
 232
 233 struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
 234 {
 235         return __dsos__find_id(dsos, name, NULL, cmp_short);
 236 }
 237
 238 static void dso__set_basename(struct dso *dso)
 239 {
 240         char *base, *lname;
 241         int tid;
 242
 243         if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
 244                 if (asprintf(&base, "[JIT] tid %d", tid) < 0)
 245                         return;
 246         } else {
 247               /*
 248                * basename() may modify path buffer, so we must pass
 249                * a copy.
 250                */
 251                 lname = strdup(dso->long_name);
 252                 if (!lname)
 253                         return;
 254
 255                 /*
 256                  * basename() may return a pointer to internal
 257                  * storage which is reused in subsequent calls
 258                  * so copy the result.
 259                  */
 260                 base = strdup(basename(lname));
 261
 262                 free(lname);
 263
 264                 if (!base)
 265                         return;
 266         }
 267         dso__set_short_name(dso, base, true);
 268 }
 269
 270 static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
 271 {
 272         struct dso *dso = dso__new_id(name, id);
 273
 274         if (dso != NULL) {
 275                 __dsos__add(dsos, dso);
 276                 dso__set_basename(dso);
 277                 /* Put dso here because __dsos_add already got it */
 278                 dso__put(dso);
 279         }
 280         return dso;
 281 }
 282
 283 struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
 284 {
 285         return __dsos__addnew_id(dsos, name, NULL);
 286 }
 287
 288 static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
 289 {
 290         struct dso *dso = __dsos__find_id(dsos, name, id, false);
 291
 292         if (dso && dso_id__empty(&dso->id) && !dso_id__empty(id))
 293                 dso__inject_id(dso, id);
 294
 295         return dso ? dso : __dsos__addnew_id(dsos, name, id);
 296 }
 297
 298 struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, struct dso_id *id)
 299 {
 300         struct dso *dso;
 301         down_write(&dsos->lock);
 302         dso = dso__get(__dsos__findnew_id(dsos, name, id));
 303         up_write(&dsos->lock);
 304         return dso;
 305 }
 306
 307 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
 308                                bool (skip)(struct dso *dso, int parm), int parm)
 309 {
 310         struct dso *pos;
 311         size_t ret = 0;
 312
 313         list_for_each_entry(pos, head, node) {
 314                 char sbuild_id[SBUILD_ID_SIZE];
 315
 316                 if (skip && skip(pos, parm))
 317                         continue;
 318                 build_id__sprintf(&pos->bid, sbuild_id);
 319                 ret += fprintf(fp, "%-40s %s\n", sbuild_id, pos->long_name);
 320         }
 321         return ret;
 322 }
 323
 324 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 325 {
 326         struct dso *pos;
 327         size_t ret = 0;
 328
 329         list_for_each_entry(pos, head, node) {
 330                 ret += dso__fprintf(pos, fp);
 331         }
 332
 333         return ret;
 334 }