1/*-
2 * Copyright (c) 2005-2007, Joseph Koshy
3 * Copyright (c) 2007 The FreeBSD Foundation
4 * Copyright (c) 2009, Fabien Thomas
5 * All rights reserved.
6 *
7 * Portions of this software were developed by A. Joseph Koshy under
8 * sponsorship from the FreeBSD Foundation and Google, Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32/*
33 * Transform a hwpmc(4) log into human readable form, and into
34 * gprof(1) compatible profiles.
35 */
36
37#include <sys/cdefs.h>
38__FBSDID("$FreeBSD$");
39
40#include <sys/param.h>
41#include <sys/endian.h>
42#include <sys/gmon.h>
43#include <sys/imgact_aout.h>
44#include <sys/imgact_elf.h>
45#include <sys/mman.h>
46#include <sys/pmc.h>
47#include <sys/queue.h>
48#include <sys/socket.h>
49#include <sys/stat.h>
50#include <sys/wait.h>
51
52#include <netinet/in.h>
53
54#include <assert.h>
55#include <curses.h>
56#include <err.h>
57#include <errno.h>
58#include <fcntl.h>
59#include <gelf.h>
60#include <libgen.h>
61#include <limits.h>
62#include <netdb.h>
63#include <pmc.h>
64#include <pmclog.h>
65#include <sysexits.h>
66#include <stdint.h>
67#include <stdio.h>
68#include <stdlib.h>
69#include <string.h>
70#include <unistd.h>
71
72#include "pmcstat.h"
73#include "pmcstat_log.h"
74#include "pmcpl_callgraph.h"
75#include "pmcpl_gprof.h"
76
77/*
78 * struct pmcstat_gmonfile tracks a given 'gmon.out' file.  These
79 * files are mmap()'ed in as needed.
80 */
81
82struct pmcstat_gmonfile {
83	LIST_ENTRY(pmcstat_gmonfile)	pgf_next; /* list of entries */
84	int		pgf_overflow;	/* whether a count overflowed */
85	pmc_id_t	pgf_pmcid;	/* id of the associated pmc */
86	size_t		pgf_nbuckets;	/* #buckets in this gmon.out */
87	unsigned int	pgf_nsamples;	/* #samples in this gmon.out */
88	pmcstat_interned_string pgf_name;	/* pathname of gmon.out file */
89	size_t		pgf_ndatabytes;	/* number of bytes mapped */
90	void		*pgf_gmondata;	/* pointer to mmap'ed data */
91	FILE		*pgf_file;	/* used when writing gmon arcs */
92};
93
94/*
95 * Prototypes
96 */
97
98static void	pmcstat_gmon_create_file(struct pmcstat_gmonfile *_pgf,
99    struct pmcstat_image *_image);
100static pmcstat_interned_string pmcstat_gmon_create_name(const char *_sd,
101    struct pmcstat_image *_img, pmc_id_t _pmcid);
102static void	pmcstat_gmon_map_file(struct pmcstat_gmonfile *_pgf);
103static void	pmcstat_gmon_unmap_file(struct pmcstat_gmonfile *_pgf);
104
105static struct pmcstat_gmonfile *pmcstat_image_find_gmonfile(struct
106    pmcstat_image *_i, pmc_id_t _id);
107
108/*
109 * Create a gmon.out file and size it.
110 */
111
112static void
113pmcstat_gmon_create_file(struct pmcstat_gmonfile *pgf,
114    struct pmcstat_image *image)
115{
116	int fd;
117	size_t count;
118	struct gmonhdr gm;
119	const char *pathname;
120	char buffer[DEFAULT_BUFFER_SIZE];
121
122	pathname = pmcstat_string_unintern(pgf->pgf_name);
123	if ((fd = open(pathname, O_RDWR|O_NOFOLLOW|O_CREAT,
124		 S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH)) < 0)
125		err(EX_OSERR, "ERROR: Cannot open \"%s\"", pathname);
126
127	gm.lpc = image->pi_start;
128	gm.hpc = image->pi_end;
129	gm.ncnt = (pgf->pgf_nbuckets * sizeof(HISTCOUNTER)) +
130	    sizeof(struct gmonhdr);
131	gm.version = GMONVERSION;
132	gm.profrate = 0;		/* use ticks */
133	gm.histcounter_type = 0;	/* compatibility with moncontrol() */
134	gm.spare[0] = gm.spare[1] = 0;
135
136	/* Write out the gmon header */
137	if (write(fd, &gm, sizeof(gm)) < 0)
138		goto error;
139
140	/* Zero fill the samples[] array */
141	(void) memset(buffer, 0, sizeof(buffer));
142
143	count = pgf->pgf_ndatabytes - sizeof(struct gmonhdr);
144	while (count > sizeof(buffer)) {
145		if (write(fd, &buffer, sizeof(buffer)) < 0)
146			goto error;
147		count -= sizeof(buffer);
148	}
149
150	if (write(fd, &buffer, count) < 0)
151		goto error;
152
153	(void) close(fd);
154
155	return;
156
157 error:
158	err(EX_OSERR, "ERROR: Cannot write \"%s\"", pathname);
159}
160
161/*
162 * Determine the full pathname of a gmon.out file for a given
163 * (image,pmcid) combination.  Return the interned string.
164 */
165
166pmcstat_interned_string
167pmcstat_gmon_create_name(const char *samplesdir, struct pmcstat_image *image,
168    pmc_id_t pmcid)
169{
170	const char *pmcname;
171	char fullpath[PATH_MAX];
172
173	pmcname = pmcstat_pmcid_to_name(pmcid);
174	if (!pmcname)
175		err(EX_SOFTWARE, "ERROR: cannot find pmcid");
176
177	(void) snprintf(fullpath, sizeof(fullpath),
178	    "%s/%s/%s", samplesdir, pmcname,
179	    pmcstat_string_unintern(image->pi_samplename));
180
181	return (pmcstat_string_intern(fullpath));
182}
183
184
185/*
186 * Mmap in a gmon.out file for processing.
187 */
188
189static void
190pmcstat_gmon_map_file(struct pmcstat_gmonfile *pgf)
191{
192	int fd;
193	const char *pathname;
194
195	pathname = pmcstat_string_unintern(pgf->pgf_name);
196
197	/* the gmon.out file must already exist */
198	if ((fd = open(pathname, O_RDWR | O_NOFOLLOW, 0)) < 0)
199		err(EX_OSERR, "ERROR: cannot open \"%s\"", pathname);
200
201	pgf->pgf_gmondata = mmap(NULL, pgf->pgf_ndatabytes,
202	    PROT_READ|PROT_WRITE, MAP_NOSYNC|MAP_SHARED, fd, 0);
203
204	if (pgf->pgf_gmondata == MAP_FAILED)
205		err(EX_OSERR, "ERROR: cannot map \"%s\"", pathname);
206
207	(void) close(fd);
208}
209
210/*
211 * Unmap a gmon.out file after sync'ing its data to disk.
212 */
213
214static void
215pmcstat_gmon_unmap_file(struct pmcstat_gmonfile *pgf)
216{
217	(void) msync(pgf->pgf_gmondata, pgf->pgf_ndatabytes,
218	    MS_SYNC);
219	(void) munmap(pgf->pgf_gmondata, pgf->pgf_ndatabytes);
220	pgf->pgf_gmondata = NULL;
221}
222
223static void
224pmcstat_gmon_append_arc(struct pmcstat_image *image, pmc_id_t pmcid,
225    uintptr_t rawfrom, uintptr_t rawto, uint32_t count)
226{
227	struct rawarc arc;	/* from <sys/gmon.h> */
228	const char *pathname;
229	struct pmcstat_gmonfile *pgf;
230
231	if ((pgf = pmcstat_image_find_gmonfile(image, pmcid)) == NULL)
232		return;
233
234	if (pgf->pgf_file == NULL) {
235		pathname = pmcstat_string_unintern(pgf->pgf_name);
236		if ((pgf->pgf_file = fopen(pathname, "a")) == NULL)
237			return;
238	}
239
240	arc.raw_frompc = rawfrom + image->pi_vaddr;
241	arc.raw_selfpc = rawto + image->pi_vaddr;
242	arc.raw_count = count;
243
244	(void) fwrite(&arc, sizeof(arc), 1, pgf->pgf_file);
245
246}
247
248static struct pmcstat_gmonfile *
249pmcstat_image_find_gmonfile(struct pmcstat_image *image, pmc_id_t pmcid)
250{
251	struct pmcstat_gmonfile *pgf;
252	LIST_FOREACH(pgf, &image->pi_gmlist, pgf_next)
253	    if (pgf->pgf_pmcid == pmcid)
254		    return (pgf);
255	return (NULL);
256}
257
258static void
259pmcstat_cgnode_do_gmon_arcs(struct pmcstat_cgnode *cg, pmc_id_t pmcid)
260{
261	struct pmcstat_cgnode *cgc;
262
263	/*
264	 * Look for child nodes that belong to the same image.
265	 */
266
267	LIST_FOREACH(cgc, &cg->pcg_children, pcg_sibling) {
268		if (cgc->pcg_image == cg->pcg_image)
269			pmcstat_gmon_append_arc(cg->pcg_image, pmcid,
270			    cgc->pcg_func, cg->pcg_func, cgc->pcg_count);
271		if (cgc->pcg_nchildren > 0)
272			pmcstat_cgnode_do_gmon_arcs(cgc, pmcid);
273	}
274}
275
276static void
277pmcstat_callgraph_do_gmon_arcs_for_pmcid(pmc_id_t pmcid)
278{
279	int n;
280	struct pmcstat_cgnode_hash *pch;
281
282	for (n = 0; n < PMCSTAT_NHASH; n++)
283		LIST_FOREACH(pch, &pmcstat_cgnode_hash[n], pch_next)
284			if (pch->pch_pmcid == pmcid &&
285			    pch->pch_cgnode->pcg_nchildren > 1)
286				pmcstat_cgnode_do_gmon_arcs(pch->pch_cgnode,
287				    pmcid);
288}
289
290
291static void
292pmcstat_callgraph_do_gmon_arcs(void)
293{
294	struct pmcstat_pmcrecord *pmcr;
295
296	LIST_FOREACH(pmcr, &pmcstat_pmcs, pr_next)
297		pmcstat_callgraph_do_gmon_arcs_for_pmcid(pmcr->pr_pmcid);
298}
299
300void
301pmcpl_gmon_initimage(struct pmcstat_image *pi)
302{
303	int count, nlen;
304	char *sn;
305	char name[NAME_MAX];
306
307	/*
308	 * Look for a suitable name for the sample files associated
309	 * with this image: if `basename(path)`+".gmon" is available,
310	 * we use that, otherwise we try iterating through
311	 * `basename(path)`+ "~" + NNN + ".gmon" till we get a free
312	 * entry.
313	 */
314	if ((sn = basename(pmcstat_string_unintern(pi->pi_execpath))) == NULL)
315		err(EX_OSERR, "ERROR: Cannot process \"%s\"",
316		    pmcstat_string_unintern(pi->pi_execpath));
317
318	nlen = strlen(sn);
319	nlen = min(nlen, (int) (sizeof(name) - sizeof(".gmon")));
320
321	snprintf(name, sizeof(name), "%.*s.gmon", nlen, sn);
322
323	/* try use the unabridged name first */
324	if (pmcstat_string_lookup(name) == NULL)
325		pi->pi_samplename = pmcstat_string_intern(name);
326	else {
327		/*
328		 * Otherwise use a prefix from the original name and
329		 * upto 3 digits.
330		 */
331		nlen = strlen(sn);
332		nlen = min(nlen, (int) (sizeof(name)-sizeof("~NNN.gmon")));
333		count = 0;
334		do {
335			if (++count > 999)
336				errx(EX_CANTCREAT,
337				    "ERROR: cannot create a gmon file for"
338				    " \"%s\"", name);
339			snprintf(name, sizeof(name), "%.*s~%3.3d.gmon",
340			    nlen, sn, count);
341			if (pmcstat_string_lookup(name) == NULL) {
342				pi->pi_samplename =
343				    pmcstat_string_intern(name);
344				count = 0;
345			}
346		} while (count > 0);
347	}
348
349	LIST_INIT(&pi->pi_gmlist);
350}
351
352void
353pmcpl_gmon_shutdownimage(struct pmcstat_image *pi)
354{
355	struct pmcstat_gmonfile *pgf, *pgftmp;
356
357	LIST_FOREACH_SAFE(pgf, &pi->pi_gmlist, pgf_next, pgftmp) {
358		if (pgf->pgf_file)
359			(void) fclose(pgf->pgf_file);
360		LIST_REMOVE(pgf, pgf_next);
361		free(pgf);
362	}
363}
364
365void
366pmcpl_gmon_newpmc(pmcstat_interned_string ps, struct pmcstat_pmcrecord *pr)
367{
368	struct stat st;
369	char fullpath[PATH_MAX];
370
371	(void) pr;
372
373	/*
374	 * Create the appropriate directory to hold gmon.out files.
375	 */
376
377	(void) snprintf(fullpath, sizeof(fullpath), "%s/%s", args.pa_samplesdir,
378	    pmcstat_string_unintern(ps));
379
380	/* If the path name exists, it should be a directory */
381	if (stat(fullpath, &st) == 0 && S_ISDIR(st.st_mode))
382		return;
383
384	if (mkdir(fullpath, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) < 0)
385		err(EX_OSERR, "ERROR: Cannot create directory \"%s\"",
386		    fullpath);
387}
388
389/*
390 * Increment the bucket in the gmon.out file corresponding to 'pmcid'
391 * and 'pc'.
392 */
393
394void
395pmcpl_gmon_process(struct pmcstat_process *pp, struct pmcstat_pmcrecord *pmcr,
396    uint32_t nsamples, uintfptr_t *cc, int usermode, uint32_t cpu)
397{
398	struct pmcstat_pcmap *map;
399	struct pmcstat_image *image;
400	struct pmcstat_gmonfile *pgf;
401	uintfptr_t bucket;
402	HISTCOUNTER *hc;
403	pmc_id_t pmcid;
404
405	(void) nsamples; (void) usermode; (void) cpu;
406
407	map = pmcstat_process_find_map(usermode ? pp : pmcstat_kernproc, cc[0]);
408	if (map == NULL) {
409		/* Unknown offset. */
410		pmcstat_stats.ps_samples_unknown_offset++;
411		return;
412	}
413
414	assert(cc[0] >= map->ppm_lowpc && cc[0] < map->ppm_highpc);
415
416	image = map->ppm_image;
417	pmcid = pmcr->pr_pmcid;
418
419	/*
420	 * If this is the first time we are seeing a sample for
421	 * this executable image, try determine its parameters.
422	 */
423	if (image->pi_type == PMCSTAT_IMAGE_UNKNOWN)
424		pmcstat_image_determine_type(image);
425
426	assert(image->pi_type != PMCSTAT_IMAGE_UNKNOWN);
427
428	/* Ignore samples in images that we know nothing about. */
429	if (image->pi_type == PMCSTAT_IMAGE_INDETERMINABLE) {
430		pmcstat_stats.ps_samples_indeterminable++;
431		return;
432	}
433
434	/*
435	 * Find the gmon file corresponding to 'pmcid', creating it if
436	 * needed.
437	 */
438	pgf = pmcstat_image_find_gmonfile(image, pmcid);
439	if (pgf == NULL) {
440		if ((pgf = calloc(1, sizeof(*pgf))) == NULL)
441			err(EX_OSERR, "ERROR:");
442
443		pgf->pgf_gmondata = NULL;	/* mark as unmapped */
444		pgf->pgf_name = pmcstat_gmon_create_name(args.pa_samplesdir,
445		    image, pmcid);
446		pgf->pgf_pmcid = pmcid;
447		assert(image->pi_end > image->pi_start);
448		pgf->pgf_nbuckets = (image->pi_end - image->pi_start) /
449		    FUNCTION_ALIGNMENT;	/* see <machine/profile.h> */
450		pgf->pgf_ndatabytes = sizeof(struct gmonhdr) +
451		    pgf->pgf_nbuckets * sizeof(HISTCOUNTER);
452		pgf->pgf_nsamples = 0;
453		pgf->pgf_file = NULL;
454
455		pmcstat_gmon_create_file(pgf, image);
456
457		LIST_INSERT_HEAD(&image->pi_gmlist, pgf, pgf_next);
458	}
459
460	/*
461	 * Map the gmon file in if needed.  It may have been mapped
462	 * out under memory pressure.
463	 */
464	if (pgf->pgf_gmondata == NULL)
465		pmcstat_gmon_map_file(pgf);
466
467	assert(pgf->pgf_gmondata != NULL);
468
469	/*
470	 *
471	 */
472
473	bucket = (cc[0] - map->ppm_lowpc) / FUNCTION_ALIGNMENT;
474
475	assert(bucket < pgf->pgf_nbuckets);
476
477	hc = (HISTCOUNTER *) ((uintptr_t) pgf->pgf_gmondata +
478	    sizeof(struct gmonhdr));
479
480	/* saturating add */
481	if (hc[bucket] < 0xFFFFU)  /* XXX tie this to sizeof(HISTCOUNTER) */
482		hc[bucket]++;
483	else /* mark that an overflow occurred */
484		pgf->pgf_overflow = 1;
485
486	pgf->pgf_nsamples++;
487}
488
489/*
490 * Shutdown module.
491 */
492
493void
494pmcpl_gmon_shutdown(FILE *mf)
495{
496	int i;
497	struct pmcstat_gmonfile *pgf;
498	struct pmcstat_image *pi;
499
500	/*
501	 * Sync back all gprof flat profile data.
502	 */
503	for (i = 0; i < PMCSTAT_NHASH; i++) {
504		LIST_FOREACH(pi, &pmcstat_image_hash[i], pi_next) {
505			if (mf)
506				(void) fprintf(mf, " \"%s\" => \"%s\"",
507				    pmcstat_string_unintern(pi->pi_execpath),
508				    pmcstat_string_unintern(
509				    pi->pi_samplename));
510
511			/* flush gmon.out data to disk */
512			LIST_FOREACH(pgf, &pi->pi_gmlist, pgf_next) {
513				pmcstat_gmon_unmap_file(pgf);
514				if (mf)
515					(void) fprintf(mf, " %s/%d",
516					    pmcstat_pmcid_to_name(
517					    pgf->pgf_pmcid),
518					    pgf->pgf_nsamples);
519				if (pgf->pgf_overflow && args.pa_verbosity >= 1)
520					warnx(
521"WARNING: profile \"%s\" overflowed.",
522					    pmcstat_string_unintern(
523					        pgf->pgf_name));
524			}
525
526			if (mf)
527				(void) fprintf(mf, "\n");
528		}
529	}
530
531	/*
532	 * Compute arcs and add these to the gprof files.
533	 */
534	if (args.pa_flags & FLAG_DO_GPROF && args.pa_graphdepth > 1)
535		pmcstat_callgraph_do_gmon_arcs();
536}
537