OFPT10_QUEUE_GET_CONFIG_REPLY /* Controller/switch message */
};
-/* Header on all OpenFlow packets. */
-struct ofp_header {
- uint8_t version; /* An OpenFlow version number, e.g. OFP10_VERSION. */
- uint8_t type; /* One of the OFPT_ constants. */
- ovs_be16 length; /* Length including this ofp_header. */
- ovs_be32 xid; /* Transaction id associated with this packet.
- Replies use the same id as was in the request
- to facilitate pairing. */
-};
-OFP_ASSERT(sizeof(struct ofp_header) == 8);
-
/* OFPT_HELLO. This message has an empty body, but implementations must
* ignore any data included in the body, to allow for future extensions. */
struct ofp_hello {
};
OFP_ASSERT(sizeof(struct ofp_switch_config) == 12);
-/* Capabilities supported by the datapath. */
-enum ofp_capabilities {
- OFPC_FLOW_STATS = 1 << 0, /* Flow statistics. */
- OFPC_TABLE_STATS = 1 << 1, /* Table statistics. */
- OFPC_PORT_STATS = 1 << 2, /* Port statistics. */
- OFPC_STP = 1 << 3, /* 802.1d spanning tree. */
- OFPC_RESERVED = 1 << 4, /* Reserved, must not be set. */
- OFPC_IP_REASM = 1 << 5, /* Can reassemble IP fragments. */
- OFPC_QUEUE_STATS = 1 << 6, /* Queue statistics. */
- OFPC_ARP_MATCH_IP = 1 << 7 /* Match IP addresses in ARP
- pkts. */
-};
-
-/* Flags to indicate behavior of the physical port. These flags are
- * used in ofp_phy_port to describe the current configuration. They are
- * used in the ofp_port_mod message to configure the port's behavior.
- */
-enum ofp_port_config {
- OFPPC_PORT_DOWN = 1 << 0, /* Port is administratively down. */
-
- OFPPC_NO_STP = 1 << 1, /* Disable 802.1D spanning tree on port. */
- OFPPC_NO_RECV = 1 << 2, /* Drop all packets except 802.1D
- spanning tree packets. */
- OFPPC_NO_RECV_STP = 1 << 3, /* Drop received 802.1D STP packets. */
- OFPPC_NO_FLOOD = 1 << 4, /* Do not include this port when flooding. */
- OFPPC_NO_FWD = 1 << 5, /* Drop packets forwarded to port. */
- OFPPC_NO_PACKET_IN = 1 << 6 /* Do not send packet-in msgs for port. */
+/* OpenFlow 1.0 specific capabilities supported by the datapath (struct
+ * ofp_switch_features, member capabilities). */
+enum ofp10_capabilities {
+ OFPC10_STP = 1 << 3, /* 802.1d spanning tree. */
+ OFPC10_RESERVED = 1 << 4, /* Reserved, must not be set. */
};
-/* Current state of the physical port. These are not configurable from
- * the controller.
+/* OpenFlow 1.0 specific flags to indicate behavior of the physical port.
+ * These flags are used in ofp10_phy_port to describe the current
+ * configuration. They are used in the ofp10_port_mod message to configure the
+ * port's behavior.
*/
-enum ofp_port_state {
- OFPPS_LINK_DOWN = 1 << 0, /* No physical link present. */
+enum ofp10_port_config {
+ OFPPC10_NO_STP = 1 << 1, /* Disable 802.1D spanning tree on port. */
+ OFPPC10_NO_RECV_STP = 1 << 3, /* Drop received 802.1D STP packets. */
+ OFPPC10_NO_FLOOD = 1 << 4, /* Do not include port when flooding. */
+#define OFPPC10_ALL (OFPPC_PORT_DOWN | OFPPC10_NO_STP | OFPPC_NO_RECV | \
+ OFPPC10_NO_RECV_STP | OFPPC10_NO_FLOOD | OFPPC_NO_FWD | \
+ OFPPC_NO_PACKET_IN)
+};
- /* The OFPPS_STP_* bits have no effect on switch operation. The
+/* OpenFlow 1.0 specific current state of the physical port. These are not
+ * configurable from the controller.
+ */
+enum ofp10_port_state {
+ /* The OFPPS10_STP_* bits have no effect on switch operation. The
* controller must adjust OFPPC_NO_RECV, OFPPC_NO_FWD, and
* OFPPC_NO_PACKET_IN appropriately to fully implement an 802.1D spanning
* tree. */
- OFPPS_STP_LISTEN = 0 << 8, /* Not learning or relaying frames. */
- OFPPS_STP_LEARN = 1 << 8, /* Learning but not relaying frames. */
- OFPPS_STP_FORWARD = 2 << 8, /* Learning and relaying frames. */
- OFPPS_STP_BLOCK = 3 << 8, /* Not part of spanning tree. */
- OFPPS_STP_MASK = 3 << 8 /* Bit mask for OFPPS_STP_* values. */
-};
-
-/* Features of physical ports available in a datapath. */
-enum ofp_port_features {
- OFPPF_10MB_HD = 1 << 0, /* 10 Mb half-duplex rate support. */
- OFPPF_10MB_FD = 1 << 1, /* 10 Mb full-duplex rate support. */
- OFPPF_100MB_HD = 1 << 2, /* 100 Mb half-duplex rate support. */
- OFPPF_100MB_FD = 1 << 3, /* 100 Mb full-duplex rate support. */
- OFPPF_1GB_HD = 1 << 4, /* 1 Gb half-duplex rate support. */
- OFPPF_1GB_FD = 1 << 5, /* 1 Gb full-duplex rate support. */
- OFPPF_10GB_FD = 1 << 6, /* 10 Gb full-duplex rate support. */
- OFPPF_COPPER = 1 << 7, /* Copper medium. */
- OFPPF_FIBER = 1 << 8, /* Fiber medium. */
- OFPPF_AUTONEG = 1 << 9, /* Auto-negotiation. */
- OFPPF_PAUSE = 1 << 10, /* Pause. */
- OFPPF_PAUSE_ASYM = 1 << 11 /* Asymmetric pause. */
+ OFPPS10_STP_LISTEN = 0 << 8, /* Not learning or relaying frames. */
+ OFPPS10_STP_LEARN = 1 << 8, /* Learning but not relaying frames. */
+ OFPPS10_STP_FORWARD = 2 << 8, /* Learning and relaying frames. */
+ OFPPS10_STP_BLOCK = 3 << 8, /* Not part of spanning tree. */
+ OFPPS10_STP_MASK = 3 << 8 /* Bit mask for OFPPS10_STP_* values. */
+
+#define OFPPS10_ALL (OFPPS_LINK_DOWN | OFPPS10_STP_MASK)
+};
+
+/* OpenFlow 1.0 specific features of physical ports available in a datapath. */
+enum ofp10_port_features {
+ OFPPF10_COPPER = 1 << 7, /* Copper medium. */
+ OFPPF10_FIBER = 1 << 8, /* Fiber medium. */
+ OFPPF10_AUTONEG = 1 << 9, /* Auto-negotiation. */
+ OFPPF10_PAUSE = 1 << 10, /* Pause. */
+ OFPPF10_PAUSE_ASYM = 1 << 11 /* Asymmetric pause. */
};
/* Description of a physical port */
-struct ofp_phy_port {
+struct ofp10_phy_port {
ovs_be16 port_no;
uint8_t hw_addr[OFP_ETH_ALEN];
char name[OFP_MAX_PORT_NAME_LEN]; /* Null-terminated */
- ovs_be32 config; /* Bitmap of OFPPC_* flags. */
- ovs_be32 state; /* Bitmap of OFPPS_* flags. */
+ ovs_be32 config; /* Bitmap of OFPPC_* and OFPPC10_* flags. */
+ ovs_be32 state; /* Bitmap of OFPPS_* and OFPPS10_* flags. */
- /* Bitmaps of OFPPF_* that describe features. All bits zeroed if
- * unsupported or unavailable. */
+ /* Bitmaps of OFPPF_* and OFPPF10_* that describe features. All bits
+ * zeroed if unsupported or unavailable. */
ovs_be32 curr; /* Current features. */
ovs_be32 advertised; /* Features being advertised by the port. */
ovs_be32 supported; /* Features supported by the port. */
ovs_be32 peer; /* Features advertised by peer. */
};
-OFP_ASSERT(sizeof(struct ofp_phy_port) == 48);
-
-/* Switch features. */
-struct ofp_switch_features {
- struct ofp_header header;
- ovs_be64 datapath_id; /* Datapath unique ID. The lower 48-bits are for
- a MAC address, while the upper 16-bits are
- implementer-defined. */
-
- ovs_be32 n_buffers; /* Max packets buffered at once. */
-
- uint8_t n_tables; /* Number of tables supported by datapath. */
- uint8_t pad[3]; /* Align to 64-bits. */
-
- /* Features. */
- ovs_be32 capabilities; /* Bitmap of support "ofp_capabilities". */
- ovs_be32 actions; /* Bitmap of supported "ofp_action_type"s. */
-
- /* Port info.*/
- struct ofp_phy_port ports[0]; /* Port definitions. The number of ports
- is inferred from the length field in
- the header. */
-};
-OFP_ASSERT(sizeof(struct ofp_switch_features) == 32);
-
-/* What changed about the physical port */
-enum ofp_port_reason {
- OFPPR_ADD, /* The port was added. */
- OFPPR_DELETE, /* The port was removed. */
- OFPPR_MODIFY /* Some attribute of the port has changed. */
-};
-
-/* A physical port has changed in the datapath */
-struct ofp_port_status {
- struct ofp_header header;
- uint8_t reason; /* One of OFPPR_*. */
- uint8_t pad[7]; /* Align to 64-bits. */
- struct ofp_phy_port desc;
-};
-OFP_ASSERT(sizeof(struct ofp_port_status) == 64);
+OFP_ASSERT(sizeof(struct ofp10_phy_port) == 48);
/* Modify behavior of the physical port */
-struct ofp_port_mod {
+struct ofp10_port_mod {
struct ofp_header header;
ovs_be16 port_no;
uint8_t hw_addr[OFP_ETH_ALEN]; /* The hardware address is not
configurable. This is used to
sanity-check the request, so it must
be the same as returned in an
- ofp_phy_port struct. */
+ ofp10_phy_port struct. */
ovs_be32 config; /* Bitmap of OFPPC_* flags. */
ovs_be32 mask; /* Bitmap of OFPPC_* flags to be changed. */
bits to prevent any action taking place. */
uint8_t pad[4]; /* Pad to 64-bits. */
};
-OFP_ASSERT(sizeof(struct ofp_port_mod) == 32);
+OFP_ASSERT(sizeof(struct ofp10_port_mod) == 32);
/* Why is this packet being sent to the controller? */
enum ofp_packet_in_reason {
OFPT11_QUEUE_GET_CONFIG_REPLY, /* Controller/switch message */
};
+/* OpenFlow 1.1 port config flags are just the common flags. */
+#define OFPPC11_ALL \
+ (OFPPC_PORT_DOWN | OFPPC_NO_RECV | OFPPC_NO_FWD | OFPPC_NO_PACKET_IN)
+
+/* OpenFlow 1.1 specific current state of the physical port. These are not
+ * configurable from the controller.
+ */
+enum ofp11_port_state {
+ OFPPS11_BLOCKED = 1 << 1, /* Port is blocked */
+ OFPPS11_LIVE = 1 << 2, /* Live for Fast Failover Group. */
+#define OFPPS11_ALL (OFPPS_LINK_DOWN | OFPPS11_BLOCKED | OFPPS11_LIVE)
+};
+
+/* OpenFlow 1.1 specific features of ports available in a datapath. */
+enum ofp11_port_features {
+ OFPPF11_40GB_FD = 1 << 7, /* 40 Gb full-duplex rate support. */
+ OFPPF11_100GB_FD = 1 << 8, /* 100 Gb full-duplex rate support. */
+ OFPPF11_1TB_FD = 1 << 9, /* 1 Tb full-duplex rate support. */
+ OFPPF11_OTHER = 1 << 10, /* Other rate, not in the list. */
+
+ OFPPF11_COPPER = 1 << 11, /* Copper medium. */
+ OFPPF11_FIBER = 1 << 12, /* Fiber medium. */
+ OFPPF11_AUTONEG = 1 << 13, /* Auto-negotiation. */
+ OFPPF11_PAUSE = 1 << 14, /* Pause. */
+ OFPPF11_PAUSE_ASYM = 1 << 15 /* Asymmetric pause. */
+#define OFPPF11_ALL ((1 << 16) - 1)
+};
+
+/* Description of a port */
+struct ofp11_port {
+ ovs_be32 port_no;
+ uint8_t pad[4];
+ uint8_t hw_addr[OFP_ETH_ALEN];
+ uint8_t pad2[2]; /* Align to 64 bits. */
+ char name[OFP_MAX_PORT_NAME_LEN]; /* Null-terminated */
+
+ ovs_be32 config; /* Bitmap of OFPPC_* flags. */
+ ovs_be32 state; /* Bitmap of OFPPS_* and OFPPS11_* flags. */
+
+ /* Bitmaps of OFPPF_* and OFPPF11_* that describe features. All bits
+ * zeroed if unsupported or unavailable. */
+ ovs_be32 curr; /* Current features. */
+ ovs_be32 advertised; /* Features being advertised by the port. */
+ ovs_be32 supported; /* Features supported by the port. */
+ ovs_be32 peer; /* Features advertised by peer. */
+
+ ovs_be32 curr_speed; /* Current port bitrate in kbps. */
+ ovs_be32 max_speed; /* Max port bitrate in kbps */
+};
+
+/* Modify behavior of the physical port */
+struct ofp11_port_mod {
+ struct ofp_header header;
+ ovs_be32 port_no;
+ uint8_t pad[4];
+ uint8_t hw_addr[OFP_ETH_ALEN]; /* The hardware address is not
+ configurable. This is used to
+ sanity-check the request, so it must
+ be the same as returned in an
+ ofp11_port struct. */
+ uint8_t pad2[2]; /* Pad to 64 bits. */
+ ovs_be32 config; /* Bitmap of OFPPC_* flags. */
+ ovs_be32 mask; /* Bitmap of OFPPC_* flags to be changed. */
+
+ ovs_be32 advertise; /* Bitmap of OFPPF_* and OFPPF11_*. Zero all bits
+ to prevent any action taking place. */
+ uint8_t pad3[4]; /* Pad to 64 bits. */
+};
+OFP_ASSERT(sizeof(struct ofp11_port_mod) == 40);
+
+/* OpenFlow 1.1 specific capabilities supported by the datapath (struct
+ * ofp_switch_features, member capabilities). */
+enum ofp11_capabilities {
+ OFPC11_GROUP_STATS = 1 << 3, /* Group statistics. */
+};
+
enum ofp11_action_type {
OFPAT11_OUTPUT, /* Output to switch port. */
OFPAT11_SET_VLAN_VID, /* Set the 802.1q VLAN id. */
OFPT_PORT_STATUS, /* Async message */
};
+/* Header on all OpenFlow packets. */
+struct ofp_header {
+ uint8_t version; /* An OpenFlow version number, e.g. OFP10_VERSION. */
+ uint8_t type; /* One of the OFPT_ constants. */
+ ovs_be16 length; /* Length including this ofp_header. */
+ ovs_be32 xid; /* Transaction id associated with this packet.
+ Replies use the same id as was in the request
+ to facilitate pairing. */
+};
+OFP_ASSERT(sizeof(struct ofp_header) == 8);
+
+/* Common flags to indicate behavior of the physical port. These flags are
+ * used in ofp_port to describe the current configuration. They are used in
+ * the ofp_port_mod message to configure the port's behavior.
+ */
+enum ofp_port_config {
+ OFPPC_PORT_DOWN = 1 << 0, /* Port is administratively down. */
+
+ OFPPC_NO_RECV = 1 << 2, /* Drop all packets received by port. */
+ OFPPC_NO_FWD = 1 << 5, /* Drop packets forwarded to port. */
+ OFPPC_NO_PACKET_IN = 1 << 6 /* Do not send packet-in msgs for port. */
+};
+
+/* Common current state of the physical port. These are not configurable from
+ * the controller.
+ */
+enum ofp_port_state {
+ OFPPS_LINK_DOWN = 1 << 0, /* No physical link present. */
+};
+
+/* Common features of physical ports available in a datapath. */
+enum ofp_port_features {
+ OFPPF_10MB_HD = 1 << 0, /* 10 Mb half-duplex rate support. */
+ OFPPF_10MB_FD = 1 << 1, /* 10 Mb full-duplex rate support. */
+ OFPPF_100MB_HD = 1 << 2, /* 100 Mb half-duplex rate support. */
+ OFPPF_100MB_FD = 1 << 3, /* 100 Mb full-duplex rate support. */
+ OFPPF_1GB_HD = 1 << 4, /* 1 Gb half-duplex rate support. */
+ OFPPF_1GB_FD = 1 << 5, /* 1 Gb full-duplex rate support. */
+ OFPPF_10GB_FD = 1 << 6, /* 10 Gb full-duplex rate support. */
+};
+
+/* Switch features. */
+struct ofp_switch_features {
+ struct ofp_header header;
+ ovs_be64 datapath_id; /* Datapath unique ID. The lower 48-bits are for
+ a MAC address, while the upper 16-bits are
+ implementer-defined. */
+
+ ovs_be32 n_buffers; /* Max packets buffered at once. */
+
+ uint8_t n_tables; /* Number of tables supported by datapath. */
+ uint8_t pad[3]; /* Align to 64-bits. */
+
+ /* Features. */
+ ovs_be32 capabilities; /* OFPC_*, OFPC10_*, OFPC11_*. */
+ ovs_be32 actions; /* Bitmap of supported "ofp_action_type"s. */
+
+ /* Followed by an array of struct ofp10_phy_port or struct ofp11_port
+ * structures. The number is inferred from header.length. */
+};
+OFP_ASSERT(sizeof(struct ofp_switch_features) == 32);
+
+/* Common capabilities supported by the datapath (struct ofp_switch_features,
+ * member capabilities). */
+enum ofp_capabilities {
+ OFPC_FLOW_STATS = 1 << 0, /* Flow statistics. */
+ OFPC_TABLE_STATS = 1 << 1, /* Table statistics. */
+ OFPC_PORT_STATS = 1 << 2, /* Port statistics. */
+ OFPC_IP_REASM = 1 << 5, /* Can reassemble IP fragments. */
+ OFPC_QUEUE_STATS = 1 << 6, /* Queue statistics. */
+ OFPC_ARP_MATCH_IP = 1 << 7 /* Match IP addresses in ARP
+ pkts. */
+};
+
+/* What changed about the physical port */
+enum ofp_port_reason {
+ OFPPR_ADD, /* The port was added. */
+ OFPPR_DELETE, /* The port was removed. */
+ OFPPR_MODIFY /* Some attribute of the port has changed. */
+};
+
+/* A physical port has changed in the datapath */
+struct ofp_port_status {
+ struct ofp_header header;
+ uint8_t reason; /* One of OFPPR_*. */
+ uint8_t pad[7]; /* Align to 64-bits. */
+ /* Followed by struct ofp10_phy_port or struct ofp11_port. */
+};
+OFP_ASSERT(sizeof(struct ofp_port_status) == 16);
+
#endif /* openflow/openflow-common.h */
static void queue_tx(struct lswitch *, struct rconn *, struct ofpbuf *);
static void send_features_request(struct lswitch *, struct rconn *);
-static void process_switch_features(struct lswitch *,
- struct ofp_switch_features *);
+static enum ofperr process_switch_features(struct lswitch *,
+ struct ofp_switch_features *);
static void process_packet_in(struct lswitch *, struct rconn *,
const struct ofp_packet_in *);
static void process_echo_request(struct lswitch *, struct rconn *,
}
}
-static void
+static enum ofperr
process_switch_features(struct lswitch *sw, struct ofp_switch_features *osf)
{
- size_t n_ports;
- size_t i;
-
- sw->datapath_id = ntohll(osf->datapath_id);
+ struct ofputil_switch_features features;
+ struct ofputil_phy_port port;
+ enum ofperr error;
+ struct ofpbuf b;
+
+ error = ofputil_decode_switch_features(osf, &features, &b);
+ if (error) {
+ VLOG_ERR("received invalid switch feature reply (%s)",
+ ofperr_to_string(error));
+ return error;
+ }
- n_ports = (ntohs(osf->header.length) - sizeof *osf) / sizeof *osf->ports;
- for (i = 0; i < n_ports; i++) {
- struct ofp_phy_port *opp = &osf->ports[i];
- struct lswitch_port *lp;
+ sw->datapath_id = features.datapath_id;
- opp->name[OFP_MAX_PORT_NAME_LEN - 1] = '\0';
- lp = shash_find_data(&sw->queue_names, opp->name);
+ while (!ofputil_pull_switch_features_port(&b, &port)) {
+ struct lswitch_port *lp = shash_find_data(&sw->queue_names, port.name);
if (lp && hmap_node_is_null(&lp->hmap_node)) {
- lp->port_no = ntohs(opp->port_no);
+ lp->port_no = port.port_no;
hmap_insert(&sw->queue_numbers, &lp->hmap_node,
hash_int(lp->port_no, 0));
}
}
+ return 0;
}
static uint16_t
/* NX(1,515). Must-be-zero field had nonzero value. */
OFPERR_NXBRC_MUST_BE_ZERO,
+ /* NX(1,516). The reason in an ofp_port_status message is not valid. */
+ OFPERR_NXBRC_BAD_REASON,
+
/* ## ---------------- ## */
/* ## OFPET_BAD_ACTION ## */
/* ## ---------------- ## */
#include "learn.h"
#include "multipath.h"
#include "meta-flow.h"
+#include "netdev.h"
#include "nx-match.h"
#include "ofp-errors.h"
#include "ofp-util.h"
static int
compare_ports(const void *a_, const void *b_)
{
- const struct ofp_phy_port *a = a_;
- const struct ofp_phy_port *b = b_;
- uint16_t ap = ntohs(a->port_no);
- uint16_t bp = ntohs(b->port_no);
+ 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;
return ap < bp ? -1 : ap > bp;
}
-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[])
+ const char *(*bit_to_name)(uint32_t bit))
{
int n = 0;
+ int i;
if (!bits) {
ds_put_cstr(string, "0");
return;
}
- for (; bits && bit_names->name; bit_names++) {
- if (bits & bit_names->bit) {
- if (n++) {
- ds_put_char(string, ' ');
+ for (i = 0; i < 32; i++) {
+ uint32_t bit = UINT32_C(1) << i;
+
+ if (bits & bit) {
+ const char *name = bit_to_name(bit);
+ if (name) {
+ if (n++) {
+ ds_put_char(string, ' ');
+ }
+ ds_put_cstr(string, name);
+ bits &= ~bit;
}
- ds_put_cstr(string, bit_names->name);
- bits &= ~bit_names->bit;
}
}
}
}
+static const char *
+netdev_feature_to_name(uint32_t bit)
+{
+ enum netdev_features f = bit;
+
+ switch (f) {
+ case NETDEV_F_10MB_HD: return "10MB-HD";
+ case NETDEV_F_10MB_FD: return "10MB-FD";
+ case NETDEV_F_100MB_HD: return "100MB-HD";
+ case NETDEV_F_100MB_FD: return "100MB-FD";
+ case NETDEV_F_1GB_HD: return "1GB-HD";
+ case NETDEV_F_1GB_FD: return "1GB-FD";
+ case NETDEV_F_10GB_FD: return "10GB-FD";
+ case NETDEV_F_40GB_FD: return "40GB-FD";
+ case NETDEV_F_100GB_FD: return "100GB-FD";
+ case NETDEV_F_1TB_FD: return "1TB-FD";
+ case NETDEV_F_OTHER: return "OTHER";
+ case NETDEV_F_COPPER: return "COPPER";
+ case NETDEV_F_FIBER: return "FIBER";
+ case NETDEV_F_AUTONEG: return "AUTO_NEG";
+ case NETDEV_F_PAUSE: return "AUTO_PAUSE";
+ case NETDEV_F_PAUSE_ASYM: return "AUTO_PAUSE_ASYM";
+ }
+
+ return NULL;
+}
+
static void
-ofp_print_port_features(struct ds *string, uint32_t features)
+ofp_print_port_features(struct ds *string, enum netdev_features 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);
+ ofp_print_bit_names(string, features, netdev_feature_to_name);
ds_put_char(string, '\n');
}
+static const char *
+ofputil_port_config_to_name(uint32_t bit)
+{
+ enum ofputil_port_config pc = bit;
+
+ switch (pc) {
+ case OFPUTIL_PC_PORT_DOWN: return "PORT_DOWN";
+ case OFPUTIL_PC_NO_STP: return "NO_STP";
+ case OFPUTIL_PC_NO_RECV: return "NO_RECV";
+ case OFPUTIL_PC_NO_RECV_STP: return "NO_RECV_STP";
+ case OFPUTIL_PC_NO_FLOOD: return "NO_FLOOD";
+ case OFPUTIL_PC_NO_FWD: return "NO_FWD";
+ case OFPUTIL_PC_NO_PACKET_IN: return "NO_PACKET_IN";
+ }
+
+ return NULL;
+}
+
static void
-ofp_print_port_config(struct ds *string, uint32_t config)
+ofp_print_port_config(struct ds *string, enum ofputil_port_config 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);
+ ofp_print_bit_names(string, config, ofputil_port_config_to_name);
ds_put_char(string, '\n');
}
+static const char *
+ofputil_port_state_to_name(uint32_t bit)
+{
+ enum ofputil_port_state ps = bit;
+
+ switch (ps) {
+ case OFPUTIL_PS_LINK_DOWN: return "LINK_DOWN";
+ case OFPUTIL_PS_BLOCKED: return "BLOCKED";
+ case OFPUTIL_PS_LIVE: return "LIVE";
+
+ case OFPUTIL_PS_STP_LISTEN:
+ case OFPUTIL_PS_STP_LEARN:
+ case OFPUTIL_PS_STP_FORWARD:
+ case OFPUTIL_PS_STP_BLOCK:
+ /* Handled elsewhere. */
+ return NULL;
+ }
+
+ return NULL;
+}
+
static void
-ofp_print_port_state(struct ds *string, uint32_t state)
+ofp_print_port_state(struct ds *string, enum ofputil_port_state state)
{
- static const struct bit_name state_bits[] = {
- { OFPPS_LINK_DOWN, "LINK_DOWN" },
- { 0, NULL },
- };
- uint32_t stp_state;
+ enum ofputil_port_state 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.
* 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;
+ stp_state = state & OFPUTIL_PS_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;
+ ds_put_cstr(string,
+ (stp_state == OFPUTIL_PS_STP_LEARN ? "STP_LEARN"
+ : stp_state == OFPUTIL_PS_STP_FORWARD ? "STP_FORWARD"
+ : "STP_BLOCK"));
+ state &= ~OFPUTIL_PS_STP_MASK;
if (state) {
- ofp_print_bit_names(string, state, state_bits);
+ ofp_print_bit_names(string, state, ofputil_port_state_to_name);
}
} else {
- ofp_print_bit_names(string, state, state_bits);
+ ofp_print_bit_names(string, state, ofputil_port_state_to_name);
}
ds_put_char(string, '\n');
}
static void
-ofp_print_phy_port(struct ds *string, const struct ofp_phy_port *port)
+ofp_print_phy_port(struct ds *string, const struct ofputil_phy_port *port)
{
- char name[OFP_MAX_PORT_NAME_LEN];
+ char name[sizeof port->name];
int j;
memcpy(name, port->name, sizeof name);
name[j] = '\0';
ds_put_char(string, ' ');
- ofputil_format_port(ntohs(port->port_no), string);
+ ofputil_format_port(port->port_no, string);
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));
+ ofp_print_port_config(string, port->config);
ds_put_cstr(string, " state: ");
- ofp_print_port_state(string, ntohl(port->state));
+ ofp_print_port_state(string, port->state);
if (port->curr) {
ds_put_format(string, " current: ");
- ofp_print_port_features(string, ntohl(port->curr));
+ ofp_print_port_features(string, port->curr);
}
if (port->advertised) {
ds_put_format(string, " advertised: ");
- ofp_print_port_features(string, ntohl(port->advertised));
+ ofp_print_port_features(string, port->advertised);
}
if (port->supported) {
ds_put_format(string, " supported: ");
- ofp_print_port_features(string, ntohl(port->supported));
+ ofp_print_port_features(string, port->supported);
}
if (port->peer) {
ds_put_format(string, " peer: ");
- ofp_print_port_features(string, ntohl(port->peer));
+ ofp_print_port_features(string, port->peer);
}
+ ds_put_format(string, " speed: %"PRIu32" Mbps now, "
+ "%"PRIu32" Mbps max\n",
+ port->curr_speed / UINT32_C(1000),
+ port->max_speed / UINT32_C(1000));
+}
+
+static const char *
+ofputil_capabilities_to_name(uint32_t bit)
+{
+ enum ofputil_capabilities capabilities = bit;
+
+ switch (capabilities) {
+ case OFPUTIL_C_FLOW_STATS: return "FLOW_STATS";
+ case OFPUTIL_C_TABLE_STATS: return "TABLE_STATS";
+ case OFPUTIL_C_PORT_STATS: return "PORT_STATS";
+ case OFPUTIL_C_IP_REASM: return "IP_REASM";
+ case OFPUTIL_C_QUEUE_STATS: return "QUEUE_STATS";
+ case OFPUTIL_C_ARP_MATCH_IP: return "ARP_MATCH_IP";
+ case OFPUTIL_C_STP: return "STP";
+ case OFPUTIL_C_GROUP_STATS: return "GROUP_STATS";
+ }
+
+ 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_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_switch_features *osf)
{
- size_t len = ntohs(osf->header.length);
- struct ofp_phy_port *port_list;
- int n_ports;
- int i;
+ struct ofputil_switch_features features;
+ struct ofputil_phy_port *ports;
+ enum ofperr error;
+ struct ofpbuf b;
+ size_t n_ports;
+ size_t i;
- ds_put_format(string, " ver:0x%x, dpid:%016"PRIx64"\n",
- osf->header.version, ntohll(osf->datapath_id));
- ds_put_format(string, "n_tables:%d, n_buffers:%d\n", osf->n_tables,
- ntohl(osf->n_buffers));
- ds_put_format(string, "features: capabilities:%#x, actions:%#x\n",
- ntohl(osf->capabilities), ntohl(osf->actions));
+ error = ofputil_decode_switch_features(osf, &features, &b);
+ if (error) {
+ ofp_print_error(string, error);
+ return;
+ }
- n_ports = (len - sizeof *osf) / sizeof *osf->ports;
+ ds_put_format(string, " dpid:%016"PRIx64"\n", features.datapath_id);
+ ds_put_format(string, "n_tables:%"PRIu8", n_buffers:%"PRIu32"\n",
+ features.n_tables, features.n_buffers);
- port_list = xmemdup(osf->ports, len - sizeof *osf);
- qsort(port_list, n_ports, sizeof *port_list, compare_ports);
+ ds_put_cstr(string, "capabilities: ");
+ ofp_print_bit_names(string, features.capabilities,
+ ofputil_capabilities_to_name);
+ ds_put_char(string, '\n');
+
+ ds_put_cstr(string, "actions: ");
+ ofp_print_bit_names(string, features.actions,
+ ofputil_action_bitmap_to_name);
+ ds_put_char(string, '\n');
+
+ n_ports = ofputil_count_phy_ports(osf);
+
+ ports = xmalloc(n_ports * sizeof *ports);
for (i = 0; i < n_ports; i++) {
- ofp_print_phy_port(string, &port_list[i]);
+ error = ofputil_pull_switch_features_port(&b, &ports[i]);
+ if (error) {
+ ofp_print_error(string, error);
+ return;
+ }
+ }
+ qsort(ports, n_ports, sizeof *ports, compare_ports);
+ for (i = 0; i < n_ports; i++) {
+ ofp_print_phy_port(string, &ports[i]);
}
- free(port_list);
+ free(ports);
}
static void
}
static void
-ofp_print_port_mod(struct ds *string, const struct ofp_port_mod *opm)
+ofp_print_port_mod(struct ds *string, const struct ofp_header *oh)
{
- ds_put_format(string, "port: %d: addr:"ETH_ADDR_FMT", config: %#x, mask:%#x\n",
- ntohs(opm->port_no), ETH_ADDR_ARGS(opm->hw_addr),
- ntohl(opm->config), ntohl(opm->mask));
+ struct ofputil_port_mod pm;
+ enum ofperr error;
+
+ error = ofputil_decode_port_mod(oh, &pm);
+ if (error) {
+ ofp_print_error(string, error);
+ return;
+ }
+
+ ds_put_format(string, "port: %"PRIu16": addr:"ETH_ADDR_FMT"\n",
+ pm.port_no, ETH_ADDR_ARGS(pm.hw_addr));
+
+ ds_put_format(string, " config: ");
+ ofp_print_port_config(string, pm.config);
+
+ ds_put_format(string, " mask: ");
+ ofp_print_port_config(string, pm.mask);
+
ds_put_format(string, " advertise: ");
- if (opm->advertise) {
- ofp_print_port_features(string, ntohl(opm->advertise));
+ if (pm.advertise) {
+ ofp_print_port_features(string, pm.advertise);
} else {
ds_put_format(string, "UNCHANGED\n");
}
static void
ofp_print_port_status(struct ds *string, const struct ofp_port_status *ops)
{
- if (ops->reason == OFPPR_ADD) {
+ struct ofputil_port_status ps;
+ enum ofperr error;
+
+ error = ofputil_decode_port_status(ops, &ps);
+ if (error) {
+ ofp_print_error(string, error);
+ return;
+ }
+
+ if (ps.reason == OFPPR_ADD) {
ds_put_format(string, " ADD:");
- } else if (ops->reason == OFPPR_DELETE) {
+ } else if (ps.reason == OFPPR_DELETE) {
ds_put_format(string, " DEL:");
- } else if (ops->reason == OFPPR_MODIFY) {
+ } else if (ps.reason == OFPPR_MODIFY) {
ds_put_format(string, " MOD:");
}
- ofp_print_phy_port(string, &ops->desc);
+ ofp_print_phy_port(string, &ps.desc);
}
static void
#include "classifier.h"
#include "dynamic-string.h"
#include "learn.h"
-#include "multipath.h"
#include "meta-flow.h"
+#include "multipath.h"
#include "netdev.h"
#include "nx-match.h"
#include "ofp-errors.h"
{ OFPUTIL_OFPT_FEATURES_REPLY, OFP10_VERSION,
OFPT_FEATURES_REPLY, "OFPT_FEATURES_REPLY",
- sizeof(struct ofp_switch_features), sizeof(struct ofp_phy_port) },
+ sizeof(struct ofp_switch_features), sizeof(struct ofp10_phy_port) },
+ { OFPUTIL_OFPT_FEATURES_REPLY, OFP11_VERSION,
+ OFPT_FEATURES_REPLY, "OFPT_FEATURES_REPLY",
+ sizeof(struct ofp_switch_features), sizeof(struct ofp11_port) },
{ OFPUTIL_OFPT_GET_CONFIG_REQUEST, OFP10_VERSION,
OFPT_GET_CONFIG_REQUEST, "OFPT_GET_CONFIG_REQUEST",
{ OFPUTIL_OFPT_PORT_STATUS, OFP10_VERSION,
OFPT_PORT_STATUS, "OFPT_PORT_STATUS",
- sizeof(struct ofp_port_status), 0 },
+ sizeof(struct ofp_port_status) + sizeof(struct ofp10_phy_port), 0 },
+ { OFPUTIL_OFPT_PORT_STATUS, OFP11_VERSION,
+ OFPT_PORT_STATUS, "OFPT_PORT_STATUS",
+ sizeof(struct ofp_port_status) + sizeof(struct ofp11_port), 0 },
{ OFPUTIL_OFPT_PACKET_OUT, OFP10_VERSION,
OFPT10_PACKET_OUT, "OFPT_PACKET_OUT",
{ OFPUTIL_OFPT_PORT_MOD, OFP10_VERSION,
OFPT10_PORT_MOD, "OFPT_PORT_MOD",
- sizeof(struct ofp_port_mod), 0 },
+ sizeof(struct ofp10_port_mod), 0 },
+ { OFPUTIL_OFPT_PORT_MOD, OFP11_VERSION,
+ OFPT11_PORT_MOD, "OFPT_PORT_MOD",
+ sizeof(struct ofp11_port_mod), 0 },
{ 0, OFP10_VERSION,
OFPT10_STATS_REQUEST, "OFPT_STATS_REQUEST",
}
}
+/* Returns the OpenFlow protocol version number (e.g. OFP10_VERSION or
+ * OFP11_VERSION) that corresponds to 'protocol'. */
+uint8_t
+ofputil_protocol_to_ofp_version(enum ofputil_protocol protocol)
+{
+ switch (protocol) {
+ case OFPUTIL_P_OF10:
+ case OFPUTIL_P_OF10_TID:
+ case OFPUTIL_P_NXM:
+ case OFPUTIL_P_NXM_TID:
+ return OFP10_VERSION;
+ }
+
+ NOT_REACHED();
+}
+
/* Returns true if 'protocol' is a single OFPUTIL_P_* value, false
* otherwise. */
bool
BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit 6 */
/* NETDEV_F_ bits 11...15 are OFPPF10_ bits 7...11: */
-BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF_COPPER << 4));
-BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF_FIBER << 4));
-BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF_AUTONEG << 4));
-BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF_PAUSE << 4));
-BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF_PAUSE_ASYM << 4));
+BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == (OFPPF10_COPPER << 4));
+BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == (OFPPF10_FIBER << 4));
+BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == (OFPPF10_AUTONEG << 4));
+BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == (OFPPF10_PAUSE << 4));
+BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == (OFPPF10_PAUSE_ASYM << 4));
-enum netdev_features
-ofputil_netdev_port_features_from_ofp10(ovs_be32 ofp10_)
+static enum netdev_features
+netdev_port_features_from_ofp10(ovs_be32 ofp10_)
{
uint32_t ofp10 = ntohl(ofp10_);
return (ofp10 & 0x7f) | ((ofp10 & 0xf80) << 4);
}
-ovs_be32
-ofputil_netdev_port_features_to_ofp10(enum netdev_features features)
+static ovs_be32
+netdev_port_features_to_ofp10(enum netdev_features features)
{
return htonl((features & 0x7f) | ((features & 0xf800) >> 4));
}
+BUILD_ASSERT_DECL((int) NETDEV_F_10MB_HD == OFPPF_10MB_HD); /* bit 0 */
+BUILD_ASSERT_DECL((int) NETDEV_F_10MB_FD == OFPPF_10MB_FD); /* bit 1 */
+BUILD_ASSERT_DECL((int) NETDEV_F_100MB_HD == OFPPF_100MB_HD); /* bit 2 */
+BUILD_ASSERT_DECL((int) NETDEV_F_100MB_FD == OFPPF_100MB_FD); /* bit 3 */
+BUILD_ASSERT_DECL((int) NETDEV_F_1GB_HD == OFPPF_1GB_HD); /* bit 4 */
+BUILD_ASSERT_DECL((int) NETDEV_F_1GB_FD == OFPPF_1GB_FD); /* bit 5 */
+BUILD_ASSERT_DECL((int) NETDEV_F_10GB_FD == OFPPF_10GB_FD); /* bit 6 */
+BUILD_ASSERT_DECL((int) NETDEV_F_40GB_FD == OFPPF11_40GB_FD); /* bit 7 */
+BUILD_ASSERT_DECL((int) NETDEV_F_100GB_FD == OFPPF11_100GB_FD); /* bit 8 */
+BUILD_ASSERT_DECL((int) NETDEV_F_1TB_FD == OFPPF11_1TB_FD); /* bit 9 */
+BUILD_ASSERT_DECL((int) NETDEV_F_OTHER == OFPPF11_OTHER); /* bit 10 */
+BUILD_ASSERT_DECL((int) NETDEV_F_COPPER == OFPPF11_COPPER); /* bit 11 */
+BUILD_ASSERT_DECL((int) NETDEV_F_FIBER == OFPPF11_FIBER); /* bit 12 */
+BUILD_ASSERT_DECL((int) NETDEV_F_AUTONEG == OFPPF11_AUTONEG); /* bit 13 */
+BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE == OFPPF11_PAUSE); /* bit 14 */
+BUILD_ASSERT_DECL((int) NETDEV_F_PAUSE_ASYM == OFPPF11_PAUSE_ASYM);/* bit 15 */
+
+static enum netdev_features
+netdev_port_features_from_ofp11(ovs_be32 ofp11)
+{
+ return ntohl(ofp11) & 0xffff;
+}
+
+static ovs_be32
+netdev_port_features_to_ofp11(enum netdev_features features)
+{
+ return htonl(features & 0xffff);
+}
+
+static enum ofperr
+ofputil_decode_ofp10_phy_port(struct ofputil_phy_port *pp,
+ const struct ofp10_phy_port *opp)
+{
+ memset(pp, 0, sizeof *pp);
+
+ pp->port_no = ntohs(opp->port_no);
+ memcpy(pp->hw_addr, opp->hw_addr, OFP_ETH_ALEN);
+ ovs_strlcpy(pp->name, opp->name, OFP_MAX_PORT_NAME_LEN);
+
+ pp->config = ntohl(opp->config) & OFPPC10_ALL;
+ pp->state = ntohl(opp->state) & OFPPS10_ALL;
+
+ pp->curr = netdev_port_features_from_ofp10(opp->curr);
+ pp->advertised = netdev_port_features_from_ofp10(opp->advertised);
+ pp->supported = netdev_port_features_from_ofp10(opp->supported);
+ pp->peer = netdev_port_features_from_ofp10(opp->peer);
+
+ pp->curr_speed = netdev_features_to_bps(pp->curr) / 1000;
+ pp->max_speed = netdev_features_to_bps(pp->supported) / 1000;
+
+ return 0;
+}
+
+static enum ofperr
+ofputil_decode_ofp11_port(struct ofputil_phy_port *pp,
+ const struct ofp11_port *op)
+{
+ enum ofperr error;
+
+ memset(pp, 0, sizeof *pp);
+
+ error = ofputil_port_from_ofp11(op->port_no, &pp->port_no);
+ if (error) {
+ return error;
+ }
+ memcpy(pp->hw_addr, op->hw_addr, OFP_ETH_ALEN);
+ ovs_strlcpy(pp->name, op->name, OFP_MAX_PORT_NAME_LEN);
+
+ pp->config = ntohl(op->config) & OFPPC11_ALL;
+ pp->state = ntohl(op->state) & OFPPC11_ALL;
+
+ pp->curr = netdev_port_features_from_ofp11(op->curr);
+ pp->advertised = netdev_port_features_from_ofp11(op->advertised);
+ pp->supported = netdev_port_features_from_ofp11(op->supported);
+ pp->peer = netdev_port_features_from_ofp11(op->peer);
+
+ pp->curr_speed = ntohl(op->curr_speed);
+ pp->max_speed = ntohl(op->max_speed);
+
+ return 0;
+}
+
+static int
+ofputil_pull_phy_port(uint8_t ofp_version, struct ofpbuf *b,
+ struct ofputil_phy_port *pp)
+{
+ if (ofp_version == OFP10_VERSION) {
+ const struct ofp10_phy_port *opp = ofpbuf_try_pull(b, sizeof *opp);
+ return opp ? ofputil_decode_ofp10_phy_port(pp, opp) : EOF;
+ } else {
+ const struct ofp11_port *op = ofpbuf_try_pull(b, sizeof *op);
+ return op ? ofputil_decode_ofp11_port(pp, op) : EOF;
+ }
+}
+
+static void
+ofputil_encode_ofp10_phy_port(const struct ofputil_phy_port *pp,
+ struct ofp10_phy_port *opp)
+{
+ memset(opp, 0, sizeof *opp);
+
+ opp->port_no = htons(pp->port_no);
+ memcpy(opp->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
+ ovs_strlcpy(opp->name, pp->name, OFP_MAX_PORT_NAME_LEN);
+
+ opp->config = htonl(pp->config & OFPPC10_ALL);
+ opp->state = htonl(pp->state & OFPPS10_ALL);
+
+ opp->curr = netdev_port_features_to_ofp10(pp->curr);
+ opp->advertised = netdev_port_features_to_ofp10(pp->advertised);
+ opp->supported = netdev_port_features_to_ofp10(pp->supported);
+ opp->peer = netdev_port_features_to_ofp10(pp->peer);
+}
+
+static void
+ofputil_encode_ofp11_port(const struct ofputil_phy_port *pp,
+ struct ofp11_port *op)
+{
+ memset(op, 0, sizeof *op);
+
+ op->port_no = ofputil_port_to_ofp11(pp->port_no);
+ memcpy(op->hw_addr, pp->hw_addr, ETH_ADDR_LEN);
+ ovs_strlcpy(op->name, pp->name, OFP_MAX_PORT_NAME_LEN);
+
+ op->config = htonl(pp->config & OFPPC11_ALL);
+ op->state = htonl(pp->state & OFPPS11_ALL);
+
+ op->curr = netdev_port_features_to_ofp11(pp->curr);
+ op->advertised = netdev_port_features_to_ofp11(pp->advertised);
+ op->supported = netdev_port_features_to_ofp11(pp->supported);
+ op->peer = netdev_port_features_to_ofp11(pp->peer);
+
+ op->curr_speed = htonl(pp->curr_speed);
+ op->max_speed = htonl(pp->max_speed);
+}
+
+static void
+ofputil_put_phy_port(uint8_t ofp_version, const struct ofputil_phy_port *pp,
+ struct ofpbuf *b)
+{
+ if (ofp_version == OFP10_VERSION) {
+ struct ofp10_phy_port *opp;
+ if (b->size + sizeof *opp <= UINT16_MAX) {
+ opp = ofpbuf_put_uninit(b, sizeof *opp);
+ ofputil_encode_ofp10_phy_port(pp, opp);
+ }
+ } else {
+ struct ofp11_port *op;
+ if (b->size + sizeof *op <= UINT16_MAX) {
+ op = ofpbuf_put_uninit(b, sizeof *op);
+ ofputil_encode_ofp11_port(pp, op);
+ }
+ }
+}
+\f
+/* ofputil_switch_features */
+
+#define OFPC_COMMON (OFPC_FLOW_STATS | OFPC_TABLE_STATS | OFPC_PORT_STATS | \
+ OFPC_IP_REASM | OFPC_QUEUE_STATS | OFPC_ARP_MATCH_IP)
+BUILD_ASSERT_DECL((int) OFPUTIL_C_FLOW_STATS == OFPC_FLOW_STATS);
+BUILD_ASSERT_DECL((int) OFPUTIL_C_TABLE_STATS == OFPC_TABLE_STATS);
+BUILD_ASSERT_DECL((int) OFPUTIL_C_PORT_STATS == OFPC_PORT_STATS);
+BUILD_ASSERT_DECL((int) OFPUTIL_C_IP_REASM == OFPC_IP_REASM);
+BUILD_ASSERT_DECL((int) OFPUTIL_C_QUEUE_STATS == OFPC_QUEUE_STATS);
+BUILD_ASSERT_DECL((int) OFPUTIL_C_ARP_MATCH_IP == OFPC_ARP_MATCH_IP);
+
+struct ofputil_action_bit_translation {
+ enum ofputil_action_bitmap ofputil_bit;
+ int of_bit;
+};
+
+static const struct ofputil_action_bit_translation of10_action_bits[] = {
+ { OFPUTIL_A_OUTPUT, OFPAT10_OUTPUT },
+ { OFPUTIL_A_SET_VLAN_VID, OFPAT10_SET_VLAN_VID },
+ { OFPUTIL_A_SET_VLAN_PCP, OFPAT10_SET_VLAN_PCP },
+ { OFPUTIL_A_STRIP_VLAN, OFPAT10_STRIP_VLAN },
+ { OFPUTIL_A_SET_DL_SRC, OFPAT10_SET_DL_SRC },
+ { OFPUTIL_A_SET_DL_DST, OFPAT10_SET_DL_DST },
+ { OFPUTIL_A_SET_NW_SRC, OFPAT10_SET_NW_SRC },
+ { OFPUTIL_A_SET_NW_DST, OFPAT10_SET_NW_DST },
+ { OFPUTIL_A_SET_NW_TOS, OFPAT10_SET_NW_TOS },
+ { OFPUTIL_A_SET_TP_SRC, OFPAT10_SET_TP_SRC },
+ { OFPUTIL_A_SET_TP_DST, OFPAT10_SET_TP_DST },
+ { OFPUTIL_A_ENQUEUE, OFPAT10_ENQUEUE },
+ { 0, 0 },
+};
+
+static const struct ofputil_action_bit_translation of11_action_bits[] = {
+ { OFPUTIL_A_OUTPUT, OFPAT11_OUTPUT },
+ { OFPUTIL_A_SET_VLAN_VID, OFPAT11_SET_VLAN_VID },
+ { OFPUTIL_A_SET_VLAN_PCP, OFPAT11_SET_VLAN_PCP },
+ { OFPUTIL_A_SET_DL_SRC, OFPAT11_SET_DL_SRC },
+ { OFPUTIL_A_SET_DL_DST, OFPAT11_SET_DL_DST },
+ { OFPUTIL_A_SET_NW_SRC, OFPAT11_SET_NW_SRC },
+ { OFPUTIL_A_SET_NW_DST, OFPAT11_SET_NW_DST },
+ { OFPUTIL_A_SET_NW_TOS, OFPAT11_SET_NW_TOS },
+ { OFPUTIL_A_SET_NW_ECN, OFPAT11_SET_NW_ECN },
+ { OFPUTIL_A_SET_TP_SRC, OFPAT11_SET_TP_SRC },
+ { OFPUTIL_A_SET_TP_DST, OFPAT11_SET_TP_DST },
+ { OFPUTIL_A_COPY_TTL_OUT, OFPAT11_COPY_TTL_OUT },
+ { OFPUTIL_A_COPY_TTL_IN, OFPAT11_COPY_TTL_IN },
+ { OFPUTIL_A_SET_MPLS_LABEL, OFPAT11_SET_MPLS_LABEL },
+ { OFPUTIL_A_SET_MPLS_TC, OFPAT11_SET_MPLS_TC },
+ { OFPUTIL_A_SET_MPLS_TTL, OFPAT11_SET_MPLS_TTL },
+ { OFPUTIL_A_DEC_MPLS_TTL, OFPAT11_DEC_MPLS_TTL },
+ { OFPUTIL_A_PUSH_VLAN, OFPAT11_PUSH_VLAN },
+ { OFPUTIL_A_POP_VLAN, OFPAT11_POP_VLAN },
+ { OFPUTIL_A_PUSH_MPLS, OFPAT11_PUSH_MPLS },
+ { OFPUTIL_A_POP_MPLS, OFPAT11_POP_MPLS },
+ { OFPUTIL_A_SET_QUEUE, OFPAT11_SET_QUEUE },
+ { OFPUTIL_A_GROUP, OFPAT11_GROUP },
+ { OFPUTIL_A_SET_NW_TTL, OFPAT11_SET_NW_TTL },
+ { OFPUTIL_A_DEC_NW_TTL, OFPAT11_DEC_NW_TTL },
+ { 0, 0 },
+};
+
+static enum ofputil_action_bitmap
+decode_action_bits(ovs_be32 of_actions,
+ const struct ofputil_action_bit_translation *x)
+{
+ enum ofputil_action_bitmap ofputil_actions;
+
+ ofputil_actions = 0;
+ for (; x->ofputil_bit; x++) {
+ if (of_actions & htonl(1u << x->of_bit)) {
+ ofputil_actions |= x->ofputil_bit;
+ }
+ }
+ return ofputil_actions;
+}
+
+/* Decodes an OpenFlow 1.0 or 1.1 "switch_features" structure 'osf' into an
+ * abstract representation in '*features'. Initializes '*b' to iterate over
+ * the OpenFlow port structures following 'osf' with later calls to
+ * ofputil_pull_switch_features_port(). Returns 0 if successful, otherwise an
+ * OFPERR_* value. */
+enum ofperr
+ofputil_decode_switch_features(const struct ofp_switch_features *osf,
+ struct ofputil_switch_features *features,
+ struct ofpbuf *b)
+{
+ ofpbuf_use_const(b, osf, ntohs(osf->header.length));
+ ofpbuf_pull(b, sizeof *osf);
+ b->l2 = (struct ofputil_switch_features *) osf;
+
+ features->datapath_id = ntohll(osf->datapath_id);
+ features->n_buffers = ntohl(osf->n_buffers);
+ features->n_tables = osf->n_tables;
+
+ features->capabilities = ntohl(osf->capabilities) & OFPC_COMMON;
+ if (osf->header.version == OFP10_VERSION) {
+ if (b->size % sizeof(struct ofp10_phy_port)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ if (osf->capabilities & htonl(OFPC10_STP)) {
+ features->capabilities |= OFPUTIL_C_STP;
+ }
+ features->actions = decode_action_bits(osf->actions, of10_action_bits);
+ } else if (osf->header.version == OFP11_VERSION) {
+ if (b->size % sizeof(struct ofp11_port)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ if (osf->capabilities & htonl(OFPC11_GROUP_STATS)) {
+ features->capabilities |= OFPUTIL_C_GROUP_STATS;
+ }
+ features->actions = decode_action_bits(osf->actions, of11_action_bits);
+ } else {
+ return OFPERR_OFPBRC_BAD_VERSION;
+ }
+
+ return 0;
+}
+
+/* Given a buffer 'b' that was initialized by a previous successful call to
+ * ofputil_decode_switch_features(), tries to decode an OpenFlow port structure
+ * following the main switch features information. If successful, initializes
+ * '*pp' with an abstract representation of the port and returns 0. If no
+ * ports remained to be decoded, returns EOF. On an error, returns a positive
+ * OFPERR_* value. */
+int
+ofputil_pull_switch_features_port(struct ofpbuf *b,
+ struct ofputil_phy_port *pp)
+{
+ const struct ofp_switch_features *osf = b->l2;
+ return ofputil_pull_phy_port(osf->header.version, b, pp);
+}
+
+/* Returns the number of OpenFlow port structures that follow the main switch
+ * features information in '*osf'. The return value is only guaranteed to be
+ * accurate if '*osf' is well-formed, that is, if
+ * ofputil_decode_switch_features() can process '*osf' successfully. */
+size_t
+ofputil_count_phy_ports(const struct ofp_switch_features *osf)
+{
+ size_t ports_len = ntohs(osf->header.length) - sizeof *osf;
+ return (osf->header.version == OFP10_VERSION
+ ? ports_len / sizeof(struct ofp10_phy_port)
+ : ports_len / sizeof(struct ofp11_port));
+}
+
+static ovs_be32
+encode_action_bits(enum ofputil_action_bitmap ofputil_actions,
+ const struct ofputil_action_bit_translation *x)
+{
+ uint32_t of_actions;
+
+ of_actions = 0;
+ for (; x->ofputil_bit; x++) {
+ if (ofputil_actions & x->ofputil_bit) {
+ of_actions |= 1 << x->of_bit;
+ }
+ }
+ return htonl(of_actions);
+}
+
+/* Returns a buffer owned by the caller that encodes 'features' in the format
+ * required by 'protocol' with the given 'xid'. The caller should append port
+ * information to the buffer with subsequent calls to
+ * ofputil_put_switch_features_port(). */
+struct ofpbuf *
+ofputil_encode_switch_features(const struct ofputil_switch_features *features,
+ enum ofputil_protocol protocol, ovs_be32 xid)
+{
+ struct ofp_switch_features *osf;
+ struct ofpbuf *b;
+
+ osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, xid, &b);
+ osf->header.version = ofputil_protocol_to_ofp_version(protocol);
+ osf->datapath_id = htonll(features->datapath_id);
+ osf->n_buffers = htonl(features->n_buffers);
+ osf->n_tables = features->n_tables;
+
+ osf->capabilities = htonl(features->capabilities & OFPC_COMMON);
+ if (osf->header.version == OFP10_VERSION) {
+ if (features->capabilities & OFPUTIL_C_STP) {
+ osf->capabilities |= htonl(OFPC10_STP);
+ }
+ osf->actions = encode_action_bits(features->actions, of10_action_bits);
+ } else {
+ if (features->capabilities & OFPUTIL_C_GROUP_STATS) {
+ osf->capabilities |= htonl(OFPC11_GROUP_STATS);
+ }
+ osf->actions = encode_action_bits(features->actions, of11_action_bits);
+ }
+
+ return b;
+}
+
+/* Encodes 'pp' into the format required by the switch_features message already
+ * in 'b', which should have been returned by ofputil_encode_switch_features(),
+ * and appends the encoded version to 'b'. */
+void
+ofputil_put_switch_features_port(const struct ofputil_phy_port *pp,
+ struct ofpbuf *b)
+{
+ const struct ofp_switch_features *osf = b->data;
+
+ ofputil_put_phy_port(osf->header.version, pp, b);
+}
+\f
+/* ofputil_port_status */
+
+/* Decodes the OpenFlow "port status" message in '*ops' into an abstract form
+ * in '*ps'. Returns 0 if successful, otherwise an OFPERR_* value. */
+enum ofperr
+ofputil_decode_port_status(const struct ofp_port_status *ops,
+ struct ofputil_port_status *ps)
+{
+ struct ofpbuf b;
+ int retval;
+
+ if (ops->reason != OFPPR_ADD &&
+ ops->reason != OFPPR_DELETE &&
+ ops->reason != OFPPR_MODIFY) {
+ return OFPERR_NXBRC_BAD_REASON;
+ }
+ ps->reason = ops->reason;
+
+ ofpbuf_use_const(&b, ops, ntohs(ops->header.length));
+ ofpbuf_pull(&b, sizeof *ops);
+ retval = ofputil_pull_phy_port(ops->header.version, &b, &ps->desc);
+ assert(retval != EOF);
+ return retval;
+}
+
+/* Converts the abstract form of a "port status" message in '*ps' into an
+ * OpenFlow message suitable for 'protocol', and returns that encoded form in
+ * a buffer owned by the caller. */
+struct ofpbuf *
+ofputil_encode_port_status(const struct ofputil_port_status *ps,
+ enum ofputil_protocol protocol)
+{
+ struct ofp_port_status *ops;
+ struct ofpbuf *b;
+
+ b = ofpbuf_new(sizeof *ops + sizeof(struct ofp11_port));
+ ops = put_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, htonl(0), b);
+ ops->header.version = ofputil_protocol_to_ofp_version(protocol);
+ ops->reason = ps->reason;
+ ofputil_put_phy_port(ops->header.version, &ps->desc, b);
+ update_openflow_length(b);
+ return b;
+}
+\f
+/* ofputil_port_mod */
+
+/* Decodes the OpenFlow "port mod" message in '*oh' into an abstract form in
+ * '*pm'. Returns 0 if successful, otherwise an OFPERR_* value. */
+enum ofperr
+ofputil_decode_port_mod(const struct ofp_header *oh,
+ struct ofputil_port_mod *pm)
+{
+ if (oh->version == OFP10_VERSION) {
+ const struct ofp10_port_mod *opm = (const struct ofp10_port_mod *) oh;
+
+ if (oh->length != htons(sizeof *opm)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ pm->port_no = ntohs(opm->port_no);
+ memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
+ pm->config = ntohl(opm->config) & OFPPC10_ALL;
+ pm->mask = ntohl(opm->mask) & OFPPC10_ALL;
+ pm->advertise = netdev_port_features_from_ofp10(opm->advertise);
+ } else if (oh->version == OFP11_VERSION) {
+ const struct ofp11_port_mod *opm = (const struct ofp11_port_mod *) oh;
+ enum ofperr error;
+
+ if (oh->length != htons(sizeof *opm)) {
+ return OFPERR_OFPBRC_BAD_LEN;
+ }
+
+ error = ofputil_port_from_ofp11(opm->port_no, &pm->port_no);
+ if (error) {
+ return error;
+ }
+
+ memcpy(pm->hw_addr, opm->hw_addr, ETH_ADDR_LEN);
+ pm->config = ntohl(opm->config) & OFPPC11_ALL;
+ pm->mask = ntohl(opm->mask) & OFPPC11_ALL;
+ pm->advertise = netdev_port_features_from_ofp11(opm->advertise);
+ } else {
+ return OFPERR_OFPBRC_BAD_VERSION;
+ }
+
+ pm->config &= pm->mask;
+ return 0;
+}
+
+/* Converts the abstract form of a "port mod" message in '*pm' into an OpenFlow
+ * message suitable for 'protocol', and returns that encoded form in a buffer
+ * owned by the caller. */
+struct ofpbuf *
+ofputil_encode_port_mod(const struct ofputil_port_mod *pm,
+ enum ofputil_protocol protocol)
+{
+ uint8_t ofp_version = ofputil_protocol_to_ofp_version(protocol);
+ struct ofpbuf *b;
+
+ if (ofp_version == OFP10_VERSION) {
+ struct ofp10_port_mod *opm;
+
+ opm = make_openflow(sizeof *opm, OFPT10_PORT_MOD, &b);
+ opm->port_no = htons(pm->port_no);
+ memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
+ opm->config = htonl(pm->config & OFPPC10_ALL);
+ opm->mask = htonl(pm->mask & OFPPC10_ALL);
+ opm->advertise = netdev_port_features_to_ofp10(pm->advertise);
+ } else if (ofp_version == OFP11_VERSION) {
+ struct ofp11_port_mod *opm;
+
+ opm = make_openflow(sizeof *opm, OFPT11_PORT_MOD, &b);
+ opm->port_no = htonl(pm->port_no);
+ memcpy(opm->hw_addr, pm->hw_addr, ETH_ADDR_LEN);
+ opm->config = htonl(pm->config & OFPPC11_ALL);
+ opm->mask = htonl(pm->mask & OFPPC11_ALL);
+ opm->advertise = netdev_port_features_to_ofp11(pm->advertise);
+ } else {
+ NOT_REACHED();
+ }
+
+ return b;
+}
+
struct ofpbuf *
ofputil_encode_packet_out(const struct ofputil_packet_out *po)
{
extern size_t ofputil_n_flow_dump_protocols;
enum ofputil_protocol ofputil_protocol_from_ofp_version(int version);
+uint8_t ofputil_protocol_to_ofp_version(enum ofputil_protocol);
+
bool ofputil_protocol_is_valid(enum ofputil_protocol);
enum ofputil_protocol ofputil_protocol_set_tid(enum ofputil_protocol,
bool enable);
const struct ofp_packet_out *);
struct ofpbuf *ofputil_encode_packet_out(const struct ofputil_packet_out *);
-/* OFPFF_* bits. */
-enum netdev_features ofputil_netdev_port_features_from_ofp10(ovs_be32 ofp10);
-ovs_be32 ofputil_netdev_port_features_to_ofp10(enum netdev_features);
+enum ofputil_port_config {
+ /* OpenFlow 1.0 and 1.1 share these values for these port config bits. */
+ OFPUTIL_PC_PORT_DOWN = 1 << 0, /* Port is administratively down. */
+ OFPUTIL_PC_NO_RECV = 1 << 2, /* Drop all packets received by port. */
+ OFPUTIL_PC_NO_FWD = 1 << 5, /* Drop packets forwarded to port. */
+ OFPUTIL_PC_NO_PACKET_IN = 1 << 6, /* No send packet-in msgs for port. */
+ /* OpenFlow 1.0 only. */
+ OFPUTIL_PC_NO_STP = 1 << 1, /* No 802.1D spanning tree for port. */
+ OFPUTIL_PC_NO_RECV_STP = 1 << 3, /* Drop received 802.1D STP packets. */
+ OFPUTIL_PC_NO_FLOOD = 1 << 4, /* Do not include port when flooding. */
+ /* There are no OpenFlow 1.1-only bits. */
+};
+
+enum ofputil_port_state {
+ /* OpenFlow 1.0 and 1.1 share this values for these port state bits. */
+ OFPUTIL_PS_LINK_DOWN = 1 << 0, /* No physical link present. */
+ /* OpenFlow 1.1 only. */
+ OFPUTIL_PS_BLOCKED = 1 << 1, /* Port is blocked */
+ OFPUTIL_PS_LIVE = 1 << 2, /* Live for Fast Failover Group. */
+ /* OpenFlow 1.0 only. */
+ OFPUTIL_PS_STP_LISTEN = 0 << 8, /* Not learning or relaying frames. */
+ OFPUTIL_PS_STP_LEARN = 1 << 8, /* Learning but not relaying frames. */
+ OFPUTIL_PS_STP_FORWARD = 2 << 8, /* Learning and relaying frames. */
+ OFPUTIL_PS_STP_BLOCK = 3 << 8, /* Not part of spanning tree. */
+ OFPUTIL_PS_STP_MASK = 3 << 8 /* Bit mask for OFPPS10_STP_* values. */
+};
+
+/* Abstract ofp10_phy_port or ofp11_port. */
+struct ofputil_phy_port {
+ uint16_t port_no;
+ uint8_t hw_addr[OFP_ETH_ALEN];
+ char name[OFP_MAX_PORT_NAME_LEN];
+ enum ofputil_port_config config;
+ enum ofputil_port_state state;
+
+ /* NETDEV_F_* feature bitmasks. */
+ enum netdev_features curr; /* Current features. */
+ enum netdev_features advertised; /* Features advertised by the port. */
+ enum netdev_features supported; /* Features supported by the port. */
+ enum netdev_features peer; /* Features advertised by peer. */
+
+ /* Speed. */
+ uint32_t curr_speed; /* Current speed, in kbps. */
+ uint32_t max_speed; /* Maximum supported speed, in kbps. */
+};
+
+enum ofputil_capabilities {
+ /* OpenFlow 1.0 and 1.1 share these values for these capabilities. */
+ OFPUTIL_C_FLOW_STATS = 1 << 0, /* Flow statistics. */
+ OFPUTIL_C_TABLE_STATS = 1 << 1, /* Table statistics. */
+ OFPUTIL_C_PORT_STATS = 1 << 2, /* Port statistics. */
+ OFPUTIL_C_IP_REASM = 1 << 5, /* Can reassemble IP fragments. */
+ OFPUTIL_C_QUEUE_STATS = 1 << 6, /* Queue statistics. */
+ OFPUTIL_C_ARP_MATCH_IP = 1 << 7, /* Match IP addresses in ARP pkts. */
+
+ /* OpenFlow 1.0 only. */
+ OFPUTIL_C_STP = 1 << 3, /* 802.1d spanning tree. */
+
+ /* OpenFlow 1.1 only. */
+ OFPUTIL_C_GROUP_STATS = 1 << 4, /* Group statistics. */
+};
+
+enum ofputil_action_bitmap {
+ OFPUTIL_A_OUTPUT = 1 << 0,
+ OFPUTIL_A_SET_VLAN_VID = 1 << 1,
+ OFPUTIL_A_SET_VLAN_PCP = 1 << 2,
+ OFPUTIL_A_STRIP_VLAN = 1 << 3,
+ OFPUTIL_A_SET_DL_SRC = 1 << 4,
+ OFPUTIL_A_SET_DL_DST = 1 << 5,
+ OFPUTIL_A_SET_NW_SRC = 1 << 6,
+ OFPUTIL_A_SET_NW_DST = 1 << 7,
+ OFPUTIL_A_SET_NW_ECN = 1 << 8,
+ OFPUTIL_A_SET_NW_TOS = 1 << 9,
+ OFPUTIL_A_SET_TP_SRC = 1 << 10,
+ OFPUTIL_A_SET_TP_DST = 1 << 11,
+ OFPUTIL_A_ENQUEUE = 1 << 12,
+ OFPUTIL_A_COPY_TTL_OUT = 1 << 13,
+ OFPUTIL_A_COPY_TTL_IN = 1 << 14,
+ OFPUTIL_A_SET_MPLS_LABEL = 1 << 15,
+ OFPUTIL_A_SET_MPLS_TC = 1 << 16,
+ OFPUTIL_A_SET_MPLS_TTL = 1 << 17,
+ OFPUTIL_A_DEC_MPLS_TTL = 1 << 18,
+ OFPUTIL_A_PUSH_VLAN = 1 << 19,
+ OFPUTIL_A_POP_VLAN = 1 << 20,
+ OFPUTIL_A_PUSH_MPLS = 1 << 21,
+ OFPUTIL_A_POP_MPLS = 1 << 22,
+ OFPUTIL_A_SET_QUEUE = 1 << 23,
+ OFPUTIL_A_GROUP = 1 << 24,
+ OFPUTIL_A_SET_NW_TTL = 1 << 25,
+ OFPUTIL_A_DEC_NW_TTL = 1 << 26,
+};
+
+/* Abstract ofp_switch_features. */
+struct ofputil_switch_features {
+ uint64_t datapath_id; /* Datapath unique ID. */
+ uint32_t n_buffers; /* Max packets buffered at once. */
+ uint8_t n_tables; /* Number of tables supported by datapath. */
+ enum ofputil_capabilities capabilities;
+ enum ofputil_action_bitmap actions;
+};
+
+enum ofperr ofputil_decode_switch_features(const struct ofp_switch_features *,
+ struct ofputil_switch_features *,
+ struct ofpbuf *);
+int ofputil_pull_switch_features_port(struct ofpbuf *,
+ struct ofputil_phy_port *);
+size_t ofputil_count_phy_ports(const struct ofp_switch_features *);
+
+struct ofpbuf *ofputil_encode_switch_features(
+ const struct ofputil_switch_features *, enum ofputil_protocol,
+ ovs_be32 xid);
+void ofputil_put_switch_features_port(const struct ofputil_phy_port *,
+ struct ofpbuf *);
+
+/* Abstract ofp_port_status. */
+struct ofputil_port_status {
+ enum ofp_port_reason reason;
+ struct ofputil_phy_port desc;
+};
+
+enum ofperr ofputil_decode_port_status(const struct ofp_port_status *,
+ struct ofputil_port_status *);
+struct ofpbuf *ofputil_encode_port_status(const struct ofputil_port_status *,
+ enum ofputil_protocol);
+
+/* Abstract ofp_port_mod. */
+struct ofputil_port_mod {
+ uint16_t port_no;
+ uint8_t hw_addr[OFP_ETH_ALEN];
+ enum ofputil_port_config config;
+ enum ofputil_port_config mask;
+ enum netdev_features advertise;
+};
+
+enum ofperr ofputil_decode_port_mod(const struct ofp_header *,
+ struct ofputil_port_mod *);
+struct ofpbuf *ofputil_encode_port_mod(const struct ofputil_port_mod *,
+ enum ofputil_protocol);
/* OpenFlow protocol utility functions. */
void *make_openflow(size_t openflow_len, uint8_t type, struct ofpbuf **);
/* Sends an OFPT_PORT_STATUS message with 'opp' and 'reason' to appropriate
* controllers managed by 'mgr'. */
void
-connmgr_send_port_status(struct connmgr *mgr, const struct ofp_phy_port *opp,
- uint8_t reason)
+connmgr_send_port_status(struct connmgr *mgr,
+ const struct ofputil_phy_port *pp, uint8_t reason)
{
/* XXX Should limit the number of queued port status change messages. */
+ struct ofputil_port_status ps;
struct ofconn *ofconn;
+ ps.reason = reason;
+ ps.desc = *pp;
LIST_FOR_EACH (ofconn, node, &mgr->all_conns) {
if (ofconn_receives_async_msg(ofconn, OAM_PORT_STATUS, reason)) {
- struct ofp_port_status *ops;
- struct ofpbuf *b;
+ struct ofpbuf *msg;
- ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b);
- ops->reason = reason;
- ops->desc = *opp;
- ofconn_send(ofconn, b, NULL);
+ msg = ofputil_encode_port_status(&ps, ofconn->protocol);
+ ofconn_send(ofconn, msg, NULL);
}
}
}
struct ofopgroup;
struct ofputil_flow_removed;
struct ofputil_packet_in;
+struct ofputil_phy_port;
struct sset;
/* ofproto supports two kinds of OpenFlow connections:
const struct ofp_header *request, int error);
/* Sending asynchronous messages. */
-void connmgr_send_port_status(struct connmgr *, const struct ofp_phy_port *,
- uint8_t reason);
+void connmgr_send_port_status(struct connmgr *,
+ const struct ofputil_phy_port *, uint8_t reason);
void connmgr_send_flow_removed(struct connmgr *,
const struct ofputil_flow_removed *);
void connmgr_send_packet_in(struct connmgr *, const struct ofputil_packet_in *,
bool use_priority_tags; /* Use 802.1p tag for frames in VLAN 0? */
/* Status. */
- bool floodable; /* True if no port has OFPPC_NO_FLOOD set. */
+ bool floodable; /* True if no port has OFPUTIL_PC_NO_FLOOD set. */
/* Port mirroring info. */
mirror_mask_t src_mirrors; /* Mirrors triggered when packet received. */
static void
get_features(struct ofproto *ofproto_ OVS_UNUSED,
- bool *arp_match_ip, uint32_t *actions)
+ bool *arp_match_ip, enum ofputil_action_bitmap *actions)
{
*arp_match_ip = true;
- *actions = ((1u << OFPAT10_OUTPUT) |
- (1u << OFPAT10_SET_VLAN_VID) |
- (1u << OFPAT10_SET_VLAN_PCP) |
- (1u << OFPAT10_STRIP_VLAN) |
- (1u << OFPAT10_SET_DL_SRC) |
- (1u << OFPAT10_SET_DL_DST) |
- (1u << OFPAT10_SET_NW_SRC) |
- (1u << OFPAT10_SET_NW_DST) |
- (1u << OFPAT10_SET_NW_TOS) |
- (1u << OFPAT10_SET_TP_SRC) |
- (1u << OFPAT10_SET_TP_DST) |
- (1u << OFPAT10_ENQUEUE));
+ *actions = (OFPUTIL_A_OUTPUT |
+ OFPUTIL_A_SET_VLAN_VID |
+ OFPUTIL_A_SET_VLAN_PCP |
+ OFPUTIL_A_STRIP_VLAN |
+ OFPUTIL_A_SET_DL_SRC |
+ OFPUTIL_A_SET_DL_DST |
+ OFPUTIL_A_SET_NW_SRC |
+ OFPUTIL_A_SET_NW_DST |
+ OFPUTIL_A_SET_NW_TOS |
+ OFPUTIL_A_SET_TP_SRC |
+ OFPUTIL_A_SET_TP_DST |
+ OFPUTIL_A_ENQUEUE);
}
static void
}
static void
-port_reconfigured(struct ofport *port_, ovs_be32 old_config)
+port_reconfigured(struct ofport *port_, enum ofputil_port_config old_config)
{
struct ofport_dpif *port = ofport_dpif_cast(port_);
struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
- ovs_be32 changed = old_config ^ port->up.opp.config;
+ enum ofputil_port_config changed = old_config ^ port->up.pp.config;
- if (changed & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP |
- OFPPC_NO_FWD | OFPPC_NO_FLOOD)) {
+ if (changed & (OFPUTIL_PC_NO_RECV | OFPUTIL_PC_NO_RECV_STP |
+ OFPUTIL_PC_NO_FWD | OFPUTIL_PC_NO_FLOOD)) {
ofproto->need_revalidate = true;
- if (changed & htonl(OFPPC_NO_FLOOD) && port->bundle) {
+ if (changed & OFPUTIL_PC_NO_FLOOD && port->bundle) {
bundle_update(port->bundle);
}
}
/* Update state. */
if (ofport->stp_state != state) {
- ovs_be32 of_state;
+ enum ofputil_port_state of_state;
bool fwd_change;
VLOG_DBG_RL(&rl, "port %s: STP state changed from %s to %s",
}
/* Update the STP state bits in the OpenFlow port description. */
- of_state = (ofport->up.opp.state & htonl(~OFPPS_STP_MASK))
- | htonl(state == STP_LISTENING ? OFPPS_STP_LISTEN
- : state == STP_LEARNING ? OFPPS_STP_LEARN
- : state == STP_FORWARDING ? OFPPS_STP_FORWARD
- : state == STP_BLOCKING ? OFPPS_STP_BLOCK
- : 0);
+ of_state = ofport->up.pp.state & ~OFPUTIL_PS_STP_MASK;
+ of_state |= (state == STP_LISTENING ? OFPUTIL_PS_STP_LISTEN
+ : state == STP_LEARNING ? OFPUTIL_PS_STP_LEARN
+ : state == STP_FORWARDING ? OFPUTIL_PS_STP_FORWARD
+ : state == STP_BLOCKING ? OFPUTIL_PS_STP_BLOCK
+ : 0);
ofproto_port_set_state(&ofport->up, of_state);
}
}
bundle->floodable = true;
LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
- if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
+ if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
+ || !stp_forward_in_state(port->stp_state)) {
bundle->floodable = false;
break;
}
port->bundle = bundle;
list_push_back(&bundle->ports, &port->bundle_node);
- if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
+ if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
+ || !stp_forward_in_state(port->stp_state)) {
bundle->floodable = false;
}
}
struct ofpbuf packet;
ofpbuf_init(&packet, 0);
- cfm_compose_ccm(ofport->cfm, &packet, ofport->up.opp.hw_addr);
+ cfm_compose_ccm(ofport->cfm, &packet, ofport->up.pp.hw_addr);
send_packet(ofport, &packet);
ofpbuf_uninit(&packet);
}
rule = rule_dpif_lookup(ofproto, flow, 0);
if (!rule) {
- /* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
+ /* Don't send a packet-in if OFPUTIL_PC_NO_PACKET_IN asserted. */
struct ofport_dpif *port = get_ofp_port(ofproto, flow->in_port);
if (port) {
- if (port->up.opp.config & htonl(OFPPC_NO_PACKET_IN)) {
+ if (port->up.pp.config & OFPUTIL_PC_NO_PACKET_IN) {
COVERAGE_INC(ofproto_dpif_no_packet_in);
/* XXX install 'drop' flow entry */
return;
if (ofport) {
struct priority_to_dscp *pdscp;
- if (ofport->up.opp.config & htonl(OFPPC_NO_FWD)
+ if (ofport->up.pp.config & OFPUTIL_PC_NO_FWD
|| (check_stp && !stp_forward_in_state(ofport->stp_state))) {
return;
}
if (all) {
compose_output_action__(ctx, ofp_port, false);
- } else if (!(ofport->up.opp.config & htonl(OFPPC_NO_FLOOD))) {
+ } else if (!(ofport->up.pp.config & OFPUTIL_PC_NO_FLOOD)) {
compose_output_action(ctx, ofp_port);
}
}
static bool
may_receive(const struct ofport_dpif *port, struct action_xlate_ctx *ctx)
{
- if (port->up.opp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
- ? htonl(OFPPC_NO_RECV_STP)
- : htonl(OFPPC_NO_RECV))) {
+ if (port->up.pp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
+ ? OFPUTIL_PC_NO_RECV_STP
+ : OFPUTIL_PC_NO_RECV)) {
return false;
}
#include "heap.h"
#include "list.h"
#include "ofp-errors.h"
+#include "ofp-util.h"
#include "shash.h"
#include "timeval.h"
struct ofproto *ofproto; /* The ofproto that contains this port. */
struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
struct netdev *netdev;
- struct ofp_phy_port opp;
+ struct ofputil_phy_port pp;
uint16_t ofp_port; /* OpenFlow port number. */
unsigned int change_seq;
int mtu;
};
-void ofproto_port_set_state(struct ofport *, ovs_be32 state);
+void ofproto_port_set_state(struct ofport *, enum ofputil_port_state);
enum oftable_flags {
OFTABLE_HIDDEN = 1 << 0, /* Hide from most OpenFlow operations. */
* otherwise.
*
* The implementation should store in '*actions' a bitmap of the supported
- * OpenFlow actions: the bit with value (1 << n) should be set to 1 if the
- * implementation supports the action with value 'n', and to 0 otherwise.
- * For example, if the implementation supports the OFPAT_OUTPUT and
- * OFPAT_ENQUEUE actions, but no others, it would set '*actions' to (1 <<
- * OFPAT_OUTPUT) | (1 << OFPAT_ENQUEUE). Vendor actions are not included
- * in '*actions'. */
+ * OpenFlow actions. Vendor actions are not included in '*actions'. */
void (*get_features)(struct ofproto *ofproto,
- bool *arp_match_ip, uint32_t *actions);
+ bool *arp_match_ip,
+ enum ofputil_action_bitmap *actions);
/* Helper for the OpenFlow OFPST_TABLE statistics request.
*
* function may use a null pointer. */
void (*port_modified)(struct ofport *ofport);
- /* Called after an OpenFlow OFPT_PORT_MOD request changes a port's
- * configuration. 'ofport->opp.config' contains the new configuration.
- * 'old_config' contains the previous configuration.
+ /* Called after an OpenFlow request changes a port's configuration.
+ * 'ofport->pp.config' contains the new configuration. 'old_config'
+ * contains the previous configuration.
*
- * The caller implements OFPPC_PORT_DOWN using netdev functions to turn
- * NETDEV_UP on and off, so this function doesn't have to do anything for
- * that bit (and it won't be called if that is the only bit that
+ * The caller implements OFPUTIL_PC_PORT_DOWN using netdev functions to
+ * turn NETDEV_UP on and off, so this function doesn't have to do anything
+ * for that bit (and it won't be called if that is the only bit that
* changes). */
- void (*port_reconfigured)(struct ofport *ofport, ovs_be32 old_config);
+ void (*port_reconfigured)(struct ofport *ofport,
+ enum ofputil_port_config old_config);
/* Looks up a port named 'devname' in 'ofproto'. On success, initializes
* '*port' appropriately.
/* 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)
{
- enum netdev_features 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 = ofputil_netdev_port_features_to_ofp10(curr);
- opp->advertised = ofputil_netdev_port_features_to_ofp10(advertised);
- opp->supported = ofputil_netdev_port_features_to_ofp10(supported);
- opp->peer = ofputil_netdev_port_features_to_ofp10(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;
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));
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);
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
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);
}
}
}
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 << OFPAT10_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;
}
}
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) {
- enum netdev_features adv;
-
- adv = ofputil_netdev_port_features_from_ofp10(opm->advertise);
- netdev_set_advertisements(port->netdev, adv);
+ 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));
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));
])
AT_CLEANUP
-AT_SETUP([OFPT_FEATURES_REPLY])
+AT_SETUP([OFPT_FEATURES_REPLY - OF1.0])
AT_KEYWORDS([ofp-print])
AT_CHECK([ovs-ofctl ofp-print "\
01 06 00 e0 00 00 00 01 00 00 50 54 00 00 00 01 \
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 \
00 00 02 08 00 00 02 8f 00 00 02 8f 00 00 00 00 \
"], [0], [dnl
-OFPT_FEATURES_REPLY (xid=0x1): ver:0x1, dpid:0000505400000001
+OFPT_FEATURES_REPLY (xid=0x1): dpid:0000505400000001
n_tables:2, n_buffers:256
-features: capabilities:0x87, actions:0xfff
+capabilities: FLOW_STATS TABLE_STATS PORT_STATS ARP_MATCH_IP
+actions: OUTPUT SET_VLAN_VID SET_VLAN_PCP STRIP_VLAN SET_DL_SRC SET_DL_DST SET_NW_SRC SET_NW_DST SET_NW_TOS SET_TP_SRC SET_TP_DST ENQUEUE
1(eth1): addr:50:54:00:00:00:02
config: 0
state: 0
current: 100MB-FD AUTO_NEG
advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
2(eth2): addr:50:54:00:00:00:03
config: 0
state: 0
current: 100MB-FD AUTO_NEG
advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
3(eth0): addr:50:54:00:00:00:01
config: 0
state: 0
current: 100MB-FD AUTO_NEG
advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
LOCAL(br0): addr:50:54:00:00:00:01
config: PORT_DOWN
state: LINK_DOWN
+ speed: 100 Mbps now, 100 Mbps max
])
AT_CLEANUP
-AT_SETUP([OFPT_FEATURES_REPLY cut off mid-port])
+AT_SETUP([OFPT_FEATURES_REPLY cut off mid-port - OF1.0])
AT_KEYWORDS([ofp-print])
AT_CHECK([ovs-ofctl ofp-print "\
01 06 00 dc 00 00 00 01 00 00 50 54 00 00 00 01 \
])
AT_CLEANUP
+AT_SETUP([OFPT_FEATURES_REPLY - OF1.1])
+AT_KEYWORDS([ofp-print])
+AT_CHECK([ovs-ofctl ofp-print "\
+02 06 00 a0 00 00 00 01 00 00 50 54 00 00 00 01 \
+00 00 01 00 02 00 00 00 00 00 00 87 00 00 ff ff \
+ff ff ff fe 00 00 00 00 50 54 00 00 00 01 00 00 \
+62 72 30 00 00 00 00 00 00 00 00 00 00 00 00 00 \
+00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 \
+00 00 00 00 00 00 00 00 00 01 86 a0 00 01 86 a0 \
+00 00 00 03 00 00 00 00 50 54 00 00 00 01 00 00 \
+65 74 68 30 00 00 00 00 00 00 00 00 00 00 00 00 \
+00 00 00 00 00 00 00 00 00 00 20 08 00 00 28 0f \
+00 00 28 0f 00 00 00 00 00 01 86 a0 00 01 86 a0 \
+"], [0], [dnl
+OFPT_FEATURES_REPLY (OF1.1) (xid=0x1): dpid:0000505400000001
+n_tables:2, n_buffers:256
+capabilities: FLOW_STATS TABLE_STATS PORT_STATS ARP_MATCH_IP
+actions: OUTPUT SET_VLAN_VID SET_VLAN_PCP SET_DL_SRC SET_DL_DST SET_NW_SRC SET_NW_DST SET_NW_ECN SET_NW_TOS SET_TP_SRC SET_TP_DST COPY_TTL_OUT COPY_TTL_IN SET_MPLS_LABEL SET_MPLS_TC SET_MPLS_TTL
+ 3(eth0): addr:50:54:00:00:00:01
+ config: 0
+ state: 0
+ current: 100MB-FD AUTO_NEG
+ advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
+ LOCAL(br0): addr:50:54:00:00:00:01
+ config: PORT_DOWN
+ state: LINK_DOWN
+ speed: 100 Mbps now, 100 Mbps max
+])
+AT_CLEANUP
+
+AT_SETUP([OFPT_FEATURES_REPLY cut off mid-port - OF1.1])
+AT_KEYWORDS([ofp-print])
+AT_CHECK([ovs-ofctl ofp-print "\
+02 06 00 90 00 00 00 01 00 00 50 54 00 00 00 01 \
+00 00 01 00 02 00 00 00 00 00 00 87 00 00 ff ff \
+ff ff ff fe 00 00 00 00 50 54 00 00 00 01 00 00 \
+62 72 30 00 00 00 00 00 00 00 00 00 00 00 00 00 \
+00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 \
+00 00 00 00 00 00 00 00 00 01 86 a0 00 01 86 a0 \
+00 00 00 03 00 00 00 00 50 54 00 00 00 01 00 00 \
+65 74 68 30 00 00 00 00 00 00 00 00 00 00 00 00 \
+00 00 00 00 00 00 00 00 00 00 20 08 00 00 28 0f \
+"], [0], [dnl
+***decode error: OFPBRC_BAD_LEN***
+00000000 02 06 00 90 00 00 00 01-00 00 50 54 00 00 00 01 |..........PT....|
+00000010 00 00 01 00 02 00 00 00-00 00 00 87 00 00 ff ff |................|
+00000020 ff ff ff fe 00 00 00 00-50 54 00 00 00 01 00 00 |........PT......|
+00000030 62 72 30 00 00 00 00 00-00 00 00 00 00 00 00 00 |br0.............|
+00000040 00 00 00 01 00 00 00 01-00 00 00 00 00 00 00 00 |................|
+00000050 00 00 00 00 00 00 00 00-00 01 86 a0 00 01 86 a0 |................|
+00000060 00 00 00 03 00 00 00 00-50 54 00 00 00 01 00 00 |........PT......|
+00000070 65 74 68 30 00 00 00 00-00 00 00 00 00 00 00 00 |eth0............|
+00000080 00 00 00 00 00 00 00 00-00 00 20 08 00 00 28 0f |.......... ...@{:@.|
+], [stderr])
+AT_CHECK([sed 's/.*|//' stderr], [0], [dnl
+received OFPT_FEATURES_REPLY with incorrect length 144 (must be exactly 32 bytes or longer by an integer multiple of 64 bytes)
+])
+AT_CLEANUP
+
AT_SETUP([OFPT_GET_CONFIG_REQUEST])
AT_KEYWORDS([ofp-print])
AT_CHECK([ovs-ofctl ofp-print '0107000800000001'], [0], [dnl
])
AT_CLEANUP
-AT_SETUP([OFPT_PORT_STATUS])
+AT_SETUP([OFPT_PORT_STATUS - OF1.0])
AT_KEYWORDS([ofp-print])
AT_CHECK([ovs-ofctl ofp-print "\
01 0c 00 40 00 00 00 00 02 00 00 00 00 00 00 00 \
current: 100MB-FD AUTO_NEG
advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
+])
+AT_CLEANUP
+
+AT_SETUP([OFPT_PORT_STATUS - OF1.1])
+AT_KEYWORDS([ofp-print])
+AT_CHECK([ovs-ofctl ofp-print "\
+02 0c 00 50 00 00 00 00 02 00 00 00 00 00 00 00 \
+00 00 00 03 00 00 00 00 50 54 00 00 00 01 00 00 \
+65 74 68 30 00 00 00 00 00 00 00 00 00 00 00 00 \
+00 00 00 00 00 00 00 00 00 00 20 08 00 00 28 0f \
+00 00 28 0f 00 00 00 00 00 01 86 a0 00 01 86 a0 \
+"], [0], [dnl
+OFPT_PORT_STATUS (OF1.1) (xid=0x0): MOD: 3(eth0): addr:50:54:00:00:00:01
+ config: 0
+ state: 0
+ current: 100MB-FD AUTO_NEG
+ advertised: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ supported: 10MB-HD 10MB-FD 100MB-HD 100MB-FD COPPER AUTO_NEG
+ speed: 100 Mbps now, 100 Mbps max
])
AT_CLEANUP
])
AT_CLEANUP
-AT_SETUP([OFPT_PORT_MOD])
+AT_SETUP([OFPT_PORT_MOD - OF1.0])
AT_KEYWORDS([ofp-print])
AT_CHECK([ovs-ofctl ofp-print "\
01 0f 00 20 00 00 00 03 00 03 50 54 00 00 00 01 \
00 00 00 01 00 00 00 01 00 00 00 00 00 00 00 00 \
" 3], [0], [dnl
-OFPT_PORT_MOD (xid=0x3):port: 3: addr:50:54:00:00:00:01, config: 0x1, mask:0x1
+OFPT_PORT_MOD (xid=0x3):port: 3: addr:50:54:00:00:00:01
+ config: PORT_DOWN
+ mask: PORT_DOWN
+ advertise: UNCHANGED
+])
+AT_CLEANUP
+
+AT_SETUP([OFPT_PORT_MOD - OF1.1])
+AT_KEYWORDS([ofp-print])
+AT_CHECK([ovs-ofctl ofp-print "\
+02 10 00 28 00 00 00 03 00 00 00 03 00 00 00 00 \
+50 54 00 00 00 01 00 00 00 00 00 01 00 00 00 01 \
+00 00 00 00 00 00 00 00 \
+" 3], [0], [dnl
+OFPT_PORT_MOD (OF1.1) (xid=0x3):port: 3: addr:50:54:00:00:00:01
+ config: PORT_DOWN
+ mask: PORT_DOWN
advertise: UNCHANGED
])
AT_CLEANUP
OVS_VSWITCHD_START
AT_CHECK([ovs-ofctl -vANY:ANY:WARN show br0], [0], [stdout])
AT_CHECK([STRIP_XIDS stdout], [0], [dnl
-OFPT_FEATURES_REPLY: ver:0x1, dpid:fedcba9876543210
+OFPT_FEATURES_REPLY: dpid:fedcba9876543210
n_tables:255, n_buffers:256
-features: capabilities:0xc7, actions:0xfff
+capabilities: FLOW_STATS TABLE_STATS PORT_STATS QUEUE_STATS ARP_MATCH_IP
+actions: OUTPUT SET_VLAN_VID SET_VLAN_PCP STRIP_VLAN SET_DL_SRC SET_DL_DST SET_NW_SRC SET_NW_DST SET_NW_TOS SET_TP_SRC SET_TP_DST ENQUEUE
LOCAL(br0): addr:aa:55:aa:55:00:00
config: PORT_DOWN
state: LINK_DOWN
+ speed: 100 Mbps now, 100 Mbps max
OFPT_GET_CONFIG_REPLY: frags=normal miss_send_len=0
])
OVS_VSWITCHD_STOP
AT_CHECK([ovs-ofctl -vANY:ANY:WARN mod-port br0 br0 $command])
AT_CHECK([ovs-ofctl -vANY:ANY:WARN show br0], [0], [stdout])
AT_CHECK_UNQUOTED([STRIP_XIDS stdout], [0], [dnl
-OFPT_FEATURES_REPLY: ver:0x1, dpid:fedcba9876543210
+OFPT_FEATURES_REPLY: dpid:fedcba9876543210
n_tables:255, n_buffers:256
-features: capabilities:0xc7, actions:0xfff
+capabilities: FLOW_STATS TABLE_STATS PORT_STATS QUEUE_STATS ARP_MATCH_IP
+actions: OUTPUT SET_VLAN_VID SET_VLAN_PCP STRIP_VLAN SET_DL_SRC SET_DL_DST SET_NW_SRC SET_NW_DST SET_NW_TOS SET_TP_SRC SET_TP_DST ENQUEUE
LOCAL(br0): addr:aa:55:aa:55:00:00
config: $config
state: $state
+ speed: 100 Mbps now, 100 Mbps max
OFPT_GET_CONFIG_REPLY: frags=normal miss_send_len=0
])
done
if test X"$1" = X"OFPPR_ADD"; then shift;
echo >>expout "OFPT_PORT_STATUS: ADD: 1(test): addr:aa:55:aa:55:00:0x
config: PORT_DOWN
- state: LINK_DOWN"
+ state: LINK_DOWN
+ speed: 100 Mbps now, 100 Mbps max"
fi
# OFPT_PORT_STATUS, OFPPR_DELETE
if test X"$1" = X"OFPPR_DELETE"; then shift;
echo >>expout "OFPT_PORT_STATUS: DEL: 1(test): addr:aa:55:aa:55:00:0x
config: PORT_DOWN
- state: LINK_DOWN"
+ state: LINK_DOWN
+ speed: 100 Mbps now, 100 Mbps max"
fi
# OFPT_FLOW_REMOVED, OFPRR_DELETE
dump_trivial_stats_transaction(argv[1], OFPST_TABLE);
}
-/* Opens a connection to 'vconn_name', fetches the ofp_phy_port structure for
+/* Opens a connection to 'vconn_name', fetches the port structure for
* 'port_name' (which may be a port name or number), and copies it into
* '*oppp'. */
static void
-fetch_ofp_phy_port(const char *vconn_name, const char *port_name,
- struct ofp_phy_port *oppp)
+fetch_ofputil_phy_port(const char *vconn_name, const char *port_name,
+ struct ofputil_phy_port *pp)
{
+ struct ofputil_switch_features features;
+ const struct ofp_switch_features *osf;
struct ofpbuf *request, *reply;
- struct ofp_switch_features *osf;
unsigned int port_no;
struct vconn *vconn;
- int n_ports;
- int port_idx;
+ enum ofperr error;
+ struct ofpbuf b;
/* Try to interpret the argument as a port number. */
if (!str_to_uint(port_name, 10, &port_no)) {
ovs_fatal(0, "%s: received too-short features reply (only %zu bytes)",
vconn_name, reply->size);
}
- n_ports = (reply->size - sizeof *osf) / sizeof *osf->ports;
-
- for (port_idx = 0; port_idx < n_ports; port_idx++) {
- const struct ofp_phy_port *opp = &osf->ports[port_idx];
+ error = ofputil_decode_switch_features(osf, &features, &b);
+ if (error) {
+ ovs_fatal(0, "%s: failed to decode features reply (%s)",
+ vconn_name, ofperr_to_string(error));
+ }
+ while (!ofputil_pull_switch_features_port(&b, pp)) {
if (port_no != UINT_MAX
- ? htons(port_no) == opp->port_no
- : !strncmp(opp->name, port_name, sizeof opp->name)) {
- *oppp = *opp;
+ ? port_no == pp->port_no
+ : !strcmp(pp->name, port_name)) {
ofpbuf_delete(reply);
vconn_close(vconn);
return;
if (str_to_uint(port_name, 10, &port_no)) {
return port_no;
} else {
- struct ofp_phy_port opp;
+ struct ofputil_phy_port pp;
- fetch_ofp_phy_port(vconn_name, port_name, &opp);
- return ntohs(opp.port_no);
+ fetch_ofputil_phy_port(vconn_name, port_name, &pp);
+ return pp.port_no;
}
}
static void
do_mod_port(int argc OVS_UNUSED, char *argv[])
{
- struct ofp_port_mod *opm;
- struct ofp_phy_port opp;
- struct ofpbuf *request;
+ enum ofputil_protocol protocol;
+ struct ofputil_port_mod pm;
+ struct ofputil_phy_port pp;
struct vconn *vconn;
- fetch_ofp_phy_port(argv[1], argv[2], &opp);
+ fetch_ofputil_phy_port(argv[1], argv[2], &pp);
- opm = make_openflow(sizeof(struct ofp_port_mod), OFPT10_PORT_MOD,
- &request);
- opm->port_no = opp.port_no;
- memcpy(opm->hw_addr, opp.hw_addr, sizeof opm->hw_addr);
- opm->config = htonl(0);
- opm->mask = htonl(0);
- opm->advertise = htonl(0);
+ pm.port_no = pp.port_no;
+ memcpy(pm.hw_addr, pp.hw_addr, ETH_ADDR_LEN);
+ pm.config = 0;
+ pm.mask = 0;
+ pm.advertise = 0;
if (!strcasecmp(argv[3], "up")) {
- opm->mask |= htonl(OFPPC_PORT_DOWN);
+ pm.mask |= OFPUTIL_PC_PORT_DOWN;
} else if (!strcasecmp(argv[3], "down")) {
- opm->mask |= htonl(OFPPC_PORT_DOWN);
- opm->config |= htonl(OFPPC_PORT_DOWN);
+ pm.mask |= OFPUTIL_PC_PORT_DOWN;
+ pm.config |= OFPUTIL_PC_PORT_DOWN;
} else if (!strcasecmp(argv[3], "flood")) {
- opm->mask |= htonl(OFPPC_NO_FLOOD);
+ pm.mask |= OFPUTIL_PC_NO_FLOOD;
} else if (!strcasecmp(argv[3], "noflood")) {
- opm->mask |= htonl(OFPPC_NO_FLOOD);
- opm->config |= htonl(OFPPC_NO_FLOOD);
+ pm.mask |= OFPUTIL_PC_NO_FLOOD;
+ pm.config |= OFPUTIL_PC_NO_FLOOD;
} else if (!strcasecmp(argv[3], "forward")) {
- opm->mask |= htonl(OFPPC_NO_FWD);
+ pm.mask |= OFPUTIL_PC_NO_FWD;
} else if (!strcasecmp(argv[3], "noforward")) {
- opm->mask |= htonl(OFPPC_NO_FWD);
- opm->config |= htonl(OFPPC_NO_FWD);
+ pm.mask |= OFPUTIL_PC_NO_FWD;
+ pm.config |= OFPUTIL_PC_NO_FWD;
} else {
ovs_fatal(0, "unknown mod-port command '%s'", argv[3]);
}
- open_vconn(argv[1], &vconn);
- transact_noreply(vconn, request);
+ protocol = open_vconn(argv[1], &vconn);
+ transact_noreply(vconn, ofputil_encode_port_mod(&pm, protocol));
vconn_close(vconn);
}
projects / openvswitch / commitdiff