X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=565cb01c12e5e27b393032e362ef7bae9199badb;hb=7431e17196fdb1c3189d67e3aeed4adeab4cf479;hp=0ade586c75c2453e206f43cf36cbb13721cc14ba;hpb=307975da7111cc223a9e2b859a0b12532fa4f2c8;p=sliver-openvswitch.git diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index 0ade586c7..565cb01c1 100644 --- a/ofproto/ofproto-provider.h +++ b/ofproto/ofproto-provider.h @@ -1,5 +1,5 @@ /* - * 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. @@ -23,16 +23,18 @@ #include "cfm.h" #include "classifier.h" #include "heap.h" +#include "hindex.h" #include "list.h" #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 simap; +struct bfd_cfg; /* An OpenFlow switch. * @@ -47,27 +49,33 @@ struct ofproto { /* Settings. */ uint64_t fallback_dpid; /* Datapath ID if no better choice found. */ uint64_t datapath_id; /* Datapath ID. */ - unsigned flow_eviction_threshold; /* Threshold at which to begin flow - * table eviction. Only affects the - * 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; - uint16_t max_ports; /* Max possible OpenFlow port num, plus one. */ + unsigned long *ofp_port_ids;/* Bitmap of used OpenFlow port numbers. */ + struct simap ofp_requests; /* OpenFlow port number requests. */ + ofp_port_t alloc_port_no; /* Last allocated OpenFlow port number. */ + ofp_port_t max_ports; /* Max possible OpenFlow port num, plus one. */ /* Flow tables. */ struct oftable *tables; int n_tables; + struct hindex cookies; /* Rules indexed on their cookie values. */ + + /* 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; @@ -95,10 +103,10 @@ struct ofproto { }; void ofproto_init_tables(struct ofproto *, int n_tables); -void ofproto_init_max_ports(struct ofproto *, uint16_t max_ports); +void ofproto_init_max_ports(struct ofproto *, ofp_port_t max_ports); struct ofproto *ofproto_lookup(const char *name); -struct ofport *ofproto_get_port(const struct ofproto *, uint16_t ofp_port); +struct ofport *ofproto_get_port(const struct ofproto *, ofp_port_t ofp_port); /* An OpenFlow port within a "struct ofproto". * @@ -109,13 +117,37 @@ struct ofport { struct ofproto *ofproto; /* The ofproto that contains this port. */ struct netdev *netdev; struct ofputil_phy_port pp; - uint16_t ofp_port; /* OpenFlow port number. */ + ofp_port_t ofp_port; /* OpenFlow port number. */ unsigned int change_seq; + long long int created; /* Time created, in msec. */ int mtu; }; 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. */ @@ -174,6 +206,7 @@ struct rule { struct ofoperation *pending; /* Operation now in progress, if nonnull. */ ovs_be64 flow_cookie; /* Controller-issued identifier. */ + struct hindex_node cookie_node; /* In owning ofproto's 'cookies' index. */ long long int created; /* Creation time. */ long long int modified; /* Time of last modification. */ @@ -195,8 +228,16 @@ struct rule { 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. */ }; +/* Threshold at which to begin flow table eviction. Only affects the + * ofproto-dpif implementation */ +extern unsigned flow_eviction_threshold; + static inline struct rule * rule_from_cls_rule(const struct cls_rule *cls_rule) { @@ -207,12 +248,12 @@ 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 *); -bool ofproto_rule_has_out_port(const struct rule *, uint16_t out_port); +bool ofproto_rule_has_out_port(const struct rule *, ofp_port_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 ofoperation_has_out_port(const struct ofoperation *, ofp_port_t out_port); bool ofproto_rule_is_hidden(const struct rule *); @@ -320,6 +361,16 @@ struct ofproto_class { /* ## 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. */ @@ -346,6 +397,48 @@ struct ofproto_class { */ 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 ## */ /* ## --------------------------- ## */ @@ -526,6 +619,8 @@ struct ofproto_class { /* 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 @@ -584,14 +679,14 @@ struct ofproto_class { 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. @@ -599,7 +694,7 @@ struct ofproto_class { * 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_del)(struct ofproto *ofproto, uint16_t ofp_port); + int (*port_del)(struct ofproto *ofproto, ofp_port_t ofp_port); /* Get port stats */ int (*port_get_stats)(const struct ofport *port, @@ -609,11 +704,9 @@ struct ofproto_class { * * 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. @@ -893,7 +986,7 @@ 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 + * 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. * @@ -968,7 +1061,7 @@ struct ofproto_class { * * 'flow' reflects the flow information for 'packet'. All of the * information in 'flow' is extracted from 'packet', except for - * flow->in_port (see below). flow->tun_id and its register values are + * 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 @@ -1023,6 +1116,20 @@ struct ofproto_class { 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. @@ -1034,44 +1141,30 @@ 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 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); - /* 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. + /* Configures BFD on 'ofport'. * - * 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 - * 0 if CFM is not enabled of 'ofport'. + * 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_remote_mpids)(const struct ofport *ofport, - const uint64_t **rmps, size_t *n_rmps); + * 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); - /* 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); + /* 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'. @@ -1201,9 +1294,14 @@ struct ofproto_class { * 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.) * @@ -1222,7 +1320,7 @@ struct ofproto_class { * 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); + ofp_port_t realdev_ofp_port, int vid); }; extern const struct ofproto_class ofproto_dpif_class;