X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=6eef1063ea9db3c28635bf19f910ead4d6bb569b;hb=2b07c8b182b76e4e3a162796d3ae273ef51d4131;hp=fa583f8698f601dec00624819eef1e7a915e15a6;hpb=1de11730e612b09e28892880c2845185497a3741;p=sliver-openvswitch.git diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index fa583f869..6eef1063e 100644 --- a/ofproto/ofproto-provider.h +++ b/ofproto/ofproto-provider.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011 Nicira Networks. + * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,19 +22,26 @@ #include "ofproto/ofproto.h" #include "cfm.h" #include "classifier.h" +#include "heap.h" #include "list.h" +#include "ofp-errors.h" +#include "ofp-util.h" #include "shash.h" #include "timeval.h" +struct ofpact; +struct ofputil_flow_mod; +struct simap; + /* An OpenFlow switch. * * With few exceptions, ofproto implementations may look at these fields but * should not modify them. */ struct ofproto { + struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */ const struct ofproto_class *ofproto_class; char *type; /* Datapath type. */ char *name; /* Datapath name. */ - struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */ /* Settings. */ uint64_t fallback_dpid; /* Datapath ID if no better choice found. */ @@ -49,13 +56,14 @@ struct ofproto { char *sw_desc; /* Software version. */ char *serial_desc; /* Serial number. */ char *dp_desc; /* Datapath description. */ + enum ofp_config_flags frag_handling; /* One of OFPC_*. */ /* Datapath. */ struct hmap ports; /* Contains "struct ofport"s. */ struct shash port_by_name; /* Flow tables. */ - struct classifier *tables; /* Each classifier contains "struct rule"s. */ + struct oftable *tables; int n_tables; /* OpenFlow connections. */ @@ -64,41 +72,100 @@ struct ofproto { /* Flow table operation tracking. */ int state; /* Internal state. */ struct list pending; /* List of "struct ofopgroup"s. */ + 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 + * drivers in old versions of Linux that do not properly support VLANs when + * VLAN devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + unsigned long int *vlan_bitmap; /* 4096-bit bitmap of in-use VLANs. */ + bool vlans_changed; /* True if new VLANs are in use. */ + int min_mtu; /* Current MTU of non-internal ports. */ }; +void ofproto_init_tables(struct ofproto *, int n_tables); + struct ofproto *ofproto_lookup(const char *name); struct ofport *ofproto_get_port(const struct ofproto *, uint16_t ofp_port); -/* Assigns CLS to each classifier table, in turn, in OFPROTO. - * - * All parameters are evaluated multiple times. */ -#define OFPROTO_FOR_EACH_TABLE(CLS, OFPROTO) \ - for ((CLS) = (OFPROTO)->tables; \ - (CLS) < &(OFPROTO)->tables[(OFPROTO)->n_tables]; \ - (CLS)++) - - /* An OpenFlow port within a "struct ofproto". * * With few exceptions, ofproto implementations may look at these fields but * should not modify them. */ struct ofport { - struct ofproto *ofproto; /* The ofproto that contains this port. */ struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */ + struct ofproto *ofproto; /* The ofproto that contains this port. */ 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 *, enum ofputil_port_state); + +enum oftable_flags { + OFTABLE_HIDDEN = 1 << 0, /* Hide from most OpenFlow operations. */ + OFTABLE_READONLY = 1 << 1 /* Don't allow OpenFlow to change this table. */ +}; + +/* A flow table within a "struct ofproto". */ +struct oftable { + enum oftable_flags flags; + struct classifier cls; /* Contains "struct rule"s. */ + char *name; /* Table name exposed via OpenFlow, or NULL. */ + + /* Maximum number of flows or UINT_MAX if there is no limit besides any + * limit imposed by resource limitations. */ + unsigned int max_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. + * + * If 'eviction_fields' is NULL, overflows will be rejected with an error. + * + * If 'eviction_fields' is nonnull (regardless of whether n_eviction_fields + * is nonzero), an overflow will cause a flow to be removed. The flow to + * be removed is chosen to give fairness among groups distinguished by + * different values for the subfields within 'groups'. */ + struct mf_subfield *eviction_fields; + size_t n_eviction_fields; + + /* Eviction groups. + * + * When a flow is added that would cause the table to have more than + * 'max_flows' flows, and 'eviction_fields' is nonnull, these groups are + * used to decide which rule to evict: the rule is chosen from the eviction + * group that contains the greatest number of rules.*/ + uint32_t eviction_group_id_basis; + struct hmap eviction_groups_by_id; + struct heap eviction_groups_by_size; +}; + +/* Assigns TABLE to each oftable, in turn, in OFPROTO. + * + * All parameters are evaluated multiple times. */ +#define OFPROTO_FOR_EACH_TABLE(TABLE, OFPROTO) \ + for ((TABLE) = (OFPROTO)->tables; \ + (TABLE) < &(OFPROTO)->tables[(OFPROTO)->n_tables]; \ + (TABLE)++) + /* An OpenFlow flow within a "struct ofproto". * * With few exceptions, ofproto implementations may look at these fields but * should not modify them. */ struct rule { - struct ofproto *ofproto; /* The ofproto that contains this rule. */ struct list ofproto_node; /* Owned by ofproto base code. */ + struct ofproto *ofproto; /* The ofproto that contains this rule. */ struct cls_rule cr; /* In owning ofproto's classifier. */ struct ofoperation *pending; /* Operation now in progress, if nonnull. */ @@ -106,13 +173,25 @@ struct rule { ovs_be64 flow_cookie; /* Controller-issued identifier. */ long long int created; /* Creation time. */ - uint16_t idle_timeout; /* In seconds from time of last use. */ - uint16_t hard_timeout; /* In seconds from time of creation. */ + long long int modified; /* Time of last modification. */ + long long int used; /* Last use; time created if never used. */ + uint16_t hard_timeout; /* In seconds from ->modified. */ + uint16_t idle_timeout; /* In seconds from ->used. */ uint8_t table_id; /* Index in ofproto's 'tables' array. */ bool send_flow_removed; /* Send a flow removed message? */ - union ofp_action *actions; /* OpenFlow actions. */ - int n_actions; /* Number of elements in actions[]. */ + /* Eviction groups. */ + bool evictable; /* If false, prevents eviction. */ + struct heap_node evg_node; /* In eviction_group's "rules" heap. */ + struct eviction_group *eviction_group; /* NULL if not in any group. */ + + 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 * @@ -121,12 +200,19 @@ rule_from_cls_rule(const struct cls_rule *cls_rule) return cls_rule ? CONTAINER_OF(cls_rule, struct rule, cr) : NULL; } +void ofproto_rule_update_used(struct rule *, long long int used); void ofproto_rule_expire(struct rule *, uint8_t reason); void ofproto_rule_destroy(struct rule *); -void ofoperation_complete(struct ofoperation *, int status); +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. * * @@ -219,7 +305,7 @@ struct rule *ofoperation_get_victim(struct ofoperation *); * * Most of these functions return 0 if they are successful or a positive error * code on failure. Depending on the function, valid error codes are either - * errno values or OpenFlow error codes constructed with ofp_mkerr(). + * errno values or OFPERR_* OpenFlow error codes. * * Most of these functions are expected to execute synchronously, that is, to * block as necessary to obtain a result. Thus, these functions may return @@ -273,14 +359,11 @@ struct ofproto_class { * * When ->construct() is called, the client does not yet know how many flow * tables the datapath supports, so ofproto->n_tables will be 0 and - * ofproto->tables will be NULL. ->construct() should store the number of - * flow tables supported by the datapath (between 1 and 255, inclusive) - * into '*n_tables'. After a successful return, the client will initialize - * the base 'n_tables' member to '*n_tables' and allocate and initialize - * the base 'tables' member as the specified number of empty flow tables. - * Each flow table will be initially empty, so ->construct() should delete - * flows from the underlying datapath, if necessary, rather than populating - * the tables. + * ofproto->tables will be NULL. ->construct() should call + * ofproto_init_tables() to allocate and initialize ofproto->n_tables and + * ofproto->tables. Each flow table will be initially empty, so + * ->construct() should delete flows from the underlying datapath, if + * necessary, rather than populating the tables. * * 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 @@ -303,7 +386,7 @@ struct ofproto_class { * returns. */ struct ofproto *(*alloc)(void); - int (*construct)(struct ofproto *ofproto, int *n_tables); + int (*construct)(struct ofproto *ofproto); void (*destruct)(struct ofproto *ofproto); void (*dealloc)(struct ofproto *ofproto); @@ -316,17 +399,32 @@ struct ofproto_class { * - Call ofproto_rule_expire() for each OpenFlow flow that has reached * its hard_timeout or idle_timeout, to expire the flow. * - * Returns 0 if successful, otherwise a positive errno value. The ENODEV - * return value specifically means that the datapath underlying 'ofproto' - * has been destroyed (externally, e.g. by an admin running ovs-dpctl). - */ + * (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); + /* Performs periodic activity required by 'ofproto' 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. */ + int (*run_fast)(struct ofproto *ofproto); + /* Causes the poll loop to wake up when 'ofproto''s 'run' function needs to * be called, e.g. by calling the timer or fd waiting functions in * 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 @@ -344,14 +442,10 @@ struct ofproto_class { * 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. * @@ -362,7 +456,7 @@ struct ofproto_class { * * - 'name' to "table#" where # is the table ID. * - * - 'wildcards' to OFPFW_ALL. + * - 'wildcards' to OFPFW10_ALL. * * - 'max_entries' to 1,000,000. * @@ -437,15 +531,16 @@ struct ofproto_class { * 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. @@ -473,6 +568,10 @@ struct ofproto_class { * convenient. */ int (*port_del)(struct ofproto *ofproto, uint16_t ofp_port); + /* Get port stats */ + int (*port_get_stats)(const struct ofport *port, + struct netdev_stats *stats); + /* Port iteration functions. * * The client might not be entirely in control of the ports within an @@ -599,7 +698,7 @@ struct ofproto_class { /* Chooses an appropriate table for 'cls_rule' within 'ofproto'. On * success, stores the table ID into '*table_idp' and returns 0. On - * failure, returns an OpenFlow error code (as returned by ofp_mkerr()). + * failure, returns an OpenFlow error code. * * The choice of table should be a function of 'cls_rule' and 'ofproto''s * datapath capabilities. It should not depend on the flows already in @@ -611,9 +710,9 @@ struct ofproto_class { * should choose one arbitrarily (but deterministically). * * If this function is NULL then table 0 is always chosen. */ - int (*rule_choose_table)(const struct ofproto *ofproto, - const struct cls_rule *cls_rule, - uint8_t *table_idp); + enum ofperr (*rule_choose_table)(const struct ofproto *ofproto, + const struct cls_rule *cls_rule, + uint8_t *table_idp); /* Life-cycle functions for a "struct rule" (see "Life Cycle" above). * @@ -697,13 +796,11 @@ struct ofproto_class { * 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 '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. * * - If the rule is valid, update the datapath flow table, adding the new * rule or replacing the existing one. @@ -724,8 +821,8 @@ struct ofproto_class { * * * Call ofoperation_complete() and return 0. * - * * Return an OpenFlow error code (as returned by ofp_mkerr()). (Do - * not call ofoperation_complete() in this case.) + * * Return an OpenFlow error code. (Do not call + * ofoperation_complete() in this case.) * * Either way, ->rule_destruct() will not be called for 'rule', but * ->rule_dealloc() will be. @@ -750,7 +847,7 @@ struct ofproto_class { * * Rule destruction must not fail. */ struct rule *(*rule_alloc)(void); - int (*rule_construct)(struct rule *rule); + enum ofperr (*rule_construct)(struct rule *rule); void (*rule_destruct)(struct rule *rule); void (*rule_dealloc)(struct rule *rule); @@ -770,14 +867,14 @@ struct ofproto_class { * '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 - * for the incoming packet. The register values are zeroed. + * for the incoming packet. The register values are zeroed. 'packet''s + * header pointers (e.g. packet->l3) are appropriately initialized. * - * The statistics for 'packet' should be included in 'rule'. + * The implementation should add the statistics for 'packet' into 'rule'. * - * Returns 0 if successful, otherwise an OpenFlow error code (as returned - * by ofp_mkerr()). */ - int (*rule_execute)(struct rule *rule, struct flow *flow, - struct ofpbuf *packet); + * Returns 0 if successful, otherwise an OpenFlow error code. */ + enum ofperr (*rule_execute)(struct rule *rule, const struct flow *flow, + struct ofpbuf *packet); /* When ->rule_modify_actions() is called, the caller has already replaced * the OpenFlow actions in 'rule' by a new set. (The original actions are @@ -802,40 +899,78 @@ struct ofproto_class { * rule. */ void (*rule_modify_actions)(struct rule *rule); - /* These functions implement the OpenFlow IP fragment handling policy. By - * default ('drop_frags' == false), an OpenFlow switch should treat IP - * fragments the same way as other packets (although TCP and UDP port - * numbers cannot be determined). With 'drop_frags' == true, the switch - * should drop all IP fragments without passing them through the flow - * table. */ - bool (*get_drop_frags)(struct ofproto *ofproto); - void (*set_drop_frags)(struct ofproto *ofproto, bool drop_frags); + /* 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). + * + * - OFPC_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 + * 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. + * + * Implementations are not required to support every mode. + * OFPC_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 + * true if the requested mode was set, false if it is not supported. + * + * Upon successful return, the caller changes 'ofproto->frag_handling' to + * reflect the new mode. + */ + bool (*set_frag_handling)(struct ofproto *ofproto, + 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 (as - * returned by ofp_mkerr()). + * This function must validate that it can 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->tun_id 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_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. + * + * (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 (as returned - * by ofp_mkerr()). */ - int (*packet_out)(struct ofproto *ofproto, struct ofpbuf *packet, - const struct flow *flow, - const union ofp_action *actions, - size_t n_actions); + * Returns 0 if successful, otherwise an OpenFlow error code. */ + enum ofperr (*packet_out)(struct ofproto *ofproto, struct ofpbuf *packet, + const struct flow *flow, + const struct ofpact *ofpacts, + size_t ofpacts_len); /* ## ------------------------- ## */ /* ## OFPP_NORMAL configuration ## */ @@ -871,9 +1006,10 @@ struct ofproto_class { * 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 1 if CFM - * is faulted (generally indicating a connectivity problem), 0 if CFM is - * not faulted, or -1 if CFM is not enabled on 'port' + /* 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'. * * This function may be a null pointer if the ofproto implementation does * not support CFM. */ @@ -889,6 +1025,75 @@ struct ofproto_class { 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. + * + * This function may be a null pointer if the ofproto implementation does + * not support CFM. */ + int (*get_cfm_health)(const struct ofport *ofport); + + /* Configures spanning tree protocol (STP) on 'ofproto' using the + * settings defined in 's'. + * + * If 's' is nonnull, configures STP according to its members. + * + * If 's' is null, removes any STP configuration from 'ofproto'. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support STP, as does a null pointer. */ + int (*set_stp)(struct ofproto *ofproto, + const struct ofproto_stp_settings *s); + + /* Retrieves state of spanning tree protocol (STP) on 'ofproto'. + * + * Stores STP state for 'ofproto' in 's'. If the 'enabled' member + * is false, the other member values are not meaningful. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support STP, as does a null pointer. */ + int (*get_stp_status)(struct ofproto *ofproto, + struct ofproto_stp_status *s); + + /* Configures spanning tree protocol (STP) on 'ofport' using the + * settings defined in 's'. + * + * If 's' is nonnull, configures STP according to its members. The + * caller is responsible for assigning STP port numbers (using the + * 'port_num' member in the range of 1 through 255, inclusive) and + * ensuring there are no duplicates. + * + * If 's' is null, removes any STP configuration from 'ofport'. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support STP, as does a null pointer. */ + int (*set_stp_port)(struct ofport *ofport, + const struct ofproto_port_stp_settings *s); + + /* Retrieves spanning tree protocol (STP) port status of 'ofport'. + * + * Stores STP state for 'ofport' in 's'. If the 'enabled' member is + * false, the other member values are not meaningful. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support STP, as does a null pointer. */ + int (*get_stp_port_status)(struct ofport *ofport, + struct ofproto_port_stp_status *s); + + /* Registers meta-data associated with the 'n_qdscp' Qualities of Service + * 'queues' attached to 'ofport'. This data is not intended to be + * sufficient to implement QoS. Instead, providers may use this + * information to implement features which require knowledge of what queues + * exist on a port, and some basic information about them. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support QoS, as does a null pointer. */ + int (*set_queues)(struct ofport *ofport, + const struct ofproto_port_queue *queues, size_t n_qdscp); + /* If 's' is nonnull, this function registers a "bundle" associated with * client data pointer 'aux' in 'ofproto'. A bundle is the same concept as * a Port in OVSDB, that is, it consists of one or more "slave" devices @@ -924,13 +1129,23 @@ struct ofproto_class { * 'ofproto' associated with client data pointer 'aux'. If no such mirror * has been registered, this has no effect. * - * This function affects only the behavior of the OFPP_NORMAL action. An - * implementation that does not support it 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. */ + * An implementation that does not support mirroring 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 (*mirror_set)(struct ofproto *ofproto, void *aux, const struct ofproto_mirror_settings *s); + /* Retrieves statistics from mirror associated with client data + * pointer 'aux' in 'ofproto'. Stores packet and byte counts in + * 'packets' and 'bytes', respectively. If a particular counter is + * not supported, the appropriate argument is set to UINT64_MAX. + * + * EOPNOTSUPP as a return value indicates that this ofproto_class does not + * support retrieving mirror statistics. */ + int (*mirror_get_stats)(struct ofproto *ofproto, void *aux, + uint64_t *packets, uint64_t *bytes); + /* Configures the VLANs whose bits are set to 1 in 'flood_vlans' as VLANs * on which all packets are flooded, instead of using MAC learning. If * 'flood_vlans' is NULL, then MAC learning applies to all VLANs. @@ -943,11 +1158,34 @@ struct ofproto_class { /* Returns true if 'aux' is a registered bundle that is currently in use as * the output for a mirror. */ - bool (*is_mirror_output_bundle)(struct ofproto *ofproto, void *aux); + bool (*is_mirror_output_bundle)(const struct ofproto *ofproto, void *aux); /* When the configuration option of forward_bpdu changes, this function * 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); + +/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) + * + * This is deprecated. It is only for compatibility with broken device drivers + * in old versions of Linux that do not properly support VLANs when VLAN + * devices are not used. When broken device drivers are no longer in + * widespread use, we will delete these interfaces. */ + + /* If 'realdev_ofp_port' is nonzero, then this function configures 'ofport' + * as a VLAN splinter port for VLAN 'vid', associated with the real device + * that has OpenFlow port number 'realdev_ofp_port'. + * + * If 'realdev_ofp_port' is zero, then this function deconfigures 'ofport' + * as a VLAN splinter port. + * + * This function should be NULL if a an implementation does not support + * it. */ + int (*set_realdev)(struct ofport *ofport, + uint16_t realdev_ofp_port, int vid); }; extern const struct ofproto_class ofproto_dpif_class; @@ -955,8 +1193,21 @@ extern const struct ofproto_class ofproto_dpif_class; int ofproto_class_register(const struct ofproto_class *); int ofproto_class_unregister(const struct ofproto_class *); +/* ofproto_flow_mod() returns this value if the flow_mod could not be processed + * because it overlaps with an ongoing flow table operation that has not yet + * completed. The caller should retry the operation later. + * + * ofproto.c also uses this value internally for additional (similar) purposes. + * + * This particular value is a good choice because it is large, so that it does + * not collide with any errno value, but not large enough to collide with an + * OFPERR_* value. */ +enum { OFPROTO_POSTPONE = 1 << 16 }; +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); + const struct ofpact *ofpacts, size_t ofpacts_len); bool ofproto_delete_flow(struct ofproto *, const struct cls_rule *); void ofproto_flush_flows(struct ofproto *);