2 * Copyright (c) 2008, 2009, 2010 Nicira Networks.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
27 #include "openflow/openflow.h"
28 #include "poll-loop.h"
35 VLOG_DEFINE_THIS_MODULE(rconn
);
37 COVERAGE_DEFINE(rconn_discarded
);
38 COVERAGE_DEFINE(rconn_overflow
);
39 COVERAGE_DEFINE(rconn_queued
);
40 COVERAGE_DEFINE(rconn_sent
);
44 STATE(BACKOFF, 1 << 1) \
45 STATE(CONNECTING, 1 << 2) \
46 STATE(ACTIVE, 1 << 3) \
49 #define STATE(NAME, VALUE) S_##NAME = VALUE,
55 state_name(enum state state
)
58 #define STATE(NAME, VALUE) case S_##NAME: return #NAME;
65 /* A reliable connection to an OpenFlow switch or controller.
67 * See the large comment in rconn.h for more information. */
73 char *name
; /* Human-readable descriptive name. */
74 char *target
; /* vconn name, passed to vconn_open(). */
77 struct list txq
; /* Contains "struct ofpbuf"s. */
81 time_t backoff_deadline
;
83 time_t last_connected
;
84 unsigned int packets_sent
;
88 /* In S_ACTIVE and S_IDLE, probably_admitted reports whether we believe
89 * that the peer has made a (positive) admission control decision on our
90 * connection. If we have not yet been (probably) admitted, then the
91 * connection does not reset the timer used for deciding whether the switch
92 * should go into fail-open mode.
94 * last_admitted reports the last time we believe such a positive admission
95 * control decision was made. */
96 bool probably_admitted
;
99 /* These values are simply for statistics reporting, not used directly by
100 * anything internal to the rconn (or ofproto for that matter). */
101 unsigned int packets_received
;
102 unsigned int n_attempted_connections
, n_successful_connections
;
103 time_t creation_time
;
104 unsigned long int total_time_connected
;
106 /* If we can't connect to the peer, it could be for any number of reasons.
107 * Usually, one would assume it is because the peer is not running or
108 * because the network is partitioned. But it could also be because the
109 * network topology has changed, in which case the upper layer will need to
110 * reassess it (in particular, obtain a new IP address via DHCP and find
111 * the new location of the controller). We set this flag when we suspect
112 * that this could be the case. */
113 bool questionable_connectivity
;
114 time_t last_questioned
;
116 /* Throughout this file, "probe" is shorthand for "inactivity probe".
117 * When nothing has been received from the peer for a while, we send out
118 * an echo request as an inactivity probe packet. We should receive back
120 int probe_interval
; /* Secs of inactivity before sending probe. */
122 /* When we create a vconn we obtain these values, to save them past the end
123 * of the vconn's lifetime. Otherwise, in-band control will only allow
124 * traffic when a vconn is actually open, but it is nice to allow ARP to
125 * complete even between connection attempts, and it is also polite to
126 * allow traffic from other switches to go through to the controller
127 * whether or not we are connected.
129 * We don't cache the local port, because that changes from one connection
130 * attempt to the next. */
131 uint32_t local_ip
, remote_ip
;
132 uint16_t remote_port
;
134 /* Messages sent or received are copied to the monitor connections. */
135 #define MAX_MONITORS 8
136 struct vconn
*monitors
[8];
140 static unsigned int elapsed_in_this_state(const struct rconn
*);
141 static unsigned int timeout(const struct rconn
*);
142 static bool timed_out(const struct rconn
*);
143 static void state_transition(struct rconn
*, enum state
);
144 static void rconn_set_target__(struct rconn
*,
145 const char *target
, const char *name
);
146 static int try_send(struct rconn
*);
147 static void reconnect(struct rconn
*);
148 static void report_error(struct rconn
*, int error
);
149 static void disconnect(struct rconn
*, int error
);
150 static void flush_queue(struct rconn
*);
151 static void question_connectivity(struct rconn
*);
152 static void copy_to_monitor(struct rconn
*, const struct ofpbuf
*);
153 static bool is_connected_state(enum state
);
154 static bool is_admitted_msg(const struct ofpbuf
*);
155 static bool rconn_logging_connection_attempts__(const struct rconn
*);
157 /* Creates and returns a new rconn.
159 * 'probe_interval' is a number of seconds. If the interval passes once
160 * without an OpenFlow message being received from the peer, the rconn sends
161 * out an "echo request" message. If the interval passes again without a
162 * message being received, the rconn disconnects and re-connects to the peer.
163 * Setting 'probe_interval' to 0 disables this behavior.
165 * 'max_backoff' is the maximum number of seconds between attempts to connect
166 * to the peer. The actual interval starts at 1 second and doubles on each
167 * failure until it reaches 'max_backoff'. If 0 is specified, the default of
170 * The new rconn is initially unconnected. Use rconn_connect() or
171 * rconn_connect_unreliably() to connect it. */
173 rconn_create(int probe_interval
, int max_backoff
)
175 struct rconn
*rc
= xzalloc(sizeof *rc
);
178 rc
->state_entered
= time_now();
181 rc
->name
= xstrdup("void");
182 rc
->target
= xstrdup("void");
183 rc
->reliable
= false;
188 rc
->max_backoff
= max_backoff
? max_backoff
: 8;
189 rc
->backoff_deadline
= TIME_MIN
;
190 rc
->last_received
= time_now();
191 rc
->last_connected
= time_now();
194 rc
->packets_sent
= 0;
196 rc
->probably_admitted
= false;
197 rc
->last_admitted
= time_now();
199 rc
->packets_received
= 0;
200 rc
->n_attempted_connections
= 0;
201 rc
->n_successful_connections
= 0;
202 rc
->creation_time
= time_now();
203 rc
->total_time_connected
= 0;
205 rc
->questionable_connectivity
= false;
206 rc
->last_questioned
= time_now();
208 rconn_set_probe_interval(rc
, probe_interval
);
216 rconn_set_max_backoff(struct rconn
*rc
, int max_backoff
)
218 rc
->max_backoff
= MAX(1, max_backoff
);
219 if (rc
->state
== S_BACKOFF
&& rc
->backoff
> max_backoff
) {
220 rc
->backoff
= max_backoff
;
221 if (rc
->backoff_deadline
> time_now() + max_backoff
) {
222 rc
->backoff_deadline
= time_now() + max_backoff
;
228 rconn_get_max_backoff(const struct rconn
*rc
)
230 return rc
->max_backoff
;
234 rconn_set_probe_interval(struct rconn
*rc
, int probe_interval
)
236 rc
->probe_interval
= probe_interval
? MAX(5, probe_interval
) : 0;
240 rconn_get_probe_interval(const struct rconn
*rc
)
242 return rc
->probe_interval
;
245 /* Drops any existing connection on 'rc', then sets up 'rc' to connect to
246 * 'target' and reconnect as needed. 'target' should be a remote OpenFlow
247 * target in a form acceptable to vconn_open().
249 * If 'name' is nonnull, then it is used in log messages in place of 'target'.
250 * It should presumably give more information to a human reader than 'target',
251 * but it need not be acceptable to vconn_open(). */
253 rconn_connect(struct rconn
*rc
, const char *target
, const char *name
)
255 rconn_disconnect(rc
);
256 rconn_set_target__(rc
, target
, name
);
261 /* Drops any existing connection on 'rc', then configures 'rc' to use
262 * 'vconn'. If the connection on 'vconn' drops, 'rc' will not reconnect on it
265 * By default, the target obtained from vconn_get_name(vconn) is used in log
266 * messages. If 'name' is nonnull, then it is used instead. It should
267 * presumably give more information to a human reader than the target, but it
268 * need not be acceptable to vconn_open(). */
270 rconn_connect_unreliably(struct rconn
*rc
,
271 struct vconn
*vconn
, const char *name
)
273 assert(vconn
!= NULL
);
274 rconn_disconnect(rc
);
275 rconn_set_target__(rc
, vconn_get_name(vconn
), name
);
276 rc
->reliable
= false;
278 rc
->last_connected
= time_now();
279 state_transition(rc
, S_ACTIVE
);
282 /* If 'rc' is connected, forces it to drop the connection and reconnect. */
284 rconn_reconnect(struct rconn
*rc
)
286 if (rc
->state
& (S_ACTIVE
| S_IDLE
)) {
287 VLOG_INFO("%s: disconnecting", rc
->name
);
293 rconn_disconnect(struct rconn
*rc
)
295 if (rc
->state
!= S_VOID
) {
297 vconn_close(rc
->vconn
);
300 rconn_set_target__(rc
, "void", NULL
);
301 rc
->reliable
= false;
304 rc
->backoff_deadline
= TIME_MIN
;
306 state_transition(rc
, S_VOID
);
310 /* Disconnects 'rc' and frees the underlying storage. */
312 rconn_destroy(struct rconn
*rc
)
319 vconn_close(rc
->vconn
);
321 ofpbuf_list_delete(&rc
->txq
);
322 for (i
= 0; i
< rc
->n_monitors
; i
++) {
323 vconn_close(rc
->monitors
[i
]);
330 timeout_VOID(const struct rconn
*rc OVS_UNUSED
)
336 run_VOID(struct rconn
*rc OVS_UNUSED
)
342 reconnect(struct rconn
*rc
)
346 if (rconn_logging_connection_attempts__(rc
)) {
347 VLOG_INFO("%s: connecting...", rc
->name
);
349 rc
->n_attempted_connections
++;
350 retval
= vconn_open(rc
->target
, OFP_VERSION
, &rc
->vconn
);
352 rc
->remote_ip
= vconn_get_remote_ip(rc
->vconn
);
353 rc
->local_ip
= vconn_get_local_ip(rc
->vconn
);
354 rc
->remote_port
= vconn_get_remote_port(rc
->vconn
);
355 rc
->backoff_deadline
= time_now() + rc
->backoff
;
356 state_transition(rc
, S_CONNECTING
);
358 VLOG_WARN("%s: connection failed (%s)", rc
->name
, strerror(retval
));
359 rc
->backoff_deadline
= TIME_MAX
; /* Prevent resetting backoff. */
360 disconnect(rc
, retval
);
365 timeout_BACKOFF(const struct rconn
*rc
)
371 run_BACKOFF(struct rconn
*rc
)
379 timeout_CONNECTING(const struct rconn
*rc
)
381 return MAX(1, rc
->backoff
);
385 run_CONNECTING(struct rconn
*rc
)
387 int retval
= vconn_connect(rc
->vconn
);
389 VLOG_INFO("%s: connected", rc
->name
);
390 rc
->n_successful_connections
++;
391 state_transition(rc
, S_ACTIVE
);
392 rc
->last_connected
= rc
->state_entered
;
393 } else if (retval
!= EAGAIN
) {
394 if (rconn_logging_connection_attempts__(rc
)) {
395 VLOG_INFO("%s: connection failed (%s)",
396 rc
->name
, strerror(retval
));
398 disconnect(rc
, retval
);
399 } else if (timed_out(rc
)) {
400 if (rconn_logging_connection_attempts__(rc
)) {
401 VLOG_INFO("%s: connection timed out", rc
->name
);
403 rc
->backoff_deadline
= TIME_MAX
; /* Prevent resetting backoff. */
404 disconnect(rc
, ETIMEDOUT
);
409 do_tx_work(struct rconn
*rc
)
411 if (list_is_empty(&rc
->txq
)) {
414 while (!list_is_empty(&rc
->txq
)) {
415 int error
= try_send(rc
);
420 if (list_is_empty(&rc
->txq
)) {
421 poll_immediate_wake();
426 timeout_ACTIVE(const struct rconn
*rc
)
428 if (rc
->probe_interval
) {
429 unsigned int base
= MAX(rc
->last_received
, rc
->state_entered
);
430 unsigned int arg
= base
+ rc
->probe_interval
- rc
->state_entered
;
437 run_ACTIVE(struct rconn
*rc
)
440 unsigned int base
= MAX(rc
->last_received
, rc
->state_entered
);
441 VLOG_DBG("%s: idle %u seconds, sending inactivity probe",
442 rc
->name
, (unsigned int) (time_now() - base
));
444 /* Ordering is important here: rconn_send() can transition to BACKOFF,
445 * and we don't want to transition back to IDLE if so, because then we
446 * can end up queuing a packet with vconn == NULL and then *boom*. */
447 state_transition(rc
, S_IDLE
);
448 rconn_send(rc
, make_echo_request(), NULL
);
456 timeout_IDLE(const struct rconn
*rc
)
458 return rc
->probe_interval
;
462 run_IDLE(struct rconn
*rc
)
465 question_connectivity(rc
);
466 VLOG_ERR("%s: no response to inactivity probe after %u "
467 "seconds, disconnecting",
468 rc
->name
, elapsed_in_this_state(rc
));
469 disconnect(rc
, ETIMEDOUT
);
475 /* Performs whatever activities are necessary to maintain 'rc': if 'rc' is
476 * disconnected, attempts to (re)connect, backing off as necessary; if 'rc' is
477 * connected, attempts to send packets in the send queue, if any. */
479 rconn_run(struct rconn
*rc
)
485 vconn_run(rc
->vconn
);
487 for (i
= 0; i
< rc
->n_monitors
; i
++) {
488 vconn_run(rc
->monitors
[i
]);
492 old_state
= rc
->state
;
494 #define STATE(NAME, VALUE) case S_##NAME: run_##NAME(rc); break;
500 } while (rc
->state
!= old_state
);
503 /* Causes the next call to poll_block() to wake up when rconn_run() should be
506 rconn_run_wait(struct rconn
*rc
)
512 vconn_run_wait(rc
->vconn
);
514 for (i
= 0; i
< rc
->n_monitors
; i
++) {
515 vconn_run_wait(rc
->monitors
[i
]);
519 if (timeo
!= UINT_MAX
) {
520 long long int expires
= sat_add(rc
->state_entered
, timeo
);
521 poll_timer_wait_until(expires
* 1000);
524 if ((rc
->state
& (S_ACTIVE
| S_IDLE
)) && !list_is_empty(&rc
->txq
)) {
525 vconn_wait(rc
->vconn
, WAIT_SEND
);
529 /* Attempts to receive a packet from 'rc'. If successful, returns the packet;
530 * otherwise, returns a null pointer. The caller is responsible for freeing
531 * the packet (with ofpbuf_delete()). */
533 rconn_recv(struct rconn
*rc
)
535 if (rc
->state
& (S_ACTIVE
| S_IDLE
)) {
536 struct ofpbuf
*buffer
;
537 int error
= vconn_recv(rc
->vconn
, &buffer
);
539 copy_to_monitor(rc
, buffer
);
540 if (rc
->probably_admitted
|| is_admitted_msg(buffer
)
541 || time_now() - rc
->last_connected
>= 30) {
542 rc
->probably_admitted
= true;
543 rc
->last_admitted
= time_now();
545 rc
->last_received
= time_now();
546 rc
->packets_received
++;
547 if (rc
->state
== S_IDLE
) {
548 state_transition(rc
, S_ACTIVE
);
551 } else if (error
!= EAGAIN
) {
552 report_error(rc
, error
);
553 disconnect(rc
, error
);
559 /* Causes the next call to poll_block() to wake up when a packet may be ready
560 * to be received by vconn_recv() on 'rc'. */
562 rconn_recv_wait(struct rconn
*rc
)
565 vconn_wait(rc
->vconn
, WAIT_RECV
);
569 /* Sends 'b' on 'rc'. Returns 0 if successful (in which case 'b' is
570 * destroyed), or ENOTCONN if 'rc' is not currently connected (in which case
571 * the caller retains ownership of 'b').
573 * If 'counter' is non-null, then 'counter' will be incremented while the
574 * packet is in flight, then decremented when it has been sent (or discarded
575 * due to disconnection). Because 'b' may be sent (or discarded) before this
576 * function returns, the caller may not be able to observe any change in
579 * There is no rconn_send_wait() function: an rconn has a send queue that it
580 * takes care of sending if you call rconn_run(), which will have the side
581 * effect of waking up poll_block(). */
583 rconn_send(struct rconn
*rc
, struct ofpbuf
*b
,
584 struct rconn_packet_counter
*counter
)
586 if (rconn_is_connected(rc
)) {
587 COVERAGE_INC(rconn_queued
);
588 copy_to_monitor(rc
, b
);
589 b
->private_p
= counter
;
591 rconn_packet_counter_inc(counter
);
593 list_push_back(&rc
->txq
, &b
->list_node
);
595 /* If the queue was empty before we added 'b', try to send some
596 * packets. (But if the queue had packets in it, it's because the
597 * vconn is backlogged and there's no point in stuffing more into it
598 * now. We'll get back to that in rconn_run().) */
599 if (rc
->txq
.next
== &b
->list_node
) {
608 /* Sends 'b' on 'rc'. Increments 'counter' while the packet is in flight; it
609 * will be decremented when it has been sent (or discarded due to
610 * disconnection). Returns 0 if successful, EAGAIN if 'counter->n' is already
611 * at least as large as 'queue_limit', or ENOTCONN if 'rc' is not currently
612 * connected. Regardless of return value, 'b' is destroyed.
614 * Because 'b' may be sent (or discarded) before this function returns, the
615 * caller may not be able to observe any change in 'counter'.
617 * There is no rconn_send_wait() function: an rconn has a send queue that it
618 * takes care of sending if you call rconn_run(), which will have the side
619 * effect of waking up poll_block(). */
621 rconn_send_with_limit(struct rconn
*rc
, struct ofpbuf
*b
,
622 struct rconn_packet_counter
*counter
, int queue_limit
)
625 retval
= counter
->n
>= queue_limit
? EAGAIN
: rconn_send(rc
, b
, counter
);
627 COVERAGE_INC(rconn_overflow
);
633 /* Returns the total number of packets successfully sent on the underlying
634 * vconn. A packet is not counted as sent while it is still queued in the
635 * rconn, only when it has been successfuly passed to the vconn. */
637 rconn_packets_sent(const struct rconn
*rc
)
639 return rc
->packets_sent
;
642 /* Adds 'vconn' to 'rc' as a monitoring connection, to which all messages sent
643 * and received on 'rconn' will be copied. 'rc' takes ownership of 'vconn'. */
645 rconn_add_monitor(struct rconn
*rc
, struct vconn
*vconn
)
647 if (rc
->n_monitors
< ARRAY_SIZE(rc
->monitors
)) {
648 VLOG_INFO("new monitor connection from %s", vconn_get_name(vconn
));
649 rc
->monitors
[rc
->n_monitors
++] = vconn
;
651 VLOG_DBG("too many monitor connections, discarding %s",
652 vconn_get_name(vconn
));
657 /* Returns 'rc''s name. This is a name for human consumption, appropriate for
658 * use in log messages. It is not necessarily a name that may be passed
659 * directly to, e.g., vconn_open(). */
661 rconn_get_name(const struct rconn
*rc
)
666 /* Sets 'rc''s name to 'new_name'. */
668 rconn_set_name(struct rconn
*rc
, const char *new_name
)
671 rc
->name
= xstrdup(new_name
);
674 /* Returns 'rc''s target. This is intended to be a string that may be passed
675 * directly to, e.g., vconn_open(). */
677 rconn_get_target(const struct rconn
*rc
)
682 /* Returns true if 'rconn' is connected or in the process of reconnecting,
683 * false if 'rconn' is disconnected and will not reconnect on its own. */
685 rconn_is_alive(const struct rconn
*rconn
)
687 return rconn
->state
!= S_VOID
;
690 /* Returns true if 'rconn' is connected, false otherwise. */
692 rconn_is_connected(const struct rconn
*rconn
)
694 return is_connected_state(rconn
->state
);
697 /* Returns true if 'rconn' is connected and thought to have been accepted by
698 * the peer's admission-control policy. */
700 rconn_is_admitted(const struct rconn
*rconn
)
702 return (rconn_is_connected(rconn
)
703 && rconn
->last_admitted
>= rconn
->last_connected
);
706 /* Returns 0 if 'rconn' is currently connected and considered to have been
707 * accepted by the peer's admission-control policy, otherwise the number of
708 * seconds since 'rconn' was last in such a state. */
710 rconn_failure_duration(const struct rconn
*rconn
)
712 return rconn_is_admitted(rconn
) ? 0 : time_now() - rconn
->last_admitted
;
715 /* Returns the IP address of the peer, or 0 if the peer's IP address is not
718 rconn_get_remote_ip(const struct rconn
*rconn
)
720 return rconn
->remote_ip
;
723 /* Returns the transport port of the peer, or 0 if the peer's port is not
726 rconn_get_remote_port(const struct rconn
*rconn
)
728 return rconn
->remote_port
;
731 /* Returns the IP address used to connect to the peer, or 0 if the
732 * connection is not an IP-based protocol or if its IP address is not
735 rconn_get_local_ip(const struct rconn
*rconn
)
737 return rconn
->local_ip
;
740 /* Returns the transport port used to connect to the peer, or 0 if the
741 * connection does not contain a port or if the port is not known. */
743 rconn_get_local_port(const struct rconn
*rconn
)
745 return rconn
->vconn
? vconn_get_local_port(rconn
->vconn
) : 0;
748 /* If 'rconn' can't connect to the peer, it could be for any number of reasons.
749 * Usually, one would assume it is because the peer is not running or because
750 * the network is partitioned. But it could also be because the network
751 * topology has changed, in which case the upper layer will need to reassess it
752 * (in particular, obtain a new IP address via DHCP and find the new location
753 * of the controller). When this appears that this might be the case, this
754 * function returns true. It also clears the questionability flag and prevents
755 * it from being set again for some time. */
757 rconn_is_connectivity_questionable(struct rconn
*rconn
)
759 bool questionable
= rconn
->questionable_connectivity
;
760 rconn
->questionable_connectivity
= false;
764 /* Returns the total number of packets successfully received by the underlying
767 rconn_packets_received(const struct rconn
*rc
)
769 return rc
->packets_received
;
772 /* Returns a string representing the internal state of 'rc'. The caller must
773 * not modify or free the string. */
775 rconn_get_state(const struct rconn
*rc
)
777 return state_name(rc
->state
);
780 /* Returns the number of connection attempts made by 'rc', including any
781 * ongoing attempt that has not yet succeeded or failed. */
783 rconn_get_attempted_connections(const struct rconn
*rc
)
785 return rc
->n_attempted_connections
;
788 /* Returns the number of successful connection attempts made by 'rc'. */
790 rconn_get_successful_connections(const struct rconn
*rc
)
792 return rc
->n_successful_connections
;
795 /* Returns the time at which the last successful connection was made by
798 rconn_get_last_connection(const struct rconn
*rc
)
800 return rc
->last_connected
;
803 /* Returns the time at which the last OpenFlow message was received by 'rc'.
804 * If no packets have been received on 'rc', returns the time at which 'rc'
807 rconn_get_last_received(const struct rconn
*rc
)
809 return rc
->last_received
;
812 /* Returns the time at which 'rc' was created. */
814 rconn_get_creation_time(const struct rconn
*rc
)
816 return rc
->creation_time
;
819 /* Returns the approximate number of seconds that 'rc' has been connected. */
821 rconn_get_total_time_connected(const struct rconn
*rc
)
823 return (rc
->total_time_connected
824 + (rconn_is_connected(rc
) ? elapsed_in_this_state(rc
) : 0));
827 /* Returns the current amount of backoff, in seconds. This is the amount of
828 * time after which the rconn will transition from BACKOFF to CONNECTING. */
830 rconn_get_backoff(const struct rconn
*rc
)
835 /* Returns the number of seconds spent in this state so far. */
837 rconn_get_state_elapsed(const struct rconn
*rc
)
839 return elapsed_in_this_state(rc
);
842 /* Returns 'rc''s current connection sequence number, a number that changes
843 * every time that 'rconn' connects or disconnects. */
845 rconn_get_connection_seqno(const struct rconn
*rc
)
850 /* Returns a value that explains why 'rc' last disconnected:
852 * - 0 means that the last disconnection was caused by a call to
853 * rconn_disconnect(), or that 'rc' is new and has not yet completed its
854 * initial connection or connection attempt.
856 * - EOF means that the connection was closed in the normal way by the peer.
858 * - A positive integer is an errno value that represents the error.
861 rconn_get_last_error(const struct rconn
*rc
)
863 return rc
->last_error
;
866 struct rconn_packet_counter
*
867 rconn_packet_counter_create(void)
869 struct rconn_packet_counter
*c
= xmalloc(sizeof *c
);
876 rconn_packet_counter_destroy(struct rconn_packet_counter
*c
)
879 assert(c
->ref_cnt
> 0);
880 if (!--c
->ref_cnt
&& !c
->n
) {
887 rconn_packet_counter_inc(struct rconn_packet_counter
*c
)
893 rconn_packet_counter_dec(struct rconn_packet_counter
*c
)
896 if (!--c
->n
&& !c
->ref_cnt
) {
901 /* Set rc->target and rc->name to 'target' and 'name', respectively. If 'name'
902 * is null, 'target' is used.
904 * Also, clear out the cached IP address and port information, since changing
905 * the target also likely changes these values. */
907 rconn_set_target__(struct rconn
*rc
, const char *target
, const char *name
)
910 rc
->name
= xstrdup(name
? name
: target
);
912 rc
->target
= xstrdup(target
);
918 /* Tries to send a packet from 'rc''s send buffer. Returns 0 if successful,
919 * otherwise a positive errno value. */
921 try_send(struct rconn
*rc
)
923 struct ofpbuf
*msg
= ofpbuf_from_list(rc
->txq
.next
);
924 struct rconn_packet_counter
*counter
= msg
->private_p
;
927 /* Eagerly remove 'msg' from the txq. We can't remove it from the list
928 * after sending, if sending is successful, because it is then owned by the
929 * vconn, which might have freed it already. */
930 list_remove(&msg
->list_node
);
932 retval
= vconn_send(rc
->vconn
, msg
);
934 list_push_front(&rc
->txq
, &msg
->list_node
);
935 if (retval
!= EAGAIN
) {
936 report_error(rc
, retval
);
937 disconnect(rc
, retval
);
941 COVERAGE_INC(rconn_sent
);
944 rconn_packet_counter_dec(counter
);
949 /* Reports that 'error' caused 'rc' to disconnect. 'error' may be a positive
950 * errno value, or it may be EOF to indicate that the connection was closed
953 report_error(struct rconn
*rc
, int error
)
956 /* If 'rc' isn't reliable, then we don't really expect this connection
957 * to last forever anyway (probably it's a connection that we received
958 * via accept()), so use DBG level to avoid cluttering the logs. */
959 enum vlog_level level
= rc
->reliable
? VLL_INFO
: VLL_DBG
;
960 VLOG(level
, "%s: connection closed by peer", rc
->name
);
962 VLOG_WARN("%s: connection dropped (%s)", rc
->name
, strerror(error
));
966 /* Disconnects 'rc' and records 'error' as the error that caused 'rc''s last
969 * - 0 means that this disconnection is due to a request by 'rc''s client,
970 * not due to any kind of network error.
972 * - EOF means that the connection was closed in the normal way by the peer.
974 * - A positive integer is an errno value that represents the error.
977 disconnect(struct rconn
*rc
, int error
)
979 rc
->last_error
= error
;
981 time_t now
= time_now();
983 if (rc
->state
& (S_CONNECTING
| S_ACTIVE
| S_IDLE
)) {
984 vconn_close(rc
->vconn
);
989 if (now
>= rc
->backoff_deadline
) {
991 } else if (rc
->backoff
< rc
->max_backoff
/ 2) {
992 rc
->backoff
= MAX(1, 2 * rc
->backoff
);
993 VLOG_INFO("%s: waiting %d seconds before reconnect",
994 rc
->name
, rc
->backoff
);
996 if (rconn_logging_connection_attempts__(rc
)) {
997 VLOG_INFO("%s: continuing to retry connections in the "
998 "background but suppressing further logging",
1001 rc
->backoff
= rc
->max_backoff
;
1003 rc
->backoff_deadline
= now
+ rc
->backoff
;
1004 state_transition(rc
, S_BACKOFF
);
1005 if (now
- rc
->last_connected
> 60) {
1006 question_connectivity(rc
);
1009 rconn_disconnect(rc
);
1013 /* Drops all the packets from 'rc''s send queue and decrements their queue
1016 flush_queue(struct rconn
*rc
)
1018 if (list_is_empty(&rc
->txq
)) {
1021 while (!list_is_empty(&rc
->txq
)) {
1022 struct ofpbuf
*b
= ofpbuf_from_list(list_pop_front(&rc
->txq
));
1023 struct rconn_packet_counter
*counter
= b
->private_p
;
1025 rconn_packet_counter_dec(counter
);
1027 COVERAGE_INC(rconn_discarded
);
1030 poll_immediate_wake();
1034 elapsed_in_this_state(const struct rconn
*rc
)
1036 return time_now() - rc
->state_entered
;
1040 timeout(const struct rconn
*rc
)
1042 switch (rc
->state
) {
1043 #define STATE(NAME, VALUE) case S_##NAME: return timeout_##NAME(rc);
1052 timed_out(const struct rconn
*rc
)
1054 return time_now() >= sat_add(rc
->state_entered
, timeout(rc
));
1058 state_transition(struct rconn
*rc
, enum state state
)
1060 rc
->seqno
+= (rc
->state
== S_ACTIVE
) != (state
== S_ACTIVE
);
1061 if (is_connected_state(state
) && !is_connected_state(rc
->state
)) {
1062 rc
->probably_admitted
= false;
1064 if (rconn_is_connected(rc
)) {
1065 rc
->total_time_connected
+= elapsed_in_this_state(rc
);
1067 VLOG_DBG("%s: entering %s", rc
->name
, state_name(state
));
1069 rc
->state_entered
= time_now();
1073 question_connectivity(struct rconn
*rc
)
1075 time_t now
= time_now();
1076 if (now
- rc
->last_questioned
> 60) {
1077 rc
->questionable_connectivity
= true;
1078 rc
->last_questioned
= now
;
1083 copy_to_monitor(struct rconn
*rc
, const struct ofpbuf
*b
)
1085 struct ofpbuf
*clone
= NULL
;
1089 for (i
= 0; i
< rc
->n_monitors
; ) {
1090 struct vconn
*vconn
= rc
->monitors
[i
];
1093 clone
= ofpbuf_clone(b
);
1095 retval
= vconn_send(vconn
, clone
);
1098 } else if (retval
!= EAGAIN
) {
1099 VLOG_DBG("%s: closing monitor connection to %s: %s",
1100 rconn_get_name(rc
), vconn_get_name(vconn
),
1102 rc
->monitors
[i
] = rc
->monitors
[--rc
->n_monitors
];
1107 ofpbuf_delete(clone
);
1111 is_connected_state(enum state state
)
1113 return (state
& (S_ACTIVE
| S_IDLE
)) != 0;
1117 is_admitted_msg(const struct ofpbuf
*b
)
1119 struct ofp_header
*oh
= b
->data
;
1120 uint8_t type
= oh
->type
;
1122 && (1u << type
) & ((1u << OFPT_HELLO
) |
1123 (1u << OFPT_ERROR
) |
1124 (1u << OFPT_ECHO_REQUEST
) |
1125 (1u << OFPT_ECHO_REPLY
) |
1126 (1u << OFPT_VENDOR
) |
1127 (1u << OFPT_FEATURES_REQUEST
) |
1128 (1u << OFPT_FEATURES_REPLY
) |
1129 (1u << OFPT_GET_CONFIG_REQUEST
) |
1130 (1u << OFPT_GET_CONFIG_REPLY
) |
1131 (1u << OFPT_SET_CONFIG
)));
1134 /* Returns true if 'rc' is currently logging information about connection
1135 * attempts, false if logging should be suppressed because 'rc' hasn't
1136 * successuflly connected in too long. */
1138 rconn_logging_connection_attempts__(const struct rconn
*rc
)
1140 return rc
->backoff
< rc
->max_backoff
;