/*
- * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <config.h>
#include "timeval.h"
-#include <assert.h>
#include <errno.h>
-#if HAVE_EXECINFO_H
-#include <execinfo.h>
-#endif
#include <poll.h>
#include <signal.h>
#include <stdlib.h>
#include "util.h"
#include "vlog.h"
+/* backtrace() from <execinfo.h> is really useful, but it is not signal safe
+ * everywhere, such as on x86-64. */
+#if HAVE_BACKTRACE && !defined __x86_64__
+# define USE_BACKTRACE 1
+# include <execinfo.h>
+#else
+# define USE_BACKTRACE 0
+#endif
+
VLOG_DEFINE_THIS_MODULE(timeval);
/* The clock to use for measuring time intervals. This is CLOCK_MONOTONIC by
const struct timespec *a, const struct timespec *b);
static unixctl_cb_func backtrace_cb;
-#ifndef HAVE_EXECINFO_H
-#define HAVE_EXECINFO_H 0
-
+#if !USE_BACKTRACE
static int
backtrace(void **buffer OVS_UNUSED, int size OVS_UNUSED)
{
{
NOT_REACHED();
}
-#endif
+#endif /* !USE_BACKTRACE */
/* Initializes the timetracking module, if not already initialized. */
static void
}
inited = true;
+ /* The implementation of backtrace() in glibc does some one time
+ * initialization which is not signal safe. This can cause deadlocks if
+ * run from the signal handler. As a workaround, force the initialization
+ * to happen here. */
+ if (USE_BACKTRACE) {
+ void *bt[1];
+
+ backtrace(bt, ARRAY_SIZE(bt));
+ }
+
memset(traces, 0, sizeof traces);
- if (HAVE_EXECINFO_H && CACHE_TIME) {
+ if (USE_BACKTRACE && CACHE_TIME) {
unixctl_command_register("backtrace", "", 0, 0, backtrace_cb, NULL);
}
time_refresh();
now = time_msec();
- msecs = secs * 1000;
+ msecs = secs * 1000LL;
block_sigalrm(&oldsigs);
deadline = now < LLONG_MAX - msecs ? now + msecs : LLONG_MAX;
wall_tick = true;
monotonic_tick = true;
- if (HAVE_EXECINFO_H && CACHE_TIME) {
+ if (USE_BACKTRACE && CACHE_TIME) {
struct trace *trace = &traces[trace_head];
trace->n_frames = backtrace(trace->backtrace,
sigset_t sigalrm;
sigemptyset(&sigalrm);
sigaddset(&sigalrm, SIGALRM);
- xsigprocmask(SIG_BLOCK, &sigalrm, oldsigs);
+ xpthread_sigmask(SIG_BLOCK, &sigalrm, oldsigs);
}
static void
unblock_sigalrm(const sigset_t *oldsigs)
{
- xsigprocmask(SIG_SETMASK, oldsigs, NULL);
+ xpthread_sigmask(SIG_SETMASK, oldsigs, NULL);
}
long long int
{
long long int interval = time_msec() - last_wakeup;
- if (interval >= 1000) {
+ if (interval >= 1000 && !warp_offset.tv_sec && !warp_offset.tv_nsec) {
const struct rusage *last_rusage = get_recent_rusage();
struct rusage rusage;
return NULL;
}
-
-static void
-format_backtraces(struct ds *ds)
+/* Appends a string to 'ds' representing backtraces recorded at regular
+ * intervals in the recent past. This information can be used to get a sense
+ * of what the process has been spending the majority of time doing. Will
+ * ommit any backtraces which have not occurred at least 'min_count' times. */
+void
+format_backtraces(struct ds *ds, size_t min_count)
{
time_init();
- if (HAVE_EXECINFO_H && CACHE_TIME) {
+ if (USE_BACKTRACE && CACHE_TIME) {
struct hmap trace_map = HMAP_INITIALIZER(&trace_map);
struct trace *trace, *next;
sigset_t oldsigs;
hmap_remove(&trace_map, &trace->node);
+ if (trace->count < min_count) {
+ continue;
+ }
+
frame_strs = backtrace_symbols(trace->backtrace, trace->n_frames);
ds_put_format(ds, "Count %zu\n", trace->count);
{
struct ds ds = DS_EMPTY_INITIALIZER;
- assert(HAVE_EXECINFO_H && CACHE_TIME);
- format_backtraces(&ds);
+ ovs_assert(USE_BACKTRACE && CACHE_TIME);
+ format_backtraces(&ds, 0);
unixctl_command_reply(conn, ds_cstr(&ds));
ds_destroy(&ds);
}