X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto-provider.h;h=c319d8fa4b8a270da1632335b4a383293ac12df5;hb=e2170cffc1e736db85b461b9bff2afa74ba180f2;hp=a74bf9ad7147cb1fa7d5fb5c6bb52e585a883cbd;hpb=751c778501b0e0726cc0c715f3ad2628c19ba0bb;p=openvswitch diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h index a74bf9ad..c319d8fa 100644 --- a/ofproto/ofproto-provider.h +++ b/ofproto/ofproto-provider.h @@ -29,7 +29,9 @@ #include "shash.h" #include "timeval.h" +struct ofpact; struct ofputil_flow_mod; +struct simap; /* An OpenFlow switch. * @@ -59,6 +61,7 @@ struct ofproto { /* Datapath. */ struct hmap ports; /* Contains "struct ofport"s. */ struct shash port_by_name; + uint16_t max_ports; /* Max possible OpenFlow port num, plus one. */ /* Flow tables. */ struct oftable *tables; @@ -73,6 +76,12 @@ struct ofproto { 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 @@ -85,6 +94,7 @@ struct ofproto { }; void ofproto_init_tables(struct ofproto *, int n_tables); +void ofproto_init_max_ports(struct ofproto *, uint16_t max_ports); struct ofproto *ofproto_lookup(const char *name); struct ofport *ofproto_get_port(const struct ofproto *, uint16_t ofp_port); @@ -177,8 +187,13 @@ struct rule { 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[]. */ + 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 * @@ -191,9 +206,15 @@ 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); + 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. * * @@ -346,6 +367,11 @@ struct ofproto_class { * ->construct() should delete flows from the underlying datapath, if * necessary, rather than populating the tables. * + * If the ofproto knows the maximum port number that the datapath can have, + * then it can call ofproto_init_max_ports(). If it does so, then the + * client will ensure that the actions it allows to be used through + * OpenFlow do not refer to ports above that maximum number. + * * 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 * attempt to "construct" the same datapath as part of another ofproto is @@ -380,6 +406,9 @@ struct ofproto_class { * - Call ofproto_rule_expire() for each OpenFlow flow that has reached * its hard_timeout or idle_timeout, to expire the flow. * + * (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); @@ -396,6 +425,13 @@ struct ofproto_class { * 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 @@ -427,7 +463,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. * @@ -452,10 +488,10 @@ struct ofproto_class { * - 'matched_count' to the number of packets looked up in this flow * table so far that matched one of the flow entries. * - * Keep in mind that all of the members of struct ofp_table_stats are in + * Keep in mind that all of the members of struct ofp10_table_stats are in * network byte order. */ - void (*get_tables)(struct ofproto *ofproto, struct ofp_table_stats *ots); + void (*get_tables)(struct ofproto *ofproto, struct ofp10_table_stats *ots); /* ## ---------------- ## */ /* ## ofport Functions ## */ @@ -767,13 +803,7 @@ 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 the datapath can correctly implement 'rule->ofpacts'. * * - If the rule is valid, update the datapath flow table, adding the new * rule or replacing the existing one. @@ -855,8 +885,8 @@ struct ofproto_class { * * ->rule_modify_actions() should set the following in motion: * - * - Validate that the actions now in 'rule' are well-formed OpenFlow - * actions that the datapath can correctly implement. + * - Validate that the datapath can correctly implement the actions now + * in 'rule'. * * - Update the datapath flow table with the new actions. * @@ -904,14 +934,13 @@ struct ofproto_class { 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. + * This function must validate that it can correctly 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 @@ -920,17 +949,18 @@ struct ofproto_class { * * 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. + * OFPERR_NXBRC_BAD_IN_PORT. (If the implementation called + * ofproto_init_max_ports(), then the client will reject these ports + * itself.) 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, @@ -943,8 +973,8 @@ struct ofproto_class { * 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); + const struct ofpact *ofpacts, + size_t ofpacts_len); /* ## ------------------------- ## */ /* ## OFPP_NORMAL configuration ## */ @@ -989,6 +1019,15 @@ struct ofproto_class { * not support CFM. */ int (*get_cfm_fault)(const struct ofport *ofport); + /* 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. + * + * 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 @@ -1181,7 +1220,7 @@ 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 *);