Thanks Numan for the improvement. The patch LGTM. Please see some feedback below.
On Wed, Oct 9, 2024 at 5:02 PM Numan Siddique <[email protected]> wrote: > > Presently, > - Any changes to SB DNS, results in full recompute of lflow_output > engine node (which can be expensive). > > - DNS internal cache is maintained by pinctrl module and because of > pinctrl mutex, DNS repsonder handling in the pinctrl thread > can get delayed if the mutex is held by ovn-controller main > thread and may result in DNS timeouts for the VIFs. > > This patch addressed these concerns by > > - Removing the sb_dns as input to lflow_output engine node as it is > not required at all. > > - maintaining a separate DNS cache in a separate module. DNS cache is > now updated incrementally with the new engine node 'en_dns_cache' for > any changes to the SB DNS table. A separate mutex - dns_cache_mutex > is used to protect the DNS cache. > > pinctrl_run() now longer maintains the DNS cache and it doesn't need nit: s/now/no > to iterate all the SB DNS rows anymore. This patch also removes > the 'dns_supports_ovn_owned' check in pinctrl as ovn-controller > doesn't update the SB DNS options column. > > Reported-at: > https://mail.openvswitch.org/pipermail/ovs-discuss/2024-October/053332.html > Reported-by: Gavin McKee <[email protected]> > Signed-off-by: Numan Siddique <[email protected]> > --- > controller/automake.mk | 4 +- > controller/ovn-controller.c | 48 +++++++- > controller/ovn-dns.c | 233 ++++++++++++++++++++++++++++++++++++ > controller/ovn-dns.h | 29 +++++ > controller/pinctrl.c | 137 +-------------------- > controller/pinctrl.h | 1 - > 6 files changed, 314 insertions(+), 138 deletions(-) > create mode 100644 controller/ovn-dns.c > create mode 100644 controller/ovn-dns.h > > diff --git a/controller/automake.mk b/controller/automake.mk > index ed93cfb3c7..bb0bf2d336 100644 > --- a/controller/automake.mk > +++ b/controller/automake.mk > @@ -49,7 +49,9 @@ controller_ovn_controller_SOURCES = \ > controller/statctrl.h \ > controller/statctrl.c \ > controller/ct-zone.h \ > - controller/ct-zone.c > + controller/ct-zone.c \ > + controller/ovn-dns.c \ > + controller/ovn-dns.h > > controller_ovn_controller_LDADD = lib/libovn.la > $(OVS_LIBDIR)/libopenvswitch.la > man_MANS += controller/ovn-controller.8 > diff --git a/controller/ovn-controller.c b/controller/ovn-controller.c > index 168167b1a1..89713a27b7 100644 > --- a/controller/ovn-controller.c > +++ b/controller/ovn-controller.c > @@ -87,6 +87,7 @@ > #include "statctrl.h" > #include "lib/dns-resolve.h" > #include "ct-zone.h" > +#include "ovn-dns.h" > > VLOG_DEFINE_THIS_MODULE(main); > > @@ -3293,6 +3294,44 @@ en_mac_cache_cleanup(void *data) > hmap_destroy(&cache_data->fdbs); > } > > +static void * > +en_dns_cache_init(struct engine_node *node OVS_UNUSED, > + struct engine_arg *arg OVS_UNUSED) > +{ > + ovn_dns_cache_init(); > + return NULL; > +} > + > +static void > +en_dns_cache_run(struct engine_node *node, void *data OVS_UNUSED) > +{ > + const struct sbrec_dns_table *dns_table = > + EN_OVSDB_GET(engine_get_input("SB_dns", node)); > + > + ovn_dns_sync_cache(dns_table); > + > + engine_set_node_state(node, EN_UPDATED); > +} > + > +static bool > +dns_cache_sb_dns_handler(struct engine_node *node, void *data OVS_UNUSED) > +{ > + const struct sbrec_dns_table *dns_table = > + EN_OVSDB_GET(engine_get_input("SB_dns", node)); > + > + ovn_dns_update_cache(dns_table); > + > + engine_set_node_state(node, EN_UPDATED); > + return true; > +} > + > +static void > +en_dns_cache_cleanup(void *data OVS_UNUSED) > +{ > + ovn_dns_cache_destroy(); > +} > + > + > /* Engine node which is used to handle the Non VIF data like > * - OVS patch ports > * - Tunnel ports and the related chassis information. > @@ -5013,6 +5052,7 @@ main(int argc, char *argv[]) > ENGINE_NODE(if_status_mgr, "if_status_mgr"); > ENGINE_NODE_WITH_CLEAR_TRACK_DATA(lb_data, "lb_data"); > ENGINE_NODE(mac_cache, "mac_cache"); > + ENGINE_NODE(dns_cache, "dns_cache"); > > #define SB_NODE(NAME, NAME_STR) ENGINE_NODE_SB(NAME, NAME_STR); > SB_NODES > @@ -5144,7 +5184,7 @@ main(int argc, char *argv[]) > * process all changes. */ > engine_add_input(&en_lflow_output, &en_sb_logical_dp_group, > engine_noop_handler); > - engine_add_input(&en_lflow_output, &en_sb_dns, NULL); > + > engine_add_input(&en_lflow_output, &en_lb_data, > lflow_output_lb_data_handler); > engine_add_input(&en_lflow_output, &en_sb_fdb, > @@ -5203,12 +5243,17 @@ main(int argc, char *argv[]) > engine_add_input(&en_mac_cache, &en_sb_port_binding, > engine_noop_handler); > > + engine_add_input(&en_dns_cache, &en_sb_dns, > + dns_cache_sb_dns_handler); > + > engine_add_input(&en_controller_output, &en_lflow_output, > controller_output_lflow_output_handler); > engine_add_input(&en_controller_output, &en_pflow_output, > controller_output_pflow_output_handler); > engine_add_input(&en_controller_output, &en_mac_cache, > controller_output_mac_cache_handler); > + engine_add_input(&en_controller_output, &en_dns_cache, > + engine_noop_handler); It looks using noop handler here should be fine because the en_controller_output node is a dummy node, but I don't remember if there are other reasons the other handlers above (controller_output_lflow_output_handler, controller_output_pflow_output_handler and controller_output_mac_cache_handler) were implemented and set the node state to EN_UPDATED. Set to NULL may also be ok since the run() function of the controller_output node is doing the same thing as the other handlers, simply setting the state to EN_UPDATED. I think we can have a follow up patch to unify and clean up the unnecessary handlers. > > struct engine_arg engine_arg = { > .sb_idl = ovnsb_idl_loop.idl, > @@ -5630,7 +5675,6 @@ main(int argc, char *argv[]) > sbrec_igmp_group, > sbrec_ip_multicast, > sbrec_fdb_by_dp_key_mac, > - sbrec_dns_table_get(ovnsb_idl_loop.idl), > sbrec_controller_event_table_get( > ovnsb_idl_loop.idl), > sbrec_service_monitor_table_get( > diff --git a/controller/ovn-dns.c b/controller/ovn-dns.c > new file mode 100644 > index 0000000000..cddbdcbe38 > --- /dev/null > +++ b/controller/ovn-dns.c > @@ -0,0 +1,233 @@ > +/* Copyright (c) 2024, Red Hat, Inc. > + * > + * Licensed under the Apache License, Version 2.0 (the "License"); > + * you may not use this file except in compliance with the License. > + * You may obtain a copy of the License at: > + * > + * http://www.apache.org/licenses/LICENSE-2.0 > + * > + * Unless required by applicable law or agreed to in writing, software > + * distributed under the License is distributed on an "AS IS" BASIS, > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > + * See the License for the specific language governing permissions and > + * limitations under the License. > + */ > + > +#include <config.h> > + > +/* OVS includes */ > +#include "include/openvswitch/shash.h" > +#include "include/openvswitch/thread.h" > +#include "openvswitch/vlog.h" > + > +/* OVN includes. */ > +#include "lib/ovn-sb-idl.h" > +#include "ovn-dns.h" > + > +VLOG_DEFINE_THIS_MODULE(ovndns); > + > +/* Internal DNS cache entry for each SB DNS record. */ > +struct dns_data { > + uint64_t *dps; > + size_t n_dps; > + struct smap records; > + struct smap options; > + bool delete; > +}; > + > +/* shash of 'struct dns_data'. */ > +static struct shash dns_cache_ = SHASH_INITIALIZER(&dns_cache_); > + > +/* Mutex to protect dns_cache_. */ > +static struct ovs_mutex dns_cache_mutex = OVS_MUTEX_INITIALIZER; > + > +static void update_cache_with_dns_rec(const struct sbrec_dns *, > + struct dns_data *, > + const char *dns_id, > + struct shash *dns_cache); > +void > +ovn_dns_cache_init(void) > +{ > +} > + > +void > +ovn_dns_cache_destroy(void) > +{ > + ovs_mutex_lock(&dns_cache_mutex); > + struct shash_node *iter; > + SHASH_FOR_EACH_SAFE (iter, &dns_cache_) { > + struct dns_data *d = iter->data; > + shash_delete(&dns_cache_, iter); > + smap_destroy(&d->records); > + smap_destroy(&d->options); > + free(d->dps); > + free(d); > + } > + shash_destroy(&dns_cache_); > + ovs_mutex_unlock(&dns_cache_mutex); > +} > + > +void > +ovn_dns_sync_cache(const struct sbrec_dns_table *dns_table) > +{ > + ovs_mutex_lock(&dns_cache_mutex); Not sure how big the DNS table can be in real production. The lock can still be held for a long time if the table is huge. @Gavin did you have a try for this patch and does it solve the performance problem? In the future if necessary we can use hash bucket level lock to further reduce the lock contention, but the current approach looks good to me if it is sufficient. So overall, the patch LGTM. Acked-by: Han Zhou <[email protected]> It would be even better > + struct shash_node *iter; > + SHASH_FOR_EACH (iter, &dns_cache_) { > + struct dns_data *d = iter->data; > + d->delete = true; > + } > + > + const struct sbrec_dns *sbrec_dns; > + SBREC_DNS_TABLE_FOR_EACH (sbrec_dns, dns_table) { > + const char *dns_id = smap_get(&sbrec_dns->external_ids, "dns_id"); > + if (!dns_id) { > + continue; > + } > + > + struct dns_data *dns_data = shash_find_data(&dns_cache_, dns_id); > + if (!dns_data) { > + dns_data = xmalloc(sizeof *dns_data); > + smap_init(&dns_data->records); > + smap_init(&dns_data->options); > + shash_add(&dns_cache_, dns_id, dns_data); > + dns_data->n_dps = 0; > + dns_data->dps = NULL; > + } else { > + free(dns_data->dps); > + } > + > + dns_data->delete = false; > + > + if (!smap_equal(&dns_data->records, &sbrec_dns->records)) { > + smap_destroy(&dns_data->records); > + smap_clone(&dns_data->records, &sbrec_dns->records); > + } > + > + if (!smap_equal(&dns_data->options, &sbrec_dns->options)) { > + smap_destroy(&dns_data->options); > + smap_clone(&dns_data->options, &sbrec_dns->options); > + } > + > + dns_data->n_dps = sbrec_dns->n_datapaths; > + dns_data->dps = xcalloc(dns_data->n_dps, sizeof(uint64_t)); > + for (size_t i = 0; i < sbrec_dns->n_datapaths; i++) { > + dns_data->dps[i] = sbrec_dns->datapaths[i]->tunnel_key; > + } > + } > + > + SHASH_FOR_EACH_SAFE (iter, &dns_cache_) { > + struct dns_data *d = iter->data; > + if (d->delete) { > + shash_delete(&dns_cache_, iter); > + smap_destroy(&d->records); > + smap_destroy(&d->options); > + free(d->dps); > + free(d); > + } > + } > + ovs_mutex_unlock(&dns_cache_mutex); > +} > + > +void > +ovn_dns_update_cache(const struct sbrec_dns_table *dns_table) > +{ > + ovs_mutex_lock(&dns_cache_mutex); > + > + const struct sbrec_dns *sbrec_dns; > + SBREC_DNS_TABLE_FOR_EACH_TRACKED (sbrec_dns, dns_table) { > + const char *dns_id = smap_get(&sbrec_dns->external_ids, "dns_id"); > + if (!dns_id) { > + continue; > + } > + > + struct shash_node *shash_node = shash_find(&dns_cache_, dns_id); > + if (sbrec_dns_is_deleted(sbrec_dns)) { > + if (shash_node) { > + struct dns_data *dns_data = shash_node->data; > + shash_delete(&dns_cache_, shash_node); > + smap_destroy(&dns_data->records); > + smap_destroy(&dns_data->options); > + free(dns_data->dps); > + free(dns_data); > + } > + } else { > + update_cache_with_dns_rec(sbrec_dns, > + shash_node ? shash_node->data : NULL, > + dns_id, &dns_cache_); > + } > + } > + > + ovs_mutex_unlock(&dns_cache_mutex); > +} > + > +const char * > +ovn_dns_lookup(const char *query_name, uint64_t dp_key, bool *ovn_owned) > +{ > + ovs_mutex_lock(&dns_cache_mutex); > + > + *ovn_owned = false; > + struct shash_node *iter; > + const char *answer_data = NULL; > + SHASH_FOR_EACH (iter, &dns_cache_) { > + struct dns_data *d = iter->data; > + for (size_t i = 0; i < d->n_dps; i++) { > + if (d->dps[i] == dp_key) { > + /* DNS records in SBDB are stored in lowercase. Convert to > + * lowercase to perform case insensitive lookup > + */ > + char *query_name_lower = str_tolower(query_name); > + answer_data = smap_get(&d->records, query_name_lower); > + free(query_name_lower); > + if (answer_data) { > + *ovn_owned = smap_get_bool(&d->options, "ovn-owned", > + false); > + break; > + } > + } > + } > + > + if (answer_data) { > + break; > + } > + } > + > + ovs_mutex_unlock(&dns_cache_mutex); > + > + return answer_data; > +} > + > + > +/* Static functions. */ > +static void > +update_cache_with_dns_rec(const struct sbrec_dns *sbrec_dns, > + struct dns_data *dns_data, > + const char *dns_id, > + struct shash *dns_cache) > +{ > + if (!dns_data) { > + dns_data = xmalloc(sizeof *dns_data); > + smap_init(&dns_data->records); > + smap_init(&dns_data->options); > + shash_add(dns_cache, dns_id, dns_data); > + dns_data->n_dps = 0; > + dns_data->dps = NULL; > + } else { > + free(dns_data->dps); > + } > + > + if (!smap_equal(&dns_data->records, &sbrec_dns->records)) { > + smap_destroy(&dns_data->records); > + smap_clone(&dns_data->records, &sbrec_dns->records); > + } > + > + if (!smap_equal(&dns_data->options, &sbrec_dns->options)) { > + smap_destroy(&dns_data->options); > + smap_clone(&dns_data->options, &sbrec_dns->options); > + } > + > + dns_data->n_dps = sbrec_dns->n_datapaths; > + dns_data->dps = xcalloc(dns_data->n_dps, sizeof(uint64_t)); > + for (size_t i = 0; i < sbrec_dns->n_datapaths; i++) { > + dns_data->dps[i] = sbrec_dns->datapaths[i]->tunnel_key; > + } > +} > diff --git a/controller/ovn-dns.h b/controller/ovn-dns.h > new file mode 100644 > index 0000000000..8eca6ad0eb > --- /dev/null > +++ b/controller/ovn-dns.h > @@ -0,0 +1,29 @@ > +/* Copyright (c) 2024, Red Hat, Inc. > + * > + * Licensed under the Apache License, Version 2.0 (the "License"); > + * you may not use this file except in compliance with the License. > + * You may obtain a copy of the License at: > + * > + * http://www.apache.org/licenses/LICENSE-2.0 > + * > + * Unless required by applicable law or agreed to in writing, software > + * distributed under the License is distributed on an "AS IS" BASIS, > + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. > + * See the License for the specific language governing permissions and > + * limitations under the License. > + */ > + > +#ifndef OVN_DNS_H > +#define OVN_DNS_H > + > +struct shash; > +struct sbrec_dns_table; > + > +void ovn_dns_cache_init(void); > +void ovn_dns_cache_destroy(void); > +void ovn_dns_sync_cache(const struct sbrec_dns_table *); > +void ovn_dns_update_cache(const struct sbrec_dns_table *); > +const char *ovn_dns_lookup(const char *query_name, uint64_t dp_key, > + bool *ovn_owned); > + > +#endif /* OVN_DNS_H */ > diff --git a/controller/pinctrl.c b/controller/pinctrl.c > index c86b4f9401..c9f096803d 100644 > --- a/controller/pinctrl.c > +++ b/controller/pinctrl.c > @@ -62,6 +62,7 @@ > #include "lflow.h" > #include "ip-mcast.h" > #include "ovn-sb-idl.h" > +#include "ovn-dns.h" > > VLOG_DEFINE_THIS_MODULE(pinctrl); > > @@ -79,13 +80,6 @@ VLOG_DEFINE_THIS_MODULE(pinctrl); > * A Mutex - 'pinctrl_mutex' is used between the pinctrl_handler() thread > * and pinctrl_run(). > * > - * - dns_lookup - In order to do a DNS lookup, this action needs > - * to access the 'DNS' table. pinctrl_run() builds a > - * local DNS cache - 'dns_cache'. See sync_dns_cache() > - * for more details. > - * The function 'pinctrl_handle_dns_lookup()' (which is > - * called with in the pinctrl_handler thread) looks into > - * the local DNS cache to resolve the DNS requests. > * > * - put_arp/put_nd - These actions stores the IPv4/IPv6 and MAC addresses > * in the 'MAC_Binding' table. > @@ -180,7 +174,6 @@ struct pinctrl { > struct latch pinctrl_thread_exit; > bool mac_binding_can_timestamp; > bool fdb_can_timestamp; > - bool dns_supports_ovn_owned; > bool igmp_group_has_chassis_name; > bool igmp_support_protocol; > }; > @@ -3277,93 +3270,6 @@ put_be32(struct ofpbuf *buf, ovs_be32 x) > ofpbuf_put(buf, &x, sizeof x); > } > > -struct dns_data { > - uint64_t *dps; > - size_t n_dps; > - struct smap records; > - struct smap options; > - bool delete; > -}; > - > -static struct shash dns_cache = SHASH_INITIALIZER(&dns_cache); > - > -/* Called by pinctrl_run(). Runs within the main ovn-controller > - * thread context. */ > -static void > -sync_dns_cache(const struct sbrec_dns_table *dns_table) > - OVS_REQUIRES(pinctrl_mutex) > -{ > - struct shash_node *iter; > - SHASH_FOR_EACH (iter, &dns_cache) { > - struct dns_data *d = iter->data; > - d->delete = true; > - } > - > - const struct sbrec_dns *sbrec_dns; > - SBREC_DNS_TABLE_FOR_EACH (sbrec_dns, dns_table) { > - const char *dns_id = smap_get(&sbrec_dns->external_ids, "dns_id"); > - if (!dns_id) { > - continue; > - } > - > - struct dns_data *dns_data = shash_find_data(&dns_cache, dns_id); > - if (!dns_data) { > - dns_data = xmalloc(sizeof *dns_data); > - smap_init(&dns_data->records); > - smap_init(&dns_data->options); > - shash_add(&dns_cache, dns_id, dns_data); > - dns_data->n_dps = 0; > - dns_data->dps = NULL; > - } else { > - free(dns_data->dps); > - } > - > - dns_data->delete = false; > - > - if (!smap_equal(&dns_data->records, &sbrec_dns->records)) { > - smap_destroy(&dns_data->records); > - smap_clone(&dns_data->records, &sbrec_dns->records); > - } > - > - if (pinctrl.dns_supports_ovn_owned > - && !smap_equal(&dns_data->options, &sbrec_dns->options)) { > - smap_destroy(&dns_data->options); > - smap_clone(&dns_data->options, &sbrec_dns->options); > - } > - > - dns_data->n_dps = sbrec_dns->n_datapaths; > - dns_data->dps = xcalloc(dns_data->n_dps, sizeof(uint64_t)); > - for (size_t i = 0; i < sbrec_dns->n_datapaths; i++) { > - dns_data->dps[i] = sbrec_dns->datapaths[i]->tunnel_key; > - } > - } > - > - SHASH_FOR_EACH_SAFE (iter, &dns_cache) { > - struct dns_data *d = iter->data; > - if (d->delete) { > - shash_delete(&dns_cache, iter); > - smap_destroy(&d->records); > - smap_destroy(&d->options); > - free(d->dps); > - free(d); > - } > - } > -} > - > -static void > -destroy_dns_cache(void) > -{ > - struct shash_node *iter; > - SHASH_FOR_EACH_SAFE (iter, &dns_cache) { > - struct dns_data *d = iter->data; > - shash_delete(&dns_cache, iter); > - smap_destroy(&d->records); > - smap_destroy(&d->options); > - free(d->dps); > - free(d); > - } > -} > - > /* Populates dns_answer struct with base data. > * Copy the answer section > * Format of the answer section is > @@ -3441,7 +3347,6 @@ pinctrl_handle_dns_lookup( > struct rconn *swconn, > struct dp_packet *pkt_in, struct ofputil_packet_in *pin, > struct ofpbuf *userdata, struct ofpbuf *continuation) > - OVS_REQUIRES(pinctrl_mutex) > { > static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); > enum ofp_version version = rconn_get_version(swconn); > @@ -3546,31 +3451,9 @@ pinctrl_handle_dns_lookup( > uint32_t query_l4_size = rest - l4_start; > > uint64_t dp_key = ntohll(pin->flow_metadata.flow.metadata); > - const char *answer_data = NULL; > bool ovn_owned = false; > - struct shash_node *iter; > - SHASH_FOR_EACH (iter, &dns_cache) { > - struct dns_data *d = iter->data; > - ovn_owned = smap_get_bool(&d->options, "ovn-owned", false); > - for (size_t i = 0; i < d->n_dps; i++) { > - if (d->dps[i] == dp_key) { > - /* DNS records in SBDB are stored in lowercase. Convert to > - * lowercase to perform case insensitive lookup > - */ > - char *query_name_lower = str_tolower(ds_cstr(&query_name)); > - answer_data = smap_get(&d->records, query_name_lower); > - free(query_name_lower); > - if (answer_data) { > - break; > - } > - } > - } > - > - if (answer_data) { > - break; > - } > - } > - > + const char *answer_data = ovn_dns_lookup(ds_cstr(&query_name), dp_key, > + &ovn_owned); > ds_destroy(&query_name); > if (!answer_data) { > goto exit; > @@ -3804,10 +3687,8 @@ process_packet_in(struct rconn *swconn, const struct > ofp_header *msg) > break; > > case ACTION_OPCODE_DNS_LOOKUP: > - ovs_mutex_lock(&pinctrl_mutex); > pinctrl_handle_dns_lookup(swconn, &packet, &pin, &userdata, > &continuation); > - ovs_mutex_unlock(&pinctrl_mutex); > break; > > case ACTION_OPCODE_LOG: > @@ -4105,15 +3986,6 @@ pinctrl_update(const struct ovsdb_idl *idl) > notify_pinctrl_handler(); > } > > - bool dns_supports_ovn_owned = > sbrec_server_has_dns_table_col_options(idl); > - if (dns_supports_ovn_owned != pinctrl.dns_supports_ovn_owned) { > - pinctrl.dns_supports_ovn_owned = dns_supports_ovn_owned; > - > - /* Notify pinctrl_handler that fdb timestamp column > - * availability has changed. */ > - notify_pinctrl_handler(); > - } > - > bool igmp_group_has_chassis_name = > sbrec_server_has_igmp_group_table_col_chassis_name(idl); > if (igmp_group_has_chassis_name != pinctrl.igmp_group_has_chassis_name) { > @@ -4146,7 +4018,6 @@ pinctrl_run(struct ovsdb_idl_txn *ovnsb_idl_txn, > struct ovsdb_idl_index *sbrec_igmp_groups, > struct ovsdb_idl_index *sbrec_ip_multicast_opts, > struct ovsdb_idl_index *sbrec_fdb_by_dp_key_mac, > - const struct sbrec_dns_table *dns_table, > const struct sbrec_controller_event_table *ce_table, > const struct sbrec_service_monitor_table *svc_mon_table, > const struct sbrec_mac_binding_table *mac_binding_table, > @@ -4173,7 +4044,6 @@ pinctrl_run(struct ovsdb_idl_txn *ovnsb_idl_txn, > prepare_ipv6_prefixd(ovnsb_idl_txn, sbrec_port_binding_by_name, > local_active_ports_ipv6_pd, chassis, > active_tunnels, local_datapaths); > - sync_dns_cache(dns_table); > controller_event_run(ovnsb_idl_txn, ce_table, chassis); > ip_mcast_sync(ovnsb_idl_txn, chassis, local_datapaths, > sbrec_datapath_binding_by_key, > @@ -4709,7 +4579,6 @@ pinctrl_destroy(void) > event_table_destroy(); > destroy_put_mac_bindings(); > destroy_put_vport_bindings(); > - destroy_dns_cache(); > ip_mcast_snoop_destroy(); > destroy_svc_monitors(); > bfd_monitor_destroy(); > diff --git a/controller/pinctrl.h b/controller/pinctrl.h > index 3462b670c9..846afe0a42 100644 > --- a/controller/pinctrl.h > +++ b/controller/pinctrl.h > @@ -49,7 +49,6 @@ void pinctrl_run(struct ovsdb_idl_txn *ovnsb_idl_txn, > struct ovsdb_idl_index *sbrec_igmp_groups, > struct ovsdb_idl_index *sbrec_ip_multicast_opts, > struct ovsdb_idl_index *sbrec_fdb_by_dp_key_mac, > - const struct sbrec_dns_table *, > const struct sbrec_controller_event_table *, > const struct sbrec_service_monitor_table *, > const struct sbrec_mac_binding_table *, > -- > 2.46.0 > > _______________________________________________ > dev mailing list > [email protected] > https://mail.openvswitch.org/mailman/listinfo/ovs-dev _______________________________________________ dev mailing list [email protected] https://mail.openvswitch.org/mailman/listinfo/ovs-dev
