X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=7b0e478bf983194bca3acc1c31da3d7feb2164e7;hb=3967a833e4db33f235f660f5d3f5bd96581d238d;hp=6c8583eacf8c9690e90e9f12f94a1a5ea397c064;hpb=6527c598eabbd34aaa7284f4b052de667e13be2f;p=sliver-openvswitch.git diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index 6c8583eac..7b0e478bf 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 Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -22,7 +22,10 @@ #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" @@ -33,10 +36,10 @@ struct ofputil_flow_mod; * 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. */ @@ -58,7 +61,7 @@ struct ofproto { struct shash port_by_name; /* Flow tables. */ - struct classifier *tables; /* Each classifier contains "struct rule"s. */ + struct oftable *tables; int n_tables; /* OpenFlow connections. */ @@ -78,42 +81,83 @@ struct ofproto { * 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 *, ovs_be32 state); +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. */ @@ -122,11 +166,17 @@ struct rule { long long int created; /* Creation time. */ long long int modified; /* Time of last modification. */ - uint16_t idle_timeout; /* In seconds from time of last use. */ - uint16_t hard_timeout; /* In seconds from 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? */ + /* 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. */ + union ofp_action *actions; /* OpenFlow actions. */ int n_actions; /* Number of elements in actions[]. */ }; @@ -137,10 +187,11 @@ 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); +void ofoperation_complete(struct ofoperation *, enum ofperr); struct rule *ofoperation_get_victim(struct ofoperation *); /* ofproto class structure, to be defined by each ofproto implementation. @@ -235,7 +286,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 @@ -289,14 +340,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 @@ -319,7 +367,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); @@ -365,14 +413,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. * @@ -458,15 +502,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. @@ -624,7 +669,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 @@ -636,9 +681,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). * @@ -749,8 +794,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. @@ -775,7 +820,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); @@ -795,14 +840,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, const 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 @@ -866,8 +911,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 @@ -877,12 +921,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,9 +961,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. */ @@ -936,6 +980,17 @@ 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'. * @@ -1064,6 +1119,10 @@ 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); + /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.) * * This is deprecated. It is only for compatibility with broken device drivers @@ -1095,10 +1154,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 *,