#include <limits.h>
#include <stdlib.h>
#include <string.h>
-#include "ofp-print.h"
#include "ofpbuf.h"
+#include "openflow/openflow.h"
#include "poll-loop.h"
#include "sat-math.h"
#include "timeval.h"
time_t last_connected;
unsigned int packets_sent;
+ /* In S_ACTIVE and S_IDLE, probably_admitted reports whether we believe
+ * that the peer has made a (positive) admission control decision on our
+ * connection. If we have not yet been (probably) admitted, then the
+ * connection does not reset the timer used for deciding whether the switch
+ * should go into fail-open mode.
+ *
+ * last_admitted reports the last time we believe such a positive admission
+ * control decision was made. */
+ bool probably_admitted;
+ time_t last_admitted;
+
/* These values are simply for statistics reporting, not used directly by
* anything internal to the rconn (or the secchan for that matter). */
unsigned int packets_received;
* an echo request as an inactivity probe packet. We should receive back
* a response. */
int probe_interval; /* Secs of inactivity before sending probe. */
+
+ /* Messages sent or received are copied to the monitor connections. */
+#define MAX_MONITORS 8
+ struct vconn *monitors[8];
+ size_t n_monitors;
};
static unsigned int elapsed_in_this_state(const struct rconn *);
static void disconnect(struct rconn *, int error);
static void flush_queue(struct rconn *);
static void question_connectivity(struct rconn *);
+static void copy_to_monitor(struct rconn *, const struct ofpbuf *);
+static bool is_connected_state(enum state);
+static bool is_admitted_msg(const struct ofpbuf *);
/* Creates a new rconn, connects it (reliably) to 'name', and returns it. */
struct rconn *
rc->packets_sent = 0;
+ rc->probably_admitted = false;
+ rc->last_admitted = time_now();
+
rc->packets_received = 0;
rc->n_attempted_connections = 0;
rc->n_successful_connections = 0;
rc->probe_interval = probe_interval ? MAX(5, probe_interval) : 0;
+ rc->n_monitors = 0;
+
return rc;
}
void
rconn_disconnect(struct rconn *rc)
{
- if (rc->vconn) {
- vconn_close(rc->vconn);
- rc->vconn = NULL;
- }
- free(rc->name);
- rc->name = xstrdup("void");
- rc->reliable = false;
+ if (rc->state != S_VOID) {
+ if (rc->vconn) {
+ vconn_close(rc->vconn);
+ rc->vconn = NULL;
+ }
+ free(rc->name);
+ rc->name = xstrdup("void");
+ rc->reliable = false;
- rc->backoff = 0;
- rc->backoff_deadline = TIME_MIN;
+ rc->backoff = 0;
+ rc->backoff_deadline = TIME_MIN;
- state_transition(rc, S_VOID);
+ state_transition(rc, S_VOID);
+ }
}
/* Disconnects 'rc' and frees the underlying storage. */
rconn_destroy(struct rconn *rc)
{
if (rc) {
+ size_t i;
+
free(rc->name);
vconn_close(rc->vconn);
flush_queue(rc);
queue_destroy(&rc->txq);
+ for (i = 0; i < rc->n_monitors; i++) {
+ vconn_close(rc->monitors[i]);
+ }
free(rc);
}
}
VLOG_WARN("%s: connecting...", rc->name);
rc->n_attempted_connections++;
- retval = vconn_open(rc->name, &rc->vconn);
+ retval = vconn_open(rc->name, OFP_VERSION, &rc->vconn);
if (!retval) {
rc->backoff_deadline = time_now() + rc->backoff;
state_transition(rc, S_CONNECTING);
} else {
VLOG_WARN("%s: connection failed (%s)", rc->name, strerror(retval));
+ rc->backoff_deadline = TIME_MAX; /* Prevent resetting backoff. */
disconnect(rc, 0);
}
return retval;
if (!retval) {
VLOG_WARN("%s: connected", rc->name);
rc->n_successful_connections++;
- if (vconn_is_passive(rc->vconn)) {
- error(0, "%s: passive vconn not supported", rc->name);
- state_transition(rc, S_VOID);
- } else {
- state_transition(rc, S_ACTIVE);
- rc->last_connected = rc->state_entered;
- }
+ state_transition(rc, S_ACTIVE);
+ rc->last_connected = rc->state_entered;
} else if (retval != EAGAIN) {
VLOG_WARN("%s: connection failed (%s)", rc->name, strerror(retval));
disconnect(rc, retval);
{
if (timed_out(rc)) {
unsigned int base = MAX(rc->last_received, rc->state_entered);
- rconn_send(rc, make_echo_request(), NULL);
VLOG_DBG("%s: idle %u seconds, sending inactivity probe",
rc->name, (unsigned int) (time_now() - base));
+
+ /* Ordering is important here: rconn_send() can transition to BACKOFF,
+ * and we don't want to transition back to IDLE if so, because then we
+ * can end up queuing a packet with vconn == NULL and then *boom*. */
state_transition(rc, S_IDLE);
+ rconn_send(rc, make_echo_request(), NULL);
return;
}
struct ofpbuf *buffer;
int error = vconn_recv(rc->vconn, &buffer);
if (!error) {
+ copy_to_monitor(rc, buffer);
+ if (is_admitted_msg(buffer)
+ || time_now() - rc->last_connected >= 30) {
+ rc->probably_admitted = true;
+ rc->last_admitted = time_now();
+ }
rc->last_received = time_now();
rc->packets_received++;
if (rc->state == S_IDLE) {
rconn_send(struct rconn *rc, struct ofpbuf *b, int *n_queued)
{
if (rconn_is_connected(rc)) {
+ copy_to_monitor(rc, b);
b->private = n_queued;
if (n_queued) {
++*n_queued;
/* Sends 'b' on 'rc'. Increments '*n_queued' while the packet is in flight; it
* will be decremented when it has been sent (or discarded due to
* disconnection). Returns 0 if successful, EAGAIN if '*n_queued' is already
- * at least as large of 'queue_limit', or ENOTCONN if 'rc' is not currently
+ * at least as large as 'queue_limit', or ENOTCONN if 'rc' is not currently
* connected. Regardless of return value, 'b' is destroyed.
*
* Because 'b' may be sent (or discarded) before this function returns, the
return rc->packets_sent;
}
+/* Adds 'vconn' to 'rc' as a monitoring connection, to which all messages sent
+ * and received on 'rconn' will be copied. 'rc' takes ownership of 'vconn'. */
+void
+rconn_add_monitor(struct rconn *rc, struct vconn *vconn)
+{
+ if (rc->n_monitors < ARRAY_SIZE(rc->monitors)) {
+ VLOG_WARN("new monitor connection from %s", vconn_get_name(vconn));
+ rc->monitors[rc->n_monitors++] = vconn;
+ } else {
+ VLOG_DBG("too many monitor connections, discarding %s",
+ vconn_get_name(vconn));
+ vconn_close(vconn);
+ }
+}
+
/* Returns 'rc''s name (the 'name' argument passed to rconn_new()). */
const char *
rconn_get_name(const struct rconn *rc)
bool
rconn_is_connected(const struct rconn *rconn)
{
- return rconn->state & (S_ACTIVE | S_IDLE);
+ return is_connected_state(rconn->state);
}
-/* Returns 0 if 'rconn' is connected, otherwise the number of seconds that it
- * has been disconnected. */
+/* Returns 0 if 'rconn' is connected. Otherwise, if 'rconn' is in a "failure
+ * mode" (that is, it is not connected), returns the number of seconds that it
+ * has been in failure mode, ignoring any times that it connected but the
+ * controller's admission control policy caused it to be quickly
+ * disconnected. */
int
-rconn_disconnected_duration(const struct rconn *rconn)
+rconn_failure_duration(const struct rconn *rconn)
{
- return rconn_is_connected(rconn) ? 0 : time_now() - rconn->last_received;
+ return rconn_is_connected(rconn) ? 0 : time_now() - rconn->last_admitted;
}
/* Returns the IP address of the peer, or 0 if the peer is not connected over
rc->name, strerror(error));
} else if (error == EOF) {
if (rc->reliable) {
- VLOG_WARN("%s: connection closed", rc->name);
+ VLOG_WARN("%s: connection closed by peer", rc->name);
}
} else {
VLOG_WARN("%s: connection dropped", rc->name);
static void
state_transition(struct rconn *rc, enum state state)
{
+ if (is_connected_state(state) && !is_connected_state(rc->state)) {
+ rc->probably_admitted = false;
+ }
if (rconn_is_connected(rc)) {
rc->total_time_connected += elapsed_in_this_state(rc);
}
rc->last_questioned = now;
}
}
+
+static void
+copy_to_monitor(struct rconn *rc, const struct ofpbuf *b)
+{
+ struct ofpbuf *clone = NULL;
+ int retval;
+ size_t i;
+
+ for (i = 0; i < rc->n_monitors; ) {
+ struct vconn *vconn = rc->monitors[i];
+
+ if (!clone) {
+ clone = ofpbuf_clone(b);
+ }
+ retval = vconn_send(vconn, clone);
+ if (!retval) {
+ clone = NULL;
+ } else if (retval != EAGAIN) {
+ VLOG_DBG("%s: closing monitor connection to %s: %s",
+ rconn_get_name(rc), vconn_get_name(vconn),
+ strerror(retval));
+ rc->monitors[i] = rc->monitors[--rc->n_monitors];
+ continue;
+ }
+ i++;
+ }
+ ofpbuf_delete(clone);
+}
+
+static bool
+is_connected_state(enum state state)
+{
+ return (state & (S_ACTIVE | S_IDLE)) != 0;
+}
+
+static bool
+is_admitted_msg(const struct ofpbuf *b)
+{
+ struct ofp_header *oh = b->data;
+ uint8_t type = oh->type;
+ return !(type < 32
+ && (1u << type) & ((1u << OFPT_HELLO) |
+ (1u << OFPT_ERROR) |
+ (1u << OFPT_ECHO_REQUEST) |
+ (1u << OFPT_ECHO_REPLY) |
+ (1u << OFPT_VENDOR) |
+ (1u << OFPT_FEATURES_REQUEST) |
+ (1u << OFPT_FEATURES_REPLY) |
+ (1u << OFPT_GET_CONFIG_REQUEST) |
+ (1u << OFPT_GET_CONFIG_REPLY) |
+ (1u << OFPT_SET_CONFIG)));
+}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff