X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=b995831832ea2615ccc0d1538fcf35a99589fe04;hb=ef13dc11ad6ec612954bd5b59751cc437f504e65;hp=7f1b110fad1f924dd9c2fdccc97d3e807bc59882;hpb=5a2dfd473a65a041356971771c99e4a9d04b3f9c;p=openvswitch diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index 7f1b110f..b9958318 100644 --- a/ofproto/ofproto-provider.h +++ b/ofproto/ofproto-provider.h @@ -23,6 +23,7 @@ #include "cfm.h" #include "classifier.h" #include "list.h" +#include "ofp-errors.h" #include "shash.h" #include "timeval.h" @@ -69,6 +70,15 @@ struct ofproto { struct list pending; /* List of "struct ofopgroup"s. */ unsigned int n_pending; /* list_size(&pending). */ struct hmap deletions; /* All OFOPERATION_DELETE "ofoperation"s. */ + + /* 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. */ }; struct ofproto *ofproto_lookup(const char *name); @@ -131,7 +141,7 @@ rule_from_cls_rule(const struct cls_rule *cls_rule) void ofproto_rule_expire(struct rule *, uint8_t reason); void ofproto_rule_destroy(struct rule *); -void ofoperation_complete(struct ofoperation *, int status); +void ofoperation_complete(struct ofoperation *, enum ofperr); struct rule *ofoperation_get_victim(struct ofoperation *); /* ofproto class structure, to be defined by each ofproto implementation. @@ -226,7 +236,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 @@ -323,12 +333,17 @@ 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). - */ + * 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. */ @@ -480,6 +495,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 @@ -606,7 +625,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 @@ -618,9 +637,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). * @@ -731,8 +750,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. @@ -757,7 +776,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); @@ -781,10 +800,9 @@ struct ofproto_class { * * The statistics for 'packet' should be included in '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 @@ -848,8 +866,7 @@ struct ofproto_class { * * 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()). + * the datapath. 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 @@ -859,12 +876,11 @@ struct ofproto_class { * '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 union ofp_action *actions, + size_t n_actions); /* ## ------------------------- ## */ /* ## OFPP_NORMAL configuration ## */ @@ -918,6 +934,64 @@ struct ofproto_class { int (*get_cfm_remote_mpids)(const struct ofport *ofport, const uint64_t **rmps, size_t *n_rmps); + /* 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 @@ -953,13 +1027,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. @@ -977,6 +1061,25 @@ struct ofproto_class { /* When the configuration option of forward_bpdu changes, this function * will be invoked. */ void (*forward_bpdu_changed)(struct ofproto *ofproto); + +/* 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; @@ -990,10 +1093,11 @@ int ofproto_class_unregister(const struct ofproto_class *); * * ofproto.c also uses this value internally for additional (similar) purposes. * - * This particular value is a good choice because it is negative (so it won't - * collide with any errno value or any value returned by ofp_mkerr()) and large - * (so it won't accidentally collide with EOF or a negative errno value). */ -enum { OFPROTO_POSTPONE = -100000 }; + * 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 *,