/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
* Copyright (c) 2008 Nokia Corporation
* All rights reserved.
*
* This software was developed by Attilio Rao for the IPSO project under
* contract to Nokia Corporation.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice unmodified, this list of conditions, and the following
* disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/queue.h>
#include <ctype.h>
#include <paths.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/* NB: Make sure FNBUFF is as large as LNBUFF, otherwise it could overflow */
#define FNBUFF 512
#define LNBUFF 512
#define TMPNAME "pmcannotate.XXXXXX"
#define FATAL(ptr, x ...) do { \
fqueue_deleteall(); \
general_deleteall(); \
if ((ptr) != NULL) \
perror(ptr); \
fprintf(stderr, ##x); \
remove(tbfl); \
remove(tofl); \
exit(EXIT_FAILURE); \
} while (0)
#define PERCSAMP(x) ((x) * 100 / totalsamples)
struct entry {
TAILQ_ENTRY(entry) en_iter;
char *en_name;
uintptr_t en_pc;
uintptr_t en_ostart;
uintptr_t en_oend;
u_int en_nsamples;
};
struct aggent {
TAILQ_ENTRY(aggent) ag_fiter;
long ag_offset;
uintptr_t ag_ostart;
uintptr_t ag_oend;
char *ag_name;
u_int ag_nsamples;
};
static struct aggent *agg_create(const char *name, u_int nsamples,
uintptr_t start, uintptr_t end);
static void agg_destroy(struct aggent *agg) __unused;
static void asmparse(FILE *fp);
static int cparse(FILE *fp);
static void entry_acqref(struct entry *entry);
static struct entry *entry_create(const char *name, uintptr_t pc,
uintptr_t start, uintptr_t end);
static void entry_destroy(struct entry *entry) __unused;
static void fqueue_compact(float th);
static void fqueue_deleteall(void);
static struct aggent *fqueue_findent_by_name(const char *name);
static int fqueue_getall(const char *bin, char *temp, int asmf);
static int fqueue_insertent(struct entry *entry);
static int fqueue_insertgen(void);
static void general_deleteall(void);
static struct entry *general_findent(uintptr_t pc);
static void general_insertent(struct entry *entry);
static void general_printasm(FILE *fp, struct aggent *agg);
static int general_printc(FILE *fp, struct aggent *agg);
static int printblock(FILE *fp, struct aggent *agg);
static void usage(const char *progname) __dead2;
static TAILQ_HEAD(, entry) mainlst = TAILQ_HEAD_INITIALIZER(mainlst);
static TAILQ_HEAD(, aggent) fqueue = TAILQ_HEAD_INITIALIZER(fqueue);
/*
* Use a float value in order to automatically promote operations
* to return a float value rather than use casts.
*/
static float totalsamples;
/*
* Identifies a string cointaining objdump's assembly printout.
*/
static inline int
isasminline(const char *str)
{
void *ptr;
int nbytes;
if (sscanf(str, " %p%n", &ptr, &nbytes) != 1)
return (0);
if (str[nbytes] != ':' || isspace(str[nbytes + 1]) == 0)
return (0);
return (1);
}
/*
* Identifies a string containing objdump's assembly printout
* for a new function.
*/
static inline int
newfunction(const char *str)
{
char fname[FNBUFF];
void *ptr;
int nbytes;
if (isspace(str[0]))
return (0);
if (sscanf(str, "%p <%[^>:]>:%n", &ptr, fname, &nbytes) != 2)
return (0);
return (nbytes);
}
/*
* Create a new first-level aggregation object for a specified
* function.
*/
static struct aggent *
agg_create(const char *name, u_int nsamples, uintptr_t start, uintptr_t end)
{
struct aggent *agg;
agg = calloc(1, sizeof(struct aggent));
if (agg == NULL)
return (NULL);
agg->ag_name = strdup(name);
if (agg->ag_name == NULL) {
free(agg);
return (NULL);
}
agg->ag_nsamples = nsamples;
agg->ag_ostart = start;
agg->ag_oend = end;
return (agg);
}
/*
* Destroy a first-level aggregation object for a specified
* function.
*/
static void
agg_destroy(struct aggent *agg)
{
free(agg->ag_name);
free(agg);
}
/*
* Analyze the "objdump -d" output, locate functions and start
* printing out the assembly functions content.
* We do not use newfunction() because we actually need the
* function name in available form, but the heurstic used is
* the same.
*/
static void
asmparse(FILE *fp)
{
char buffer[LNBUFF], fname[FNBUFF];
struct aggent *agg;
void *ptr;
while (fgets(buffer, LNBUFF, fp) != NULL) {
if (isspace(buffer[0]))
continue;
if (sscanf(buffer, "%p <%[^>:]>:", &ptr, fname) != 2)
continue;
agg = fqueue_findent_by_name(fname);
if (agg == NULL)
continue;
agg->ag_offset = ftell(fp);
}
TAILQ_FOREACH(agg, &fqueue, ag_fiter) {
if (fseek(fp, agg->ag_offset, SEEK_SET) == -1)
return;
printf("Profile trace for function: %s() [%.2f%%]\n",
agg->ag_name, PERCSAMP(agg->ag_nsamples));
general_printasm(fp, agg);
printf("\n");
}
}
/*
* Analyze the "objdump -S" output, locate functions and start
* printing out the C functions content.
* We do not use newfunction() because we actually need the
* function name in available form, but the heurstic used is
* the same.
* In order to maintain the printout sorted, on the first pass it
* simply stores the file offsets in order to fastly moved later
* (when the file is hot-cached also) when the real printout will
* happen.
*/
static int
cparse(FILE *fp)
{
char buffer[LNBUFF], fname[FNBUFF];
struct aggent *agg;
void *ptr;
while (fgets(buffer, LNBUFF, fp) != NULL) {
if (isspace(buffer[0]))
continue;
if (sscanf(buffer, "%p <%[^>:]>:", &ptr, fname) != 2)
continue;
agg = fqueue_findent_by_name(fname);
if (agg == NULL)
continue;
agg->ag_offset = ftell(fp);
}
TAILQ_FOREACH(agg, &fqueue, ag_fiter) {
if (fseek(fp, agg->ag_offset, SEEK_SET) == -1)
return (-1);
printf("Profile trace for function: %s() [%.2f%%]\n",
agg->ag_name, PERCSAMP(agg->ag_nsamples));
if (general_printc(fp, agg) == -1)
return (-1);
printf("\n");
}
return (0);
}
/*
* Bump the number of samples for any raw entry.
*/
static void
entry_acqref(struct entry *entry)
{
entry->en_nsamples++;
}
/*
* Create a new raw entry object for a specified function.
*/
static struct entry *
entry_create(const char *name, uintptr_t pc, uintptr_t start, uintptr_t end)
{
struct entry *obj;
obj = calloc(1, sizeof(struct entry));
if (obj == NULL)
return (NULL);
obj->en_name = strdup(name);
if (obj->en_name == NULL) {
free(obj);
return (NULL);
}
obj->en_pc = pc;
obj->en_ostart = start;
obj->en_oend = end;
obj->en_nsamples = 1;
return (obj);
}
/*
* Destroy a raw entry object for a specified function.
*/
static void
entry_destroy(struct entry *entry)
{
free(entry->en_name);
free(entry);
}
/*
* Specify a lower bound in percentage and drop from the
* first-level aggregation queue all the objects with a
* smaller impact.
*/
static void
fqueue_compact(float th)
{
u_int thi;
struct aggent *agg, *tmpagg;
if (totalsamples == 0)
return;
/* Revert the percentage calculation. */
thi = th * totalsamples / 100;
TAILQ_FOREACH_SAFE(agg, &fqueue, ag_fiter, tmpagg)
if (agg->ag_nsamples < thi)
TAILQ_REMOVE(&fqueue, agg, ag_fiter);
}
/*
* Flush the first-level aggregates queue.
*/
static void
fqueue_deleteall(void)
{
struct aggent *agg;
while (TAILQ_EMPTY(&fqueue) == 0) {
agg = TAILQ_FIRST(&fqueue);
TAILQ_REMOVE(&fqueue, agg, ag_fiter);
}
}
/*
* Insert a raw entry into the aggregations queue.
* If the respective first-level aggregation object
* does not exist create it and maintain it sorted
* in respect of the number of samples.
*/
static int
fqueue_insertent(struct entry *entry)
{
struct aggent *obj, *tmp;
int found;
found = 0;
TAILQ_FOREACH(obj, &fqueue, ag_fiter)
if (!strcmp(obj->ag_name, entry->en_name)) {
found = 1;
obj->ag_nsamples += entry->en_nsamples;
break;
}
/*
* If the first-level aggregation object already exists,
* just aggregate the samples and, if needed, resort
* it.
*/
if (found) {
TAILQ_REMOVE(&fqueue, obj, ag_fiter);
found = 0;
TAILQ_FOREACH(tmp, &fqueue, ag_fiter)
if (obj->ag_nsamples > tmp->ag_nsamples) {
found = 1;
break;
}
if (found)
TAILQ_INSERT_BEFORE(tmp, obj, ag_fiter);
else
TAILQ_INSERT_TAIL(&fqueue, obj, ag_fiter);
return (0);
}
/*
* If the first-level aggregation object does not
* exist, create it and put in the sorted queue.
* If this is the first object, we need to set the
* head of the queue.
*/
obj = agg_create(entry->en_name, entry->en_nsamples, entry->en_ostart,
entry->en_oend);
if (obj == NULL)
return (-1);
if (TAILQ_EMPTY(&fqueue) != 0) {
TAILQ_INSERT_HEAD(&fqueue, obj, ag_fiter);
return (0);
}
TAILQ_FOREACH(tmp, &fqueue, ag_fiter)
if (obj->ag_nsamples > tmp->ag_nsamples) {
found = 1;
break;
}
if (found)
TAILQ_INSERT_BEFORE(tmp, obj, ag_fiter);
else
TAILQ_INSERT_TAIL(&fqueue, obj, ag_fiter);
return (0);
}
/*
* Lookup a first-level aggregation object by name.
*/
static struct aggent *
fqueue_findent_by_name(const char *name)
{
struct aggent *obj;
TAILQ_FOREACH(obj, &fqueue, ag_fiter)
if (!strcmp(obj->ag_name, name))
return (obj);
return (NULL);
}
/*
* Return the number of object in the first-level aggregations queue.
*/
static int
fqueue_getall(const char *bin, char *temp, int asmf)
{
char tmpf[MAXPATHLEN * 2 + 50];
struct aggent *agg;
uintptr_t start, end;
if (mkstemp(temp) == -1)
return (-1);
TAILQ_FOREACH(agg, &fqueue, ag_fiter) {
bzero(tmpf, sizeof(tmpf));
start = agg->ag_ostart;
end = agg->ag_oend;
/*
* Fix-up the end address in order to show it in the objdump's
* trace.
*/
end++;
if (asmf)
snprintf(tmpf, sizeof(tmpf),
"objdump --start-address=%p "
"--stop-address=%p -d %s >> %s", (void *)start,
(void *)end, bin, temp);
else
snprintf(tmpf, sizeof(tmpf),
"objdump --start-address=%p "
"--stop-address=%p -S %s >> %s", (void *)start,
(void *)end, bin, temp);
if (system(tmpf) != 0)
return (-1);
}
return (0);
}
/*
* Insert all the raw entries present in the general queue
* into the first-level aggregations queue.
*/
static int
fqueue_insertgen(void)
{
struct entry *obj;
TAILQ_FOREACH(obj, &mainlst, en_iter)
if (fqueue_insertent(obj) == -1)
return (-1);
return (0);
}
/*
* Flush the raw entries general queue.
*/
static void
general_deleteall(void)
{
struct entry *obj;
while (TAILQ_EMPTY(&mainlst) == 0) {
obj = TAILQ_FIRST(&mainlst);
TAILQ_REMOVE(&mainlst, obj, en_iter);
}
}
/*
* Lookup a raw entry by the PC.
*/
static struct entry *
general_findent(uintptr_t pc)
{
struct entry *obj;
TAILQ_FOREACH(obj, &mainlst, en_iter)
if (obj->en_pc == pc)
return (obj);
return (NULL);
}
/*
* Insert a new raw entry in the general queue.
*/
static void
general_insertent(struct entry *entry)
{
TAILQ_INSERT_TAIL(&mainlst, entry, en_iter);
}
/*
* Printout the body of an "objdump -d" assembly function.
* It does simply stops when a new function is encountered,
* bringing back the file position in order to not mess up
* subsequent analysis.
* C lines and others not recognized are simply skipped.
*/
static void
general_printasm(FILE *fp, struct aggent *agg)
{
char buffer[LNBUFF];
struct entry *obj;
int nbytes;
void *ptr;
while (fgets(buffer, LNBUFF, fp) != NULL) {
if ((nbytes = newfunction(buffer)) != 0) {
fseek(fp, nbytes * -1, SEEK_CUR);
break;
}
if (!isasminline(buffer))
continue;
if (sscanf(buffer, " %p:", &ptr) != 1)
continue;
obj = general_findent((uintptr_t)ptr);
if (obj == NULL)
printf("\t| %s", buffer);
else
printf("%.2f%%\t| %s",
(float)obj->en_nsamples * 100 / agg->ag_nsamples,
buffer);
}
}
/*
* Printout the body of an "objdump -S" function.
* It does simply stops when a new function is encountered,
* bringing back the file position in order to not mess up
* subsequent analysis.
* It expect from the starting to the end to find, always, valid blocks
* (see below for an explanation of the "block" concept).
*/
static int
general_printc(FILE *fp, struct aggent *agg)
{
char buffer[LNBUFF];
while (fgets(buffer, LNBUFF, fp) != NULL) {
fseek(fp, strlen(buffer) * -1, SEEK_CUR);
if (newfunction(buffer) != 0)
break;
if (printblock(fp, agg) == -1)
return (-1);
}
return (0);
}
/*
* Printout a single block inside an "objdump -S" function.
* The block is composed of a first part in C and subsequent translation
* in assembly.
* This code also operates a second-level aggregation packing together
* samples relative to PCs into a (lower bottom) block with their
* C (higher half) counterpart.
*/
static int
printblock(FILE *fp, struct aggent *agg)
{
char buffer[LNBUFF];
long lstart;
struct entry *obj;
u_int tnsamples;
int done, nbytes, sentinel;
void *ptr;
/*
* We expect the first thing of the block is C code, so simply give
* up if asm line is found.
*/
lstart = ftell(fp);
sentinel = 0;
for (;;) {
if (fgets(buffer, LNBUFF, fp) == NULL)
return (0);
if (isasminline(buffer) != 0)
break;
sentinel = 1;
nbytes = newfunction(buffer);
if (nbytes != 0) {
if (fseek(fp, nbytes * -1, SEEK_CUR) == -1)
return (-1);
return (0);
}
}
/*
* If the sentinel is not set, it means it did not match any
* "high half" for this code so simply give up.
* Operates the second-level aggregation.
*/
tnsamples = 0;
do {
if (sentinel == 0)
return (-1);
if (sscanf(buffer, " %p:", &ptr) != 1)
return (-1);
obj = general_findent((uintptr_t)ptr);
if (obj != NULL)
tnsamples += obj->en_nsamples;
} while (fgets(buffer, LNBUFF, fp) != NULL && isasminline(buffer) != 0);
/* Rewind to the start of the block in order to start the printout. */
if (fseek(fp, lstart, SEEK_SET) == -1)
return (-1);
/* Again the high half of the block rappresenting the C part. */
done = 0;
while (fgets(buffer, LNBUFF, fp) != NULL && isasminline(buffer) == 0) {
if (tnsamples == 0 || done != 0)
printf("\t| %s", buffer);
else {
done = 1;
printf("%.2f%%\t| %s",
(float)tnsamples * 100 / agg->ag_nsamples, buffer);
}
}
/*
* Again the low half of the block rappresenting the asm
* translation part.
*/
for (;;) {
if (fgets(buffer, LNBUFF, fp) == NULL)
return (0);
if (isasminline(buffer) == 0)
break;
nbytes = newfunction(buffer);
if (nbytes != 0) {
if (fseek(fp, nbytes * -1, SEEK_CUR) == -1)
return (-1);
return (0);
}
}
if (fseek(fp, strlen(buffer) * -1, SEEK_CUR) == -1)
return (-1);
return (0);
}
/*
* Helper printout functions.
*/
static void
usage(const char *progname)
{
fprintf(stderr,
"usage: %s [-a] [-h] [-k kfile] [-l lb] pmcraw.out binary\n",
progname);
exit(EXIT_SUCCESS);
}
int
main(int argc, char *argv[])
{
char buffer[LNBUFF], fname[FNBUFF];
char *tbfl, *tofl, *tmpdir;
char tmpf[MAXPATHLEN * 2 + 50];
float limit;
char *bin, *exec, *kfile, *ofile;
struct entry *obj;
FILE *gfp, *bfp;
void *ptr, *hstart, *hend;
uintptr_t tmppc, ostart, oend;
int cget, asmsrc;
exec = argv[0];
ofile = NULL;
bin = NULL;
kfile = NULL;
asmsrc = 0;
limit = 0.5;
while ((cget = getopt(argc, argv, "ahl:k:")) != -1)
switch(cget) {
case 'a':
asmsrc = 1;
break;
case 'k':
kfile = optarg;
break;
case 'l':
limit = (float)atof(optarg);
break;
case 'h':
case '?':
default:
usage(exec);
}
argc -= optind;
argv += optind;
if (argc != 2)
usage(exec);
ofile = argv[0];
bin = argv[1];
if (access(bin, R_OK | F_OK) == -1)
FATAL(exec, "%s: Impossible to locate the binary file\n",
exec);
if (access(ofile, R_OK | F_OK) == -1)
FATAL(exec, "%s: Impossible to locate the pmcstat file\n",
exec);
if (kfile != NULL && access(kfile, R_OK | F_OK) == -1)
FATAL(exec, "%s: Impossible to locate the kernel file\n",
exec);
bzero(tmpf, sizeof(tmpf));
tmpdir = getenv("TMPDIR");
if (tmpdir == NULL) {
asprintf(&tbfl, "%s/%s", _PATH_TMP, TMPNAME);
asprintf(&tofl, "%s/%s", _PATH_TMP, TMPNAME);
} else {
asprintf(&tbfl, "%s/%s", tmpdir, TMPNAME);
asprintf(&tofl, "%s/%s", tmpdir, TMPNAME);
}
if (tofl == NULL || tbfl == NULL)
FATAL(exec, "%s: Cannot create tempfile templates\n",
exec);
if (mkstemp(tofl) == -1)
FATAL(exec, "%s: Impossible to create the tmp file\n",
exec);
if (kfile != NULL)
snprintf(tmpf, sizeof(tmpf), "pmcstat -k %s -R %s -m %s",
kfile, ofile, tofl);
else
snprintf(tmpf, sizeof(tmpf), "pmcstat -R %s -m %s", ofile,
tofl);
if (system(tmpf) != 0)
FATAL(exec, "%s: Impossible to create the tmp file\n",
exec);
gfp = fopen(tofl, "r");
if (gfp == NULL)
FATAL(exec, "%s: Impossible to open the map file\n",
exec);
/*
* Make the collection of raw entries from a pmcstat mapped file.
* The heuristic here wants strings in the form:
* "addr funcname startfaddr endfaddr".
*/
while (fgets(buffer, LNBUFF, gfp) != NULL) {
if (isspace(buffer[0]))
continue;
if (sscanf(buffer, "%p %s %p %p\n", &ptr, fname,
&hstart, &hend) != 4)
FATAL(NULL,
"%s: Invalid scan of function in the map file\n",
exec);
ostart = (uintptr_t)hstart;
oend = (uintptr_t)hend;
tmppc = (uintptr_t)ptr;
totalsamples++;
obj = general_findent(tmppc);
if (obj != NULL) {
entry_acqref(obj);
continue;
}
obj = entry_create(fname, tmppc, ostart, oend);
if (obj == NULL)
FATAL(exec,
"%s: Impossible to create a new object\n", exec);
general_insertent(obj);
}
if (fclose(gfp) == EOF)
FATAL(exec, "%s: Impossible to close the filedesc\n",
exec);
if (remove(tofl) == -1)
FATAL(exec, "%s: Impossible to remove the tmpfile\n",
exec);
/*
* Remove the loose end objects and feed the first-level aggregation
* queue.
*/
if (fqueue_insertgen() == -1)
FATAL(exec, "%s: Impossible to generate an analysis\n",
exec);
fqueue_compact(limit);
if (fqueue_getall(bin, tbfl, asmsrc) == -1)
FATAL(exec, "%s: Impossible to create the tmp file\n",
exec);
bfp = fopen(tbfl, "r");
if (bfp == NULL)
FATAL(exec, "%s: Impossible to open the binary file\n",
exec);
if (asmsrc != 0)
asmparse(bfp);
else if (cparse(bfp) == -1)
FATAL(NULL, "%s: Invalid format for the C file\n", exec);
if (fclose(bfp) == EOF)
FATAL(exec, "%s: Impossible to close the filedesc\n",
exec);
if (remove(tbfl) == -1)
FATAL(exec, "%s: Impossible to remove the tmpfile\n",
exec);
return (0);
}
