X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=44f3115bf6814f523c277e52ab38c6937126b397;hb=8811fc0ae150f51078321798b22d49e9f98fa454;hp=549616c90194c0400236089c8055d2f4d3357ddf;hpb=8961699e0310fd2b77035dc7bff63eb9538daf67;p=cascardo%2Fovs.git diff --git a/lib/ofp-print.c b/lib/ofp-print.c index 549616c90..44f3115bf 100644 --- a/lib/ofp-print.c +++ b/lib/ofp-print.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013 Nicira, Inc. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -37,44 +37,56 @@ #include "netdev.h" #include "nx-match.h" #include "ofp-actions.h" +#include "ofpbuf.h" #include "ofp-errors.h" #include "ofp-msgs.h" #include "ofp-util.h" -#include "ofpbuf.h" #include "openflow/openflow.h" #include "openflow/nicira-ext.h" #include "packets.h" +#include "dp-packet.h" #include "type-props.h" #include "unaligned.h" +#include "odp-util.h" #include "util.h" static void ofp_print_queue_name(struct ds *string, uint32_t port); static void ofp_print_error(struct ds *, enum ofperr); - /* Returns a string that represents the contents of the Ethernet frame in the * 'len' bytes starting at 'data'. The caller must free the returned string.*/ char * ofp_packet_to_string(const void *data, size_t len) { struct ds ds = DS_EMPTY_INITIALIZER; - struct ofpbuf buf; + struct dp_packet buf; struct flow flow; + size_t l4_size; - ofpbuf_use_const(&buf, data, len); - flow_extract(&buf, 0, 0, NULL, 0, &flow); + dp_packet_use_const(&buf, data, len); + flow_extract(&buf, &flow); flow_format(&ds, &flow); - if (buf.l7) { - if (flow.nw_proto == IPPROTO_TCP) { - struct tcp_header *th = buf.l4; - ds_put_format(&ds, " tcp_csum:%"PRIx16, - ntohs(th->tcp_csum)); - } else if (flow.nw_proto == IPPROTO_UDP) { - struct udp_header *uh = buf.l4; - ds_put_format(&ds, " udp_csum:%"PRIx16, - ntohs(uh->udp_csum)); - } + l4_size = dp_packet_l4_size(&buf); + + if (flow.nw_proto == IPPROTO_TCP && l4_size >= TCP_HEADER_LEN) { + struct tcp_header *th = dp_packet_l4(&buf); + ds_put_format(&ds, " tcp_csum:%"PRIx16, ntohs(th->tcp_csum)); + } else if (flow.nw_proto == IPPROTO_UDP && l4_size >= UDP_HEADER_LEN) { + struct udp_header *uh = dp_packet_l4(&buf); + ds_put_format(&ds, " udp_csum:%"PRIx16, ntohs(uh->udp_csum)); + } else if (flow.nw_proto == IPPROTO_SCTP && l4_size >= SCTP_HEADER_LEN) { + struct sctp_header *sh = dp_packet_l4(&buf); + ds_put_format(&ds, " sctp_csum:%"PRIx32, + ntohl(get_16aligned_be32(&sh->sctp_csum))); + } else if (flow.nw_proto == IPPROTO_ICMP && l4_size >= ICMP_HEADER_LEN) { + struct icmp_header *icmph = dp_packet_l4(&buf); + ds_put_format(&ds, " icmp_csum:%"PRIx16, + ntohs(icmph->icmp_csum)); + } else if (flow.nw_proto == IPPROTO_ICMPV6 && l4_size >= ICMP6_HEADER_LEN) { + struct icmp6_header *icmp6h = dp_packet_l4(&buf); + ds_put_format(&ds, " icmp6_csum:%"PRIx16, + ntohs(icmp6h->icmp6_cksum)); } ds_put_char(&ds, '\n'); @@ -89,7 +101,6 @@ ofp_print_packet_in(struct ds *string, const struct ofp_header *oh, char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; struct ofputil_packet_in pin; int error; - int i; error = ofputil_decode_packet_in(&pin, oh); if (error) { @@ -101,40 +112,19 @@ ofp_print_packet_in(struct ds *string, const struct ofp_header *oh, ds_put_format(string, " table_id=%"PRIu8, pin.table_id); } - if (pin.cookie) { + if (pin.cookie != OVS_BE64_MAX) { ds_put_format(string, " cookie=0x%"PRIx64, ntohll(pin.cookie)); } - ds_put_format(string, " total_len=%"PRIu16" in_port=", pin.total_len); - ofputil_format_port(pin.fmd.in_port, string); - - if (pin.fmd.tun_id != htonll(0)) { - ds_put_format(string, " tun_id=0x%"PRIx64, ntohll(pin.fmd.tun_id)); - } - - if (pin.fmd.tun_src != htonl(0)) { - ds_put_format(string, " tun_src="IP_FMT, IP_ARGS(pin.fmd.tun_src)); - } - - if (pin.fmd.tun_dst != htonl(0)) { - ds_put_format(string, " tun_dst="IP_FMT, IP_ARGS(pin.fmd.tun_dst)); - } - - if (pin.fmd.metadata != htonll(0)) { - ds_put_format(string, " metadata=0x%"PRIx64, ntohll(pin.fmd.metadata)); - } + ds_put_format(string, " total_len=%"PRIuSIZE" ", pin.total_len); - for (i = 0; i < FLOW_N_REGS; i++) { - if (pin.fmd.regs[i]) { - ds_put_format(string, " reg%d=0x%"PRIx32, i, pin.fmd.regs[i]); - } - } + match_format(&pin.flow_metadata, string, OFP_DEFAULT_PRIORITY); ds_put_format(string, " (via %s)", ofputil_packet_in_reason_to_string(pin.reason, reasonbuf, sizeof reasonbuf)); - ds_put_format(string, " data_len=%zu", pin.packet_len); + ds_put_format(string, " data_len=%"PRIuSIZE, pin.packet_len); if (pin.buffer_id == UINT32_MAX) { ds_put_format(string, " (unbuffered)"); if (pin.total_len != pin.packet_len) { @@ -177,11 +167,11 @@ ofp_print_packet_out(struct ds *string, const struct ofp_header *oh, ds_put_cstr(string, " in_port="); ofputil_format_port(po.in_port, string); - ds_put_char(string, ' '); + ds_put_cstr(string, " actions="); ofpacts_format(po.ofpacts, po.ofpacts_len, string); if (po.buffer_id == UINT32_MAX) { - ds_put_format(string, " data_len=%zu", po.packet_len); + ds_put_format(string, " data_len=%"PRIuSIZE, po.packet_len); if (verbosity > 0 && po.packet_len > 0) { char *packet = ofp_packet_to_string(po.packet, po.packet_len); ds_put_char(string, '\n'); @@ -204,8 +194,8 @@ compare_ports(const void *a_, const void *b_) { const struct ofputil_phy_port *a = a_; const struct ofputil_phy_port *b = b_; - uint16_t ap = a->port_no; - uint16_t bp = b->port_no; + uint16_t ap = ofp_to_u16(a->port_no); + uint16_t bp = ofp_to_u16(b->port_no); return ap < bp ? -1 : ap > bp; } @@ -409,28 +399,33 @@ static void ofp_print_phy_ports(struct ds *string, uint8_t ofp_version, struct ofpbuf *b) { - size_t n_ports; struct ofputil_phy_port *ports; - enum ofperr error; + size_t allocated_ports, n_ports; + int retval; size_t i; - n_ports = ofputil_count_phy_ports(ofp_version, b); + ports = NULL; + allocated_ports = 0; + for (n_ports = 0; ; n_ports++) { + if (n_ports >= allocated_ports) { + ports = x2nrealloc(ports, &allocated_ports, sizeof *ports); + } - ports = xmalloc(n_ports * sizeof *ports); - for (i = 0; i < n_ports; i++) { - error = ofputil_pull_phy_port(ofp_version, b, &ports[i]); - if (error) { - ofp_print_error(string, error); - goto exit; + retval = ofputil_pull_phy_port(ofp_version, b, &ports[n_ports]); + if (retval) { + break; } } + qsort(ports, n_ports, sizeof *ports, compare_ports); for (i = 0; i < n_ports; i++) { ofp_print_phy_port(string, &ports[i]); } - -exit: free(ports); + + if (retval != EOF) { + ofp_print_error(string, retval); + } } static const char * @@ -453,45 +448,6 @@ ofputil_capabilities_to_name(uint32_t bit) return NULL; } -static const char * -ofputil_action_bitmap_to_name(uint32_t bit) -{ - enum ofputil_action_bitmap action = bit; - - switch (action) { - case OFPUTIL_A_OUTPUT: return "OUTPUT"; - case OFPUTIL_A_SET_VLAN_VID: return "SET_VLAN_VID"; - case OFPUTIL_A_SET_VLAN_PCP: return "SET_VLAN_PCP"; - case OFPUTIL_A_STRIP_VLAN: return "STRIP_VLAN"; - case OFPUTIL_A_SET_DL_SRC: return "SET_DL_SRC"; - case OFPUTIL_A_SET_DL_DST: return "SET_DL_DST"; - case OFPUTIL_A_SET_NW_SRC: return "SET_NW_SRC"; - case OFPUTIL_A_SET_NW_DST: return "SET_NW_DST"; - case OFPUTIL_A_SET_NW_ECN: return "SET_NW_ECN"; - case OFPUTIL_A_SET_NW_TOS: return "SET_NW_TOS"; - case OFPUTIL_A_SET_TP_SRC: return "SET_TP_SRC"; - case OFPUTIL_A_SET_TP_DST: return "SET_TP_DST"; - case OFPUTIL_A_SET_FIELD: return "SET_FIELD"; - case OFPUTIL_A_ENQUEUE: return "ENQUEUE"; - case OFPUTIL_A_COPY_TTL_OUT: return "COPY_TTL_OUT"; - case OFPUTIL_A_COPY_TTL_IN: return "COPY_TTL_IN"; - case OFPUTIL_A_SET_MPLS_LABEL: return "SET_MPLS_LABEL"; - case OFPUTIL_A_SET_MPLS_TC: return "SET_MPLS_TC"; - case OFPUTIL_A_SET_MPLS_TTL: return "SET_MPLS_TTL"; - case OFPUTIL_A_DEC_MPLS_TTL: return "DEC_MPLS_TTL"; - case OFPUTIL_A_PUSH_VLAN: return "PUSH_VLAN"; - case OFPUTIL_A_POP_VLAN: return "POP_VLAN"; - case OFPUTIL_A_PUSH_MPLS: return "PUSH_MPLS"; - case OFPUTIL_A_POP_MPLS: return "POP_MPLS"; - case OFPUTIL_A_SET_QUEUE: return "SET_QUEUE"; - case OFPUTIL_A_GROUP: return "GROUP"; - case OFPUTIL_A_SET_NW_TTL: return "SET_NW_TTL"; - case OFPUTIL_A_DEC_NW_TTL: return "DEC_NW_TTL"; - } - - return NULL; -} - static void ofp_print_switch_features(struct ds *string, const struct ofp_header *oh) { @@ -522,17 +478,18 @@ ofp_print_switch_features(struct ds *string, const struct ofp_header *oh) switch ((enum ofp_version)oh->version) { case OFP10_VERSION: ds_put_cstr(string, "actions: "); - ofp_print_bit_names(string, features.actions, - ofputil_action_bitmap_to_name, ' '); + ofpact_bitmap_format(features.ofpacts, string); ds_put_char(string, '\n'); break; case OFP11_VERSION: case OFP12_VERSION: break; case OFP13_VERSION: + case OFP14_VERSION: + case OFP15_VERSION: return; /* no ports in ofp13_switch_features */ default: - NOT_REACHED(); + OVS_NOT_REACHED(); } ofp_print_phy_ports(string, oh->version, &b); @@ -562,7 +519,7 @@ ofp_print_switch_config(struct ds *string, const struct ofp_switch_config *osc) static void print_wild(struct ds *string, const char *leader, int is_wild, int verbosity, const char *format, ...) - __attribute__((format(printf, 5, 6))); + OVS_PRINTF_FORMAT(5, 6); static void print_wild(struct ds *string, const char *leader, int is_wild, int verbosity, const char *format, ...) @@ -585,7 +542,7 @@ static void print_wild(struct ds *string, const char *leader, int is_wild, static void print_wild_port(struct ds *string, const char *leader, int is_wild, - int verbosity, uint16_t port) + int verbosity, ofp_port_t port) { if (is_wild && verbosity < 2) { return; @@ -645,6 +602,8 @@ ofp10_match_to_string(const struct ofp10_match *om, int verbosity) ds_put_cstr(&f, "tcp,"); } else if (om->nw_proto == IPPROTO_UDP) { ds_put_cstr(&f, "udp,"); + } else if (om->nw_proto == IPPROTO_SCTP) { + ds_put_cstr(&f, "sctp,"); } else { ds_put_cstr(&f, "ip,"); skip_proto = false; @@ -665,7 +624,7 @@ ofp10_match_to_string(const struct ofp10_match *om, int verbosity) } } print_wild_port(&f, "in_port=", w & OFPFW10_IN_PORT, verbosity, - ntohs(om->in_port)); + u16_to_ofp(ntohs(om->in_port))); print_wild(&f, "dl_vlan=", w & OFPFW10_DL_VLAN, verbosity, "%d", ntohs(om->dl_vlan)); print_wild(&f, "dl_vlan_pcp=", w & OFPFW10_DL_VLAN_PCP, verbosity, @@ -707,36 +666,33 @@ ofp10_match_to_string(const struct ofp10_match *om, int verbosity) print_wild(&f, "tp_dst=", w & OFPFW10_TP_DST, verbosity, "%d", ntohs(om->tp_dst)); } - if (ds_last(&f) == ',') { - f.length--; - } + ds_chomp(&f, ','); return ds_cstr(&f); } static void -ofp_print_flow_flags(struct ds *s, uint16_t flags) +ofp_print_flow_flags(struct ds *s, enum ofputil_flow_mod_flags flags) { - if (flags & OFPFF_SEND_FLOW_REM) { + if (flags & OFPUTIL_FF_SEND_FLOW_REM) { ds_put_cstr(s, "send_flow_rem "); } - if (flags & OFPFF_CHECK_OVERLAP) { + if (flags & OFPUTIL_FF_CHECK_OVERLAP) { ds_put_cstr(s, "check_overlap "); } - if (flags & OFPFF12_RESET_COUNTS) { + if (flags & OFPUTIL_FF_RESET_COUNTS) { ds_put_cstr(s, "reset_counts "); } - if (flags & OFPFF13_NO_PKT_COUNTS) { + if (flags & OFPUTIL_FF_NO_PKT_COUNTS) { ds_put_cstr(s, "no_packet_counts "); } - if (flags & OFPFF13_NO_BYT_COUNTS) { + if (flags & OFPUTIL_FF_NO_BYT_COUNTS) { ds_put_cstr(s, "no_byte_counts "); } - - flags &= ~(OFPFF_SEND_FLOW_REM | OFPFF_CHECK_OVERLAP - | OFPFF12_RESET_COUNTS - | OFPFF13_NO_PKT_COUNTS | OFPFF13_NO_BYT_COUNTS); - if (flags) { - ds_put_format(s, "flags:0x%"PRIx16" ", flags); + if (flags & OFPUTIL_FF_HIDDEN_FIELDS) { + ds_put_cstr(s, "allow_hidden_fields "); + } + if (flags & OFPUTIL_FF_NO_READONLY) { + ds_put_cstr(s, "no_readonly_table "); } } @@ -754,7 +710,8 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity) protocol = ofputil_protocol_set_tid(protocol, true); ofpbuf_init(&ofpacts, 64); - error = ofputil_decode_flow_mod(&fm, oh, protocol, &ofpacts); + error = ofputil_decode_flow_mod(&fm, oh, protocol, &ofpacts, + OFPP_MAX, 255); if (error) { ofpbuf_uninit(&ofpacts); ofp_print_error(s, error); @@ -814,7 +771,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity) if (ds_last(s) != ' ') { ds_put_char(s, ' '); } - if (fm.new_cookie != htonll(0) && fm.new_cookie != htonll(UINT64_MAX)) { + if (fm.new_cookie != htonll(0) && fm.new_cookie != OVS_BE64_MAX) { ds_put_format(s, "cookie:0x%"PRIx64" ", ntohll(fm.new_cookie)); } if (fm.cookie_mask != htonll(0)) { @@ -827,6 +784,9 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity) if (fm.hard_timeout != OFP_FLOW_PERMANENT) { ds_put_format(s, "hard:%"PRIu16" ", fm.hard_timeout); } + if (fm.importance != 0) { + ds_put_format(s, "importance:%"PRIu16" ", fm.importance); + } if (fm.priority != OFP_DEFAULT_PRIORITY && need_priority) { ds_put_format(s, "pri:%"PRIu16" ", fm.priority); } @@ -838,10 +798,16 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, int verbosity) ofputil_format_port(fm.out_port, s); ds_put_char(s, ' '); } - if (fm.flags != 0) { - ofp_print_flow_flags(s, fm.flags); + + if (oh->version == OFP10_VERSION || oh->version == OFP11_VERSION) { + /* Don't print the reset_counts flag for OF1.0 and OF1.1 because those + * versions don't really have such a flag and printing one is likely to + * confuse people. */ + fm.flags &= ~OFPUTIL_FF_RESET_COUNTS; } + ofp_print_flow_flags(s, fm.flags); + ds_put_cstr(s, "actions="); ofpacts_format(fm.ofpacts, fm.ofpacts_len, s); ofpbuf_uninit(&ofpacts); } @@ -850,10 +816,26 @@ static void ofp_print_duration(struct ds *string, unsigned int sec, unsigned int nsec) { ds_put_format(string, "%u", sec); + + /* If there are no fractional seconds, don't print any decimals. + * + * If the fractional seconds can be expressed exactly as milliseconds, + * print 3 decimals. Open vSwitch provides millisecond precision for most + * time measurements, so printing 3 decimals every time makes it easier to + * spot real changes in flow dumps that refresh themselves quickly. + * + * If the fractional seconds are more precise than milliseconds, print the + * number of decimals needed to express them exactly. + */ if (nsec > 0) { - ds_put_format(string, ".%09u", nsec); - while (string->string[string->length - 1] == '0') { - string->length--; + unsigned int msec = nsec / 1000000; + if (msec * 1000000 == nsec) { + ds_put_format(string, ".%03u", msec); + } else { + ds_put_format(string, ".%09u", nsec); + while (string->string[string->length - 1] == '0') { + string->length--; + } } } ds_put_char(string, 's'); @@ -878,6 +860,9 @@ ofp_flow_removed_reason_to_string(enum ofp_flow_removed_reason reason, return "group_delete"; case OFPRR_EVICTION: return "eviction"; + case OFPRR_METER_DELETE: + return "meter_delete"; + case OVS_OFPRR_NONE: default: snprintf(reasonbuf, bufsize, "%d", (int) reason); return reasonbuf; @@ -929,7 +914,7 @@ ofp_print_port_mod(struct ds *string, const struct ofp_header *oh) struct ofputil_port_mod pm; enum ofperr error; - error = ofputil_decode_port_mod(oh, &pm); + error = ofputil_decode_port_mod(oh, &pm, true); if (error) { ofp_print_error(string, error); return; @@ -954,6 +939,392 @@ ofp_print_port_mod(struct ds *string, const struct ofp_header *oh) } } +static const char * +ofputil_table_miss_to_string(enum ofputil_table_miss miss) +{ + switch (miss) { + case OFPUTIL_TABLE_MISS_DEFAULT: return "default"; + case OFPUTIL_TABLE_MISS_CONTROLLER: return "controller"; + case OFPUTIL_TABLE_MISS_CONTINUE: return "continue"; + case OFPUTIL_TABLE_MISS_DROP: return "drop"; + default: return "***error***"; + } +} + +static const char * +ofputil_table_eviction_to_string(enum ofputil_table_eviction eviction) +{ + switch (eviction) { + case OFPUTIL_TABLE_EVICTION_DEFAULT: return "default"; + case OFPUTIL_TABLE_EVICTION_ON: return "on"; + case OFPUTIL_TABLE_EVICTION_OFF: return "off"; + default: return "***error***"; + } + +} + +static const char * +ofputil_eviction_flag_to_string(uint32_t bit) +{ + enum ofp14_table_mod_prop_eviction_flag eviction_flag = bit; + + switch (eviction_flag) { + case OFPTMPEF14_OTHER: return "OTHER"; + case OFPTMPEF14_IMPORTANCE: return "IMPORTANCE"; + case OFPTMPEF14_LIFETIME: return "LIFETIME"; + } + + return NULL; +} + +/* Appends to 'string' a description of the bitmap of OFPTMPEF14_* values in + * 'eviction_flags'. */ +static void +ofputil_put_eviction_flags(struct ds *string, uint32_t eviction_flags) +{ + if (eviction_flags != UINT32_MAX) { + ofp_print_bit_names(string, eviction_flags, + ofputil_eviction_flag_to_string, '|'); + } else { + ds_put_cstr(string, "(default)"); + } +} + +static void +ofp_print_table_mod(struct ds *string, const struct ofp_header *oh) +{ + struct ofputil_table_mod pm; + enum ofperr error; + + error = ofputil_decode_table_mod(oh, &pm); + if (error) { + ofp_print_error(string, error); + return; + } + + if (pm.table_id == 0xff) { + ds_put_cstr(string, " table_id: ALL_TABLES"); + } else { + ds_put_format(string, " table_id=%"PRIu8, pm.table_id); + } + + if (pm.miss != OFPUTIL_TABLE_MISS_DEFAULT) { + ds_put_format(string, ", flow_miss_config=%s", + ofputil_table_miss_to_string(pm.miss)); + } + if (pm.eviction != OFPUTIL_TABLE_EVICTION_DEFAULT) { + ds_put_format(string, ", eviction=%s", + ofputil_table_eviction_to_string(pm.eviction)); + } + if (pm.eviction_flags != UINT32_MAX) { + ds_put_cstr(string, "eviction_flags="); + ofputil_put_eviction_flags(string, pm.eviction_flags); + } +} + +/* This function will print the Table description properties. */ +static void +ofp_print_table_desc(struct ds *string, const struct ofputil_table_desc *td) +{ + ds_put_format(string, "\n table %"PRIu8, td->table_id); + ds_put_cstr(string, ":\n"); + ds_put_format(string, " eviction=%s eviction_flags=", + ofputil_table_eviction_to_string(td->eviction)); + ofputil_put_eviction_flags(string, td->eviction_flags); + ds_put_char(string, '\n'); +} + +static void +ofp_print_queue_get_config_request(struct ds *string, + const struct ofp_header *oh) +{ + enum ofperr error; + ofp_port_t port; + + error = ofputil_decode_queue_get_config_request(oh, &port); + if (error) { + ofp_print_error(string, error); + return; + } + + ds_put_cstr(string, " port="); + ofputil_format_port(port, string); +} + +static void +print_queue_rate(struct ds *string, const char *name, unsigned int rate) +{ + if (rate <= 1000) { + ds_put_format(string, " %s:%u.%u%%", name, rate / 10, rate % 10); + } else if (rate < UINT16_MAX) { + ds_put_format(string, " %s:(disabled)", name); + } +} + +static void +ofp_print_queue_get_config_reply(struct ds *string, + const struct ofp_header *oh) +{ + enum ofperr error; + struct ofpbuf b; + ofp_port_t port; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + error = ofputil_decode_queue_get_config_reply(&b, &port); + if (error) { + ofp_print_error(string, error); + return; + } + + ds_put_cstr(string, " port="); + ofputil_format_port(port, string); + ds_put_char(string, '\n'); + + for (;;) { + struct ofputil_queue_config queue; + int retval; + + retval = ofputil_pull_queue_get_config_reply(&b, &queue); + if (retval) { + if (retval != EOF) { + ofp_print_error(string, retval); + } + break; + } + + ds_put_format(string, "queue %"PRIu32":", queue.queue_id); + print_queue_rate(string, "min_rate", queue.min_rate); + print_queue_rate(string, "max_rate", queue.max_rate); + ds_put_char(string, '\n'); + } +} + +static void +ofp_print_meter_flags(struct ds *s, uint16_t flags) +{ + if (flags & OFPMF13_KBPS) { + ds_put_cstr(s, "kbps "); + } + if (flags & OFPMF13_PKTPS) { + ds_put_cstr(s, "pktps "); + } + if (flags & OFPMF13_BURST) { + ds_put_cstr(s, "burst "); + } + if (flags & OFPMF13_STATS) { + ds_put_cstr(s, "stats "); + } + + flags &= ~(OFPMF13_KBPS | OFPMF13_PKTPS | OFPMF13_BURST | OFPMF13_STATS); + if (flags) { + ds_put_format(s, "flags:0x%"PRIx16" ", flags); + } +} + +static void +ofp_print_meter_band(struct ds *s, uint16_t flags, + const struct ofputil_meter_band *mb) +{ + ds_put_cstr(s, "\ntype="); + switch (mb->type) { + case OFPMBT13_DROP: + ds_put_cstr(s, "drop"); + break; + case OFPMBT13_DSCP_REMARK: + ds_put_cstr(s, "dscp_remark"); + break; + default: + ds_put_format(s, "%u", mb->type); + } + + ds_put_format(s, " rate=%"PRIu32, mb->rate); + + if (flags & OFPMF13_BURST) { + ds_put_format(s, " burst_size=%"PRIu32, mb->burst_size); + } + if (mb->type == OFPMBT13_DSCP_REMARK) { + ds_put_format(s, " prec_level=%"PRIu8, mb->prec_level); + } +} + +static void +ofp_print_meter_stats(struct ds *s, const struct ofputil_meter_stats *ms) +{ + uint16_t i; + + ds_put_format(s, "meter:%"PRIu32" ", ms->meter_id); + ds_put_format(s, "flow_count:%"PRIu32" ", ms->flow_count); + ds_put_format(s, "packet_in_count:%"PRIu64" ", ms->packet_in_count); + ds_put_format(s, "byte_in_count:%"PRIu64" ", ms->byte_in_count); + ds_put_cstr(s, "duration:"); + ofp_print_duration(s, ms->duration_sec, ms->duration_nsec); + ds_put_char(s, ' '); + + ds_put_cstr(s, "bands:\n"); + for (i = 0; i < ms->n_bands; ++i) { + ds_put_format(s, "%d: ", i); + ds_put_format(s, "packet_count:%"PRIu64" ", ms->bands[i].packet_count); + ds_put_format(s, "byte_count:%"PRIu64"\n", ms->bands[i].byte_count); + } +} + +static void +ofp_print_meter_config(struct ds *s, const struct ofputil_meter_config *mc) +{ + uint16_t i; + + ds_put_format(s, "meter=%"PRIu32" ", mc->meter_id); + + ofp_print_meter_flags(s, mc->flags); + + ds_put_cstr(s, "bands="); + for (i = 0; i < mc->n_bands; ++i) { + ofp_print_meter_band(s, mc->flags, &mc->bands[i]); + } + ds_put_char(s, '\n'); +} + +static void +ofp_print_meter_mod(struct ds *s, const struct ofp_header *oh) +{ + struct ofputil_meter_mod mm; + struct ofpbuf bands; + enum ofperr error; + + ofpbuf_init(&bands, 64); + error = ofputil_decode_meter_mod(oh, &mm, &bands); + if (error) { + ofpbuf_uninit(&bands); + ofp_print_error(s, error); + return; + } + + switch (mm.command) { + case OFPMC13_ADD: + ds_put_cstr(s, " ADD "); + break; + case OFPMC13_MODIFY: + ds_put_cstr(s, " MOD "); + break; + case OFPMC13_DELETE: + ds_put_cstr(s, " DEL "); + break; + default: + ds_put_format(s, " cmd:%d ", mm.command); + } + + ofp_print_meter_config(s, &mm.meter); + ofpbuf_uninit(&bands); +} + +static void +ofp_print_meter_stats_request(struct ds *s, const struct ofp_header *oh) +{ + uint32_t meter_id; + + ofputil_decode_meter_request(oh, &meter_id); + + ds_put_format(s, " meter=%"PRIu32, meter_id); +} + +static const char * +ofputil_meter_capabilities_to_name(uint32_t bit) +{ + enum ofp13_meter_flags flag = bit; + + switch (flag) { + case OFPMF13_KBPS: return "kbps"; + case OFPMF13_PKTPS: return "pktps"; + case OFPMF13_BURST: return "burst"; + case OFPMF13_STATS: return "stats"; + } + + return NULL; +} + +static const char * +ofputil_meter_band_types_to_name(uint32_t bit) +{ + switch (bit) { + case 1 << OFPMBT13_DROP: return "drop"; + case 1 << OFPMBT13_DSCP_REMARK: return "dscp_remark"; + } + + return NULL; +} + +static void +ofp_print_meter_features_reply(struct ds *s, const struct ofp_header *oh) +{ + struct ofputil_meter_features mf; + + ofputil_decode_meter_features(oh, &mf); + + ds_put_format(s, "\nmax_meter:%"PRIu32, mf.max_meters); + ds_put_format(s, " max_bands:%"PRIu8, mf.max_bands); + ds_put_format(s, " max_color:%"PRIu8"\n", mf.max_color); + + ds_put_cstr(s, "band_types: "); + ofp_print_bit_names(s, mf.band_types, + ofputil_meter_band_types_to_name, ' '); + ds_put_char(s, '\n'); + + ds_put_cstr(s, "capabilities: "); + ofp_print_bit_names(s, mf.capabilities, + ofputil_meter_capabilities_to_name, ' '); + ds_put_char(s, '\n'); +} + +static void +ofp_print_meter_config_reply(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf bands; + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + ofpbuf_init(&bands, 64); + for (;;) { + struct ofputil_meter_config mc; + int retval; + + retval = ofputil_decode_meter_config(&b, &mc, &bands); + if (retval) { + if (retval != EOF) { + ofp_print_error(s, retval); + } + break; + } + ds_put_char(s, '\n'); + ofp_print_meter_config(s, &mc); + } + ofpbuf_uninit(&bands); +} + +static void +ofp_print_meter_stats_reply(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf bands; + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + ofpbuf_init(&bands, 64); + for (;;) { + struct ofputil_meter_stats ms; + int retval; + + retval = ofputil_decode_meter_stats(&b, &ms, &bands); + if (retval) { + if (retval != EOF) { + ofp_print_error(s, retval); + } + break; + } + ds_put_char(s, '\n'); + ofp_print_meter_stats(s, &ms); + } + ofpbuf_uninit(&bands); +} + static void ofp_print_error(struct ds *string, enum ofperr error) { @@ -1004,6 +1375,7 @@ ofp_print_error_msg(struct ds *string, const struct ofp_header *oh) ds_put_cstr(string, s); free(s); } + ofpbuf_uninit(&payload); } static void @@ -1091,6 +1463,9 @@ ofp_print_flow_stats(struct ds *string, struct ofputil_flow_stats *fs) if (fs->flags) { ofp_print_flow_flags(string, fs->flags); } + if (fs->importance != 0) { + ds_put_format(string, "importance=%"PRIu16", ", fs->importance); + } if (fs->idle_age >= 0) { ds_put_format(string, "idle_age=%d, ", fs->idle_age); } @@ -1103,6 +1478,7 @@ ofp_print_flow_stats(struct ds *string, struct ofputil_flow_stats *fs) ds_put_char(string, ' '); } + ds_put_cstr(string, "actions="); ofpacts_format(fs->ofpacts, fs->ofpacts_len, string); } @@ -1167,7 +1543,7 @@ print_port_stat(struct ds *string, const char *leader, uint64_t stat, int more) static void ofp_print_ofpst_port_request(struct ds *string, const struct ofp_header *oh) { - uint16_t ofp10_port; + ofp_port_t ofp10_port; enum ofperr error; error = ofputil_decode_port_stats_request(oh, &ofp10_port); @@ -1186,7 +1562,7 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh, { struct ofpbuf b; - ds_put_format(string, " %zu ports\n", ofputil_count_port_stats(oh)); + ds_put_format(string, " %"PRIuSIZE" ports\n", ofputil_count_port_stats(oh)); if (verbosity < 1) { return; } @@ -1205,7 +1581,7 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh, } ds_put_cstr(string, " port "); - if (ps.port_no < 10) { + if (ofp_to_u16(ps.port_no) < 10) { ds_put_char(string, ' '); } ofputil_format_port(ps.port_no, string); @@ -1235,214 +1611,34 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh, } static void -ofp_print_one_ofpst_table_reply(struct ds *string, enum ofp_version ofp_version, - const char *name, struct ofp12_table_stats *ts) +ofp_print_table_stats_reply(struct ds *string, const struct ofp_header *oh) { - char name_[OFP_MAX_TABLE_NAME_LEN + 1]; - - /* ofp13_table_stats is different */ - if (ofp_version > OFP12_VERSION) { - return; - } - - ovs_strlcpy(name_, name, sizeof name_); - - ds_put_format(string, " %d: %-8s: ", ts->table_id, name_); - ds_put_format(string, "wild=0x%05"PRIx64", ", ntohll(ts->wildcards)); - ds_put_format(string, "max=%6"PRIu32", ", ntohl(ts->max_entries)); - ds_put_format(string, "active=%"PRIu32"\n", ntohl(ts->active_count)); - ds_put_cstr(string, " "); - ds_put_format(string, "lookup=%"PRIu64", ", ntohll(ts->lookup_count)); - ds_put_format(string, "matched=%"PRIu64"\n", ntohll(ts->matched_count)); - - if (ofp_version < OFP11_VERSION) { - return; - } - - ds_put_cstr(string, " "); - ds_put_format(string, "match=0x%08"PRIx64", ", ntohll(ts->match)); - ds_put_format(string, "instructions=0x%08"PRIx32", ", - ntohl(ts->instructions)); - ds_put_format(string, "config=0x%08"PRIx32"\n", ntohl(ts->config)); - ds_put_cstr(string, " "); - ds_put_format(string, "write_actions=0x%08"PRIx32", ", - ntohl(ts->write_actions)); - ds_put_format(string, "apply_actions=0x%08"PRIx32"\n", - ntohl(ts->apply_actions)); - - if (ofp_version < OFP12_VERSION) { - return; - } - - ds_put_cstr(string, " "); - ds_put_format(string, "write_setfields=0x%016"PRIx64"\n", - ntohll(ts->write_setfields)); - ds_put_cstr(string, " "); - ds_put_format(string, "apply_setfields=0x%016"PRIx64"\n", - ntohll(ts->apply_setfields)); - ds_put_cstr(string, " "); - ds_put_format(string, "metadata_match=0x%016"PRIx64"\n", - ntohll(ts->metadata_match)); - ds_put_cstr(string, " "); - ds_put_format(string, "metadata_write=0x%016"PRIx64"\n", - ntohll(ts->metadata_write)); -} - -static void -ofp_print_ofpst_table_reply13(struct ds *string, const struct ofp_header *oh, - int verbosity) -{ - struct ofp13_table_stats *ts; - struct ofpbuf b; - size_t n; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - ofpraw_pull_assert(&b); - - n = b.size / sizeof *ts; - ds_put_format(string, " %zu tables\n", n); - if (verbosity < 1) { - return; - } - - for (;;) { - ts = ofpbuf_try_pull(&b, sizeof *ts); - if (!ts) { - return; - } - ds_put_format(string, - " %d: active=%"PRIu32", lookup=%"PRIu64 \ - ", matched=%"PRIu64"\n", - ts->table_id, ntohl(ts->active_count), - ntohll(ts->lookup_count), ntohll(ts->matched_count)); - } -} - -static void -ofp_print_ofpst_table_reply12(struct ds *string, const struct ofp_header *oh, - int verbosity) -{ - struct ofp12_table_stats *ts; - struct ofpbuf b; - size_t n; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - ofpraw_pull_assert(&b); - - n = b.size / sizeof *ts; - ds_put_format(string, " %zu tables\n", n); - if (verbosity < 1) { - return; - } - - for (;;) { - ts = ofpbuf_try_pull(&b, sizeof *ts); - if (!ts) { - return; - } - - ofp_print_one_ofpst_table_reply(string, OFP12_VERSION, ts->name, ts); - } -} - -static void -ofp_print_ofpst_table_reply11(struct ds *string, const struct ofp_header *oh, - int verbosity) -{ - struct ofp11_table_stats *ts; - struct ofpbuf b; - size_t n; - - ofpbuf_use_const(&b, oh, ntohs(oh->length)); - ofpraw_pull_assert(&b); - - n = b.size / sizeof *ts; - ds_put_format(string, " %zu tables\n", n); - if (verbosity < 1) { - return; - } - - for (;;) { - struct ofp12_table_stats ts12; - - ts = ofpbuf_try_pull(&b, sizeof *ts); - if (!ts) { - return; - } - - ts12.table_id = ts->table_id; - ts12.wildcards = htonll(ntohl(ts->wildcards)); - ts12.max_entries = ts->max_entries; - ts12.active_count = ts->active_count; - ts12.lookup_count = ts->lookup_count; - ts12.matched_count = ts->matched_count; - ts12.match = htonll(ntohl(ts->match)); - ts12.instructions = ts->instructions; - ts12.config = ts->config; - ts12.write_actions = ts->write_actions; - ts12.apply_actions = ts->apply_actions; - ofp_print_one_ofpst_table_reply(string, OFP11_VERSION, ts->name, &ts12); - } -} - -static void -ofp_print_ofpst_table_reply10(struct ds *string, const struct ofp_header *oh, - int verbosity) -{ - struct ofp10_table_stats *ts; - struct ofpbuf b; - size_t n; + struct ofpbuf b; ofpbuf_use_const(&b, oh, ntohs(oh->length)); ofpraw_pull_assert(&b); - n = b.size / sizeof *ts; - ds_put_format(string, " %zu tables\n", n); - if (verbosity < 1) { - return; - } - - for (;;) { - struct ofp12_table_stats ts12; + struct ofputil_table_features prev_features; + struct ofputil_table_stats prev_stats; + for (int i = 0;; i++) { + struct ofputil_table_features features; + struct ofputil_table_stats stats; + int retval; - ts = ofpbuf_try_pull(&b, sizeof *ts); - if (!ts) { + retval = ofputil_decode_table_stats_reply(&b, &stats, &features); + if (retval) { + if (retval != EOF) { + ofp_print_error(string, retval); + } return; } - ts12.table_id = ts->table_id; - ts12.wildcards = htonll(ntohl(ts->wildcards)); - ts12.max_entries = ts->max_entries; - ts12.active_count = ts->active_count; - ts12.lookup_count = get_32aligned_be64(&ts->lookup_count); - ts12.matched_count = get_32aligned_be64(&ts->matched_count); - ofp_print_one_ofpst_table_reply(string, OFP10_VERSION, ts->name, &ts12); - } -} - -static void -ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh, - int verbosity) -{ - switch ((enum ofp_version)oh->version) { - case OFP13_VERSION: - ofp_print_ofpst_table_reply13(string, oh, verbosity); - break; - - case OFP12_VERSION: - ofp_print_ofpst_table_reply12(string, oh, verbosity); - break; - - case OFP11_VERSION: - ofp_print_ofpst_table_reply11(string, oh, verbosity); - break; - - case OFP10_VERSION: - ofp_print_ofpst_table_reply10(string, oh, verbosity); - break; - - default: - NOT_REACHED(); + ds_put_char(string, '\n'); + ofp_print_table_features(string, + &features, i ? &prev_features : NULL, + &stats, i ? &prev_stats : NULL); + prev_features = features; + prev_stats = stats; } } @@ -1481,7 +1677,7 @@ ofp_print_ofpst_queue_reply(struct ds *string, const struct ofp_header *oh, { struct ofpbuf b; - ds_put_format(string, " %zu queues\n", ofputil_count_queue_stats(oh)); + ds_put_format(string, " %"PRIuSIZE" queues\n", ofputil_count_queue_stats(oh)); if (verbosity < 1) { return; } @@ -1505,10 +1701,35 @@ ofp_print_ofpst_queue_reply(struct ds *string, const struct ofp_header *oh, ofp_print_queue_name(string, qs.queue_id); ds_put_cstr(string, ": "); - print_port_stat(string, "bytes=", qs.stats.tx_bytes, 1); - print_port_stat(string, "pkts=", qs.stats.tx_packets, 1); - print_port_stat(string, "errors=", qs.stats.tx_errors, 0); + print_port_stat(string, "bytes=", qs.tx_bytes, 1); + print_port_stat(string, "pkts=", qs.tx_packets, 1); + print_port_stat(string, "errors=", qs.tx_errors, 1); + + ds_put_cstr(string, "duration="); + if (qs.duration_sec != UINT32_MAX) { + ofp_print_duration(string, qs.duration_sec, qs.duration_nsec); + } else { + ds_put_char(string, '?'); + } + ds_put_char(string, '\n'); + } +} + +static void +ofp_print_ofpst_port_desc_request(struct ds *string, + const struct ofp_header *oh) +{ + enum ofperr error; + ofp_port_t port; + + error = ofputil_decode_port_desc_stats_request(oh, &port); + if (error) { + ofp_print_error(string, error); + return; } + + ds_put_cstr(string, " port="); + ofputil_format_port(port, string); } static void @@ -1524,23 +1745,14 @@ ofp_print_ofpst_port_desc_reply(struct ds *string, } static void -ofp_print_stats_request(struct ds *string, const struct ofp_header *oh) -{ - uint16_t flags = ofpmp_flags(oh); - - if (flags) { - ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags); - } -} - -static void -ofp_print_stats_reply(struct ds *string, const struct ofp_header *oh) +ofp_print_stats(struct ds *string, const struct ofp_header *oh) { uint16_t flags = ofpmp_flags(oh); if (flags) { ds_put_cstr(string, " flags="); - if (flags & OFPSF_REPLY_MORE) { + if ((!ofpmsg_is_stat_request(oh) || oh->version >= OFP13_VERSION) + && (flags & OFPSF_REPLY_MORE)) { ds_put_cstr(string, "[more]"); flags &= ~OFPSF_REPLY_MORE; } @@ -1556,27 +1768,19 @@ ofp_print_echo(struct ds *string, const struct ofp_header *oh, int verbosity) { size_t len = ntohs(oh->length); - ds_put_format(string, " %zu bytes of payload\n", len - sizeof *oh); + ds_put_format(string, " %"PRIuSIZE" bytes of payload\n", len - sizeof *oh); if (verbosity > 1) { ds_put_hex_dump(string, oh + 1, len - sizeof *oh, 0, true); } } static void -ofp_print_role_message(struct ds *string, const struct ofp_header *oh) +ofp_print_role_generic(struct ds *string, enum ofp12_controller_role role, + uint64_t generation_id) { - struct ofputil_role_request rr; - enum ofperr error; - - error = ofputil_decode_role_message(oh, &rr); - if (error) { - ofp_print_error(string, error); - return; - } - ds_put_cstr(string, " role="); - switch (rr.role) { + switch (role) { case OFPCR12_ROLE_NOCHANGE: ds_put_cstr(string, "nochange"); break; @@ -1590,11 +1794,57 @@ ofp_print_role_message(struct ds *string, const struct ofp_header *oh) ds_put_cstr(string, "slave"); break; default: - NOT_REACHED(); + OVS_NOT_REACHED(); + } + + if (generation_id != UINT64_MAX) { + ds_put_format(string, " generation_id=%"PRIu64, generation_id); + } +} + +static void +ofp_print_role_message(struct ds *string, const struct ofp_header *oh) +{ + struct ofputil_role_request rr; + enum ofperr error; + + error = ofputil_decode_role_message(oh, &rr); + if (error) { + ofp_print_error(string, error); + return; + } + + ofp_print_role_generic(string, rr.role, rr.have_generation_id ? rr.generation_id : UINT64_MAX); +} + +static void +ofp_print_role_status_message(struct ds *string, const struct ofp_header *oh) +{ + struct ofputil_role_status rs; + enum ofperr error; + + error = ofputil_decode_role_status(oh, &rs); + if (error) { + ofp_print_error(string, error); + return; } - if (rr.have_generation_id) { - ds_put_format(string, " generation_id=%"PRIu64, rr.generation_id); + ofp_print_role_generic(string, rs.role, rs.generation_id); + + ds_put_cstr(string, " reason="); + + switch (rs.reason) { + case OFPCRR_MASTER_REQUEST: + ds_put_cstr(string, "master_request"); + break; + case OFPCRR_CONFIG: + ds_put_cstr(string, "configuration_changed"); + break; + case OFPCRR_EXPERIMENTER: + ds_put_cstr(string, "experimenter_data_changed"); + break; + default: + OVS_NOT_REACHED(); } } @@ -1657,64 +1907,220 @@ ofp_port_reason_to_string(enum ofp_port_reason reason, } } +/* Returns a string form of 'reason'. The return value is either a statically + * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'. + * 'bufsize' should be at least OFP_ASYNC_CONFIG_REASON_BUFSIZE. */ +static const char* +ofp_role_reason_to_string(enum ofp14_controller_role_reason reason, + char *reasonbuf, size_t bufsize) +{ + switch (reason) { + case OFPCRR_MASTER_REQUEST: + return "master_request"; + + case OFPCRR_CONFIG: + return "configuration_changed"; + + case OFPCRR_EXPERIMENTER: + return "experimenter_data_changed"; + + default: + snprintf(reasonbuf, bufsize, "%d", (int) reason); + return reasonbuf; + } +} + +/* Returns a string form of 'reason'. The return value is either a statically + * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'. + * 'bufsize' should be at least OFP_ASYNC_CONFIG_REASON_BUFSIZE. */ +static const char* +ofp_table_reason_to_string(enum ofp14_table_reason reason, + char *reasonbuf, size_t bufsize) +{ + switch (reason) { + case OFPTR_VACANCY_DOWN: + return "vacancy_down"; + + case OFPTR_VACANCY_UP: + return "vacancy_up"; + + default: + snprintf(reasonbuf, bufsize, "%d", (int) reason); + return reasonbuf; + } +} + +/* Returns a string form of 'reason'. The return value is either a statically + * allocated constant string or the 'bufsize'-byte buffer 'reasonbuf'. + * 'bufsize' should be at least OFP_ASYNC_CONFIG_REASON_BUFSIZE. */ +static const char* +ofp_requestforward_reason_to_string(enum ofp14_requestforward_reason reason, + char *reasonbuf, size_t bufsize) +{ + switch (reason) { + case OFPRFR_GROUP_MOD: + return "group_mod_request"; + + case OFPRFR_METER_MOD: + return "meter_mod_request"; + + default: + snprintf(reasonbuf, bufsize, "%d", (int) reason); + return reasonbuf; + } +} + +static const char * +ofp_async_config_reason_to_string(uint32_t reason, + enum ofputil_async_msg_type type, + char *reasonbuf, size_t bufsize) +{ + switch (type) { + case OAM_PACKET_IN: + return ofputil_packet_in_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_PORT_STATUS: + return ofp_port_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_FLOW_REMOVED: + return ofp_flow_removed_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_ROLE_STATUS: + return ofp_role_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_TABLE_STATUS: + return ofp_table_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_REQUESTFORWARD: + return ofp_requestforward_reason_to_string(reason, reasonbuf, bufsize); + + case OAM_N_TYPES: + default: + return "Unknown asynchronous configuration message type"; + } +} + + +#define OFP_ASYNC_CONFIG_REASON_BUFSIZE (INT_STRLEN(int) + 1) static void ofp_print_nxt_set_async_config(struct ds *string, - const struct nx_async_config *nac) + const struct ofp_header *oh) { - int i; + int i, j; + enum ofpraw raw; + + ofpraw_decode(&raw, oh); + + if (raw == OFPRAW_OFPT13_SET_ASYNC || + raw == OFPRAW_NXT_SET_ASYNC_CONFIG || + raw == OFPRAW_OFPT13_GET_ASYNC_REPLY) { + const struct nx_async_config *nac = ofpmsg_body(oh); - for (i = 0; i < 2; i++) { - int j; + for (i = 0; i < 2; i++) { - ds_put_format(string, "\n %s:\n", i == 0 ? "master" : "slave"); + ds_put_format(string, "\n %s:\n", i == 0 ? "master" : "slave"); - ds_put_cstr(string, " PACKET_IN:"); - for (j = 0; j < 32; j++) { - if (nac->packet_in_mask[i] & htonl(1u << j)) { - char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; - const char *reason; + ds_put_cstr(string, " PACKET_IN:"); + for (j = 0; j < 32; j++) { + if (nac->packet_in_mask[i] & htonl(1u << j)) { + char reasonbuf[OFPUTIL_PACKET_IN_REASON_BUFSIZE]; + const char *reason; - reason = ofputil_packet_in_reason_to_string(j, reasonbuf, + reason = ofputil_packet_in_reason_to_string(j, reasonbuf, sizeof reasonbuf); - ds_put_format(string, " %s", reason); + ds_put_format(string, " %s", reason); + } } - } - if (!nac->packet_in_mask[i]) { - ds_put_cstr(string, " (off)"); - } - ds_put_char(string, '\n'); + if (!nac->packet_in_mask[i]) { + ds_put_cstr(string, " (off)"); + } + ds_put_char(string, '\n'); - ds_put_cstr(string, " PORT_STATUS:"); - for (j = 0; j < 32; j++) { - if (nac->port_status_mask[i] & htonl(1u << j)) { - char reasonbuf[OFP_PORT_REASON_BUFSIZE]; - const char *reason; + ds_put_cstr(string, " PORT_STATUS:"); + for (j = 0; j < 32; j++) { + if (nac->port_status_mask[i] & htonl(1u << j)) { + char reasonbuf[OFP_PORT_REASON_BUFSIZE]; + const char *reason; - reason = ofp_port_reason_to_string(j, reasonbuf, - sizeof reasonbuf); - ds_put_format(string, " %s", reason); + reason = ofp_port_reason_to_string(j, reasonbuf, + sizeof reasonbuf); + ds_put_format(string, " %s", reason); + } } - } - if (!nac->port_status_mask[i]) { - ds_put_cstr(string, " (off)"); - } - ds_put_char(string, '\n'); + if (!nac->port_status_mask[i]) { + ds_put_cstr(string, " (off)"); + } + ds_put_char(string, '\n'); - ds_put_cstr(string, " FLOW_REMOVED:"); - for (j = 0; j < 32; j++) { - if (nac->flow_removed_mask[i] & htonl(1u << j)) { - char reasonbuf[OFP_FLOW_REMOVED_REASON_BUFSIZE]; - const char *reason; + ds_put_cstr(string, " FLOW_REMOVED:"); + for (j = 0; j < 32; j++) { + if (nac->flow_removed_mask[i] & htonl(1u << j)) { + char reasonbuf[OFP_FLOW_REMOVED_REASON_BUFSIZE]; + const char *reason; - reason = ofp_flow_removed_reason_to_string(j, reasonbuf, + reason = ofp_flow_removed_reason_to_string(j, reasonbuf, sizeof reasonbuf); - ds_put_format(string, " %s", reason); + ds_put_format(string, " %s", reason); + } + } + if (!nac->flow_removed_mask[i]) { + ds_put_cstr(string, " (off)"); } + ds_put_char(string, '\n'); } - if (!nac->flow_removed_mask[i]) { - ds_put_cstr(string, " (off)"); + } else if (raw == OFPRAW_OFPT14_SET_ASYNC || + raw == OFPRAW_OFPT14_GET_ASYNC_REPLY) { + uint32_t role[2][OAM_N_TYPES] = {{0}}; + uint32_t type; + + ofputil_decode_set_async_config(oh, role[0], role[1], true); + for (i = 0; i < 2; i++) { + + ds_put_format(string, "\n %s:\n", i == 0 ? "master" : "slave"); + for (type = 0; type < OAM_N_TYPES; type++) { + switch (type) { + case OAM_PACKET_IN: + ds_put_cstr(string, " PACKET_IN:"); + break; + + case OAM_PORT_STATUS: + ds_put_cstr(string, " PORT_STATUS:"); + break; + + case OAM_FLOW_REMOVED: + ds_put_cstr(string, " FLOW_REMOVED:"); + break; + + case OAM_ROLE_STATUS: + ds_put_cstr(string, " ROLE_STATUS:"); + break; + + case OAM_TABLE_STATUS: + ds_put_cstr(string, " TABLE_STATUS:"); + break; + + case OAM_REQUESTFORWARD: + ds_put_cstr(string, " REQUESTFORWARD:"); + break; + } + + for (j = 0; j < 32; j++) { + if (role[i][type] & (1u << j)) { + char reasonbuf[OFP_ASYNC_CONFIG_REASON_BUFSIZE]; + const char *reason; + + reason = ofp_async_config_reason_to_string(j, type, + reasonbuf, + sizeof reasonbuf); + ds_put_format(string, " %s", reason); + } + } + if (!role[i][type]) { + ds_put_cstr(string, " (off)"); + } + ds_put_char(string, '\n'); + } } - ds_put_char(string, '\n'); } } @@ -1854,6 +2260,7 @@ ofp_print_nxst_flow_monitor_reply(struct ds *string, if (string->string[string->length - 1] != ' ') { ds_put_char(string, ' '); } + ds_put_cstr(string, "actions="); ofpacts_format(update.ofpacts, update.ofpacts_len, string); } } @@ -1875,6 +2282,12 @@ ofp_print_version(const struct ofp_header *oh, case OFP13_VERSION: ds_put_cstr(string, " (OF1.3)"); break; + case OFP14_VERSION: + ds_put_cstr(string, " (OF1.4)"); + break; + case OFP15_VERSION: + ds_put_cstr(string, " (OF1.5)"); + break; default: ds_put_format(string, " (OF 0x%02"PRIx8")", oh->version); break; @@ -1891,41 +2304,799 @@ ofp_header_to_string__(const struct ofp_header *oh, enum ofpraw raw, } static void -ofp_print_not_implemented(struct ds *string) +ofp_print_bucket_id(struct ds *s, const char *label, uint32_t bucket_id, + enum ofp_version ofp_version) { - ds_put_cstr(string, "NOT IMPLEMENTED YET!\n"); -} + if (ofp_version < OFP15_VERSION) { + return; + } -static void -ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw, - struct ds *string, int verbosity) -{ + ds_put_cstr(s, label); + + switch (bucket_id) { + case OFPG15_BUCKET_FIRST: + ds_put_cstr(s, "first"); + break; + case OFPG15_BUCKET_LAST: + ds_put_cstr(s, "last"); + break; + case OFPG15_BUCKET_ALL: + ds_put_cstr(s, "all"); + break; + default: + ds_put_format(s, "%"PRIu32, bucket_id); + break; + } + + ds_put_char(s, ','); +} + +static void +ofp_print_group(struct ds *s, uint32_t group_id, uint8_t type, + struct ovs_list *p_buckets, struct ofputil_group_props *props, + enum ofp_version ofp_version, bool suppress_type) +{ + struct ofputil_bucket *bucket; + + ds_put_format(s, "group_id=%"PRIu32, group_id); + + if (!suppress_type) { + static const char *type_str[] = { "all", "select", "indirect", + "ff", "unknown" }; + ds_put_format(s, ",type=%s", type_str[type > 4 ? 4 : type]); + } + + if (props->selection_method[0]) { + size_t mark, start; + + ds_put_format(s, ",selection_method=%s,", props->selection_method); + if (props->selection_method_param) { + ds_put_format(s, "selection_method_param=%"PRIu64",", + props->selection_method_param); + } + + /* Allow rewinding to immediately before the trailing ',' */ + mark = s->length - 1; + + ds_put_cstr(s, "fields="); + start = s->length; + oxm_format_field_array(s, &props->fields); + if (s->length == start) { + ds_truncate(s, mark); + } + } + + if (!p_buckets) { + return; + } + + ds_put_char(s, ','); + + LIST_FOR_EACH (bucket, list_node, p_buckets) { + ds_put_cstr(s, "bucket="); + + ofp_print_bucket_id(s, "bucket_id:", bucket->bucket_id, ofp_version); + if (bucket->weight != 1) { + ds_put_format(s, "weight:%"PRIu16",", bucket->weight); + } + if (bucket->watch_port != OFPP_NONE) { + ds_put_format(s, "watch_port:%"PRIu32",", bucket->watch_port); + } + if (bucket->watch_group != OFPG11_ANY) { + ds_put_format(s, "watch_group:%"PRIu32",", bucket->watch_group); + } + + ds_put_cstr(s, "actions="); + ofpacts_format(bucket->ofpacts, bucket->ofpacts_len, s); + ds_put_char(s, ','); + } + + ds_chomp(s, ','); +} + +static void +ofp_print_ofpst_group_desc_request(struct ds *string, + const struct ofp_header *oh) +{ + uint32_t group_id = ofputil_decode_group_desc_request(oh); + ds_put_cstr(string, " group_id="); + ofputil_format_group(group_id, string); +} + +static void +ofp_print_group_desc(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + for (;;) { + struct ofputil_group_desc gd; + int retval; + + retval = ofputil_decode_group_desc_reply(&gd, &b, oh->version); + if (retval) { + if (retval != EOF) { + ds_put_cstr(s, " ***parse error***"); + } + break; + } + + ds_put_char(s, '\n'); + ds_put_char(s, ' '); + ofp_print_group(s, gd.group_id, gd.type, &gd.buckets, &gd.props, + oh->version, false); + ofputil_bucket_list_destroy(&gd.buckets); + } +} + +static void +ofp_print_ofpst_group_request(struct ds *string, const struct ofp_header *oh) +{ + enum ofperr error; + uint32_t group_id; + + error = ofputil_decode_group_stats_request(oh, &group_id); + if (error) { + ofp_print_error(string, error); + return; + } + + ds_put_cstr(string, " group_id="); + ofputil_format_group(group_id, string); +} + +static void +ofp_print_group_stats(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf b; + uint32_t bucket_i; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + + for (;;) { + struct ofputil_group_stats gs; + int retval; + + retval = ofputil_decode_group_stats_reply(&b, &gs); + if (retval) { + if (retval != EOF) { + ds_put_cstr(s, " ***parse error***"); + } + break; + } + + ds_put_char(s, '\n'); + + ds_put_char(s, ' '); + ds_put_format(s, "group_id=%"PRIu32",", gs.group_id); + + if (gs.duration_sec != UINT32_MAX) { + ds_put_cstr(s, "duration="); + ofp_print_duration(s, gs.duration_sec, gs.duration_nsec); + ds_put_char(s, ','); + } + ds_put_format(s, "ref_count=%"PRIu32",", gs.ref_count); + ds_put_format(s, "packet_count=%"PRIu64",", gs.packet_count); + ds_put_format(s, "byte_count=%"PRIu64"", gs.byte_count); + + for (bucket_i = 0; bucket_i < gs.n_buckets; bucket_i++) { + if (gs.bucket_stats[bucket_i].packet_count != UINT64_MAX) { + ds_put_format(s, ",bucket%"PRIu32":", bucket_i); + ds_put_format(s, "packet_count=%"PRIu64",", gs.bucket_stats[bucket_i].packet_count); + ds_put_format(s, "byte_count=%"PRIu64"", gs.bucket_stats[bucket_i].byte_count); + } + } + + free(gs.bucket_stats); + } +} + +static const char * +group_type_to_string(enum ofp11_group_type type) +{ + switch (type) { + case OFPGT11_ALL: return "all"; + case OFPGT11_SELECT: return "select"; + case OFPGT11_INDIRECT: return "indirect"; + case OFPGT11_FF: return "fast failover"; + default: OVS_NOT_REACHED(); + } +} + +static void +ofp_print_group_features(struct ds *string, const struct ofp_header *oh) +{ + struct ofputil_group_features features; + int i; + + ofputil_decode_group_features_reply(oh, &features); + + ds_put_format(string, "\n Group table:\n"); + ds_put_format(string, " Types: 0x%"PRIx32"\n", features.types); + ds_put_format(string, " Capabilities: 0x%"PRIx32"\n", + features.capabilities); + + for (i = 0; i < OFPGT12_N_TYPES; i++) { + if (features.types & (1u << i)) { + ds_put_format(string, " %s group:\n", group_type_to_string(i)); + ds_put_format(string, " max_groups=%#"PRIx32"\n", + features.max_groups[i]); + ds_put_format(string, " actions: "); + ofpact_bitmap_format(features.ofpacts[i], string); + ds_put_char(string, '\n'); + } + } +} + +static void +ofp_print_group_mod(struct ds *s, const struct ofp_header *oh) +{ + struct ofputil_group_mod gm; + int error; + bool bucket_command = false; + + error = ofputil_decode_group_mod(oh, &gm); + if (error) { + ofp_print_error(s, error); + return; + } + + ds_put_char(s, '\n'); + + ds_put_char(s, ' '); + switch (gm.command) { + case OFPGC11_ADD: + ds_put_cstr(s, "ADD"); + break; + + case OFPGC11_MODIFY: + ds_put_cstr(s, "MOD"); + break; + + case OFPGC11_DELETE: + ds_put_cstr(s, "DEL"); + break; + + case OFPGC15_INSERT_BUCKET: + ds_put_cstr(s, "INSERT_BUCKET"); + bucket_command = true; + break; + + case OFPGC15_REMOVE_BUCKET: + ds_put_cstr(s, "REMOVE_BUCKET"); + bucket_command = true; + break; + + default: + ds_put_format(s, "cmd:%"PRIu16"", gm.command); + } + ds_put_char(s, ' '); + + if (bucket_command) { + ofp_print_bucket_id(s, "command_bucket_id:", + gm.command_bucket_id, oh->version); + } + + ofp_print_group(s, gm.group_id, gm.type, &gm.buckets, &gm.props, + oh->version, bucket_command); + ofputil_bucket_list_destroy(&gm.buckets); +} + +static void +print_table_action_features(struct ds *s, + const struct ofputil_table_action_features *taf) +{ + if (taf->ofpacts) { + ds_put_cstr(s, " actions: "); + ofpact_bitmap_format(taf->ofpacts, s); + ds_put_char(s, '\n'); + } + + if (!bitmap_is_all_zeros(taf->set_fields.bm, MFF_N_IDS)) { + int i; + + ds_put_cstr(s, " supported on Set-Field:"); + BITMAP_FOR_EACH_1 (i, MFF_N_IDS, taf->set_fields.bm) { + ds_put_format(s, " %s", mf_from_id(i)->name); + } + ds_put_char(s, '\n'); + } +} + +static bool +table_action_features_equal(const struct ofputil_table_action_features *a, + const struct ofputil_table_action_features *b) +{ + return (a->ofpacts == b->ofpacts + && bitmap_equal(a->set_fields.bm, b->set_fields.bm, MFF_N_IDS)); +} + +static bool +table_action_features_empty(const struct ofputil_table_action_features *taf) +{ + return !taf->ofpacts && bitmap_is_all_zeros(taf->set_fields.bm, MFF_N_IDS); +} + +static void +print_table_instruction_features( + struct ds *s, + const struct ofputil_table_instruction_features *tif, + const struct ofputil_table_instruction_features *prev_tif) +{ + int start, end; + + if (!bitmap_is_all_zeros(tif->next, 255)) { + ds_put_cstr(s, " next tables: "); + for (start = bitmap_scan(tif->next, 1, 0, 255); start < 255; + start = bitmap_scan(tif->next, 1, end, 255)) { + end = bitmap_scan(tif->next, 0, start + 1, 255); + if (end == start + 1) { + ds_put_format(s, "%d,", start); + } else { + ds_put_format(s, "%d-%d,", start, end - 1); + } + } + ds_chomp(s, ','); + if (ds_last(s) == ' ') { + ds_put_cstr(s, "none"); + } + ds_put_char(s, '\n'); + } + + if (tif->instructions) { + if (prev_tif && tif->instructions == prev_tif->instructions) { + ds_put_cstr(s, " (same instructions)\n"); + } else { + ds_put_cstr(s, " instructions: "); + int i; + + for (i = 0; i < 32; i++) { + if (tif->instructions & (1u << i)) { + ds_put_format(s, "%s,", ovs_instruction_name_from_type(i)); + } + } + ds_chomp(s, ','); + ds_put_char(s, '\n'); + } + } + + if (prev_tif + && table_action_features_equal(&tif->write, &prev_tif->write) + && table_action_features_equal(&tif->apply, &prev_tif->apply) + && !bitmap_is_all_zeros(tif->write.set_fields.bm, MFF_N_IDS)) { + ds_put_cstr(s, " (same actions)\n"); + } else if (!table_action_features_equal(&tif->write, &tif->apply)) { + ds_put_cstr(s, " Write-Actions features:\n"); + print_table_action_features(s, &tif->write); + ds_put_cstr(s, " Apply-Actions features:\n"); + print_table_action_features(s, &tif->apply); + } else if (tif->write.ofpacts + || !bitmap_is_all_zeros(tif->write.set_fields.bm, MFF_N_IDS)) { + ds_put_cstr(s, " Write-Actions and Apply-Actions features:\n"); + print_table_action_features(s, &tif->write); + } +} + +static bool +table_instruction_features_equal( + const struct ofputil_table_instruction_features *a, + const struct ofputil_table_instruction_features *b) +{ + return (bitmap_equal(a->next, b->next, 255) + && a->instructions == b->instructions + && table_action_features_equal(&a->write, &b->write) + && table_action_features_equal(&a->apply, &b->apply)); +} + +static bool +table_instruction_features_empty( + const struct ofputil_table_instruction_features *tif) +{ + return (bitmap_is_all_zeros(tif->next, 255) + && !tif->instructions + && table_action_features_empty(&tif->write) + && table_action_features_empty(&tif->apply)); +} + +static bool +table_features_equal(const struct ofputil_table_features *a, + const struct ofputil_table_features *b) +{ + return (a->metadata_match == b->metadata_match + && a->metadata_write == b->metadata_write + && a->miss_config == b->miss_config + && a->supports_eviction == b->supports_eviction + && a->supports_vacancy_events == b->supports_vacancy_events + && a->max_entries == b->max_entries + && table_instruction_features_equal(&a->nonmiss, &b->nonmiss) + && table_instruction_features_equal(&a->miss, &b->miss) + && bitmap_equal(a->match.bm, b->match.bm, MFF_N_IDS)); +} + +static bool +table_features_empty(const struct ofputil_table_features *tf) +{ + return (!tf->metadata_match + && !tf->metadata_write + && tf->miss_config == OFPUTIL_TABLE_MISS_DEFAULT + && tf->supports_eviction < 0 + && tf->supports_vacancy_events < 0 + && !tf->max_entries + && table_instruction_features_empty(&tf->nonmiss) + && table_instruction_features_empty(&tf->miss) + && bitmap_is_all_zeros(tf->match.bm, MFF_N_IDS)); +} + +static bool +table_stats_equal(const struct ofputil_table_stats *a, + const struct ofputil_table_stats *b) +{ + return (a->active_count == b->active_count + && a->lookup_count == b->lookup_count + && a->matched_count == b->matched_count); +} + +void +ofp_print_table_features(struct ds *s, + const struct ofputil_table_features *features, + const struct ofputil_table_features *prev_features, + const struct ofputil_table_stats *stats, + const struct ofputil_table_stats *prev_stats) +{ + int i; + + ds_put_format(s, " table %"PRIu8, features->table_id); + if (features->name[0]) { + ds_put_format(s, " (\"%s\")", features->name); + } + ds_put_char(s, ':'); + + bool same_stats = prev_stats && table_stats_equal(stats, prev_stats); + bool same_features = prev_features && table_features_equal(features, + prev_features); + if ((!stats || same_stats) && (!features || same_features)) { + ds_put_cstr(s, " ditto"); + return; + } + ds_put_char(s, '\n'); + if (stats) { + ds_put_format(s, " active=%"PRIu32", ", stats->active_count); + ds_put_format(s, "lookup=%"PRIu64", ", stats->lookup_count); + ds_put_format(s, "matched=%"PRIu64"\n", stats->matched_count); + } + if (same_features) { + if (!table_features_empty(features)) { + ds_put_cstr(s, " (same features)\n"); + } + return; + } + if (features->metadata_match || features->metadata_write) { + ds_put_format(s, " metadata: match=%#"PRIx64" write=%#"PRIx64"\n", + ntohll(features->metadata_match), + ntohll(features->metadata_write)); + } + + if (features->miss_config != OFPUTIL_TABLE_MISS_DEFAULT) { + ds_put_format(s, " config=%s\n", + ofputil_table_miss_to_string(features->miss_config)); + } + + if (features->supports_eviction >= 0) { + ds_put_format(s, " eviction: %ssupported\n", + features->supports_eviction ? "" : "not "); + + } + if (features->supports_vacancy_events >= 0) { + ds_put_format(s, " vacancy events: %ssupported\n", + features->supports_vacancy_events ? "" : "not "); + + } + + if (features->max_entries) { + ds_put_format(s, " max_entries=%"PRIu32"\n", features->max_entries); + } + + const struct ofputil_table_instruction_features *prev_nonmiss + = prev_features ? &prev_features->nonmiss : NULL; + const struct ofputil_table_instruction_features *prev_miss + = prev_features ? &prev_features->miss : NULL; + if (prev_features + && table_instruction_features_equal(&features->nonmiss, prev_nonmiss) + && table_instruction_features_equal(&features->miss, prev_miss)) { + if (!table_instruction_features_empty(&features->nonmiss)) { + ds_put_cstr(s, " (same instructions)\n"); + } + } else if (!table_instruction_features_equal(&features->nonmiss, + &features->miss)) { + ds_put_cstr(s, " instructions (other than table miss):\n"); + print_table_instruction_features(s, &features->nonmiss, prev_nonmiss); + ds_put_cstr(s, " instructions (table miss):\n"); + print_table_instruction_features(s, &features->miss, prev_miss); + } else if (!table_instruction_features_empty(&features->nonmiss)) { + ds_put_cstr(s, " instructions (table miss and others):\n"); + print_table_instruction_features(s, &features->nonmiss, prev_nonmiss); + } + + if (!bitmap_is_all_zeros(features->match.bm, MFF_N_IDS)) { + if (prev_features + && bitmap_equal(features->match.bm, prev_features->match.bm, + MFF_N_IDS)) { + ds_put_cstr(s, " (same matching)\n"); + } else { + ds_put_cstr(s, " matching:\n"); + BITMAP_FOR_EACH_1 (i, MFF_N_IDS, features->match.bm) { + const struct mf_field *f = mf_from_id(i); + bool mask = bitmap_is_set(features->mask.bm, i); + bool wildcard = bitmap_is_set(features->wildcard.bm, i); + + ds_put_format(s, " %s: %s\n", + f->name, + (mask ? "arbitrary mask" + : wildcard ? "exact match or wildcard" + : "must exact match")); + } + } + } +} + +static void +ofp_print_table_features_reply(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + + struct ofputil_table_features prev; + for (int i = 0; ; i++) { + struct ofputil_table_features tf; + int retval; + + retval = ofputil_decode_table_features(&b, &tf, true); + if (retval) { + if (retval != EOF) { + ofp_print_error(s, retval); + } + return; + } + + ds_put_char(s, '\n'); + ofp_print_table_features(s, &tf, i ? &prev : NULL, NULL, NULL); + prev = tf; + } +} + +static void +ofp_print_table_desc_reply(struct ds *s, const struct ofp_header *oh) +{ + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); + + for (;;) { + struct ofputil_table_desc td; + int retval; + + retval = ofputil_decode_table_desc(&b, &td, oh->version); + if (retval) { + if (retval != EOF) { + ofp_print_error(s, retval); + } + return; + } + ofp_print_table_desc(s, &td); + } +} + +static const char * +bundle_flags_to_name(uint32_t bit) +{ + switch (bit) { + case OFPBF_ATOMIC: + return "atomic"; + case OFPBF_ORDERED: + return "ordered"; + default: + return NULL; + } +} + +static void +ofp_print_bundle_ctrl(struct ds *s, const struct ofp_header *oh) +{ + int error; + struct ofputil_bundle_ctrl_msg bctrl; + + error = ofputil_decode_bundle_ctrl(oh, &bctrl); + if (error) { + ofp_print_error(s, error); + return; + } + + ds_put_char(s, '\n'); + + ds_put_format(s, " bundle_id=%#"PRIx32" type=", bctrl.bundle_id); + switch (bctrl.type) { + case OFPBCT_OPEN_REQUEST: + ds_put_cstr(s, "OPEN_REQUEST"); + break; + case OFPBCT_OPEN_REPLY: + ds_put_cstr(s, "OPEN_REPLY"); + break; + case OFPBCT_CLOSE_REQUEST: + ds_put_cstr(s, "CLOSE_REQUEST"); + break; + case OFPBCT_CLOSE_REPLY: + ds_put_cstr(s, "CLOSE_REPLY"); + break; + case OFPBCT_COMMIT_REQUEST: + ds_put_cstr(s, "COMMIT_REQUEST"); + break; + case OFPBCT_COMMIT_REPLY: + ds_put_cstr(s, "COMMIT_REPLY"); + break; + case OFPBCT_DISCARD_REQUEST: + ds_put_cstr(s, "DISCARD_REQUEST"); + break; + case OFPBCT_DISCARD_REPLY: + ds_put_cstr(s, "DISCARD_REPLY"); + break; + } + + ds_put_cstr(s, " flags="); + ofp_print_bit_names(s, bctrl.flags, bundle_flags_to_name, ' '); +} + +static void +ofp_print_bundle_add(struct ds *s, const struct ofp_header *oh, int verbosity) +{ + int error; + struct ofputil_bundle_add_msg badd; + char *msg; + + error = ofputil_decode_bundle_add(oh, &badd, NULL); + if (error) { + ofp_print_error(s, error); + return; + } + + ds_put_char(s, '\n'); + ds_put_format(s, " bundle_id=%#"PRIx32, badd.bundle_id); + ds_put_cstr(s, " flags="); + ofp_print_bit_names(s, badd.flags, bundle_flags_to_name, ' '); + + ds_put_char(s, '\n'); + msg = ofp_to_string(badd.msg, ntohs(badd.msg->length), verbosity); + if (msg) { + ds_put_cstr(s, msg); + } +} + +static void +print_geneve_table(struct ds *s, struct ovs_list *mappings) +{ + struct ofputil_geneve_map *map; + + ds_put_cstr(s, " mapping table:\n"); + ds_put_cstr(s, " class\ttype\tlength\tmatch field\n"); + ds_put_cstr(s, " -----\t----\t------\t-----------"); + + LIST_FOR_EACH (map, list_node, mappings) { + ds_put_char(s, '\n'); + ds_put_format(s, " 0x%"PRIx16"\t0x%"PRIx8"\t%"PRIu8"\ttun_metadata%"PRIu16, + map->option_class, map->option_type, map->option_len, + map->index); + } +} + +static void +ofp_print_geneve_table_mod(struct ds *s, const struct ofp_header *oh) +{ + int error; + struct ofputil_geneve_table_mod gtm; + + error = ofputil_decode_geneve_table_mod(oh, >m); + if (error) { + ofp_print_error(s, error); + return; + } + + ds_put_cstr(s, "\n "); + + switch (gtm.command) { + case NXGTMC_ADD: + ds_put_cstr(s, "ADD"); + break; + case NXGTMC_DELETE: + ds_put_cstr(s, "DEL"); + break; + case NXGTMC_CLEAR: + ds_put_cstr(s, "CLEAR"); + break; + } + + if (gtm.command != NXGTMC_CLEAR) { + print_geneve_table(s, >m.mappings); + } + + ofputil_uninit_geneve_table(>m.mappings); +} + +static void +ofp_print_geneve_table_reply(struct ds *s, const struct ofp_header *oh) +{ + int error; + struct ofputil_geneve_table_reply gtr; + struct ofputil_geneve_map *map; + int allocated_space = 0; + + error = ofputil_decode_geneve_table_reply(oh, >r); + if (error) { + ofp_print_error(s, error); + return; + } + + ds_put_char(s, '\n'); + + LIST_FOR_EACH (map, list_node, >r.mappings) { + allocated_space += map->option_len; + } + + ds_put_format(s, " max option space=%"PRIu32" max fields=%"PRIu16"\n", + gtr.max_option_space, gtr.max_fields); + ds_put_format(s, " allocated option space=%d\n", allocated_space); + ds_put_char(s, '\n'); + print_geneve_table(s, >r.mappings); + + ofputil_uninit_geneve_table(>r.mappings); +} + +static void +ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw, + struct ds *string, int verbosity) +{ const void *msg = oh; ofp_header_to_string__(oh, raw, string); switch (ofptype_from_ofpraw(raw)) { - /* FIXME: Change the following once they are implemented: */ - case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: - case OFPTYPE_QUEUE_GET_CONFIG_REPLY: - case OFPTYPE_GET_ASYNC_REQUEST: - case OFPTYPE_GET_ASYNC_REPLY: - case OFPTYPE_METER_MOD: - case OFPTYPE_GROUP_REQUEST: - case OFPTYPE_GROUP_REPLY: - case OFPTYPE_GROUP_DESC_REQUEST: - case OFPTYPE_GROUP_DESC_REPLY: - case OFPTYPE_GROUP_FEATURES_REQUEST: - case OFPTYPE_GROUP_FEATURES_REPLY: - case OFPTYPE_METER_REQUEST: - case OFPTYPE_METER_REPLY: - case OFPTYPE_METER_CONFIG_REQUEST: - case OFPTYPE_METER_CONFIG_REPLY: - case OFPTYPE_METER_FEATURES_REQUEST: - case OFPTYPE_METER_FEATURES_REPLY: - case OFPTYPE_TABLE_FEATURES_REQUEST: - case OFPTYPE_TABLE_FEATURES_REPLY: - ofp_print_not_implemented(string); + case OFPTYPE_GROUP_STATS_REQUEST: + ofp_print_stats(string, oh); + ofp_print_ofpst_group_request(string, oh); + break; + + case OFPTYPE_GROUP_STATS_REPLY: + ofp_print_group_stats(string, oh); + break; + + case OFPTYPE_GROUP_DESC_STATS_REQUEST: + ofp_print_stats(string, oh); + ofp_print_ofpst_group_desc_request(string, oh); + break; + + case OFPTYPE_GROUP_DESC_STATS_REPLY: + ofp_print_group_desc(string, oh); + break; + + case OFPTYPE_GROUP_FEATURES_STATS_REQUEST: + ofp_print_stats(string, oh); + break; + + case OFPTYPE_GROUP_FEATURES_STATS_REPLY: + ofp_print_group_features(string, oh); + break; + + case OFPTYPE_GROUP_MOD: + ofp_print_group_mod(string, oh); + break; + + case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: + case OFPTYPE_TABLE_FEATURES_STATS_REPLY: + ofp_print_table_features_reply(string, oh); + break; + + case OFPTYPE_TABLE_DESC_REQUEST: + case OFPTYPE_TABLE_DESC_REPLY: + ofp_print_table_desc_reply(string, oh); break; case OFPTYPE_HELLO: @@ -1980,72 +3151,117 @@ ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw, ofp_print_port_mod(string, oh); break; + case OFPTYPE_TABLE_MOD: + ofp_print_table_mod(string, oh); + break; + + case OFPTYPE_METER_MOD: + ofp_print_meter_mod(string, oh); + break; + case OFPTYPE_BARRIER_REQUEST: case OFPTYPE_BARRIER_REPLY: break; + case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: + ofp_print_queue_get_config_request(string, oh); + break; + + case OFPTYPE_QUEUE_GET_CONFIG_REPLY: + ofp_print_queue_get_config_reply(string, oh); + break; + case OFPTYPE_ROLE_REQUEST: case OFPTYPE_ROLE_REPLY: ofp_print_role_message(string, oh); break; + case OFPTYPE_ROLE_STATUS: + ofp_print_role_status_message(string, oh); + break; + + case OFPTYPE_METER_STATS_REQUEST: + case OFPTYPE_METER_CONFIG_STATS_REQUEST: + ofp_print_stats(string, oh); + ofp_print_meter_stats_request(string, oh); + break; + + case OFPTYPE_METER_STATS_REPLY: + ofp_print_stats(string, oh); + ofp_print_meter_stats_reply(string, oh); + break; + + case OFPTYPE_METER_CONFIG_STATS_REPLY: + ofp_print_stats(string, oh); + ofp_print_meter_config_reply(string, oh); + break; + + case OFPTYPE_METER_FEATURES_STATS_REPLY: + ofp_print_stats(string, oh); + ofp_print_meter_features_reply(string, oh); + break; case OFPTYPE_DESC_STATS_REQUEST: - case OFPTYPE_PORT_DESC_STATS_REQUEST: - ofp_print_stats_request(string, oh); + case OFPTYPE_METER_FEATURES_STATS_REQUEST: + ofp_print_stats(string, oh); break; case OFPTYPE_FLOW_STATS_REQUEST: case OFPTYPE_AGGREGATE_STATS_REQUEST: - ofp_print_stats_request(string, oh); + ofp_print_stats(string, oh); ofp_print_flow_stats_request(string, oh); break; case OFPTYPE_TABLE_STATS_REQUEST: - ofp_print_stats_request(string, oh); + ofp_print_stats(string, oh); break; case OFPTYPE_PORT_STATS_REQUEST: - ofp_print_stats_request(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_port_request(string, oh); break; case OFPTYPE_QUEUE_STATS_REQUEST: - ofp_print_stats_request(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_queue_request(string, oh); break; case OFPTYPE_DESC_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_desc_reply(string, oh); break; case OFPTYPE_FLOW_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_flow_stats_reply(string, oh); break; case OFPTYPE_QUEUE_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_queue_reply(string, oh, verbosity); break; case OFPTYPE_PORT_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_port_reply(string, oh, verbosity); break; case OFPTYPE_TABLE_STATS_REPLY: - ofp_print_stats_reply(string, oh); - ofp_print_ofpst_table_reply(string, oh, verbosity); + ofp_print_stats(string, oh); + ofp_print_table_stats_reply(string, oh); break; case OFPTYPE_AGGREGATE_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_aggregate_stats_reply(string, oh); break; + case OFPTYPE_PORT_DESC_STATS_REQUEST: + ofp_print_stats(string, oh); + ofp_print_ofpst_port_desc_request(string, oh); + break; + case OFPTYPE_PORT_DESC_STATS_REPLY: - ofp_print_stats_reply(string, oh); + ofp_print_stats(string, oh); ofp_print_ofpst_port_desc_reply(string, oh); break; @@ -2068,10 +3284,12 @@ ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw, ofp_print_nxt_set_controller_id(string, ofpmsg_body(oh)); break; + case OFPTYPE_GET_ASYNC_REPLY: case OFPTYPE_SET_ASYNC_CONFIG: - ofp_print_nxt_set_async_config(string, ofpmsg_body(oh)); + ofp_print_nxt_set_async_config(string, oh); + break; + case OFPTYPE_GET_ASYNC_REQUEST: break; - case OFPTYPE_FLOW_MONITOR_CANCEL: ofp_print_nxt_flow_monitor_cancel(string, msg); break; @@ -2087,6 +3305,26 @@ ofp_to_string__(const struct ofp_header *oh, enum ofpraw raw, case OFPTYPE_FLOW_MONITOR_STATS_REPLY: ofp_print_nxst_flow_monitor_reply(string, msg); break; + + case OFPTYPE_BUNDLE_CONTROL: + ofp_print_bundle_ctrl(string, msg); + break; + + case OFPTYPE_BUNDLE_ADD_MESSAGE: + ofp_print_bundle_add(string, msg, verbosity); + break; + + case OFPTYPE_NXT_GENEVE_TABLE_MOD: + ofp_print_geneve_table_mod(string, msg); + break; + + case OFPTYPE_NXT_GENEVE_TABLE_REQUEST: + break; + + case OFPTYPE_NXT_GENEVE_TABLE_REPLY: + ofp_print_geneve_table_reply(string, msg); + break; + } } @@ -2103,7 +3341,7 @@ ofp_to_string(const void *oh_, size_t len, int verbosity) if (!len) { ds_put_cstr(&string, "OpenFlow message is empty\n"); } else if (len < sizeof(struct ofp_header)) { - ds_put_format(&string, "OpenFlow packet too short (only %zu bytes):\n", + ds_put_format(&string, "OpenFlow packet too short (only %"PRIuSIZE" bytes):\n", len); } else if (ntohs(oh->length) > len) { enum ofperr error; @@ -2116,11 +3354,11 @@ ofp_to_string(const void *oh_, size_t len, int verbosity) } ds_put_format(&string, - "(***truncated to %zu bytes from %"PRIu16"***)\n", + "(***truncated to %"PRIuSIZE" bytes from %"PRIu16"***)\n", len, ntohs(oh->length)); } else if (ntohs(oh->length) < len) { ds_put_format(&string, - "(***only uses %"PRIu16" bytes out of %zu***)\n", + "(***only uses %"PRIu16" bytes out of %"PRIuSIZE"***)\n", ntohs(oh->length), len); } else { enum ofperr error;