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