/*
- * Copyright (c) 2009 Nicira Networks.
+ * Copyright (c) 2009, 2010 Nicira Networks.
*
- * Permission to use, copy, modify, and/or distribute this software for any
- * purpose with or without fee is hereby granted, provided that the above
- * copyright notice and this permission notice appear in all copies.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
*
- * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
- * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
- * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
- * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
- * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
- * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
- * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
*/
#include <config.h>
#include "coverage.h"
#include <inttypes.h>
#include <stdlib.h>
-#include "coverage-counters.h"
#include "dynamic-string.h"
#include "hash.h"
+#include "unixctl.h"
#include "util.h"
-
-#define THIS_MODULE VLM_coverage
#include "vlog.h"
+VLOG_DEFINE_THIS_MODULE(coverage);
+
+/* The coverage counters. */
+#if USE_LINKER_SECTIONS
+extern struct coverage_counter *__start_coverage[];
+extern struct coverage_counter *__stop_coverage[];
+#define coverage_counters __start_coverage
+#define n_coverage_counters (__stop_coverage - __start_coverage)
+#else /* !USE_LINKER_SECTIONS */
+#define COVERAGE_COUNTER(NAME) COVERAGE_DEFINE__(NAME);
+#include "coverage.def"
+#undef COVERAGE_COUNTER
+
+struct coverage_counter *coverage_counters[] = {
+#define COVERAGE_COUNTER(NAME) &counter_##NAME,
+#include "coverage.def"
+#undef COVERAGE_COUNTER
+};
+#define n_coverage_counters ARRAY_SIZE(coverage_counters)
+#endif /* !USE_LINKER_SECTIONS */
+
static unsigned int epoch;
+static void
+coverage_unixctl_log(struct unixctl_conn *conn, const char *args OVS_UNUSED,
+ void *aux OVS_UNUSED)
+{
+ coverage_log(VLL_WARN, false);
+ unixctl_command_reply(conn, 200, NULL);
+}
+
+void
+coverage_init(void)
+{
+ unixctl_command_register("coverage/log", coverage_unixctl_log, NULL);
+}
+
/* Sorts coverage counters in descending order by count, within equal counts
* alphabetically by name. */
static int
int n_groups, i;
/* Sort coverage counters into groups with equal counts. */
- c = xmalloc(coverage_n_counters * sizeof *c);
- for (i = 0; i < coverage_n_counters; i++) {
+ c = xmalloc(n_coverage_counters * sizeof *c);
+ for (i = 0; i < n_coverage_counters; i++) {
c[i] = coverage_counters[i];
}
- qsort(c, coverage_n_counters, sizeof *c, compare_coverage_counters);
+ qsort(c, n_coverage_counters, sizeof *c, compare_coverage_counters);
/* Hash the names in each group along with the rank. */
n_groups = 0;
- for (i = 0; i < coverage_n_counters; ) {
+ for (i = 0; i < n_coverage_counters; ) {
int j;
if (!c[i]->count) {
}
n_groups++;
hash = hash_int(i, hash);
- for (j = i; j < coverage_n_counters; j++) {
+ for (j = i; j < n_coverage_counters; j++) {
if (c[j]->count != c[i]->count) {
break;
}
unsigned int word_mask = 1u << (bit_index % BITS_PER_WORD);
if (hit[word_index] & word_mask) {
- return true;
+ return true;
} else {
hit[word_index] |= word_mask;
return false;
VLOG(level, "%-24s %5u / %9llu", c->name, c->count, c->count + c->total);
}
-/* Logs the coverage counters at the given vlog 'level'. */
+/* Logs the coverage counters at the given vlog 'level'. If
+ * 'suppress_dups' is true, then duplicate events are not displayed.
+ * Care should be taken in the value used for 'level'. Depending on the
+ * configuration, syslog can write changes synchronously, which can
+ * cause the coverage messages to take several seconds to write. */
void
-coverage_log(enum vlog_level level)
+coverage_log(enum vlog_level level, bool suppress_dups)
{
size_t n_never_hit;
uint32_t hash;
}
hash = coverage_hash();
- if (coverage_hit(hash)) {
- VLOG(level, "Skipping details of duplicate event coverage for "
- "hash=%08"PRIx32" in epoch %u", hash, epoch);
- return;
+ if (suppress_dups) {
+ if (coverage_hit(hash)) {
+ VLOG(level, "Skipping details of duplicate event coverage for "
+ "hash=%08"PRIx32" in epoch %u", hash, epoch);
+ return;
+ }
}
n_never_hit = 0;
VLOG(level, "Event coverage (epoch %u/entire run), hash=%08"PRIx32":",
epoch, hash);
- for (i = 0; i < coverage_n_counters; i++) {
+ for (i = 0; i < n_coverage_counters; i++) {
struct coverage_counter *c = coverage_counters[i];
if (c->count) {
coverage_log_counter(level, c);
}
}
- for (i = 0; i < coverage_n_counters; i++) {
+ for (i = 0; i < n_coverage_counters; i++) {
struct coverage_counter *c = coverage_counters[i];
if (!c->count) {
if (c->total) {
size_t i;
epoch++;
- for (i = 0; i < coverage_n_counters; i++) {
+ for (i = 0; i < n_coverage_counters; i++) {
struct coverage_counter *c = coverage_counters[i];
c->total += c->count;
c->count = 0;
git://git.onelab.eu / sliver-openvswitch.git / blobdiff