xenserver: Add support for disabling in-band management via XAPI.
[openvswitch] / lib / coverage.c
1 /*
2  * Copyright (c) 2009, 2010 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "coverage.h"
19 #include <inttypes.h>
20 #include <stdlib.h>
21 #include "dynamic-string.h"
22 #include "hash.h"
23 #include "unixctl.h"
24 #include "util.h"
25 #include "vlog.h"
26
27 VLOG_DEFINE_THIS_MODULE(coverage);
28
29 /* The coverage counters. */
30 #if USE_LINKER_SECTIONS
31 extern struct coverage_counter *__start_coverage[];
32 extern struct coverage_counter *__stop_coverage[];
33 #define coverage_counters __start_coverage
34 #define n_coverage_counters  (__stop_coverage - __start_coverage)
35 #else  /* !USE_LINKER_SECTIONS */
36 #define COVERAGE_COUNTER(NAME) COVERAGE_DEFINE__(NAME);
37 #include "coverage.def"
38 #undef COVERAGE_COUNTER
39
40 struct coverage_counter *coverage_counters[] = {
41 #define COVERAGE_COUNTER(NAME) &counter_##NAME,
42 #include "coverage.def"
43 #undef COVERAGE_COUNTER
44 };
45 #define n_coverage_counters ARRAY_SIZE(coverage_counters)
46 #endif  /* !USE_LINKER_SECTIONS */
47
48 static unsigned int epoch;
49
50 static void
51 coverage_unixctl_log(struct unixctl_conn *conn, const char *args OVS_UNUSED,
52                      void *aux OVS_UNUSED)
53 {
54     coverage_log(VLL_WARN, false);
55     unixctl_command_reply(conn, 200, NULL);
56 }
57
58 void
59 coverage_init(void)
60 {
61     unixctl_command_register("coverage/log", coverage_unixctl_log, NULL);
62 }
63
64 /* Sorts coverage counters in descending order by count, within equal counts
65  * alphabetically by name. */
66 static int
67 compare_coverage_counters(const void *a_, const void *b_)
68 {
69     const struct coverage_counter *const *ap = a_;
70     const struct coverage_counter *const *bp = b_;
71     const struct coverage_counter *a = *ap;
72     const struct coverage_counter *b = *bp;
73     if (a->count != b->count) {
74         return a->count < b->count ? 1 : -1;
75     } else {
76         return strcmp(a->name, b->name);
77     }
78 }
79
80 static uint32_t
81 coverage_hash(void)
82 {
83     struct coverage_counter **c;
84     uint32_t hash = 0;
85     int n_groups, i;
86
87     /* Sort coverage counters into groups with equal counts. */
88     c = xmalloc(n_coverage_counters * sizeof *c);
89     for (i = 0; i < n_coverage_counters; i++) {
90         c[i] = coverage_counters[i];
91     }
92     qsort(c, n_coverage_counters, sizeof *c, compare_coverage_counters);
93
94     /* Hash the names in each group along with the rank. */
95     n_groups = 0;
96     for (i = 0; i < n_coverage_counters; ) {
97         int j;
98
99         if (!c[i]->count) {
100             break;
101         }
102         n_groups++;
103         hash = hash_int(i, hash);
104         for (j = i; j < n_coverage_counters; j++) {
105             if (c[j]->count != c[i]->count) {
106                 break;
107             }
108             hash = hash_string(c[j]->name, hash);
109         }
110         i = j;
111     }
112
113     free(c);
114
115     return hash_int(n_groups, hash);
116 }
117
118 static bool
119 coverage_hit(uint32_t hash)
120 {
121     enum { HIT_BITS = 1024, BITS_PER_WORD = 32 };
122     static uint32_t hit[HIT_BITS / BITS_PER_WORD];
123     BUILD_ASSERT_DECL(IS_POW2(HIT_BITS));
124
125     unsigned int bit_index = hash & (HIT_BITS - 1);
126     unsigned int word_index = bit_index / BITS_PER_WORD;
127     unsigned int word_mask = 1u << (bit_index % BITS_PER_WORD);
128
129     if (hit[word_index] & word_mask) {
130  return true;
131     } else {
132         hit[word_index] |= word_mask;
133         return false;
134     }
135 }
136
137 static void
138 coverage_log_counter(enum vlog_level level, const struct coverage_counter *c)
139 {
140     VLOG(level, "%-24s %5u / %9llu", c->name, c->count, c->count + c->total);
141 }
142
143 /* Logs the coverage counters at the given vlog 'level'.  If
144  * 'suppress_dups' is true, then duplicate events are not displayed.
145  * Care should be taken in the value used for 'level'.  Depending on the
146  * configuration, syslog can write changes synchronously, which can
147  * cause the coverage messages to take several seconds to write. */
148 void
149 coverage_log(enum vlog_level level, bool suppress_dups)
150 {
151     size_t n_never_hit;
152     uint32_t hash;
153     size_t i;
154
155     if (!vlog_is_enabled(THIS_MODULE, level)) {
156         return;
157     }
158
159     hash = coverage_hash();
160     if (suppress_dups) {
161         if (coverage_hit(hash)) {
162             VLOG(level, "Skipping details of duplicate event coverage for "
163                  "hash=%08"PRIx32" in epoch %u", hash, epoch);
164             return;
165         }
166     }
167
168     n_never_hit = 0;
169     VLOG(level, "Event coverage (epoch %u/entire run), hash=%08"PRIx32":",
170          epoch, hash);
171     for (i = 0; i < n_coverage_counters; i++) {
172         struct coverage_counter *c = coverage_counters[i];
173         if (c->count) {
174             coverage_log_counter(level, c);
175         }
176     }
177     for (i = 0; i < n_coverage_counters; i++) {
178         struct coverage_counter *c = coverage_counters[i];
179         if (!c->count) {
180             if (c->total) {
181                 coverage_log_counter(level, c);
182             } else {
183                 n_never_hit++;
184             }
185         }
186     }
187     VLOG(level, "%zu events never hit", n_never_hit);
188 }
189
190 /* Advances to the next epoch of coverage, resetting all the counters to 0. */
191 void
192 coverage_clear(void)
193 {
194     size_t i;
195
196     epoch++;
197     for (i = 0; i < n_coverage_counters; i++) {
198         struct coverage_counter *c = coverage_counters[i];
199         c->total += c->count;
200         c->count = 0;
201     }
202 }