/* Datapath. */
struct hmap ports; /* Contains "struct ofport"s. */
struct shash port_by_name;
+ uint16_t max_ports; /* Max possible OpenFlow port num, plus one. */
/* Flow tables. */
struct oftable *tables;
};
void ofproto_init_tables(struct ofproto *, int n_tables);
+void ofproto_init_max_ports(struct ofproto *, uint16_t max_ports);
struct ofproto *ofproto_lookup(const char *name);
struct ofport *ofproto_get_port(const struct ofproto *, uint16_t ofp_port);
struct ofpact *ofpacts; /* Sequence of "struct ofpacts". */
unsigned int ofpacts_len; /* Size of 'ofpacts', in bytes. */
+
+ /* Flow monitors. */
+ enum nx_flow_monitor_flags monitor_flags;
+ uint64_t add_seqno; /* Sequence number when added. */
+ uint64_t modify_seqno; /* Sequence number when changed. */
};
static inline struct rule *
void ofproto_rule_expire(struct rule *, uint8_t reason);
void ofproto_rule_destroy(struct rule *);
+bool ofproto_rule_has_out_port(const struct rule *, uint16_t out_port);
+
void ofoperation_complete(struct ofoperation *, enum ofperr);
struct rule *ofoperation_get_victim(struct ofoperation *);
+bool ofoperation_has_out_port(const struct ofoperation *, uint16_t out_port);
+
+bool ofproto_rule_is_hidden(const struct rule *);
+
/* ofproto class structure, to be defined by each ofproto implementation.
*
*
* ->construct() should delete flows from the underlying datapath, if
* necessary, rather than populating the tables.
*
+ * If the ofproto knows the maximum port number that the datapath can have,
+ * then it can call ofproto_init_max_ports(). If it does so, then the
+ * client will ensure that the actions it allows to be used through
+ * OpenFlow do not refer to ports above that maximum number.
+ *
* Only one ofproto instance needs to be supported for any given datapath.
* If a datapath is already open as part of one "ofproto", then another
* attempt to "construct" the same datapath as part of another ofproto is
* - Call ofproto_rule_expire() for each OpenFlow flow that has reached
* its hard_timeout or idle_timeout, to expire the flow.
*
+ * (But rules that are part of a pending operation, e.g. rules for
+ * which ->pending is true, may not expire.)
+ *
* Returns 0 if successful, otherwise a positive errno value. */
int (*run)(struct ofproto *ofproto);
* - 'matched_count' to the number of packets looked up in this flow
* table so far that matched one of the flow entries.
*
- * Keep in mind that all of the members of struct ofp_table_stats are in
+ * Keep in mind that all of the members of struct ofp10_table_stats are in
* network byte order.
*/
- void (*get_tables)(struct ofproto *ofproto, struct ofp_table_stats *ots);
+ void (*get_tables)(struct ofproto *ofproto, struct ofp10_table_stats *ots);
/* ## ---------------- ## */
/* ## ofport Functions ## */
* registers, then it is an error if 'rule->cr' does not wildcard all
* registers.
*
- * - Validate that 'rule->ofpacts' is a sequence of well-formed actions
- * that the datapath can correctly implement. If your ofproto
- * implementation only implements a subset of the actions that Open
- * vSwitch understands, then you should implement your own action
- * validation.
+ * - Validate that the datapath can correctly implement 'rule->ofpacts'.
*
* - If the rule is valid, update the datapath flow table, adding the new
* rule or replacing the existing one.
*
* ->rule_modify_actions() should set the following in motion:
*
- * - Validate that the actions now in 'rule' are well-formed OpenFlow
- * actions that the datapath can correctly implement.
+ * - Validate that the datapath can correctly implement the actions now
+ * in 'rule'.
*
* - Update the datapath flow table with the new actions.
*
* The caller retains ownership of 'packet' and of 'ofpacts', so
* ->packet_out() should not modify or free them.
*
- * This function must validate that it can implement 'ofpacts'. If not,
- * then it should return an OpenFlow error code.
+ * This function must validate that it can correctly implement 'ofpacts'.
+ * If not, then it should return an OpenFlow error code.
*
* 'flow' reflects the flow information for 'packet'. All of the
* information in 'flow' is extracted from 'packet', except for
*
* flow->in_port comes from the OpenFlow OFPT_PACKET_OUT message. The
* implementation should reject invalid flow->in_port values by returning
- * OFPERR_NXBRC_BAD_IN_PORT. For consistency, the implementation should
- * consider valid for flow->in_port any value that could possibly be seen
- * in a packet that it passes to connmgr_send_packet_in(). Ideally, even
- * an implementation that never generates packet-ins (e.g. due to hardware
- * limitations) should still allow flow->in_port values for every possible
- * physical port and OFPP_LOCAL. The only virtual ports (those above
- * OFPP_MAX) that the caller will ever pass in as flow->in_port, other than
- * OFPP_LOCAL, are OFPP_NONE and OFPP_CONTROLLER. The implementation
- * should allow both of these, treating each of them as packets generated
- * by the controller as opposed to packets originating from some switch
- * port.
+ * OFPERR_NXBRC_BAD_IN_PORT. (If the implementation called
+ * ofproto_init_max_ports(), then the client will reject these ports
+ * itself.) For consistency, the implementation should consider valid for
+ * flow->in_port any value that could possibly be seen in a packet that it
+ * passes to connmgr_send_packet_in(). Ideally, even an implementation
+ * that never generates packet-ins (e.g. due to hardware limitations)
+ * should still allow flow->in_port values for every possible physical port
+ * and OFPP_LOCAL. The only virtual ports (those above OFPP_MAX) that the
+ * caller will ever pass in as flow->in_port, other than OFPP_LOCAL, are
+ * OFPP_NONE and OFPP_CONTROLLER. The implementation should allow both of
+ * these, treating each of them as packets generated by the controller as
+ * opposed to packets originating from some switch port.
*
* (Ordinarily the only effect of flow->in_port is on output actions that
* involve the input port, such as actions that output to OFPP_IN_PORT,
* not support CFM. */
int (*get_cfm_fault)(const struct ofport *ofport);
+ /* Check the operational status reported by the remote CFM endpoint of
+ * 'ofp_port' Returns 1 if operationally up, 0 if operationally down, and
+ * -1 if CFM is not enabled on 'ofp_port' or does not support operational
+ * status.
+ *
+ * This function may be a null pointer if the ofproto implementation does
+ * not support CFM. */
+ int (*get_cfm_opup)(const struct ofport *ofport);
+
/* Gets the MPIDs of the remote maintenance points broadcasting to
* 'ofport'. Populates 'rmps' with a provider owned array of MPIDs, and
* 'n_rmps' with the number of MPIDs in 'rmps'. Returns a number less than