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 void dsos__init(struct dsos *dsos) 16 { 17 init_rwsem(&dsos->lock); 18 19 dsos->cnt = 0; 20 dsos->allocated = 0; 21 dsos->dsos = NULL; 22 dsos->sorted = true; 23 } 24 25 static void dsos__purge(struct dsos *dsos) 26 { 27 down_write(&dsos->lock); 28 29 for (unsigned int i = 0; i < dsos->cnt; i++) { 30 struct dso *dso = dsos->dsos[i]; 31 32 dso__set_dsos(dso, NULL); 33 dso__put(dso); 34 } 35 36 zfree(&dsos->dsos); 37 dsos->cnt = 0; 38 dsos->allocated = 0; 39 dsos->sorted = true; 40 41 up_write(&dsos->lock); 42 } 43 44 void dsos__exit(struct dsos *dsos) 45 { 46 dsos__purge(dsos); 47 exit_rwsem(&dsos->lock); 48 } 49 50 51 static int __dsos__for_each_dso(struct dsos *dsos, 52 int (*cb)(struct dso *dso, void *data), 53 void *data) 54 { 55 for (unsigned int i = 0; i < dsos->cnt; i++) { 56 struct dso *dso = dsos->dsos[i]; 57 int err; 58 59 err = cb(dso, data); 60 if (err) 61 return err; 62 } 63 return 0; 64 } 65 66 struct dsos__read_build_ids_cb_args { 67 bool with_hits; 68 bool have_build_id; 69 }; 70 71 static int dsos__read_build_ids_cb(struct dso *dso, void *data) 72 { 73 struct dsos__read_build_ids_cb_args *args = data; 74 struct nscookie nsc; 75 struct build_id bid = { .size = 0, }; 76 77 if (args->with_hits && !dso__hit(dso) && !dso__is_vdso(dso)) 78 return 0; 79 if (dso__has_build_id(dso)) { 80 args->have_build_id = true; 81 return 0; 82 } 83 nsinfo__mountns_enter(dso__nsinfo(dso), &nsc); 84 if (filename__read_build_id(dso__long_name(dso), &bid, /*block=*/true) > 0) { 85 dso__set_build_id(dso, &bid); 86 args->have_build_id = true; 87 } else if (errno == ENOENT && dso__nsinfo(dso)) { 88 char *new_name = dso__filename_with_chroot(dso, dso__long_name(dso)); 89 90 if (new_name && filename__read_build_id(new_name, &bid, /*block=*/true) > 0) { 91 dso__set_build_id(dso, &bid); 92 args->have_build_id = true; 93 } 94 free(new_name); 95 } 96 nsinfo__mountns_exit(&nsc); 97 return 0; 98 } 99 100 bool dsos__read_build_ids(struct dsos *dsos, bool with_hits) 101 { 102 struct dsos__read_build_ids_cb_args args = { 103 .with_hits = with_hits, 104 .have_build_id = false, 105 }; 106 107 dsos__for_each_dso(dsos, dsos__read_build_ids_cb, &args); 108 return args.have_build_id; 109 } 110 111 static int __dso__cmp_long_name(const char *long_name, const struct dso_id *id, 112 const struct dso *b) 113 { 114 int rc = strcmp(long_name, dso__long_name(b)); 115 return rc ?: dso_id__cmp(id, dso__id_const(b)); 116 } 117 118 static int __dso__cmp_short_name(const char *short_name, const struct dso_id *id, 119 const struct dso *b) 120 { 121 int rc = strcmp(short_name, dso__short_name(b)); 122 return rc ?: dso_id__cmp(id, dso__id_const(b)); 123 } 124 125 static int dsos__cmp_long_name_id_short_name(const void *va, const void *vb) 126 { 127 const struct dso *a = *((const struct dso **)va); 128 const struct dso *b = *((const struct dso **)vb); 129 int rc = strcmp(dso__long_name(a), dso__long_name(b)); 130 131 if (!rc) { 132 rc = dso_id__cmp(dso__id_const(a), dso__id_const(b)); 133 if (!rc) 134 rc = strcmp(dso__short_name(a), dso__short_name(b)); 135 } 136 return rc; 137 } 138 139 struct dsos__key { 140 const char *long_name; 141 const struct dso_id *id; 142 }; 143 144 static int dsos__cmp_key_long_name_id(const void *vkey, const void *vdso) 145 { 146 const struct dsos__key *key = vkey; 147 const struct dso *dso = *((const struct dso **)vdso); 148 149 return __dso__cmp_long_name(key->long_name, key->id, dso); 150 } 151 152 /* 153 * Find a matching entry and/or link current entry to RB tree. 154 * Either one of the dso or name parameter must be non-NULL or the 155 * function will not work. 156 */ 157 static struct dso *__dsos__find_by_longname_id(struct dsos *dsos, 158 const char *name, 159 const struct dso_id *id, 160 bool write_locked) 161 SHARED_LOCKS_REQUIRED(dsos->lock) 162 { 163 struct dsos__key key = { 164 .long_name = name, 165 .id = id, 166 }; 167 struct dso **res; 168 169 if (dsos->dsos == NULL) 170 return NULL; 171 172 if (!dsos->sorted) { 173 if (!write_locked) { 174 struct dso *dso; 175 176 up_read(&dsos->lock); 177 down_write(&dsos->lock); 178 dso = __dsos__find_by_longname_id(dsos, name, id, 179 /*write_locked=*/true); 180 up_write(&dsos->lock); 181 down_read(&dsos->lock); 182 return dso; 183 } 184 qsort(dsos->dsos, dsos->cnt, sizeof(struct dso *), 185 dsos__cmp_long_name_id_short_name); 186 dsos->sorted = true; 187 } 188 189 res = bsearch(&key, dsos->dsos, dsos->cnt, sizeof(struct dso *), 190 dsos__cmp_key_long_name_id); 191 if (!res) 192 return NULL; 193 194 return dso__get(*res); 195 } 196 197 int __dsos__add(struct dsos *dsos, struct dso *dso) 198 { 199 if (dsos->cnt == dsos->allocated) { 200 unsigned int to_allocate = 2; 201 struct dso **temp; 202 203 if (dsos->allocated > 0) 204 to_allocate = dsos->allocated * 2; 205 temp = realloc(dsos->dsos, sizeof(struct dso *) * to_allocate); 206 if (!temp) 207 return -ENOMEM; 208 dsos->dsos = temp; 209 dsos->allocated = to_allocate; 210 } 211 if (!dsos->sorted) { 212 dsos->dsos[dsos->cnt++] = dso__get(dso); 213 } else { 214 int low = 0, high = dsos->cnt - 1; 215 int insert = dsos->cnt; /* Default to inserting at the end. */ 216 217 while (low <= high) { 218 int mid = low + (high - low) / 2; 219 int cmp = dsos__cmp_long_name_id_short_name(&dsos->dsos[mid], &dso); 220 221 if (cmp < 0) { 222 low = mid + 1; 223 } else { 224 high = mid - 1; 225 insert = mid; 226 } 227 } 228 memmove(&dsos->dsos[insert + 1], &dsos->dsos[insert], 229 (dsos->cnt - insert) * sizeof(struct dso *)); 230 dsos->cnt++; 231 dsos->dsos[insert] = dso__get(dso); 232 } 233 dso__set_dsos(dso, dsos); 234 return 0; 235 } 236 237 int dsos__add(struct dsos *dsos, struct dso *dso) 238 { 239 int ret; 240 241 down_write(&dsos->lock); 242 ret = __dsos__add(dsos, dso); 243 up_write(&dsos->lock); 244 return ret; 245 } 246 247 struct dsos__find_id_cb_args { 248 const char *name; 249 const struct dso_id *id; 250 struct dso *res; 251 }; 252 253 static int dsos__find_id_cb(struct dso *dso, void *data) 254 { 255 struct dsos__find_id_cb_args *args = data; 256 257 if (__dso__cmp_short_name(args->name, args->id, dso) == 0) { 258 args->res = dso__get(dso); 259 return 1; 260 } 261 return 0; 262 263 } 264 265 static struct dso *__dsos__find_id(struct dsos *dsos, const char *name, const struct dso_id *id, 266 bool cmp_short, bool write_locked) 267 SHARED_LOCKS_REQUIRED(dsos->lock) 268 { 269 struct dso *res; 270 271 if (cmp_short) { 272 struct dsos__find_id_cb_args args = { 273 .name = name, 274 .id = id, 275 .res = NULL, 276 }; 277 278 __dsos__for_each_dso(dsos, dsos__find_id_cb, &args); 279 return args.res; 280 } 281 res = __dsos__find_by_longname_id(dsos, name, id, write_locked); 282 return res; 283 } 284 285 struct dso *dsos__find(struct dsos *dsos, const char *name, bool cmp_short) 286 { 287 struct dso *res; 288 289 down_read(&dsos->lock); 290 res = __dsos__find_id(dsos, name, &dso_id_empty, cmp_short, /*write_locked=*/false); 291 up_read(&dsos->lock); 292 return res; 293 } 294 295 static void dso__set_basename(struct dso *dso) 296 { 297 char *base, *lname; 298 int tid; 299 300 if (perf_pid_map_tid(dso__long_name(dso), &tid)) { 301 if (asprintf(&base, "[JIT] tid %d", tid) < 0) 302 return; 303 } else { 304 /* 305 * basename() may modify path buffer, so we must pass 306 * a copy. 307 */ 308 lname = strdup(dso__long_name(dso)); 309 if (!lname) 310 return; 311 312 /* 313 * basename() may return a pointer to internal 314 * storage which is reused in subsequent calls 315 * so copy the result. 316 */ 317 base = strdup(basename(lname)); 318 319 free(lname); 320 321 if (!base) 322 return; 323 } 324 dso__set_short_name(dso, base, true); 325 } 326 327 static struct dso *__dsos__addnew_id(struct dsos *dsos, const char *name, const struct dso_id *id) 328 { 329 struct dso *dso = dso__new_id(name, id); 330 331 if (dso != NULL) { 332 /* 333 * The dsos lock is held on entry, so rename the dso before 334 * adding it to avoid needing to take the dsos lock again to say 335 * the array isn't sorted. 336 */ 337 dso__set_basename(dso); 338 __dsos__add(dsos, dso); 339 } 340 return dso; 341 } 342 343 static struct dso *__dsos__findnew_id(struct dsos *dsos, const char *name, const struct dso_id *id) 344 SHARED_LOCKS_REQUIRED(dsos->lock) 345 { 346 struct dso *dso = __dsos__find_id(dsos, name, id, false, /*write_locked=*/true); 347 348 if (dso) 349 __dso__improve_id(dso, id); 350 351 return dso ? dso : __dsos__addnew_id(dsos, name, id); 352 } 353 354 struct dso *dsos__findnew_id(struct dsos *dsos, const char *name, const struct dso_id *id) 355 { 356 struct dso *dso; 357 down_write(&dsos->lock); 358 dso = __dsos__findnew_id(dsos, name, id); 359 up_write(&dsos->lock); 360 return dso; 361 } 362 363 struct dsos__fprintf_buildid_cb_args { 364 FILE *fp; 365 bool (*skip)(struct dso *dso, int parm); 366 int parm; 367 size_t ret; 368 }; 369 370 static int dsos__fprintf_buildid_cb(struct dso *dso, void *data) 371 { 372 struct dsos__fprintf_buildid_cb_args *args = data; 373 char sbuild_id[SBUILD_ID_SIZE]; 374 375 if (args->skip && args->skip(dso, args->parm)) 376 return 0; 377 build_id__snprintf(dso__bid(dso), sbuild_id, sizeof(sbuild_id)); 378 args->ret += fprintf(args->fp, "%-40s %s\n", sbuild_id, dso__long_name(dso)); 379 return 0; 380 } 381 382 size_t dsos__fprintf_buildid(struct dsos *dsos, FILE *fp, 383 bool (*skip)(struct dso *dso, int parm), int parm) 384 { 385 struct dsos__fprintf_buildid_cb_args args = { 386 .fp = fp, 387 .skip = skip, 388 .parm = parm, 389 .ret = 0, 390 }; 391 392 dsos__for_each_dso(dsos, dsos__fprintf_buildid_cb, &args); 393 return args.ret; 394 } 395 396 struct dsos__fprintf_cb_args { 397 FILE *fp; 398 size_t ret; 399 }; 400 401 static int dsos__fprintf_cb(struct dso *dso, void *data) 402 { 403 struct dsos__fprintf_cb_args *args = data; 404 405 args->ret += dso__fprintf(dso, args->fp); 406 return 0; 407 } 408 409 size_t dsos__fprintf(struct dsos *dsos, FILE *fp) 410 { 411 struct dsos__fprintf_cb_args args = { 412 .fp = fp, 413 .ret = 0, 414 }; 415 416 dsos__for_each_dso(dsos, dsos__fprintf_cb, &args); 417 return args.ret; 418 } 419 420 static int dsos__hit_all_cb(struct dso *dso, void *data __maybe_unused) 421 { 422 dso__set_hit(dso); 423 return 0; 424 } 425 426 int dsos__hit_all(struct dsos *dsos) 427 { 428 return dsos__for_each_dso(dsos, dsos__hit_all_cb, NULL); 429 } 430 431 struct dso *dsos__findnew_module_dso(struct dsos *dsos, 432 struct machine *machine, 433 struct kmod_path *m, 434 const char *filename) 435 { 436 struct dso *dso; 437 438 down_write(&dsos->lock); 439 440 dso = __dsos__find_id(dsos, m->name, &dso_id_empty, /*cmp_short=*/true, 441 /*write_locked=*/true); 442 if (dso) { 443 up_write(&dsos->lock); 444 return dso; 445 } 446 /* 447 * Failed to find the dso so create it. Change the name before adding it 448 * to the array, to avoid unnecessary sorts and potential locking 449 * issues. 450 */ 451 dso = dso__new_id(m->name, /*id=*/NULL); 452 if (!dso) { 453 up_write(&dsos->lock); 454 return NULL; 455 } 456 dso__set_basename(dso); 457 dso__set_module_info(dso, m, machine); 458 dso__set_long_name(dso, strdup(filename), true); 459 dso__set_kernel(dso, DSO_SPACE__KERNEL); 460 __dsos__add(dsos, dso); 461 462 up_write(&dsos->lock); 463 return dso; 464 } 465 466 static int dsos__find_kernel_dso_cb(struct dso *dso, void *data) 467 { 468 struct dso **res = data; 469 /* 470 * The cpumode passed to is_kernel_module is not the cpumode of *this* 471 * event. If we insist on passing correct cpumode to is_kernel_module, 472 * we should record the cpumode when we adding this dso to the linked 473 * list. 474 * 475 * However we don't really need passing correct cpumode. We know the 476 * correct cpumode must be kernel mode (if not, we should not link it 477 * onto kernel_dsos list). 478 * 479 * Therefore, we pass PERF_RECORD_MISC_CPUMODE_UNKNOWN. 480 * is_kernel_module() treats it as a kernel cpumode. 481 */ 482 if (!dso__kernel(dso) || 483 is_kernel_module(dso__long_name(dso), PERF_RECORD_MISC_CPUMODE_UNKNOWN)) 484 return 0; 485 486 *res = dso__get(dso); 487 return 1; 488 } 489 490 struct dso *dsos__find_kernel_dso(struct dsos *dsos) 491 { 492 struct dso *res = NULL; 493 494 dsos__for_each_dso(dsos, dsos__find_kernel_dso_cb, &res); 495 return res; 496 } 497 498 int dsos__for_each_dso(struct dsos *dsos, int (*cb)(struct dso *dso, void *data), void *data) 499 { 500 int err; 501 502 down_read(&dsos->lock); 503 err = __dsos__for_each_dso(dsos, cb, data); 504 up_read(&dsos->lock); 505 return err; 506 } 507