X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=2c6e4839f2da4869a2b294d95fb8ef3aef80d7db;hb=6c6eedc5d6730835a0d9724e2e8cfe9cdf03b07d;hp=de354ec42743c85160d4ac0ac22e8a5c1484ed80;hpb=9efd308e957c26ab42a5210cc9fc7300c7d021f0;p=cascardo%2Fovs.git diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index de354ec42..2c6e4839f 100644 --- a/ofproto/ofproto-provider.h +++ b/ofproto/ofproto-provider.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -78,7 +78,7 @@ struct ofproto { 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_*. */ + enum ofputil_frag_handling frag_handling; /* Datapath. */ struct hmap ports; /* Contains "struct ofport"s. */ @@ -93,13 +93,15 @@ struct ofproto { long long int eviction_group_timer; /* For rate limited reheapification. */ struct oftable *tables; int n_tables; + cls_version_t tables_version; /* Controls which rules are visible to + * table lookups. */ /* Rules indexed on their cookie values, in all flow tables. */ struct hindex cookies OVS_GUARDED_BY(ofproto_mutex); struct hmap learned_cookies OVS_GUARDED_BY(ofproto_mutex); /* List of expirable flows, in all flow tables. */ - struct list expirable OVS_GUARDED_BY(ofproto_mutex); + struct ovs_list expirable OVS_GUARDED_BY(ofproto_mutex); /* Meter table. * OpenFlow meters start at 1. To avoid confusion we leave the first @@ -218,6 +220,9 @@ struct oftable { /* Maximum number of flows or UINT_MAX if there is no limit besides any * limit imposed by resource limitations. */ unsigned int max_flows; + /* Current number of flows, not counting temporary duplicates nor deferred + * deletions. */ + unsigned int n_flows; /* These members determine the handling of an attempt to add a flow that * would cause the table to have more than 'max_flows' flows. @@ -241,9 +246,28 @@ struct oftable { struct hmap eviction_groups_by_id; struct heap eviction_groups_by_size; - /* Table configuration. */ + /* Flow table miss handling configuration. */ ATOMIC(enum ofputil_table_miss) miss_config; + /* Eviction is enabled if either the client (vswitchd) enables it or an + * OpenFlow controller enables it; thus, a nonzero value indicates that + * eviction is enabled. */ +#define EVICTION_CLIENT (1 << 0) /* Set to 1 if client enables eviction. */ +#define EVICTION_OPENFLOW (1 << 1) /* Set to 1 if OpenFlow enables eviction. */ + unsigned int eviction; + + /* If zero, vacancy events are disabled. If nonzero, this is the type of + vacancy event that is enabled: either OFPTR_VACANCY_DOWN or + OFPTR_VACANCY_UP. Only one type of vacancy event can be enabled at a + time. */ + enum ofp14_table_reason vacancy_event; + + /* Non-zero values for vacancy_up and vacancy_down indicates that vacancy + * is enabled by table-mod, else these values are set to zero when + * vacancy is disabled */ + uint8_t vacancy_down; /* Vacancy threshold when space decreases (%). */ + uint8_t vacancy_up; /* Vacancy threshold when space increases (%). */ + atomic_ulong n_matched; atomic_ulong n_missed; }; @@ -321,6 +345,8 @@ struct rule { struct ofproto *const ofproto; /* The ofproto that contains this rule. */ const struct cls_rule cr; /* In owning ofproto's classifier. */ const uint8_t table_id; /* Index in ofproto's 'tables' array. */ + bool removed; /* Rule has been removed from the ofproto + * data structures. */ /* Protects members marked OVS_GUARDED. * Readers only need to hold this mutex. @@ -346,6 +372,14 @@ struct rule { uint16_t hard_timeout OVS_GUARDED; /* In seconds from ->modified. */ uint16_t idle_timeout OVS_GUARDED; /* In seconds from ->used. */ + /* Eviction precedence. */ + const uint16_t importance; + + /* Removal reason for sending flow removed message. + * Used only if 'flags' has OFPUTIL_FF_SEND_FLOW_REM set and if the + * value is not OVS_OFPRR_NONE. */ + uint8_t removed_reason; + /* Eviction groups (see comment on struct eviction_group for explanation) . * * 'eviction_group' is this rule's eviction group, or NULL if it is not in @@ -356,10 +390,10 @@ struct rule { /* OpenFlow actions. See struct rule_actions for more thread-safety * notes. */ - OVSRCU_TYPE(const struct rule_actions *) actions; + const struct rule_actions * const actions; /* In owning meter's 'rules' list. An empty list if there is no meter. */ - struct list meter_list_node OVS_GUARDED_BY(ofproto_mutex); + struct ovs_list meter_list_node OVS_GUARDED_BY(ofproto_mutex); /* Flow monitors (e.g. for NXST_FLOW_MONITOR, related to struct ofmonitor). * @@ -372,7 +406,7 @@ struct rule { /* Optimisation for flow expiry. In ofproto's 'expirable' list if this * rule is expirable, otherwise empty. */ - struct list expirable OVS_GUARDED_BY(ofproto_mutex); + struct ovs_list expirable OVS_GUARDED_BY(ofproto_mutex); /* Times. Last so that they are more likely close to the stats managed * by the provider. */ @@ -400,7 +434,7 @@ static inline bool rule_is_hidden(const struct rule *); * code that holds 'rule->mutex' (where 'rule' is the rule for which * 'rule->actions == actions') or during the RCU active period. * - * All members are immutable: they do not change during the struct's + * All members are immutable: they do not change during the rule's * lifetime. */ struct rule_actions { /* Flags. @@ -451,6 +485,9 @@ extern unsigned ofproto_max_idle; * ofproto-dpif implementation. */ extern size_t n_handlers, n_revalidators; +/* Cpu mask for pmd threads. */ +extern char *pmd_cpu_mask; + static inline struct rule *rule_from_cls_rule(const struct cls_rule *); void ofproto_rule_expire(struct rule *rule, uint8_t reason) @@ -488,8 +525,10 @@ struct ofgroup { const long long int created; /* Creation time. */ const long long int modified; /* Time of last modification. */ - struct list buckets; /* Contains "struct ofputil_bucket"s. */ + struct ovs_list buckets; /* Contains "struct ofputil_bucket"s. */ const uint32_t n_buckets; + + const struct ofputil_group_props props; }; bool ofproto_group_lookup(const struct ofproto *ofproto, uint32_t group_id, @@ -498,6 +537,8 @@ bool ofproto_group_lookup(const struct ofproto *ofproto, uint32_t group_id, void ofproto_group_ref(struct ofgroup *); void ofproto_group_unref(struct ofgroup *); +void ofproto_group_delete_all(struct ofproto *); + /* ofproto class structure, to be defined by each ofproto implementation. * * @@ -587,7 +628,7 @@ void ofproto_group_unref(struct ofgroup *); * not yet been uninitialized, so the "destruct" function may refer to it. The * "destruct" function is not allowed to fail. * - * Each "dealloc" function frees raw memory that was allocated by the the + * Each "dealloc" function frees raw memory that was allocated by the * "alloc" function. The memory's base and derived members might not have ever * been initialized (but if "construct" returned successfully, then it has been * "destruct"ed already). The "dealloc" function is not allowed to fail. @@ -620,9 +661,10 @@ struct ofproto_class { * 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. */ + /* Enumerates the types of all supported ofproto types into 'types'. The + * caller has already initialized 'types'. The implementation should add + * its own types to 'types' but not remove any existing ones, because other + * ofproto classes might already have added names to it. */ void (*enumerate_types)(struct sset *types); /* Enumerates the names of all existing datapath of the specified 'type' @@ -718,7 +760,8 @@ struct ofproto_class { * =========== * * ->destruct() must also destroy all remaining rules in the ofproto's - * tables, by passing each remaining rule to ofproto_rule_delete(). + * tables, by passing each remaining rule to ofproto_rule_delete(), then + * destroy all remaining groups by calling ofproto_group_delete_all(). * * The client will destroy the flow tables themselves after ->destruct() * returns. @@ -802,7 +845,7 @@ struct ofproto_class { * * - 'table_id' to the array index. * - * - 'active_count' to the classifier_count() for the table. + * - 'active_count' to the 'n_flows' of struct ofproto for the table. * * - 'lookup_count' and 'matched_count' to 0. * @@ -822,6 +865,9 @@ struct ofproto_class { struct ofputil_table_features *features, struct ofputil_table_stats *stats); + /* Sets the current tables version the provider should use for classifier + * lookups. */ + void (*set_tables_version)(struct ofproto *ofproto, cls_version_t version); /* ## ---------------- ## */ /* ## ofport Functions ## */ /* ## ---------------- ## */ @@ -853,12 +899,36 @@ struct ofproto_class { * initialization, and construct and destruct ofports to reflect all of * the changes. * + * - On graceful shutdown, the base ofproto code will destruct all + * the ports. + * * ->port_construct() returns 0 if successful, otherwise a positive errno * value. + * + * + * ->port_destruct() + * ================= + * + * ->port_destruct() takes a 'del' parameter. If the provider implements + * the datapath itself (e.g. dpif-netdev, it can ignore 'del'. On the + * other hand, if the provider is an interface to an external datapath + * (e.g. to a kernel module that implement the datapath) then 'del' should + * influence destruction behavior in the following way: + * + * - If 'del' is true, it should remove the port from the underlying + * implementation. This is the common case. + * + * - If 'del' is false, it should leave the port in the underlying + * implementation. This is used when Open vSwitch is performing a + * graceful shutdown and ensures that, across Open vSwitch restarts, + * the underlying ports are not removed and recreated. That makes an + * important difference for, e.g., "internal" ports that have + * configured IP addresses; without this distinction, the IP address + * and other configured state for the port is lost. */ struct ofport *(*port_alloc)(void); int (*port_construct)(struct ofport *ofport); - void (*port_destruct)(struct ofport *ofport); + void (*port_destruct)(struct ofport *ofport, bool del); void (*port_dealloc)(struct ofport *ofport); /* Called after 'ofport->netdev' is replaced by a new netdev object. If @@ -1024,9 +1094,18 @@ struct ofproto_class { * problem), or -1 if LACP is not enabled on 'port'. * * This function may be a null pointer if the ofproto implementation does - * not support LACP. */ + * not support LACP. + */ int (*port_is_lacp_current)(const struct ofport *port); + /* Get LACP port stats. Returns -1 if LACP is not enabled on 'port'. + * + * This function may be a null pointer if the ofproto implementation does + * not support LACP. + */ + int (*port_get_lacp_stats)(const struct ofport *port, + struct lacp_slave_stats *stats); + /* ## ----------------------- ## */ /* ## OpenFlow Rule Functions ## */ /* ## ----------------------- ## */ @@ -1097,7 +1176,7 @@ struct ofproto_class { * OpenFlow error code), the ofproto base code will uninitialize and * deallocate 'rule'. See "Rule Life Cycle" above for more details. * - * ->rule_construct() may also: + * ->rule_construct() must also: * * - Validate that the datapath supports the matching rule in 'rule->cr' * datapath. For example, if the rule's table does not support @@ -1106,8 +1185,9 @@ struct ofproto_class { * * - Validate that the datapath can correctly implement 'rule->ofpacts'. * - * Some implementations might need to defer these tasks to ->rule_insert(), - * which is also acceptable. + * After a successful construction the rest of the rule life cycle calls + * may not fail, so ->rule_construct() must also make sure that the rule + * can be inserted in to the datapath. * * * Insertion @@ -1116,11 +1196,10 @@ struct ofproto_class { * Following successful construction, the ofproto base case inserts 'rule' * into its flow table, then it calls ->rule_insert(). ->rule_insert() * must add the new rule to the datapath flow table and return only after - * this is complete (whether it succeeds or fails). - * - * If ->rule_insert() fails, the ofproto base code will remove 'rule' from - * the flow table, destruct, uninitialize, and deallocate 'rule'. See - * "Rule Life Cycle" above for more details. + * this is complete. The 'new_rule' may be a duplicate of an 'old_rule'. + * In this case the 'old_rule' is non-null, and the implementation should + * forward rule statistics from the 'old_rule' to the 'new_rule' if + * 'forward_stats' is 'true'. This may not fail. * * * Deletion @@ -1142,7 +1221,8 @@ struct ofproto_class { struct rule *(*rule_alloc)(void); enum ofperr (*rule_construct)(struct rule *rule) /* OVS_REQUIRES(ofproto_mutex) */; - enum ofperr (*rule_insert)(struct rule *rule) + void (*rule_insert)(struct rule *rule, struct rule *old_rule, + bool forward_stats) /* OVS_REQUIRES(ofproto_mutex) */; void (*rule_delete)(struct rule *rule) /* OVS_REQUIRES(ofproto_mutex) */; void (*rule_destruct)(struct rule *rule); @@ -1173,58 +1253,28 @@ struct ofproto_class { * * Returns 0 if successful, otherwise an OpenFlow error code. */ enum ofperr (*rule_execute)(struct rule *rule, const struct flow *flow, - struct ofpbuf *packet); - - /* If the datapath can properly implement changing 'rule''s actions to the - * 'ofpacts_len' bytes in 'ofpacts', returns 0. Otherwise, returns an enum - * ofperr indicating why the new actions wouldn't work. - * - * May be a null pointer if any set of actions is acceptable. */ - enum ofperr (*rule_premodify_actions)(const struct rule *rule, - const struct ofpact *ofpacts, - size_t ofpacts_len) - /* OVS_REQUIRES(ofproto_mutex) */; - - /* When ->rule_modify_actions() is called, the caller has already replaced - * the OpenFlow actions in 'rule' by a new set. (If - * ->rule_premodify_actions is nonnull, then it was previously called to - * verify that the new set of actions is acceptable.) - * - * ->rule_modify_actions() must: - * - * - Update the datapath flow table with the new actions. - * - * - Only if 'reset_counters' is true, reset any packet or byte counters - * associated with the rule to zero, so that rule_get_stats() will not - * longer count those packets or bytes. - * - * Rule modification must not fail. - * - * ->rule_modify_actions() should not modify any base members of struct - * rule. */ - void (*rule_modify_actions)(struct rule *rule, bool reset_counters) - /* OVS_REQUIRES(ofproto_mutex) */; + struct dp_packet *packet); /* Changes the OpenFlow IP fragment handling policy to 'frag_handling', * which takes one of the following values, with the corresponding * meanings: * - * - OFPC_FRAG_NORMAL: The switch should treat IP fragments the same way - * as other packets, omitting TCP and UDP port numbers (always setting - * them to 0). + * - OFPUTIL_FRAG_NORMAL: The switch should treat IP fragments the same + * way as other packets, omitting TCP and UDP port numbers (always + * setting them to 0). * - * - OFPC_FRAG_DROP: The switch should drop all IP fragments without + * - OFPUTIL_FRAG_DROP: The switch should drop all IP fragments without * passing them through the flow table. * - * - OFPC_FRAG_REASM: The switch should reassemble IP fragments before + * - OFPUTIL_FRAG_REASM: The switch should reassemble IP fragments before * passing packets through the flow table. * - * - OFPC_FRAG_NX_MATCH (a Nicira extension): Similar to OFPC_FRAG_NORMAL, - * except that TCP and UDP port numbers should be included in fragments - * with offset 0. + * - OFPUTIL_FRAG_NX_MATCH (a Nicira extension): Similar to + * OFPUTIL_FRAG_NORMAL, except that TCP and UDP port numbers should be + * included in fragments with offset 0. * * Implementations are not required to support every mode. - * OFPC_FRAG_NORMAL is the default mode when an ofproto is created. + * OFPUTIL_FRAG_NORMAL is the default mode when an ofproto is created. * * At the time of the call to ->set_frag_handling(), the current mode is * available in 'ofproto->frag_handling'. ->set_frag_handling() returns @@ -1234,7 +1284,7 @@ struct ofproto_class { * reflect the new mode. */ bool (*set_frag_handling)(struct ofproto *ofproto, - enum ofp_config_flags frag_handling); + enum ofputil_frag_handling frag_handling); /* Implements the OpenFlow OFPT_PACKET_OUT command. The datapath should * execute the 'ofpacts_len' bytes of "struct ofpacts" in 'ofpacts'. @@ -1274,11 +1324,14 @@ struct ofproto_class { * 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, + enum ofperr (*packet_out)(struct ofproto *ofproto, struct dp_packet *packet, const struct flow *flow, const struct ofpact *ofpacts, size_t ofpacts_len); + enum ofperr (*nxt_resume)(struct ofproto *ofproto, + const struct ofputil_packet_in_private *); + /* ## ------------------------- ## */ /* ## OFPP_NORMAL configuration ## */ /* ## ------------------------- ## */ @@ -1341,6 +1394,77 @@ struct ofproto_class { int (*get_cfm_status)(const struct ofport *ofport, struct cfm_status *status); + /* Configures LLDP on 'ofport'. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support LLDP, as does a null pointer. */ + int (*set_lldp)(struct ofport *ofport, const struct smap *cfg); + + /* Checks the status of LLDP configured on 'ofport'. Returns true if the + * port's LLDP status was successfully stored into '*status'. Returns + * false if the port did not have LLDP configured, in which case '*status' + * is indeterminate. + * + * The caller must provide and own '*status'. '*status' is indeterminate + * if the return value is non-zero. */ + bool (*get_lldp_status)(const struct ofport *ofport, + struct lldp_status *status); + + /* Configures Auto Attach. + * + * If 's' is nonnull, configures Auto Attach according to its members. + * + * If 's' is null, removes any Auto Attach configuration. + */ + int (*set_aa)(struct ofproto *ofproto, + const struct aa_settings *s); + + /* If 's' is nonnull, this function registers a mapping associated with + * client data pointer 'aux' in 'ofproto'. If 'aux' is already registered + * then this function updates its configuration to 's'. Otherwise, this + * function registers a new mapping. + * + * An implementation that does not support mapping at all may set + * it to NULL or return EOPNOTSUPP. An implementation that supports + * only a subset of the functionality should implement what it can + * and return 0. + */ + int (*aa_mapping_set)(struct ofproto *ofproto, void *aux, + const struct aa_mapping_settings *s); + + /* If 's' is nonnull, this function unregisters a mapping associated with + * client data pointer 'aux' in 'ofproto'. If 'aux' is already registered + * then this function updates its configuration to 's'. Otherwise, this + * function unregisters a new mapping. + * + * An implementation that does not support mapping at all may set + * it to NULL or return EOPNOTSUPP. An implementation that supports + * only a subset of the functionality should implement what it can + * and return 0. + */ + int (*aa_mapping_unset)(struct ofproto *ofproto, void *aux); + + /* + * Returns the a list of AutoAttach VLAN operations. When Auto Attach is + * enabled, the VLAN associated with an I-SID/VLAN mapping is first + * negotiated with an Auto Attach Server. Once an I-SID VLAN mapping + * becomes active, the corresponding VLAN needs to be communicated to the + * bridge in order to add the VLAN to the trunk port linking the Auto + * Attach Client (in this case openvswitch) and the Auto Attach Server. + * + * The list entries are of type "struct bridge_aa_vlan". Each entry + * specifies the operation (add or remove), the interface on which to + * execute the operation and the VLAN. + */ + int (*aa_vlan_get_queued)(struct ofproto *ofproto, struct ovs_list *list); + + /* + * Returns the current number of entries in the list of VLAN operations + * in the Auto Attach Client (see previous function description + * aa_vlan_get_queued). Returns 0 if Auto Attach is disabled. + */ + unsigned int (*aa_vlan_get_queue_size)(struct ofproto *ofproto); + /* Configures BFD on 'ofport'. * * If 'cfg' is NULL, or 'cfg' does not contain the key value pair @@ -1570,14 +1694,15 @@ struct ofproto_class { /* Configures multicast snooping port's flood setting on 'ofproto'. * - * All multicast traffic is sent to struct port 'aux' in 'ofproto' - * if 'flood' is true. Otherwise, struct port 'aux' is an ordinary - * switch port. + * If 's' is nonnull, this function updates multicast snooping + * configuration to 's' in 'ofproto'. + * + * If 's' is NULL, this function doesn't change anything. * * An implementation that does not support multicast snooping may set * it to NULL or return EOPNOTSUPP. */ int (*set_mcast_snooping_port)(struct ofproto *ofproto_, void *aux, - bool flood); + const struct ofproto_mcast_snooping_port_settings *s); /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) * @@ -1653,6 +1778,19 @@ struct ofproto_class { enum ofperr (*group_get_stats)(const struct ofgroup *, struct ofputil_group_stats *); + +/* ## --------------------- ## */ +/* ## Datapath information ## */ +/* ## --------------------- ## */ + /* Retrieve the version string of the datapath. The version + * string can be NULL if it can not be determined. + * + * The version retuned is read only. The caller should not + * free it. + * + * This function should be NULL if an implementation does not support it. + */ + const char *(*get_datapath_version)(const struct ofproto *); }; extern const struct ofproto_class ofproto_dpif_class; @@ -1660,22 +1798,39 @@ extern const struct ofproto_class ofproto_dpif_class; int ofproto_class_register(const struct ofproto_class *); int ofproto_class_unregister(const struct ofproto_class *); -int ofproto_flow_mod(struct ofproto *, struct ofputil_flow_mod *) +/* flow_mod with execution context. */ +struct ofproto_flow_mod { + struct ofputil_flow_mod fm; + + cls_version_t version; /* Version in which changes take + * effect. */ + struct rule_collection old_rules; /* Affected rules. */ + struct rule_collection new_rules; /* Replacement rules. */ +}; + +/* port_mod with execution context. */ +struct ofproto_port_mod { + struct ofputil_port_mod pm; + struct ofport *port; /* Affected port. */ +}; + +enum ofperr ofproto_flow_mod(struct ofproto *, struct ofproto_flow_mod *) OVS_EXCLUDED(ofproto_mutex); -void ofproto_add_flow(struct ofproto *, const struct match *, - unsigned int priority, +void ofproto_add_flow(struct ofproto *, const struct match *, int priority, const struct ofpact *ofpacts, size_t ofpacts_len) OVS_EXCLUDED(ofproto_mutex); -void ofproto_delete_flow(struct ofproto *, - const struct match *, unsigned int priority) +void ofproto_delete_flow(struct ofproto *, const struct match *, int priority) OVS_EXCLUDED(ofproto_mutex); void ofproto_flush_flows(struct ofproto *); +enum ofperr ofproto_check_ofpacts(struct ofproto *, + const struct ofpact ofpacts[], + size_t ofpacts_len); static inline const struct rule_actions * rule_get_actions(const struct rule *rule) { - return ovsrcu_get(const struct rule_actions *, &rule->actions); + return rule->actions; } /* Returns true if 'rule' is an OpenFlow 1.3 "table-miss" rule, false