[ovs-dev] [PATCH 4/5] v2: ofproto: Implement OpenFlow 1.3 meter table.

Jarno Rajahalme jarno.rajahalme at nsn.com
Wed Jun 26 22:39:51 UTC 2013


Signed-off-by: Jarno Rajahalme <jarno.rajahalme at nsn.com>
---
v2: Addresses comments by Ben.
---
 lib/ofp-actions.c          |   20 +-
 lib/ofp-actions.h          |    2 +
 lib/rconn.c                |   14 +-
 ofproto/ofproto-dpif.c     |    4 +
 ofproto/ofproto-provider.h |   49 ++++-
 ofproto/ofproto.c          |  490 +++++++++++++++++++++++++++++++++++++++++---
 ofproto/ofproto.h          |    4 +
 7 files changed, 539 insertions(+), 44 deletions(-)

diff --git a/lib/ofp-actions.c b/lib/ofp-actions.c
index 34a700b..af7143a 100644
--- a/lib/ofp-actions.c
+++ b/lib/ofp-actions.c
@@ -1150,9 +1150,9 @@ exit:
     return error;
 }
 
-/* May modify flow->dl_type, caller must restore it. */
-static enum ofperr
-ofpact_check__(const struct ofpact *a, struct flow *flow, ofp_port_t max_ports)
+enum ofperr
+ofpacts_check_action(const struct ofpact *a, const struct flow *flow,
+                     ovs_be16 *new_dl_type, ofp_port_t max_ports)
 {
     const struct ofpact_enqueue *enqueue;
 
@@ -1225,11 +1225,11 @@ ofpact_check__(const struct ofpact *a, struct flow *flow, ofp_port_t max_ports)
         return 0;
 
     case OFPACT_PUSH_MPLS:
-        flow->dl_type = ofpact_get_PUSH_MPLS(a)->ethertype;
+        *new_dl_type = ofpact_get_PUSH_MPLS(a)->ethertype;
         return 0;
 
     case OFPACT_POP_MPLS:
-        flow->dl_type = ofpact_get_POP_MPLS(a)->ethertype;
+        *new_dl_type = ofpact_get_POP_MPLS(a)->ethertype;
         return 0;
 
     case OFPACT_SAMPLE:
@@ -1237,10 +1237,16 @@ ofpact_check__(const struct ofpact *a, struct flow *flow, ofp_port_t max_ports)
 
     case OFPACT_CLEAR_ACTIONS:
     case OFPACT_WRITE_METADATA:
-    case OFPACT_METER:
     case OFPACT_GOTO_TABLE:
         return 0;
 
+    case OFPACT_METER: {
+        uint32_t mid = ofpact_get_METER(a)->meter_id;
+        if (mid == 0 || mid > OFPM13_MAX) {
+            return OFPERR_OFPMMFC_INVALID_METER;
+        }
+        return 0;
+    }
     default:
         NOT_REACHED();
     }
@@ -1260,7 +1266,7 @@ ofpacts_check(const struct ofpact ofpacts[], size_t ofpacts_len,
     enum ofperr error = 0;
 
     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
-        error = ofpact_check__(a, flow, max_ports);
+        error = ofpacts_check_action(a, flow, &flow->dl_type, max_ports);
         if (error) {
             break;
         }
diff --git a/lib/ofp-actions.h b/lib/ofp-actions.h
index 799f64c..ca80cdf 100644
--- a/lib/ofp-actions.h
+++ b/lib/ofp-actions.h
@@ -501,6 +501,8 @@ enum ofperr ofpacts_pull_openflow11_instructions(struct ofpbuf *openflow,
                                                  unsigned int instructions_len,
                                                  uint8_t table_id,
                                                  struct ofpbuf *ofpacts);
+enum ofperr ofpacts_check_action(const struct ofpact *, const struct flow *,
+                                 ovs_be16 *new_dl_type, ofp_port_t max_ports);
 enum ofperr ofpacts_check(const struct ofpact[], size_t ofpacts_len,
                           struct flow *, ofp_port_t max_ports);
 enum ofperr ofpacts_verify(const struct ofpact ofpacts[], size_t ofpacts_len);
diff --git a/lib/rconn.c b/lib/rconn.c
index 4922a5c..ffd2738 100644
--- a/lib/rconn.c
+++ b/lib/rconn.c
@@ -1137,19 +1137,12 @@ is_admitted_msg(const struct ofpbuf *b)
     case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
     case OFPTYPE_GET_ASYNC_REQUEST:
     case OFPTYPE_GET_ASYNC_REPLY:
-    case OFPTYPE_METER_MOD:
     case OFPTYPE_GROUP_REQUEST:
     case OFPTYPE_GROUP_REPLY:
     case OFPTYPE_GROUP_DESC_REQUEST:
     case OFPTYPE_GROUP_DESC_REPLY:
     case OFPTYPE_GROUP_FEATURES_REQUEST:
     case OFPTYPE_GROUP_FEATURES_REPLY:
-    case OFPTYPE_METER_REQUEST:
-    case OFPTYPE_METER_REPLY:
-    case OFPTYPE_METER_CONFIG_REQUEST:
-    case OFPTYPE_METER_CONFIG_REPLY:
-    case OFPTYPE_METER_FEATURES_REQUEST:
-    case OFPTYPE_METER_FEATURES_REPLY:
     case OFPTYPE_TABLE_FEATURES_REQUEST:
     case OFPTYPE_TABLE_FEATURES_REPLY:
         return false;
@@ -1160,6 +1153,7 @@ is_admitted_msg(const struct ofpbuf *b)
     case OFPTYPE_PACKET_OUT:
     case OFPTYPE_FLOW_MOD:
     case OFPTYPE_PORT_MOD:
+    case OFPTYPE_METER_MOD:
     case OFPTYPE_BARRIER_REQUEST:
     case OFPTYPE_BARRIER_REPLY:
     case OFPTYPE_DESC_STATS_REQUEST:
@@ -1176,6 +1170,12 @@ is_admitted_msg(const struct ofpbuf *b)
     case OFPTYPE_QUEUE_STATS_REPLY:
     case OFPTYPE_PORT_DESC_STATS_REQUEST:
     case OFPTYPE_PORT_DESC_STATS_REPLY:
+    case OFPTYPE_METER_REQUEST:
+    case OFPTYPE_METER_REPLY:
+    case OFPTYPE_METER_CONFIG_REQUEST:
+    case OFPTYPE_METER_CONFIG_REPLY:
+    case OFPTYPE_METER_FEATURES_REQUEST:
+    case OFPTYPE_METER_FEATURES_REPLY:
     case OFPTYPE_ROLE_REQUEST:
     case OFPTYPE_ROLE_REPLY:
     case OFPTYPE_SET_FLOW_FORMAT:
diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c
index c6a7abc..68f7fad 100644
--- a/ofproto/ofproto-dpif.c
+++ b/ofproto/ofproto-dpif.c
@@ -6810,4 +6810,8 @@ const struct ofproto_class ofproto_dpif_class = {
     forward_bpdu_changed,
     set_mac_table_config,
     set_realdev,
+    NULL,                       /* meter_get_features */
+    NULL,                       /* meter_set */
+    NULL,                       /* meter_get */
+    NULL,                       /* meter_del */
 };
diff --git a/ofproto/ofproto-provider.h b/ofproto/ofproto-provider.h
index 565cb01..96471cd 100644
--- a/ofproto/ofproto-provider.h
+++ b/ofproto/ofproto-provider.h
@@ -35,6 +35,7 @@ struct match;
 struct ofpact;
 struct ofputil_flow_mod;
 struct bfd_cfg;
+struct meter;
 
 /* An OpenFlow switch.
  *
@@ -76,6 +77,14 @@ struct ofproto {
      * These flows should all be present in tables. */
     struct list expirable;      /* Expirable 'struct rule"s in all tables. */
 
+    /* Meter table.
+     * OpenFlow meters start at 1.  To avoid confusion we leave the first
+     * pointer in the array un-used, and index directly with the OpenFlow
+     * meter_id. */
+    struct ofputil_meter_features meter_features;
+    struct meter **meters; /* 'meter_features.max_meter' + 1 pointers. */
+    uint32_t last_meter;   /* Last meter in use or 0. */
+
     /* OpenFlow connections. */
     struct connmgr *connmgr;
 
@@ -224,6 +233,9 @@ struct rule {
     struct ofpact *ofpacts;      /* Sequence of "struct ofpacts". */
     unsigned int ofpacts_len;    /* Size of 'ofpacts', in bytes. */
 
+    uint32_t meter_id;           /* Non-zero OF meter_id, or zero. */
+    struct list meter_list_node; /* In owning meter's 'rules' list. */
+
     /* Flow monitors. */
     enum nx_flow_monitor_flags monitor_flags;
     uint64_t add_seqno;         /* Sequence number when added. */
@@ -1317,10 +1329,43 @@ struct ofproto_class {
      * 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. */
+     * This function should be NULL if an implementation does not support it.
+     */
     int (*set_realdev)(struct ofport *ofport,
                        ofp_port_t realdev_ofp_port, int vid);
+
+/* ## ------------------------ ## */
+/* ## OpenFlow Meter Functions ## */
+/* ## ------------------------ ## */
+
+    /* These functions should be NULL if an implementation does not support
+     * them.  If meter_get_features is non-NULL, then the rest must also
+     * be non-NULL. */
+    void (*meter_get_features)(const struct ofproto *,
+                               struct ofputil_meter_features *);
+    /* Modifies an existing meter, if the 'ofproto_meter_id *' points to
+     * a value other than UINT32_MAX, otherwise adds a new meter.  On success
+     * a provider meter id is stored at 'ofproto_meter_id *'.  All further
+     * references to the meter will be made with the returned provider meter id
+     * rather than the OpenFlow meter id.  The caller does not try to interpret
+     * the provider meter id (other than UINT32_MAX signifying an invalid
+     * provider meter id), giving the implementation the freedom to either use
+     * the OpenFlow meter_id value provided in the meter configuration, or any
+     * other value suitable for the implementation.
+     * If a meter modification fails, the existing meter configuration is left
+     * intact. */
+    enum ofperr (*meter_set)(struct ofproto *, ofproto_meter_id *,
+                             const struct ofputil_meter_config *);
+    /* Gets the meter and meter band packet and byte counts for maximum of
+     * 'stats->n_bands' bands.  The caller fills in the other stats values.
+     * The band stats are copied to memory at 'stats->bands' provided by the
+     * caller.  The number of returned band stats is returned in
+     * 'stats->n_bands'. */
+    enum ofperr (*meter_get)(const struct ofproto *, ofproto_meter_id,
+                             struct ofputil_meter_stats *stats);
+    /* Deletes a meter, making the 'ofproto_meter_id' invalid for any
+     * further calls. */
+    void (*meter_del)(struct ofproto *, ofproto_meter_id);
 };
 
 extern const struct ofproto_class ofproto_dpif_class;
diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c
index 66aa3c9..b6f1944 100644
--- a/ofproto/ofproto.c
+++ b/ofproto/ofproto.c
@@ -126,6 +126,7 @@ struct ofoperation {
     /* OFOPERATION_MODIFY: The old actions, if the actions are changing. */
     struct ofpact *ofpacts;
     size_t ofpacts_len;
+    uint32_t meter_id;
 
     /* OFOPERATION_DELETE. */
     enum ofp_flow_removed_reason reason; /* Reason flow was removed. */
@@ -197,13 +198,15 @@ static bool rule_is_modifiable(const struct rule *);
 /* OpenFlow. */
 static enum ofperr add_flow(struct ofproto *, struct ofconn *,
                             const struct ofputil_flow_mod *,
-                            const struct ofp_header *);
+                            const struct ofp_header *,
+                            const uint32_t *meter_id);
 static void delete_flow__(struct rule *, struct ofopgroup *,
                           enum ofp_flow_removed_reason);
 static bool handle_openflow(struct ofconn *, const struct ofpbuf *);
 static enum ofperr handle_flow_mod__(struct ofproto *, struct ofconn *,
                                      const struct ofputil_flow_mod *,
-                                     const struct ofp_header *);
+                                     const struct ofp_header *,
+                                     const uint32_t *meter_id);
 static void calc_duration(long long int start, long long int now,
                           uint32_t *sec, uint32_t *nsec);
 
@@ -465,6 +468,17 @@ ofproto_create(const char *datapath_name, const char *datapath_type,
     ofproto->datapath_id = pick_datapath_id(ofproto);
     init_ports(ofproto);
 
+    /* Initialize meters table. */
+    if (ofproto->ofproto_class->meter_get_features) {
+        ofproto->ofproto_class->meter_get_features(ofproto,
+                                                   &ofproto->meter_features);
+    } else {
+        memset(&ofproto->meter_features, 0, sizeof ofproto->meter_features);
+    }
+    ofproto->meters = xzalloc((ofproto->meter_features.max_meters + 1)
+                              * sizeof(struct meter *));
+    ofproto->last_meter = 0; /* Last meter in use or zero. */
+
     *ofprotop = ofproto;
     return 0;
 }
@@ -1571,7 +1585,7 @@ ofproto_port_del(struct ofproto *ofproto, ofp_port_t ofp_port)
 
 /* Adds a flow to OpenFlow flow table 0 in 'p' that matches 'cls_rule' and
  * performs the 'n_actions' actions in 'actions'.  The new flow will not
- * timeout.
+ * timeout and its actions may not include a meter action.
  *
  * If cls_rule->priority is in the range of priorities supported by OpenFlow
  * (0...65535, inclusive) then the flow will be visible to OpenFlow
@@ -1592,6 +1606,7 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match,
     if (!rule || !ofpacts_equal(rule->ofpacts, rule->ofpacts_len,
                                 ofpacts, ofpacts_len)) {
         struct ofputil_flow_mod fm;
+        uint32_t meter_id = 0;
 
         memset(&fm, 0, sizeof fm);
         fm.match = *match;
@@ -1599,7 +1614,7 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match,
         fm.buffer_id = UINT32_MAX;
         fm.ofpacts = xmemdup(ofpacts, ofpacts_len);
         fm.ofpacts_len = ofpacts_len;
-        add_flow(ofproto, NULL, &fm, NULL);
+        add_flow(ofproto, NULL, &fm, NULL, &meter_id);
         free(fm.ofpacts);
     }
 }
@@ -1608,11 +1623,14 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match,
  * OFPERR_* OpenFlow error code on failure, or OFPROTO_POSTPONE if the
  * operation cannot be initiated now but may be retried later.
  *
+ * 'fm->ofpacts' may not contain a meter action.
+ *
  * This is a helper function for in-band control and fail-open. */
 int
 ofproto_flow_mod(struct ofproto *ofproto, const struct ofputil_flow_mod *fm)
 {
-    return handle_flow_mod__(ofproto, NULL, fm, NULL);
+    uint32_t meter_id = 0;
+    return handle_flow_mod__(ofproto, NULL, fm, NULL, &meter_id);
 }
 
 /* Searches for a rule with matching criteria exactly equal to 'target' in
@@ -2361,6 +2379,46 @@ reject_slave_controller(struct ofconn *ofconn)
     }
 }
 
+/* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are
+ * appropriate for a packet with the prerequisites satisfied by 'flow'.
+ * 'flow' may be temporarily modified, but is restored at return.
+ * If the actions include a meter action, and a non-NULL 'meter_id' is
+ * provided, the meter_id is stored at '*meter_id', if valid.
+ */
+static enum ofperr
+ofproto_check_ofpacts(struct ofproto *ofproto,
+                      const struct ofpact ofpacts[], size_t ofpacts_len,
+                      struct flow *flow, uint32_t *meter_id)
+{
+    const struct ofpact *a;
+    ovs_be16 dl_type = flow->dl_type;
+    enum ofperr error = 0;
+
+    OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
+        if (a->type == OFPACT_METER) {
+            uint32_t mid = 0;
+
+            mid = ofpact_get_METER(a)->meter_id;
+
+            if (ofproto_get_provider_meter_id(ofproto, mid) != UINT32_MAX) {
+                if (meter_id) {
+                    *meter_id = mid;
+                }
+            } else {
+                error = OFPERR_OFPMMFC_INVALID_METER;
+            }
+        } else {
+            error = ofpacts_check_action(a, flow, &flow->dl_type,
+                                         ofproto->max_ports);
+        }
+        if (error) {
+            break;
+        }
+    }
+    flow->dl_type = dl_type; /* Restore. */
+    return error;
+}
+
 static enum ofperr
 handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh)
 {
@@ -2407,7 +2465,7 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh)
     /* Verify actions against packet, then send packet if successful. */
     in_port_.ofp_port = po.in_port;
     flow_extract(payload, 0, 0, NULL, &in_port_, &flow);
-    error = ofpacts_check(po.ofpacts, po.ofpacts_len, &flow, p->max_ports);
+    error = ofproto_check_ofpacts(p, po.ofpacts, po.ofpacts_len, &flow, NULL);
     if (!error) {
         error = p->ofproto_class->packet_out(p, payload, &flow,
                                              po.ofpacts, po.ofpacts_len);
@@ -3217,7 +3275,8 @@ is_flow_deletion_pending(const struct ofproto *ofproto,
  * if any. */
 static enum ofperr
 add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
-         const struct ofputil_flow_mod *fm, const struct ofp_header *request)
+         const struct ofputil_flow_mod *fm, const struct ofp_header *request,
+         const uint32_t *meter_id)
 {
     struct oftable *table;
     struct ofopgroup *group;
@@ -3294,6 +3353,8 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
        and OFPFF13_NO_BYT_COUNTS */
     rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len);
     rule->ofpacts_len = fm->ofpacts_len;
+    rule->meter_id = *meter_id;
+    list_init(&rule->meter_list_node);
     rule->evictable = true;
     rule->eviction_group = NULL;
     list_init(&rule->expirable);
@@ -3365,7 +3426,8 @@ exit:
 static enum ofperr
 modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
                const struct ofputil_flow_mod *fm,
-               const struct ofp_header *request, struct list *rules)
+               const struct ofp_header *request,
+               const uint32_t *meter_id, struct list *rules)
 {
     struct ofopgroup *group;
     struct rule *rule;
@@ -3397,8 +3459,10 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
         if (actions_changed) {
             op->ofpacts = rule->ofpacts;
             op->ofpacts_len = rule->ofpacts_len;
+            op->meter_id = rule->meter_id;
             rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len);
             rule->ofpacts_len = fm->ofpacts_len;
+            rule->meter_id = *meter_id;
             rule->ofproto->ofproto_class->rule_modify_actions(rule);
         } else {
             ofoperation_complete(op, 0);
@@ -3412,12 +3476,13 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
 static enum ofperr
 modify_flows_add(struct ofproto *ofproto, struct ofconn *ofconn,
                  const struct ofputil_flow_mod *fm,
-                 const struct ofp_header *request)
+                 const struct ofp_header *request,
+                 const uint32_t *meter_id)
 {
     if (fm->cookie_mask != htonll(0) || fm->new_cookie == htonll(UINT64_MAX)) {
         return 0;
     }
-    return add_flow(ofproto, ofconn, fm, request);
+    return add_flow(ofproto, ofconn, fm, request, meter_id);
 }
 
 /* Implements OFPFC_MODIFY.  Returns 0 on success or an OpenFlow error code on
@@ -3428,7 +3493,8 @@ modify_flows_add(struct ofproto *ofproto, struct ofconn *ofconn,
 static enum ofperr
 modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
                    const struct ofputil_flow_mod *fm,
-                   const struct ofp_header *request)
+                   const struct ofp_header *request,
+                   const uint32_t *meter_id)
 {
     struct list rules;
     int error;
@@ -3439,9 +3505,9 @@ modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
     if (error) {
         return error;
     } else if (list_is_empty(&rules)) {
-        return modify_flows_add(ofproto, ofconn, fm, request);
+        return modify_flows_add(ofproto, ofconn, fm, request, meter_id);
     } else {
-        return modify_flows__(ofproto, ofconn, fm, request, &rules);
+        return modify_flows__(ofproto, ofconn, fm, request, meter_id, &rules);
     }
 }
 
@@ -3453,7 +3519,8 @@ modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
 static enum ofperr
 modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
                    const struct ofputil_flow_mod *fm,
-                   const struct ofp_header *request)
+                   const struct ofp_header *request,
+                   const uint32_t *meter_id)
 {
     struct list rules;
     int error;
@@ -3465,10 +3532,11 @@ modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
     if (error) {
         return error;
     } else if (list_is_empty(&rules)) {
-        return modify_flows_add(ofproto, ofconn, fm, request);
+        return modify_flows_add(ofproto, ofconn, fm, request, meter_id);
     } else {
         return list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
-                                                          fm, request, &rules)
+                                                          fm, request,
+                                                          meter_id, &rules)
                                          : 0;
     }
 }
@@ -3618,6 +3686,7 @@ handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh)
     struct ofpbuf ofpacts;
     enum ofperr error;
     long long int now;
+    uint32_t meter_id = 0;
 
     error = reject_slave_controller(ofconn);
     if (error) {
@@ -3628,11 +3697,12 @@ handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh)
     error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_protocol(ofconn),
                                     &ofpacts);
     if (!error) {
-        error = ofpacts_check(fm.ofpacts, fm.ofpacts_len,
-                              &fm.match.flow, ofproto->max_ports);
+        error = ofproto_check_ofpacts(ofproto, fm.ofpacts, fm.ofpacts_len,
+                                      &fm.match.flow, &meter_id);
     }
+
     if (!error) {
-        error = handle_flow_mod__(ofproto, ofconn, &fm, oh);
+        error = handle_flow_mod__(ofproto, ofconn, &fm, oh, &meter_id);
     }
     if (error) {
         goto exit_free_ofpacts;
@@ -3673,7 +3743,8 @@ exit:
 static enum ofperr
 handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
                   const struct ofputil_flow_mod *fm,
-                  const struct ofp_header *oh)
+                  const struct ofp_header *oh,
+                  const uint32_t *meter_id)
 {
     if (ofproto->n_pending >= 50) {
         ovs_assert(!list_is_empty(&ofproto->pending));
@@ -3682,13 +3753,13 @@ handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
 
     switch (fm->command) {
     case OFPFC_ADD:
-        return add_flow(ofproto, ofconn, fm, oh);
+        return add_flow(ofproto, ofconn, fm, oh, meter_id);
 
     case OFPFC_MODIFY:
-        return modify_flows_loose(ofproto, ofconn, fm, oh);
+        return modify_flows_loose(ofproto, ofconn, fm, oh, meter_id);
 
     case OFPFC_MODIFY_STRICT:
-        return modify_flow_strict(ofproto, ofconn, fm, oh);
+        return modify_flow_strict(ofproto, ofconn, fm, oh, meter_id);
 
     case OFPFC_DELETE:
         return delete_flows_loose(ofproto, ofconn, fm, oh);
@@ -4109,6 +4180,351 @@ handle_flow_monitor_cancel(struct ofconn *ofconn, const struct ofp_header *oh)
     return 0;
 }
 
+/* Meters implementation.
+ *
+ * Meter table entry, indexed by the OpenFlow meter_id.
+ * These are always dynamically allocated to allocate enough space for
+ * the bands.
+ * 'created' is used to compute the duration for meter stats.
+ * 'list rules' is needed so that we can delete the dependent rules when the
+ * meter table entry is deleted.
+ * 'provider_meter_id' is for the provider's private use.
+ */
+struct meter {
+    long long int created;      /* Time created. */
+    struct list rules;          /* List of "struct rule_dpif"s. */
+    ofproto_meter_id provider_meter_id;
+    uint16_t flags;             /* Meter flags. */
+    uint16_t n_bands;           /* Number of meter bands. */
+    struct ofputil_meter_band bands[0];
+};
+
+/*
+ * This is used in instruction validation at flow set-up time,
+ * as flows may not use non-existing meters.
+ * This is also used by ofproto-providers to translate OpenFlow meter_ids
+ * in METER instructions to the corresponding provider meter IDs.
+ * Return value of UINT32_MAX signifies an invalid meter.
+ */
+uint32_t
+ofproto_get_provider_meter_id(const struct ofproto * ofproto,
+                              uint32_t of_meter_id)
+{
+    if (of_meter_id && of_meter_id <= ofproto->last_meter) {
+        const struct meter *meter = ofproto->meters[of_meter_id];
+        if (meter) {
+            return meter->provider_meter_id.uint32;
+        }
+    }
+    return UINT32_MAX;
+}
+
+static struct meter *
+meter_create(const struct ofputil_meter_config *config)
+{
+    struct meter *meter
+        = xmalloc(sizeof *meter + config->n_bands * sizeof *meter->bands);
+    int i;
+
+    if (meter) {
+        meter->provider_meter_id.uint32 = UINT32_MAX;
+        meter->flags = config->flags;
+        meter->n_bands = config->n_bands;
+        meter->created = time_msec();
+        list_init(&meter->rules);
+        for (i = 0; i < config->n_bands; ++i) {
+            meter->bands[i] = config->bands[i];
+        }
+    }
+    return meter;
+}
+
+static void
+meter_update(struct ofproto *ofproto, struct meter *meter,
+             struct meter *new_meter,
+             const struct ofputil_meter_config *config)
+{
+    if (new_meter) {
+        new_meter->provider_meter_id = meter->provider_meter_id;
+        /* Move rules list over. */
+        if (list_is_empty(&meter->rules)) {
+            list_init(&new_meter->rules);
+        } else {
+            new_meter->rules = meter->rules;
+            list_moved(&new_meter->rules);
+        }
+        ofproto->meters[config->meter_id] = new_meter;
+        free(meter);
+    } else {
+        int i;
+        /* Update existing meter. */
+        meter->flags = config->flags;
+        meter->n_bands = config->n_bands;
+        for (i = 0; i < config->n_bands; ++i) {
+            meter->bands[i] = config->bands[i];
+        }
+    }
+}
+
+static enum ofperr
+handle_meter_mod(struct ofconn *ofconn, const struct ofp_header *oh)
+{
+    struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
+    struct ofputil_meter_mod mm;
+    uint64_t bands_stub[256 / 8];
+    struct ofpbuf bands;
+    uint32_t meter_id;
+    enum ofperr error;
+
+    error = reject_slave_controller(ofconn);
+    if (error) {
+        goto exit;
+    }
+
+    ofpbuf_use_stub(&bands, bands_stub, sizeof bands_stub);
+
+    error = ofputil_decode_meter_mod(oh, &mm, &bands);
+    if (error) {
+        goto exit_free_bands;
+    }
+
+    meter_id = mm.meter.meter_id;
+
+    if (mm.command != OFPMC13_DELETE) {
+        /* Fails also when meters are not implemented by the provider. */
+        if (!meter_id || meter_id > ofproto->meter_features.max_meters) {
+            error = OFPERR_OFPMMFC_INVALID_METER;
+            goto exit_free_bands;
+        }
+        if (mm.meter.n_bands > ofproto->meter_features.max_bands) {
+            error = OFPERR_OFPMMFC_OUT_OF_BANDS;
+            goto exit_free_bands;
+        }
+    }
+
+    switch (mm.command) {
+    case OFPMC13_ADD: {
+        struct meter *meter;
+
+        if (ofproto->meters[meter_id]) {
+            error = OFPERR_OFPMMFC_METER_EXISTS;
+            break;
+        }
+
+        meter = meter_create(&mm.meter);
+        if (!meter) {
+            error = OFPERR_OFPMMFC_OUT_OF_METERS;
+            break;
+        }
+
+        error = ofproto->ofproto_class->meter_set(ofproto,
+                                                  &meter->provider_meter_id,
+                                                  &mm.meter);
+        if (!error) {
+            ofproto->meters[meter_id] = meter;
+            if (ofproto->last_meter < meter_id) {
+                ofproto->last_meter = meter_id;
+            }
+        } else {
+            free(meter);
+        }
+        break;
+    }
+    case OFPMC13_MODIFY: {
+        struct meter *meter = ofproto->meters[meter_id];
+        struct meter *new_meter = NULL;
+
+        if (!meter) {
+            error = OFPERR_OFPMMFC_UNKNOWN_METER;
+            break;
+        }
+        /* Realloc meter if number of bands increases. */
+        if (mm.meter.n_bands > meter->n_bands) {
+            new_meter = meter_create(&mm.meter);
+            if (!new_meter) {
+                error = OFPERR_OFPMMFC_OUT_OF_METERS;
+                break;
+            }
+        }
+
+        error = ofproto->ofproto_class->meter_set(ofproto,
+                                                  &meter->provider_meter_id,
+                                                  &mm.meter);
+        if (!error) {
+            meter_update(ofproto, meter, new_meter, &mm.meter);
+        } else if (new_meter) {
+            free(new_meter);
+        }
+        break;
+    }
+    case OFPMC13_DELETE: {
+        struct list rules;
+        uint32_t first, last;
+
+        if (meter_id == OFPM13_ALL) {
+            first = 1;
+            /* 'last' is 0 when meters are not implemented by the provider. */
+            last = ofproto->last_meter;
+        } else {
+            /* True also when meters are not implemented by the provider. */
+            if (!meter_id || meter_id > ofproto->last_meter) {
+                return 0;
+            }
+            first = last = meter_id;
+        }
+
+        /* First collect flows to be deleted, possibly postponing
+         * the whole operation. */
+        list_init(&rules);
+        for (meter_id = first; meter_id <= last; ++meter_id) {
+            struct meter *meter = ofproto->meters[meter_id];
+            if (!meter) {
+                continue; /* Skip non-existing meters. */
+            }
+
+            if (!list_is_empty(&meter->rules)) {
+                struct rule *rule, *next_rule;
+                /* Move rules depending on this meter to be deleted later. */
+                LIST_FOR_EACH_SAFE (rule, next_rule, meter_list_node,
+                                    &meter->rules) {
+                    if (rule->pending) {
+                        return OFPROTO_POSTPONE;
+                    }
+                    list_push_back(&rules, &rule->ofproto_node);
+                }
+            }
+        }
+
+        /* Delete the collected rules. */
+        if (!list_is_empty(&rules)) {
+            delete_flows__(ofproto, ofconn, oh, &rules, OFPRR_METER_DELETE);
+        }
+
+        /* Delete the meters. */
+        for (meter_id = first; meter_id <= last; ++meter_id) {
+            struct meter *meter = ofproto->meters[meter_id];
+            if (!meter) {
+                continue; /* Skip non-existing meters. */
+            }
+
+            ofproto->meters[meter_id] = NULL;
+            ofproto->ofproto_class->meter_del(ofproto,
+                                              meter->provider_meter_id);
+            free(meter);
+        }
+
+        if (first == last) {
+            /* Deleted only one meter. */
+            if (ofproto->last_meter == last) {
+                while (--last && !ofproto->meters[last]) {}
+                ofproto->last_meter = last; /* Last meter or 0 */
+            }
+        } else {
+            /* Deleted all meters. */
+            ofproto->last_meter = 0;
+        }
+
+        /* Delete does not parse bands, no need to free. */
+        return 0;
+    }
+    default:
+        error = OFPERR_OFPMMFC_BAD_COMMAND;
+    }
+
+exit_free_bands:
+    ofpbuf_uninit(&bands);
+exit:
+    return error;
+}
+
+static enum ofperr
+handle_meter_features_request(struct ofconn *ofconn,
+                              const struct ofp_header *request)
+{
+    struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
+    struct ofputil_meter_features features;
+    struct ofpbuf *b;
+
+    if (ofproto->ofproto_class->meter_get_features) {
+        ofproto->ofproto_class->meter_get_features(ofproto, &features);
+    } else {
+        memset(&features, 0, sizeof features);
+    }
+    b = ofputil_encode_meter_features_reply(&features, request);
+
+    ofconn_send_reply(ofconn, b);
+    return 0;
+}
+
+static enum ofperr
+handle_meter_request(struct ofconn *ofconn, const struct ofp_header *request,
+                     enum ofptype type)
+{
+    struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
+    struct list replies;
+    uint64_t bands_stub[256 / 8];
+    struct ofpbuf bands;
+    uint32_t meter_id, first, last;
+
+    ofputil_decode_meter_request(request, &meter_id);
+
+    if (meter_id == OFPM13_ALL) {
+        first = 1;
+        /* 'last' is 0 when meters are not implemented by the provider. */
+        last = ofproto->last_meter;
+    } else {
+        /* True also when meters are not implemented by the provider. */
+        if (!meter_id || meter_id > ofproto->meter_features.max_meters ||
+            !ofproto->meters[meter_id]) {
+            return OFPERR_OFPMMFC_UNKNOWN_METER;
+        }
+        first = last = meter_id;
+    }
+
+    ofpbuf_use_stub(&bands, bands_stub, sizeof bands_stub);
+    ofpmp_init(&replies, request);
+
+    for (meter_id = first; meter_id <= last; ++meter_id) {
+        struct meter *meter = ofproto->meters[meter_id];
+        if (!meter) {
+            continue; /* Skip non-existing meters. */
+        }
+        if (type == OFPTYPE_METER_REQUEST) {
+            struct ofputil_meter_stats stats;
+
+            stats.meter_id = meter_id;
+
+            /* Provider sets the packet and byte counts, we do the rest. */
+            stats.flow_count = list_size(&meter->rules);
+            calc_duration(meter->created, time_msec(),
+                          &stats.duration_sec, &stats.duration_nsec);
+            stats.n_bands = meter->n_bands;
+            ofpbuf_clear(&bands);
+            stats.bands
+                = ofpbuf_put_uninit(&bands,
+                                    meter->n_bands * sizeof *stats.bands);
+
+            if (!ofproto->ofproto_class->meter_get(ofproto,
+                                                   meter->provider_meter_id,
+                                                   &stats)) {
+                ofputil_append_meter_stats(&replies, &stats);
+            }
+        } else { /* type == OFPTYPE_METER_CONFIG_REQUEST */
+            struct ofputil_meter_config config;
+
+            config.meter_id = meter_id;
+            config.flags = meter->flags;
+            config.n_bands = meter->n_bands;
+            config.bands = meter->bands;
+            ofputil_append_meter_config(&replies, &config);
+        }
+    }
+
+    ofconn_send_replies(ofconn, &replies);
+    ofpbuf_uninit(&bands);
+    return 0;
+}
+
 static enum ofperr
 handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
 {
@@ -4144,6 +4560,9 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
     case OFPTYPE_FLOW_MOD:
         return handle_flow_mod(ofconn, oh);
 
+    case OFPTYPE_METER_MOD:
+        return handle_meter_mod(ofconn, oh);
+
     case OFPTYPE_BARRIER_REQUEST:
         return handle_barrier_request(ofconn, oh);
 
@@ -4202,16 +4621,19 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
     case OFPTYPE_FLOW_MONITOR_STATS_REQUEST:
         return handle_flow_monitor_request(ofconn, oh);
 
+    case OFPTYPE_METER_REQUEST:
+    case OFPTYPE_METER_CONFIG_REQUEST:
+        return handle_meter_request(ofconn, oh, type);
+
+    case OFPTYPE_METER_FEATURES_REQUEST:
+        return handle_meter_features_request(ofconn, oh);
+
         /* FIXME: Change the following once they are implemented: */
     case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
     case OFPTYPE_GET_ASYNC_REQUEST:
-    case OFPTYPE_METER_MOD:
     case OFPTYPE_GROUP_REQUEST:
     case OFPTYPE_GROUP_DESC_REQUEST:
     case OFPTYPE_GROUP_FEATURES_REQUEST:
-    case OFPTYPE_METER_REQUEST:
-    case OFPTYPE_METER_CONFIG_REQUEST:
-    case OFPTYPE_METER_FEATURES_REQUEST:
     case OFPTYPE_TABLE_FEATURES_REQUEST:
         return OFPERR_OFPBRC_BAD_TYPE;
 
@@ -4964,11 +5386,17 @@ oftable_remove_rule(struct rule *rule)
     struct oftable *table = &ofproto->tables[rule->table_id];
 
     classifier_remove(&table->cls, &rule->cr);
+    if (rule->meter_id) {
+        list_remove(&rule->meter_list_node);
+    }
     cookies_remove(ofproto, rule);
     eviction_group_remove_rule(rule);
     if (!list_is_empty(&rule->expirable)) {
         list_remove(&rule->expirable);
     }
+    if (!list_is_empty(&rule->meter_list_node)) {
+        list_remove(&rule->meter_list_node);
+    }
 }
 
 /* Inserts 'rule' into its oftable.  Removes any existing rule from 'rule''s
@@ -4986,9 +5414,15 @@ oftable_replace_rule(struct rule *rule)
         list_insert(&ofproto->expirable, &rule->expirable);
     }
     cookies_insert(ofproto, rule);
-
+    if (rule->meter_id) {
+        struct meter *meter = ofproto->meters[rule->meter_id];
+        list_insert(&meter->rules, &rule->meter_list_node);
+    }
     victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr));
     if (victim) {
+        if (victim->meter_id) {
+            list_remove(&victim->meter_list_node);
+        }
         cookies_remove(ofproto, victim);
 
         if (!list_is_empty(&victim->expirable)) {
diff --git a/ofproto/ofproto.h b/ofproto/ofproto.h
index 2609c94..b3ce87e 100644
--- a/ofproto/ofproto.h
+++ b/ofproto/ofproto.h
@@ -422,6 +422,10 @@ bool ofproto_has_vlan_usage_changed(const struct ofproto *);
 int ofproto_port_set_realdev(struct ofproto *, ofp_port_t vlandev_ofp_port,
                              ofp_port_t realdev_ofp_port, int vid);
 
+/* Returns UINT32_MAX if the given of_meter_id is invalid. */
+uint32_t ofproto_get_provider_meter_id(const struct ofproto *,
+                                       uint32_t of_meter_id);
+
 #ifdef  __cplusplus
 }
 #endif
-- 
1.7.10.4




More information about the dev mailing list