X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fofp-print.c;h=d7804fed81b838eb54dcc11de5a05bd0ad2e2241;hb=49c57a8fef46461da911802e8bf82329924ea329;hp=eba194e4a1506bd7db2a846d22feb91ad3cbf2ca;hpb=7fa9111326e440a56dff41e0d4571716032a1de7;p=sliver-openvswitch.git diff --git a/lib/ofp-print.c b/lib/ofp-print.c index eba194e4a..d7804fed8 100644 --- a/lib/ofp-print.c +++ b/lib/ofp-print.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,10 +26,12 @@ #include #include +#include "bundle.h" #include "byte-order.h" #include "compiler.h" #include "dynamic-string.h" #include "flow.h" +#include "multipath.h" #include "nx-match.h" #include "ofp-util.h" #include "ofpbuf.h" @@ -37,6 +39,8 @@ #include "openflow/nicira-ext.h" #include "packets.h" #include "pcap.h" +#include "type-props.h" +#include "unaligned.h" #include "util.h" static void ofp_print_port_name(struct ds *string, uint16_t port); @@ -64,8 +68,7 @@ ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED) int status; int c; - buf.data = (void *) data; - buf.size = len; + ofpbuf_use_const(&buf, data, len); pcap = tmpfile(); if (!pcap) { @@ -80,7 +83,7 @@ ofp_packet_to_string(const void *data, size_t len, size_t total_len OVS_UNUSED) } rewind(pcap); - snprintf(command, sizeof command, "/usr/sbin/tcpdump -e -n -r /dev/fd/%d 2>/dev/null", + snprintf(command, sizeof command, "/usr/sbin/tcpdump -t -e -n -r /dev/fd/%d 2>/dev/null", fileno(pcap)); tcpdump = popen(command, "r"); fclose(pcap); @@ -121,7 +124,7 @@ ofp_print_packet_in(struct ds *string, const struct ofp_packet_in *op, data_len = len - offsetof(struct ofp_packet_in, data); ds_put_format(string, " data_len=%zu", data_len); - if (htonl(op->buffer_id) == UINT32_MAX) { + if (op->buffer_id == htonl(UINT32_MAX)) { ds_put_format(string, " (unbuffered)"); if (ntohs(op->total_len) != data_len) ds_put_format(string, " (***total_len != data_len***)"); @@ -136,8 +139,7 @@ ofp_print_packet_in(struct ds *string, const struct ofp_packet_in *op, struct flow flow; struct ofpbuf packet; - packet.data = (void *) op->data; - packet.size = data_len; + ofpbuf_use_const(&packet, op->data, data_len); flow_extract(&packet, 0, ntohs(op->in_port), &flow); flow_format(string, &flow); ds_put_char(string, '\n'); @@ -185,6 +187,7 @@ static void ofp_print_port_name(struct ds *string, uint16_t port) ds_put_cstr(string, name); } + static void print_note(struct ds *string, const struct nx_action_note *nan) { @@ -202,279 +205,202 @@ print_note(struct ds *string, const struct nx_action_note *nan) } static void -ofp_print_nx_action(struct ds *string, const struct nx_action_header *nah) +ofp_print_action(struct ds *s, const union ofp_action *a, + enum ofputil_action_code code) { - switch (ntohs(nah->subtype)) { - case NXAST_RESUBMIT: { - const struct nx_action_resubmit *nar = (struct nx_action_resubmit *)nah; - ds_put_format(string, "resubmit:"); - ofp_print_port_name(string, ntohs(nar->in_port)); - break; - } + const struct ofp_action_enqueue *oae; + const struct ofp_action_dl_addr *oada; + const struct nx_action_set_tunnel64 *nast64; + const struct nx_action_set_tunnel *nast; + const struct nx_action_set_queue *nasq; + const struct nx_action_resubmit *nar; + const struct nx_action_reg_move *move; + const struct nx_action_reg_load *load; + const struct nx_action_multipath *nam; + const struct nx_action_autopath *naa; + const struct nx_action_output_reg *naor; + uint16_t port; - case NXAST_SET_TUNNEL: { - const struct nx_action_set_tunnel *nast = - (struct nx_action_set_tunnel *)nah; - ds_put_format(string, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); + switch (code) { + case OFPUTIL_OFPAT_OUTPUT: + port = ntohs(a->output.port); + if (port < OFPP_MAX) { + ds_put_format(s, "output:%"PRIu16, port); + } else { + ofp_print_port_name(s, port); + if (port == OFPP_CONTROLLER) { + if (a->output.max_len != htons(0)) { + ds_put_format(s, ":%"PRIu16, ntohs(a->output.max_len)); + } else { + ds_put_cstr(s, ":all"); + } + } + } break; - } - case NXAST_DROP_SPOOFED_ARP: - ds_put_cstr(string, "drop_spoofed_arp"); + case OFPUTIL_OFPAT_ENQUEUE: + oae = (const struct ofp_action_enqueue *) a; + ds_put_format(s, "enqueue:"); + ofp_print_port_name(s, ntohs(oae->port)); + ds_put_format(s, "q%"PRIu32, ntohl(oae->queue_id)); break; - case NXAST_SET_QUEUE: { - const struct nx_action_set_queue *nasq = - (struct nx_action_set_queue *)nah; - ds_put_format(string, "set_queue:%u", ntohl(nasq->queue_id)); + case OFPUTIL_OFPAT_SET_VLAN_VID: + ds_put_format(s, "mod_vlan_vid:%"PRIu16, + ntohs(a->vlan_vid.vlan_vid)); break; - } - case NXAST_POP_QUEUE: - ds_put_cstr(string, "pop_queue"); + case OFPUTIL_OFPAT_SET_VLAN_PCP: + ds_put_format(s, "mod_vlan_pcp:%"PRIu8, a->vlan_pcp.vlan_pcp); break; - case NXAST_NOTE: - print_note(string, (const struct nx_action_note *) nah); + case OFPUTIL_OFPAT_STRIP_VLAN: + ds_put_cstr(s, "strip_vlan"); break; - default: - ds_put_format(string, "***unknown Nicira action:%d***", - ntohs(nah->subtype)); - } -} - -static int -ofp_print_action(struct ds *string, const struct ofp_action_header *ah, - size_t actions_len) -{ - uint16_t type; - size_t len; - - struct openflow_action { - size_t min_size; - size_t max_size; - }; + case OFPUTIL_OFPAT_SET_DL_SRC: + oada = (const struct ofp_action_dl_addr *) a; + ds_put_format(s, "mod_dl_src:"ETH_ADDR_FMT, + ETH_ADDR_ARGS(oada->dl_addr)); + break; - const struct openflow_action of_actions[] = { - [OFPAT_OUTPUT] = { - sizeof(struct ofp_action_output), - sizeof(struct ofp_action_output), - }, - [OFPAT_SET_VLAN_VID] = { - sizeof(struct ofp_action_vlan_vid), - sizeof(struct ofp_action_vlan_vid), - }, - [OFPAT_SET_VLAN_PCP] = { - sizeof(struct ofp_action_vlan_pcp), - sizeof(struct ofp_action_vlan_pcp), - }, - [OFPAT_STRIP_VLAN] = { - sizeof(struct ofp_action_header), - sizeof(struct ofp_action_header), - }, - [OFPAT_SET_DL_SRC] = { - sizeof(struct ofp_action_dl_addr), - sizeof(struct ofp_action_dl_addr), - }, - [OFPAT_SET_DL_DST] = { - sizeof(struct ofp_action_dl_addr), - sizeof(struct ofp_action_dl_addr), - }, - [OFPAT_SET_NW_SRC] = { - sizeof(struct ofp_action_nw_addr), - sizeof(struct ofp_action_nw_addr), - }, - [OFPAT_SET_NW_DST] = { - sizeof(struct ofp_action_nw_addr), - sizeof(struct ofp_action_nw_addr), - }, - [OFPAT_SET_NW_TOS] = { - sizeof(struct ofp_action_nw_tos), - sizeof(struct ofp_action_nw_tos), - }, - [OFPAT_SET_TP_SRC] = { - sizeof(struct ofp_action_tp_port), - sizeof(struct ofp_action_tp_port), - }, - [OFPAT_SET_TP_DST] = { - sizeof(struct ofp_action_tp_port), - sizeof(struct ofp_action_tp_port), - } - /* OFPAT_VENDOR is not here, since it would blow up the array size. */ - }; + case OFPUTIL_OFPAT_SET_DL_DST: + oada = (const struct ofp_action_dl_addr *) a; + ds_put_format(s, "mod_dl_dst:"ETH_ADDR_FMT, + ETH_ADDR_ARGS(oada->dl_addr)); + break; - if (actions_len < sizeof *ah) { - ds_put_format(string, "***action array too short for next action***\n"); - return -1; - } + case OFPUTIL_OFPAT_SET_NW_SRC: + ds_put_format(s, "mod_nw_src:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr)); + break; - type = ntohs(ah->type); - len = ntohs(ah->len); - if (actions_len < len) { - ds_put_format(string, "***truncated action %"PRIu16"***\n", type); - return -1; - } + case OFPUTIL_OFPAT_SET_NW_DST: + ds_put_format(s, "mod_nw_dst:"IP_FMT, IP_ARGS(&a->nw_addr.nw_addr)); + break; - if (!len) { - ds_put_format(string, "***zero-length action***\n"); - return 8; - } + case OFPUTIL_OFPAT_SET_NW_TOS: + ds_put_format(s, "mod_nw_tos:%d", a->nw_tos.nw_tos); + break; - if ((len % OFP_ACTION_ALIGN) != 0) { - ds_put_format(string, - "***action %"PRIu16" length not a multiple of %d***\n", - type, OFP_ACTION_ALIGN); - return -1; - } + case OFPUTIL_OFPAT_SET_TP_SRC: + ds_put_format(s, "mod_tp_src:%d", ntohs(a->tp_port.tp_port)); + break; - if (type < ARRAY_SIZE(of_actions)) { - const struct openflow_action *act = &of_actions[type]; - if ((len < act->min_size) || (len > act->max_size)) { - ds_put_format(string, - "***action %"PRIu16" wrong length: %zu***\n", type, len); - return -1; - } - } + case OFPUTIL_OFPAT_SET_TP_DST: + ds_put_format(s, "mod_tp_dst:%d", ntohs(a->tp_port.tp_port)); + break; - switch (type) { - case OFPAT_OUTPUT: { - struct ofp_action_output *oa = (struct ofp_action_output *)ah; - uint16_t port = ntohs(oa->port); - if (port < OFPP_MAX) { - ds_put_format(string, "output:%"PRIu16, port); - } else { - ofp_print_port_name(string, port); - if (port == OFPP_CONTROLLER) { - if (oa->max_len) { - ds_put_format(string, ":%"PRIu16, ntohs(oa->max_len)); - } else { - ds_put_cstr(string, ":all"); - } - } - } + case OFPUTIL_NXAST_RESUBMIT: + nar = (struct nx_action_resubmit *)a; + ds_put_format(s, "resubmit:"); + ofp_print_port_name(s, ntohs(nar->in_port)); break; - } - case OFPAT_ENQUEUE: { - struct ofp_action_enqueue *ea = (struct ofp_action_enqueue *)ah; - unsigned int port = ntohs(ea->port); - unsigned int queue_id = ntohl(ea->queue_id); - ds_put_format(string, "enqueue:"); - if (port != OFPP_IN_PORT) { - ds_put_format(string, "%u", port); - } else { - ds_put_cstr(string, "IN_PORT"); + case OFPUTIL_NXAST_RESUBMIT_TABLE: + nar = (struct nx_action_resubmit *)a; + ds_put_format(s, "resubmit("); + if (nar->in_port != htons(OFPP_IN_PORT)) { + ofp_print_port_name(s, ntohs(nar->in_port)); + } + ds_put_char(s, ','); + if (nar->table != 255) { + ds_put_format(s, "%"PRIu8, nar->table); } - ds_put_format(string, "q%u", queue_id); + ds_put_char(s, ')'); break; - } - case OFPAT_SET_VLAN_VID: { - struct ofp_action_vlan_vid *va = (struct ofp_action_vlan_vid *)ah; - ds_put_format(string, "mod_vlan_vid:%"PRIu16, ntohs(va->vlan_vid)); + case OFPUTIL_NXAST_SET_TUNNEL: + nast = (struct nx_action_set_tunnel *)a; + ds_put_format(s, "set_tunnel:%#"PRIx32, ntohl(nast->tun_id)); break; - } - case OFPAT_SET_VLAN_PCP: { - struct ofp_action_vlan_pcp *va = (struct ofp_action_vlan_pcp *)ah; - ds_put_format(string, "mod_vlan_pcp:%"PRIu8, va->vlan_pcp); + case OFPUTIL_NXAST_SET_QUEUE: + nasq = (struct nx_action_set_queue *)a; + ds_put_format(s, "set_queue:%u", ntohl(nasq->queue_id)); break; - } - case OFPAT_STRIP_VLAN: - ds_put_cstr(string, "strip_vlan"); + case OFPUTIL_NXAST_POP_QUEUE: + ds_put_cstr(s, "pop_queue"); break; - case OFPAT_SET_DL_SRC: { - struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah; - ds_put_format(string, "mod_dl_src:"ETH_ADDR_FMT, - ETH_ADDR_ARGS(da->dl_addr)); + case OFPUTIL_NXAST_NOTE: + print_note(s, (const struct nx_action_note *) a); break; - } - case OFPAT_SET_DL_DST: { - struct ofp_action_dl_addr *da = (struct ofp_action_dl_addr *)ah; - ds_put_format(string, "mod_dl_dst:"ETH_ADDR_FMT, - ETH_ADDR_ARGS(da->dl_addr)); + case OFPUTIL_NXAST_REG_MOVE: + move = (const struct nx_action_reg_move *) a; + nxm_format_reg_move(move, s); break; - } - case OFPAT_SET_NW_SRC: { - struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah; - ds_put_format(string, "mod_nw_src:"IP_FMT, IP_ARGS(&na->nw_addr)); + case OFPUTIL_NXAST_REG_LOAD: + load = (const struct nx_action_reg_load *) a; + nxm_format_reg_load(load, s); break; - } - case OFPAT_SET_NW_DST: { - struct ofp_action_nw_addr *na = (struct ofp_action_nw_addr *)ah; - ds_put_format(string, "mod_nw_dst:"IP_FMT, IP_ARGS(&na->nw_addr)); + case OFPUTIL_NXAST_SET_TUNNEL64: + nast64 = (const struct nx_action_set_tunnel64 *) a; + ds_put_format(s, "set_tunnel64:%#"PRIx64, + ntohll(nast64->tun_id)); break; - } - case OFPAT_SET_NW_TOS: { - struct ofp_action_nw_tos *nt = (struct ofp_action_nw_tos *)ah; - ds_put_format(string, "mod_nw_tos:%d", nt->nw_tos); + case OFPUTIL_NXAST_MULTIPATH: + nam = (const struct nx_action_multipath *) a; + multipath_format(nam, s); break; - } - case OFPAT_SET_TP_SRC: { - struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah; - ds_put_format(string, "mod_tp_src:%d", ntohs(ta->tp_port)); + case OFPUTIL_NXAST_AUTOPATH: + naa = (const struct nx_action_autopath *)a; + ds_put_format(s, "autopath(%u,", ntohl(naa->id)); + nxm_format_field_bits(s, ntohl(naa->dst), + nxm_decode_ofs(naa->ofs_nbits), + nxm_decode_n_bits(naa->ofs_nbits)); + ds_put_char(s, ')'); break; - } - case OFPAT_SET_TP_DST: { - struct ofp_action_tp_port *ta = (struct ofp_action_tp_port *)ah; - ds_put_format(string, "mod_tp_dst:%d", ntohs(ta->tp_port)); + case OFPUTIL_NXAST_BUNDLE: + case OFPUTIL_NXAST_BUNDLE_LOAD: + bundle_format((const struct nx_action_bundle *) a, s); break; - } - case OFPAT_VENDOR: { - struct ofp_action_vendor_header *avh - = (struct ofp_action_vendor_header *)ah; - if (len < sizeof *avh) { - ds_put_format(string, "***ofpat_vendor truncated***\n"); - return -1; - } - if (avh->vendor == htonl(NX_VENDOR_ID)) { - ofp_print_nx_action(string, (struct nx_action_header *)avh); - } else { - ds_put_format(string, "vendor action:0x%x", ntohl(avh->vendor)); - } + case OFPUTIL_NXAST_OUTPUT_REG: + naor = (const struct nx_action_output_reg *) a; + ds_put_cstr(s, "output:"); + nxm_format_field_bits(s, ntohl(naor->src), + nxm_decode_ofs(naor->ofs_nbits), + nxm_decode_n_bits(naor->ofs_nbits)); break; - } default: - ds_put_format(string, "(decoder %"PRIu16" not implemented)", type); break; } - - return len; } void -ofp_print_actions(struct ds *string, const struct ofp_action_header *action, - size_t actions_len) +ofp_print_actions(struct ds *string, const union ofp_action *actions, + size_t n_actions) { - uint8_t *p = (uint8_t *)action; - int len = 0; + const union ofp_action *a; + size_t left; ds_put_cstr(string, "actions="); - if (!actions_len) { + if (!n_actions) { ds_put_cstr(string, "drop"); } - while (actions_len > 0) { - if (len) { - ds_put_cstr(string, ","); - } - len = ofp_print_action(string, (struct ofp_action_header *)p, - actions_len); - if (len < 0) { - return; + + OFPUTIL_ACTION_FOR_EACH (a, left, actions, n_actions) { + int code = ofputil_decode_action(a); + if (code >= 0) { + if (a != actions) { + ds_put_cstr(string, ","); + } + ofp_print_action(string, a, code); + } else { + ofp_print_error(string, -code); } - p += len; - actions_len -= len; + } + if (left > 0) { + ds_put_format(string, " ***%zu leftover bytes following actions", + left * sizeof *a); } } @@ -493,7 +419,12 @@ ofp_print_packet_out(struct ds *string, const struct ofp_packet_out *opo, ds_put_format(string, "***packet too short for action length***\n"); return; } - ofp_print_actions(string, opo->actions, actions_len); + if (actions_len % sizeof(union ofp_action)) { + ds_put_format(string, "***action length not a multiple of %zu***\n", + sizeof(union ofp_action)); + } + ofp_print_actions(string, (const union ofp_action *) opo->actions, + actions_len / sizeof(union ofp_action)); if (ntohl(opo->buffer_id) == UINT32_MAX) { int data_len = len - sizeof *opo - actions_len; @@ -523,47 +454,108 @@ compare_ports(const void *a_, const void *b_) return ap < bp ? -1 : ap > bp; } -static void ofp_print_port_features(struct ds *string, uint32_t features) +struct bit_name { + uint32_t bit; + const char *name; +}; + +static void +ofp_print_bit_names(struct ds *string, uint32_t bits, + const struct bit_name bit_names[]) { - if (features == 0) { - ds_put_cstr(string, "Unsupported\n"); + int n = 0; + + if (!bits) { + ds_put_cstr(string, "0"); return; } - if (features & OFPPF_10MB_HD) { - ds_put_cstr(string, "10MB-HD "); - } - if (features & OFPPF_10MB_FD) { - ds_put_cstr(string, "10MB-FD "); - } - if (features & OFPPF_100MB_HD) { - ds_put_cstr(string, "100MB-HD "); - } - if (features & OFPPF_100MB_FD) { - ds_put_cstr(string, "100MB-FD "); - } - if (features & OFPPF_1GB_HD) { - ds_put_cstr(string, "1GB-HD "); - } - if (features & OFPPF_1GB_FD) { - ds_put_cstr(string, "1GB-FD "); - } - if (features & OFPPF_10GB_FD) { - ds_put_cstr(string, "10GB-FD "); - } - if (features & OFPPF_COPPER) { - ds_put_cstr(string, "COPPER "); - } - if (features & OFPPF_FIBER) { - ds_put_cstr(string, "FIBER "); - } - if (features & OFPPF_AUTONEG) { - ds_put_cstr(string, "AUTO_NEG "); + + for (; bits && bit_names->name; bit_names++) { + if (bits & bit_names->bit) { + if (n++) { + ds_put_char(string, ' '); + } + ds_put_cstr(string, bit_names->name); + bits &= ~bit_names->bit; + } } - if (features & OFPPF_PAUSE) { - ds_put_cstr(string, "AUTO_PAUSE "); + + if (bits) { + if (n++) { + ds_put_char(string, ' '); + } + ds_put_format(string, "0x%"PRIx32, bits); } - if (features & OFPPF_PAUSE_ASYM) { - ds_put_cstr(string, "AUTO_PAUSE_ASYM "); +} + +static void +ofp_print_port_features(struct ds *string, uint32_t features) +{ + static const struct bit_name feature_bits[] = { + { OFPPF_10MB_HD, "10MB-HD" }, + { OFPPF_10MB_FD, "10MB-FD" }, + { OFPPF_100MB_HD, "100MB-HD" }, + { OFPPF_100MB_FD, "100MB-FD" }, + { OFPPF_1GB_HD, "1GB-HD" }, + { OFPPF_1GB_FD, "1GB-FD" }, + { OFPPF_10GB_FD, "10GB-FD" }, + { OFPPF_COPPER, "COPPER" }, + { OFPPF_FIBER, "FIBER" }, + { OFPPF_AUTONEG, "AUTO_NEG" }, + { OFPPF_PAUSE, "AUTO_PAUSE" }, + { OFPPF_PAUSE_ASYM, "AUTO_PAUSE_ASYM" }, + { 0, NULL }, + }; + + ofp_print_bit_names(string, features, feature_bits); + ds_put_char(string, '\n'); +} + +static void +ofp_print_port_config(struct ds *string, uint32_t config) +{ + static const struct bit_name config_bits[] = { + { OFPPC_PORT_DOWN, "PORT_DOWN" }, + { OFPPC_NO_STP, "NO_STP" }, + { OFPPC_NO_RECV, "NO_RECV" }, + { OFPPC_NO_RECV_STP, "NO_RECV_STP" }, + { OFPPC_NO_FLOOD, "NO_FLOOD" }, + { OFPPC_NO_FWD, "NO_FWD" }, + { OFPPC_NO_PACKET_IN, "NO_PACKET_IN" }, + { 0, NULL }, + }; + + ofp_print_bit_names(string, config, config_bits); + ds_put_char(string, '\n'); +} + +static void +ofp_print_port_state(struct ds *string, uint32_t state) +{ + static const struct bit_name state_bits[] = { + { OFPPS_LINK_DOWN, "LINK_DOWN" }, + { 0, NULL }, + }; + uint32_t stp_state; + + /* The STP state is a 2-bit field so it doesn't fit in with the bitmask + * pattern. We have to special case it. + * + * OVS doesn't support STP, so this field will always be 0 if we are + * talking to OVS, so we'd always print STP_LISTEN in that case. + * Therefore, we don't print anything at all if the value is STP_LISTEN, to + * avoid confusing users. */ + stp_state = state & OFPPS_STP_MASK; + if (stp_state) { + ds_put_cstr(string, (stp_state == OFPPS_STP_LEARN ? "STP_LEARN" + : stp_state == OFPPS_STP_FORWARD ? "STP_FORWARD" + : "STP_BLOCK")); + state &= ~OFPPS_STP_MASK; + if (state) { + ofp_print_bit_names(string, state, state_bits); + } + } else { + ofp_print_bit_names(string, state, state_bits); } ds_put_char(string, '\n'); } @@ -576,7 +568,7 @@ ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port) memcpy(name, port->name, sizeof name); for (j = 0; j < sizeof name - 1; j++) { - if (!isprint(name[j])) { + if (!isprint((unsigned char) name[j])) { break; } } @@ -584,9 +576,15 @@ ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port) ds_put_char(string, ' '); ofp_print_port_name(string, ntohs(port->port_no)); - ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT", config: %#x, state:%#x\n", - name, ETH_ADDR_ARGS(port->hw_addr), ntohl(port->config), - ntohl(port->state)); + ds_put_format(string, "(%s): addr:"ETH_ADDR_FMT"\n", + name, ETH_ADDR_ARGS(port->hw_addr)); + + ds_put_cstr(string, " config: "); + ofp_print_port_config(string, ntohl(port->config)); + + ds_put_cstr(string, " state: "); + ofp_print_port_state(string, ntohl(port->state)); + if (port->curr) { ds_put_format(string, " current: "); ofp_print_port_features(string, ntohl(port->curr)); @@ -637,6 +635,22 @@ ofp_print_switch_config(struct ds *string, const struct ofp_switch_config *osc) uint16_t flags; flags = ntohs(osc->flags); + + ds_put_cstr(string, " frags="); + switch (flags & OFPC_FRAG_MASK) { + case OFPC_FRAG_NORMAL: + ds_put_cstr(string, "normal"); + flags &= ~OFPC_FRAG_MASK; + break; + case OFPC_FRAG_DROP: + ds_put_cstr(string, "drop"); + flags &= ~OFPC_FRAG_MASK; + break; + case OFPC_FRAG_REASM: + ds_put_cstr(string, "reassemble"); + flags &= ~OFPC_FRAG_MASK; + break; + } if (flags) { ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", flags); } @@ -668,7 +682,7 @@ static void print_wild(struct ds *string, const char *leader, int is_wild, } static void -print_ip_netmask(struct ds *string, const char *leader, uint32_t ip, +print_ip_netmask(struct ds *string, const char *leader, ovs_be32 ip, uint32_t wild_bits, int verbosity) { if (wild_bits >= 32 && verbosity < 2) { @@ -707,11 +721,11 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity) if (om->dl_type == htons(ETH_TYPE_IP)) { if (!(w & OFPFW_NW_PROTO)) { skip_proto = true; - if (om->nw_proto == IP_TYPE_ICMP) { + if (om->nw_proto == IPPROTO_ICMP) { ds_put_cstr(&f, "icmp,"); - } else if (om->nw_proto == IP_TYPE_TCP) { + } else if (om->nw_proto == IPPROTO_TCP) { ds_put_cstr(&f, "tcp,"); - } else if (om->nw_proto == IP_TYPE_UDP) { + } else if (om->nw_proto == IPPROTO_UDP) { ds_put_cstr(&f, "udp,"); } else { ds_put_cstr(&f, "ip,"); @@ -726,9 +740,6 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity) skip_type = false; } } - if (w & NXFW_TUN_ID) { - ds_put_cstr(&f, "tun_id_wild,"); - } print_wild(&f, "in_port=", w & OFPFW_IN_PORT, verbosity, "%d", ntohs(om->in_port)); print_wild(&f, "dl_vlan=", w & OFPFW_DL_VLAN, verbosity, @@ -749,7 +760,7 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity) (w & OFPFW_NW_DST_MASK) >> OFPFW_NW_DST_SHIFT, verbosity); if (!skip_proto) { if (om->dl_type == htons(ETH_TYPE_ARP)) { - print_wild(&f, "opcode=", w & OFPFW_NW_PROTO, verbosity, + print_wild(&f, "arp_op=", w & OFPFW_NW_PROTO, verbosity, "%u", om->nw_proto); } else { print_wild(&f, "nw_proto=", w & OFPFW_NW_PROTO, verbosity, @@ -758,7 +769,7 @@ ofp_match_to_string(const struct ofp_match *om, int verbosity) } print_wild(&f, "nw_tos=", w & OFPFW_NW_TOS, verbosity, "%u", om->nw_tos); - if (om->nw_proto == IP_TYPE_ICMP) { + if (om->nw_proto == IPPROTO_ICMP) { print_wild(&f, "icmp_type=", w & OFPFW_ICMP_TYPE, verbosity, "%d", ntohs(om->icmp_type)); print_wild(&f, "icmp_code=", w & OFPFW_ICMP_CODE, verbosity, @@ -779,10 +790,11 @@ static void ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, enum ofputil_msg_code code, int verbosity) { - struct flow_mod fm; + struct ofputil_flow_mod fm; + bool need_priority; int error; - error = ofputil_decode_flow_mod(&fm, oh, NXFF_OPENFLOW10); + error = ofputil_decode_flow_mod(&fm, oh, true); if (error) { ofp_print_error(s, error); return; @@ -808,20 +820,33 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, default: ds_put_format(s, "cmd:%d", fm.command); } + if (fm.table_id != 0) { + ds_put_format(s, " table:%d", fm.table_id); + } ds_put_char(s, ' '); if (verbosity >= 3 && code == OFPUTIL_OFPT_FLOW_MOD) { const struct ofp_flow_mod *ofm = (const struct ofp_flow_mod *) oh; - ofp_print_match(s, &ofm->match, verbosity); + + /* ofp_print_match() doesn't print priority. */ + need_priority = true; } else if (verbosity >= 3 && code == OFPUTIL_NXT_FLOW_MOD) { const struct nx_flow_mod *nfm = (const struct nx_flow_mod *) oh; const void *nxm = nfm + 1; - char *nxm_s = nx_match_to_string(nxm, ntohs(nfm->match_len)); + char *nxm_s; + + nxm_s = nx_match_to_string(nxm, ntohs(nfm->match_len)); ds_put_cstr(s, nxm_s); free(nxm_s); + + /* nx_match_to_string() doesn't print priority. */ + need_priority = true; } else { cls_rule_format(&fm.cr, s); + + /* cls_rule_format() does print priority. */ + need_priority = false; } if (ds_last(s) != ' ') { @@ -836,7 +861,7 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, if (fm.hard_timeout != OFP_FLOW_PERMANENT) { ds_put_format(s, "hard:%"PRIu16" ", fm.hard_timeout); } - if (fm.cr.priority != OFP_DEFAULT_PRIORITY && verbosity >= 3) { + if (fm.cr.priority != OFP_DEFAULT_PRIORITY && need_priority) { ds_put_format(s, "pri:%"PRIu16" ", fm.cr.priority); } if (fm.buffer_id != UINT32_MAX) { @@ -846,17 +871,39 @@ ofp_print_flow_mod(struct ds *s, const struct ofp_header *oh, ds_put_format(s, "flags:0x%"PRIx16" ", fm.flags); } - ofp_print_actions(s, (const struct ofp_action_header *) fm.actions, - fm.n_actions * sizeof *fm.actions); + ofp_print_actions(s, fm.actions, fm.n_actions); } static void -ofp_print_flow_removed(struct ds *string, const struct ofp_flow_removed *ofr, - int verbosity) +ofp_print_duration(struct ds *string, unsigned int sec, unsigned int nsec) { - ofp_print_match(string, &ofr->match, verbosity); + ds_put_format(string, "%u", sec); + if (nsec > 0) { + ds_put_format(string, ".%09u", nsec); + while (string->string[string->length - 1] == '0') { + string->length--; + } + } + ds_put_char(string, 's'); +} + +static void +ofp_print_flow_removed(struct ds *string, const struct ofp_header *oh) +{ + struct ofputil_flow_removed fr; + int error; + + error = ofputil_decode_flow_removed(&fr, oh); + if (error) { + ofp_print_error(string, error); + return; + } + + ds_put_char(string, ' '); + cls_rule_format(&fr.rule, string); + ds_put_cstr(string, " reason="); - switch (ofr->reason) { + switch (fr.reason) { case OFPRR_IDLE_TIMEOUT: ds_put_cstr(string, "idle"); break; @@ -867,21 +914,17 @@ ofp_print_flow_removed(struct ds *string, const struct ofp_flow_removed *ofr, ds_put_cstr(string, "delete"); break; default: - ds_put_format(string, "**%"PRIu8"**", ofr->reason); + ds_put_format(string, "**%"PRIu8"**", fr.reason); break; } - if (ofr->cookie != htonll(0)) { - ds_put_format(string, " cookie:0x%"PRIx64, ntohll(ofr->cookie)); + if (fr.cookie != htonll(0)) { + ds_put_format(string, " cookie:0x%"PRIx64, ntohll(fr.cookie)); } - if (ofr->priority != htons(32768)) { - ds_put_format(string, " pri:%"PRIu16, ntohs(ofr->priority)); - } - ds_put_format(string, " secs%"PRIu32" nsecs%"PRIu32 - " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n", - ntohl(ofr->duration_sec), ntohl(ofr->duration_nsec), - ntohs(ofr->idle_timeout), ntohll(ofr->packet_count), - ntohll(ofr->byte_count)); + ds_put_cstr(string, " duration"); + ofp_print_duration(string, fr.duration_sec, fr.duration_nsec); + ds_put_format(string, " idle%"PRIu16" pkts%"PRIu64" bytes%"PRIu64"\n", + fr.idle_timeout, fr.packet_count, fr.byte_count); } static void @@ -898,117 +941,52 @@ ofp_print_port_mod(struct ds *string, const struct ofp_port_mod *opm) } } -struct error_type { - int type; - int code; - const char *name; -}; - -static const struct error_type error_types[] = { -#define ERROR_TYPE(TYPE) {TYPE, -1, #TYPE} -#define ERROR_CODE(TYPE, CODE) {TYPE, CODE, #CODE} - ERROR_TYPE(OFPET_HELLO_FAILED), - ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_INCOMPATIBLE), - ERROR_CODE(OFPET_HELLO_FAILED, OFPHFC_EPERM), - - ERROR_TYPE(OFPET_BAD_REQUEST), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_EPERM), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_EMPTY), - ERROR_CODE(OFPET_BAD_REQUEST, OFPBRC_BUFFER_UNKNOWN), - - ERROR_TYPE(OFPET_BAD_ACTION), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_LEN), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_VENDOR_TYPE), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_EPERM), - ERROR_CODE(OFPET_BAD_ACTION, OFPBAC_TOO_MANY), - - ERROR_TYPE(OFPET_FLOW_MOD_FAILED), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_EPERM), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_EMERG_TIMEOUT), - ERROR_CODE(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND), - - ERROR_TYPE(OFPET_PORT_MOD_FAILED), - ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT), - ERROR_CODE(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR) -}; -#define N_ERROR_TYPES ARRAY_SIZE(error_types) - -static const char * -lookup_error_type(int type) -{ - const struct error_type *t; - - for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) { - if (t->type == type && t->code == -1) { - return t->name; - } - } - return "?"; -} - -static const char * -lookup_error_code(int type, int code) -{ - const struct error_type *t; - - for (t = error_types; t < &error_types[N_ERROR_TYPES]; t++) { - if (t->type == type && t->code == code) { - return t->name; - } - } - return "?"; -} - static void ofp_print_error(struct ds *string, int error) { - int type = get_ofp_err_type(error); - int code = get_ofp_err_code(error); if (string->length) { ds_put_char(string, ' '); } - ds_put_format(string, " ***decode error type:%d(%s) code:%d(%s)***", - type, lookup_error_type(type), - code, lookup_error_code(type, code)); + ds_put_cstr(string, "***decode error: "); + ofputil_format_error(string, error); + ds_put_cstr(string, "***\n"); } static void ofp_print_error_msg(struct ds *string, const struct ofp_error_msg *oem) { size_t len = ntohs(oem->header.length); - int type = ntohs(oem->type); - int code = ntohs(oem->code); + size_t payload_ofs, payload_len; + const void *payload; + int error; char *s; - ds_put_format(string, " type:%d(%s) code:%d(%s) payload:\n", - type, lookup_error_type(type), - code, lookup_error_code(type, code)); + error = ofputil_decode_error_msg(&oem->header, &payload_ofs); + if (!is_ofp_error(error)) { + ofp_print_error(string, error); + ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true); + return; + } - switch (type) { + ds_put_char(string, ' '); + ofputil_format_error(string, error); + ds_put_char(string, '\n'); + + payload = (const uint8_t *) oem + payload_ofs; + payload_len = len - payload_ofs; + switch (get_ofp_err_type(error)) { case OFPET_HELLO_FAILED: - ds_put_printable(string, (char *) oem->data, len - sizeof *oem); + ds_put_printable(string, payload, payload_len); break; case OFPET_BAD_REQUEST: - s = ofp_to_string(oem->data, len - sizeof *oem, 1); + s = ofp_to_string(payload, payload_len, 1); ds_put_cstr(string, s); free(s); break; default: - ds_put_hex_dump(string, oem->data, len - sizeof *oem, 0, true); + ds_put_hex_dump(string, payload, payload_len, 0, true); break; } } @@ -1028,10 +1006,9 @@ ofp_print_port_status(struct ds *string, const struct ofp_port_status *ops) } static void -ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_header *oh) +ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_desc_stats *ods) { - const struct ofp_desc_stats *ods = ofputil_stats_body(oh); - + ds_put_char(string, '\n'); ds_put_format(string, "Manufacturer: %.*s\n", (int) sizeof ods->mfr_desc, ods->mfr_desc); ds_put_format(string, "Hardware: %.*s\n", @@ -1045,117 +1022,101 @@ ofp_print_ofpst_desc_reply(struct ds *string, const struct ofp_header *oh) } static void -ofp_print_ofpst_flow_request(struct ds *string, const struct ofp_header *oh, - int verbosity) +ofp_print_flow_stats_request(struct ds *string, + const struct ofp_stats_msg *osm) { - const struct ofp_flow_stats_request *fsr = ofputil_stats_body(oh); + struct ofputil_flow_stats_request fsr; + int error; - if (fsr->table_id == 0xff) { - ds_put_format(string, " table_id=any, "); - } else { - ds_put_format(string, " table_id=%"PRIu8", ", fsr->table_id); + error = ofputil_decode_flow_stats_request(&fsr, &osm->header); + if (error) { + ofp_print_error(string, error); + return; + } + + if (fsr.table_id != 0xff) { + ds_put_format(string, " table=%"PRIu8, fsr.table_id); } - ofp_print_match(string, &fsr->match, verbosity); + if (fsr.out_port != OFPP_NONE) { + ds_put_cstr(string, " out_port="); + ofp_print_port_name(string, fsr.out_port); + } + + /* A flow stats request doesn't include a priority, but cls_rule_format() + * will print one unless it is OFP_DEFAULT_PRIORITY. */ + fsr.match.priority = OFP_DEFAULT_PRIORITY; + + ds_put_char(string, ' '); + cls_rule_format(&fsr.match, string); } static void -ofp_print_ofpst_flow_reply(struct ds *string, const struct ofp_header *oh, - int verbosity) +ofp_print_flow_stats_reply(struct ds *string, const struct ofp_header *oh) { - size_t len = ofputil_stats_body_len(oh); - const char *body = ofputil_stats_body(oh); - const char *pos = body; + struct ofpbuf b; + + ofpbuf_use_const(&b, oh, ntohs(oh->length)); for (;;) { - const struct ofp_flow_stats *fs; - ptrdiff_t bytes_left = body + len - pos; - size_t length; - - if (bytes_left < sizeof *fs) { - if (bytes_left != 0) { - ds_put_format(string, " ***%td leftover bytes at end***", - bytes_left); + struct ofputil_flow_stats fs; + int retval; + + retval = ofputil_decode_flow_stats_reply(&fs, &b); + if (retval) { + if (retval != EOF) { + ds_put_cstr(string, " ***parse error***"); } break; } - fs = (const void *) pos; - length = ntohs(fs->length); - if (length < sizeof *fs) { - ds_put_format(string, " ***length=%zu shorter than minimum %zu***", - length, sizeof *fs); - break; - } else if (length > bytes_left) { - ds_put_format(string, - " ***length=%zu but only %td bytes left***", - length, bytes_left); - break; - } else if ((length - sizeof *fs) % sizeof fs->actions[0]) { - ds_put_format(string, - " ***length=%zu has %zu bytes leftover in " - "final action***", - length, - (length - sizeof *fs) % sizeof fs->actions[0]); - break; - } + ds_put_char(string, '\n'); - ds_put_format(string, " cookie=0x%"PRIx64", ", ntohll(fs->cookie)); - ds_put_format(string, "duration_sec=%"PRIu32"s, ", - ntohl(fs->duration_sec)); - ds_put_format(string, "duration_nsec=%"PRIu32"ns, ", - ntohl(fs->duration_nsec)); - ds_put_format(string, "table_id=%"PRIu8", ", fs->table_id); - ds_put_format(string, "priority=%"PRIu16", ", - fs->match.wildcards ? ntohs(fs->priority) : (uint16_t)-1); - ds_put_format(string, "n_packets=%"PRIu64", ", - ntohll(fs->packet_count)); - ds_put_format(string, "n_bytes=%"PRIu64", ", ntohll(fs->byte_count)); - if (fs->idle_timeout != htons(OFP_FLOW_PERMANENT)) { - ds_put_format(string, "idle_timeout=%"PRIu16",", - ntohs(fs->idle_timeout)); + ds_put_format(string, " cookie=0x%"PRIx64", duration=", + ntohll(fs.cookie)); + ofp_print_duration(string, fs.duration_sec, fs.duration_nsec); + ds_put_format(string, ", table=%"PRIu8", ", fs.table_id); + ds_put_format(string, "n_packets=%"PRIu64", ", fs.packet_count); + ds_put_format(string, "n_bytes=%"PRIu64", ", fs.byte_count); + if (fs.idle_timeout != OFP_FLOW_PERMANENT) { + ds_put_format(string, "idle_timeout=%"PRIu16",", fs.idle_timeout); } - if (fs->hard_timeout != htons(OFP_FLOW_PERMANENT)) { - ds_put_format(string, "hard_timeout=%"PRIu16",", - ntohs(fs->hard_timeout)); + if (fs.hard_timeout != OFP_FLOW_PERMANENT) { + ds_put_format(string, "hard_timeout=%"PRIu16",", fs.hard_timeout); } - ofp_print_match(string, &fs->match, verbosity); - ofp_print_actions(string, fs->actions, length - sizeof *fs); - ds_put_char(string, '\n'); - pos += length; + cls_rule_format(&fs.rule, string); + ds_put_char(string, ' '); + ofp_print_actions(string, fs.actions, fs.n_actions); } } static void -ofp_print_ofpst_aggregate_request(struct ds *string, - const struct ofp_header *oh, int verbosity) +ofp_print_ofpst_aggregate_reply(struct ds *string, + const struct ofp_aggregate_stats_reply *asr) { - const struct ofp_aggregate_stats_request *asr = ofputil_stats_body(oh); - - if (asr->table_id == 0xff) { - ds_put_format(string, " table_id=any, "); - } else { - ds_put_format(string, " table_id=%"PRIu8", ", asr->table_id); - } - - ofp_print_match(string, &asr->match, verbosity); + ds_put_format(string, " packet_count=%"PRIu64, + ntohll(get_32aligned_be64(&asr->packet_count))); + ds_put_format(string, " byte_count=%"PRIu64, + ntohll(get_32aligned_be64(&asr->byte_count))); + ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count)); } static void -ofp_print_ofpst_aggregate_reply(struct ds *string, const struct ofp_header *oh) +ofp_print_nxst_aggregate_reply(struct ds *string, + const struct nx_aggregate_stats_reply *nasr) { - const struct ofp_aggregate_stats_reply *asr = ofputil_stats_body(oh); - - ds_put_format(string, " packet_count=%"PRIu64, ntohll(asr->packet_count)); - ds_put_format(string, " byte_count=%"PRIu64, ntohll(asr->byte_count)); - ds_put_format(string, " flow_count=%"PRIu32, ntohl(asr->flow_count)); + ds_put_format(string, " packet_count=%"PRIu64, ntohll(nasr->packet_count)); + ds_put_format(string, " byte_count=%"PRIu64, ntohll(nasr->byte_count)); + ds_put_format(string, " flow_count=%"PRIu32, ntohl(nasr->flow_count)); } static void print_port_stat(struct ds *string, const char *leader, - uint64_t stat, int more) + const ovs_32aligned_be64 *statp, int more) { + uint64_t stat = ntohll(get_32aligned_be64(statp)); + ds_put_cstr(string, leader); - if (stat != -1) { + if (stat != UINT64_MAX) { ds_put_format(string, "%"PRIu64, stat); } else { ds_put_char(string, '?'); @@ -1168,10 +1129,10 @@ static void print_port_stat(struct ds *string, const char *leader, } static void -ofp_print_ofpst_port_request(struct ds *string, const struct ofp_header *oh) +ofp_print_ofpst_port_request(struct ds *string, + const struct ofp_port_stats_request *psr) { - const struct ofp_port_stats_request *psr = ofputil_stats_body(oh); - ds_put_format(string, "port_no=%"PRIu16, ntohs(psr->port_no)); + ds_put_format(string, " port_no=%"PRIu16, ntohs(psr->port_no)); } static void @@ -1189,20 +1150,20 @@ ofp_print_ofpst_port_reply(struct ds *string, const struct ofp_header *oh, ds_put_format(string, " port %2"PRIu16": ", ntohs(ps->port_no)); ds_put_cstr(string, "rx "); - print_port_stat(string, "pkts=", ntohll(ps->rx_packets), 1); - print_port_stat(string, "bytes=", ntohll(ps->rx_bytes), 1); - print_port_stat(string, "drop=", ntohll(ps->rx_dropped), 1); - print_port_stat(string, "errs=", ntohll(ps->rx_errors), 1); - print_port_stat(string, "frame=", ntohll(ps->rx_frame_err), 1); - print_port_stat(string, "over=", ntohll(ps->rx_over_err), 1); - print_port_stat(string, "crc=", ntohll(ps->rx_crc_err), 0); + print_port_stat(string, "pkts=", &ps->rx_packets, 1); + print_port_stat(string, "bytes=", &ps->rx_bytes, 1); + print_port_stat(string, "drop=", &ps->rx_dropped, 1); + print_port_stat(string, "errs=", &ps->rx_errors, 1); + print_port_stat(string, "frame=", &ps->rx_frame_err, 1); + print_port_stat(string, "over=", &ps->rx_over_err, 1); + print_port_stat(string, "crc=", &ps->rx_crc_err, 0); ds_put_cstr(string, " tx "); - print_port_stat(string, "pkts=", ntohll(ps->tx_packets), 1); - print_port_stat(string, "bytes=", ntohll(ps->tx_bytes), 1); - print_port_stat(string, "drop=", ntohll(ps->tx_dropped), 1); - print_port_stat(string, "errs=", ntohll(ps->tx_errors), 1); - print_port_stat(string, "coll=", ntohll(ps->collisions), 0); + print_port_stat(string, "pkts=", &ps->tx_packets, 1); + print_port_stat(string, "bytes=", &ps->tx_bytes, 1); + print_port_stat(string, "drop=", &ps->tx_dropped, 1); + print_port_stat(string, "errs=", &ps->tx_errors, 1); + print_port_stat(string, "coll=", &ps->collisions, 0); } } @@ -1219,8 +1180,7 @@ ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh, for (; n--; ts++) { char name[OFP_MAX_TABLE_NAME_LEN + 1]; - strncpy(name, ts->name, sizeof name); - name[OFP_MAX_TABLE_NAME_LEN] = '\0'; + ovs_strlcpy(name, ts->name, sizeof name); ds_put_format(string, " %d: %-8s: ", ts->table_id, name); ds_put_format(string, "wild=0x%05"PRIx32", ", ntohl(ts->wildcards)); @@ -1228,9 +1188,9 @@ ofp_print_ofpst_table_reply(struct ds *string, const struct ofp_header *oh, 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)); + ntohll(get_32aligned_be64(&ts->lookup_count))); ds_put_format(string, "matched=%"PRIu64"\n", - ntohll(ts->matched_count)); + ntohll(get_32aligned_be64(&ts->matched_count))); } } @@ -1245,10 +1205,9 @@ ofp_print_queue_name(struct ds *string, uint32_t queue_id) } static void -ofp_print_ofpst_queue_request(struct ds *string, const struct ofp_header *oh) +ofp_print_ofpst_queue_request(struct ds *string, + const struct ofp_queue_stats_request *qsr) { - const struct ofp_queue_stats_request *qsr = ofputil_stats_body(oh); - ds_put_cstr(string, "port="); ofp_print_port_name(string, ntohs(qsr->port_no)); @@ -1274,17 +1233,16 @@ ofp_print_ofpst_queue_reply(struct ds *string, const struct ofp_header *oh, ofp_print_queue_name(string, ntohl(qs->queue_id)); ds_put_cstr(string, ": "); - print_port_stat(string, "bytes=", ntohll(qs->tx_bytes), 1); - print_port_stat(string, "pkts=", ntohll(qs->tx_packets), 1); - print_port_stat(string, "errors=", ntohll(qs->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, 0); } } static void ofp_print_stats_request(struct ds *string, const struct ofp_header *oh) { - const struct ofp_stats_request *srq - = (const struct ofp_stats_request *) oh; + const struct ofp_stats_msg *srq = (const struct ofp_stats_msg *) oh; if (srq->flags) { ds_put_format(string, " ***unknown flags 0x%04"PRIx16"***", @@ -1295,7 +1253,7 @@ ofp_print_stats_request(struct ds *string, const struct ofp_header *oh) static void ofp_print_stats_reply(struct ds *string, const struct ofp_header *oh) { - const struct ofp_stats_reply *srp = (const struct ofp_stats_reply *) oh; + const struct ofp_stats_msg *srp = (const struct ofp_stats_msg *) oh; if (srp->flags) { uint16_t flags = ntohs(srp->flags); @@ -1324,10 +1282,28 @@ ofp_print_echo(struct ds *string, const struct ofp_header *oh, int verbosity) } static void -ofp_print_nxt_tun_id_from_cookie(struct ds *string, - const struct nxt_tun_id_cookie *ntic) +ofp_print_nxt_role_message(struct ds *string, + const struct nx_role_request *nrr) +{ + unsigned int role = ntohl(nrr->role); + + ds_put_cstr(string, " role="); + if (role == NX_ROLE_OTHER) { + ds_put_cstr(string, "other"); + } else if (role == NX_ROLE_MASTER) { + ds_put_cstr(string, "master"); + } else if (role == NX_ROLE_SLAVE) { + ds_put_cstr(string, "slave"); + } else { + ds_put_format(string, "%u", role); + } +} + +static void +ofp_print_nxt_flow_mod_table_id(struct ds *string, + const struct nxt_flow_mod_table_id *nfmti) { - ds_put_format(string, " set=%"PRIu8, ntic->set); + ds_put_format(string, " %s", nfmti->set ? "enable" : "disable"); } static void @@ -1357,10 +1333,13 @@ ofp_to_string__(const struct ofp_header *oh, code = ofputil_msg_type_code(type); switch (code) { - case OFPUTIL_INVALID: + case OFPUTIL_MSG_INVALID: break; case OFPUTIL_OFPT_HELLO: + ds_put_char(string, '\n'); + ds_put_hex_dump(string, oh + 1, ntohs(oh->length) - sizeof *oh, + 0, true); break; case OFPUTIL_OFPT_ERROR: @@ -1392,7 +1371,8 @@ ofp_to_string__(const struct ofp_header *oh, break; case OFPUTIL_OFPT_FLOW_REMOVED: - ofp_print_flow_removed(string, msg, verbosity); + case OFPUTIL_NXT_FLOW_REMOVED: + ofp_print_flow_removed(string, msg); break; case OFPUTIL_OFPT_PORT_STATUS: @@ -1425,13 +1405,11 @@ ofp_to_string__(const struct ofp_header *oh, break; case OFPUTIL_OFPST_FLOW_REQUEST: - ofp_print_stats_request(string, oh); - ofp_print_ofpst_flow_request(string, oh, verbosity); - break; - + case OFPUTIL_NXST_FLOW_REQUEST: case OFPUTIL_OFPST_AGGREGATE_REQUEST: + case OFPUTIL_NXST_AGGREGATE_REQUEST: ofp_print_stats_request(string, oh); - ofp_print_ofpst_aggregate_request(string, oh, verbosity); + ofp_print_flow_stats_request(string, msg); break; case OFPUTIL_OFPST_TABLE_REQUEST: @@ -1440,22 +1418,23 @@ ofp_to_string__(const struct ofp_header *oh, case OFPUTIL_OFPST_PORT_REQUEST: ofp_print_stats_request(string, oh); - ofp_print_ofpst_port_request(string, oh); + ofp_print_ofpst_port_request(string, msg); break; case OFPUTIL_OFPST_QUEUE_REQUEST: ofp_print_stats_request(string, oh); - ofp_print_ofpst_queue_request(string, oh); + ofp_print_ofpst_queue_request(string, msg); break; case OFPUTIL_OFPST_DESC_REPLY: ofp_print_stats_reply(string, oh); - ofp_print_ofpst_desc_reply(string, oh); + ofp_print_ofpst_desc_reply(string, msg); break; case OFPUTIL_OFPST_FLOW_REPLY: + case OFPUTIL_NXST_FLOW_REPLY: ofp_print_stats_reply(string, oh); - ofp_print_ofpst_flow_reply(string, oh, verbosity); + ofp_print_flow_stats_reply(string, oh); break; case OFPUTIL_OFPST_QUEUE_REPLY: @@ -1475,21 +1454,16 @@ ofp_to_string__(const struct ofp_header *oh, case OFPUTIL_OFPST_AGGREGATE_REPLY: ofp_print_stats_reply(string, oh); - ofp_print_ofpst_aggregate_reply(string, oh); - break; - - case OFPUTIL_NXT_STATUS_REQUEST: - case OFPUTIL_NXT_STATUS_REPLY: - /* XXX */ - break; - - case OFPUTIL_NXT_TUN_ID_FROM_COOKIE: - ofp_print_nxt_tun_id_from_cookie(string, msg); + ofp_print_ofpst_aggregate_reply(string, msg); break; case OFPUTIL_NXT_ROLE_REQUEST: case OFPUTIL_NXT_ROLE_REPLY: - /* XXX */ + ofp_print_nxt_role_message(string, msg); + break; + + case OFPUTIL_NXT_FLOW_MOD_TABLE_ID: + ofp_print_nxt_flow_mod_table_id(string, msg); break; case OFPUTIL_NXT_SET_FLOW_FORMAT: @@ -1500,12 +1474,9 @@ ofp_to_string__(const struct ofp_header *oh, ofp_print_flow_mod(string, msg, code, verbosity); break; - case OFPUTIL_NXT_FLOW_REMOVED: - case OFPUTIL_NXST_FLOW_REQUEST: - case OFPUTIL_NXST_AGGREGATE_REQUEST: - case OFPUTIL_NXST_FLOW_REPLY: case OFPUTIL_NXST_AGGREGATE_REPLY: - /* XXX */ + ofp_print_stats_reply(string, oh); + ofp_print_nxst_aggregate_reply(string, msg); break; } } @@ -1520,14 +1491,17 @@ ofp_to_string(const void *oh_, size_t len, int verbosity) struct ds string = DS_EMPTY_INITIALIZER; const struct ofp_header *oh = oh_; - if (len < sizeof(struct ofp_header)) { - ds_put_cstr(&string, "OpenFlow packet too short:\n"); + 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", + len); } else if (oh->version != OFP_VERSION) { ds_put_format(&string, "Bad OpenFlow version %"PRIu8":\n", oh->version); } else if (ntohs(oh->length) > len) { ds_put_format(&string, - "(***truncated to %zu bytes from %"PRIu16"***)", + "(***truncated to %zu bytes from %"PRIu16"***)\n", len, ntohs(oh->length)); } else if (ntohs(oh->length) < len) { ds_put_format(&string,