/*
- * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "ofp-errors.h"
#include "ofp-util.h"
#include "shash.h"
+#include "simap.h"
#include "timeval.h"
+struct match;
+struct ofpact;
struct ofputil_flow_mod;
+struct bfd_cfg;
/* An OpenFlow switch.
*
* ofproto-dpif implementation */
bool forward_bpdu; /* Option to allow forwarding of BPDU frames
* when NORMAL action is invoked. */
- char *mfr_desc; /* Manufacturer. */
- char *hw_desc; /* Hardware. */
- char *sw_desc; /* Software version. */
- char *serial_desc; /* Serial number. */
- char *dp_desc; /* Datapath description. */
+ char *mfr_desc; /* Manufacturer (NULL for default)b. */
+ char *hw_desc; /* Hardware (NULL for default). */
+ char *sw_desc; /* Software version (NULL for default). */
+ char *serial_desc; /* Serial number (NULL for default). */
+ char *dp_desc; /* Datapath description (NULL for default). */
enum ofp_config_flags frag_handling; /* One of OFPC_*. */
/* Datapath. */
struct hmap ports; /* Contains "struct ofport"s. */
struct shash port_by_name;
+ unsigned long *ofp_port_ids;/* Bitmap of used OpenFlow port numbers. */
+ struct simap ofp_requests; /* OpenFlow port number requests. */
+ uint16_t alloc_port_no; /* Last allocated OpenFlow port number. */
+ uint16_t max_ports; /* Max possible OpenFlow port num, plus one. */
/* Flow tables. */
struct oftable *tables;
int n_tables;
+ /* Optimisation for flow expiry.
+ * These flows should all be present in tables. */
+ struct list expirable; /* Expirable 'struct rule"s in all tables. */
+
/* OpenFlow connections. */
struct connmgr *connmgr;
unsigned int n_pending; /* list_size(&pending). */
struct hmap deletions; /* All OFOPERATION_DELETE "ofoperation"s. */
+ /* Flow table operation logging. */
+ int n_add, n_delete, n_modify; /* Number of unreported ops of each kind. */
+ long long int first_op, last_op; /* Range of times for unreported ops. */
+ long long int next_op_report; /* Time to report ops, or LLONG_MAX. */
+ long long int op_backoff; /* Earliest time to report ops again. */
+
/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
*
* This is deprecated. It is only for compatibility with broken device
};
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);
void ofproto_port_set_state(struct ofport *, enum ofputil_port_state);
+/* OpenFlow table flags:
+ *
+ * - "Hidden" tables are not included in OpenFlow operations that operate on
+ * "all tables". For example, a request for flow stats on all tables will
+ * omit flows in hidden tables, table stats requests will omit the table
+ * entirely, and the switch features reply will not count the hidden table.
+ *
+ * However, operations that specifically name the particular table still
+ * operate on it. For example, flow_mods and flow stats requests on a
+ * hidden table work.
+ *
+ * To avoid gaps in table IDs (which have unclear validity in OpenFlow),
+ * hidden tables must be the highest-numbered tables that a provider
+ * implements.
+ *
+ * - "Read-only" tables can't be changed through OpenFlow operations. (At
+ * the moment all flow table operations go effectively through OpenFlow, so
+ * this means that read-only tables can't be changed at all after the
+ * read-only flag is set.)
+ *
+ * The generic ofproto layer never sets these flags. An ofproto provider can
+ * set them if it is appropriate.
+ */
enum oftable_flags {
OFTABLE_HIDDEN = 1 << 0, /* Hide from most OpenFlow operations. */
OFTABLE_READONLY = 1 << 1 /* Don't allow OpenFlow to change this table. */
struct heap_node evg_node; /* In eviction_group's "rules" heap. */
struct eviction_group *eviction_group; /* NULL if not in any group. */
- union ofp_action *actions; /* OpenFlow actions. */
- int n_actions; /* Number of elements in actions[]. */
+ 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. */
+
+ /* Optimisation for flow expiry. */
+ struct list expirable; /* In ofproto's 'expirable' list if this rule
+ * is expirable, otherwise empty. */
};
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.
*
*
/* ## Factory Functions ## */
/* ## ----------------- ## */
+ /* Initializes provider. The caller may pass in 'iface_hints',
+ * which contains an shash of "struct iface_hint" elements indexed
+ * by the interface's name. The provider may use these hints to
+ * describe the startup configuration in order to reinitialize its
+ * state. The caller owns the provided data, so a provider must
+ * make copies of anything required. An ofproto provider must
+ * remove any existing state that is not described by the hint, and
+ * may choose to remove it all. */
+ void (*init)(const struct shash *iface_hints);
+
/* Enumerates the types of all support ofproto types into 'types'. The
* caller has already initialized 'types' and other ofproto classes might
* already have added names to it. */
*/
int (*del)(const char *type, const char *name);
+ /* Returns the type to pass to netdev_open() when a datapath of type
+ * 'datapath_type' has a port of type 'port_type', for a few special
+ * cases when a netdev type differs from a port type. For example,
+ * when using the userspace datapath, a port of type "internal"
+ * needs to be opened as "tap".
+ *
+ * Returns either 'type' itself or a string literal, which must not
+ * be freed. */
+ const char *(*port_open_type)(const char *datapath_type,
+ const char *port_type);
+
+/* ## ------------------------ ## */
+/* ## Top-Level type Functions ## */
+/* ## ------------------------ ## */
+
+ /* Performs any periodic activity required on ofprotos of type
+ * 'type'.
+ *
+ * An ofproto provider may implement it or not, depending on whether
+ * it needs type-level maintenance.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+ int (*type_run)(const char *type);
+
+ /* Performs periodic activity required on ofprotos of type 'type'
+ * that needs to be done with the least possible latency.
+ *
+ * This is run multiple times per main loop. An ofproto provider may
+ * implement it or not, according to whether it provides a performance
+ * boost for that ofproto implementation.
+ *
+ * Returns 0 if successful, otherwise a positive errno value. */
+ int (*type_run_fast)(const char *type);
+
+ /* Causes the poll loop to wake up when a type 'type''s 'run'
+ * function needs to be called, e.g. by calling the timer or fd
+ * waiting functions in poll-loop.h.
+ *
+ * An ofproto provider may implement it or not, depending on whether
+ * it needs type-level maintenance. */
+ void (*type_wait)(const char *type);
+
/* ## --------------------------- ## */
/* ## Top-Level ofproto Functions ## */
/* ## --------------------------- ## */
* ->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);
* poll-loop.h. */
void (*wait)(struct ofproto *ofproto);
+ /* Adds some memory usage statistics for the implementation of 'ofproto'
+ * into 'usage', for use with memory_report().
+ *
+ * This function is optional. */
+ void (*get_memory_usage)(const struct ofproto *ofproto,
+ struct simap *usage);
+
/* Every "struct rule" in 'ofproto' is about to be deleted, one by one.
* This function may prepare for that, for example by clearing state in
* advance. It should *not* actually delete any "struct rule"s from
*
* - 'name' to "table#" where # is the table ID.
*
- * - 'wildcards' to OFPFW_ALL.
+ * - 'match' and 'wildcards' to OFPXMT12_MASK.
+ *
+ * - 'write_actions' and 'apply_actions' to OFPAT12_OUTPUT.
+ *
+ * - 'write_setfields' and 'apply_setfields' to OFPXMT12_MASK.
+ *
+ * - 'metadata_match' and 'metadata_write' to UINT64_MAX.
+ *
+ * - 'instructions' to OFPIT11_ALL.
+ *
+ * - 'config' to OFPTC11_TABLE_MISS_MASK.
*
* - 'max_entries' to 1,000,000.
*
* - 'wildcards' to the set of wildcards actually supported by the table
* (if it doesn't support all OpenFlow wildcards).
*
+ * - 'instructions' to set the instructions actually supported by
+ * the table.
+ *
+ * - 'write_actions' to set the write actions actually supported by
+ * the table (if it doesn't support all OpenFlow actions).
+ *
+ * - 'apply_actions' to set the apply actions actually supported by
+ * the table (if it doesn't support all OpenFlow actions).
+ *
+ * - 'write_setfields' to set the write setfields actually supported by
+ * the table.
+ *
+ * - 'apply_setfields' to set the apply setfields actually supported by
+ * the table.
+ *
* - 'max_entries' to the maximum number of flows actually supported by
* the hardware.
*
* - '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
- * network byte order.
+ * All of the members of struct ofp12_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 ofp12_table_stats *ots);
/* ## ---------------- ## */
/* ## ofport Functions ## */
/* Life-cycle functions for a "struct ofport" (see "Life Cycle" above).
*
* ->port_construct() should not modify any base members of the ofport.
+ * An ofproto implementation should use the 'ofp_port' member of
+ * "struct ofport" as the OpenFlow port number.
*
* ofports are managed by the base ofproto code. The ofproto
* implementation should only create and destroy them in response to calls
const char *devname, struct ofproto_port *port);
/* Attempts to add 'netdev' as a port on 'ofproto'. Returns 0 if
- * successful, otherwise a positive errno value. If successful, sets
- * '*ofp_portp' to the new port's port number.
+ * successful, otherwise a positive errno value. The caller should
+ * inform the implementation of the OpenFlow port through the
+ * ->port_construct() method.
*
* It doesn't matter whether the new port will be returned by a later call
* to ->port_poll(); the implementation may do whatever is more
* convenient. */
- int (*port_add)(struct ofproto *ofproto, struct netdev *netdev,
- uint16_t *ofp_portp);
+ int (*port_add)(struct ofproto *ofproto, struct netdev *netdev);
/* Deletes port number 'ofp_port' from the datapath for 'ofproto'. Returns
* 0 if successful, otherwise a positive errno value.
*
* The client might not be entirely in control of the ports within an
* ofproto. Some hardware implementations, for example, might have a fixed
- * set of ports in a datapath, and the Linux datapath allows the system
- * administrator to externally add and remove ports with ovs-dpctl. For
- * this reason, the client needs a way to iterate through all the ports
- * that are actually in a datapath. These functions provide that
- * functionality.
+ * set of ports in a datapath. For this reason, the client needs a way to
+ * iterate through all the ports that are actually in a datapath. These
+ * functions provide that functionality.
*
* The 'state' pointer provides the implementation a place to
* keep track of its position. Its format is opaque to the caller.
/* ## OpenFlow Rule Functions ## */
/* ## ----------------------- ## */
-
-
- /* Chooses an appropriate table for 'cls_rule' within 'ofproto'. On
+ /* Chooses an appropriate table for 'match' within 'ofproto'. On
* success, stores the table ID into '*table_idp' and returns 0. On
* failure, returns an OpenFlow error code.
*
- * The choice of table should be a function of 'cls_rule' and 'ofproto''s
+ * The choice of table should be a function of 'match' and 'ofproto''s
* datapath capabilities. It should not depend on the flows already in
* 'ofproto''s flow tables. Failure implies that an OpenFlow rule with
- * 'cls_rule' as its matching condition can never be inserted into
- * 'ofproto', even starting from an empty flow table.
+ * 'match' as its matching condition can never be inserted into 'ofproto',
+ * even starting from an empty flow table.
*
* If multiple tables are candidates for inserting the flow, the function
* should choose one arbitrarily (but deterministically).
*
* If this function is NULL then table 0 is always chosen. */
enum ofperr (*rule_choose_table)(const struct ofproto *ofproto,
- const struct cls_rule *cls_rule,
+ const struct match *match,
uint8_t *table_idp);
/* Life-cycle functions for a "struct rule" (see "Life Cycle" above).
* registers, then it is an error if 'rule->cr' does not wildcard all
* registers.
*
- * - Validate that 'rule->actions' and 'rule->n_actions' are well-formed
- * OpenFlow actions that the datapath can correctly implement. The
- * validate_actions() function (in ofp-util.c) can be useful as a model
- * for action validation, but it accepts all of the OpenFlow actions
- * that OVS understands. If your ofproto implementation only
- * implements a subset of those, 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.
*
* 'flow' reflects the flow information for 'packet'. All of the
* information in 'flow' is extracted from 'packet', except for
- * flow->tun_id and flow->in_port, which are assigned the correct values
+ * flow->tunnel and flow->in_port, which are assigned the correct values
* for the incoming packet. The register values are zeroed. 'packet''s
* header pointers (e.g. packet->l3) are appropriately initialized.
*
*
* ->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.
*
enum ofp_config_flags frag_handling);
/* Implements the OpenFlow OFPT_PACKET_OUT command. The datapath should
- * execute the 'n_actions' in the 'actions' array on 'packet'.
+ * execute the 'ofpacts_len' bytes of "struct ofpacts" in 'ofpacts'.
*
- * The caller retains ownership of 'packet', so ->packet_out() should not
- * modify or free it.
+ * The caller retains ownership of 'packet' and of 'ofpacts', so
+ * ->packet_out() should not modify or free them.
*
- * This function must validate that the 'n_actions' elements in 'actions'
- * are well-formed OpenFlow actions that can be correctly implemented by
- * the datapath. 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, which is taken from the OFPT_PACKET_OUT message.
- * flow->tun_id and its register values are zeroed.
+ * flow->in_port (see below). flow->tunnel and its register values are
+ * zeroed.
+ *
+ * flow->in_port comes from the OpenFlow OFPT_PACKET_OUT message. The
+ * implementation should reject invalid flow->in_port values by returning
+ * OFPERR_OFPBRC_BAD_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,
+ * OFPP_FLOOD, or OFPP_ALL. flow->in_port can also affect Nicira extension
+ * "resubmit" actions.)
*
* 'packet' is not matched against the OpenFlow flow table, so its
* statistics should not be included in OpenFlow flow statistics.
* Returns 0 if successful, otherwise an OpenFlow error code. */
enum ofperr (*packet_out)(struct ofproto *ofproto, struct ofpbuf *packet,
const struct flow *flow,
- const union ofp_action *actions,
- size_t n_actions);
+ const struct ofpact *ofpacts,
+ size_t ofpacts_len);
/* ## ------------------------- ## */
/* ## OFPP_NORMAL configuration ## */
int (*set_sflow)(struct ofproto *ofproto,
const struct ofproto_sflow_options *sflow_options);
+ /* Configures IPFIX on 'ofproto' according to the options in
+ * 'bridge_exporter_options' and the 'flow_exporters_options'
+ * array, or turns off IPFIX if 'bridge_exporter_options' and
+ * 'flow_exporters_options' is NULL.
+ *
+ * EOPNOTSUPP as a return value indicates that 'ofproto' does not support
+ * IPFIX, as does a null pointer. */
+ int (*set_ipfix)(
+ struct ofproto *ofproto,
+ const struct ofproto_ipfix_bridge_exporter_options
+ *bridge_exporter_options,
+ const struct ofproto_ipfix_flow_exporter_options
+ *flow_exporters_options, size_t n_flow_exporters_options);
+
/* Configures connectivity fault management on 'ofport'.
*
* If 'cfm_settings' is nonnull, configures CFM according to its members.
* support CFM, as does a null pointer. */
int (*set_cfm)(struct ofport *ofport, const struct cfm_settings *s);
- /* Checks the fault status of CFM configured on 'ofport'. Returns a
- * bitmask of 'cfm_fault_reason's to indicate a CFM fault (generally
- * indicating a connectivity problem). Returns zero if CFM is not faulted,
- * and -1 if CFM is not enabled on 'port'.
+ /* Checks the status of CFM configured on 'ofport'. Returns true if the
+ * port's CFM status was successfully stored into '*status'. Returns false
+ * if the port did not have CFM configured, in which case '*status' is
+ * indeterminate.
*
- * This function may be a null pointer if the ofproto implementation does
- * not support CFM. */
- int (*get_cfm_fault)(const struct ofport *ofport);
+ * The caller must provide and owns '*status', but it does not own and must
+ * not modify or free the array returned in 'status->rmps'. */
+ bool (*get_cfm_status)(const struct ofport *ofport,
+ struct ofproto_cfm_status *status);
- /* 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
- * 0 if CFM is not enabled of 'ofport'.
+ /* Configures BFD on 'ofport'.
*
- * This function may be a null pointer if the ofproto implementation does
- * not support CFM. */
- int (*get_cfm_remote_mpids)(const struct ofport *ofport,
- const uint64_t **rmps, size_t *n_rmps);
-
- /* Checks the health of CFM configured on 'ofport'. Returns an integer
- * to indicate the health percentage of the 'ofport' which is an average of
- * the health of all the remote_mps. Returns an integer between 0 and 100
- * where 0 means that the 'ofport' is very unhealthy and 100 means the
- * 'ofport' is perfectly healthy. Returns -1 if CFM is not enabled on
- * 'port' or if the number of remote_mpids is > 1.
+ * If 'cfg' is NULL, or 'cfg' does not contain the key value pair
+ * "enable=true", removes BFD from 'ofport'. Otherwise, configures BFD
+ * according to 'cfg'.
*
- * This function may be a null pointer if the ofproto implementation does
- * not support CFM. */
- int (*get_cfm_health)(const struct ofport *ofport);
+ * EOPNOTSUPP as a return value indicates that this ofproto_class does not
+ * support BFD, as does a null pointer. */
+ int (*set_bfd)(struct ofport *ofport, const struct smap *cfg);
+
+ /* Populates 'smap' with the status of BFD on 'ofport'. Returns 0 on
+ * success, or a positive errno. EOPNOTSUPP as a return value indicates
+ * that this ofproto_class does not support BFD, as does a null pointer. */
+ int (*get_bfd_status)(struct ofport *ofport, struct smap *smap);
/* Configures spanning tree protocol (STP) on 'ofproto' using the
* settings defined in 's'.
* will be invoked. */
void (*forward_bpdu_changed)(struct ofproto *ofproto);
- /* Sets the MAC aging timeout for the OFPP_NORMAL action to 'idle_time',
- * in seconds. */
- void (*set_mac_idle_time)(struct ofproto *ofproto, unsigned int idle_time);
+ /* Sets the MAC aging timeout for the OFPP_NORMAL action to 'idle_time', in
+ * seconds, and the maximum number of MAC table entries to
+ * 'max_entries'.
+ *
+ * An implementation that doesn't support configuring these features may
+ * set this function to NULL or implement it as a no-op. */
+ void (*set_mac_table_config)(struct ofproto *ofproto,
+ unsigned int idle_time, size_t max_entries);
/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
*
BUILD_ASSERT_DECL(OFPROTO_POSTPONE < OFPERR_OFS);
int ofproto_flow_mod(struct ofproto *, const struct ofputil_flow_mod *);
-void ofproto_add_flow(struct ofproto *, const struct cls_rule *,
- const union ofp_action *, size_t n_actions);
-bool ofproto_delete_flow(struct ofproto *, const struct cls_rule *);
+void ofproto_add_flow(struct ofproto *, const struct match *,
+ unsigned int priority,
+ const struct ofpact *ofpacts, size_t ofpacts_len);
+bool ofproto_delete_flow(struct ofproto *,
+ const struct match *, unsigned int priority);
void ofproto_flush_flows(struct ofproto *);
#endif /* ofproto/ofproto-provider.h */