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 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
  13 {
  14         bool have_build_id = false;
  15         struct dso *pos;
  16         struct nscookie nsc;
  17
  18         list_for_each_entry(pos, head, node) {
  19                 if (with_hits && !pos->hit && !dso__is_vdso(pos))
  20                         continue;
  21                 if (pos->has_build_id) {
  22                         have_build_id = true;
  23                         continue;
  24                 }
  25                 nsinfo__mountns_enter(pos->nsinfo, &nsc);
  26                 if (filename__read_build_id(pos->long_name, pos->build_id,
  27                                             sizeof(pos->build_id)) > 0) {
  28                         have_build_id     = true;
  29                         pos->has_build_id = true;
  30                 }
  31                 nsinfo__mountns_exit(&nsc);
  32         }
  33
  34         return have_build_id;
  35 }
  36
  37 /*
  38  * Find a matching entry and/or link current entry to RB tree.
  39  * Either one of the dso or name parameter must be non-NULL or the
  40  * function will not work.
  41  */
  42 struct dso *__dsos__findnew_link_by_longname(struct rb_root *root, struct dso *dso, const char *name)
  43 {
  44         struct rb_node **p = &root->rb_node;
  45         struct rb_node  *parent = NULL;
  46
  47         if (!name)
  48                 name = dso->long_name;
  49         /*
  50          * Find node with the matching name
  51          */
  52         while (*p) {
  53                 struct dso *this = rb_entry(*p, struct dso, rb_node);
  54                 int rc = strcmp(name, this->long_name);
  55
  56                 parent = *p;
  57                 if (rc == 0) {
  58                         /*
  59                          * In case the new DSO is a duplicate of an existing
  60                          * one, print a one-time warning & put the new entry
  61                          * at the end of the list of duplicates.
  62                          */
  63                         if (!dso || (dso == this))
  64                                 return this;    /* Find matching dso */
  65                         /*
  66                          * The core kernel DSOs may have duplicated long name.
  67                          * In this case, the short name should be different.
  68                          * Comparing the short names to differentiate the DSOs.
  69                          */
  70                         rc = strcmp(dso->short_name, this->short_name);
  71                         if (rc == 0) {
  72                                 pr_err("Duplicated dso name: %s\n", name);
  73                                 return NULL;
  74                         }
  75                 }
  76                 if (rc < 0)
  77                         p = &parent->rb_left;
  78                 else
  79                         p = &parent->rb_right;
  80         }
  81         if (dso) {
  82                 /* Add new node and rebalance tree */
  83                 rb_link_node(&dso->rb_node, parent, p);
  84                 rb_insert_color(&dso->rb_node, root);
  85                 dso->root = root;
  86         }
  87         return NULL;
  88 }
  89
  90 void __dsos__add(struct dsos *dsos, struct dso *dso)
  91 {
  92         list_add_tail(&dso->node, &dsos->head);
  93         __dsos__findnew_link_by_longname(&dsos->root, dso, NULL);
  94         /*
  95          * It is now in the linked list, grab a reference, then garbage collect
  96          * this when needing memory, by looking at LRU dso instances in the
  97          * list with atomic_read(&dso->refcnt) == 1, i.e. no references
  98          * anywhere besides the one for the list, do, under a lock for the
  99          * list: remove it from the list, then a dso__put(), that probably will
 100          * be the last and will then call dso__delete(), end of life.
 101          *
 102          * That, or at the end of the 'struct machine' lifetime, when all
 103          * 'struct dso' instances will be removed from the list, in
 104          * dsos__exit(), if they have no other reference from some other data
 105          * structure.
 106          *
 107          * E.g.: after processing a 'perf.data' file and storing references
 108          * to objects instantiated while processing events, we will have
 109          * references to the 'thread', 'map', 'dso' structs all from 'struct
 110          * hist_entry' instances, but we may not need anything not referenced,
 111          * so we might as well call machines__exit()/machines__delete() and
 112          * garbage collect it.
 113          */
 114         dso__get(dso);
 115 }
 116
 117 void dsos__add(struct dsos *dsos, struct dso *dso)
 118 {
 119         down_write(&dsos->lock);
 120         __dsos__add(dsos, dso);
 121         up_write(&dsos->lock);
 122 }
 123
 124 struct dso *__dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
 125 {
 126         struct dso *pos;
 127
 128         if (cmp_short) {
 129                 list_for_each_entry(pos, &dsos->head, node)
 130                         if (strcmp(pos->short_name, name) == 0)
 131                                 return pos;
 132                 return NULL;
 133         }
 134         return __dsos__findnew_by_longname(&dsos->root, name);
 135 }
 136
 137 struct dso *dsos__find(struct dsos *dsos, const char *name, bool cmp_short)
 138 {
 139         struct dso *dso;
 140         down_read(&dsos->lock);
 141         dso = __dsos__find(dsos, name, cmp_short);
 142         up_read(&dsos->lock);
 143         return dso;
 144 }
 145
 146 static void dso__set_basename(struct dso *dso)
 147 {
 148         char *base, *lname;
 149         int tid;
 150
 151         if (sscanf(dso->long_name, "/tmp/perf-%d.map", &tid) == 1) {
 152                 if (asprintf(&base, "[JIT] tid %d", tid) < 0)
 153                         return;
 154         } else {
 155               /*
 156                * basename() may modify path buffer, so we must pass
 157                * a copy.
 158                */
 159                 lname = strdup(dso->long_name);
 160                 if (!lname)
 161                         return;
 162
 163                 /*
 164                  * basename() may return a pointer to internal
 165                  * storage which is reused in subsequent calls
 166                  * so copy the result.
 167                  */
 168                 base = strdup(basename(lname));
 169
 170                 free(lname);
 171
 172                 if (!base)
 173                         return;
 174         }
 175         dso__set_short_name(dso, base, true);
 176 }
 177
 178 struct dso *__dsos__addnew(struct dsos *dsos, const char *name)
 179 {
 180         struct dso *dso = dso__new(name);
 181
 182         if (dso != NULL) {
 183                 __dsos__add(dsos, dso);
 184                 dso__set_basename(dso);
 185                 /* Put dso here because __dsos_add already got it */
 186                 dso__put(dso);
 187         }
 188         return dso;
 189 }
 190
 191 struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
 192 {
 193         struct dso *dso = __dsos__find(dsos, name, false);
 194
 195         return dso ? dso : __dsos__addnew(dsos, name);
 196 }
 197
 198 struct dso *dsos__findnew(struct dsos *dsos, const char *name)
 199 {
 200         struct dso *dso;
 201         down_write(&dsos->lock);
 202         dso = dso__get(__dsos__findnew(dsos, name));
 203         up_write(&dsos->lock);
 204         return dso;
 205 }
 206
 207 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
 208                                bool (skip)(struct dso *dso, int parm), int parm)
 209 {
 210         struct dso *pos;
 211         size_t ret = 0;
 212
 213         list_for_each_entry(pos, head, node) {
 214                 if (skip && skip(pos, parm))
 215                         continue;
 216                 ret += dso__fprintf_buildid(pos, fp);
 217                 ret += fprintf(fp, " %s\n", pos->long_name);
 218         }
 219         return ret;
 220 }
 221
 222 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
 223 {
 224         struct dso *pos;
 225         size_t ret = 0;
 226
 227         list_for_each_entry(pos, head, node) {
 228                 ret += dso__fprintf(pos, fp);
 229         }
 230
 231         return ret;
 232 }