#include <stdlib.h>
#include <string.h>
#include "coverage.h"
+#include "ofp-util.h"
#include "ofpbuf.h"
#include "openflow/openflow.h"
#include "poll-loop.h"
#include "timeval.h"
#include "util.h"
#include "vconn.h"
-
-#define THIS_MODULE VLM_rconn
#include "vlog.h"
+VLOG_DEFINE_THIS_MODULE(rconn);
+
+COVERAGE_DEFINE(rconn_discarded);
+COVERAGE_DEFINE(rconn_overflow);
+COVERAGE_DEFINE(rconn_queued);
+COVERAGE_DEFINE(rconn_sent);
+
#define STATES \
STATE(VOID, 1 << 0) \
STATE(BACKOFF, 1 << 1) \
char *target; /* vconn name, passed to vconn_open(). */
bool reliable;
- struct ovs_queue txq;
+ struct list txq; /* Contains "struct ofpbuf"s. */
int backoff;
int max_backoff;
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 *);
+static bool rconn_logging_connection_attempts__(const struct rconn *);
/* Creates and returns a new rconn.
*
rc->target = xstrdup("void");
rc->reliable = false;
- queue_init(&rc->txq);
+ list_init(&rc->txq);
rc->backoff = 0;
rc->max_backoff = max_backoff ? max_backoff : 8;
free(rc->target);
vconn_close(rc->vconn);
flush_queue(rc);
- queue_destroy(&rc->txq);
+ ofpbuf_list_delete(&rc->txq);
for (i = 0; i < rc->n_monitors; i++) {
vconn_close(rc->monitors[i]);
}
{
int retval;
- VLOG_INFO("%s: connecting...", rc->name);
+ if (rconn_logging_connection_attempts__(rc)) {
+ VLOG_INFO("%s: connecting...", rc->name);
+ }
rc->n_attempted_connections++;
retval = vconn_open(rc->target, OFP_VERSION, &rc->vconn);
if (!retval) {
state_transition(rc, S_ACTIVE);
rc->last_connected = rc->state_entered;
} else if (retval != EAGAIN) {
- VLOG_INFO("%s: connection failed (%s)", rc->name, strerror(retval));
+ if (rconn_logging_connection_attempts__(rc)) {
+ VLOG_INFO("%s: connection failed (%s)",
+ rc->name, strerror(retval));
+ }
disconnect(rc, retval);
} else if (timed_out(rc)) {
- VLOG_INFO("%s: connection timed out", rc->name);
+ if (rconn_logging_connection_attempts__(rc)) {
+ VLOG_INFO("%s: connection timed out", rc->name);
+ }
rc->backoff_deadline = TIME_MAX; /* Prevent resetting backoff. */
disconnect(rc, ETIMEDOUT);
}
static void
do_tx_work(struct rconn *rc)
{
- if (!rc->txq.n) {
+ if (list_is_empty(&rc->txq)) {
return;
}
- while (rc->txq.n > 0) {
+ while (!list_is_empty(&rc->txq)) {
int error = try_send(rc);
if (error) {
break;
}
}
- if (!rc->txq.n) {
+ if (list_is_empty(&rc->txq)) {
poll_immediate_wake();
}
}
poll_timer_wait_until(expires * 1000);
}
- if ((rc->state & (S_ACTIVE | S_IDLE)) && rc->txq.n) {
+ if ((rc->state & (S_ACTIVE | S_IDLE)) && !list_is_empty(&rc->txq)) {
vconn_wait(rc->vconn, WAIT_SEND);
}
}
if (counter) {
rconn_packet_counter_inc(counter);
}
- queue_push_tail(&rc->txq, b);
+ list_push_back(&rc->txq, &b->list_node);
/* If the queue was empty before we added 'b', try to send some
* packets. (But if the queue had packets in it, it's because the
* vconn is backlogged and there's no point in stuffing more into it
* now. We'll get back to that in rconn_run().) */
- if (rc->txq.n == 1) {
+ if (rc->txq.next == &b->list_node) {
try_send(rc);
}
return 0;
/* Returns the IP address of the peer, or 0 if the peer's IP address is not
* known. */
uint32_t
-rconn_get_remote_ip(const struct rconn *rconn)
+rconn_get_remote_ip(const struct rconn *rconn)
{
return rconn->remote_ip;
}
/* Returns the transport port of the peer, or 0 if the peer's port is not
* known. */
uint16_t
-rconn_get_remote_port(const struct rconn *rconn)
+rconn_get_remote_port(const struct rconn *rconn)
{
return rconn->remote_port;
}
/* Returns the IP address used to connect to the peer, or 0 if the
- * connection is not an IP-based protocol or if its IP address is not
+ * connection is not an IP-based protocol or if its IP address is not
* known. */
uint32_t
-rconn_get_local_ip(const struct rconn *rconn)
+rconn_get_local_ip(const struct rconn *rconn)
{
return rconn->local_ip;
}
/* Returns the transport port used to connect to the peer, or 0 if the
* connection does not contain a port or if the port is not known. */
uint16_t
-rconn_get_local_port(const struct rconn *rconn)
+rconn_get_local_port(const struct rconn *rconn)
{
return rconn->vconn ? vconn_get_local_port(rconn->vconn) : 0;
}
static int
try_send(struct rconn *rc)
{
- int retval = 0;
- struct ofpbuf *next = rc->txq.head->next;
- struct rconn_packet_counter *counter = rc->txq.head->private_p;
- retval = vconn_send(rc->vconn, rc->txq.head);
+ struct ofpbuf *msg = ofpbuf_from_list(rc->txq.next);
+ struct rconn_packet_counter *counter = msg->private_p;
+ int retval;
+
+ /* Eagerly remove 'msg' from the txq. We can't remove it from the list
+ * after sending, if sending is successful, because it is then owned by the
+ * vconn, which might have freed it already. */
+ list_remove(&msg->list_node);
+
+ retval = vconn_send(rc->vconn, msg);
if (retval) {
+ list_push_front(&rc->txq, &msg->list_node);
if (retval != EAGAIN) {
report_error(rc, retval);
disconnect(rc, retval);
if (counter) {
rconn_packet_counter_dec(counter);
}
- queue_advance_head(&rc->txq, next);
return 0;
}
if (now >= rc->backoff_deadline) {
rc->backoff = 1;
- } else {
- rc->backoff = MIN(rc->max_backoff, MAX(1, 2 * rc->backoff));
- VLOG_INFO("%s: waiting %d seconds before reconnect\n",
+ } else if (rc->backoff < rc->max_backoff / 2) {
+ rc->backoff = MAX(1, 2 * rc->backoff);
+ VLOG_INFO("%s: waiting %d seconds before reconnect",
rc->name, rc->backoff);
+ } else {
+ if (rconn_logging_connection_attempts__(rc)) {
+ VLOG_INFO("%s: continuing to retry connections in the "
+ "background but suppressing further logging",
+ rc->name);
+ }
+ rc->backoff = rc->max_backoff;
}
rc->backoff_deadline = now + rc->backoff;
state_transition(rc, S_BACKOFF);
static void
flush_queue(struct rconn *rc)
{
- if (!rc->txq.n) {
+ if (list_is_empty(&rc->txq)) {
return;
}
- while (rc->txq.n > 0) {
- struct ofpbuf *b = queue_pop_head(&rc->txq);
+ while (!list_is_empty(&rc->txq)) {
+ struct ofpbuf *b = ofpbuf_from_list(list_pop_front(&rc->txq));
struct rconn_packet_counter *counter = b->private_p;
if (counter) {
rconn_packet_counter_dec(counter);
}
static void
-question_connectivity(struct rconn *rc)
+question_connectivity(struct rconn *rc)
{
time_t now = time_now();
if (now - rc->last_questioned > 60) {
}
static bool
-is_connected_state(enum state state)
+is_connected_state(enum state state)
{
return (state & (S_ACTIVE | S_IDLE)) != 0;
}
(1u << OFPT_GET_CONFIG_REPLY) |
(1u << OFPT_SET_CONFIG)));
}
+
+/* Returns true if 'rc' is currently logging information about connection
+ * attempts, false if logging should be suppressed because 'rc' hasn't
+ * successuflly connected in too long. */
+static bool
+rconn_logging_connection_attempts__(const struct rconn *rc)
+{
+ return rc->backoff < rc->max_backoff;
+}