X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=include%2Fopenflow.h;h=e34c60188aa9f7549ff8fe899d29e683c8f8a9f1;hb=9da88ee2ad791e259a8c88ba2fc116830293aaf5;hp=6303b490070e837490cbda078c3b0db8f11e91da;hpb=59ba307325ee2f9c6e1fe80f4c8a2fac7f6b32f2;p=sliver-openvswitch.git diff --git a/include/openflow.h b/include/openflow.h index 6303b4900..e34c60188 100644 --- a/include/openflow.h +++ b/include/openflow.h @@ -42,15 +42,28 @@ #include #endif -/* Maximum length of a OpenFlow packet. */ -#define OFP_MAXLEN (sizeof(struct ofp_switch_features) \ - + (sizeof(struct ofp_phy_port) * OFPP_MAX) + 200) - +#ifdef SWIG +#define OFP_ASSERT(EXPR) /* SWIG can't handle OFP_ASSERT. */ +#elif !defined(__cplusplus) +/* Build-time assertion for use in a declaration context. */ +#define OFP_ASSERT(EXPR) \ + extern int (*build_assert(void))[ sizeof(struct { \ + unsigned int build_assert_failed : (EXPR) ? 1 : -1; })] +#else /* __cplusplus */ +#include +#define OFP_ASSERT BOOST_STATIC_ASSERT +#endif /* __cplusplus */ + +#ifndef SWIG +#define OFP_PACKED __attribute__((packed)) +#else +#define OFP_PACKED /* SWIG doesn't understand __attribute. */ +#endif /* The most significant bit being set in the version field indicates an * experimental OpenFlow version. */ -#define OFP_VERSION 0x83 +#define OFP_VERSION 0x93 #define OFP_MAX_TABLE_NAME_LEN 32 #define OFP_MAX_PORT_NAME_LEN 16 @@ -63,13 +76,16 @@ /* Port numbering. Physical ports are numbered starting from 0. */ enum ofp_port { /* Maximum number of physical switch ports. */ - OFPP_MAX = 0x100, + OFPP_MAX = 255, /* Fake output "ports". */ + OFPP_IN_PORT = 0xfff8, /* Send the packet out the input port. This + virtual port must be explicitly used + in order to send back out of the input + port. */ OFPP_TABLE = 0xfff9, /* Perform actions in flow table. - * NB: This can only be the destination - * port for packet-out messages. - */ + NB: This can only be the destination + port for packet-out messages. */ OFPP_NORMAL = 0xfffa, /* Process with normal L2/L3 switching. */ OFPP_FLOOD = 0xfffb, /* All physical ports except input port and those disabled by STP. */ @@ -80,21 +96,34 @@ enum ofp_port { }; enum ofp_type { - OFPT_FEATURES_REQUEST, /* 0 Controller/switch message */ - OFPT_FEATURES_REPLY, /* 1 Controller/switch message */ - OFPT_GET_CONFIG_REQUEST, /* 2 Controller/switch message */ - OFPT_GET_CONFIG_REPLY, /* 3 Controller/switch message */ - OFPT_SET_CONFIG, /* 4 Controller/switch message */ - OFPT_PACKET_IN, /* 5 Async message */ - OFPT_PACKET_OUT, /* 6 Controller/switch message */ - OFPT_FLOW_MOD, /* 7 Controller/switch message */ - OFPT_FLOW_EXPIRED, /* 8 Async message */ - OFPT_TABLE, /* 9 Controller/switch message */ - OFPT_PORT_MOD, /* 10 Controller/switch message */ - OFPT_PORT_STATUS, /* 11 Async message */ - OFPT_ERROR_MSG, /* 12 Async message */ - OFPT_STATS_REQUEST, /* 13 Controller/switch message */ - OFPT_STATS_REPLY /* 14 Controller/switch message */ + /* Immutable messages. */ + OFPT_HELLO, /* Symmetric message */ + OFPT_ERROR, /* Symmetric message */ + OFPT_ECHO_REQUEST, /* Symmetric message */ + OFPT_ECHO_REPLY, /* Symmetric message */ + OFPT_VENDOR, /* Symmetric message */ + + /* Switch configuration messages. */ + OFPT_FEATURES_REQUEST, /* Controller/switch message */ + OFPT_FEATURES_REPLY, /* Controller/switch message */ + OFPT_GET_CONFIG_REQUEST, /* Controller/switch message */ + OFPT_GET_CONFIG_REPLY, /* Controller/switch message */ + OFPT_SET_CONFIG, /* Controller/switch message */ + + /* Asynchronous messages. */ + OFPT_PACKET_IN, /* Async message */ + OFPT_FLOW_EXPIRED, /* Async message */ + OFPT_PORT_STATUS, /* Async message */ + + /* Controller command messages. */ + OFPT_PACKET_OUT, /* Controller/switch message */ + OFPT_FLOW_MOD, /* Controller/switch message */ + OFPT_PORT_MOD, /* Controller/switch message */ + OFPT_TABLE, /* Controller/switch message */ + + /* Statistics messages. */ + OFPT_STATS_REQUEST, /* Controller/switch message */ + OFPT_STATS_REPLY /* Controller/switch message */ }; /* Header on all OpenFlow packets. */ @@ -106,12 +135,25 @@ struct ofp_header { 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 { + struct ofp_header header; +}; #define OFP_DEFAULT_MISS_SEND_LEN 128 enum ofp_config_flags { /* Tells datapath to notify the controller of expired flow entries. */ - OFPC_SEND_FLOW_EXP = 1 << 0 + OFPC_SEND_FLOW_EXP = 1 << 0, + + /* Handling of IP fragments. */ + OFPC_FRAG_NORMAL = 0 << 1, /* No special handling for fragments. */ + OFPC_FRAG_DROP = 1 << 1, /* Drop fragments. */ + OFPC_FRAG_REASM = 2 << 1, /* Reassemble (only if OFPC_IP_REASM set). */ + OFPC_FRAG_MASK = 3 << 1 }; /* Switch configuration. */ @@ -121,43 +163,84 @@ struct ofp_switch_config { uint16_t miss_send_len; /* Max bytes of new flow that datapath should send to the controller. */ }; +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.11d spanning tree. */ - OFPC_MULTI_PHY_TX = 1 << 4 /* Supports transmitting through multiple - physical interfaces */ + 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_MULTI_PHY_TX = 1 << 4, /* Supports transmitting through multiple + physical interfaces */ + OFPC_IP_REASM = 1 << 5 /* Can reassemble IP fragments. */ +}; + +/* 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 most packets received on port. */ + 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. */ }; -/* Flags to indicate behavior of the physical port */ -enum ofp_port_flags { - OFPPFL_NO_FLOOD = 1 << 0, /* Do not include this port when flooding */ +/* 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. */ + + /* The OFPPFL_STP_* bits have no effect on switch operation. The + * controller must adjust OFPPFL_NO_RECV, OFPPFL_NO_FWD, and + * OFPPFL_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 OFPPFL_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_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 */ }; - /* Description of a physical port */ struct ofp_phy_port { uint16_t port_no; uint8_t hw_addr[OFP_ETH_ALEN]; uint8_t name[OFP_MAX_PORT_NAME_LEN]; /* Null-terminated */ - uint32_t flags; /* Bitmap of "ofp_port_flags". */ - uint32_t speed; /* Current speed in Mbps */ - uint32_t features; /* Bitmap of supported "ofp_port_features"s. */ + + uint32_t config; /* Bitmap of OFPPC_* flags. */ + uint32_t state; /* Bitmap of OFPPS_* flags. */ + + /* Bitmaps of OFPPF_* that describe features. All bits zeroed if + * unsupported or unavailable. */ + uint32_t curr; /* Current features. */ + uint32_t advertised; /* Features being advertised by the port. */ + uint32_t supported; /* Features supported by the port. */ + uint32_t peer; /* Features advertised by peer. */ }; +OFP_ASSERT(sizeof(struct ofp_phy_port) == 48); /* Switch features. */ struct ofp_switch_features { @@ -165,48 +248,59 @@ struct ofp_switch_features { uint64_t datapath_id; /* Datapath unique ID. Only the lower 48-bits are meaningful. */ - /* Table info. */ - uint32_t n_exact; /* Max exact-match table entries. */ - uint32_t n_compression; /* Max entries compressed on service port. */ - uint32_t n_general; /* Max entries of arbitrary form. */ - - /* Buffer limits. A datapath that cannot buffer reports 0.*/ - uint32_t buffer_mb; /* Space for buffering packets, in MB. */ uint32_t 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. */ uint32_t capabilities; /* Bitmap of support "ofp_capabilities". */ uint32_t actions; /* Bitmap of supported "ofp_action_type"s. */ /* Port info.*/ - struct ofp_phy_port ports[0]; /* Port definitions. The number of ports + 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 phsyical port */ +/* What changed about the physical port */ enum ofp_port_reason { OFPPR_ADD, /* The port was added */ OFPPR_DELETE, /* The port was removed */ - OFPPR_MOD /* Some attribute of the port has changed */ + 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[3]; /* Align to 32-bits */ + uint8_t pad[7]; /* Align to 64-bits */ struct ofp_phy_port desc; }; +OFP_ASSERT(sizeof(struct ofp_port_status) == 64); /* Modify behavior of the physical port */ struct ofp_port_mod { struct ofp_header header; - struct ofp_phy_port desc; + uint16_t 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. */ + + uint32_t config; /* Bitmap of OFPPC_* flags. */ + uint32_t mask; /* Bitmap of OFPPC_* flags to be changed. */ + + uint32_t advertise; /* Bitmap of "ofp_port_features"s. Zero all + bits to prevent any action taking place. */ + uint8_t pad[4]; /* Pad to 64-bits. */ }; +OFP_ASSERT(sizeof(struct ofp_port_mod) == 32); /* Why is this packet being sent to the controller? */ -enum ofp_reason { +enum ofp_packet_in_reason { OFPR_NO_MATCH, /* No matching flow. */ OFPR_ACTION /* Action explicitly output to controller. */ }; @@ -226,6 +320,7 @@ struct ofp_packet_in { offsetof(struct ofp_packet_in, data) == sizeof(struct ofp_packet_in) - 2. */ }; +OFP_ASSERT(sizeof(struct ofp_packet_in) == 20); enum ofp_action_type { OFPAT_OUTPUT, /* Output to switch port. */ @@ -245,6 +340,7 @@ struct ofp_action_output { uint16_t max_len; uint16_t port; }; +OFP_ASSERT(sizeof(struct ofp_action_output) == 4); /* The VLAN id is 12-bits, so we'll use the entire 16 bits to indicate * special conditions. All ones is used to indicate that no VLAN id was @@ -259,25 +355,29 @@ struct ofp_action { struct ofp_action_output output; /* OFPAT_OUTPUT: output struct. */ uint16_t vlan_id; /* OFPAT_SET_DL_VLAN: VLAN id. */ uint8_t dl_addr[OFP_ETH_ALEN]; /* OFPAT_SET_DL_SRC/DST */ - uint32_t nw_addr; /* OFPAT_SET_NW_SRC/DST */ + uint32_t nw_addr OFP_PACKED; /* OFPAT_SET_NW_SRC/DST */ uint16_t tp; /* OFPAT_SET_TP_SRC/DST */ } arg; }; +OFP_ASSERT(sizeof(struct ofp_action) == 8); /* Send packet (controller -> datapath). */ struct ofp_packet_out { struct ofp_header header; - uint32_t buffer_id; /* ID assigned by datapath (-1 if none). */ - uint16_t in_port; /* Packet's input port (OFPP_NONE if none). */ - uint16_t out_port; /* Output port (if buffer_id == -1). */ - union { - struct ofp_action actions[0]; /* buffer_id != -1 */ - uint8_t data[0]; /* buffer_id == -1 */ - } u; + uint32_t buffer_id; /* ID assigned by datapath (-1 if none). */ + uint16_t in_port; /* Packet's input port (OFPP_NONE if none). */ + uint16_t n_actions; /* Number of actions. */ + struct ofp_action actions[0]; /* Actions. */ + /* uint8_t data[0]; */ /* Packet data. The length is inferred + from the length field in the header. + (Only meaningful if buffer_id == -1.) */ }; +OFP_ASSERT(sizeof(struct ofp_packet_out) == 16); enum ofp_flow_mod_command { OFPFC_ADD, /* New flow. */ + OFPFC_MODIFY, /* Modify all matching flows. */ + OFPFC_MODIFY_STRICT, /* Modify entry strictly matching wildcards */ OFPFC_DELETE, /* Delete all matching flows. */ OFPFC_DELETE_STRICT /* Strictly match wildcards and priority. */ }; @@ -289,12 +389,27 @@ enum ofp_flow_wildcards { OFPFW_DL_SRC = 1 << 2, /* Ethernet source address. */ OFPFW_DL_DST = 1 << 3, /* Ethernet destination address. */ OFPFW_DL_TYPE = 1 << 4, /* Ethernet frame type. */ - OFPFW_NW_SRC = 1 << 5, /* IP source address. */ - OFPFW_NW_DST = 1 << 6, /* IP destination address. */ - OFPFW_NW_PROTO = 1 << 7, /* IP protocol. */ - OFPFW_TP_SRC = 1 << 8, /* TCP/UDP source port. */ - OFPFW_TP_DST = 1 << 9, /* TCP/UDP destination port. */ - OFPFW_ALL = (1 << 10) - 1 + OFPFW_NW_PROTO = 1 << 5, /* IP protocol. */ + OFPFW_TP_SRC = 1 << 6, /* TCP/UDP source port. */ + OFPFW_TP_DST = 1 << 7, /* TCP/UDP destination port. */ + + /* IP source address wildcard bit count. 0 is exact match, 1 ignores the + * LSB, 2 ignores the 2 least-significant bits, ..., 32 and higher wildcard + * the entire field. This is the *opposite* of the usual convention where + * e.g. /24 indicates that 8 bits (not 24 bits) are wildcarded. */ + OFPFW_NW_SRC_SHIFT = 8, + OFPFW_NW_SRC_BITS = 6, + OFPFW_NW_SRC_MASK = ((1 << OFPFW_NW_SRC_BITS) - 1) << OFPFW_NW_SRC_SHIFT, + OFPFW_NW_SRC_ALL = 32 << OFPFW_NW_SRC_SHIFT, + + /* IP destination address wildcard bit count. Same format as source. */ + OFPFW_NW_DST_SHIFT = 14, + OFPFW_NW_DST_BITS = 6, + OFPFW_NW_DST_MASK = ((1 << OFPFW_NW_DST_BITS) - 1) << OFPFW_NW_DST_SHIFT, + OFPFW_NW_DST_ALL = 32 << OFPFW_NW_DST_SHIFT, + + /* Wildcard all fields. */ + OFPFW_ALL = ((1 << 20) - 1) }; /* Values below this cutoff are 802.3 packets and the two bytes @@ -310,21 +425,23 @@ enum ofp_flow_wildcards { /* Fields to match against flows */ struct ofp_match { - uint16_t wildcards; /* Wildcard fields. */ + uint32_t wildcards; /* Wildcard fields. */ uint16_t in_port; /* Input switch port. */ uint8_t dl_src[OFP_ETH_ALEN]; /* Ethernet source address. */ uint8_t dl_dst[OFP_ETH_ALEN]; /* Ethernet destination address. */ uint16_t dl_vlan; /* Input VLAN. */ uint16_t dl_type; /* Ethernet frame type. */ + uint8_t nw_proto; /* IP protocol. */ + uint8_t pad; /* Align to 32-bits. */ uint32_t nw_src; /* IP source address. */ uint32_t nw_dst; /* IP destination address. */ - uint8_t nw_proto; /* IP protocol. */ - uint8_t pad[3]; /* Align to 32-bits. */ uint16_t tp_src; /* TCP/UDP source port. */ uint16_t tp_dst; /* TCP/UDP destination port. */ }; +OFP_ASSERT(sizeof(struct ofp_match) == 36); -/* Value used in "max_idle" to indicate that the entry is permanent */ +/* Value used in "idle_timeout" and "hard_timeout" to indicate that the entry + * is permanent. */ #define OFP_FLOW_PERMANENT 0 /* By default, choose a priority in the middle */ @@ -337,13 +454,21 @@ struct ofp_flow_mod { /* Flow actions. */ uint16_t command; /* One of OFPFC_*. */ - uint16_t max_idle; /* Idle time before discarding (seconds). */ - uint32_t buffer_id; /* Buffered packet to apply to (or -1). */ + uint16_t idle_timeout; /* Idle time before discarding (seconds). */ + uint16_t hard_timeout; /* Max time before discarding (seconds). */ uint16_t priority; /* Priority level of flow entry. */ - uint8_t pad[2]; /* Align to 32-bits. */ + uint32_t buffer_id; /* Buffered packet to apply to (or -1). + Not meaningful for OFPFC_DELETE*. */ uint32_t reserved; /* Reserved for future use. */ struct ofp_action actions[0]; /* The number of actions is inferred from - the length field in the header. */ + the length field in the header. */ +}; +OFP_ASSERT(sizeof(struct ofp_flow_mod) == 60); + +/* Why did this flow expire? */ +enum ofp_flow_expired_reason { + OFPER_IDLE_TIMEOUT, /* Flow idle time exceeded idle_timeout. */ + OFPER_HARD_TIMEOUT /* Time exceeded hard_timeout. */ }; /* Flow expiration (datapath -> controller). */ @@ -352,14 +477,41 @@ struct ofp_flow_expired { struct ofp_match match; /* Description of fields */ uint16_t priority; /* Priority level of flow entry. */ - uint8_t pad[2]; /* Align to 32-bits. */ + uint8_t reason; /* One of OFPER_*. */ + uint8_t pad[1]; /* Align to 32-bits. */ uint32_t duration; /* Time flow was alive in seconds. */ + uint8_t pad2[4]; /* Align to 64-bits. */ uint64_t packet_count; uint64_t byte_count; }; +OFP_ASSERT(sizeof(struct ofp_flow_expired) == 72); + +/* Values for 'type' in ofp_error_message. These values are immutable: they + * will not change in future versions of the protocol (although new values may + * be added). */ +enum ofp_error_type { + OFPET_HELLO_FAILED, /* Hello protocol failed. */ + OFPET_BAD_REQUEST /* Request was not understood. */ +}; -/* Error message (datapath -> controller). */ +/* ofp_error_msg 'code' values for OFPET_HELLO_FAILED. 'data' contains an + * ASCII text string that may give failure details. */ +enum ofp_hello_failed_code { + OFPHFC_INCOMPATIBLE /* No compatible version. */ +}; + +/* ofp_error_msg 'code' values for OFPET_BAD_REQUEST. 'data' contains at least + * the first 64 bytes of the failed request. */ +enum ofp_bad_request_code { + OFPBRC_BAD_VERSION, /* ofp_header.version not supported. */ + OFPBRC_BAD_TYPE, /* ofp_header.type not supported. */ + OFPBRC_BAD_STAT, /* ofp_stats_request.type not supported. */ + OFPBRC_BAD_VENDOR /* Vendor not supported (in ofp_vendor or + * ofp_stats_request or ofp_stats_reply). */ +}; + +/* OFPT_ERROR: Error message (datapath -> controller). */ struct ofp_error_msg { struct ofp_header header; @@ -368,8 +520,14 @@ struct ofp_error_msg { uint8_t data[0]; /* Variable-length data. Interpreted based on the type and code. */ }; +OFP_ASSERT(sizeof(struct ofp_error_msg) == 12); enum ofp_stats_types { + /* Description of this OpenFlow switch. + * The request body is empty. + * The reply body is struct ofp_desc_stats. */ + OFPST_DESC, + /* Individual flow statistics. * The request body is struct ofp_flow_stats_request. * The reply body is an array of struct ofp_flow_stats. */ @@ -388,7 +546,13 @@ enum ofp_stats_types { /* Physical port statistics. * The request body is empty. * The reply body is an array of struct ofp_port_stats. */ - OFPST_PORT + OFPST_PORT, + + /* Vendor extension. + * The request and reply bodies begin with a 32-bit vendor ID, which takes + * the same form as in "struct ofp_vendor". The request and reply bodies + * are otherwise vendor-defined. */ + OFPST_VENDOR = 0xffff }; struct ofp_stats_request { @@ -397,9 +561,10 @@ struct ofp_stats_request { uint16_t flags; /* OFPSF_REQ_* flags (none yet defined). */ uint8_t body[0]; /* Body of the request. */ }; +OFP_ASSERT(sizeof(struct ofp_stats_request) == 12); enum ofp_stats_reply_flags { - OFPSF_REPLY_MORE = 1 << 0, /* More replies to follow */ + OFPSF_REPLY_MORE = 1 << 0 /* More replies to follow */ }; struct ofp_stats_reply { @@ -408,6 +573,19 @@ struct ofp_stats_reply { uint16_t flags; /* OFPSF_REPLY_* flags. */ uint8_t body[0]; /* Body of the reply. */ }; +OFP_ASSERT(sizeof(struct ofp_stats_reply) == 12); + +#define DESC_STR_LEN 256 +#define SERIAL_NUM_LEN 32 +/* Body of reply to OFPST_DESC request. Each entry is a NULL-terminated + * ASCII string. */ +struct ofp_desc_stats { + char mfr_desc[DESC_STR_LEN]; /* Manufacturer description. */ + char hw_desc[DESC_STR_LEN]; /* Hardware description. */ + char sw_desc[DESC_STR_LEN]; /* Software description. */ + char serial_num[SERIAL_NUM_LEN]; /* Serial number. */ +}; +OFP_ASSERT(sizeof(struct ofp_desc_stats) == 800); /* Body for ofp_stats_request of type OFPST_FLOW. */ struct ofp_flow_stats_request { @@ -416,6 +594,7 @@ struct ofp_flow_stats_request { or 0xff for all tables. */ uint8_t pad[3]; /* Align to 32 bits. */ }; +OFP_ASSERT(sizeof(struct ofp_flow_stats_request) == 40); /* Body of reply to OFPST_FLOW request. */ struct ofp_flow_stats { @@ -424,13 +603,16 @@ struct ofp_flow_stats { uint8_t pad; struct ofp_match match; /* Description of fields. */ uint32_t duration; /* Time flow has been alive in seconds. */ - uint64_t packet_count; /* Number of packets in flow. */ - uint64_t byte_count; /* Number of bytes in flow. */ uint16_t priority; /* Priority of the entry. Only meaningful when this is not an exact-match entry. */ - uint16_t max_idle; /* Number of seconds idle before expiration. */ + uint16_t idle_timeout; /* Number of seconds idle before expiration. */ + uint16_t hard_timeout; /* Number of seconds before expiration. */ + uint16_t pad2[3]; /* Pad to 64 bits. */ + uint64_t packet_count; /* Number of packets in flow. */ + uint64_t byte_count; /* Number of bytes in flow. */ struct ofp_action actions[0]; /* Actions. */ }; +OFP_ASSERT(sizeof(struct ofp_flow_stats) == 72); /* Body for ofp_stats_request of type OFPST_AGGREGATE. */ struct ofp_aggregate_stats_request { @@ -439,31 +621,64 @@ struct ofp_aggregate_stats_request { or 0xff for all tables. */ uint8_t pad[3]; /* Align to 32 bits. */ }; +OFP_ASSERT(sizeof(struct ofp_aggregate_stats_request) == 40); /* Body of reply to OFPST_AGGREGATE request. */ struct ofp_aggregate_stats_reply { uint64_t packet_count; /* Number of packets in flows. */ uint64_t byte_count; /* Number of bytes in flows. */ uint32_t flow_count; /* Number of flows. */ + uint8_t pad[4]; /* Align to 64 bits. */ }; +OFP_ASSERT(sizeof(struct ofp_aggregate_stats_reply) == 24); /* Body of reply to OFPST_TABLE request. */ struct ofp_table_stats { - uint8_t table_id; + uint8_t table_id; /* Identifier of table. Lower numbered tables + are consulted first. */ uint8_t pad[3]; /* Align to 32-bits */ char name[OFP_MAX_TABLE_NAME_LEN]; + uint32_t wildcards; /* Bitmap of OFPFW_* wildcards that are + supported by the table. */ uint32_t max_entries; /* Max number of entries supported */ uint32_t active_count; /* Number of active entries */ + uint64_t lookup_count; /* Number of packets looked up in table */ uint64_t matched_count; /* Number of packets that hit table */ }; +OFP_ASSERT(sizeof(struct ofp_table_stats) == 64); -/* Statistics about a particular port */ +/* Body of reply to OFPST_PORT request. If a counter is unsupported, set + * the field to all ones. */ struct ofp_port_stats { uint16_t port_no; - uint8_t pad[2]; /* Align to 32-bits */ - uint64_t rx_count; /* Number of received packets */ - uint64_t tx_count; /* Number of transmitted packets */ - uint64_t drop_count; /* Number of packets dropped by interface */ -}; + uint8_t pad[6]; /* Align to 64-bits. */ + uint64_t rx_packets; /* Number of received packets. */ + uint64_t tx_packets; /* Number of transmitted packets. */ + uint64_t rx_bytes; /* Number of received bytes. */ + uint64_t tx_bytes; /* Number of transmitted bytes. */ + uint64_t rx_dropped; /* Number of packets dropped by RX. */ + uint64_t tx_dropped; /* Number of packets dropped by TX. */ + uint64_t rx_errors; /* Number of receive errors. This is a super-set + of receive errors and should be great than or + equal to the sum of al rx_*_err values. */ + uint64_t tx_errors; /* Number of transmit errors. This is a super-set + of transmit errors. */ + uint64_t rx_frame_err; /* Number of frame alignment errors. */ + uint64_t rx_over_err; /* Number of packets with RX overrun. */ + uint64_t rx_crc_err; /* Number of CRC errors. */ + uint64_t collisions; /* Number of collisions. */ +}; +OFP_ASSERT(sizeof(struct ofp_port_stats) == 104); + +/* Vendor extension. */ +struct ofp_vendor { + struct ofp_header header; /* Type OFPT_VENDOR. */ + uint32_t vendor; /* Vendor ID: + * - MSB 0: low-order bytes are IEEE OUI. + * - MSB != 0: defined by OpenFlow + * consortium. */ + /* Vendor-defined arbitrary additional data. */ +}; +OFP_ASSERT(sizeof(struct ofp_vendor) == 12); #endif /* openflow.h */