/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
* Copyright (c) 2010 Jean Tourrilhes - HP-Labs.
*
* Licensed under the Apache License, Version 2.0 (the "License");
#include "poll-loop.h"
#include "random.h"
#include "shash.h"
+#include "simap.h"
#include "sset.h"
#include "timeval.h"
#include "unaligned.h"
static uint64_t pick_datapath_id(const struct ofproto *);
static uint64_t pick_fallback_dpid(void);
static void ofproto_destroy__(struct ofproto *);
-static void set_internal_devs_mtu(struct ofproto *);
+static void update_mtu(struct ofproto *, struct ofport *);
/* unixctl. */
static void ofproto_unixctl_init(void);
hmap_init(&ofproto->deletions);
ofproto->vlan_bitmap = NULL;
ofproto->vlans_changed = false;
+ ofproto->min_mtu = INT_MAX;
error = ofproto->ofproto_class->construct(ofproto);
if (error) {
{
struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
if (!ofport) {
- VLOG_WARN("%s: cannot get STP status on nonexistent port %"PRIu16,
- ofproto->name, ofp_port);
+ VLOG_WARN_RL(&rl, "%s: cannot get STP status on nonexistent "
+ "port %"PRIu16, ofproto->name, ofp_port);
return ENODEV;
}
int
ofproto_run(struct ofproto *p)
{
+ struct sset changed_netdevs;
+ const char *changed_netdev;
struct ofport *ofport;
- char *devname;
int error;
error = p->ofproto_class->run(p);
}
if (p->ofproto_class->port_poll) {
+ char *devname;
+
while ((error = p->ofproto_class->port_poll(p, &devname)) != EAGAIN) {
process_port_change(p, error, devname);
}
}
+ /* Update OpenFlow port status for any port whose netdev has changed.
+ *
+ * Refreshing a given 'ofport' can cause an arbitrary ofport to be
+ * destroyed, so it's not safe to update ports directly from the
+ * HMAP_FOR_EACH loop, or even to use HMAP_FOR_EACH_SAFE. Instead, we
+ * need this two-phase approach. */
+ sset_init(&changed_netdevs);
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
unsigned int change_seq = netdev_change_seq(ofport->netdev);
if (ofport->change_seq != change_seq) {
ofport->change_seq = change_seq;
- update_port(p, netdev_get_name(ofport->netdev));
+ sset_add(&changed_netdevs, netdev_get_name(ofport->netdev));
}
}
+ SSET_FOR_EACH (changed_netdev, &changed_netdevs) {
+ update_port(p, changed_netdev);
+ }
+ sset_destroy(&changed_netdevs);
switch (p->state) {
case S_OPENFLOW:
return connmgr_has_controllers(p->connmgr);
}
+/* Adds some memory usage statistics for 'ofproto' into 'usage', for use with
+ * memory_report(). */
+void
+ofproto_get_memory_usage(const struct ofproto *ofproto, struct simap *usage)
+{
+ const struct oftable *table;
+ unsigned int n_rules;
+
+ simap_increase(usage, "ports", hmap_count(&ofproto->ports));
+ simap_increase(usage, "ops",
+ ofproto->n_pending + hmap_count(&ofproto->deletions));
+
+ n_rules = 0;
+ OFPROTO_FOR_EACH_TABLE (table, ofproto) {
+ n_rules += classifier_count(&table->cls);
+ }
+ simap_increase(usage, "rules", n_rules);
+
+ if (ofproto->ofproto_class->get_memory_usage) {
+ ofproto->ofproto_class->get_memory_usage(ofproto, usage);
+ }
+
+ connmgr_get_memory_usage(ofproto->connmgr, usage);
+}
+
void
ofproto_get_ofproto_controller_info(const struct ofproto *ofproto,
struct shash *info)
/* Opens and returns a netdev for 'ofproto_port', or a null pointer if the
* netdev cannot be opened. On success, also fills in 'opp'. */
static struct netdev *
-ofport_open(const struct ofproto_port *ofproto_port, struct ofp_phy_port *opp)
+ofport_open(const struct ofproto_port *ofproto_port,
+ struct ofputil_phy_port *pp)
{
- uint32_t curr, advertised, supported, peer;
enum netdev_flags flags;
struct netdev *netdev;
int error;
return NULL;
}
+ pp->port_no = ofproto_port->ofp_port;
+ netdev_get_etheraddr(netdev, pp->hw_addr);
+ ovs_strlcpy(pp->name, ofproto_port->name, sizeof pp->name);
netdev_get_flags(netdev, &flags);
- netdev_get_features(netdev, &curr, &advertised, &supported, &peer);
-
- opp->port_no = htons(ofproto_port->ofp_port);
- netdev_get_etheraddr(netdev, opp->hw_addr);
- ovs_strzcpy(opp->name, ofproto_port->name, sizeof opp->name);
- opp->config = flags & NETDEV_UP ? 0 : htonl(OFPPC_PORT_DOWN);
- opp->state = netdev_get_carrier(netdev) ? 0 : htonl(OFPPS_LINK_DOWN);
- opp->curr = htonl(curr);
- opp->advertised = htonl(advertised);
- opp->supported = htonl(supported);
- opp->peer = htonl(peer);
+ pp->config = flags & NETDEV_UP ? 0 : OFPUTIL_PC_PORT_DOWN;
+ pp->state = netdev_get_carrier(netdev) ? 0 : OFPUTIL_PS_LINK_DOWN;
+ netdev_get_features(netdev, &pp->curr, &pp->advertised,
+ &pp->supported, &pp->peer);
+ pp->curr_speed = netdev_features_to_bps(pp->curr);
+ pp->max_speed = netdev_features_to_bps(pp->supported);
return netdev;
}
/* Returns true if most fields of 'a' and 'b' are equal. Differences in name,
- * port number, and 'config' bits other than OFPPC_PORT_DOWN are
+ * port number, and 'config' bits other than OFPUTIL_PS_LINK_DOWN are
* disregarded. */
static bool
-ofport_equal(const struct ofp_phy_port *a, const struct ofp_phy_port *b)
+ofport_equal(const struct ofputil_phy_port *a,
+ const struct ofputil_phy_port *b)
{
- BUILD_ASSERT_DECL(sizeof *a == 48); /* Detect ofp_phy_port changes. */
- return (!memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr)
+ return (eth_addr_equals(a->hw_addr, b->hw_addr)
&& a->state == b->state
- && !((a->config ^ b->config) & htonl(OFPPC_PORT_DOWN))
+ && !((a->config ^ b->config) & OFPUTIL_PC_PORT_DOWN)
&& a->curr == b->curr
&& a->advertised == b->advertised
&& a->supported == b->supported
- && a->peer == b->peer);
+ && a->peer == b->peer
+ && a->curr_speed == b->curr_speed
+ && a->max_speed == b->max_speed);
}
/* Adds an ofport to 'p' initialized based on the given 'netdev' and 'opp'.
* one with the same name or port number). */
static void
ofport_install(struct ofproto *p,
- struct netdev *netdev, const struct ofp_phy_port *opp)
+ struct netdev *netdev, const struct ofputil_phy_port *pp)
{
const char *netdev_name = netdev_get_name(netdev);
struct ofport *ofport;
- int dev_mtu;
int error;
/* Create ofport. */
ofport->ofproto = p;
ofport->netdev = netdev;
ofport->change_seq = netdev_change_seq(netdev);
- ofport->opp = *opp;
- ofport->ofp_port = ntohs(opp->port_no);
+ ofport->pp = *pp;
+ ofport->ofp_port = pp->port_no;
/* Add port to 'p'. */
hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->ofp_port, 0));
shash_add(&p->port_by_name, netdev_name, ofport);
- if (!netdev_get_mtu(netdev, &dev_mtu)) {
- set_internal_devs_mtu(p);
- ofport->mtu = dev_mtu;
- } else {
- ofport->mtu = 0;
- }
+ update_mtu(p, ofport);
/* Let the ofproto_class initialize its private data. */
error = p->ofproto_class->port_construct(ofport);
if (error) {
goto error;
}
- connmgr_send_port_status(p->connmgr, opp, OFPPR_ADD);
+ connmgr_send_port_status(p->connmgr, pp, OFPPR_ADD);
return;
error:
static void
ofport_remove(struct ofport *ofport)
{
- connmgr_send_port_status(ofport->ofproto->connmgr, &ofport->opp,
+ connmgr_send_port_status(ofport->ofproto->connmgr, &ofport->pp,
OFPPR_DELETE);
ofport_destroy(ofport);
}
}
}
-/* Updates 'port' with new 'opp' description.
+/* Updates 'port' with new 'pp' description.
*
* Does not handle a name or port number change. The caller must implement
* such a change as a delete followed by an add. */
static void
-ofport_modified(struct ofport *port, struct ofp_phy_port *opp)
+ofport_modified(struct ofport *port, struct ofputil_phy_port *pp)
{
- memcpy(port->opp.hw_addr, opp->hw_addr, ETH_ADDR_LEN);
- port->opp.config = ((port->opp.config & ~htonl(OFPPC_PORT_DOWN))
- | (opp->config & htonl(OFPPC_PORT_DOWN)));
- port->opp.state = opp->state;
- port->opp.curr = opp->curr;
- port->opp.advertised = opp->advertised;
- port->opp.supported = opp->supported;
- port->opp.peer = opp->peer;
+ memcpy(port->pp.hw_addr, pp->hw_addr, ETH_ADDR_LEN);
+ port->pp.config = ((port->pp.config & ~OFPUTIL_PC_PORT_DOWN)
+ | (pp->config & OFPUTIL_PC_PORT_DOWN));
+ port->pp.state = pp->state;
+ port->pp.curr = pp->curr;
+ port->pp.advertised = pp->advertised;
+ port->pp.supported = pp->supported;
+ port->pp.peer = pp->peer;
+ port->pp.curr_speed = pp->curr_speed;
+ port->pp.max_speed = pp->max_speed;
- connmgr_send_port_status(port->ofproto->connmgr, &port->opp, OFPPR_MODIFY);
+ connmgr_send_port_status(port->ofproto->connmgr, &port->pp, OFPPR_MODIFY);
}
/* Update OpenFlow 'state' in 'port' and notify controller. */
void
-ofproto_port_set_state(struct ofport *port, ovs_be32 state)
+ofproto_port_set_state(struct ofport *port, enum ofputil_port_state state)
{
- if (port->opp.state != state) {
- port->opp.state = state;
- connmgr_send_port_status(port->ofproto->connmgr, &port->opp,
+ if (port->pp.state != state) {
+ port->pp.state = state;
+ connmgr_send_port_status(port->ofproto->connmgr, &port->pp,
OFPPR_MODIFY);
}
}
update_port(struct ofproto *ofproto, const char *name)
{
struct ofproto_port ofproto_port;
- struct ofp_phy_port opp;
+ struct ofputil_phy_port pp;
struct netdev *netdev;
struct ofport *port;
/* Fetch 'name''s location and properties from the datapath. */
netdev = (!ofproto_port_query_by_name(ofproto, name, &ofproto_port)
- ? ofport_open(&ofproto_port, &opp)
+ ? ofport_open(&ofproto_port, &pp)
: NULL);
if (netdev) {
port = ofproto_get_port(ofproto, ofproto_port.ofp_port);
if (port && !strcmp(netdev_get_name(port->netdev), name)) {
struct netdev *old_netdev = port->netdev;
- int dev_mtu;
/* 'name' hasn't changed location. Any properties changed? */
- if (!ofport_equal(&port->opp, &opp)) {
- ofport_modified(port, &opp);
+ if (!ofport_equal(&port->pp, &pp)) {
+ ofport_modified(port, &pp);
}
- /* If this is a non-internal port and the MTU changed, check
- * if the datapath's MTU needs to be updated. */
- if (strcmp(netdev_get_type(netdev), "internal")
- && !netdev_get_mtu(netdev, &dev_mtu)
- && port->mtu != dev_mtu) {
- set_internal_devs_mtu(ofproto);
- port->mtu = dev_mtu;
- }
+ update_mtu(ofproto, port);
/* Install the newly opened netdev in case it has changed.
* Don't close the old netdev yet in case port_modified has to
ofport_remove(port);
}
ofport_remove_with_name(ofproto, name);
- ofport_install(ofproto, netdev, &opp);
+ ofport_install(ofproto, netdev, &pp);
}
} else {
/* Any port named 'name' is gone now. */
VLOG_WARN_RL(&rl, "ignoring duplicate device %s in datapath",
ofproto_port.name);
} else {
- struct ofp_phy_port opp;
+ struct ofputil_phy_port pp;
struct netdev *netdev;
- netdev = ofport_open(&ofproto_port, &opp);
+ netdev = ofport_open(&ofproto_port, &pp);
if (netdev) {
- ofport_install(p, netdev, &opp);
+ ofport_install(p, netdev, &pp);
}
}
}
return mtu ? mtu: ETH_PAYLOAD_MAX;
}
-/* Set the MTU of all datapath devices on 'p' to the minimum of the
- * non-datapath ports. */
+/* Update MTU of all datapath devices on 'p' to the minimum of the
+ * non-datapath ports in event of 'port' added or changed. */
static void
-set_internal_devs_mtu(struct ofproto *p)
+update_mtu(struct ofproto *p, struct ofport *port)
{
struct ofport *ofport;
- int mtu = find_min_mtu(p);
+ struct netdev *netdev = port->netdev;
+ int dev_mtu, old_min;
+
+ if (netdev_get_mtu(netdev, &dev_mtu)) {
+ port->mtu = 0;
+ return;
+ }
+ if (!strcmp(netdev_get_type(port->netdev), "internal")) {
+ if (dev_mtu > p->min_mtu) {
+ if (!netdev_set_mtu(port->netdev, p->min_mtu)) {
+ dev_mtu = p->min_mtu;
+ }
+ }
+ port->mtu = dev_mtu;
+ return;
+ }
+
+ /* For non-internal port find new min mtu. */
+ old_min = p->min_mtu;
+ port->mtu = dev_mtu;
+ p->min_mtu = find_min_mtu(p);
+ if (p->min_mtu == old_min) {
+ return;
+ }
HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
struct netdev *netdev = ofport->netdev;
if (!strcmp(netdev_get_type(netdev), "internal")) {
- netdev_set_mtu(netdev, mtu);
+ if (!netdev_set_mtu(netdev, p->min_mtu)) {
+ ofport->mtu = p->min_mtu;
+ }
}
}
}
handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
- struct ofp_switch_features *osf;
- struct ofpbuf *buf;
+ struct ofputil_switch_features features;
struct ofport *port;
bool arp_match_ip;
- uint32_t actions;
+ struct ofpbuf *b;
- ofproto->ofproto_class->get_features(ofproto, &arp_match_ip, &actions);
- assert(actions & (1 << OFPAT_OUTPUT)); /* sanity check */
+ ofproto->ofproto_class->get_features(ofproto, &arp_match_ip,
+ &features.actions);
+ assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */
- osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, oh->xid, &buf);
- osf->datapath_id = htonll(ofproto->datapath_id);
- osf->n_buffers = htonl(pktbuf_capacity());
- osf->n_tables = ofproto->n_tables;
- osf->capabilities = htonl(OFPC_FLOW_STATS | OFPC_TABLE_STATS |
- OFPC_PORT_STATS | OFPC_QUEUE_STATS);
+ features.datapath_id = ofproto->datapath_id;
+ features.n_buffers = pktbuf_capacity();
+ features.n_tables = ofproto->n_tables;
+ features.capabilities = (OFPUTIL_C_FLOW_STATS | OFPUTIL_C_TABLE_STATS |
+ OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS);
if (arp_match_ip) {
- osf->capabilities |= htonl(OFPC_ARP_MATCH_IP);
+ features.capabilities |= OFPUTIL_C_ARP_MATCH_IP;
}
- osf->actions = htonl(actions);
+ b = ofputil_encode_switch_features(&features, ofconn_get_protocol(ofconn),
+ oh->xid);
HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
- ofpbuf_put(buf, &port->opp, sizeof port->opp);
+ ofputil_put_switch_features_port(&port->pp, b);
}
- ofconn_send_reply(ofconn, buf);
+ ofconn_send_reply(ofconn, b);
return 0;
}
}
}
ofconn_set_invalid_ttl_to_controller(ofconn,
- (flags & OFPC_INVALID_TTL_TO_CONTROLLER));
+ (flags & OFPC_INVALID_TTL_TO_CONTROLLER));
ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len));
}
static void
-update_port_config(struct ofport *port, ovs_be32 config, ovs_be32 mask)
+update_port_config(struct ofport *port,
+ enum ofputil_port_config config,
+ enum ofputil_port_config mask)
{
- ovs_be32 old_config = port->opp.config;
+ enum ofputil_port_config old_config = port->pp.config;
+ enum ofputil_port_config toggle;
- mask &= config ^ port->opp.config;
- if (mask & htonl(OFPPC_PORT_DOWN)) {
- if (config & htonl(OFPPC_PORT_DOWN)) {
+ toggle = (config ^ port->pp.config) & mask;
+ if (toggle & OFPUTIL_PC_PORT_DOWN) {
+ if (config & OFPUTIL_PC_PORT_DOWN) {
netdev_turn_flags_off(port->netdev, NETDEV_UP, true);
} else {
netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
}
+ toggle &= ~OFPUTIL_PC_PORT_DOWN;
}
- port->opp.config ^= mask & (htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP |
- OFPPC_NO_FLOOD | OFPPC_NO_FWD |
- OFPPC_NO_PACKET_IN));
- if (port->opp.config != old_config) {
+ port->pp.config ^= toggle;
+ if (port->pp.config != old_config) {
port->ofproto->ofproto_class->port_reconfigured(port, old_config);
}
}
handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh)
{
struct ofproto *p = ofconn_get_ofproto(ofconn);
- const struct ofp_port_mod *opm = (const struct ofp_port_mod *) oh;
+ struct ofputil_port_mod pm;
struct ofport *port;
- int error;
+ enum ofperr error;
error = reject_slave_controller(ofconn);
if (error) {
return error;
}
- port = ofproto_get_port(p, ntohs(opm->port_no));
+ error = ofputil_decode_port_mod(oh, &pm);
+ if (error) {
+ return error;
+ }
+
+ port = ofproto_get_port(p, pm.port_no);
if (!port) {
return OFPERR_OFPPMFC_BAD_PORT;
- } else if (memcmp(port->opp.hw_addr, opm->hw_addr, OFP_ETH_ALEN)) {
+ } else if (!eth_addr_equals(port->pp.hw_addr, pm.hw_addr)) {
return OFPERR_OFPPMFC_BAD_HW_ADDR;
} else {
- update_port_config(port, opm->config, opm->mask);
- if (opm->advertise) {
- netdev_set_advertisements(port->netdev, ntohl(opm->advertise));
+ update_port_config(port, pm.config, pm.mask);
+ if (pm.advertise) {
+ netdev_set_advertisements(port->netdev, pm.advertise);
}
}
return 0;
ofproto_port_get_stats(port, &stats);
ops = ofputil_append_stats_reply(sizeof *ops, replies);
- ops->port_no = port->opp.port_no;
+ ops->port_no = htons(port->pp.port_no);
memset(ops->pad, 0, sizeof ops->pad);
put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
return 0;
}
+static enum ofperr
+handle_port_desc_stats_request(struct ofconn *ofconn,
+ const struct ofp_stats_msg *osm)
+{
+ struct ofproto *p = ofconn_get_ofproto(ofconn);
+ struct ofport *port;
+ struct list replies;
+
+ ofputil_start_stats_reply(osm, &replies);
+
+ HMAP_FOR_EACH (port, hmap_node, &p->ports) {
+ ofputil_append_port_desc_stats_reply(ofconn_get_protocol(ofconn),
+ &port->pp, &replies);
+ }
+
+ ofconn_send_replies(ofconn, &replies);
+ return 0;
+}
+
static void
calc_flow_duration__(long long int start, long long int now,
uint32_t *sec, uint32_t *nsec)
: -1);
}
+/* Checks the health of the CFM for 'ofp_port' within 'ofproto'. Returns an
+ * integer value between 0 and 100 to indicate the health of the port as a
+ * percentage which is the average of cfm health of all the remote_mpids or
+ * returns -1 if CFM is not enabled on 'ofport'. */
+int
+ofproto_port_get_cfm_health(const struct ofproto *ofproto, uint16_t ofp_port)
+{
+ struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
+ return (ofport && ofproto->ofproto_class->get_cfm_health
+ ? ofproto->ofproto_class->get_cfm_health(ofport)
+ : -1);
+}
+
static enum ofperr
handle_aggregate_stats_request(struct ofconn *ofconn,
const struct ofp_stats_msg *osm)
struct ofp_queue_stats *reply;
reply = ofputil_append_stats_reply(sizeof *reply, &cbdata->replies);
- reply->port_no = cbdata->ofport->opp.port_no;
+ reply->port_no = htons(cbdata->ofport->pp.port_no);
memset(reply->pad, 0, sizeof reply->pad);
reply->queue_id = htonl(queue_id);
put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
rule->ofproto = ofproto;
rule->cr = fm->cr;
rule->pending = NULL;
- rule->flow_cookie = fm->cookie;
+ rule->flow_cookie = fm->new_cookie;
rule->created = rule->modified = rule->used = time_msec();
rule->idle_timeout = fm->idle_timeout;
rule->hard_timeout = fm->hard_timeout;
} else {
rule->modified = time_msec();
}
- rule->flow_cookie = fm->cookie;
+ if (fm->new_cookie != htonll(UINT64_MAX)) {
+ rule->flow_cookie = fm->new_cookie;
+ }
}
ofopgroup_submit(group);
error = collect_rules_loose(ofproto, fm->table_id, &fm->cr,
fm->cookie, fm->cookie_mask,
OFPP_NONE, &rules);
- return (error ? error
- : list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
- : modify_flows__(ofproto, ofconn, fm, request, &rules));
+ if (error) {
+ return error;
+ } else if (list_is_empty(&rules)) {
+ return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request);
+ } else {
+ return modify_flows__(ofproto, ofconn, fm, request, &rules);
+ }
}
/* Implements OFPFC_MODIFY_STRICT. Returns 0 on success or an OpenFlow error
error = collect_rules_strict(ofproto, fm->table_id, &fm->cr,
fm->cookie, fm->cookie_mask,
OFPP_NONE, &rules);
- return (error ? error
- : list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
- : list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
- fm, request, &rules)
- : 0);
+
+ if (error) {
+ return error;
+ } else if (list_is_empty(&rules)) {
+ return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request);
+ } else {
+ return list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
+ fm, request, &rules)
+ : 0;
+ }
}
\f
/* OFPFC_DELETE implementation. */
return error;
}
- error = ofputil_decode_flow_mod(&fm, oh,
- ofconn_get_flow_mod_table_id(ofconn));
+ error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_protocol(ofconn));
if (error) {
return error;
}
role = ntohl(nrr->role);
if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER
&& role != NX_ROLE_SLAVE) {
- return OFPERR_NXBRC_BAD_ROLE;
+ return OFPERR_OFPRRFC_BAD_ROLE;
}
if (ofconn_get_role(ofconn) != role
{
const struct nx_flow_mod_table_id *msg
= (const struct nx_flow_mod_table_id *) oh;
+ enum ofputil_protocol cur, next;
+
+ cur = ofconn_get_protocol(ofconn);
+ next = ofputil_protocol_set_tid(cur, msg->set != 0);
+ ofconn_set_protocol(ofconn, next);
- ofconn_set_flow_mod_table_id(ofconn, msg->set != 0);
return 0;
}
{
const struct nx_set_flow_format *msg
= (const struct nx_set_flow_format *) oh;
- uint32_t format;
+ enum ofputil_protocol cur, next;
+ enum ofputil_protocol next_base;
- format = ntohl(msg->format);
- if (format != NXFF_OPENFLOW10 && format != NXFF_NXM) {
+ next_base = ofputil_nx_flow_format_to_protocol(ntohl(msg->format));
+ if (!next_base) {
return OFPERR_OFPBRC_EPERM;
}
- if (format != ofconn_get_flow_format(ofconn)
- && ofconn_has_pending_opgroups(ofconn)) {
- /* Avoid sending async messages in surprising flow format. */
+ cur = ofconn_get_protocol(ofconn);
+ next = ofputil_protocol_set_base(cur, next_base);
+ if (cur != next && ofconn_has_pending_opgroups(ofconn)) {
+ /* Avoid sending async messages in surprising protocol. */
return OFPROTO_POSTPONE;
}
- ofconn_set_flow_format(ofconn, format);
+ ofconn_set_protocol(ofconn, next);
return 0;
}
static enum ofperr
handle_barrier_request(struct ofconn *ofconn, const struct ofp_header *oh)
{
- struct ofp_header *ob;
struct ofpbuf *buf;
if (ofconn_has_pending_opgroups(ofconn)) {
return OFPROTO_POSTPONE;
}
- ob = make_openflow_xid(sizeof *ob, OFPT_BARRIER_REPLY, oh->xid, &buf);
+ make_openflow_xid(sizeof *oh, OFPT10_BARRIER_REPLY, oh->xid, &buf);
ofconn_send_reply(ofconn, buf);
return 0;
}
case OFPUTIL_OFPST_QUEUE_REQUEST:
return handle_queue_stats_request(ofconn, msg->data);
+ case OFPUTIL_OFPST_PORT_DESC_REQUEST:
+ return handle_port_desc_stats_request(ofconn, msg->data);
+
case OFPUTIL_MSG_INVALID:
case OFPUTIL_OFPT_HELLO:
case OFPUTIL_OFPT_ERROR:
case OFPUTIL_OFPST_PORT_REPLY:
case OFPUTIL_OFPST_TABLE_REPLY:
case OFPUTIL_OFPST_AGGREGATE_REPLY:
+ case OFPUTIL_OFPST_PORT_DESC_REPLY:
case OFPUTIL_NXT_ROLE_REPLY:
case OFPUTIL_NXT_FLOW_REMOVED:
case OFPUTIL_NXT_PACKET_IN:
case OFPUTIL_NXST_FLOW_REPLY:
case OFPUTIL_NXST_AGGREGATE_REPLY:
default:
- if (oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY) {
- return OFPERR_OFPBRC_BAD_STAT;
- } else {
- return OFPERR_OFPBRC_BAD_TYPE;
- }
+ return (oh->type == OFPT10_STATS_REQUEST ||
+ oh->type == OFPT10_STATS_REPLY
+ ? OFPERR_OFPBRC_BAD_STAT
+ : OFPERR_OFPBRC_BAD_TYPE);
}
}
{
memset(table, 0, sizeof *table);
classifier_init(&table->cls);
+ table->max_flows = UINT_MAX;
}
/* Destroys 'table', including its classifier and eviction groups.
HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
ds_put_format(&results, "%s\n", ofproto->name);
}
- unixctl_command_reply(conn, 200, ds_cstr(&results));
+ unixctl_command_reply(conn, ds_cstr(&results));
ds_destroy(&results);
}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff