The SPDX folks have obsoleted the BSD-2-Clause-FreeBSD identifier. Catch up to that fact and revert to their recommended match of BSD-2-Clause. Discussed with: pfg MFC After: 3 days Sponsored by: Netflix
814 lines
19 KiB
C
814 lines
19 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* 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;
|
|
|
|
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);
|
|
}
|