X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Ffail-open.c;h=3c9a9ad63a2a7c6a00a9b215c7b27445f4dc81af;hb=2bd318dec2428ae6c0febbf79453982676ccb672;hp=48f7069452b0ac63fc64392555127fe45be4a77c;hpb=d65349ea28bb67a0062a9b4b60ff97538206373b;p=cascardo%2Fovs.git diff --git a/ofproto/fail-open.c b/ofproto/fail-open.c index 48f706945..3c9a9ad63 100644 --- a/ofproto/fail-open.c +++ b/ofproto/fail-open.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,20 +18,25 @@ #include "fail-open.h" #include #include +#include "classifier.h" +#include "connmgr.h" #include "flow.h" #include "mac-learning.h" #include "odp-util.h" #include "ofpbuf.h" +#include "ofp-actions.h" +#include "ofp-util.h" #include "ofproto.h" +#include "ofproto-provider.h" #include "pktbuf.h" +#include "dp-packet.h" #include "poll-loop.h" #include "rconn.h" -#include "status.h" #include "timeval.h" -#include "vconn.h" +#include "openvswitch/vconn.h" +#include "openvswitch/vlog.h" -#define THIS_MODULE VLM_fail_open -#include "vlog.h" +VLOG_DEFINE_THIS_MODULE(fail_open); /* * Fail-open mode. @@ -49,8 +54,8 @@ * connection to the controller, and thus the whole network would go down for * that period of time. * - * So, instead, we add some special caseswhen we are connected to a controller, - * but not yet sure that it has admitted us: + * So, instead, we add some special cases when we are connected to a + * controller, but not yet sure that it has admitted us: * * - We set up flows immediately ourselves, but simultaneously send out an * OFPT_PACKET_IN to the controller. We put a special bogus buffer-id in @@ -68,19 +73,39 @@ struct fail_open { struct ofproto *ofproto; - struct rconn *controller; - int trigger_duration; + struct connmgr *connmgr; int last_disconn_secs; - struct status_category *ss_cat; long long int next_bogus_packet_in; struct rconn_packet_counter *bogus_packet_counter; + bool fail_open_active; }; -/* Returns true if 'fo' should be in fail-open mode, otherwise false. */ -static inline bool -should_fail_open(const struct fail_open *fo) +static void fail_open_recover(struct fail_open *); + +/* Returns the number of seconds of disconnection after which fail-open mode + * should activate. */ +static int +trigger_duration(const struct fail_open *fo) { - return rconn_failure_duration(fo->controller) >= fo->trigger_duration; + if (!connmgr_has_controllers(fo->connmgr)) { + /* Shouldn't ever arrive here, but if we do, never fail open. */ + return INT_MAX; + } else { + /* Otherwise, every controller must have a chance to send an + * inactivity probe and reconnect before we fail open, so take the + * maximum probe interval and multiply by 3: + * + * - The first interval is the idle time before sending an inactivity + * probe. + * + * - The second interval is the time allowed for a response to the + * inactivity probe. + * + * - The third interval is the time allowed to reconnect after no + * response is received. + */ + return connmgr_get_max_probe_interval(fo->connmgr) * 3; + } } /* Returns true if 'fo' is currently in fail-open mode, otherwise false. */ @@ -91,31 +116,37 @@ fail_open_is_active(const struct fail_open *fo) } static void -send_bogus_packet_in(struct fail_open *fo) +send_bogus_packet_ins(struct fail_open *fo) { - uint8_t mac[ETH_ADDR_LEN]; - struct ofpbuf *opi; - struct ofpbuf b; - - /* Compose ofp_packet_in. */ - ofpbuf_init(&b, 128); - eth_addr_random(mac); - compose_benign_packet(&b, "Open vSwitch Controller Probe", 0xa033, mac); - opi = make_packet_in(pktbuf_get_null(), OFPP_LOCAL, OFPR_NO_MATCH, &b, 64); - ofpbuf_uninit(&b); - - /* Send. */ - rconn_send_with_limit(fo->controller, opi, fo->bogus_packet_counter, 1); + struct ofproto_packet_in pin; + struct eth_addr mac; + struct dp_packet b; + + dp_packet_init(&b, 128); + eth_addr_nicira_random(&mac); + compose_rarp(&b, mac); + + memset(&pin, 0, sizeof pin); + pin.up.packet = dp_packet_data(&b); + pin.up.packet_len = dp_packet_size(&b); + pin.up.reason = OFPR_NO_MATCH; + match_init_catchall(&pin.up.flow_metadata); + match_set_in_port(&pin.up.flow_metadata, OFPP_LOCAL); + pin.send_len = dp_packet_size(&b); + pin.miss_type = OFPROTO_PACKET_IN_NO_MISS; + connmgr_send_packet_in(fo->connmgr, &pin); + + dp_packet_uninit(&b); } -/* Enter fail-open mode if we should be in it. Handle reconnecting to a - * controller from fail-open mode. */ +/* Enter fail-open mode if we should be in it. */ void fail_open_run(struct fail_open *fo) { + int disconn_secs = connmgr_failure_duration(fo->connmgr); + /* Enter fail-open mode if 'fo' is not in it but should be. */ - if (should_fail_open(fo)) { - int disconn_secs = rconn_failure_duration(fo->controller); + if (disconn_secs >= trigger_duration(fo)) { if (!fail_open_is_active(fo)) { VLOG_WARN("Could not connect to controller (or switch failed " "controller's post-connection admission control " @@ -135,10 +166,10 @@ fail_open_run(struct fail_open *fo) /* Schedule a bogus packet-in if we're connected and in fail-open. */ if (fail_open_is_active(fo)) { - if (rconn_is_connected(fo->controller)) { + if (connmgr_is_any_controller_connected(fo->connmgr)) { bool expired = time_msec() >= fo->next_bogus_packet_in; if (expired) { - send_bogus_packet_in(fo); + send_bogus_packet_ins(fo); } if (expired || fo->next_bogus_packet_in == LLONG_MAX) { fo->next_bogus_packet_in = time_msec() + 2000; @@ -154,89 +185,92 @@ fail_open_run(struct fail_open *fo) * controller, exits fail open mode. */ void fail_open_maybe_recover(struct fail_open *fo) + OVS_EXCLUDED(ofproto_mutex) { - if (fail_open_is_active(fo) && rconn_is_admitted(fo->controller)) { - flow_t flow; + if (fail_open_is_active(fo) + && connmgr_is_any_controller_admitted(fo->connmgr)) { + fail_open_recover(fo); + } +} - VLOG_WARN("No longer in fail-open mode"); - fo->last_disconn_secs = 0; - fo->next_bogus_packet_in = LLONG_MAX; +static void +fail_open_recover(struct fail_open *fo) + OVS_EXCLUDED(ofproto_mutex) +{ + struct match match; - memset(&flow, 0, sizeof flow); - ofproto_delete_flow(fo->ofproto, &flow, OFPFW_ALL, FAIL_OPEN_PRIORITY); - } + VLOG_WARN("No longer in fail-open mode"); + fo->last_disconn_secs = 0; + fo->next_bogus_packet_in = LLONG_MAX; + + match_init_catchall(&match); + ofproto_delete_flow(fo->ofproto, &match, FAIL_OPEN_PRIORITY); } void fail_open_wait(struct fail_open *fo) { if (fo->next_bogus_packet_in != LLONG_MAX) { - poll_timer_wait(fo->next_bogus_packet_in - time_msec()); + poll_timer_wait_until(fo->next_bogus_packet_in); } } void fail_open_flushed(struct fail_open *fo) + OVS_EXCLUDED(ofproto_mutex) { - int disconn_secs = rconn_failure_duration(fo->controller); - bool open = disconn_secs >= fo->trigger_duration; + int disconn_secs = connmgr_failure_duration(fo->connmgr); + bool open = disconn_secs >= trigger_duration(fo); if (open) { - union ofp_action action; - flow_t flow; + struct ofpbuf ofpacts; + struct match match; /* Set up a flow that matches every packet and directs them to * OFPP_NORMAL. */ - memset(&action, 0, sizeof action); - action.type = htons(OFPAT_OUTPUT); - action.output.len = htons(sizeof action); - action.output.port = htons(OFPP_NORMAL); - memset(&flow, 0, sizeof flow); - ofproto_add_flow(fo->ofproto, &flow, OFPFW_ALL, FAIL_OPEN_PRIORITY, - &action, 1, 0); + ofpbuf_init(&ofpacts, OFPACT_OUTPUT_SIZE); + ofpact_put_OUTPUT(&ofpacts)->port = OFPP_NORMAL; + + match_init_catchall(&match); + ofproto_add_flow(fo->ofproto, &match, FAIL_OPEN_PRIORITY, + ofpacts.data, ofpacts.size); + + ofpbuf_uninit(&ofpacts); } + fo->fail_open_active = open; } -static void -fail_open_status_cb(struct status_reply *sr, void *fo_) +/* Returns the number of fail-open rules currently installed in the flow + * table. */ +int +fail_open_count_rules(const struct fail_open *fo) { - struct fail_open *fo = fo_; - int cur_duration = rconn_failure_duration(fo->controller); - - status_reply_put(sr, "trigger-duration=%d", fo->trigger_duration); - status_reply_put(sr, "current-duration=%d", cur_duration); - status_reply_put(sr, "triggered=%s", - cur_duration >= fo->trigger_duration ? "true" : "false"); + return fo->fail_open_active != 0; } +/* Creates and returns a new struct fail_open for 'ofproto' and 'mgr'. */ struct fail_open * -fail_open_create(struct ofproto *ofproto, - int trigger_duration, struct switch_status *switch_status, - struct rconn *controller) +fail_open_create(struct ofproto *ofproto, struct connmgr *mgr) { struct fail_open *fo = xmalloc(sizeof *fo); fo->ofproto = ofproto; - fo->controller = controller; - fo->trigger_duration = trigger_duration; + fo->connmgr = mgr; fo->last_disconn_secs = 0; - fo->ss_cat = switch_status_register(switch_status, "fail-open", - fail_open_status_cb, fo); fo->next_bogus_packet_in = LLONG_MAX; fo->bogus_packet_counter = rconn_packet_counter_create(); + fo->fail_open_active = false; return fo; } -void -fail_open_set_trigger_duration(struct fail_open *fo, int trigger_duration) -{ - fo->trigger_duration = trigger_duration; -} - +/* Destroys 'fo'. */ void fail_open_destroy(struct fail_open *fo) + OVS_EXCLUDED(ofproto_mutex) { if (fo) { - /* We don't own fo->controller. */ - switch_status_unregister(fo->ss_cat); + if (fail_open_is_active(fo)) { + fail_open_recover(fo); + } + /* We don't own fo->connmgr. */ rconn_packet_counter_destroy(fo->bogus_packet_counter); free(fo); }