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);
+ ds_put_format(string, " total_len=%"PRIuSIZE" in_port=", pin.total_len);
ofputil_format_port(pin.fmd.in_port, string);
if (pin.fmd.tun_id != htonll(0)) {
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) {
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');
case OFP13_VERSION:
return; /* no ports in ofp13_switch_features */
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
ofp_print_phy_ports(string, oh->version, &b);
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);
}
ofp_print_flow_flags(s, fm.flags);
+ ds_put_cstr(s, "actions=");
ofpacts_format(fm.ofpacts, fm.ofpacts_len, s);
ofpbuf_uninit(&ofpacts);
}
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');
ofp_print_table_miss_config(string, pm.config);
}
+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)
{
ds_put_char(string, ' ');
}
+ ds_put_cstr(string, "actions=");
ofpacts_format(fs->ofpacts, fs->ofpacts_len, string);
}
{
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;
}
ofpraw_pull_assert(&b);
n = b.size / sizeof *ts;
- ds_put_format(string, " %zu tables\n", n);
+ ds_put_format(string, " %"PRIuSIZE" tables\n", n);
if (verbosity < 1) {
return;
}
ofpraw_pull_assert(&b);
n = b.size / sizeof *ts;
- ds_put_format(string, " %zu tables\n", n);
+ ds_put_format(string, " %"PRIuSIZE" tables\n", n);
if (verbosity < 1) {
return;
}
ofpraw_pull_assert(&b);
n = b.size / sizeof *ts;
- ds_put_format(string, " %zu tables\n", n);
+ ds_put_format(string, " %"PRIuSIZE" tables\n", n);
if (verbosity < 1) {
return;
}
ofpraw_pull_assert(&b);
n = b.size / sizeof *ts;
- ds_put_format(string, " %zu tables\n", n);
+ ds_put_format(string, " %"PRIuSIZE" tables\n", n);
if (verbosity < 1) {
return;
}
break;
default:
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
}
{
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;
}
{
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;
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();
}
}
if (string->string[string->length - 1] != ' ') {
ds_put_char(string, ' ');
}
+ ds_put_cstr(string, "actions=");
ofpacts_format(update.ofpacts, update.ofpacts_len, string);
}
}
ds_put_format(s, "watch_group:%"PRIu32",", bucket->watch_group);
}
+ ds_put_cstr(s, "actions=");
ofpacts_format(bucket->ofpacts, bucket->ofpacts_len, s);
}
}
struct ofputil_group_desc gd;
int retval;
- retval = ofputil_decode_group_desc_reply(&gd, &b);
+ retval = ofputil_decode_group_desc_reply(&gd, &b, oh->version);
if (retval) {
if (retval != EOF) {
ds_put_cstr(s, " ***parse error***");
ofp_print_group_mod(string, oh);
break;
- case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
- case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
case OFPTYPE_TABLE_FEATURES_STATS_REQUEST:
case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
ofp_print_not_implemented(string);
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:
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;
}
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;