ovn/controller/ofctrl.c

   1 /* Copyright (c) 2015 Nicira, Inc.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <config.h>
  17 #include "ofctrl.h"
  18 #include "dirs.h"
  19 #include "dynamic-string.h"
  20 #include "hmap.h"
  21 #include "match.h"
  22 #include "ofp-actions.h"
  23 #include "ofp-msgs.h"
  24 #include "ofp-print.h"
  25 #include "ofp-util.h"
  26 #include "ofpbuf.h"
  27 #include "openflow/openflow.h"
  28 #include "openvswitch/vlog.h"
  29 #include "ovn-controller.h"
  30 #include "vswitch-idl.h"
  31 #include "rconn.h"
  32 #include "socket-util.h"
  33
  34 VLOG_DEFINE_THIS_MODULE(ofctrl);
  35
  36 /* An OpenFlow flow. */
  37 struct ovn_flow {
  38     /* Key. */
  39     struct hmap_node hmap_node;
  40     uint8_t table_id;
  41     uint16_t priority;
  42     struct match match;
  43
  44     /* Data. */
  45     struct ofpact *ofpacts;
  46     size_t ofpacts_len;
  47 };
  48
  49 static uint32_t ovn_flow_hash(const struct ovn_flow *);
  50 static struct ovn_flow *ovn_flow_lookup(struct hmap *flow_table,
  51                                         const struct ovn_flow *target);
  52 static char *ovn_flow_to_string(const struct ovn_flow *);
  53 static void ovn_flow_log(const struct ovn_flow *, const char *action);
  54 static void ovn_flow_destroy(struct ovn_flow *);
  55
  56 /* OpenFlow connection to the switch. */
  57 static struct rconn *swconn;
  58
  59 /* Last seen sequence number for 'swconn'.  When this differs from
  60  * rconn_get_connection_seqno(rconn), 'swconn' has reconnected. */
  61 static unsigned int seqno;
  62
  63 /* Counter for in-flight OpenFlow messages on 'swconn'.  We only send a new
  64  * round of flow table modifications to the switch when the counter falls to
  65  * zero, to avoid unbounded buffering. */
  66 static struct rconn_packet_counter *tx_counter;
  67
  68 /* Flow table of "struct ovn_flow"s, that holds the flow table currently
  69  * installed in the switch. */
  70 static struct hmap installed_flows;
  71
  72 static void ovn_flow_table_clear(struct hmap *flow_table);
  73 static void ovn_flow_table_destroy(struct hmap *flow_table);
  74
  75 static void ofctrl_update_flows(struct hmap *desired_flows);
  76 static void ofctrl_recv(const struct ofpbuf *msg);
  77
  78 void
  79 ofctrl_init(void)
  80 {
  81     swconn = rconn_create(5, 0, DSCP_DEFAULT, 1 << OFP13_VERSION);
  82     tx_counter = rconn_packet_counter_create();
  83     hmap_init(&installed_flows);
  84 }
  85
  86 /* Attempts to update the OpenFlow flows in bridge 'br_int' to those in
  87  * 'flow_table'.  Removes all of the flows from 'flow_table' and frees them.
  88  *
  89  * The flow table will only be updated if we've got an OpenFlow connection to
  90  * 'br_int' and it's not backlogged.  Otherwise, it'll have to wait until the
  91  * next iteration. */
  92 void
  93 ofctrl_run(const struct ovsrec_bridge *br_int, struct hmap *flow_table)
  94 {
  95     char *target;
  96     target = xasprintf("unix:%s/%s.mgmt", ovs_rundir(), br_int->name);
  97     if (strcmp(target, rconn_get_target(swconn))) {
  98         VLOG_INFO("%s: connecting to switch", target);
  99         rconn_connect(swconn, target, target);
 100     }
 101     free(target);
 102
 103     rconn_run(swconn);
 104
 105     if (!rconn_is_connected(swconn)) {
 106         goto exit;
 107     }
 108     if (!rconn_packet_counter_n_packets(tx_counter)) {
 109         ofctrl_update_flows(flow_table);
 110     }
 111
 112     for (int i = 0; i < 50; i++) {
 113         struct ofpbuf *msg = rconn_recv(swconn);
 114         if (!msg) {
 115             break;
 116         }
 117
 118         ofctrl_recv(msg);
 119         ofpbuf_delete(msg);
 120     }
 121
 122 exit:
 123     ovn_flow_table_clear(flow_table);
 124 }
 125
 126 void
 127 ofctrl_wait(void)
 128 {
 129     rconn_run_wait(swconn);
 130     rconn_recv_wait(swconn);
 131 }
 132
 133 void
 134 ofctrl_destroy(void)
 135 {
 136     rconn_destroy(swconn);
 137     ovn_flow_table_destroy(&installed_flows);
 138     rconn_packet_counter_destroy(tx_counter);
 139 }
 140 \f
 141 static void
 142 queue_msg(struct ofpbuf *msg)
 143 {
 144     rconn_send(swconn, msg, tx_counter);
 145 }
 146
 147 static void
 148 ofctrl_recv(const struct ofpbuf *msg)
 149 {
 150     enum ofptype type;
 151     struct ofpbuf b;
 152
 153     b = *msg;
 154     if (ofptype_pull(&type, &b)) {
 155         return;
 156     }
 157
 158     switch (type) {
 159     case OFPTYPE_ECHO_REQUEST:
 160         queue_msg(make_echo_reply(msg->data));
 161         break;
 162
 163     case OFPTYPE_ECHO_REPLY:
 164     case OFPTYPE_PACKET_IN:
 165     case OFPTYPE_PORT_STATUS:
 166     case OFPTYPE_FLOW_REMOVED:
 167         /* Nothing to do. */
 168         break;
 169
 170     case OFPTYPE_HELLO:
 171     case OFPTYPE_ERROR:
 172     case OFPTYPE_FEATURES_REQUEST:
 173     case OFPTYPE_FEATURES_REPLY:
 174     case OFPTYPE_GET_CONFIG_REQUEST:
 175     case OFPTYPE_GET_CONFIG_REPLY:
 176     case OFPTYPE_SET_CONFIG:
 177     case OFPTYPE_PACKET_OUT:
 178     case OFPTYPE_FLOW_MOD:
 179     case OFPTYPE_GROUP_MOD:
 180     case OFPTYPE_PORT_MOD:
 181     case OFPTYPE_TABLE_MOD:
 182     case OFPTYPE_BARRIER_REQUEST:
 183     case OFPTYPE_BARRIER_REPLY:
 184     case OFPTYPE_QUEUE_GET_CONFIG_REQUEST:
 185     case OFPTYPE_QUEUE_GET_CONFIG_REPLY:
 186     case OFPTYPE_DESC_STATS_REQUEST:
 187     case OFPTYPE_DESC_STATS_REPLY:
 188     case OFPTYPE_FLOW_STATS_REQUEST:
 189     case OFPTYPE_FLOW_STATS_REPLY:
 190     case OFPTYPE_AGGREGATE_STATS_REQUEST:
 191     case OFPTYPE_AGGREGATE_STATS_REPLY:
 192     case OFPTYPE_TABLE_STATS_REQUEST:
 193     case OFPTYPE_TABLE_STATS_REPLY:
 194     case OFPTYPE_PORT_STATS_REQUEST:
 195     case OFPTYPE_PORT_STATS_REPLY:
 196     case OFPTYPE_QUEUE_STATS_REQUEST:
 197     case OFPTYPE_QUEUE_STATS_REPLY:
 198     case OFPTYPE_PORT_DESC_STATS_REQUEST:
 199     case OFPTYPE_PORT_DESC_STATS_REPLY:
 200     case OFPTYPE_ROLE_REQUEST:
 201     case OFPTYPE_ROLE_REPLY:
 202     case OFPTYPE_ROLE_STATUS:
 203     case OFPTYPE_SET_FLOW_FORMAT:
 204     case OFPTYPE_FLOW_MOD_TABLE_ID:
 205     case OFPTYPE_SET_PACKET_IN_FORMAT:
 206     case OFPTYPE_FLOW_AGE:
 207     case OFPTYPE_SET_CONTROLLER_ID:
 208     case OFPTYPE_FLOW_MONITOR_STATS_REQUEST:
 209     case OFPTYPE_FLOW_MONITOR_STATS_REPLY:
 210     case OFPTYPE_FLOW_MONITOR_CANCEL:
 211     case OFPTYPE_FLOW_MONITOR_PAUSED:
 212     case OFPTYPE_FLOW_MONITOR_RESUMED:
 213     case OFPTYPE_GET_ASYNC_REQUEST:
 214     case OFPTYPE_GET_ASYNC_REPLY:
 215     case OFPTYPE_SET_ASYNC_CONFIG:
 216     case OFPTYPE_METER_MOD:
 217     case OFPTYPE_GROUP_STATS_REQUEST:
 218     case OFPTYPE_GROUP_STATS_REPLY:
 219     case OFPTYPE_GROUP_DESC_STATS_REQUEST:
 220     case OFPTYPE_GROUP_DESC_STATS_REPLY:
 221     case OFPTYPE_GROUP_FEATURES_STATS_REQUEST:
 222     case OFPTYPE_GROUP_FEATURES_STATS_REPLY:
 223     case OFPTYPE_METER_STATS_REQUEST:
 224     case OFPTYPE_METER_STATS_REPLY:
 225     case OFPTYPE_METER_CONFIG_STATS_REQUEST:
 226     case OFPTYPE_METER_CONFIG_STATS_REPLY:
 227     case OFPTYPE_METER_FEATURES_STATS_REQUEST:
 228     case OFPTYPE_METER_FEATURES_STATS_REPLY:
 229     case OFPTYPE_TABLE_FEATURES_STATS_REQUEST:
 230     case OFPTYPE_TABLE_FEATURES_STATS_REPLY:
 231     case OFPTYPE_TABLE_DESC_REQUEST:
 232     case OFPTYPE_TABLE_DESC_REPLY:
 233     case OFPTYPE_BUNDLE_CONTROL:
 234     case OFPTYPE_BUNDLE_ADD_MESSAGE:
 235     case OFPTYPE_NXT_GENEVE_TABLE_MOD:
 236     case OFPTYPE_NXT_GENEVE_TABLE_REQUEST:
 237     case OFPTYPE_NXT_GENEVE_TABLE_REPLY:
 238     default:
 239         /* Messages that are generally unexpected. */
 240         if (VLOG_IS_DBG_ENABLED()) {
 241             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
 242
 243             char *s = ofp_to_string(msg->data, msg->size, 2);
 244             VLOG_DBG_RL(&rl, "OpenFlow packet ignored: %s", s);
 245             free(s);
 246         }
 247     }
 248 }
 249 \f
 250 /* Flow table interface to the rest of ovn-controller. */
 251
 252 /* Adds a flow to 'desired_flows' with the specified 'match' and 'actions' to
 253  * the OpenFlow table numbered 'table_id' with the given 'priority'.  The
 254  * caller retains ownership of 'match' and 'actions'.
 255  *
 256  * This just assembles the desired flow table in memory.  Nothing is actually
 257  * sent to the switch until a later call to ofctrl_run().
 258  *
 259  * The caller should initialize its own hmap to hold the flows. */
 260 void
 261 ofctrl_add_flow(struct hmap *desired_flows,
 262                 uint8_t table_id, uint16_t priority,
 263                 const struct match *match, const struct ofpbuf *actions)
 264 {
 265     struct ovn_flow *f = xmalloc(sizeof *f);
 266     f->table_id = table_id;
 267     f->priority = priority;
 268     f->match = *match;
 269     f->ofpacts = xmemdup(actions->data, actions->size);
 270     f->ofpacts_len = actions->size;
 271
 272     if (ovn_flow_lookup(desired_flows, f)) {
 273         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
 274         if (!VLOG_DROP_INFO(&rl)) {
 275             char *s = ovn_flow_to_string(f);
 276             VLOG_INFO("dropping duplicate flow: %s", s);
 277             free(s);
 278         }
 279
 280         ovn_flow_destroy(f);
 281         return;
 282     }
 283
 284     hmap_insert(desired_flows, &f->hmap_node, ovn_flow_hash(f));
 285 }
 286 \f
 287 /* ovn_flow. */
 288
 289 /* Returns a hash of the key in 'f'. */
 290 static uint32_t
 291 ovn_flow_hash(const struct ovn_flow *f)
 292 {
 293     return hash_2words((f->table_id << 16) | f->priority,
 294                        match_hash(&f->match, 0));
 295
 296 }
 297
 298 /* Finds and returns an ovn_flow in 'flow_table' whose key is identical to
 299  * 'target''s key, or NULL if there is none. */
 300 static struct ovn_flow *
 301 ovn_flow_lookup(struct hmap *flow_table, const struct ovn_flow *target)
 302 {
 303     struct ovn_flow *f;
 304
 305     HMAP_FOR_EACH_WITH_HASH (f, hmap_node, target->hmap_node.hash,
 306                              flow_table) {
 307         if (f->table_id == target->table_id
 308             && f->priority == target->priority
 309             && match_equal(&f->match, &target->match)) {
 310             return f;
 311         }
 312     }
 313     return NULL;
 314 }
 315
 316 static char *
 317 ovn_flow_to_string(const struct ovn_flow *f)
 318 {
 319     struct ds s = DS_EMPTY_INITIALIZER;
 320     ds_put_format(&s, "table_id=%"PRIu8", ", f->table_id);
 321     ds_put_format(&s, "priority=%"PRIu16", ", f->priority);
 322     match_format(&f->match, &s, OFP_DEFAULT_PRIORITY);
 323     ds_put_cstr(&s, ", actions=");
 324     ofpacts_format(f->ofpacts, f->ofpacts_len, &s);
 325     return ds_steal_cstr(&s);
 326 }
 327
 328 static void
 329 ovn_flow_log(const struct ovn_flow *f, const char *action)
 330 {
 331     if (VLOG_IS_DBG_ENABLED()) {
 332         char *s = ovn_flow_to_string(f);
 333         VLOG_DBG("%s flow: %s", action, s);
 334         free(s);
 335     }
 336 }
 337
 338 static void
 339 ovn_flow_destroy(struct ovn_flow *f)
 340 {
 341     if (f) {
 342         free(f->ofpacts);
 343         free(f);
 344     }
 345 }
 346 \f
 347 /* Flow tables of struct ovn_flow. */
 348
 349 static void
 350 ovn_flow_table_clear(struct hmap *flow_table)
 351 {
 352     struct ovn_flow *f, *next;
 353     HMAP_FOR_EACH_SAFE (f, next, hmap_node, flow_table) {
 354         hmap_remove(flow_table, &f->hmap_node);
 355         ovn_flow_destroy(f);
 356     }
 357 }
 358 static void
 359 ovn_flow_table_destroy(struct hmap *flow_table)
 360 {
 361     ovn_flow_table_clear(flow_table);
 362     hmap_destroy(flow_table);
 363 }
 364 \f
 365 /* Flow table update. */
 366
 367 static void
 368 queue_flow_mod(struct ofputil_flow_mod *fm)
 369 {
 370     fm->buffer_id = UINT32_MAX;
 371     fm->out_port = OFPP_ANY;
 372     fm->out_group = OFPG_ANY;
 373     queue_msg(ofputil_encode_flow_mod(fm, OFPUTIL_P_OF13_OXM));
 374 }
 375
 376 static void
 377 ofctrl_update_flows(struct hmap *desired_flows)
 378 {
 379     /* If we've (re)connected, don't make any assumptions about the flows in
 380      * the switch: delete all of them.  (We'll immediately repopulate it
 381      * below.) */
 382     if (seqno != rconn_get_connection_seqno(swconn)) {
 383         seqno = rconn_get_connection_seqno(swconn);
 384
 385         /* Send a flow_mod to delete all flows. */
 386         struct ofputil_flow_mod fm = {
 387             .match = MATCH_CATCHALL_INITIALIZER,
 388             .table_id = OFPTT_ALL,
 389             .command = OFPFC_DELETE,
 390         };
 391         queue_flow_mod(&fm);
 392         VLOG_DBG("clearing all flows");
 393
 394         /* Clear installed_flows, to match the state of the switch. */
 395         ovn_flow_table_clear(&installed_flows);
 396     }
 397
 398     /* Iterate through all of the installed flows.  If any of them are no
 399      * longer desired, delete them; if any of them should have different
 400      * actions, update them. */
 401     struct ovn_flow *i, *next;
 402     HMAP_FOR_EACH_SAFE (i, next, hmap_node, &installed_flows) {
 403         struct ovn_flow *d = ovn_flow_lookup(desired_flows, i);
 404         if (!d) {
 405             /* Installed flow is no longer desirable.  Delete it from the
 406              * switch and from installed_flows. */
 407             struct ofputil_flow_mod fm = {
 408                 .match = i->match,
 409                 .priority = i->priority,
 410                 .table_id = i->table_id,
 411                 .command = OFPFC_DELETE_STRICT,
 412             };
 413             queue_flow_mod(&fm);
 414             ovn_flow_log(i, "removing");
 415
 416             hmap_remove(&installed_flows, &i->hmap_node);
 417             ovn_flow_destroy(i);
 418         } else {
 419             if (!ofpacts_equal(i->ofpacts, i->ofpacts_len,
 420                                d->ofpacts, d->ofpacts_len)) {
 421                 /* Update actions in installed flow. */
 422                 struct ofputil_flow_mod fm = {
 423                     .match = i->match,
 424                     .priority = i->priority,
 425                     .table_id = i->table_id,
 426                     .ofpacts = d->ofpacts,
 427                     .ofpacts_len = d->ofpacts_len,
 428                     .command = OFPFC_MODIFY_STRICT,
 429                 };
 430                 queue_flow_mod(&fm);
 431                 ovn_flow_log(i, "updating");
 432
 433                 /* Replace 'i''s actions by 'd''s. */
 434                 free(i->ofpacts);
 435                 i->ofpacts = d->ofpacts;
 436                 i->ofpacts_len = d->ofpacts_len;
 437                 d->ofpacts = NULL;
 438                 d->ofpacts_len = 0;
 439             }
 440
 441             hmap_remove(desired_flows, &d->hmap_node);
 442             ovn_flow_destroy(d);
 443         }
 444     }
 445
 446     /* The previous loop removed from 'desired_flows' all of the flows that are
 447      * already installed.  Thus, any flows remaining in 'desired_flows' need to
 448      * be added to the flow table. */
 449     struct ovn_flow *d;
 450     HMAP_FOR_EACH_SAFE (d, next, hmap_node, desired_flows) {
 451         /* Send flow_mod to add flow. */
 452         struct ofputil_flow_mod fm = {
 453             .match = d->match,
 454             .priority = d->priority,
 455             .table_id = d->table_id,
 456             .ofpacts = d->ofpacts,
 457             .ofpacts_len = d->ofpacts_len,
 458             .command = OFPFC_ADD,
 459         };
 460         queue_flow_mod(&fm);
 461         ovn_flow_log(d, "adding");
 462
 463         /* Move 'd' from 'desired_flows' to installed_flows. */
 464         hmap_remove(desired_flows, &d->hmap_node);
 465         hmap_insert(&installed_flows, &d->hmap_node, d->hmap_node.hash);
 466     }
 467 }