/*
* Print out the specified DOF buffer as a set of ASCII bytes appropriate for
* storing in a driver.conf(4) file associated with the dtrace driver.
*/
static void
anon_prog(const dtrace_cmd_t *dcp, dof_hdr_t *dof, int n)
{
const uchar_t *p, *q;
if (dof == NULL)
dfatal("failed to create DOF image for '%s'", dcp->dc_name);
p = (uchar_t *)dof;
q = p + dof->dofh_loadsz;
#if defined(sun)
oprintf("dof-data-%d=0x%x", n, *p++);
while (p < q)
oprintf(",0x%x", *p++);
oprintf(";\n");
#else
/*
* On FreeBSD, the DOF data is handled as a kernel environment (kenv)
* string. We use two hex characters per DOF byte.
*/
oprintf("dof-data-%d=%02x", n, *p++);
while (p < q)
oprintf("%02x", *p++);
oprintf("\n");
#endif
dtrace_dof_destroy(g_dtp, dof);
}
static void
go(void)
{
int i;
struct {
char *name;
char *optname;
dtrace_optval_t val;
} bufs[] = {
{ "buffer size", "bufsize" },
{ "aggregation size", "aggsize" },
{ "speculation size", "specsize" },
{ "dynamic variable size", "dynvarsize" },
{ NULL }
}, rates[] = {
{ "cleaning rate", "cleanrate" },
{ "status rate", "statusrate" },
{ NULL }
};
for (i = 0; bufs[i].name != NULL; i++) {
if (dtrace_getopt(g_dtp, bufs[i].optname, &bufs[i].val) == -1)
fatal("couldn't get option %s", bufs[i].optname);
}
for (i = 0; rates[i].name != NULL; i++) {
if (dtrace_getopt(g_dtp, rates[i].optname, &rates[i].val) == -1)
fatal("couldn't get option %s", rates[i].optname);
}
if (dtrace_go(g_dtp) == -1)
dfatal("could not enable tracing");
for (i = 0; bufs[i].name != NULL; i++) {
dtrace_optval_t j = 0, mul = 10;
dtrace_optval_t nsize;
if (bufs[i].val == DTRACEOPT_UNSET)
continue;
(void) dtrace_getopt(g_dtp, bufs[i].optname, &nsize);
if (nsize == DTRACEOPT_UNSET || nsize == 0)
continue;
if (nsize >= bufs[i].val - sizeof (uint64_t))
continue;
for (; (INT64_C(1) << mul) <= nsize; j++, mul += 10)
continue;
if (!(nsize & ((INT64_C(1) << (mul - 10)) - 1))) {
error("%s lowered to %lld%c\n", bufs[i].name,
(long long)nsize >> (mul - 10), " kmgtpe"[j]);
} else {
static void
dprog_compile(void)
{
dtrace_prog_t *prog;
dtrace_proginfo_t info;
if (g_opt_V) {
(void) fprintf(stderr, "%s: vvvv D program vvvv\n", g_pname);
(void) fputs(g_prog, stderr);
(void) fprintf(stderr, "%s: ^^^^ D program ^^^^\n", g_pname);
}
if ((prog = dtrace_program_strcompile(g_dtp, g_prog,
DTRACE_PROBESPEC_NAME, 0, 0, NULL)) == NULL)
dfatal("failed to compile program");
if (dtrace_program_exec(g_dtp, prog, &info) == -1)
dfatal("failed to enable probes");
}
/*ARGSUSED*/
static int
chewrec(const dtrace_probedata_t *data, const dtrace_recdesc_t *rec, void *arg)
{
dtrace_eprobedesc_t *epd = data->dtpda_edesc;
dtrace_aggvarid_t aggvars[2];
const void *buf;
int i, nagv;
/*
* A NULL rec indicates that we've processed the last record.
*/
if (rec == NULL)
return (DTRACE_CONSUME_NEXT);
buf = data->dtpda_data - rec->dtrd_offset;
switch (rec->dtrd_action) {
case DTRACEACT_DIFEXPR:
(void) printf("\n%s\n\n", (char *)buf + rec->dtrd_offset);
if (!g_opt_s) {
print_legend();
print_bar();
}
return (DTRACE_CONSUME_NEXT);
case DTRACEACT_PRINTA:
for (nagv = 0, i = 0; i < epd->dtepd_nrecs - 1; i++) {
const dtrace_recdesc_t *nrec = &rec[i];
if (nrec->dtrd_uarg != rec->dtrd_uarg)
break;
/*LINTED - alignment*/
aggvars[nagv++] = *(dtrace_aggvarid_t *)((caddr_t)buf +
nrec->dtrd_offset);
}
if (nagv == (g_opt_s ? 1 : 2)) {
uint_t nent = 0;
if (dtrace_aggregate_walk_joined(g_dtp, aggvars, nagv,
process_aggregate, &nent) != 0)
dfatal("failed to walk aggregate");
}
return (DTRACE_CONSUME_NEXT);
}
return (DTRACE_CONSUME_THIS);
}
static void
compile_str(dtrace_cmd_t *dcp)
{
char *p;
if ((dcp->dc_prog = dtrace_program_strcompile(g_dtp, dcp->dc_arg,
dcp->dc_spec, g_cflags | DTRACE_C_PSPEC, g_argc, g_argv)) == NULL)
dfatal("invalid probe specifier %s", dcp->dc_arg);
if ((p = strpbrk(dcp->dc_arg, "{/;")) != NULL)
*p = '\0'; /* crop name for reporting */
dcp->dc_desc = "description";
dcp->dc_name = dcp->dc_arg;
}
/*
* Execute the specified program by enabling the corresponding instrumentation.
* If -e has been specified, we get the program info but do not enable it. If
* -v has been specified, we print a stability report for the program.
*/
static void
exec_prog(const dtrace_cmd_t *dcp)
{
dtrace_ecbdesc_t *last = NULL;
dtrace_proginfo_t dpi;
if (!g_exec) {
dtrace_program_info(g_dtp, dcp->dc_prog, &dpi);
} else if (dtrace_program_exec(g_dtp, dcp->dc_prog, &dpi) == -1) {
dfatal("failed to enable '%s'", dcp->dc_name);
} else {
notice("%s '%s' matched %u probe%s\n",
dcp->dc_desc, dcp->dc_name,
dpi.dpi_matches, dpi.dpi_matches == 1 ? "" : "s");
}
if (g_verbose) {
oprintf("\nStability attributes for %s %s:\n",
dcp->dc_desc, dcp->dc_name);
oprintf("\n\tMinimum Probe Description Attributes\n");
oprintf("\t\tIdentifier Names: %s\n",
dtrace_stability_name(dpi.dpi_descattr.dtat_name));
oprintf("\t\tData Semantics: %s\n",
dtrace_stability_name(dpi.dpi_descattr.dtat_data));
oprintf("\t\tDependency Class: %s\n",
dtrace_class_name(dpi.dpi_descattr.dtat_class));
oprintf("\n\tMinimum Statement Attributes\n");
oprintf("\t\tIdentifier Names: %s\n",
dtrace_stability_name(dpi.dpi_stmtattr.dtat_name));
oprintf("\t\tData Semantics: %s\n",
dtrace_stability_name(dpi.dpi_stmtattr.dtat_data));
oprintf("\t\tDependency Class: %s\n",
dtrace_class_name(dpi.dpi_stmtattr.dtat_class));
if (!g_exec) {
(void) dtrace_stmt_iter(g_dtp, dcp->dc_prog,
(dtrace_stmt_f *)info_stmt, &last);
} else
oprintf("\n");
}
g_total += dpi.dpi_matches;
}
static void
compile_file(dtrace_cmd_t *dcp)
{
char *arg0;
FILE *fp;
if ((fp = fopen(dcp->dc_arg, "r")) == NULL)
fatal("failed to open %s", dcp->dc_arg);
arg0 = g_argv[0];
g_argv[0] = dcp->dc_arg;
if ((dcp->dc_prog = dtrace_program_fcompile(g_dtp, fp,
g_cflags, g_argc, g_argv)) == NULL)
dfatal("failed to compile script %s", dcp->dc_arg);
g_argv[0] = arg0;
(void) fclose(fp);
dcp->dc_desc = "script";
dcp->dc_name = dcp->dc_arg;
}
void simple_timer_service::add_timer(task* task)
{
std::shared_ptr<boost::asio::deadline_timer> timer(new boost::asio::deadline_timer(_ios));
timer->expires_from_now(boost::posix_time::milliseconds(task->delay_milliseconds()));
task->set_delay(0);
timer->async_wait([this, task, timer](const boost::system::error_code& ec)
{
if (!ec)
{
task->enqueue();
}
else
{
dfatal("delayed execution failed for task %s, err = %u",
task->spec().name.c_str(), ec.value());
}
// to consume the added ref count by another task::enqueue
task->release_ref();
});
}
/*
* Link the specified D program in DOF form into an ELF file for use in either
* helpers, userland provider definitions, or both. If -o was specified, that
* path is used as the output file name. If -o wasn't specified and the input
* program is from a script whose name is %.d, use basename(%.o) as the output
* file name. Otherwise we use "d.out" as the default output file name.
*/
static void
link_prog(dtrace_cmd_t *dcp)
{
char *p;
if (g_cmdc == 1 && g_ofile != NULL) {
(void) strlcpy(dcp->dc_ofile, g_ofile, sizeof (dcp->dc_ofile));
} else if ((p = strrchr(dcp->dc_arg, '.')) != NULL &&
strcmp(p, ".d") == 0) {
p[0] = '\0'; /* strip .d suffix */
(void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile),
"%s.o", basename(dcp->dc_arg));
} else if (g_cmdc > 1) {
(void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile),
"d.out.%td", dcp - g_cmdv);
} else {
(void) snprintf(dcp->dc_ofile, sizeof (dcp->dc_ofile),
"d.out");
}
if (dtrace_program_link(g_dtp, dcp->dc_prog, DTRACE_D_PROBES,
dcp->dc_ofile, g_objc, g_objv) != 0)
dfatal("failed to link %s %s", dcp->dc_desc, dcp->dc_name);
}
static LONG WINAPI TopLevelFilter(struct _EXCEPTION_POINTERS *pExceptionInfo)
{
LONG retval = EXCEPTION_CONTINUE_SEARCH;
HWND hParent = NULL; // find a better value for your app
// firstly see if dbghelp.dll is around and has the function we need
// look next to the EXE first, as the one in System32 might be old
// (e.g. Windows 2000)
HMODULE hDll = NULL;
if (hDll == NULL)
{
// load any version we can
hDll = ::LoadLibraryA("DBGHELP.DLL");
}
LPCSTR szResult = "core dump success";
char szDumpPath[512];
char szScratch[512];
dfatal("fatal exception, core dump started ...");
if (hDll)
{
MINIDUMPWRITEDUMP pDump = (MINIDUMPWRITEDUMP)::GetProcAddress(hDll, "MiniDumpWriteDump");
if (pDump)
{
sprintf(szDumpPath, "%s\\%s_%d_%d.dmp", s_dump_dir.c_str(), s_app_name, ::GetCurrentProcessId(), time(NULL));
// create the file
HANDLE hFile = ::CreateFileA(szDumpPath, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
_MINIDUMP_EXCEPTION_INFORMATION ExInfo;
ExInfo.ThreadId = ::GetCurrentThreadId();
ExInfo.ExceptionPointers = pExceptionInfo;
ExInfo.ClientPointers = NULL;
// write the dump
BOOL bOK = pDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &ExInfo, NULL, NULL);
if (bOK)
{
sprintf(szScratch, "saved dump file to '%s'", szDumpPath);
szResult = szScratch;
retval = EXCEPTION_EXECUTE_HANDLER;
}
else
{
sprintf(szScratch, "failed to save dump file to '%s' (error %d)", szDumpPath, GetLastError());
szResult = szScratch;
}
::CloseHandle(hFile);
}
else
{
sprintf(szScratch, "failed to create dump file '%s' (error %d)", szDumpPath, GetLastError());
szResult = szScratch;
}
}
else
{
szResult = "DBGHELP.DLL too old";
}
}
else
{
szResult = "DBGHELP.DLL not found";
}
if (szResult)
{
derror("%s", szResult);
printf(szResult);
}
::dsn::tools::sys_exit.execute(SYS_EXIT_EXCEPTION);
return retval;
}
int
main(int argc, char **argv)
{
int err;
int opt_C = 0, opt_H = 0, opt_p = 0, opt_v = 0;
char c, *p, *end;
struct sigaction act;
int done = 0;
g_pname = basename(argv[0]);
argv[0] = g_pname; /* rewrite argv[0] for getopt errors */
while ((c = getopt(argc, argv, PLOCKSTAT_OPTSTR)) != EOF) {
switch (c) {
case 'n':
errno = 0;
g_nent = strtoul(optarg, &end, 10);
if (*end != '\0' || errno != 0) {
(void) fprintf(stderr, "%s: invalid count "
"'%s'\n", g_pname, optarg);
usage();
}
break;
case 'p':
opt_p = 1;
break;
case 'v':
opt_v = 1;
break;
case 'A':
opt_C = opt_H = 1;
break;
case 'C':
opt_C = 1;
break;
case 'H':
opt_H = 1;
break;
case 'V':
g_opt_V = 1;
break;
default:
if (strchr(PLOCKSTAT_OPTSTR, c) == NULL)
usage();
}
}
/*
* We need a command or at least one pid.
*/
if (argc == optind)
usage();
if (opt_C == 0 && opt_H == 0)
opt_C = 1;
if ((g_dtp = dtrace_open(DTRACE_VERSION, 0, &err)) == NULL)
fatal("failed to initialize dtrace: %s\n",
dtrace_errmsg(NULL, err));
/*
* The longest string we trace is 23 bytes long -- so 32 is plenty.
*/
if (dtrace_setopt(g_dtp, "strsize", "32") == -1)
dfatal("failed to set 'strsize'");
/*
* 1k should be more than enough for all trace() and printa() actions.
*/
if (dtrace_setopt(g_dtp, "bufsize", "1k") == -1)
dfatal("failed to set 'bufsize'");
/*
* The table we produce has the hottest locks at the top.
*/
if (dtrace_setopt(g_dtp, "aggsortrev", NULL) == -1)
dfatal("failed to set 'aggsortrev'");
/*
* These are two reasonable defaults which should suffice.
*/
if (dtrace_setopt(g_dtp, "aggsize", "256k") == -1)
dfatal("failed to set 'aggsize'");
if (dtrace_setopt(g_dtp, "aggrate", "1sec") == -1)
dfatal("failed to set 'aggrate'");
/*
* Take a second pass through to look for options that set options now
* that we have an open dtrace handle.
*/
optind = 1;
while ((c = getopt(argc, argv, PLOCKSTAT_OPTSTR)) != EOF) {
switch (c) {
case 's':
g_opt_s = 1;
if (dtrace_setopt(g_dtp, "ustackframes", optarg) == -1)
dfatal("failed to set 'ustackframes'");
break;
case 'x':
if ((p = strchr(optarg, '=')) != NULL)
*p++ = '\0';
if (dtrace_setopt(g_dtp, optarg, p) != 0)
dfatal("failed to set -x %s", optarg);
break;
case 'e':
errno = 0;
(void) strtoul(optarg, &end, 10);
if (*optarg == '-' || *end != '\0' || errno != 0) {
(void) fprintf(stderr, "%s: invalid timeout "
"'%s'\n", g_pname, optarg);
usage();
}
/*
* Construct a DTrace enabling that will exit after
* the specified number of seconds.
*/
dprog_add("BEGIN\n{\n\tend = timestamp + ");
dprog_add(optarg);
dprog_add(" * 1000000000;\n}\n");
dprog_add("tick-10hz\n/timestamp >= end/\n");
dprog_add("{\n\texit(0);\n}\n");
break;
}
}
argc -= optind;
argv += optind;
if (opt_H) {
dprog_add(g_hold_init);
if (g_opt_s == NULL)
dprog_add(g_hold_times);
else
dprog_add(g_hold_histogram);
}
if (opt_C) {
dprog_add(g_ctnd_init);
if (g_opt_s == NULL)
dprog_add(g_ctnd_times);
else
dprog_add(g_ctnd_histogram);
}
if (opt_p) {
ulong_t pid;
if (argc > 1) {
(void) fprintf(stderr, "%s: only one pid is allowed\n",
g_pname);
usage();
}
errno = 0;
pid = strtoul(argv[0], &end, 10);
if (*end != '\0' || errno != 0 || (pid_t)pid != pid) {
(void) fprintf(stderr, "%s: invalid pid '%s'\n",
g_pname, argv[0]);
usage();
}
if ((g_pr = dtrace_proc_grab(g_dtp, (pid_t)pid, 0)) == NULL)
dfatal(NULL);
} else {
if ((g_pr = dtrace_proc_create(g_dtp, argv[0], argv)) == NULL)
dfatal(NULL);
}
dprog_compile();
if (dtrace_handle_proc(g_dtp, &prochandler, NULL) == -1)
dfatal("failed to establish proc handler");
(void) sigemptyset(&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = intr;
(void) sigaction(SIGINT, &act, NULL);
(void) sigaction(SIGTERM, &act, NULL);
if (dtrace_go(g_dtp) != 0)
dfatal("dtrace_go()");
if (dtrace_getopt(g_dtp, "ustackframes", &g_nframes) != 0)
dfatal("failed to get 'ustackframes'");
dtrace_proc_continue(g_dtp, g_pr);
if (opt_v)
(void) printf("%s: tracing enabled for pid %d\n", g_pname,
(int)Pstatus(g_pr)->pr_pid);
do {
if (!g_intr && !done)
dtrace_sleep(g_dtp);
if (done || g_intr || g_exited) {
done = 1;
if (dtrace_stop(g_dtp) == -1)
dfatal("couldn't stop tracing");
}
switch (dtrace_work(g_dtp, stdout, NULL, chewrec, NULL)) {
case DTRACE_WORKSTATUS_DONE:
done = 1;
break;
case DTRACE_WORKSTATUS_OKAY:
break;
default:
dfatal("processing aborted");
}
} while (!done);
dtrace_close(g_dtp);
return (0);
}
