2 * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016 Nicira, Inc.
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.
25 #include "dynamic-string.h"
26 #include "fail-open.h"
29 #include "ofp-actions.h"
33 #include "ofproto-provider.h"
35 #include "poll-loop.h"
42 #include "openvswitch/vconn.h"
43 #include "openvswitch/vlog.h"
47 VLOG_DEFINE_THIS_MODULE(connmgr
);
48 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(1, 5);
50 /* An OpenFlow connection.
56 * 'ofproto_mutex' must be held whenever an ofconn is created or destroyed or,
57 * more or less equivalently, whenever an ofconn is added to or removed from a
58 * connmgr. 'ofproto_mutex' doesn't protect the data inside the ofconn, except
59 * as specifically noted below. */
61 /* Configuration that persists from one connection to the next. */
63 struct ovs_list node
; /* In struct connmgr's "all_conns" list. */
64 struct hmap_node hmap_node
; /* In struct connmgr's "controllers" map. */
66 struct connmgr
*connmgr
; /* Connection's manager. */
67 struct rconn
*rconn
; /* OpenFlow connection. */
68 enum ofconn_type type
; /* Type. */
69 enum ofproto_band band
; /* In-band or out-of-band? */
70 bool enable_async_msgs
; /* Initially enable async messages? */
72 /* State that should be cleared from one connection to the next. */
75 enum ofp12_controller_role role
; /* Role. */
76 enum ofputil_protocol protocol
; /* Current protocol variant. */
77 enum nx_packet_in_format packet_in_format
; /* OFPT_PACKET_IN format. */
79 /* OFPT_PACKET_IN related data. */
80 struct rconn_packet_counter
*packet_in_counter
; /* # queued on 'rconn'. */
81 #define N_SCHEDULERS 2
82 struct pinsched
*schedulers
[N_SCHEDULERS
];
83 struct pktbuf
*pktbuf
; /* OpenFlow packet buffers. */
84 int miss_send_len
; /* Bytes to send of buffered packets. */
85 uint16_t controller_id
; /* Connection controller ID. */
87 /* Number of OpenFlow messages queued on 'rconn' as replies to OpenFlow
88 * requests, and the maximum number before we stop reading OpenFlow
90 #define OFCONN_REPLY_MAX 100
91 struct rconn_packet_counter
*reply_counter
;
93 /* Asynchronous message configuration in each possible role.
95 * A 1-bit enables sending an asynchronous message for one possible reason
96 * that the message might be generated, a 0-bit disables it. */
97 struct ofputil_async_cfg
*async_cfg
;
99 /* Flow table operation logging. */
100 int n_add
, n_delete
, n_modify
; /* Number of unreported ops of each kind. */
101 long long int first_op
, last_op
; /* Range of times for unreported ops. */
102 long long int next_op_report
; /* Time to report ops, or LLONG_MAX. */
103 long long int op_backoff
; /* Earliest time to report ops again. */
105 /* Flow monitors (e.g. NXST_FLOW_MONITOR). */
107 /* Configuration. Contains "struct ofmonitor"s. */
108 struct hmap monitors
OVS_GUARDED_BY(ofproto_mutex
);
112 * When too many flow monitor notifications back up in the transmit buffer,
113 * we pause the transmission of further notifications. These members track
114 * the flow control state.
116 * When notifications are flowing, 'monitor_paused' is 0. When
117 * notifications are paused, 'monitor_paused' is the value of
118 * 'monitor_seqno' at the point we paused.
120 * 'monitor_counter' counts the OpenFlow messages and bytes currently in
121 * flight. This value growing too large triggers pausing. */
122 uint64_t monitor_paused
OVS_GUARDED_BY(ofproto_mutex
);
123 struct rconn_packet_counter
*monitor_counter
OVS_GUARDED_BY(ofproto_mutex
);
125 /* State of monitors for a single ongoing flow_mod.
127 * 'updates' is a list of "struct ofpbuf"s that contain
128 * NXST_FLOW_MONITOR_REPLY messages representing the changes made by the
131 * When 'updates' is nonempty, 'sent_abbrev_update' is true if 'updates'
132 * contains an update event of type NXFME_ABBREV and false otherwise.. */
133 struct ovs_list updates
OVS_GUARDED_BY(ofproto_mutex
);
134 bool sent_abbrev_update
OVS_GUARDED_BY(ofproto_mutex
);
136 /* Active bundles. Contains "struct ofp_bundle"s. */
140 static struct ofconn
*ofconn_create(struct connmgr
*, struct rconn
*,
141 enum ofconn_type
, bool enable_async_msgs
)
142 OVS_REQUIRES(ofproto_mutex
);
143 static void ofconn_destroy(struct ofconn
*) OVS_REQUIRES(ofproto_mutex
);
144 static void ofconn_flush(struct ofconn
*) OVS_REQUIRES(ofproto_mutex
);
146 static void ofconn_reconfigure(struct ofconn
*,
147 const struct ofproto_controller
*);
149 static void ofconn_run(struct ofconn
*,
150 void (*handle_openflow
)(struct ofconn
*,
151 const struct ofpbuf
*ofp_msg
));
152 static void ofconn_wait(struct ofconn
*);
154 static void ofconn_log_flow_mods(struct ofconn
*);
156 static const char *ofconn_get_target(const struct ofconn
*);
157 static char *ofconn_make_name(const struct connmgr
*, const char *target
);
159 static void ofconn_set_rate_limit(struct ofconn
*, int rate
, int burst
);
161 static void ofconn_send(const struct ofconn
*, struct ofpbuf
*,
162 struct rconn_packet_counter
*);
164 static void do_send_packet_ins(struct ofconn
*, struct ovs_list
*txq
);
166 /* A listener for incoming OpenFlow "service" connections. */
168 struct hmap_node node
; /* In struct connmgr's "services" hmap. */
169 struct pvconn
*pvconn
; /* OpenFlow connection listener. */
171 /* These are not used by ofservice directly. They are settings for
172 * accepted "struct ofconn"s from the pvconn. */
173 int probe_interval
; /* Max idle time before probing, in seconds. */
174 int rate_limit
; /* Max packet-in rate in packets per second. */
175 int burst_limit
; /* Limit on accumulating packet credits. */
176 bool enable_async_msgs
; /* Initially enable async messages? */
177 uint8_t dscp
; /* DSCP Value for controller connection */
178 uint32_t allowed_versions
; /* OpenFlow protocol versions that may
179 * be negotiated for a session. */
182 static void ofservice_reconfigure(struct ofservice
*,
183 const struct ofproto_controller
*);
184 static int ofservice_create(struct connmgr
*mgr
, const char *target
,
185 uint32_t allowed_versions
, uint8_t dscp
);
186 static void ofservice_destroy(struct connmgr
*, struct ofservice
*);
187 static struct ofservice
*ofservice_lookup(struct connmgr
*,
190 /* Connection manager for an OpenFlow switch. */
192 struct ofproto
*ofproto
;
194 char *local_port_name
;
196 /* OpenFlow connections. */
197 struct hmap controllers
; /* All OFCONN_PRIMARY controllers. */
198 struct ovs_list all_conns
; /* All controllers. */
199 uint64_t master_election_id
; /* monotonically increasing sequence number
200 * for master election */
201 bool master_election_id_defined
;
203 /* OpenFlow listeners. */
204 struct hmap services
; /* Contains "struct ofservice"s. */
205 struct pvconn
**snoops
;
209 struct fail_open
*fail_open
;
210 enum ofproto_fail_mode fail_mode
;
212 /* In-band control. */
213 struct in_band
*in_band
;
214 struct sockaddr_in
*extra_in_band_remotes
;
215 size_t n_extra_remotes
;
219 static void update_in_band_remotes(struct connmgr
*);
220 static void add_snooper(struct connmgr
*, struct vconn
*);
221 static void ofmonitor_run(struct connmgr
*);
222 static void ofmonitor_wait(struct connmgr
*);
224 /* Creates and returns a new connection manager owned by 'ofproto'. 'name' is
225 * a name for the ofproto suitable for using in log messages.
226 * 'local_port_name' is the name of the local port (OFPP_LOCAL) within
229 connmgr_create(struct ofproto
*ofproto
,
230 const char *name
, const char *local_port_name
)
234 mgr
= xmalloc(sizeof *mgr
);
235 mgr
->ofproto
= ofproto
;
236 mgr
->name
= xstrdup(name
);
237 mgr
->local_port_name
= xstrdup(local_port_name
);
239 hmap_init(&mgr
->controllers
);
240 list_init(&mgr
->all_conns
);
241 mgr
->master_election_id
= 0;
242 mgr
->master_election_id_defined
= false;
244 hmap_init(&mgr
->services
);
248 mgr
->fail_open
= NULL
;
249 mgr
->fail_mode
= OFPROTO_FAIL_SECURE
;
252 mgr
->extra_in_band_remotes
= NULL
;
253 mgr
->n_extra_remotes
= 0;
254 mgr
->in_band_queue
= -1;
259 /* Frees 'mgr' and all of its resources. */
261 connmgr_destroy(struct connmgr
*mgr
)
263 struct ofservice
*ofservice
, *next_ofservice
;
264 struct ofconn
*ofconn
, *next_ofconn
;
271 ovs_mutex_lock(&ofproto_mutex
);
272 LIST_FOR_EACH_SAFE (ofconn
, next_ofconn
, node
, &mgr
->all_conns
) {
273 ofconn_destroy(ofconn
);
275 ovs_mutex_unlock(&ofproto_mutex
);
277 hmap_destroy(&mgr
->controllers
);
279 HMAP_FOR_EACH_SAFE (ofservice
, next_ofservice
, node
, &mgr
->services
) {
280 ofservice_destroy(mgr
, ofservice
);
282 hmap_destroy(&mgr
->services
);
284 for (i
= 0; i
< mgr
->n_snoops
; i
++) {
285 pvconn_close(mgr
->snoops
[i
]);
289 fail_open_destroy(mgr
->fail_open
);
290 mgr
->fail_open
= NULL
;
292 in_band_destroy(mgr
->in_band
);
294 free(mgr
->extra_in_band_remotes
);
296 free(mgr
->local_port_name
);
301 /* Does all of the periodic maintenance required by 'mgr'. Calls
302 * 'handle_openflow' for each message received on an OpenFlow connection,
303 * passing along the OpenFlow connection itself and the message that was sent.
304 * 'handle_openflow' must not modify or free the message. */
306 connmgr_run(struct connmgr
*mgr
,
307 void (*handle_openflow
)(struct ofconn
*,
308 const struct ofpbuf
*ofp_msg
))
309 OVS_EXCLUDED(ofproto_mutex
)
311 struct ofconn
*ofconn
, *next_ofconn
;
312 struct ofservice
*ofservice
;
316 if (!in_band_run(mgr
->in_band
)) {
317 in_band_destroy(mgr
->in_band
);
322 LIST_FOR_EACH_SAFE (ofconn
, next_ofconn
, node
, &mgr
->all_conns
) {
323 ofconn_run(ofconn
, handle_openflow
);
327 /* Fail-open maintenance. Do this after processing the ofconns since
328 * fail-open checks the status of the controller rconn. */
329 if (mgr
->fail_open
) {
330 fail_open_run(mgr
->fail_open
);
333 HMAP_FOR_EACH (ofservice
, node
, &mgr
->services
) {
337 retval
= pvconn_accept(ofservice
->pvconn
, &vconn
);
342 /* Passing default value for creation of the rconn */
343 rconn
= rconn_create(ofservice
->probe_interval
, 0, ofservice
->dscp
,
344 vconn_get_allowed_versions(vconn
));
345 name
= ofconn_make_name(mgr
, vconn_get_name(vconn
));
346 rconn_connect_unreliably(rconn
, vconn
, name
);
349 ovs_mutex_lock(&ofproto_mutex
);
350 ofconn
= ofconn_create(mgr
, rconn
, OFCONN_SERVICE
,
351 ofservice
->enable_async_msgs
);
352 ovs_mutex_unlock(&ofproto_mutex
);
354 ofconn_set_rate_limit(ofconn
, ofservice
->rate_limit
,
355 ofservice
->burst_limit
);
356 } else if (retval
!= EAGAIN
) {
357 VLOG_WARN_RL(&rl
, "accept failed (%s)", ovs_strerror(retval
));
361 for (i
= 0; i
< mgr
->n_snoops
; i
++) {
365 retval
= pvconn_accept(mgr
->snoops
[i
], &vconn
);
367 add_snooper(mgr
, vconn
);
368 } else if (retval
!= EAGAIN
) {
369 VLOG_WARN_RL(&rl
, "accept failed (%s)", ovs_strerror(retval
));
374 /* Causes the poll loop to wake up when connmgr_run() needs to run. */
376 connmgr_wait(struct connmgr
*mgr
)
378 struct ofservice
*ofservice
;
379 struct ofconn
*ofconn
;
382 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
387 in_band_wait(mgr
->in_band
);
389 if (mgr
->fail_open
) {
390 fail_open_wait(mgr
->fail_open
);
392 HMAP_FOR_EACH (ofservice
, node
, &mgr
->services
) {
393 pvconn_wait(ofservice
->pvconn
);
395 for (i
= 0; i
< mgr
->n_snoops
; i
++) {
396 pvconn_wait(mgr
->snoops
[i
]);
400 /* Adds some memory usage statistics for 'mgr' into 'usage', for use with
401 * memory_report(). */
403 connmgr_get_memory_usage(const struct connmgr
*mgr
, struct simap
*usage
)
405 const struct ofconn
*ofconn
;
406 unsigned int packets
= 0;
407 unsigned int ofconns
= 0;
409 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
414 packets
+= rconn_count_txqlen(ofconn
->rconn
);
415 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
416 struct pinsched_stats stats
;
418 pinsched_get_stats(ofconn
->schedulers
[i
], &stats
);
419 packets
+= stats
.n_queued
;
421 packets
+= pktbuf_count_packets(ofconn
->pktbuf
);
423 simap_increase(usage
, "ofconns", ofconns
);
424 simap_increase(usage
, "packets", packets
);
427 /* Returns the ofproto that owns 'ofconn''s connmgr. */
429 ofconn_get_ofproto(const struct ofconn
*ofconn
)
431 return ofconn
->connmgr
->ofproto
;
434 /* OpenFlow configuration. */
436 static void add_controller(struct connmgr
*, const char *target
, uint8_t dscp
,
437 uint32_t allowed_versions
)
438 OVS_REQUIRES(ofproto_mutex
);
439 static struct ofconn
*find_controller_by_target(struct connmgr
*,
441 static void update_fail_open(struct connmgr
*) OVS_EXCLUDED(ofproto_mutex
);
442 static int set_pvconns(struct pvconn
***pvconnsp
, size_t *n_pvconnsp
,
443 const struct sset
*);
445 /* Returns true if 'mgr' has any configured primary controllers.
447 * Service controllers do not count, but configured primary controllers do
448 * count whether or not they are currently connected. */
450 connmgr_has_controllers(const struct connmgr
*mgr
)
452 return !hmap_is_empty(&mgr
->controllers
);
455 /* Initializes 'info' and populates it with information about each configured
456 * primary controller. The keys in 'info' are the controllers' targets; the
457 * data values are corresponding "struct ofproto_controller_info".
459 * The caller owns 'info' and everything in it and should free it when it is no
462 connmgr_get_controller_info(struct connmgr
*mgr
, struct shash
*info
)
464 const struct ofconn
*ofconn
;
466 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
467 const struct rconn
*rconn
= ofconn
->rconn
;
468 const char *target
= rconn_get_target(rconn
);
470 if (!shash_find(info
, target
)) {
471 struct ofproto_controller_info
*cinfo
= xmalloc(sizeof *cinfo
);
472 time_t now
= time_now();
473 time_t last_connection
= rconn_get_last_connection(rconn
);
474 time_t last_disconnect
= rconn_get_last_disconnect(rconn
);
475 int last_error
= rconn_get_last_error(rconn
);
478 shash_add(info
, target
, cinfo
);
480 cinfo
->is_connected
= rconn_is_connected(rconn
);
481 cinfo
->role
= ofconn
->role
;
483 smap_init(&cinfo
->pairs
);
485 smap_add(&cinfo
->pairs
, "last_error",
486 ovs_retval_to_string(last_error
));
489 smap_add(&cinfo
->pairs
, "state", rconn_get_state(rconn
));
491 if (last_connection
!= TIME_MIN
) {
492 smap_add_format(&cinfo
->pairs
, "sec_since_connect",
493 "%ld", (long int) (now
- last_connection
));
496 if (last_disconnect
!= TIME_MIN
) {
497 smap_add_format(&cinfo
->pairs
, "sec_since_disconnect",
498 "%ld", (long int) (now
- last_disconnect
));
501 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
502 if (ofconn
->schedulers
[i
]) {
503 const char *name
= i
? "miss" : "action";
504 struct pinsched_stats stats
;
506 pinsched_get_stats(ofconn
->schedulers
[i
], &stats
);
507 smap_add_nocopy(&cinfo
->pairs
,
508 xasprintf("packet-in-%s-backlog", name
),
509 xasprintf("%u", stats
.n_queued
));
510 smap_add_nocopy(&cinfo
->pairs
,
511 xasprintf("packet-in-%s-bypassed", name
),
512 xasprintf("%llu", stats
.n_normal
));
513 smap_add_nocopy(&cinfo
->pairs
,
514 xasprintf("packet-in-%s-queued", name
),
515 xasprintf("%llu", stats
.n_limited
));
516 smap_add_nocopy(&cinfo
->pairs
,
517 xasprintf("packet-in-%s-dropped", name
),
518 xasprintf("%llu", stats
.n_queue_dropped
));
526 connmgr_free_controller_info(struct shash
*info
)
528 struct shash_node
*node
;
530 SHASH_FOR_EACH (node
, info
) {
531 struct ofproto_controller_info
*cinfo
= node
->data
;
532 smap_destroy(&cinfo
->pairs
);
538 /* Changes 'mgr''s set of controllers to the 'n_controllers' controllers in
541 connmgr_set_controllers(struct connmgr
*mgr
,
542 const struct ofproto_controller
*controllers
,
543 size_t n_controllers
, uint32_t allowed_versions
)
544 OVS_EXCLUDED(ofproto_mutex
)
546 bool had_controllers
= connmgr_has_controllers(mgr
);
547 struct shash new_controllers
;
548 struct ofconn
*ofconn
, *next_ofconn
;
549 struct ofservice
*ofservice
, *next_ofservice
;
552 /* Required to add and remove ofconns. This could probably be narrowed to
553 * cover a smaller amount of code, if that yielded some benefit. */
554 ovs_mutex_lock(&ofproto_mutex
);
556 /* Create newly configured controllers and services.
557 * Create a name to ofproto_controller mapping in 'new_controllers'. */
558 shash_init(&new_controllers
);
559 for (i
= 0; i
< n_controllers
; i
++) {
560 const struct ofproto_controller
*c
= &controllers
[i
];
562 if (!vconn_verify_name(c
->target
)) {
564 ofconn
= find_controller_by_target(mgr
, c
->target
);
566 VLOG_INFO("%s: added primary controller \"%s\"",
567 mgr
->name
, c
->target
);
569 } else if (rconn_get_allowed_versions(ofconn
->rconn
) !=
571 VLOG_INFO("%s: re-added primary controller \"%s\"",
572 mgr
->name
, c
->target
);
574 ofconn_destroy(ofconn
);
577 add_controller(mgr
, c
->target
, c
->dscp
, allowed_versions
);
579 } else if (!pvconn_verify_name(c
->target
)) {
581 ofservice
= ofservice_lookup(mgr
, c
->target
);
583 VLOG_INFO("%s: added service controller \"%s\"",
584 mgr
->name
, c
->target
);
586 } else if (ofservice
->allowed_versions
!= allowed_versions
) {
587 VLOG_INFO("%s: re-added service controller \"%s\"",
588 mgr
->name
, c
->target
);
589 ofservice_destroy(mgr
, ofservice
);
593 ofservice_create(mgr
, c
->target
, allowed_versions
, c
->dscp
);
596 VLOG_WARN_RL(&rl
, "%s: unsupported controller \"%s\"",
597 mgr
->name
, c
->target
);
601 shash_add_once(&new_controllers
, c
->target
, &controllers
[i
]);
604 /* Delete controllers that are no longer configured.
605 * Update configuration of all now-existing controllers. */
606 HMAP_FOR_EACH_SAFE (ofconn
, next_ofconn
, hmap_node
, &mgr
->controllers
) {
607 const char *target
= ofconn_get_target(ofconn
);
608 struct ofproto_controller
*c
;
610 c
= shash_find_data(&new_controllers
, target
);
612 VLOG_INFO("%s: removed primary controller \"%s\"",
614 ofconn_destroy(ofconn
);
616 ofconn_reconfigure(ofconn
, c
);
620 /* Delete services that are no longer configured.
621 * Update configuration of all now-existing services. */
622 HMAP_FOR_EACH_SAFE (ofservice
, next_ofservice
, node
, &mgr
->services
) {
623 const char *target
= pvconn_get_name(ofservice
->pvconn
);
624 struct ofproto_controller
*c
;
626 c
= shash_find_data(&new_controllers
, target
);
628 VLOG_INFO("%s: removed service controller \"%s\"",
630 ofservice_destroy(mgr
, ofservice
);
632 ofservice_reconfigure(ofservice
, c
);
636 shash_destroy(&new_controllers
);
638 ovs_mutex_unlock(&ofproto_mutex
);
640 update_in_band_remotes(mgr
);
641 update_fail_open(mgr
);
642 if (had_controllers
!= connmgr_has_controllers(mgr
)) {
643 ofproto_flush_flows(mgr
->ofproto
);
647 /* Drops the connections between 'mgr' and all of its primary and secondary
648 * controllers, forcing them to reconnect. */
650 connmgr_reconnect(const struct connmgr
*mgr
)
652 struct ofconn
*ofconn
;
654 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
655 rconn_reconnect(ofconn
->rconn
);
659 /* Sets the "snoops" for 'mgr' to the pvconn targets listed in 'snoops'.
661 * A "snoop" is a pvconn to which every OpenFlow message to or from the most
662 * important controller on 'mgr' is mirrored. */
664 connmgr_set_snoops(struct connmgr
*mgr
, const struct sset
*snoops
)
666 return set_pvconns(&mgr
->snoops
, &mgr
->n_snoops
, snoops
);
669 /* Adds each of the snoops currently configured on 'mgr' to 'snoops'. */
671 connmgr_get_snoops(const struct connmgr
*mgr
, struct sset
*snoops
)
675 for (i
= 0; i
< mgr
->n_snoops
; i
++) {
676 sset_add(snoops
, pvconn_get_name(mgr
->snoops
[i
]));
680 /* Returns true if 'mgr' has at least one snoop, false if it has none. */
682 connmgr_has_snoops(const struct connmgr
*mgr
)
684 return mgr
->n_snoops
> 0;
687 /* Creates a new controller for 'target' in 'mgr'. update_controller() needs
688 * to be called later to finish the new ofconn's configuration. */
690 add_controller(struct connmgr
*mgr
, const char *target
, uint8_t dscp
,
691 uint32_t allowed_versions
)
692 OVS_REQUIRES(ofproto_mutex
)
694 char *name
= ofconn_make_name(mgr
, target
);
695 struct ofconn
*ofconn
;
697 ofconn
= ofconn_create(mgr
, rconn_create(5, 8, dscp
, allowed_versions
),
698 OFCONN_PRIMARY
, true);
699 ofconn
->pktbuf
= pktbuf_create();
700 rconn_connect(ofconn
->rconn
, target
, name
);
701 hmap_insert(&mgr
->controllers
, &ofconn
->hmap_node
, hash_string(target
, 0));
706 static struct ofconn
*
707 find_controller_by_target(struct connmgr
*mgr
, const char *target
)
709 struct ofconn
*ofconn
;
711 HMAP_FOR_EACH_WITH_HASH (ofconn
, hmap_node
,
712 hash_string(target
, 0), &mgr
->controllers
) {
713 if (!strcmp(ofconn_get_target(ofconn
), target
)) {
721 update_in_band_remotes(struct connmgr
*mgr
)
723 struct sockaddr_in
*addrs
;
724 size_t max_addrs
, n_addrs
;
725 struct ofconn
*ofconn
;
728 /* Allocate enough memory for as many remotes as we could possibly have. */
729 max_addrs
= mgr
->n_extra_remotes
+ hmap_count(&mgr
->controllers
);
730 addrs
= xmalloc(max_addrs
* sizeof *addrs
);
733 /* Add all the remotes. */
734 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
735 const char *target
= rconn_get_target(ofconn
->rconn
);
737 struct sockaddr_storage ss
;
738 struct sockaddr_in in
;
741 if (ofconn
->band
== OFPROTO_IN_BAND
742 && stream_parse_target_with_default_port(target
, OFP_PORT
, &sa
.ss
)
743 && sa
.ss
.ss_family
== AF_INET
) {
744 addrs
[n_addrs
++] = sa
.in
;
747 for (i
= 0; i
< mgr
->n_extra_remotes
; i
++) {
748 addrs
[n_addrs
++] = mgr
->extra_in_band_remotes
[i
];
751 /* Create or update or destroy in-band. */
754 in_band_create(mgr
->ofproto
, mgr
->local_port_name
, &mgr
->in_band
);
756 in_band_set_queue(mgr
->in_band
, mgr
->in_band_queue
);
758 /* in_band_run() needs a chance to delete any existing in-band flows.
759 * We will destroy mgr->in_band after it's done with that. */
762 in_band_set_remotes(mgr
->in_band
, addrs
, n_addrs
);
770 update_fail_open(struct connmgr
*mgr
)
771 OVS_EXCLUDED(ofproto_mutex
)
773 if (connmgr_has_controllers(mgr
)
774 && mgr
->fail_mode
== OFPROTO_FAIL_STANDALONE
) {
775 if (!mgr
->fail_open
) {
776 mgr
->fail_open
= fail_open_create(mgr
->ofproto
, mgr
);
779 fail_open_destroy(mgr
->fail_open
);
780 mgr
->fail_open
= NULL
;
785 set_pvconns(struct pvconn
***pvconnsp
, size_t *n_pvconnsp
,
786 const struct sset
*sset
)
788 struct pvconn
**pvconns
= *pvconnsp
;
789 size_t n_pvconns
= *n_pvconnsp
;
794 for (i
= 0; i
< n_pvconns
; i
++) {
795 pvconn_close(pvconns
[i
]);
799 pvconns
= xmalloc(sset_count(sset
) * sizeof *pvconns
);
801 SSET_FOR_EACH (name
, sset
) {
802 struct pvconn
*pvconn
;
804 error
= pvconn_open(name
, 0, 0, &pvconn
);
806 pvconns
[n_pvconns
++] = pvconn
;
808 VLOG_ERR("failed to listen on %s: %s", name
, ovs_strerror(error
));
816 *n_pvconnsp
= n_pvconns
;
821 /* Returns a "preference level" for snooping 'ofconn'. A higher return value
822 * means that 'ofconn' is more interesting for monitoring than a lower return
825 snoop_preference(const struct ofconn
*ofconn
)
827 switch (ofconn
->role
) {
828 case OFPCR12_ROLE_MASTER
:
830 case OFPCR12_ROLE_EQUAL
:
832 case OFPCR12_ROLE_SLAVE
:
834 case OFPCR12_ROLE_NOCHANGE
:
836 /* Shouldn't happen. */
841 /* One of 'mgr''s "snoop" pvconns has accepted a new connection on 'vconn'.
842 * Connects this vconn to a controller. */
844 add_snooper(struct connmgr
*mgr
, struct vconn
*vconn
)
846 struct ofconn
*ofconn
, *best
;
848 /* Pick a controller for monitoring. */
850 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
851 if (ofconn
->type
== OFCONN_PRIMARY
852 && (!best
|| snoop_preference(ofconn
) > snoop_preference(best
))) {
858 rconn_add_monitor(best
->rconn
, vconn
);
860 VLOG_INFO_RL(&rl
, "no controller connection to snoop");
865 /* Public ofconn functions. */
867 /* Returns the connection type, either OFCONN_PRIMARY or OFCONN_SERVICE. */
869 ofconn_get_type(const struct ofconn
*ofconn
)
874 /* If a master election id is defined, stores it into '*idp' and returns
875 * true. Otherwise, stores UINT64_MAX into '*idp' and returns false. */
877 ofconn_get_master_election_id(const struct ofconn
*ofconn
, uint64_t *idp
)
879 *idp
= (ofconn
->connmgr
->master_election_id_defined
880 ? ofconn
->connmgr
->master_election_id
882 return ofconn
->connmgr
->master_election_id_defined
;
885 /* Sets the master election id.
887 * Returns true if successful, false if the id is stale
890 ofconn_set_master_election_id(struct ofconn
*ofconn
, uint64_t id
)
892 if (ofconn
->connmgr
->master_election_id_defined
894 /* Unsigned difference interpreted as a two's complement signed
896 (int64_t)(id
- ofconn
->connmgr
->master_election_id
) < 0) {
899 ofconn
->connmgr
->master_election_id
= id
;
900 ofconn
->connmgr
->master_election_id_defined
= true;
905 /* Returns the role configured for 'ofconn'.
907 * The default role, if no other role has been set, is OFPCR12_ROLE_EQUAL. */
908 enum ofp12_controller_role
909 ofconn_get_role(const struct ofconn
*ofconn
)
915 ofconn_send_role_status(struct ofconn
*ofconn
, uint32_t role
, uint8_t reason
)
917 struct ofputil_role_status status
;
920 status
.reason
= reason
;
922 ofconn_get_master_election_id(ofconn
, &status
.generation_id
);
924 buf
= ofputil_encode_role_status(&status
, ofconn_get_protocol(ofconn
));
926 ofconn_send(ofconn
, buf
, NULL
);
930 /* Changes 'ofconn''s role to 'role'. If 'role' is OFPCR12_ROLE_MASTER then
931 * any existing master is demoted to a slave. */
933 ofconn_set_role(struct ofconn
*ofconn
, enum ofp12_controller_role role
)
935 if (role
!= ofconn
->role
&& role
== OFPCR12_ROLE_MASTER
) {
936 struct ofconn
*other
;
938 LIST_FOR_EACH (other
, node
, &ofconn
->connmgr
->all_conns
) {
939 if (other
->role
== OFPCR12_ROLE_MASTER
) {
940 other
->role
= OFPCR12_ROLE_SLAVE
;
941 ofconn_send_role_status(other
, OFPCR12_ROLE_SLAVE
, OFPCRR_MASTER_REQUEST
);
949 ofconn_set_invalid_ttl_to_controller(struct ofconn
*ofconn
, bool enable
)
951 struct ofputil_async_cfg ac
= ofconn_get_async_config(ofconn
);
952 uint32_t bit
= 1u << OFPR_INVALID_TTL
;
954 ac
.master
[OAM_PACKET_IN
] |= bit
;
956 ac
.master
[OAM_PACKET_IN
] &= ~bit
;
958 ofconn_set_async_config(ofconn
, &ac
);
962 ofconn_get_invalid_ttl_to_controller(struct ofconn
*ofconn
)
964 struct ofputil_async_cfg ac
= ofconn_get_async_config(ofconn
);
965 uint32_t bit
= 1u << OFPR_INVALID_TTL
;
966 return (ac
.master
[OAM_PACKET_IN
] & bit
) != 0;
969 /* Returns the currently configured protocol for 'ofconn', one of OFPUTIL_P_*.
971 * Returns OFPUTIL_P_NONE, which is not a valid protocol, if 'ofconn' hasn't
972 * completed version negotiation. This can't happen if at least one OpenFlow
973 * message, other than OFPT_HELLO, has been received on the connection (such as
974 * in ofproto.c's message handling code), since version negotiation is a
975 * prerequisite for starting to receive messages. This means that
976 * OFPUTIL_P_NONE is a special case that most callers need not worry about. */
977 enum ofputil_protocol
978 ofconn_get_protocol(const struct ofconn
*ofconn
)
980 if (ofconn
->protocol
== OFPUTIL_P_NONE
&&
981 rconn_is_connected(ofconn
->rconn
)) {
982 int version
= rconn_get_version(ofconn
->rconn
);
984 ofconn_set_protocol(CONST_CAST(struct ofconn
*, ofconn
),
985 ofputil_protocol_from_ofp_version(version
));
989 return ofconn
->protocol
;
992 /* Sets the protocol for 'ofconn' to 'protocol' (one of OFPUTIL_P_*).
994 * (This doesn't actually send anything to accomplish this. Presumably the
995 * caller already did that.) */
997 ofconn_set_protocol(struct ofconn
*ofconn
, enum ofputil_protocol protocol
)
999 ofconn
->protocol
= protocol
;
1002 /* Returns the currently configured packet in format for 'ofconn', one of
1005 * The default, if no other format has been set, is NXPIF_OPENFLOW10. */
1006 enum nx_packet_in_format
1007 ofconn_get_packet_in_format(struct ofconn
*ofconn
)
1009 return ofconn
->packet_in_format
;
1012 /* Sets the packet in format for 'ofconn' to 'packet_in_format' (one of
1015 ofconn_set_packet_in_format(struct ofconn
*ofconn
,
1016 enum nx_packet_in_format packet_in_format
)
1018 ofconn
->packet_in_format
= packet_in_format
;
1021 /* Sets the controller connection ID for 'ofconn' to 'controller_id'.
1023 * The connection controller ID is used for OFPP_CONTROLLER and
1024 * NXAST_CONTROLLER actions. See "struct nx_action_controller" for details. */
1026 ofconn_set_controller_id(struct ofconn
*ofconn
, uint16_t controller_id
)
1028 ofconn
->controller_id
= controller_id
;
1031 /* Returns the default miss send length for 'ofconn'. */
1033 ofconn_get_miss_send_len(const struct ofconn
*ofconn
)
1035 return ofconn
->miss_send_len
;
1038 /* Sets the default miss send length for 'ofconn' to 'miss_send_len'. */
1040 ofconn_set_miss_send_len(struct ofconn
*ofconn
, int miss_send_len
)
1042 ofconn
->miss_send_len
= miss_send_len
;
1046 ofconn_set_async_config(struct ofconn
*ofconn
,
1047 const struct ofputil_async_cfg
*ac
)
1049 if (!ofconn
->async_cfg
) {
1050 ofconn
->async_cfg
= xmalloc(sizeof *ofconn
->async_cfg
);
1052 *ofconn
->async_cfg
= *ac
;
1055 struct ofputil_async_cfg
1056 ofconn_get_async_config(const struct ofconn
*ofconn
)
1058 if (ofconn
->async_cfg
) {
1059 return *ofconn
->async_cfg
;
1062 int version
= rconn_get_version(ofconn
->rconn
);
1063 return (version
< 0 || !ofconn
->enable_async_msgs
1064 ? OFPUTIL_ASYNC_CFG_INIT
1065 : ofputil_async_cfg_default(version
));
1068 /* Sends 'msg' on 'ofconn', accounting it as a reply. (If there is a
1069 * sufficient number of OpenFlow replies in-flight on a single ofconn, then the
1070 * connmgr will stop accepting new OpenFlow requests on that ofconn until the
1071 * controller has accepted some of the replies.) */
1073 ofconn_send_reply(const struct ofconn
*ofconn
, struct ofpbuf
*msg
)
1075 ofconn_send(ofconn
, msg
, ofconn
->reply_counter
);
1078 /* Sends each of the messages in list 'replies' on 'ofconn' in order,
1079 * accounting them as replies. */
1081 ofconn_send_replies(const struct ofconn
*ofconn
, struct ovs_list
*replies
)
1083 struct ofpbuf
*reply
;
1085 LIST_FOR_EACH_POP (reply
, list_node
, replies
) {
1086 ofconn_send_reply(ofconn
, reply
);
1090 /* Sends 'error' on 'ofconn', as a reply to 'request'. Only at most the
1091 * first 64 bytes of 'request' are used. */
1093 ofconn_send_error(const struct ofconn
*ofconn
,
1094 const struct ofp_header
*request
, enum ofperr error
)
1096 static struct vlog_rate_limit err_rl
= VLOG_RATE_LIMIT_INIT(10, 10);
1097 struct ofpbuf
*reply
;
1099 reply
= ofperr_encode_reply(error
, request
);
1100 if (!VLOG_DROP_INFO(&err_rl
)) {
1101 const char *type_name
;
1105 request_len
= ntohs(request
->length
);
1106 type_name
= (!ofpraw_decode_partial(&raw
, request
,
1107 MIN(64, request_len
))
1108 ? ofpraw_get_name(raw
)
1111 VLOG_INFO("%s: sending %s error reply to %s message",
1112 rconn_get_name(ofconn
->rconn
), ofperr_to_string(error
),
1115 ofconn_send_reply(ofconn
, reply
);
1118 /* Same as pktbuf_retrieve(), using the pktbuf owned by 'ofconn'. */
1120 ofconn_pktbuf_retrieve(struct ofconn
*ofconn
, uint32_t id
,
1121 struct dp_packet
**bufferp
, ofp_port_t
*in_port
)
1123 return pktbuf_retrieve(ofconn
->pktbuf
, id
, bufferp
, in_port
);
1126 /* Reports that a flow_mod operation of the type specified by 'command' was
1127 * successfully executed by 'ofconn', so that the connmgr can log it. */
1129 ofconn_report_flow_mod(struct ofconn
*ofconn
,
1130 enum ofp_flow_mod_command command
)
1140 case OFPFC_MODIFY_STRICT
:
1145 case OFPFC_DELETE_STRICT
:
1151 if (ofconn
->next_op_report
== LLONG_MAX
) {
1152 ofconn
->first_op
= now
;
1153 ofconn
->next_op_report
= MAX(now
+ 10 * 1000, ofconn
->op_backoff
);
1154 ofconn
->op_backoff
= ofconn
->next_op_report
+ 60 * 1000;
1156 ofconn
->last_op
= now
;
1159 /* OpenFlow 1.4 bundles. */
1161 static inline uint32_t
1162 bundle_hash(uint32_t id
)
1164 return hash_int(id
, 0);
1168 ofconn_get_bundle(struct ofconn
*ofconn
, uint32_t id
)
1170 struct ofp_bundle
*bundle
;
1172 HMAP_FOR_EACH_IN_BUCKET(bundle
, node
, bundle_hash(id
), &ofconn
->bundles
) {
1173 if (bundle
->id
== id
) {
1182 ofconn_insert_bundle(struct ofconn
*ofconn
, struct ofp_bundle
*bundle
)
1184 /* XXX: Check the limit of open bundles */
1186 hmap_insert(&ofconn
->bundles
, &bundle
->node
, bundle_hash(bundle
->id
));
1192 ofconn_remove_bundle(struct ofconn
*ofconn
, struct ofp_bundle
*bundle
)
1194 hmap_remove(&ofconn
->bundles
, &bundle
->node
);
1200 bundle_remove_all(struct ofconn
*ofconn
)
1202 struct ofp_bundle
*b
, *next
;
1204 HMAP_FOR_EACH_SAFE (b
, next
, node
, &ofconn
->bundles
) {
1205 ofp_bundle_remove__(ofconn
, b
, false);
1209 /* Private ofconn functions. */
1212 ofconn_get_target(const struct ofconn
*ofconn
)
1214 return rconn_get_target(ofconn
->rconn
);
1217 static struct ofconn
*
1218 ofconn_create(struct connmgr
*mgr
, struct rconn
*rconn
, enum ofconn_type type
,
1219 bool enable_async_msgs
)
1221 struct ofconn
*ofconn
;
1223 ofconn
= xzalloc(sizeof *ofconn
);
1224 ofconn
->connmgr
= mgr
;
1225 list_push_back(&mgr
->all_conns
, &ofconn
->node
);
1226 ofconn
->rconn
= rconn
;
1227 ofconn
->type
= type
;
1228 ofconn
->enable_async_msgs
= enable_async_msgs
;
1230 hmap_init(&ofconn
->monitors
);
1231 list_init(&ofconn
->updates
);
1233 hmap_init(&ofconn
->bundles
);
1235 ofconn_flush(ofconn
);
1240 /* Clears all of the state in 'ofconn' that should not persist from one
1241 * connection to the next. */
1243 ofconn_flush(struct ofconn
*ofconn
)
1244 OVS_REQUIRES(ofproto_mutex
)
1246 struct ofmonitor
*monitor
, *next_monitor
;
1249 ofconn_log_flow_mods(ofconn
);
1251 ofconn
->role
= OFPCR12_ROLE_EQUAL
;
1252 ofconn_set_protocol(ofconn
, OFPUTIL_P_NONE
);
1253 ofconn
->packet_in_format
= NXPIF_OPENFLOW10
;
1255 rconn_packet_counter_destroy(ofconn
->packet_in_counter
);
1256 ofconn
->packet_in_counter
= rconn_packet_counter_create();
1257 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
1258 if (ofconn
->schedulers
[i
]) {
1261 pinsched_get_limits(ofconn
->schedulers
[i
], &rate
, &burst
);
1262 pinsched_destroy(ofconn
->schedulers
[i
]);
1263 ofconn
->schedulers
[i
] = pinsched_create(rate
, burst
);
1266 if (ofconn
->pktbuf
) {
1267 pktbuf_destroy(ofconn
->pktbuf
);
1268 ofconn
->pktbuf
= pktbuf_create();
1270 ofconn
->miss_send_len
= (ofconn
->type
== OFCONN_PRIMARY
1271 ? OFP_DEFAULT_MISS_SEND_LEN
1273 ofconn
->controller_id
= 0;
1275 rconn_packet_counter_destroy(ofconn
->reply_counter
);
1276 ofconn
->reply_counter
= rconn_packet_counter_create();
1278 free(ofconn
->async_cfg
);
1279 ofconn
->async_cfg
= NULL
;
1281 ofconn
->n_add
= ofconn
->n_delete
= ofconn
->n_modify
= 0;
1282 ofconn
->first_op
= ofconn
->last_op
= LLONG_MIN
;
1283 ofconn
->next_op_report
= LLONG_MAX
;
1284 ofconn
->op_backoff
= LLONG_MIN
;
1286 HMAP_FOR_EACH_SAFE (monitor
, next_monitor
, ofconn_node
,
1287 &ofconn
->monitors
) {
1288 ofmonitor_destroy(monitor
);
1290 rconn_packet_counter_destroy(ofconn
->monitor_counter
);
1291 ofconn
->monitor_counter
= rconn_packet_counter_create();
1292 ofpbuf_list_delete(&ofconn
->updates
); /* ...but it should be empty. */
1296 ofconn_destroy(struct ofconn
*ofconn
)
1297 OVS_REQUIRES(ofproto_mutex
)
1299 ofconn_flush(ofconn
);
1301 if (ofconn
->type
== OFCONN_PRIMARY
) {
1302 hmap_remove(&ofconn
->connmgr
->controllers
, &ofconn
->hmap_node
);
1305 bundle_remove_all(ofconn
);
1306 hmap_destroy(&ofconn
->bundles
);
1308 hmap_destroy(&ofconn
->monitors
);
1309 list_remove(&ofconn
->node
);
1310 rconn_destroy(ofconn
->rconn
);
1311 rconn_packet_counter_destroy(ofconn
->packet_in_counter
);
1312 rconn_packet_counter_destroy(ofconn
->reply_counter
);
1313 pktbuf_destroy(ofconn
->pktbuf
);
1314 rconn_packet_counter_destroy(ofconn
->monitor_counter
);
1318 /* Reconfigures 'ofconn' to match 'c'. 'ofconn' and 'c' must have the same
1321 ofconn_reconfigure(struct ofconn
*ofconn
, const struct ofproto_controller
*c
)
1325 ofconn
->band
= c
->band
;
1326 ofconn
->enable_async_msgs
= c
->enable_async_msgs
;
1328 rconn_set_max_backoff(ofconn
->rconn
, c
->max_backoff
);
1330 probe_interval
= c
->probe_interval
? MAX(c
->probe_interval
, 5) : 0;
1331 rconn_set_probe_interval(ofconn
->rconn
, probe_interval
);
1333 ofconn_set_rate_limit(ofconn
, c
->rate_limit
, c
->burst_limit
);
1335 /* If dscp value changed reconnect. */
1336 if (c
->dscp
!= rconn_get_dscp(ofconn
->rconn
)) {
1337 rconn_set_dscp(ofconn
->rconn
, c
->dscp
);
1338 rconn_reconnect(ofconn
->rconn
);
1342 /* Returns true if it makes sense for 'ofconn' to receive and process OpenFlow
1345 ofconn_may_recv(const struct ofconn
*ofconn
)
1347 int count
= rconn_packet_counter_n_packets(ofconn
->reply_counter
);
1348 return count
< OFCONN_REPLY_MAX
;
1352 ofconn_run(struct ofconn
*ofconn
,
1353 void (*handle_openflow
)(struct ofconn
*,
1354 const struct ofpbuf
*ofp_msg
))
1356 struct connmgr
*mgr
= ofconn
->connmgr
;
1359 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
1360 struct ovs_list txq
;
1362 pinsched_run(ofconn
->schedulers
[i
], &txq
);
1363 do_send_packet_ins(ofconn
, &txq
);
1366 rconn_run(ofconn
->rconn
);
1368 /* Limit the number of iterations to avoid starving other tasks. */
1369 for (i
= 0; i
< 50 && ofconn_may_recv(ofconn
); i
++) {
1370 struct ofpbuf
*of_msg
= rconn_recv(ofconn
->rconn
);
1375 if (mgr
->fail_open
) {
1376 fail_open_maybe_recover(mgr
->fail_open
);
1379 handle_openflow(ofconn
, of_msg
);
1380 ofpbuf_delete(of_msg
);
1383 if (time_msec() >= ofconn
->next_op_report
) {
1384 ofconn_log_flow_mods(ofconn
);
1387 ovs_mutex_lock(&ofproto_mutex
);
1388 if (!rconn_is_alive(ofconn
->rconn
)) {
1389 ofconn_destroy(ofconn
);
1390 } else if (!rconn_is_connected(ofconn
->rconn
)) {
1391 ofconn_flush(ofconn
);
1393 ovs_mutex_unlock(&ofproto_mutex
);
1397 ofconn_wait(struct ofconn
*ofconn
)
1401 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
1402 pinsched_wait(ofconn
->schedulers
[i
]);
1404 rconn_run_wait(ofconn
->rconn
);
1405 if (ofconn_may_recv(ofconn
)) {
1406 rconn_recv_wait(ofconn
->rconn
);
1408 if (ofconn
->next_op_report
!= LLONG_MAX
) {
1409 poll_timer_wait_until(ofconn
->next_op_report
);
1414 ofconn_log_flow_mods(struct ofconn
*ofconn
)
1416 int n_flow_mods
= ofconn
->n_add
+ ofconn
->n_delete
+ ofconn
->n_modify
;
1418 long long int ago
= (time_msec() - ofconn
->first_op
) / 1000;
1419 long long int interval
= (ofconn
->last_op
- ofconn
->first_op
) / 1000;
1423 ds_put_format(&s
, "%d flow_mods ", n_flow_mods
);
1424 if (interval
== ago
) {
1425 ds_put_format(&s
, "in the last %lld s", ago
);
1426 } else if (interval
) {
1427 ds_put_format(&s
, "in the %lld s starting %lld s ago",
1430 ds_put_format(&s
, "%lld s ago", ago
);
1433 ds_put_cstr(&s
, " (");
1434 if (ofconn
->n_add
) {
1435 ds_put_format(&s
, "%d adds, ", ofconn
->n_add
);
1437 if (ofconn
->n_delete
) {
1438 ds_put_format(&s
, "%d deletes, ", ofconn
->n_delete
);
1440 if (ofconn
->n_modify
) {
1441 ds_put_format(&s
, "%d modifications, ", ofconn
->n_modify
);
1444 ds_put_char(&s
, ')');
1446 VLOG_INFO("%s: %s", rconn_get_name(ofconn
->rconn
), ds_cstr(&s
));
1449 ofconn
->n_add
= ofconn
->n_delete
= ofconn
->n_modify
= 0;
1451 ofconn
->next_op_report
= LLONG_MAX
;
1454 /* Returns true if 'ofconn' should receive asynchronous messages of the given
1455 * OAM_* 'type' and 'reason', which should be a OFPR_* value for OAM_PACKET_IN,
1456 * a OFPPR_* value for OAM_PORT_STATUS, or an OFPRR_* value for
1457 * OAM_FLOW_REMOVED. Returns false if the message should not be sent on
1460 ofconn_receives_async_msg(const struct ofconn
*ofconn
,
1461 enum ofputil_async_msg_type type
,
1462 unsigned int reason
)
1464 ovs_assert(reason
< 32);
1465 ovs_assert((unsigned int) type
< OAM_N_TYPES
);
1467 /* Keep the following code in sync with the documentation in the
1468 * "Asynchronous Messages" section in DESIGN. */
1470 if (ofconn
->type
== OFCONN_SERVICE
&& !ofconn
->miss_send_len
) {
1471 /* Service connections don't get asynchronous messages unless they have
1472 * explicitly asked for them by setting a nonzero miss send length. */
1476 struct ofputil_async_cfg ac
= ofconn_get_async_config(ofconn
);
1477 uint32_t *masks
= (ofconn
->role
== OFPCR12_ROLE_SLAVE
1480 return (masks
[type
] & (1u << reason
)) != 0;
1483 /* The default "table-miss" behaviour for OpenFlow1.3+ is to drop the
1484 * packet rather than to send the packet to the controller.
1486 * This function returns true to indicate that a packet_in message
1487 * for a "table-miss" should be sent to at least one controller.
1488 * That is there is at least one controller with controller_id 0
1489 * which connected using an OpenFlow version earlier than OpenFlow1.3.
1493 * This logic assumes that "table-miss" packet_in messages
1494 * are always sent to controller_id 0. */
1496 connmgr_wants_packet_in_on_miss(struct connmgr
*mgr
) OVS_EXCLUDED(ofproto_mutex
)
1498 struct ofconn
*ofconn
;
1500 ovs_mutex_lock(&ofproto_mutex
);
1501 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
1502 enum ofputil_protocol protocol
= ofconn_get_protocol(ofconn
);
1504 if (ofconn
->controller_id
== 0 &&
1505 (protocol
== OFPUTIL_P_NONE
||
1506 ofputil_protocol_to_ofp_version(protocol
) < OFP13_VERSION
)) {
1507 ovs_mutex_unlock(&ofproto_mutex
);
1511 ovs_mutex_unlock(&ofproto_mutex
);
1516 /* Returns a human-readable name for an OpenFlow connection between 'mgr' and
1517 * 'target', suitable for use in log messages for identifying the connection.
1519 * The name is dynamically allocated. The caller should free it (with free())
1520 * when it is no longer needed. */
1522 ofconn_make_name(const struct connmgr
*mgr
, const char *target
)
1524 return xasprintf("%s<->%s", mgr
->name
, target
);
1528 ofconn_set_rate_limit(struct ofconn
*ofconn
, int rate
, int burst
)
1532 for (i
= 0; i
< N_SCHEDULERS
; i
++) {
1533 struct pinsched
**s
= &ofconn
->schedulers
[i
];
1537 *s
= pinsched_create(rate
, burst
);
1539 pinsched_set_limits(*s
, rate
, burst
);
1542 pinsched_destroy(*s
);
1549 ofconn_send(const struct ofconn
*ofconn
, struct ofpbuf
*msg
,
1550 struct rconn_packet_counter
*counter
)
1552 ofpmsg_update_length(msg
);
1553 rconn_send(ofconn
->rconn
, msg
, counter
);
1556 /* Sending asynchronous messages. */
1558 /* Sends an OFPT_PORT_STATUS message with 'opp' and 'reason' to appropriate
1559 * controllers managed by 'mgr'. For messages caused by a controller
1560 * OFPT_PORT_MOD, specify 'source' as the controller connection that sent the
1561 * request; otherwise, specify 'source' as NULL. */
1563 connmgr_send_port_status(struct connmgr
*mgr
, struct ofconn
*source
,
1564 const struct ofputil_phy_port
*pp
, uint8_t reason
)
1566 /* XXX Should limit the number of queued port status change messages. */
1567 struct ofputil_port_status ps
;
1568 struct ofconn
*ofconn
;
1572 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
1573 if (ofconn_receives_async_msg(ofconn
, OAM_PORT_STATUS
, reason
)) {
1576 /* Before 1.5, OpenFlow specified that OFPT_PORT_MOD should not
1577 * generate OFPT_PORT_STATUS messages. That requirement was a
1578 * relic of how OpenFlow originally supported a single controller,
1579 * so that one could expect the controller to already know the
1580 * changes it had made.
1582 * EXT-338 changes OpenFlow 1.5 OFPT_PORT_MOD to send
1583 * OFPT_PORT_STATUS messages to every controller. This is
1584 * obviously more useful in the multi-controller case. We could
1585 * always implement it that way in OVS, but that would risk
1586 * confusing controllers that are intended for single-controller
1587 * use only. (Imagine a controller that generates an OFPT_PORT_MOD
1588 * in response to any OFPT_PORT_STATUS!)
1590 * So this compromises: for OpenFlow 1.4 and earlier, it generates
1591 * OFPT_PORT_STATUS for OFPT_PORT_MOD, but not back to the
1592 * originating controller. In a single-controller environment, in
1593 * particular, this means that it will never generate
1594 * OFPT_PORT_STATUS for OFPT_PORT_MOD at all. */
1595 if (ofconn
== source
1596 && rconn_get_version(ofconn
->rconn
) < OFP15_VERSION
) {
1600 msg
= ofputil_encode_port_status(&ps
, ofconn_get_protocol(ofconn
));
1601 ofconn_send(ofconn
, msg
, NULL
);
1606 /* Sends an OFPT_REQUESTFORWARD message with 'request' and 'reason' to
1607 * appropriate controllers managed by 'mgr'. For messages caused by a
1608 * controller OFPT_GROUP_MOD and OFPT_METER_MOD, specify 'source' as the
1609 * controller connection that sent the request; otherwise, specify 'source'
1612 connmgr_send_requestforward(struct connmgr
*mgr
, const struct ofconn
*source
,
1613 const struct ofputil_requestforward
*rf
)
1615 struct ofconn
*ofconn
;
1617 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
1618 if (ofconn_receives_async_msg(ofconn
, OAM_REQUESTFORWARD
, rf
->reason
)
1619 && rconn_get_version(ofconn
->rconn
) >= OFP14_VERSION
1620 && ofconn
!= source
) {
1621 enum ofputil_protocol protocol
= ofconn_get_protocol(ofconn
);
1622 ofconn_send(ofconn
, ofputil_encode_requestforward(rf
, protocol
),
1628 /* Sends an OFPT_FLOW_REMOVED or NXT_FLOW_REMOVED message based on 'fr' to
1629 * appropriate controllers managed by 'mgr'. */
1631 connmgr_send_flow_removed(struct connmgr
*mgr
,
1632 const struct ofputil_flow_removed
*fr
)
1634 struct ofconn
*ofconn
;
1636 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
1637 if (ofconn_receives_async_msg(ofconn
, OAM_FLOW_REMOVED
, fr
->reason
)) {
1640 /* Account flow expirations as replies to OpenFlow requests. That
1641 * works because preventing OpenFlow requests from being processed
1642 * also prevents new flows from being added (and expiring). (It
1643 * also prevents processing OpenFlow requests that would not add
1644 * new flows, so it is imperfect.) */
1645 msg
= ofputil_encode_flow_removed(fr
, ofconn_get_protocol(ofconn
));
1646 ofconn_send_reply(ofconn
, msg
);
1651 /* Given 'pin', sends an OFPT_PACKET_IN message to each OpenFlow controller as
1652 * necessary according to their individual configurations.
1654 * The caller doesn't need to fill in pin->buffer_id or pin->total_len. */
1656 connmgr_send_async_msg(struct connmgr
*mgr
,
1657 const struct ofproto_async_msg
*am
)
1659 struct ofconn
*ofconn
;
1661 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
1662 enum ofputil_protocol protocol
= ofconn_get_protocol(ofconn
);
1663 if (protocol
== OFPUTIL_P_NONE
|| !rconn_is_connected(ofconn
->rconn
)
1664 || ofconn
->controller_id
!= am
->controller_id
1665 || !ofconn_receives_async_msg(ofconn
, am
->oam
,
1666 am
->pin
.up
.reason
)) {
1670 struct ofpbuf
*msg
= ofputil_encode_packet_in(
1671 &am
->pin
.up
, protocol
, ofconn
->packet_in_format
,
1672 am
->pin
.max_len
>= 0 ? am
->pin
.max_len
: ofconn
->miss_send_len
,
1675 struct ovs_list txq
;
1676 bool is_miss
= (am
->pin
.up
.reason
== OFPR_NO_MATCH
||
1677 am
->pin
.up
.reason
== OFPR_EXPLICIT_MISS
||
1678 am
->pin
.up
.reason
== OFPR_IMPLICIT_MISS
);
1679 pinsched_send(ofconn
->schedulers
[is_miss
],
1680 am
->pin
.up
.flow_metadata
.flow
.in_port
.ofp_port
,
1682 do_send_packet_ins(ofconn
, &txq
);
1687 do_send_packet_ins(struct ofconn
*ofconn
, struct ovs_list
*txq
)
1691 LIST_FOR_EACH_POP (pin
, list_node
, txq
) {
1692 if (rconn_send_with_limit(ofconn
->rconn
, pin
,
1693 ofconn
->packet_in_counter
, 100) == EAGAIN
) {
1694 static struct vlog_rate_limit rl
= VLOG_RATE_LIMIT_INIT(5, 5);
1696 VLOG_INFO_RL(&rl
, "%s: dropping packet-in due to queue overflow",
1697 rconn_get_name(ofconn
->rconn
));
1702 /* Fail-open settings. */
1704 /* Returns the failure handling mode (OFPROTO_FAIL_SECURE or
1705 * OFPROTO_FAIL_STANDALONE) for 'mgr'. */
1706 enum ofproto_fail_mode
1707 connmgr_get_fail_mode(const struct connmgr
*mgr
)
1709 return mgr
->fail_mode
;
1712 /* Sets the failure handling mode for 'mgr' to 'fail_mode' (either
1713 * OFPROTO_FAIL_SECURE or OFPROTO_FAIL_STANDALONE). */
1715 connmgr_set_fail_mode(struct connmgr
*mgr
, enum ofproto_fail_mode fail_mode
)
1717 if (mgr
->fail_mode
!= fail_mode
) {
1718 mgr
->fail_mode
= fail_mode
;
1719 update_fail_open(mgr
);
1720 if (!connmgr_has_controllers(mgr
)) {
1721 ofproto_flush_flows(mgr
->ofproto
);
1726 /* Fail-open implementation. */
1728 /* Returns the longest probe interval among the primary controllers configured
1729 * on 'mgr'. Returns 0 if there are no primary controllers. */
1731 connmgr_get_max_probe_interval(const struct connmgr
*mgr
)
1733 const struct ofconn
*ofconn
;
1734 int max_probe_interval
;
1736 max_probe_interval
= 0;
1737 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
1738 int probe_interval
= rconn_get_probe_interval(ofconn
->rconn
);
1739 max_probe_interval
= MAX(max_probe_interval
, probe_interval
);
1741 return max_probe_interval
;
1744 /* Returns the number of seconds for which all of 'mgr's primary controllers
1745 * have been disconnected. Returns 0 if 'mgr' has no primary controllers. */
1747 connmgr_failure_duration(const struct connmgr
*mgr
)
1749 const struct ofconn
*ofconn
;
1750 int min_failure_duration
;
1752 if (!connmgr_has_controllers(mgr
)) {
1756 min_failure_duration
= INT_MAX
;
1757 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
1758 int failure_duration
= rconn_failure_duration(ofconn
->rconn
);
1759 min_failure_duration
= MIN(min_failure_duration
, failure_duration
);
1761 return min_failure_duration
;
1764 /* Returns true if at least one primary controller is connected (regardless of
1765 * whether those controllers are believed to have authenticated and accepted
1766 * this switch), false if none of them are connected. */
1768 connmgr_is_any_controller_connected(const struct connmgr
*mgr
)
1770 const struct ofconn
*ofconn
;
1772 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
1773 if (rconn_is_connected(ofconn
->rconn
)) {
1780 /* Returns true if at least one primary controller is believed to have
1781 * authenticated and accepted this switch, false otherwise. */
1783 connmgr_is_any_controller_admitted(const struct connmgr
*mgr
)
1785 const struct ofconn
*ofconn
;
1787 HMAP_FOR_EACH (ofconn
, hmap_node
, &mgr
->controllers
) {
1788 if (rconn_is_admitted(ofconn
->rconn
)) {
1795 /* In-band configuration. */
1797 static bool any_extras_changed(const struct connmgr
*,
1798 const struct sockaddr_in
*extras
, size_t n
);
1800 /* Sets the 'n' TCP port addresses in 'extras' as ones to which 'mgr''s
1801 * in-band control should guarantee access, in the same way that in-band
1802 * control guarantees access to OpenFlow controllers. */
1804 connmgr_set_extra_in_band_remotes(struct connmgr
*mgr
,
1805 const struct sockaddr_in
*extras
, size_t n
)
1807 if (!any_extras_changed(mgr
, extras
, n
)) {
1811 free(mgr
->extra_in_band_remotes
);
1812 mgr
->n_extra_remotes
= n
;
1813 mgr
->extra_in_band_remotes
= xmemdup(extras
, n
* sizeof *extras
);
1815 update_in_band_remotes(mgr
);
1818 /* Sets the OpenFlow queue used by flows set up by in-band control on
1819 * 'mgr' to 'queue_id'. If 'queue_id' is negative, then in-band control
1820 * flows will use the default queue. */
1822 connmgr_set_in_band_queue(struct connmgr
*mgr
, int queue_id
)
1824 if (queue_id
!= mgr
->in_band_queue
) {
1825 mgr
->in_band_queue
= queue_id
;
1826 update_in_band_remotes(mgr
);
1831 any_extras_changed(const struct connmgr
*mgr
,
1832 const struct sockaddr_in
*extras
, size_t n
)
1836 if (n
!= mgr
->n_extra_remotes
) {
1840 for (i
= 0; i
< n
; i
++) {
1841 const struct sockaddr_in
*old
= &mgr
->extra_in_band_remotes
[i
];
1842 const struct sockaddr_in
*new = &extras
[i
];
1844 if (old
->sin_addr
.s_addr
!= new->sin_addr
.s_addr
||
1845 old
->sin_port
!= new->sin_port
) {
1853 /* In-band implementation. */
1856 connmgr_has_in_band(struct connmgr
*mgr
)
1858 return mgr
->in_band
!= NULL
;
1861 /* Fail-open and in-band implementation. */
1863 /* Called by 'ofproto' after all flows have been flushed, to allow fail-open
1864 * and standalone mode to re-create their flows.
1866 * In-band control has more sophisticated code that manages flows itself. */
1868 connmgr_flushed(struct connmgr
*mgr
)
1869 OVS_EXCLUDED(ofproto_mutex
)
1871 if (mgr
->fail_open
) {
1872 fail_open_flushed(mgr
->fail_open
);
1875 /* If there are no controllers and we're in standalone mode, set up a flow
1876 * that matches every packet and directs them to OFPP_NORMAL (which goes to
1877 * us). Otherwise, the switch is in secure mode and we won't pass any
1878 * traffic until a controller has been defined and it tells us to do so. */
1879 if (!connmgr_has_controllers(mgr
)
1880 && mgr
->fail_mode
== OFPROTO_FAIL_STANDALONE
) {
1881 struct ofpbuf ofpacts
;
1884 ofpbuf_init(&ofpacts
, OFPACT_OUTPUT_SIZE
);
1885 ofpact_put_OUTPUT(&ofpacts
)->port
= OFPP_NORMAL
;
1887 match_init_catchall(&match
);
1888 ofproto_add_flow(mgr
->ofproto
, &match
, 0, ofpacts
.data
,
1891 ofpbuf_uninit(&ofpacts
);
1895 /* Returns the number of hidden rules created by the in-band and fail-open
1896 * implementations in table 0. (Subtracting this count from the number of
1897 * rules in the table 0 classifier, as maintained in struct oftable, yields
1898 * the number of flows that OVS should report via OpenFlow for table 0.) */
1900 connmgr_count_hidden_rules(const struct connmgr
*mgr
)
1904 n_hidden
+= in_band_count_rules(mgr
->in_band
);
1906 if (mgr
->fail_open
) {
1907 n_hidden
+= fail_open_count_rules(mgr
->fail_open
);
1912 /* Creates a new ofservice for 'target' in 'mgr'. Returns 0 if successful,
1913 * otherwise a positive errno value.
1915 * ofservice_reconfigure() must be called to fully configure the new
1918 ofservice_create(struct connmgr
*mgr
, const char *target
,
1919 uint32_t allowed_versions
, uint8_t dscp
)
1921 struct ofservice
*ofservice
;
1922 struct pvconn
*pvconn
;
1925 error
= pvconn_open(target
, allowed_versions
, dscp
, &pvconn
);
1930 ofservice
= xzalloc(sizeof *ofservice
);
1931 hmap_insert(&mgr
->services
, &ofservice
->node
, hash_string(target
, 0));
1932 ofservice
->pvconn
= pvconn
;
1933 ofservice
->allowed_versions
= allowed_versions
;
1939 ofservice_destroy(struct connmgr
*mgr
, struct ofservice
*ofservice
)
1941 hmap_remove(&mgr
->services
, &ofservice
->node
);
1942 pvconn_close(ofservice
->pvconn
);
1947 ofservice_reconfigure(struct ofservice
*ofservice
,
1948 const struct ofproto_controller
*c
)
1950 ofservice
->probe_interval
= c
->probe_interval
;
1951 ofservice
->rate_limit
= c
->rate_limit
;
1952 ofservice
->burst_limit
= c
->burst_limit
;
1953 ofservice
->enable_async_msgs
= c
->enable_async_msgs
;
1954 ofservice
->dscp
= c
->dscp
;
1957 /* Finds and returns the ofservice within 'mgr' that has the given
1958 * 'target', or a null pointer if none exists. */
1959 static struct ofservice
*
1960 ofservice_lookup(struct connmgr
*mgr
, const char *target
)
1962 struct ofservice
*ofservice
;
1964 HMAP_FOR_EACH_WITH_HASH (ofservice
, node
, hash_string(target
, 0),
1966 if (!strcmp(pvconn_get_name(ofservice
->pvconn
), target
)) {
1973 /* Flow monitors (NXST_FLOW_MONITOR). */
1975 /* A counter incremented when something significant happens to an OpenFlow
1978 * - When a rule is added, its 'add_seqno' and 'modify_seqno' are set to
1979 * the current value (which is then incremented).
1981 * - When a rule is modified, its 'modify_seqno' is set to the current
1982 * value (which is then incremented).
1984 * Thus, by comparing an old value of monitor_seqno against a rule's
1985 * 'add_seqno', one can tell whether the rule was added before or after the old
1986 * value was read, and similarly for 'modify_seqno'.
1988 * 32 bits should normally be sufficient (and would be nice, to save space in
1989 * each rule) but then we'd have to have some special cases for wraparound.
1991 * We initialize monitor_seqno to 1 to allow 0 to be used as an invalid
1993 static uint64_t monitor_seqno
= 1;
1995 COVERAGE_DEFINE(ofmonitor_pause
);
1996 COVERAGE_DEFINE(ofmonitor_resume
);
1999 ofmonitor_create(const struct ofputil_flow_monitor_request
*request
,
2000 struct ofconn
*ofconn
, struct ofmonitor
**monitorp
)
2001 OVS_REQUIRES(ofproto_mutex
)
2003 struct ofmonitor
*m
;
2007 m
= ofmonitor_lookup(ofconn
, request
->id
);
2009 return OFPERR_OFPMOFC_MONITOR_EXISTS
;
2012 m
= xmalloc(sizeof *m
);
2014 hmap_insert(&ofconn
->monitors
, &m
->ofconn_node
, hash_int(request
->id
, 0));
2015 m
->id
= request
->id
;
2016 m
->flags
= request
->flags
;
2017 m
->out_port
= request
->out_port
;
2018 m
->table_id
= request
->table_id
;
2019 minimatch_init(&m
->match
, &request
->match
);
2026 ofmonitor_lookup(struct ofconn
*ofconn
, uint32_t id
)
2027 OVS_REQUIRES(ofproto_mutex
)
2029 struct ofmonitor
*m
;
2031 HMAP_FOR_EACH_IN_BUCKET (m
, ofconn_node
, hash_int(id
, 0),
2032 &ofconn
->monitors
) {
2041 ofmonitor_destroy(struct ofmonitor
*m
)
2042 OVS_REQUIRES(ofproto_mutex
)
2045 minimatch_destroy(&m
->match
);
2046 hmap_remove(&m
->ofconn
->monitors
, &m
->ofconn_node
);
2052 ofmonitor_report(struct connmgr
*mgr
, struct rule
*rule
,
2053 enum nx_flow_update_event event
,
2054 enum ofp_flow_removed_reason reason
,
2055 const struct ofconn
*abbrev_ofconn
, ovs_be32 abbrev_xid
,
2056 const struct rule_actions
*old_actions
)
2057 OVS_REQUIRES(ofproto_mutex
)
2059 enum nx_flow_monitor_flags update
;
2060 struct ofconn
*ofconn
;
2062 if (rule_is_hidden(rule
)) {
2069 rule
->add_seqno
= rule
->modify_seqno
= monitor_seqno
++;
2073 update
= NXFMF_DELETE
;
2076 case NXFME_MODIFIED
:
2077 update
= NXFMF_MODIFY
;
2078 rule
->modify_seqno
= monitor_seqno
++;
2086 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
2087 enum nx_flow_monitor_flags flags
= 0;
2088 struct ofmonitor
*m
;
2090 if (ofconn
->monitor_paused
) {
2091 /* Only send NXFME_DELETED notifications for flows that were added
2092 * before we paused. */
2093 if (event
!= NXFME_DELETED
2094 || rule
->add_seqno
> ofconn
->monitor_paused
) {
2099 HMAP_FOR_EACH (m
, ofconn_node
, &ofconn
->monitors
) {
2100 if (m
->flags
& update
2101 && (m
->table_id
== 0xff || m
->table_id
== rule
->table_id
)
2102 && (ofproto_rule_has_out_port(rule
, m
->out_port
)
2104 && ofpacts_output_to_port(old_actions
->ofpacts
,
2105 old_actions
->ofpacts_len
,
2107 && cls_rule_is_loose_match(&rule
->cr
, &m
->match
)) {
2113 if (list_is_empty(&ofconn
->updates
)) {
2114 ofputil_start_flow_update(&ofconn
->updates
);
2115 ofconn
->sent_abbrev_update
= false;
2118 if (flags
& NXFMF_OWN
|| ofconn
!= abbrev_ofconn
2119 || ofconn
->monitor_paused
) {
2120 struct ofputil_flow_update fu
;
2124 fu
.reason
= event
== NXFME_DELETED
? reason
: 0;
2125 fu
.table_id
= rule
->table_id
;
2126 fu
.cookie
= rule
->flow_cookie
;
2127 minimatch_expand(&rule
->cr
.match
, &match
);
2129 fu
.priority
= rule
->cr
.priority
;
2131 ovs_mutex_lock(&rule
->mutex
);
2132 fu
.idle_timeout
= rule
->idle_timeout
;
2133 fu
.hard_timeout
= rule
->hard_timeout
;
2134 ovs_mutex_unlock(&rule
->mutex
);
2136 if (flags
& NXFMF_ACTIONS
) {
2137 const struct rule_actions
*actions
= rule_get_actions(rule
);
2138 fu
.ofpacts
= actions
->ofpacts
;
2139 fu
.ofpacts_len
= actions
->ofpacts_len
;
2144 ofputil_append_flow_update(&fu
, &ofconn
->updates
);
2145 } else if (!ofconn
->sent_abbrev_update
) {
2146 struct ofputil_flow_update fu
;
2148 fu
.event
= NXFME_ABBREV
;
2149 fu
.xid
= abbrev_xid
;
2150 ofputil_append_flow_update(&fu
, &ofconn
->updates
);
2152 ofconn
->sent_abbrev_update
= true;
2159 ofmonitor_flush(struct connmgr
*mgr
)
2160 OVS_REQUIRES(ofproto_mutex
)
2162 struct ofconn
*ofconn
;
2164 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
2167 LIST_FOR_EACH_POP (msg
, list_node
, &ofconn
->updates
) {
2168 unsigned int n_bytes
;
2170 ofconn_send(ofconn
, msg
, ofconn
->monitor_counter
);
2171 n_bytes
= rconn_packet_counter_n_bytes(ofconn
->monitor_counter
);
2172 if (!ofconn
->monitor_paused
&& n_bytes
> 128 * 1024) {
2173 struct ofpbuf
*pause
;
2175 COVERAGE_INC(ofmonitor_pause
);
2176 ofconn
->monitor_paused
= monitor_seqno
++;
2177 pause
= ofpraw_alloc_xid(OFPRAW_NXT_FLOW_MONITOR_PAUSED
,
2178 OFP10_VERSION
, htonl(0), 0);
2179 ofconn_send(ofconn
, pause
, ofconn
->monitor_counter
);
2186 ofmonitor_resume(struct ofconn
*ofconn
)
2187 OVS_REQUIRES(ofproto_mutex
)
2189 struct rule_collection rules
;
2190 struct ofpbuf
*resumed
;
2191 struct ofmonitor
*m
;
2192 struct ovs_list msgs
;
2194 rule_collection_init(&rules
);
2195 HMAP_FOR_EACH (m
, ofconn_node
, &ofconn
->monitors
) {
2196 ofmonitor_collect_resume_rules(m
, ofconn
->monitor_paused
, &rules
);
2200 ofmonitor_compose_refresh_updates(&rules
, &msgs
);
2202 resumed
= ofpraw_alloc_xid(OFPRAW_NXT_FLOW_MONITOR_RESUMED
, OFP10_VERSION
,
2204 list_push_back(&msgs
, &resumed
->list_node
);
2205 ofconn_send_replies(ofconn
, &msgs
);
2207 ofconn
->monitor_paused
= 0;
2211 ofmonitor_may_resume(const struct ofconn
*ofconn
)
2212 OVS_REQUIRES(ofproto_mutex
)
2214 return (ofconn
->monitor_paused
!= 0
2215 && !rconn_packet_counter_n_packets(ofconn
->monitor_counter
));
2219 ofmonitor_run(struct connmgr
*mgr
)
2221 struct ofconn
*ofconn
;
2223 ovs_mutex_lock(&ofproto_mutex
);
2224 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
2225 if (ofmonitor_may_resume(ofconn
)) {
2226 COVERAGE_INC(ofmonitor_resume
);
2227 ofmonitor_resume(ofconn
);
2230 ovs_mutex_unlock(&ofproto_mutex
);
2234 ofmonitor_wait(struct connmgr
*mgr
)
2236 struct ofconn
*ofconn
;
2238 ovs_mutex_lock(&ofproto_mutex
);
2239 LIST_FOR_EACH (ofconn
, node
, &mgr
->all_conns
) {
2240 if (ofmonitor_may_resume(ofconn
)) {
2241 poll_immediate_wake();
2244 ovs_mutex_unlock(&ofproto_mutex
);
2248 ofproto_async_msg_free(struct ofproto_async_msg
*am
)
2250 free(CONST_CAST(void *, am
->pin
.up
.packet
));