xref: /linux/tools/perf/util/dso.c (revision e0bf6c5ca2d3281f231c5f0c9bf145e9513644de)
1 #include <asm/bug.h>
2 #include <sys/time.h>
3 #include <sys/resource.h>
4 #include "symbol.h"
5 #include "dso.h"
6 #include "machine.h"
7 #include "util.h"
8 #include "debug.h"
9 
10 char dso__symtab_origin(const struct dso *dso)
11 {
12 	static const char origin[] = {
13 		[DSO_BINARY_TYPE__KALLSYMS]			= 'k',
14 		[DSO_BINARY_TYPE__VMLINUX]			= 'v',
15 		[DSO_BINARY_TYPE__JAVA_JIT]			= 'j',
16 		[DSO_BINARY_TYPE__DEBUGLINK]			= 'l',
17 		[DSO_BINARY_TYPE__BUILD_ID_CACHE]		= 'B',
18 		[DSO_BINARY_TYPE__FEDORA_DEBUGINFO]		= 'f',
19 		[DSO_BINARY_TYPE__UBUNTU_DEBUGINFO]		= 'u',
20 		[DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO]	= 'o',
21 		[DSO_BINARY_TYPE__BUILDID_DEBUGINFO]		= 'b',
22 		[DSO_BINARY_TYPE__SYSTEM_PATH_DSO]		= 'd',
23 		[DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE]		= 'K',
24 		[DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP]	= 'm',
25 		[DSO_BINARY_TYPE__GUEST_KALLSYMS]		= 'g',
26 		[DSO_BINARY_TYPE__GUEST_KMODULE]		= 'G',
27 		[DSO_BINARY_TYPE__GUEST_KMODULE_COMP]		= 'M',
28 		[DSO_BINARY_TYPE__GUEST_VMLINUX]		= 'V',
29 	};
30 
31 	if (dso == NULL || dso->symtab_type == DSO_BINARY_TYPE__NOT_FOUND)
32 		return '!';
33 	return origin[dso->symtab_type];
34 }
35 
36 int dso__read_binary_type_filename(const struct dso *dso,
37 				   enum dso_binary_type type,
38 				   char *root_dir, char *filename, size_t size)
39 {
40 	char build_id_hex[BUILD_ID_SIZE * 2 + 1];
41 	int ret = 0;
42 	size_t len;
43 
44 	switch (type) {
45 	case DSO_BINARY_TYPE__DEBUGLINK: {
46 		char *debuglink;
47 
48 		strncpy(filename, dso->long_name, size);
49 		debuglink = filename + dso->long_name_len;
50 		while (debuglink != filename && *debuglink != '/')
51 			debuglink--;
52 		if (*debuglink == '/')
53 			debuglink++;
54 		ret = filename__read_debuglink(dso->long_name, debuglink,
55 					       size - (debuglink - filename));
56 		}
57 		break;
58 	case DSO_BINARY_TYPE__BUILD_ID_CACHE:
59 		/* skip the locally configured cache if a symfs is given */
60 		if (symbol_conf.symfs[0] ||
61 		    (dso__build_id_filename(dso, filename, size) == NULL))
62 			ret = -1;
63 		break;
64 
65 	case DSO_BINARY_TYPE__FEDORA_DEBUGINFO:
66 		len = __symbol__join_symfs(filename, size, "/usr/lib/debug");
67 		snprintf(filename + len, size - len, "%s.debug", dso->long_name);
68 		break;
69 
70 	case DSO_BINARY_TYPE__UBUNTU_DEBUGINFO:
71 		len = __symbol__join_symfs(filename, size, "/usr/lib/debug");
72 		snprintf(filename + len, size - len, "%s", dso->long_name);
73 		break;
74 
75 	case DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO:
76 	{
77 		const char *last_slash;
78 		size_t dir_size;
79 
80 		last_slash = dso->long_name + dso->long_name_len;
81 		while (last_slash != dso->long_name && *last_slash != '/')
82 			last_slash--;
83 
84 		len = __symbol__join_symfs(filename, size, "");
85 		dir_size = last_slash - dso->long_name + 2;
86 		if (dir_size > (size - len)) {
87 			ret = -1;
88 			break;
89 		}
90 		len += scnprintf(filename + len, dir_size, "%s",  dso->long_name);
91 		len += scnprintf(filename + len , size - len, ".debug%s",
92 								last_slash);
93 		break;
94 	}
95 
96 	case DSO_BINARY_TYPE__BUILDID_DEBUGINFO:
97 		if (!dso->has_build_id) {
98 			ret = -1;
99 			break;
100 		}
101 
102 		build_id__sprintf(dso->build_id,
103 				  sizeof(dso->build_id),
104 				  build_id_hex);
105 		len = __symbol__join_symfs(filename, size, "/usr/lib/debug/.build-id/");
106 		snprintf(filename + len, size - len, "%.2s/%s.debug",
107 			 build_id_hex, build_id_hex + 2);
108 		break;
109 
110 	case DSO_BINARY_TYPE__VMLINUX:
111 	case DSO_BINARY_TYPE__GUEST_VMLINUX:
112 	case DSO_BINARY_TYPE__SYSTEM_PATH_DSO:
113 		__symbol__join_symfs(filename, size, dso->long_name);
114 		break;
115 
116 	case DSO_BINARY_TYPE__GUEST_KMODULE:
117 	case DSO_BINARY_TYPE__GUEST_KMODULE_COMP:
118 		path__join3(filename, size, symbol_conf.symfs,
119 			    root_dir, dso->long_name);
120 		break;
121 
122 	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE:
123 	case DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP:
124 		__symbol__join_symfs(filename, size, dso->long_name);
125 		break;
126 
127 	case DSO_BINARY_TYPE__KCORE:
128 	case DSO_BINARY_TYPE__GUEST_KCORE:
129 		snprintf(filename, size, "%s", dso->long_name);
130 		break;
131 
132 	default:
133 	case DSO_BINARY_TYPE__KALLSYMS:
134 	case DSO_BINARY_TYPE__GUEST_KALLSYMS:
135 	case DSO_BINARY_TYPE__JAVA_JIT:
136 	case DSO_BINARY_TYPE__NOT_FOUND:
137 		ret = -1;
138 		break;
139 	}
140 
141 	return ret;
142 }
143 
144 static const struct {
145 	const char *fmt;
146 	int (*decompress)(const char *input, int output);
147 } compressions[] = {
148 #ifdef HAVE_ZLIB_SUPPORT
149 	{ "gz", gzip_decompress_to_file },
150 #endif
151 	{ NULL, NULL },
152 };
153 
154 bool is_supported_compression(const char *ext)
155 {
156 	unsigned i;
157 
158 	for (i = 0; compressions[i].fmt; i++) {
159 		if (!strcmp(ext, compressions[i].fmt))
160 			return true;
161 	}
162 	return false;
163 }
164 
165 bool is_kmodule_extension(const char *ext)
166 {
167 	if (strncmp(ext, "ko", 2))
168 		return false;
169 
170 	if (ext[2] == '\0' || (ext[2] == '.' && is_supported_compression(ext+3)))
171 		return true;
172 
173 	return false;
174 }
175 
176 bool is_kernel_module(const char *pathname, bool *compressed)
177 {
178 	const char *ext = strrchr(pathname, '.');
179 
180 	if (ext == NULL)
181 		return false;
182 
183 	if (is_supported_compression(ext + 1)) {
184 		if (compressed)
185 			*compressed = true;
186 		ext -= 3;
187 	} else if (compressed)
188 		*compressed = false;
189 
190 	return is_kmodule_extension(ext + 1);
191 }
192 
193 bool decompress_to_file(const char *ext, const char *filename, int output_fd)
194 {
195 	unsigned i;
196 
197 	for (i = 0; compressions[i].fmt; i++) {
198 		if (!strcmp(ext, compressions[i].fmt))
199 			return !compressions[i].decompress(filename,
200 							   output_fd);
201 	}
202 	return false;
203 }
204 
205 bool dso__needs_decompress(struct dso *dso)
206 {
207 	return dso->symtab_type == DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE_COMP ||
208 		dso->symtab_type == DSO_BINARY_TYPE__GUEST_KMODULE_COMP;
209 }
210 
211 /*
212  * Global list of open DSOs and the counter.
213  */
214 static LIST_HEAD(dso__data_open);
215 static long dso__data_open_cnt;
216 
217 static void dso__list_add(struct dso *dso)
218 {
219 	list_add_tail(&dso->data.open_entry, &dso__data_open);
220 	dso__data_open_cnt++;
221 }
222 
223 static void dso__list_del(struct dso *dso)
224 {
225 	list_del(&dso->data.open_entry);
226 	WARN_ONCE(dso__data_open_cnt <= 0,
227 		  "DSO data fd counter out of bounds.");
228 	dso__data_open_cnt--;
229 }
230 
231 static void close_first_dso(void);
232 
233 static int do_open(char *name)
234 {
235 	int fd;
236 	char sbuf[STRERR_BUFSIZE];
237 
238 	do {
239 		fd = open(name, O_RDONLY);
240 		if (fd >= 0)
241 			return fd;
242 
243 		pr_debug("dso open failed, mmap: %s\n",
244 			 strerror_r(errno, sbuf, sizeof(sbuf)));
245 		if (!dso__data_open_cnt || errno != EMFILE)
246 			break;
247 
248 		close_first_dso();
249 	} while (1);
250 
251 	return -1;
252 }
253 
254 static int __open_dso(struct dso *dso, struct machine *machine)
255 {
256 	int fd;
257 	char *root_dir = (char *)"";
258 	char *name = malloc(PATH_MAX);
259 
260 	if (!name)
261 		return -ENOMEM;
262 
263 	if (machine)
264 		root_dir = machine->root_dir;
265 
266 	if (dso__read_binary_type_filename(dso, dso->binary_type,
267 					    root_dir, name, PATH_MAX)) {
268 		free(name);
269 		return -EINVAL;
270 	}
271 
272 	fd = do_open(name);
273 	free(name);
274 	return fd;
275 }
276 
277 static void check_data_close(void);
278 
279 /**
280  * dso_close - Open DSO data file
281  * @dso: dso object
282  *
283  * Open @dso's data file descriptor and updates
284  * list/count of open DSO objects.
285  */
286 static int open_dso(struct dso *dso, struct machine *machine)
287 {
288 	int fd = __open_dso(dso, machine);
289 
290 	if (fd >= 0) {
291 		dso__list_add(dso);
292 		/*
293 		 * Check if we crossed the allowed number
294 		 * of opened DSOs and close one if needed.
295 		 */
296 		check_data_close();
297 	}
298 
299 	return fd;
300 }
301 
302 static void close_data_fd(struct dso *dso)
303 {
304 	if (dso->data.fd >= 0) {
305 		close(dso->data.fd);
306 		dso->data.fd = -1;
307 		dso->data.file_size = 0;
308 		dso__list_del(dso);
309 	}
310 }
311 
312 /**
313  * dso_close - Close DSO data file
314  * @dso: dso object
315  *
316  * Close @dso's data file descriptor and updates
317  * list/count of open DSO objects.
318  */
319 static void close_dso(struct dso *dso)
320 {
321 	close_data_fd(dso);
322 }
323 
324 static void close_first_dso(void)
325 {
326 	struct dso *dso;
327 
328 	dso = list_first_entry(&dso__data_open, struct dso, data.open_entry);
329 	close_dso(dso);
330 }
331 
332 static rlim_t get_fd_limit(void)
333 {
334 	struct rlimit l;
335 	rlim_t limit = 0;
336 
337 	/* Allow half of the current open fd limit. */
338 	if (getrlimit(RLIMIT_NOFILE, &l) == 0) {
339 		if (l.rlim_cur == RLIM_INFINITY)
340 			limit = l.rlim_cur;
341 		else
342 			limit = l.rlim_cur / 2;
343 	} else {
344 		pr_err("failed to get fd limit\n");
345 		limit = 1;
346 	}
347 
348 	return limit;
349 }
350 
351 static bool may_cache_fd(void)
352 {
353 	static rlim_t limit;
354 
355 	if (!limit)
356 		limit = get_fd_limit();
357 
358 	if (limit == RLIM_INFINITY)
359 		return true;
360 
361 	return limit > (rlim_t) dso__data_open_cnt;
362 }
363 
364 /*
365  * Check and close LRU dso if we crossed allowed limit
366  * for opened dso file descriptors. The limit is half
367  * of the RLIMIT_NOFILE files opened.
368 */
369 static void check_data_close(void)
370 {
371 	bool cache_fd = may_cache_fd();
372 
373 	if (!cache_fd)
374 		close_first_dso();
375 }
376 
377 /**
378  * dso__data_close - Close DSO data file
379  * @dso: dso object
380  *
381  * External interface to close @dso's data file descriptor.
382  */
383 void dso__data_close(struct dso *dso)
384 {
385 	close_dso(dso);
386 }
387 
388 /**
389  * dso__data_fd - Get dso's data file descriptor
390  * @dso: dso object
391  * @machine: machine object
392  *
393  * External interface to find dso's file, open it and
394  * returns file descriptor.
395  */
396 int dso__data_fd(struct dso *dso, struct machine *machine)
397 {
398 	enum dso_binary_type binary_type_data[] = {
399 		DSO_BINARY_TYPE__BUILD_ID_CACHE,
400 		DSO_BINARY_TYPE__SYSTEM_PATH_DSO,
401 		DSO_BINARY_TYPE__NOT_FOUND,
402 	};
403 	int i = 0;
404 
405 	if (dso->data.status == DSO_DATA_STATUS_ERROR)
406 		return -1;
407 
408 	if (dso->data.fd >= 0)
409 		goto out;
410 
411 	if (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND) {
412 		dso->data.fd = open_dso(dso, machine);
413 		goto out;
414 	}
415 
416 	do {
417 		dso->binary_type = binary_type_data[i++];
418 
419 		dso->data.fd = open_dso(dso, machine);
420 		if (dso->data.fd >= 0)
421 			goto out;
422 
423 	} while (dso->binary_type != DSO_BINARY_TYPE__NOT_FOUND);
424 out:
425 	if (dso->data.fd >= 0)
426 		dso->data.status = DSO_DATA_STATUS_OK;
427 	else
428 		dso->data.status = DSO_DATA_STATUS_ERROR;
429 
430 	return dso->data.fd;
431 }
432 
433 bool dso__data_status_seen(struct dso *dso, enum dso_data_status_seen by)
434 {
435 	u32 flag = 1 << by;
436 
437 	if (dso->data.status_seen & flag)
438 		return true;
439 
440 	dso->data.status_seen |= flag;
441 
442 	return false;
443 }
444 
445 static void
446 dso_cache__free(struct rb_root *root)
447 {
448 	struct rb_node *next = rb_first(root);
449 
450 	while (next) {
451 		struct dso_cache *cache;
452 
453 		cache = rb_entry(next, struct dso_cache, rb_node);
454 		next = rb_next(&cache->rb_node);
455 		rb_erase(&cache->rb_node, root);
456 		free(cache);
457 	}
458 }
459 
460 static struct dso_cache *dso_cache__find(const struct rb_root *root, u64 offset)
461 {
462 	struct rb_node * const *p = &root->rb_node;
463 	const struct rb_node *parent = NULL;
464 	struct dso_cache *cache;
465 
466 	while (*p != NULL) {
467 		u64 end;
468 
469 		parent = *p;
470 		cache = rb_entry(parent, struct dso_cache, rb_node);
471 		end = cache->offset + DSO__DATA_CACHE_SIZE;
472 
473 		if (offset < cache->offset)
474 			p = &(*p)->rb_left;
475 		else if (offset >= end)
476 			p = &(*p)->rb_right;
477 		else
478 			return cache;
479 	}
480 	return NULL;
481 }
482 
483 static void
484 dso_cache__insert(struct rb_root *root, struct dso_cache *new)
485 {
486 	struct rb_node **p = &root->rb_node;
487 	struct rb_node *parent = NULL;
488 	struct dso_cache *cache;
489 	u64 offset = new->offset;
490 
491 	while (*p != NULL) {
492 		u64 end;
493 
494 		parent = *p;
495 		cache = rb_entry(parent, struct dso_cache, rb_node);
496 		end = cache->offset + DSO__DATA_CACHE_SIZE;
497 
498 		if (offset < cache->offset)
499 			p = &(*p)->rb_left;
500 		else if (offset >= end)
501 			p = &(*p)->rb_right;
502 	}
503 
504 	rb_link_node(&new->rb_node, parent, p);
505 	rb_insert_color(&new->rb_node, root);
506 }
507 
508 static ssize_t
509 dso_cache__memcpy(struct dso_cache *cache, u64 offset,
510 		  u8 *data, u64 size)
511 {
512 	u64 cache_offset = offset - cache->offset;
513 	u64 cache_size   = min(cache->size - cache_offset, size);
514 
515 	memcpy(data, cache->data + cache_offset, cache_size);
516 	return cache_size;
517 }
518 
519 static ssize_t
520 dso_cache__read(struct dso *dso, u64 offset, u8 *data, ssize_t size)
521 {
522 	struct dso_cache *cache;
523 	ssize_t ret;
524 
525 	do {
526 		u64 cache_offset;
527 
528 		ret = -ENOMEM;
529 
530 		cache = zalloc(sizeof(*cache) + DSO__DATA_CACHE_SIZE);
531 		if (!cache)
532 			break;
533 
534 		cache_offset = offset & DSO__DATA_CACHE_MASK;
535 
536 		ret = pread(dso->data.fd, cache->data, DSO__DATA_CACHE_SIZE, cache_offset);
537 		if (ret <= 0)
538 			break;
539 
540 		cache->offset = cache_offset;
541 		cache->size   = ret;
542 		dso_cache__insert(&dso->data.cache, cache);
543 
544 		ret = dso_cache__memcpy(cache, offset, data, size);
545 
546 	} while (0);
547 
548 	if (ret <= 0)
549 		free(cache);
550 
551 	return ret;
552 }
553 
554 static ssize_t dso_cache_read(struct dso *dso, u64 offset,
555 			      u8 *data, ssize_t size)
556 {
557 	struct dso_cache *cache;
558 
559 	cache = dso_cache__find(&dso->data.cache, offset);
560 	if (cache)
561 		return dso_cache__memcpy(cache, offset, data, size);
562 	else
563 		return dso_cache__read(dso, offset, data, size);
564 }
565 
566 /*
567  * Reads and caches dso data DSO__DATA_CACHE_SIZE size chunks
568  * in the rb_tree. Any read to already cached data is served
569  * by cached data.
570  */
571 static ssize_t cached_read(struct dso *dso, u64 offset, u8 *data, ssize_t size)
572 {
573 	ssize_t r = 0;
574 	u8 *p = data;
575 
576 	do {
577 		ssize_t ret;
578 
579 		ret = dso_cache_read(dso, offset, p, size);
580 		if (ret < 0)
581 			return ret;
582 
583 		/* Reached EOF, return what we have. */
584 		if (!ret)
585 			break;
586 
587 		BUG_ON(ret > size);
588 
589 		r      += ret;
590 		p      += ret;
591 		offset += ret;
592 		size   -= ret;
593 
594 	} while (size);
595 
596 	return r;
597 }
598 
599 static int data_file_size(struct dso *dso)
600 {
601 	struct stat st;
602 	char sbuf[STRERR_BUFSIZE];
603 
604 	if (!dso->data.file_size) {
605 		if (fstat(dso->data.fd, &st)) {
606 			pr_err("dso mmap failed, fstat: %s\n",
607 				strerror_r(errno, sbuf, sizeof(sbuf)));
608 			return -1;
609 		}
610 		dso->data.file_size = st.st_size;
611 	}
612 
613 	return 0;
614 }
615 
616 /**
617  * dso__data_size - Return dso data size
618  * @dso: dso object
619  * @machine: machine object
620  *
621  * Return: dso data size
622  */
623 off_t dso__data_size(struct dso *dso, struct machine *machine)
624 {
625 	int fd;
626 
627 	fd = dso__data_fd(dso, machine);
628 	if (fd < 0)
629 		return fd;
630 
631 	if (data_file_size(dso))
632 		return -1;
633 
634 	/* For now just estimate dso data size is close to file size */
635 	return dso->data.file_size;
636 }
637 
638 static ssize_t data_read_offset(struct dso *dso, u64 offset,
639 				u8 *data, ssize_t size)
640 {
641 	if (data_file_size(dso))
642 		return -1;
643 
644 	/* Check the offset sanity. */
645 	if (offset > dso->data.file_size)
646 		return -1;
647 
648 	if (offset + size < offset)
649 		return -1;
650 
651 	return cached_read(dso, offset, data, size);
652 }
653 
654 /**
655  * dso__data_read_offset - Read data from dso file offset
656  * @dso: dso object
657  * @machine: machine object
658  * @offset: file offset
659  * @data: buffer to store data
660  * @size: size of the @data buffer
661  *
662  * External interface to read data from dso file offset. Open
663  * dso data file and use cached_read to get the data.
664  */
665 ssize_t dso__data_read_offset(struct dso *dso, struct machine *machine,
666 			      u64 offset, u8 *data, ssize_t size)
667 {
668 	if (dso__data_fd(dso, machine) < 0)
669 		return -1;
670 
671 	return data_read_offset(dso, offset, data, size);
672 }
673 
674 /**
675  * dso__data_read_addr - Read data from dso address
676  * @dso: dso object
677  * @machine: machine object
678  * @add: virtual memory address
679  * @data: buffer to store data
680  * @size: size of the @data buffer
681  *
682  * External interface to read data from dso address.
683  */
684 ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
685 			    struct machine *machine, u64 addr,
686 			    u8 *data, ssize_t size)
687 {
688 	u64 offset = map->map_ip(map, addr);
689 	return dso__data_read_offset(dso, machine, offset, data, size);
690 }
691 
692 struct map *dso__new_map(const char *name)
693 {
694 	struct map *map = NULL;
695 	struct dso *dso = dso__new(name);
696 
697 	if (dso)
698 		map = map__new2(0, dso, MAP__FUNCTION);
699 
700 	return map;
701 }
702 
703 struct dso *dso__kernel_findnew(struct machine *machine, const char *name,
704 		    const char *short_name, int dso_type)
705 {
706 	/*
707 	 * The kernel dso could be created by build_id processing.
708 	 */
709 	struct dso *dso = __dsos__findnew(&machine->kernel_dsos, name);
710 
711 	/*
712 	 * We need to run this in all cases, since during the build_id
713 	 * processing we had no idea this was the kernel dso.
714 	 */
715 	if (dso != NULL) {
716 		dso__set_short_name(dso, short_name, false);
717 		dso->kernel = dso_type;
718 	}
719 
720 	return dso;
721 }
722 
723 /*
724  * Find a matching entry and/or link current entry to RB tree.
725  * Either one of the dso or name parameter must be non-NULL or the
726  * function will not work.
727  */
728 static struct dso *dso__findlink_by_longname(struct rb_root *root,
729 					     struct dso *dso, const char *name)
730 {
731 	struct rb_node **p = &root->rb_node;
732 	struct rb_node  *parent = NULL;
733 
734 	if (!name)
735 		name = dso->long_name;
736 	/*
737 	 * Find node with the matching name
738 	 */
739 	while (*p) {
740 		struct dso *this = rb_entry(*p, struct dso, rb_node);
741 		int rc = strcmp(name, this->long_name);
742 
743 		parent = *p;
744 		if (rc == 0) {
745 			/*
746 			 * In case the new DSO is a duplicate of an existing
747 			 * one, print an one-time warning & put the new entry
748 			 * at the end of the list of duplicates.
749 			 */
750 			if (!dso || (dso == this))
751 				return this;	/* Find matching dso */
752 			/*
753 			 * The core kernel DSOs may have duplicated long name.
754 			 * In this case, the short name should be different.
755 			 * Comparing the short names to differentiate the DSOs.
756 			 */
757 			rc = strcmp(dso->short_name, this->short_name);
758 			if (rc == 0) {
759 				pr_err("Duplicated dso name: %s\n", name);
760 				return NULL;
761 			}
762 		}
763 		if (rc < 0)
764 			p = &parent->rb_left;
765 		else
766 			p = &parent->rb_right;
767 	}
768 	if (dso) {
769 		/* Add new node and rebalance tree */
770 		rb_link_node(&dso->rb_node, parent, p);
771 		rb_insert_color(&dso->rb_node, root);
772 	}
773 	return NULL;
774 }
775 
776 static inline struct dso *
777 dso__find_by_longname(const struct rb_root *root, const char *name)
778 {
779 	return dso__findlink_by_longname((struct rb_root *)root, NULL, name);
780 }
781 
782 void dso__set_long_name(struct dso *dso, const char *name, bool name_allocated)
783 {
784 	if (name == NULL)
785 		return;
786 
787 	if (dso->long_name_allocated)
788 		free((char *)dso->long_name);
789 
790 	dso->long_name		 = name;
791 	dso->long_name_len	 = strlen(name);
792 	dso->long_name_allocated = name_allocated;
793 }
794 
795 void dso__set_short_name(struct dso *dso, const char *name, bool name_allocated)
796 {
797 	if (name == NULL)
798 		return;
799 
800 	if (dso->short_name_allocated)
801 		free((char *)dso->short_name);
802 
803 	dso->short_name		  = name;
804 	dso->short_name_len	  = strlen(name);
805 	dso->short_name_allocated = name_allocated;
806 }
807 
808 static void dso__set_basename(struct dso *dso)
809 {
810        /*
811         * basename() may modify path buffer, so we must pass
812         * a copy.
813         */
814        char *base, *lname = strdup(dso->long_name);
815 
816        if (!lname)
817                return;
818 
819        /*
820         * basename() may return a pointer to internal
821         * storage which is reused in subsequent calls
822         * so copy the result.
823         */
824        base = strdup(basename(lname));
825 
826        free(lname);
827 
828        if (!base)
829                return;
830 
831        dso__set_short_name(dso, base, true);
832 }
833 
834 int dso__name_len(const struct dso *dso)
835 {
836 	if (!dso)
837 		return strlen("[unknown]");
838 	if (verbose)
839 		return dso->long_name_len;
840 
841 	return dso->short_name_len;
842 }
843 
844 bool dso__loaded(const struct dso *dso, enum map_type type)
845 {
846 	return dso->loaded & (1 << type);
847 }
848 
849 bool dso__sorted_by_name(const struct dso *dso, enum map_type type)
850 {
851 	return dso->sorted_by_name & (1 << type);
852 }
853 
854 void dso__set_sorted_by_name(struct dso *dso, enum map_type type)
855 {
856 	dso->sorted_by_name |= (1 << type);
857 }
858 
859 struct dso *dso__new(const char *name)
860 {
861 	struct dso *dso = calloc(1, sizeof(*dso) + strlen(name) + 1);
862 
863 	if (dso != NULL) {
864 		int i;
865 		strcpy(dso->name, name);
866 		dso__set_long_name(dso, dso->name, false);
867 		dso__set_short_name(dso, dso->name, false);
868 		for (i = 0; i < MAP__NR_TYPES; ++i)
869 			dso->symbols[i] = dso->symbol_names[i] = RB_ROOT;
870 		dso->data.cache = RB_ROOT;
871 		dso->data.fd = -1;
872 		dso->data.status = DSO_DATA_STATUS_UNKNOWN;
873 		dso->symtab_type = DSO_BINARY_TYPE__NOT_FOUND;
874 		dso->binary_type = DSO_BINARY_TYPE__NOT_FOUND;
875 		dso->is_64_bit = (sizeof(void *) == 8);
876 		dso->loaded = 0;
877 		dso->rel = 0;
878 		dso->sorted_by_name = 0;
879 		dso->has_build_id = 0;
880 		dso->has_srcline = 1;
881 		dso->a2l_fails = 1;
882 		dso->kernel = DSO_TYPE_USER;
883 		dso->needs_swap = DSO_SWAP__UNSET;
884 		RB_CLEAR_NODE(&dso->rb_node);
885 		INIT_LIST_HEAD(&dso->node);
886 		INIT_LIST_HEAD(&dso->data.open_entry);
887 	}
888 
889 	return dso;
890 }
891 
892 void dso__delete(struct dso *dso)
893 {
894 	int i;
895 
896 	if (!RB_EMPTY_NODE(&dso->rb_node))
897 		pr_err("DSO %s is still in rbtree when being deleted!\n",
898 		       dso->long_name);
899 	for (i = 0; i < MAP__NR_TYPES; ++i)
900 		symbols__delete(&dso->symbols[i]);
901 
902 	if (dso->short_name_allocated) {
903 		zfree((char **)&dso->short_name);
904 		dso->short_name_allocated = false;
905 	}
906 
907 	if (dso->long_name_allocated) {
908 		zfree((char **)&dso->long_name);
909 		dso->long_name_allocated = false;
910 	}
911 
912 	dso__data_close(dso);
913 	dso_cache__free(&dso->data.cache);
914 	dso__free_a2l(dso);
915 	zfree(&dso->symsrc_filename);
916 	free(dso);
917 }
918 
919 void dso__set_build_id(struct dso *dso, void *build_id)
920 {
921 	memcpy(dso->build_id, build_id, sizeof(dso->build_id));
922 	dso->has_build_id = 1;
923 }
924 
925 bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
926 {
927 	return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
928 }
929 
930 void dso__read_running_kernel_build_id(struct dso *dso, struct machine *machine)
931 {
932 	char path[PATH_MAX];
933 
934 	if (machine__is_default_guest(machine))
935 		return;
936 	sprintf(path, "%s/sys/kernel/notes", machine->root_dir);
937 	if (sysfs__read_build_id(path, dso->build_id,
938 				 sizeof(dso->build_id)) == 0)
939 		dso->has_build_id = true;
940 }
941 
942 int dso__kernel_module_get_build_id(struct dso *dso,
943 				    const char *root_dir)
944 {
945 	char filename[PATH_MAX];
946 	/*
947 	 * kernel module short names are of the form "[module]" and
948 	 * we need just "module" here.
949 	 */
950 	const char *name = dso->short_name + 1;
951 
952 	snprintf(filename, sizeof(filename),
953 		 "%s/sys/module/%.*s/notes/.note.gnu.build-id",
954 		 root_dir, (int)strlen(name) - 1, name);
955 
956 	if (sysfs__read_build_id(filename, dso->build_id,
957 				 sizeof(dso->build_id)) == 0)
958 		dso->has_build_id = true;
959 
960 	return 0;
961 }
962 
963 bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
964 {
965 	bool have_build_id = false;
966 	struct dso *pos;
967 
968 	list_for_each_entry(pos, head, node) {
969 		if (with_hits && !pos->hit)
970 			continue;
971 		if (pos->has_build_id) {
972 			have_build_id = true;
973 			continue;
974 		}
975 		if (filename__read_build_id(pos->long_name, pos->build_id,
976 					    sizeof(pos->build_id)) > 0) {
977 			have_build_id	  = true;
978 			pos->has_build_id = true;
979 		}
980 	}
981 
982 	return have_build_id;
983 }
984 
985 void dsos__add(struct dsos *dsos, struct dso *dso)
986 {
987 	list_add_tail(&dso->node, &dsos->head);
988 	dso__findlink_by_longname(&dsos->root, dso, NULL);
989 }
990 
991 struct dso *dsos__find(const struct dsos *dsos, const char *name,
992 		       bool cmp_short)
993 {
994 	struct dso *pos;
995 
996 	if (cmp_short) {
997 		list_for_each_entry(pos, &dsos->head, node)
998 			if (strcmp(pos->short_name, name) == 0)
999 				return pos;
1000 		return NULL;
1001 	}
1002 	return dso__find_by_longname(&dsos->root, name);
1003 }
1004 
1005 struct dso *__dsos__findnew(struct dsos *dsos, const char *name)
1006 {
1007 	struct dso *dso = dsos__find(dsos, name, false);
1008 
1009 	if (!dso) {
1010 		dso = dso__new(name);
1011 		if (dso != NULL) {
1012 			dsos__add(dsos, dso);
1013 			dso__set_basename(dso);
1014 		}
1015 	}
1016 
1017 	return dso;
1018 }
1019 
1020 size_t __dsos__fprintf_buildid(struct list_head *head, FILE *fp,
1021 			       bool (skip)(struct dso *dso, int parm), int parm)
1022 {
1023 	struct dso *pos;
1024 	size_t ret = 0;
1025 
1026 	list_for_each_entry(pos, head, node) {
1027 		if (skip && skip(pos, parm))
1028 			continue;
1029 		ret += dso__fprintf_buildid(pos, fp);
1030 		ret += fprintf(fp, " %s\n", pos->long_name);
1031 	}
1032 	return ret;
1033 }
1034 
1035 size_t __dsos__fprintf(struct list_head *head, FILE *fp)
1036 {
1037 	struct dso *pos;
1038 	size_t ret = 0;
1039 
1040 	list_for_each_entry(pos, head, node) {
1041 		int i;
1042 		for (i = 0; i < MAP__NR_TYPES; ++i)
1043 			ret += dso__fprintf(pos, i, fp);
1044 	}
1045 
1046 	return ret;
1047 }
1048 
1049 size_t dso__fprintf_buildid(struct dso *dso, FILE *fp)
1050 {
1051 	char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1052 
1053 	build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
1054 	return fprintf(fp, "%s", sbuild_id);
1055 }
1056 
1057 size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
1058 {
1059 	struct rb_node *nd;
1060 	size_t ret = fprintf(fp, "dso: %s (", dso->short_name);
1061 
1062 	if (dso->short_name != dso->long_name)
1063 		ret += fprintf(fp, "%s, ", dso->long_name);
1064 	ret += fprintf(fp, "%s, %sloaded, ", map_type__name[type],
1065 		       dso__loaded(dso, type) ? "" : "NOT ");
1066 	ret += dso__fprintf_buildid(dso, fp);
1067 	ret += fprintf(fp, ")\n");
1068 	for (nd = rb_first(&dso->symbols[type]); nd; nd = rb_next(nd)) {
1069 		struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
1070 		ret += symbol__fprintf(pos, fp);
1071 	}
1072 
1073 	return ret;
1074 }
1075 
1076 enum dso_type dso__type(struct dso *dso, struct machine *machine)
1077 {
1078 	int fd;
1079 
1080 	fd = dso__data_fd(dso, machine);
1081 	if (fd < 0)
1082 		return DSO__TYPE_UNKNOWN;
1083 
1084 	return dso__type_fd(fd);
1085 }
1086