Levels are treated as severity ones. Default level remains INFO and two
additional levels WARN and ERR are added.
Signed-off-by: Eli Britstein <el...@nvidia.com>
---
lib/conntrack-tcp.c | 4 ++--
lib/conntrack.c | 10 +++++-----
lib/coverage.c | 12 ++++++++++++
lib/coverage.h | 6 ++++++
lib/dpif-netdev.c | 24 ++++++++++++------------
lib/dpif.c | 6 +++---
lib/flow.c | 8 ++++----
lib/hindex.c | 2 +-
lib/ipf.c | 6 +++---
lib/lockfile.c | 2 +-
lib/netdev-afxdp.c | 8 ++++----
lib/netdev-dpdk.c | 2 +-
lib/netdev-linux.c | 4 ++--
lib/netdev-native-tnl.c | 4 ++--
lib/netdev.c | 4 ++--
lib/netlink-socket.c | 2 +-
lib/odp-execute.c | 34 +++++++++++++++++-----------------
lib/ovsdb-idl.c | 2 +-
lib/tc.c | 2 +-
ofproto/ofproto-dpif-upcall.c | 22 +++++++++++-----------
ofproto/ofproto-dpif-xlate.c | 4 ++--
ofproto/ofproto-dpif.c | 2 +-
22 files changed, 94 insertions(+), 76 deletions(-)
diff --git a/lib/conntrack-tcp.c b/lib/conntrack-tcp.c
index 8a7c98cc4..c3d52d231 100644
--- a/lib/conntrack-tcp.c
+++ b/lib/conntrack-tcp.c
@@ -46,8 +46,8 @@
#include "util.h"
COVERAGE_DEFINE(conntrack_tcp_seq_chk_bypass);
-COVERAGE_DEFINE(conntrack_tcp_seq_chk_failed);
-COVERAGE_DEFINE(conntrack_invalid_tcp_flags);
+COVERAGE_DEFINE_ERR(conntrack_tcp_seq_chk_failed);
+COVERAGE_DEFINE_ERR(conntrack_invalid_tcp_flags);
struct tcp_peer {
uint32_t seqlo; /* Max sequence number sent */
diff --git a/lib/conntrack.c b/lib/conntrack.c
index 00262a0c6..3b3235b7b 100644
--- a/lib/conntrack.c
+++ b/lib/conntrack.c
@@ -47,13 +47,13 @@
VLOG_DEFINE_THIS_MODULE(conntrack);
-COVERAGE_DEFINE(conntrack_full);
+COVERAGE_DEFINE_ERR(conntrack_full);
COVERAGE_DEFINE(conntrack_l3csum_checked);
-COVERAGE_DEFINE(conntrack_l3csum_err);
+COVERAGE_DEFINE_ERR(conntrack_l3csum_err);
COVERAGE_DEFINE(conntrack_l4csum_checked);
-COVERAGE_DEFINE(conntrack_l4csum_err);
-COVERAGE_DEFINE(conntrack_lookup_natted_miss);
-COVERAGE_DEFINE(conntrack_zone_full);
+COVERAGE_DEFINE_ERR(conntrack_l4csum_err);
+COVERAGE_DEFINE_WARN(conntrack_lookup_natted_miss);
+COVERAGE_DEFINE_WARN(conntrack_zone_full);
struct conn_lookup_ctx {
struct conn_key key;
diff --git a/lib/coverage.c b/lib/coverage.c
index fab739b59..7d22e499b 100644
--- a/lib/coverage.c
+++ b/lib/coverage.c
@@ -35,6 +35,8 @@ static size_t allocated_coverage_counters[COVERAGE_LEVELS];
static struct ovs_mutex coverage_mutex[COVERAGE_LEVELS] = {
[COVERAGE_LEVEL_INFO] = OVS_MUTEX_INITIALIZER,
+ [COVERAGE_LEVEL_WARN] = OVS_MUTEX_INITIALIZER,
+ [COVERAGE_LEVEL_ERR] = OVS_MUTEX_INITIALIZER,
};
DEFINE_STATIC_PER_THREAD_DATA(long long int, coverage_clear_time, LLONG_MIN);
@@ -70,6 +72,10 @@ coverage_level_name(enum coverage_level level)
switch (level) {
case COVERAGE_LEVEL_INFO:
return "info";
+ case COVERAGE_LEVEL_WARN:
+ return "warning";
+ case COVERAGE_LEVEL_ERR:
+ return "error";
case COVERAGE_LEVELS:
default:
OVS_NOT_REACHED();
@@ -246,6 +252,10 @@ coverage_vlog_level(const char *line)
{
if (line[0] == COVERAGE_LEVEL_INFO) {
return VLL_INFO;
+ } else if (line[0] == COVERAGE_LEVEL_WARN) {
+ return VLL_WARN;
+ } else if (line[0] == COVERAGE_LEVEL_ERR) {
+ return VLL_ERR;
}
OVS_NOT_REACHED();
@@ -264,6 +274,8 @@ coverage_log__(enum coverage_level level)
{
static struct vlog_rate_limit rl[COVERAGE_LEVELS] = {
[COVERAGE_LEVEL_INFO] = VLOG_RATE_LIMIT_INIT(1, 3),
+ [COVERAGE_LEVEL_WARN] = VLOG_RATE_LIMIT_INIT(1, 3),
+ [COVERAGE_LEVEL_ERR] = VLOG_RATE_LIMIT_INIT(1, 3),
};
if (!VLOG_DROP_INFO(&rl[level])) {
diff --git a/lib/coverage.h b/lib/coverage.h
index 8614b03d2..73cc5734a 100644
--- a/lib/coverage.h
+++ b/lib/coverage.h
@@ -55,10 +55,16 @@ struct coverage_counter {
};
enum coverage_level {
+ COVERAGE_LEVEL_ERR,
+ COVERAGE_LEVEL_WARN,
COVERAGE_LEVEL_INFO,
COVERAGE_LEVELS
};
+#define COVERAGE_DEFINE_ERR(COUNTER) \
+ COVERAGE_DEFINE__(COUNTER, COVERAGE_LEVEL_ERR)
+#define COVERAGE_DEFINE_WARN(COUNTER) \
+ COVERAGE_DEFINE__(COUNTER, COVERAGE_LEVEL_WARN)
#define COVERAGE_DEFINE(COUNTER) \
COVERAGE_DEFINE__(COUNTER, COVERAGE_LEVEL_INFO)
diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c
index 87d69c46d..949951631 100644
--- a/lib/dpif-netdev.c
+++ b/lib/dpif-netdev.c
@@ -109,19 +109,19 @@ DEFINE_STATIC_PER_THREAD_DATA(uint32_t, recirc_depth, 0)
enum { MAX_METERS = 1 << 18 }; /* Maximum number of meters. */
enum { MAX_BANDS = 8 }; /* Maximum number of bands / meter. */
-COVERAGE_DEFINE(datapath_drop_meter);
-COVERAGE_DEFINE(datapath_drop_upcall_error);
-COVERAGE_DEFINE(datapath_drop_lock_error);
-COVERAGE_DEFINE(datapath_drop_userspace_action_error);
-COVERAGE_DEFINE(datapath_drop_tunnel_push_error);
-COVERAGE_DEFINE(datapath_drop_tunnel_pop_error);
-COVERAGE_DEFINE(datapath_drop_recirc_error);
-COVERAGE_DEFINE(datapath_drop_invalid_port);
-COVERAGE_DEFINE(datapath_drop_invalid_bond);
-COVERAGE_DEFINE(datapath_drop_invalid_tnl_port);
-COVERAGE_DEFINE(datapath_drop_rx_invalid_packet);
+COVERAGE_DEFINE_WARN(datapath_drop_meter);
+COVERAGE_DEFINE_ERR(datapath_drop_upcall_error);
+COVERAGE_DEFINE_ERR(datapath_drop_lock_error);
+COVERAGE_DEFINE_ERR(datapath_drop_userspace_action_error);
+COVERAGE_DEFINE_WARN(datapath_drop_tunnel_push_error);
+COVERAGE_DEFINE_WARN(datapath_drop_tunnel_pop_error);
+COVERAGE_DEFINE_WARN(datapath_drop_recirc_error);
+COVERAGE_DEFINE_WARN(datapath_drop_invalid_port);
+COVERAGE_DEFINE_WARN(datapath_drop_invalid_bond);
+COVERAGE_DEFINE_WARN(datapath_drop_invalid_tnl_port);
+COVERAGE_DEFINE_ERR(datapath_drop_rx_invalid_packet);
#ifdef ALLOW_EXPERIMENTAL_API /* Packet restoration API required. */
-COVERAGE_DEFINE(datapath_drop_hw_miss_recover);
+COVERAGE_DEFINE_WARN(datapath_drop_hw_miss_recover);
#endif
/* Protects against changes to 'dp_netdevs'. */
diff --git a/lib/dpif.c b/lib/dpif.c
index 070fc0131..33793ecc3 100644
--- a/lib/dpif.c
+++ b/lib/dpif.c
@@ -57,13 +57,13 @@ VLOG_DEFINE_THIS_MODULE(dpif);
COVERAGE_DEFINE(dpif_destroy);
COVERAGE_DEFINE(dpif_execute);
-COVERAGE_DEFINE(dpif_execute_error);
+COVERAGE_DEFINE_ERR(dpif_execute_error);
COVERAGE_DEFINE(dpif_execute_with_help);
COVERAGE_DEFINE(dpif_flow_del);
-COVERAGE_DEFINE(dpif_flow_del_error);
+COVERAGE_DEFINE_WARN(dpif_flow_del_error);
COVERAGE_DEFINE(dpif_flow_flush);
COVERAGE_DEFINE(dpif_flow_get);
-COVERAGE_DEFINE(dpif_flow_get_error);
+COVERAGE_DEFINE_ERR(dpif_flow_get_error);
COVERAGE_DEFINE(dpif_flow_put);
COVERAGE_DEFINE(dpif_flow_put_error);
COVERAGE_DEFINE(dpif_meter_del);
diff --git a/lib/flow.c b/lib/flow.c
index b522f7f11..97bc3dbe9 100644
--- a/lib/flow.c
+++ b/lib/flow.c
@@ -49,10 +49,10 @@
VLOG_DEFINE_THIS_MODULE(flow);
COVERAGE_DEFINE(flow_extract);
-COVERAGE_DEFINE(miniflow_extract_ipv4_pkt_len_error);
-COVERAGE_DEFINE(miniflow_extract_ipv4_pkt_too_short);
-COVERAGE_DEFINE(miniflow_extract_ipv6_pkt_len_error);
-COVERAGE_DEFINE(miniflow_extract_ipv6_pkt_too_short);
+COVERAGE_DEFINE_ERR(miniflow_extract_ipv4_pkt_len_error);
+COVERAGE_DEFINE_ERR(miniflow_extract_ipv4_pkt_too_short);
+COVERAGE_DEFINE_ERR(miniflow_extract_ipv6_pkt_len_error);
+COVERAGE_DEFINE_ERR(miniflow_extract_ipv6_pkt_too_short);
COVERAGE_DEFINE(miniflow_malloc);
/* U64 indices for segmented flow classification. */
diff --git a/lib/hindex.c b/lib/hindex.c
index 260649bf8..4e6238669 100644
--- a/lib/hindex.c
+++ b/lib/hindex.c
@@ -23,7 +23,7 @@ static bool hindex_node_is_head(const struct hindex_node *);
static void hindex_resize(struct hindex *, size_t new_mask);
static size_t hindex_calc_mask(size_t capacity);
-COVERAGE_DEFINE(hindex_pathological);
+COVERAGE_DEFINE_WARN(hindex_pathological);
COVERAGE_DEFINE(hindex_expand);
COVERAGE_DEFINE(hindex_shrink);
COVERAGE_DEFINE(hindex_reserve);
diff --git a/lib/ipf.c b/lib/ipf.c
index b16797312..7e08481c6 100644
--- a/lib/ipf.c
+++ b/lib/ipf.c
@@ -36,10 +36,10 @@
#include "util.h"
VLOG_DEFINE_THIS_MODULE(ipf);
-COVERAGE_DEFINE(ipf_stuck_frag_list_expired);
-COVERAGE_DEFINE(ipf_stuck_frag_list_purged);
+COVERAGE_DEFINE_WARN(ipf_stuck_frag_list_expired);
+COVERAGE_DEFINE_WARN(ipf_stuck_frag_list_purged);
COVERAGE_DEFINE(ipf_l3csum_checked);
-COVERAGE_DEFINE(ipf_l3csum_err);
+COVERAGE_DEFINE_ERR(ipf_l3csum_err);
enum {
IPV4_PACKET_MAX_HDR_SIZE = 60,
diff --git a/lib/lockfile.c b/lib/lockfile.c
index 42782d29e..3323767ae 100644
--- a/lib/lockfile.c
+++ b/lib/lockfile.c
@@ -35,7 +35,7 @@
VLOG_DEFINE_THIS_MODULE(lockfile);
COVERAGE_DEFINE(lockfile_lock);
-COVERAGE_DEFINE(lockfile_error);
+COVERAGE_DEFINE_ERR(lockfile_error);
COVERAGE_DEFINE(lockfile_unlock);
struct lockfile {
diff --git a/lib/netdev-afxdp.c b/lib/netdev-afxdp.c
index 54029722e..49353730b 100644
--- a/lib/netdev-afxdp.c
+++ b/lib/netdev-afxdp.c
@@ -60,10 +60,10 @@
#define SOL_XDP 283
#endif
-COVERAGE_DEFINE(afxdp_cq_empty);
-COVERAGE_DEFINE(afxdp_fq_full);
-COVERAGE_DEFINE(afxdp_tx_full);
-COVERAGE_DEFINE(afxdp_cq_skip);
+COVERAGE_DEFINE_WARN(afxdp_cq_empty);
+COVERAGE_DEFINE_WARN(afxdp_fq_full);
+COVERAGE_DEFINE_WARN(afxdp_tx_full);
+COVERAGE_DEFINE_WARN(afxdp_cq_skip);
VLOG_DEFINE_THIS_MODULE(netdev_afxdp);
diff --git a/lib/netdev-dpdk.c b/lib/netdev-dpdk.c
index 17b4d6677..613e71033 100644
--- a/lib/netdev-dpdk.c
+++ b/lib/netdev-dpdk.c
@@ -80,7 +80,7 @@ enum {VIRTIO_RXQ, VIRTIO_TXQ, VIRTIO_QNUM};
VLOG_DEFINE_THIS_MODULE(netdev_dpdk);
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
-COVERAGE_DEFINE(vhost_tx_contention);
+COVERAGE_DEFINE_WARN(vhost_tx_contention);
static char *vhost_sock_dir = NULL; /* Location of vhost-user sockets */
static bool vhost_iommu_enabled = false; /* Status of vHost IOMMU support */
diff --git a/lib/netdev-linux.c b/lib/netdev-linux.c
index a63d03d48..744cb2353 100644
--- a/lib/netdev-linux.c
+++ b/lib/netdev-linux.c
@@ -89,8 +89,8 @@ COVERAGE_DEFINE(netdev_get_hwaddr);
COVERAGE_DEFINE(netdev_set_hwaddr);
COVERAGE_DEFINE(netdev_get_ethtool);
COVERAGE_DEFINE(netdev_set_ethtool);
-COVERAGE_DEFINE(netdev_linux_invalid_l4_csum);
-COVERAGE_DEFINE(netdev_linux_unknown_l4_csum);
+COVERAGE_DEFINE_WARN(netdev_linux_invalid_l4_csum);
+COVERAGE_DEFINE_WARN(netdev_linux_unknown_l4_csum);
#ifndef IFLA_IF_NETNSID
diff --git a/lib/netdev-native-tnl.c b/lib/netdev-native-tnl.c
index 439f0679d..a2e513855 100644
--- a/lib/netdev-native-tnl.c
+++ b/lib/netdev-native-tnl.c
@@ -51,9 +51,9 @@ VLOG_DEFINE_THIS_MODULE(native_tnl);
static struct vlog_rate_limit err_rl = VLOG_RATE_LIMIT_INIT(60, 5);
COVERAGE_DEFINE(native_tnl_l3csum_checked);
-COVERAGE_DEFINE(native_tnl_l3csum_err);
+COVERAGE_DEFINE_ERR(native_tnl_l3csum_err);
COVERAGE_DEFINE(native_tnl_l4csum_checked);
-COVERAGE_DEFINE(native_tnl_l4csum_err);
+COVERAGE_DEFINE_ERR(native_tnl_l4csum_err);
#define VXLAN_HLEN (sizeof(struct udp_header) + \
sizeof(struct vxlanhdr))
diff --git a/lib/netdev.c b/lib/netdev.c
index df5b35232..620c1cfb9 100644
--- a/lib/netdev.c
+++ b/lib/netdev.c
@@ -69,9 +69,9 @@ COVERAGE_DEFINE(netdev_received);
COVERAGE_DEFINE(netdev_sent);
COVERAGE_DEFINE(netdev_add_router);
COVERAGE_DEFINE(netdev_get_stats);
-COVERAGE_DEFINE(netdev_push_header_drops);
+COVERAGE_DEFINE_ERR(netdev_push_header_drops);
COVERAGE_DEFINE(netdev_soft_seg_good);
-COVERAGE_DEFINE(netdev_soft_seg_drops);
+COVERAGE_DEFINE_ERR(netdev_soft_seg_drops);
struct netdev_saved_flags {
struct netdev *netdev;
diff --git a/lib/netlink-socket.c b/lib/netlink-socket.c
index 976ed15e8..4cfa5057a 100644
--- a/lib/netlink-socket.c
+++ b/lib/netlink-socket.c
@@ -41,7 +41,7 @@
VLOG_DEFINE_THIS_MODULE(netlink_socket);
-COVERAGE_DEFINE(netlink_overflow);
+COVERAGE_DEFINE_WARN(netlink_overflow);
COVERAGE_DEFINE(netlink_received);
COVERAGE_DEFINE(netlink_recv_jumbo);
COVERAGE_DEFINE(netlink_sent);
diff --git a/lib/odp-execute.c b/lib/odp-execute.c
index 649f8e99a..4a33659bf 100644
--- a/lib/odp-execute.c
+++ b/lib/odp-execute.c
@@ -42,24 +42,24 @@
#include "unixctl.h"
VLOG_DEFINE_THIS_MODULE(odp_execute);
-COVERAGE_DEFINE(datapath_drop_sample_error);
-COVERAGE_DEFINE(datapath_drop_nsh_decap_error);
+COVERAGE_DEFINE_WARN(datapath_drop_sample_error);
+COVERAGE_DEFINE_ERR(datapath_drop_nsh_decap_error);
COVERAGE_DEFINE(drop_action_of_pipeline);
-COVERAGE_DEFINE(drop_action_bridge_not_found);
-COVERAGE_DEFINE(drop_action_recursion_too_deep);
-COVERAGE_DEFINE(drop_action_too_many_resubmit);
-COVERAGE_DEFINE(drop_action_stack_too_deep);
-COVERAGE_DEFINE(drop_action_no_recirculation_context);
-COVERAGE_DEFINE(drop_action_recirculation_conflict);
-COVERAGE_DEFINE(drop_action_too_many_mpls_labels);
-COVERAGE_DEFINE(drop_action_invalid_tunnel_metadata);
-COVERAGE_DEFINE(drop_action_unsupported_packet_type);
-COVERAGE_DEFINE(drop_action_congestion);
-COVERAGE_DEFINE(drop_action_forwarding_disabled);
-COVERAGE_DEFINE(drop_action_tunnel_routing_failed);
-COVERAGE_DEFINE(drop_action_tunnel_output_no_ethernet);
-COVERAGE_DEFINE(drop_action_tunnel_neigh_cache_miss);
-COVERAGE_DEFINE(drop_action_tunnel_header_build_failed);
+COVERAGE_DEFINE_WARN(drop_action_bridge_not_found);
+COVERAGE_DEFINE_ERR(drop_action_recursion_too_deep);
+COVERAGE_DEFINE_ERR(drop_action_too_many_resubmit);
+COVERAGE_DEFINE_ERR(drop_action_stack_too_deep);
+COVERAGE_DEFINE_ERR(drop_action_no_recirculation_context);
+COVERAGE_DEFINE_ERR(drop_action_recirculation_conflict);
+COVERAGE_DEFINE_ERR(drop_action_too_many_mpls_labels);
+COVERAGE_DEFINE_WARN(drop_action_invalid_tunnel_metadata);
+COVERAGE_DEFINE_ERR(drop_action_unsupported_packet_type);
+COVERAGE_DEFINE_ERR(drop_action_congestion);
+COVERAGE_DEFINE_ERR(drop_action_forwarding_disabled);
+COVERAGE_DEFINE_WARN(drop_action_tunnel_routing_failed);
+COVERAGE_DEFINE_WARN(drop_action_tunnel_output_no_ethernet);
+COVERAGE_DEFINE_WARN(drop_action_tunnel_neigh_cache_miss);
+COVERAGE_DEFINE_WARN(drop_action_tunnel_header_build_failed);
static void
dp_update_drop_action_counter(enum xlate_error drop_reason,
diff --git a/lib/ovsdb-idl.c b/lib/ovsdb-idl.c
index cd781f300..7290b40ac 100644
--- a/lib/ovsdb-idl.c
+++ b/lib/ovsdb-idl.c
@@ -58,7 +58,7 @@ COVERAGE_DEFINE(txn_aborted);
COVERAGE_DEFINE(txn_success);
COVERAGE_DEFINE(txn_try_again);
COVERAGE_DEFINE(txn_not_locked);
-COVERAGE_DEFINE(txn_error);
+COVERAGE_DEFINE_ERR(txn_error);
/* An arc from one idl_row to another. When row A contains a UUID that
* references row B, this is represented by an arc from A (the source) to B
diff --git a/lib/tc.c b/lib/tc.c
index a5f9bc1c1..195fc5c13 100644
--- a/lib/tc.c
+++ b/lib/tc.c
@@ -69,7 +69,7 @@
VLOG_DEFINE_THIS_MODULE(tc);
-COVERAGE_DEFINE(tc_netlink_malformed_reply);
+COVERAGE_DEFINE_ERR(tc_netlink_malformed_reply);
static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(60, 5);
diff --git a/ofproto/ofproto-dpif-upcall.c b/ofproto/ofproto-dpif-upcall.c
index 9dfa52d82..97d4e157f 100644
--- a/ofproto/ofproto-dpif-upcall.c
+++ b/ofproto/ofproto-dpif-upcall.c
@@ -52,21 +52,21 @@
VLOG_DEFINE_THIS_MODULE(ofproto_dpif_upcall);
-COVERAGE_DEFINE(dumped_duplicate_flow);
-COVERAGE_DEFINE(dumped_inconsistent_flow);
+COVERAGE_DEFINE_WARN(dumped_duplicate_flow);
+COVERAGE_DEFINE_ERR(dumped_inconsistent_flow);
COVERAGE_DEFINE(dumped_new_flow);
-COVERAGE_DEFINE(handler_duplicate_upcall);
-COVERAGE_DEFINE(revalidate_missed_dp_flow);
-COVERAGE_DEFINE(revalidate_missing_dp_flow);
+COVERAGE_DEFINE_ERR(handler_duplicate_upcall);
+COVERAGE_DEFINE_WARN(revalidate_missed_dp_flow);
+COVERAGE_DEFINE_WARN(revalidate_missing_dp_flow);
COVERAGE_DEFINE(ukey_dp_change);
-COVERAGE_DEFINE(ukey_invalid_stat_reset);
+COVERAGE_DEFINE_WARN(ukey_invalid_stat_reset);
COVERAGE_DEFINE(ukey_replace_contention);
COVERAGE_DEFINE(upcall_flow_limit_grew);
-COVERAGE_DEFINE(upcall_flow_limit_hit);
-COVERAGE_DEFINE(upcall_flow_limit_kill);
-COVERAGE_DEFINE(upcall_flow_limit_reduced);
-COVERAGE_DEFINE(upcall_flow_limit_scaled);
-COVERAGE_DEFINE(upcall_ukey_contention);
+COVERAGE_DEFINE_WARN(upcall_flow_limit_hit);
+COVERAGE_DEFINE_ERR(upcall_flow_limit_kill);
+COVERAGE_DEFINE_WARN(upcall_flow_limit_reduced);
+COVERAGE_DEFINE_WARN(upcall_flow_limit_scaled);
+COVERAGE_DEFINE_WARN(upcall_ukey_contention);
COVERAGE_DEFINE(upcall_ukey_replace);
/* A thread that reads upcalls from dpif, forwards each upcall's packet,
diff --git a/ofproto/ofproto-dpif-xlate.c b/ofproto/ofproto-dpif-xlate.c
index 2c8197fb7..5f6d7f8f8 100644
--- a/ofproto/ofproto-dpif-xlate.c
+++ b/ofproto/ofproto-dpif-xlate.c
@@ -70,8 +70,8 @@
#include "vlan-bitmap.h"
COVERAGE_DEFINE(xlate_actions);
-COVERAGE_DEFINE(xlate_actions_oversize);
-COVERAGE_DEFINE(xlate_actions_too_many_output);
+COVERAGE_DEFINE_ERR(xlate_actions_oversize);
+COVERAGE_DEFINE_WARN(xlate_actions_too_many_output);
VLOG_DEFINE_THIS_MODULE(ofproto_dpif_xlate);
diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index ed9e44ce2..a79d0c979 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -78,7 +78,7 @@
VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
COVERAGE_DEFINE(ofproto_dpif_expired);
-COVERAGE_DEFINE(packet_in_overflow);
+COVERAGE_DEFINE_ERR(packet_in_overflow);
struct flow_miss;
--
2.34.1
_______________________________________________
dev mailing list
d...@openvswitch.org
https://mail.openvswitch.org/mailman/listinfo/ovs-dev
