From: Erik Hugne <erik.hugne(a)ericsson.com&gt; All ethtool specific code is moved to teamd_lw_ethtool.c, and the generic link watcher types and functions are moved to a common header file, teamd_link_watch.h Signed-off-by: Erik Hugne <erik.hugne(a)ericsson.com&gt; --- teamd/Makefile.am | 3 +- teamd/teamd_link_watch.c | 231 ++--------------------------------------------- teamd/teamd_link_watch.h | 33 +++++++ teamd/teamd_lw_ethtool.c | 223 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 264 insertions(+), 226 deletions(-) create mode 100644 teamd/teamd_link_watch.h create mode 100644 teamd/teamd_lw_ethtool.c diff --git a/teamd/Makefile.am b/teamd/Makefile.am index dc7ca07..2a0f5ea 100644 --- a/teamd/Makefile.am +++ b/teamd/Makefile.am @@ -13,7 +13,8 @@ teamd_LDADD = $(top_builddir)/libteam/libteam.la $(LIBDAEMON_LIBS) $(JANSSON_LIB bin_PROGRAMS=teamd teamd_SOURCES=teamd.c teamd_common.c teamd_json.c teamd_config.c teamd_state.c \ teamd_workq.c teamd_events.c teamd_per_port.c \ - teamd_option_watch.c teamd_ifinfo_watch.c teamd_link_watch.c \ + teamd_option_watch.c teamd_ifinfo_watch.c teamd_lw_ethtool.c \ + teamd_link_watch.c \ teamd_ctl.c teamd_dbus.c teamd_zmq.c teamd_usock.c \ teamd_phys_port_check.c teamd_bpf_chef.c teamd_hash_func.c \ teamd_balancer.c teamd_runner_basic_ones.c \ diff --git a/teamd/teamd_link_watch.c b/teamd/teamd_link_watch.c index d35ff86..c11b256 100644 --- a/teamd/teamd_link_watch.c +++ b/teamd/teamd_link_watch.c @@ -39,23 +39,9 @@ #include "teamd.h" #include "teamd_config.h" -#include "teamd_state.h" +#include "teamd_link_watch.h" -struct lw_common_port_priv { - unsigned int id; - const struct teamd_link_watch *link_watch; - struct teamd_context *ctx; - struct teamd_port *tdport; - bool link_up; - bool forced_send; - struct teamd_config_path_cookie *cpcookie; -}; - -struct teamd_link_watch { - const char *name; - const struct teamd_state_val state_vg; - struct teamd_port_priv port_priv; -}; +extern const struct teamd_link_watch teamd_link_watch_ethtool; static int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, const char *hostname) @@ -136,16 +122,10 @@ static char *str_sockaddr_in6(struct sockaddr_in6 *sin6) sizeof(*sin6), AF_INET6); } -static bool teamd_link_watch_link_up_differs(struct lw_common_port_priv *common_ppriv, - bool new_link_up) -{ - return new_link_up != common_ppriv->link_up; -} - -static int teamd_link_watch_check_link_up(struct teamd_context *ctx, - struct teamd_port *tdport, - struct lw_common_port_priv *common_ppriv, - bool new_link_up) +int teamd_link_watch_check_link_up(struct teamd_context *ctx, + struct teamd_port *tdport, + struct lw_common_port_priv *common_ppriv, + bool new_link_up) { const char *lw_name = common_ppriv->link_watch->name; @@ -159,205 +139,6 @@ static int teamd_link_watch_check_link_up(struct teamd_context *ctx, /* - * Ethtool link watch - */ - -struct lw_ethtool_port_priv { - struct lw_common_port_priv common; /* must be first */ - struct timespec delay_up; - struct timespec delay_down; -}; - -static struct lw_ethtool_port_priv * -lw_ethtool_ppriv_get(struct lw_common_port_priv *common_ppriv) -{ - return (struct lw_ethtool_port_priv *) common_ppriv; -} - -#define LW_ETHTOOL_DELAY_CB_NAME "lw_ethtool_delay" - -static int lw_ethtool_event_watch_port_changed(struct teamd_context *ctx, - struct teamd_port *tdport, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_ethtool_port_priv *ethtool_ppriv = priv; - bool link_up; - struct timespec *delay; - int err; - - if (common_ppriv->tdport != tdport || - !team_is_port_changed(tdport->team_port)) - return 0; - - /* - * Link changed for sure, so if there is some delay in progress, - * cancel it before proceeding. - */ - teamd_loop_callback_disable(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); - link_up = team_is_port_link_up(tdport->team_port); - if (!teamd_link_watch_link_up_differs(common_ppriv, link_up)) - return 0; - - if (link_up) { - if (timespec_is_zero(&ethtool_ppriv->delay_up)) - goto nodelay; - delay = &ethtool_ppriv->delay_up; - } else { - if (timespec_is_zero(&ethtool_ppriv->delay_down)) - goto nodelay; - delay = &ethtool_ppriv->delay_down; - } - - err = teamd_loop_callback_timer_set(ctx, LW_ETHTOOL_DELAY_CB_NAME, - priv, NULL, delay); - if (err) { - teamd_log_err("Failed to set delay timer."); - return err; - } - teamd_loop_callback_enable(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); - return 0; - -nodelay: - return teamd_link_watch_check_link_up(ctx, tdport, common_ppriv, - link_up); -} - -static int lw_ethtool_callback_delay(struct teamd_context *ctx, int events, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct teamd_port *tdport; - bool link_up; - - tdport = common_ppriv->tdport; - link_up = team_is_port_link_up(tdport->team_port); - return teamd_link_watch_check_link_up(ctx, tdport, common_ppriv, - link_up); -} - -static int lw_ethtool_load_options(struct teamd_context *ctx, - struct teamd_port *tdport, - struct lw_ethtool_port_priv *ethtool_ppriv) -{ - struct teamd_config_path_cookie *cpcookie = ethtool_ppriv->common.cpcookie; - int err; - int tmp; - - err = teamd_config_int_get(ctx, &tmp, "@.queue_id", cpcookie); - if (!err) { - if (tmp < 0) { - teamd_log_err("\"delay_up\" must not be negative number."); - return -EINVAL; - } - teamd_log_dbg("delay_up \"%d\".", tmp); - ms_to_timespec(&ethtool_ppriv->delay_up, tmp); - } - err = teamd_config_int_get(ctx, &tmp, "@.delay_down", cpcookie); - if (!err) { - if (tmp < 0) { - teamd_log_err("\"delay_down\" must not be negative number."); - return -EINVAL; - } - teamd_log_dbg("delay_down \"%d\".", tmp); - ms_to_timespec(&ethtool_ppriv->delay_down, tmp); - } - return 0; -} - -static const struct teamd_event_watch_ops lw_ethtool_port_watch_ops = { - .port_changed = lw_ethtool_event_watch_port_changed, -}; - -static int lw_ethtool_port_added(struct teamd_context *ctx, - struct teamd_port *tdport, - void *priv, void *creator_priv) -{ - int err; - - err = lw_ethtool_load_options(ctx, tdport, priv); - if (err) { - teamd_log_err("Failed to load options."); - return err; - } - err = teamd_loop_callback_timer_add(ctx, LW_ETHTOOL_DELAY_CB_NAME, - priv, lw_ethtool_callback_delay); - if (err) { - teamd_log_err("Failed add delay callback timer"); - return err; - } - err = teamd_event_watch_register(ctx, &lw_ethtool_port_watch_ops, priv); - if (err) { - teamd_log_err("Failed to register event watch."); - goto delay_callback_del; - } - return 0; - -delay_callback_del: - teamd_loop_callback_del(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); - return err; -} - -static void lw_ethtool_port_removed(struct teamd_context *ctx, - struct teamd_port *tdport, - void *priv, void *creator_priv) -{ - teamd_event_watch_unregister(ctx, &lw_ethtool_port_watch_ops, priv); - teamd_loop_callback_del(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); -} - -static int lw_ethtool_state_delay_up_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct timespec *ts; - - ts = &lw_ethtool_ppriv_get(common_ppriv)->delay_up; - gsc->data.int_val = timespec_to_ms(ts); - return 0; -} - -static int lw_ethtool_state_delay_down_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct timespec *ts; - - ts = &lw_ethtool_ppriv_get(common_ppriv)->delay_down; - gsc->data.int_val = timespec_to_ms(ts); - return 0; -} - -static const struct teamd_state_val lw_ethtool_state_vals[] = { - { - .subpath = "delay_up", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_ethtool_state_delay_up_get, - }, - { - .subpath = "delay_down", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_ethtool_state_delay_down_get, - }, -}; - -static const struct teamd_link_watch teamd_link_watch_ethtool = { - .name = "ethtool", - .state_vg = { - .vals = lw_ethtool_state_vals, - .vals_count = ARRAY_SIZE(lw_ethtool_state_vals), - }, - .port_priv = { - .init = lw_ethtool_port_added, - .fini = lw_ethtool_port_removed, - .priv_size = sizeof(struct lw_ethtool_port_priv), - }, -}; - - -/* * Generic periodic send/receive link watch "template" */ diff --git a/teamd/teamd_link_watch.h b/teamd/teamd_link_watch.h new file mode 100644 index 0000000..27e2025 --- /dev/null +++ b/teamd/teamd_link_watch.h @@ -0,0 +1,33 @@ +#ifndef _TEAMD_LINK_WATCH_H_ +#define _TEAMD_LINK_WATCH_H_ + +#include "teamd_state.h" + +struct teamd_link_watch { + const char *name; + const struct teamd_state_val state_vg; + struct teamd_port_priv port_priv; +}; + +struct lw_common_port_priv { + unsigned int id; + const struct teamd_link_watch *link_watch; + struct teamd_context *ctx; + struct teamd_port *tdport; + bool link_up; + bool forced_send; + struct teamd_config_path_cookie *cpcookie; +}; + +static inline bool teamd_link_watch_link_up_differs(struct lw_common_port_priv *common_ppriv, + bool new_link_up) +{ + return new_link_up != common_ppriv->link_up; +} + +int teamd_link_watch_check_link_up(struct teamd_context *ctx, + struct teamd_port *tdport, + struct lw_common_port_priv *common_ppriv, + bool new_link_up); + +#endif diff --git a/teamd/teamd_lw_ethtool.c b/teamd/teamd_lw_ethtool.c new file mode 100644 index 0000000..b323eb7 --- /dev/null +++ b/teamd/teamd_lw_ethtool.c @@ -0,0 +1,223 @@ +/* + * teamd_lw_ethtool.c - Team port ethtool link watcher + * Copyright (C) 2012-2013 Jiri Pirko <jiri(a)resnulli.us&gt; + * Copyright (C) 2014 Erik Hugne <erik.hugne(a)ericsson.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <private/misc.h> +#include "teamd.h" +#include "teamd_link_watch.h" +#include "teamd_config.h" + +/* + * Ethtool link watch + */ + +struct lw_ethtool_port_priv { + struct lw_common_port_priv common; /* must be first */ + struct timespec delay_up; + struct timespec delay_down; +}; + +static struct lw_ethtool_port_priv * +lw_ethtool_ppriv_get(struct lw_common_port_priv *common_ppriv) +{ + return (struct lw_ethtool_port_priv *) common_ppriv; +} + +#define LW_ETHTOOL_DELAY_CB_NAME "lw_ethtool_delay" + +static int lw_ethtool_event_watch_port_changed(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_ethtool_port_priv *ethtool_ppriv = priv; + bool link_up; + struct timespec *delay; + int err; + + if (common_ppriv->tdport != tdport || + !team_is_port_changed(tdport->team_port)) + return 0; + + /* + * Link changed for sure, so if there is some delay in progress, + * cancel it before proceeding. + */ + teamd_loop_callback_disable(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); + link_up = team_is_port_link_up(tdport->team_port); + if (!teamd_link_watch_link_up_differs(common_ppriv, link_up)) + return 0; + + if (link_up) { + if (timespec_is_zero(&ethtool_ppriv->delay_up)) + goto nodelay; + delay = &ethtool_ppriv->delay_up; + } else { + if (timespec_is_zero(&ethtool_ppriv->delay_down)) + goto nodelay; + delay = &ethtool_ppriv->delay_down; + } + + err = teamd_loop_callback_timer_set(ctx, LW_ETHTOOL_DELAY_CB_NAME, + priv, NULL, delay); + if (err) { + teamd_log_err("Failed to set delay timer."); + return err; + } + teamd_loop_callback_enable(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); + return 0; + +nodelay: + return teamd_link_watch_check_link_up(ctx, tdport, common_ppriv, + link_up); +} + +static int lw_ethtool_callback_delay(struct teamd_context *ctx, int events, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct teamd_port *tdport; + bool link_up; + + tdport = common_ppriv->tdport; + link_up = team_is_port_link_up(tdport->team_port); + return teamd_link_watch_check_link_up(ctx, tdport, common_ppriv, + link_up); +} + +static int lw_ethtool_load_options(struct teamd_context *ctx, + struct teamd_port *tdport, + struct lw_ethtool_port_priv *ethtool_ppriv) +{ + struct teamd_config_path_cookie *cpcookie = ethtool_ppriv->common.cpcookie; + int err; + int tmp; + + err = teamd_config_int_get(ctx, &tmp, "@.queue_id", cpcookie); + if (!err) { + if (tmp < 0) { + teamd_log_err("\"delay_up\" must not be negative number."); + return -EINVAL; + } + teamd_log_dbg("delay_up \"%d\".", tmp); + ms_to_timespec(&ethtool_ppriv->delay_up, tmp); + } + err = teamd_config_int_get(ctx, &tmp, "@.delay_down", cpcookie); + if (!err) { + if (tmp < 0) { + teamd_log_err("\"delay_down\" must not be negative number."); + return -EINVAL; + } + teamd_log_dbg("delay_down \"%d\".", tmp); + ms_to_timespec(&ethtool_ppriv->delay_down, tmp); + } + return 0; +} + +static const struct teamd_event_watch_ops lw_ethtool_port_watch_ops = { + .port_changed = lw_ethtool_event_watch_port_changed, +}; + +static int lw_ethtool_port_added(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv, void *creator_priv) +{ + int err; + + err = lw_ethtool_load_options(ctx, tdport, priv); + if (err) { + teamd_log_err("Failed to load options."); + return err; + } + err = teamd_loop_callback_timer_add(ctx, LW_ETHTOOL_DELAY_CB_NAME, + priv, lw_ethtool_callback_delay); + if (err) { + teamd_log_err("Failed add delay callback timer"); + return err; + } + err = teamd_event_watch_register(ctx, &lw_ethtool_port_watch_ops, priv); + if (err) { + teamd_log_err("Failed to register event watch."); + goto delay_callback_del; + } + return 0; + +delay_callback_del: + teamd_loop_callback_del(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); + return err; +} + +static void lw_ethtool_port_removed(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv, void *creator_priv) +{ + teamd_event_watch_unregister(ctx, &lw_ethtool_port_watch_ops, priv); + teamd_loop_callback_del(ctx, LW_ETHTOOL_DELAY_CB_NAME, priv); +} + +static int lw_ethtool_state_delay_up_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct timespec *ts; + + ts = &lw_ethtool_ppriv_get(common_ppriv)->delay_up; + gsc->data.int_val = timespec_to_ms(ts); + return 0; +} + +static int lw_ethtool_state_delay_down_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct timespec *ts; + + ts = &lw_ethtool_ppriv_get(common_ppriv)->delay_down; + gsc->data.int_val = timespec_to_ms(ts); + return 0; +} + +static const struct teamd_state_val lw_ethtool_state_vals[] = { + { + .subpath = "delay_up", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_ethtool_state_delay_up_get, + }, + { + .subpath = "delay_down", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_ethtool_state_delay_down_get, + }, +}; + +const struct teamd_link_watch teamd_link_watch_ethtool = { + .name = "ethtool", + .state_vg = { + .vals = lw_ethtool_state_vals, + .vals_count = ARRAY_SIZE(lw_ethtool_state_vals), + }, + .port_priv = { + .init = lw_ethtool_port_added, + .fini = lw_ethtool_port_removed, + .priv_size = sizeof(struct lw_ethtool_port_priv), + }, +}; + -- 1.8.3.2

From: Erik Hugne <erik.hugne(a)ericsson.com&gt; All ARP link watcher specific code is moved to teamd_lw_arp.c. Signed-off-by: Erik Hugne <erik.hugne(a)ericsson.com&gt; --- teamd/Makefile.am | 2 +- teamd/teamd_link_watch.c | 471 +-------------------------------------------- teamd/teamd_link_watch.h | 5 +- teamd/teamd_lw_arp.c | 485 +++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 497 insertions(+), 466 deletions(-) create mode 100644 teamd/teamd_lw_arp.c diff --git a/teamd/Makefile.am b/teamd/Makefile.am index c388f87..fbc8a6a 100644 --- a/teamd/Makefile.am +++ b/teamd/Makefile.am @@ -14,7 +14,7 @@ bin_PROGRAMS=teamd teamd_SOURCES=teamd.c teamd_common.c teamd_json.c teamd_config.c teamd_state.c \ teamd_workq.c teamd_events.c teamd_per_port.c \ teamd_option_watch.c teamd_ifinfo_watch.c teamd_lw_ethtool.c \ - teamd_lw_psr.c teamd_link_watch.c \ + teamd_lw_psr.c teamd_lw_arp.c teamd_link_watch.c \ teamd_ctl.c teamd_dbus.c teamd_zmq.c teamd_usock.c \ teamd_phys_port_check.c teamd_bpf_chef.c teamd_hash_func.c \ teamd_balancer.c teamd_runner_basic_ones.c \ diff --git a/teamd/teamd_link_watch.c b/teamd/teamd_link_watch.c index dd16ebf..e6bd863 100644 --- a/teamd/teamd_link_watch.c +++ b/teamd/teamd_link_watch.c @@ -24,15 +24,11 @@ #include <errno.h> #include <sys/socket.h> #include <sys/types.h> -#include <arpa/inet.h> #include <linux/if_packet.h> #include <linux/if_ether.h> -#include <linux/if_vlan.h> #include <netdb.h> #include <netinet/ip6.h> #include <netinet/icmp6.h> -#include <net/if_arp.h> -#include <linux/filter.h> #include <time.h> #include <private/misc.h> #include <team.h> @@ -42,9 +38,10 @@ #include "teamd_link_watch.h" extern const struct teamd_link_watch teamd_link_watch_ethtool; +extern const struct teamd_link_watch teamd_link_watch_arp_ping; -static int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, - sa_family_t family, const char *hostname) +int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, + const char *hostname) { struct addrinfo *result; struct addrinfo hints; @@ -67,18 +64,6 @@ static int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, return 0; } -static int set_in_addr(struct in_addr *addr, const char *hostname) -{ - struct sockaddr_in sin; - int err; - - err = __set_sockaddr((struct sockaddr *) &sin, sizeof(sin), - AF_INET, hostname); - if (err) - return err; - memcpy(addr, &sin.sin_addr, sizeof(*addr)); - return 0; -} static int set_sockaddr_in6(struct sockaddr_in6 *sin6, const char *hostname) { @@ -91,10 +76,9 @@ static int set_sockaddr_in6(struct sockaddr_in6 *sin6, const char *hostname) return 0; } -static char *__str_sockaddr(struct sockaddr *sa, socklen_t sa_len, - sa_family_t family) +char *__str_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, + char buf[]) { - static char buf[NI_MAXHOST]; int err; sa->sa_family = family; @@ -107,19 +91,11 @@ static char *__str_sockaddr(struct sockaddr *sa, socklen_t sa_len, return buf; } -static char *str_in_addr(struct in_addr *addr) -{ - struct sockaddr_in sin; - - memcpy(&sin.sin_addr, addr, sizeof(*addr)); - return __str_sockaddr((struct sockaddr *) &sin, - sizeof(sin), AF_INET); -} - static char *str_sockaddr_in6(struct sockaddr_in6 *sin6) { + static char buf[NI_MAXHOST]; return __str_sockaddr((struct sockaddr *) sin6, - sizeof(*sin6), AF_INET6); + sizeof(*sin6), AF_INET6, buf); } int teamd_link_watch_check_link_up(struct teamd_context *ctx, @@ -141,439 +117,6 @@ int teamd_link_watch_check_link_up(struct teamd_context *ctx, /* - * ARP ping link watch - */ - -struct lw_ap_port_priv { - union { - struct lw_common_port_priv common; - struct lw_psr_port_priv psr; - } start; /* must be first */ - struct in_addr src; - struct in_addr dst; - bool validate_active; - bool validate_inactive; - bool send_always; - bool vlanid_in_use; - unsigned short vlanid; -}; - -static struct lw_ap_port_priv * -lw_ap_ppriv_get(struct lw_psr_port_priv *psr_ppriv) -{ - return (struct lw_ap_port_priv *) psr_ppriv; -} - -#define OFFSET_ARP_OP_CODE \ - in_struct_offset(struct arphdr, ar_op) - -static struct sock_filter arp_rpl_flt[] = { - BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), - BPF_STMT(BPF_RET + BPF_K, (u_int) -1), - BPF_STMT(BPF_RET + BPF_K, 0), -}; - -static const struct sock_fprog arp_rpl_fprog = { - .len = ARRAY_SIZE(arp_rpl_flt), - .filter = arp_rpl_flt, -}; - -static struct sock_filter arp_novlan_rpl_flt[] = { - BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 0, 4), - BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), - BPF_STMT(BPF_RET + BPF_K, (u_int) -1), - BPF_STMT(BPF_RET + BPF_K, 0), -}; - -static const struct sock_fprog arp_novlan_rpl_fprog = { - .len = ARRAY_SIZE(arp_novlan_rpl_flt), - .filter = arp_novlan_rpl_flt, -}; - -static struct sock_filter arp_vlan_rpl_flt[] = { - BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 6, 0), - BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0xffff, 0, 4), /* 0xffff will be replaced by vland id */ - BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), - BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), - BPF_STMT(BPF_RET + BPF_K, (u_int) -1), - BPF_STMT(BPF_RET + BPF_K, 0), -}; - -/* this hack replaces vlanid value in filter code */ -#define SET_FILTER_VLANID(fprog, vlanid) (fprog)->filter[3].k = vlanid - -static const struct sock_fprog arp_vlan_rpl_fprog = { - .len = ARRAY_SIZE(arp_vlan_rpl_flt), - .filter = arp_vlan_rpl_flt, -}; - -static int lw_ap_sock_open(struct lw_psr_port_priv *psr_ppriv) -{ - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - struct sock_fprog fprog; - struct sock_filter arp_vlan_rpl_flt[ARRAY_SIZE(arp_vlan_rpl_flt)]; - - if (ap_ppriv->vlanid_in_use) { - memcpy(&arp_vlan_rpl_flt, arp_vlan_rpl_fprog.filter, - sizeof(arp_vlan_rpl_flt)); - fprog = arp_vlan_rpl_fprog; - fprog.filter = arp_vlan_rpl_flt; - SET_FILTER_VLANID(&fprog, ap_ppriv->vlanid); - } else { - fprog = arp_novlan_rpl_fprog; - } - return teamd_packet_sock_open(&psr_ppriv->sock, - psr_ppriv->common.tdport->ifindex, - htons(ETH_P_ARP), &fprog, &arp_rpl_fprog); -} - -static void lw_ap_sock_close(struct lw_psr_port_priv *psr_ppriv) -{ - close(psr_ppriv->sock); -} - -static int lw_ap_load_options(struct teamd_context *ctx, - struct teamd_port *tdport, - struct lw_psr_port_priv *psr_ppriv) -{ - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - struct teamd_config_path_cookie *cpcookie = psr_ppriv->common.cpcookie; - const char *host; - int tmp; - int err; - - err = teamd_config_string_get(ctx, &host, "@.source_host", cpcookie); - if (!err) { - err = set_in_addr(&ap_ppriv->src, host); - if (err) - return err; - } - /* - * If source_host is not provided, just use address 0.0.0.0 according - * to RFC 5227 (IPv4 Address Conflict Detection). - */ - teamd_log_dbg("source address \"%s\".", - str_in_addr(&ap_ppriv->src)); - - err = teamd_config_string_get(ctx, &host, "@.target_host", cpcookie); - if (err) { - teamd_log_err("Failed to get \"target_host\" link-watch option."); - return -EINVAL; - } - err = set_in_addr(&ap_ppriv->dst, host); - if (err) - return err; - teamd_log_dbg("target address \"%s\".", str_in_addr(&ap_ppriv->dst)); - - err = teamd_config_bool_get(ctx, &ap_ppriv->validate_active, - "@.validate_active", cpcookie); - if (err) - ap_ppriv->validate_active = false; - teamd_log_dbg("validate_active \"%d\".", ap_ppriv->validate_active); - - err = teamd_config_bool_get(ctx, &ap_ppriv->validate_inactive, - "@.validate_inactive", cpcookie); - if (err) - ap_ppriv->validate_inactive = false; - teamd_log_dbg("validate_inactive \"%d\".", ap_ppriv->validate_inactive); - - err = teamd_config_bool_get(ctx, &ap_ppriv->send_always, - "@.send_always", cpcookie); - if (err) - ap_ppriv->send_always = false; - teamd_log_dbg("send_always \"%d\".", ap_ppriv->send_always); - - err = teamd_config_int_get(ctx, &tmp, "@.vlanid", cpcookie); - if (!err) { - if (tmp < 0 || tmp >= 4096) { - teamd_log_err("Wrong \"vlanid\" option value."); - return -EINVAL; - } - ap_ppriv->vlanid_in_use = true; - ap_ppriv->vlanid = tmp; - teamd_log_dbg("vlan id \"%u\".", ap_ppriv->vlanid); - } - - return 0; -} - -static int __get_port_curr_hwaddr(struct lw_psr_port_priv *psr_ppriv, - struct sockaddr_ll *addr, size_t expected_len) -{ - struct team_ifinfo *ifinfo = psr_ppriv->common.tdport->team_ifinfo; - size_t port_hwaddr_len = team_get_ifinfo_hwaddr_len(ifinfo); - char *port_hwaddr = team_get_ifinfo_hwaddr(ifinfo); - int err; - - err = teamd_getsockname_hwaddr(psr_ppriv->sock, addr, expected_len); - if (err) - return err; - if ((addr->sll_halen != port_hwaddr_len) || - (expected_len && expected_len != port_hwaddr_len)) { - teamd_log_err("Unexpected length of hw address."); - return -ENOTSUP; - } - memcpy(addr->sll_addr, port_hwaddr, addr->sll_halen); - return 0; -} - -struct arp_packet { - struct arphdr ah; - unsigned char sender_mac[ETH_ALEN]; - struct in_addr sender_ip; - unsigned char target_mac[ETH_ALEN]; - struct in_addr target_ip; -} __attribute__((packed)); - -struct __vlan_hdr { - __be16 h_vlan_TCI; - __be16 h_vlan_encapsulated_proto; -}; - -struct arp_vlan_packet { - struct __vlan_hdr vlanh; - struct arp_packet ap; -} __attribute__((packed)); - -static int lw_ap_send(struct lw_psr_port_priv *psr_ppriv) -{ - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - int err; - struct sockaddr_ll ll_my; - struct sockaddr_ll ll_bcast; - struct arp_packet ap; - - if (!(psr_ppriv->common.forced_send || ap_ppriv->send_always)) - return 0; - - err = __get_port_curr_hwaddr(psr_ppriv, &ll_my, 0); - if (err) - return err; - ll_bcast = ll_my; - memset(ll_bcast.sll_addr, 0xFF, ll_bcast.sll_halen); - - memset(&ap, 0, sizeof(ap)); - ap.ah.ar_hrd = htons(ll_my.sll_hatype); - ap.ah.ar_pro = htons(ETH_P_IP); - ap.ah.ar_hln = ll_my.sll_halen; - ap.ah.ar_pln = 4; - ap.ah.ar_op = htons(ARPOP_REQUEST); - - memcpy(ap.sender_mac, ll_my.sll_addr, sizeof(ap.sender_mac)); - ap.sender_ip = ap_ppriv->src; - memcpy(ap.target_mac, ll_bcast.sll_addr, sizeof(ap.target_mac)); - ap.target_ip = ap_ppriv->dst; - - if (ap_ppriv->vlanid_in_use) { - struct arp_vlan_packet avp; - avp.ap = ap; - avp.vlanh.h_vlan_encapsulated_proto = htons(ETH_P_ARP); - avp.vlanh.h_vlan_TCI = htons(ap_ppriv->vlanid); - ll_bcast.sll_protocol = htons(ETH_P_8021Q); - return teamd_sendto(psr_ppriv->sock, &avp, sizeof(avp), - 0, (struct sockaddr *) &ll_bcast, - sizeof(ll_bcast)); - } else { - return teamd_sendto(psr_ppriv->sock, &ap, sizeof(ap), - 0, (struct sockaddr *) &ll_bcast, - sizeof(ll_bcast)); - } -} - -static int lw_ap_receive(struct lw_psr_port_priv *psr_ppriv) -{ - struct lw_common_port_priv *common_ppriv = &psr_ppriv->common; - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - int err; - struct sockaddr_ll ll_my; - struct sockaddr_ll ll_from; - struct arp_packet ap; - bool port_enabled; - - err = teamd_recvfrom(psr_ppriv->sock, &ap, sizeof(ap), 0, - (struct sockaddr *) &ll_from, sizeof(ll_from)); - if (err <= 0) - return err; - - err = teamd_port_enabled(common_ppriv->ctx, common_ppriv->tdport, - &port_enabled); - if (err) - return err; - - if ((port_enabled && ap_ppriv->validate_active) || - (!port_enabled && ap_ppriv->validate_inactive)) { - err = __get_port_curr_hwaddr(psr_ppriv, &ll_my, 0); - if (err) - return err; - - if (ap.ah.ar_hrd != htons(ll_my.sll_hatype) || - ap.ah.ar_pro != htons(ETH_P_IP) || - ap.ah.ar_hln != ll_my.sll_halen || - ap.ah.ar_pln != 4) { - return 0; - } - - if ((ap_ppriv->src.s_addr != ap.target_ip.s_addr || - ap_ppriv->dst.s_addr != ap.sender_ip.s_addr) && - (ap_ppriv->dst.s_addr != ap.target_ip.s_addr || - ap_ppriv->src.s_addr != ap.sender_ip.s_addr)) - return 0; - } - - psr_ppriv->reply_received = true; - return 0; -} - -static const struct lw_psr_ops lw_psr_ops_ap = { - .sock_open = lw_ap_sock_open, - .sock_close = lw_ap_sock_close, - .load_options = lw_ap_load_options, - .send = lw_ap_send, - .receive = lw_ap_receive, -}; - -static int lw_ap_port_added(struct teamd_context *ctx, - struct teamd_port *tdport, - void *priv, void *creator_priv) -{ - struct lw_ap_port_priv *ap_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = &ap_ppriv->start.psr; - - psr_ppriv->ops = &lw_psr_ops_ap; - return lw_psr_port_added(ctx, tdport, priv, creator_priv); -} - -static int lw_ap_state_source_host_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - - gsc->data.str_val.ptr = str_in_addr(&ap_ppriv->src); - return 0; -} - -static int lw_ap_state_target_host_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - - gsc->data.str_val.ptr = str_in_addr(&ap_ppriv->dst); - return 0; -} - -static int lw_ap_state_validate_active_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - - gsc->data.int_val = ap_ppriv->validate_active; - return 0; -} - -static int lw_ap_state_validate_inactive_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - - gsc->data.int_val = ap_ppriv->validate_inactive; - return 0; -} - -static int lw_ap_state_send_always_get(struct teamd_context *ctx, - struct team_state_gsc *gsc, - void *priv) -{ - struct lw_common_port_priv *common_ppriv = priv; - struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); - struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); - - gsc->data.int_val = ap_ppriv->send_always; - return 0; -} - -static const struct teamd_state_val lw_ap_state_vals[] = { - { - .subpath = "source_host", - .type = TEAMD_STATE_ITEM_TYPE_STRING, - .getter = lw_ap_state_source_host_get, - }, - { - .subpath = "target_host", - .type = TEAMD_STATE_ITEM_TYPE_STRING, - .getter = lw_ap_state_target_host_get, - }, - { - .subpath = "interval", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_psr_state_interval_get, - }, - { - .subpath = "init_wait", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_psr_state_init_wait_get, - }, - { - .subpath = "validate_active", - .type = TEAMD_STATE_ITEM_TYPE_BOOL, - .getter = lw_ap_state_validate_active_get, - }, - { - .subpath = "validate_inactive", - .type = TEAMD_STATE_ITEM_TYPE_BOOL, - .getter = lw_ap_state_validate_inactive_get, - }, - { - .subpath = "send_always", - .type = TEAMD_STATE_ITEM_TYPE_BOOL, - .getter = lw_ap_state_send_always_get, - }, - { - .subpath = "missed_max", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_psr_state_missed_max_get, - }, - { - .subpath = "missed", - .type = TEAMD_STATE_ITEM_TYPE_INT, - .getter = lw_psr_state_missed_get, - }, -}; - -static const struct teamd_link_watch teamd_link_watch_arp_ping = { - .name = "arp_ping", - .state_vg = { - .vals = lw_ap_state_vals, - .vals_count = ARRAY_SIZE(lw_ap_state_vals), - }, - .port_priv = { - .init = lw_ap_port_added, - .fini = lw_psr_port_removed, - .priv_size = sizeof(struct lw_ap_port_priv), - }, -}; - - -/* * IPV6 NS/NA ping link watch */ diff --git a/teamd/teamd_link_watch.h b/teamd/teamd_link_watch.h index ef8634e..2461649 100644 --- a/teamd/teamd_link_watch.h +++ b/teamd/teamd_link_watch.h @@ -42,6 +42,10 @@ struct lw_psr_port_priv { bool reply_received; }; +int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, + const char *hostname); +char *__str_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, + char buf[]); static inline bool teamd_link_watch_link_up_differs(struct lw_common_port_priv *common_ppriv, bool new_link_up) @@ -53,7 +57,6 @@ int teamd_link_watch_check_link_up(struct teamd_context *ctx, struct teamd_port *tdport, struct lw_common_port_priv *common_ppriv, bool new_link_up); - struct lw_psr_port_priv * lw_psr_ppriv_get(struct lw_common_port_priv *common_ppriv); int lw_psr_port_added(struct teamd_context *ctx, struct teamd_port *tdport, diff --git a/teamd/teamd_lw_arp.c b/teamd/teamd_lw_arp.c new file mode 100644 index 0000000..4d07436 --- /dev/null +++ b/teamd/teamd_lw_arp.c @@ -0,0 +1,485 @@ +/* + * teamd_lw_arp.c - Team port arp link watcher + * Copyright (C) 2012-2013 Jiri Pirko <jiri(a)resnulli.us&gt; + * Copyright (C) 2014 Erik Hugne <erik.hugne(a)ericsson.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <arpa/inet.h> +#include <net/if_arp.h> +#include <linux/if_ether.h> +#include <netdb.h> +#include <private/misc.h> +#include "teamd.h" +#include "teamd_link_watch.h" +#include "teamd_config.h" + +/* + * ARP ping link watch + */ + +struct lw_ap_port_priv { + union { + struct lw_common_port_priv common; + struct lw_psr_port_priv psr; + } start; /* must be first */ + struct in_addr src; + struct in_addr dst; + bool validate_active; + bool validate_inactive; + bool send_always; + bool vlanid_in_use; + unsigned short vlanid; +}; + +static struct lw_ap_port_priv * +lw_ap_ppriv_get(struct lw_psr_port_priv *psr_ppriv) +{ + return (struct lw_ap_port_priv *) psr_ppriv; +} + +#define OFFSET_ARP_OP_CODE \ + in_struct_offset(struct arphdr, ar_op) + +static struct sock_filter arp_rpl_flt[] = { + BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), + BPF_STMT(BPF_RET + BPF_K, (u_int) -1), + BPF_STMT(BPF_RET + BPF_K, 0), +}; + +static const struct sock_fprog arp_rpl_fprog = { + .len = ARRAY_SIZE(arp_rpl_flt), + .filter = arp_rpl_flt, +}; + +static struct sock_filter arp_novlan_rpl_flt[] = { + BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 0, 4), + BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), + BPF_STMT(BPF_RET + BPF_K, (u_int) -1), + BPF_STMT(BPF_RET + BPF_K, 0), +}; + +static const struct sock_fprog arp_novlan_rpl_fprog = { + .len = ARRAY_SIZE(arp_novlan_rpl_flt), + .filter = arp_novlan_rpl_flt, +}; + +static struct sock_filter arp_vlan_rpl_flt[] = { + BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG_PRESENT), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0, 6, 0), + BPF_STMT(BPF_LD + BPF_B + BPF_ABS, SKF_AD_OFF + SKF_AD_VLAN_TAG), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0xffff, 0, 4), /* 0xffff will be replaced by vland id */ + BPF_STMT(BPF_LD + BPF_H + BPF_ABS, OFFSET_ARP_OP_CODE), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REPLY, 1, 0), + BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ARPOP_REQUEST, 0, 1), + BPF_STMT(BPF_RET + BPF_K, (u_int) -1), + BPF_STMT(BPF_RET + BPF_K, 0), +}; + +/* this hack replaces vlanid value in filter code */ +#define SET_FILTER_VLANID(fprog, vlanid) (fprog)->filter[3].k = vlanid + +static const struct sock_fprog arp_vlan_rpl_fprog = { + .len = ARRAY_SIZE(arp_vlan_rpl_flt), + .filter = arp_vlan_rpl_flt, +}; + +static int set_in_addr(struct in_addr *addr, const char *hostname) +{ + struct sockaddr_in sin; + int err; + + err = __set_sockaddr((struct sockaddr *) &sin, sizeof(sin), + AF_INET, hostname); + if (err) + return err; + memcpy(addr, &sin.sin_addr, sizeof(*addr)); + return 0; +} + +static char *str_in_addr(struct in_addr *addr) +{ + struct sockaddr_in sin; + char buf[NI_MAXHOST]; + + memcpy(&sin.sin_addr, addr, sizeof(*addr)); + return __str_sockaddr((struct sockaddr *) &sin, sizeof(sin), AF_INET, + buf); +} + +static int lw_ap_sock_open(struct lw_psr_port_priv *psr_ppriv) +{ + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + struct sock_fprog fprog; + struct sock_filter arp_vlan_rpl_flt[ARRAY_SIZE(arp_vlan_rpl_flt)]; + + if (ap_ppriv->vlanid_in_use) { + memcpy(&arp_vlan_rpl_flt, arp_vlan_rpl_fprog.filter, + sizeof(arp_vlan_rpl_flt)); + fprog = arp_vlan_rpl_fprog; + fprog.filter = arp_vlan_rpl_flt; + SET_FILTER_VLANID(&fprog, ap_ppriv->vlanid); + } else { + fprog = arp_novlan_rpl_fprog; + } + return teamd_packet_sock_open(&psr_ppriv->sock, + psr_ppriv->common.tdport->ifindex, + htons(ETH_P_ARP), &fprog, &arp_rpl_fprog); +} + +static void lw_ap_sock_close(struct lw_psr_port_priv *psr_ppriv) +{ + close(psr_ppriv->sock); +} + +static int lw_ap_load_options(struct teamd_context *ctx, + struct teamd_port *tdport, + struct lw_psr_port_priv *psr_ppriv) +{ + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + struct teamd_config_path_cookie *cpcookie = psr_ppriv->common.cpcookie; + const char *host; + int tmp; + int err; + + err = teamd_config_string_get(ctx, &host, "@.source_host", cpcookie); + if (!err) { + err = set_in_addr(&ap_ppriv->src, host); + if (err) + return err; + } + /* + * If source_host is not provided, just use address 0.0.0.0 according + * to RFC 5227 (IPv4 Address Conflict Detection). + */ + teamd_log_dbg("source address \"%s\".", + str_in_addr(&ap_ppriv->src)); + + err = teamd_config_string_get(ctx, &host, "@.target_host", cpcookie); + if (err) { + teamd_log_err("Failed to get \"target_host\" link-watch option."); + return -EINVAL; + } + err = set_in_addr(&ap_ppriv->dst, host); + if (err) + return err; + teamd_log_dbg("target address \"%s\".", str_in_addr(&ap_ppriv->dst)); + + err = teamd_config_bool_get(ctx, &ap_ppriv->validate_active, + "@.validate_active", cpcookie); + if (err) + ap_ppriv->validate_active = false; + teamd_log_dbg("validate_active \"%d\".", ap_ppriv->validate_active); + + err = teamd_config_bool_get(ctx, &ap_ppriv->validate_inactive, + "@.validate_inactive", cpcookie); + if (err) + ap_ppriv->validate_inactive = false; + teamd_log_dbg("validate_inactive \"%d\".", ap_ppriv->validate_inactive); + + err = teamd_config_bool_get(ctx, &ap_ppriv->send_always, + "@.send_always", cpcookie); + if (err) + ap_ppriv->send_always = false; + teamd_log_dbg("send_always \"%d\".", ap_ppriv->send_always); + + err = teamd_config_int_get(ctx, &tmp, "@.vlanid", cpcookie); + if (!err) { + if (tmp < 0 || tmp >= 4096) { + teamd_log_err("Wrong \"vlanid\" option value."); + return -EINVAL; + } + ap_ppriv->vlanid_in_use = true; + ap_ppriv->vlanid = tmp; + teamd_log_dbg("vlan id \"%u\".", ap_ppriv->vlanid); + } + + return 0; +} + +static int __get_port_curr_hwaddr(struct lw_psr_port_priv *psr_ppriv, + struct sockaddr_ll *addr, size_t expected_len) +{ + struct team_ifinfo *ifinfo = psr_ppriv->common.tdport->team_ifinfo; + size_t port_hwaddr_len = team_get_ifinfo_hwaddr_len(ifinfo); + char *port_hwaddr = team_get_ifinfo_hwaddr(ifinfo); + int err; + + err = teamd_getsockname_hwaddr(psr_ppriv->sock, addr, expected_len); + if (err) + return err; + if ((addr->sll_halen != port_hwaddr_len) || + (expected_len && expected_len != port_hwaddr_len)) { + teamd_log_err("Unexpected length of hw address."); + return -ENOTSUP; + } + memcpy(addr->sll_addr, port_hwaddr, addr->sll_halen); + return 0; +} + +struct arp_packet { + struct arphdr ah; + unsigned char sender_mac[ETH_ALEN]; + struct in_addr sender_ip; + unsigned char target_mac[ETH_ALEN]; + struct in_addr target_ip; +} __attribute__((packed)); + +struct __vlan_hdr { + __be16 h_vlan_TCI; + __be16 h_vlan_encapsulated_proto; +}; + +struct arp_vlan_packet { + struct __vlan_hdr vlanh; + struct arp_packet ap; +} __attribute__((packed)); + +static int lw_ap_send(struct lw_psr_port_priv *psr_ppriv) +{ + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + int err; + struct sockaddr_ll ll_my; + struct sockaddr_ll ll_bcast; + struct arp_packet ap; + + if (!(psr_ppriv->common.forced_send || ap_ppriv->send_always)) + return 0; + + err = __get_port_curr_hwaddr(psr_ppriv, &ll_my, 0); + if (err) + return err; + ll_bcast = ll_my; + memset(ll_bcast.sll_addr, 0xFF, ll_bcast.sll_halen); + + memset(&ap, 0, sizeof(ap)); + ap.ah.ar_hrd = htons(ll_my.sll_hatype); + ap.ah.ar_pro = htons(ETH_P_IP); + ap.ah.ar_hln = ll_my.sll_halen; + ap.ah.ar_pln = 4; + ap.ah.ar_op = htons(ARPOP_REQUEST); + + memcpy(ap.sender_mac, ll_my.sll_addr, sizeof(ap.sender_mac)); + ap.sender_ip = ap_ppriv->src; + memcpy(ap.target_mac, ll_bcast.sll_addr, sizeof(ap.target_mac)); + ap.target_ip = ap_ppriv->dst; + + if (ap_ppriv->vlanid_in_use) { + struct arp_vlan_packet avp; + avp.ap = ap; + avp.vlanh.h_vlan_encapsulated_proto = htons(ETH_P_ARP); + avp.vlanh.h_vlan_TCI = htons(ap_ppriv->vlanid); + ll_bcast.sll_protocol = htons(ETH_P_8021Q); + return teamd_sendto(psr_ppriv->sock, &avp, sizeof(avp), + 0, (struct sockaddr *) &ll_bcast, + sizeof(ll_bcast)); + } else { + return teamd_sendto(psr_ppriv->sock, &ap, sizeof(ap), + 0, (struct sockaddr *) &ll_bcast, + sizeof(ll_bcast)); + } +} + +static int lw_ap_receive(struct lw_psr_port_priv *psr_ppriv) +{ + struct lw_common_port_priv *common_ppriv = &psr_ppriv->common; + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + int err; + struct sockaddr_ll ll_my; + struct sockaddr_ll ll_from; + struct arp_packet ap; + bool port_enabled; + + err = teamd_recvfrom(psr_ppriv->sock, &ap, sizeof(ap), 0, + (struct sockaddr *) &ll_from, sizeof(ll_from)); + if (err <= 0) + return err; + + err = teamd_port_enabled(common_ppriv->ctx, common_ppriv->tdport, + &port_enabled); + if (err) + return err; + + if ((port_enabled && ap_ppriv->validate_active) || + (!port_enabled && ap_ppriv->validate_inactive)) { + err = __get_port_curr_hwaddr(psr_ppriv, &ll_my, 0); + if (err) + return err; + + if (ap.ah.ar_hrd != htons(ll_my.sll_hatype) || + ap.ah.ar_pro != htons(ETH_P_IP) || + ap.ah.ar_hln != ll_my.sll_halen || + ap.ah.ar_pln != 4) { + return 0; + } + + if ((ap_ppriv->src.s_addr != ap.target_ip.s_addr || + ap_ppriv->dst.s_addr != ap.sender_ip.s_addr) && + (ap_ppriv->dst.s_addr != ap.target_ip.s_addr || + ap_ppriv->src.s_addr != ap.sender_ip.s_addr)) + return 0; + } + + psr_ppriv->reply_received = true; + return 0; +} + +static const struct lw_psr_ops lw_psr_ops_ap = { + .sock_open = lw_ap_sock_open, + .sock_close = lw_ap_sock_close, + .load_options = lw_ap_load_options, + .send = lw_ap_send, + .receive = lw_ap_receive, +}; + +static int lw_ap_port_added(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv, void *creator_priv) +{ + struct lw_ap_port_priv *ap_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = &ap_ppriv->start.psr; + + psr_ppriv->ops = &lw_psr_ops_ap; + return lw_psr_port_added(ctx, tdport, priv, creator_priv); +} + +static int lw_ap_state_source_host_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + + gsc->data.str_val.ptr = str_in_addr(&ap_ppriv->src); + return 0; +} + +static int lw_ap_state_target_host_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + + gsc->data.str_val.ptr = str_in_addr(&ap_ppriv->dst); + return 0; +} + +static int lw_ap_state_validate_active_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + + gsc->data.int_val = ap_ppriv->validate_active; + return 0; +} + +static int lw_ap_state_validate_inactive_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + + gsc->data.int_val = ap_ppriv->validate_inactive; + return 0; +} + +static int lw_ap_state_send_always_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_common_port_priv *common_ppriv = priv; + struct lw_psr_port_priv *psr_ppriv = lw_psr_ppriv_get(common_ppriv); + struct lw_ap_port_priv *ap_ppriv = lw_ap_ppriv_get(psr_ppriv); + + gsc->data.int_val = ap_ppriv->send_always; + return 0; +} + +static const struct teamd_state_val lw_ap_state_vals[] = { + { + .subpath = "source_host", + .type = TEAMD_STATE_ITEM_TYPE_STRING, + .getter = lw_ap_state_source_host_get, + }, + { + .subpath = "target_host", + .type = TEAMD_STATE_ITEM_TYPE_STRING, + .getter = lw_ap_state_target_host_get, + }, + { + .subpath = "interval", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_psr_state_interval_get, + }, + { + .subpath = "init_wait", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_psr_state_init_wait_get, + }, + { + .subpath = "validate_active", + .type = TEAMD_STATE_ITEM_TYPE_BOOL, + .getter = lw_ap_state_validate_active_get, + }, + { + .subpath = "validate_inactive", + .type = TEAMD_STATE_ITEM_TYPE_BOOL, + .getter = lw_ap_state_validate_inactive_get, + }, + { + .subpath = "send_always", + .type = TEAMD_STATE_ITEM_TYPE_BOOL, + .getter = lw_ap_state_send_always_get, + }, + { + .subpath = "missed_max", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_psr_state_missed_max_get, + }, + { + .subpath = "missed", + .type = TEAMD_STATE_ITEM_TYPE_INT, + .getter = lw_psr_state_missed_get, + }, +}; + +const struct teamd_link_watch teamd_link_watch_arp_ping = { + .name = "arp_ping", + .state_vg = { + .vals = lw_ap_state_vals, + .vals_count = ARRAY_SIZE(lw_ap_state_vals), + }, + .port_priv = { + .init = lw_ap_port_added, + .fini = lw_psr_port_removed, + .priv_size = sizeof(struct lw_ap_port_priv), + }, +}; + + -- 1.8.3.2

From: Erik Hugne <erik.hugne(a)ericsson.com&gt; The TIPC link watcher provides a teaming failover mechanism that use the logical link availability to all other peer nodes in a cluster. When the last logical link over a bearer device fails, teamd will be notified of the path failure an initiate a failover. An active-backup setup in a single-switch configuration, or configurations that involve ISL/Crosslink between multiple switches, TIPC plane separation is normally accomplished through vlans, the link_watchers would then normally be assigned to be the TIPC bearer devices directly attached to the physical interface. (activebackup_tipc.conf) tipc bearer A tipc bearer B | | | teamd | | | | | | | | +---team0---+ | vlan0 | | vlan1 | | | | | | | | +-----eth0----+---eth1-----+ | switch For setups where the physical devices are in separate broadcast domains, the TIPC bearer interface is normally the same as the teaming port. Signed-off-by: Erik Hugne <erik.hugne(a)ericsson.com&gt; --- configure.ac | 34 ++++ teamd/Makefile.am | 4 + teamd/example_configs/activebackup_tipc.conf | 22 +++ teamd/teamd_link_watch.c | 6 + teamd/teamd_lw_tipc.c | 263 +++++++++++++++++++++++++++ utils/teamdctl.c | 11 +- 6 files changed, 339 insertions(+), 1 deletion(-) create mode 100644 teamd/example_configs/activebackup_tipc.conf create mode 100644 teamd/teamd_lw_tipc.c diff --git a/configure.ac b/configure.ac index f2b269c..5af8bf7 100644 --- a/configure.ac +++ b/configure.ac @@ -101,6 +101,40 @@ AC_ARG_ENABLE([zmq], fi fi +AC_MSG_CHECKING([if TIPC is available and supports link state supervision]) +AC_COMPILE_IFELSE([ + AC_LANG_PROGRAM([[ + #include <stdlib.h> + #include <string.h> + #include <errno.h> + #include <sys/socket.h> + #include <sys/ioctl.h> + #include <netinet/in.h> + #include <linux/tipc.h> + ]],[[ + #ifndef TIPC_LINK_STATE + #error TIPC link state monitoring is not available for your kernel + #endif + int sd = 0; + struct tipc_sioc_ln_req lnr = { 0 }; + + if ((sd = socket(AF_TIPC, SOCK_SEQPACKET, 0)) == -1) { + return errno; + } + lnr.peer = 0; + lnr.bearer_id = 0; + if ((ioctl(sd, SIOCGETLINKNAME, &lnr) < 0) < 0) { + return errno; + } + ]])], + [teamd_tipc_support=yes], + [teamd_tipc_support=no]) +AC_MSG_RESULT([$teamd_tipc_support]) +if test "x$teamd_tipc_support" = "xyes"; then + AC_DEFINE(TEAMD_ENABLE_TIPC, 1, [TIPC support enabled]) +fi +AM_CONDITIONAL(TEAMD_ENABLE_TIPC, test "x$teamd_tipc_support" = "xyes") + AC_CONFIG_FILES([Makefile include/Makefile \ libteam/Makefile \ diff --git a/teamd/Makefile.am b/teamd/Makefile.am index ee1ed8d..6cad07a 100644 --- a/teamd/Makefile.am +++ b/teamd/Makefile.am @@ -21,6 +21,10 @@ teamd_SOURCES=teamd.c teamd_common.c teamd_json.c teamd_config.c teamd_state.c \ teamd_runner_activebackup.c teamd_runner_loadbalance.c \ teamd_runner_lacp.c +if TEAMD_ENABLE_TIPC +teamd_SOURCES+=teamd_lw_tipc.c +endif + EXTRA_DIST = example_configs dbus redhat noinst_HEADERS = teamd.h teamd_workq.h teamd_bpf_chef.h teamd_ctl.h \ diff --git a/teamd/example_configs/activebackup_tipc.conf b/teamd/example_configs/activebackup_tipc.conf new file mode 100644 index 0000000..81e7717 --- /dev/null +++ b/teamd/example_configs/activebackup_tipc.conf @@ -0,0 +1,22 @@ +{ + "device": "team0", + "runner": {"name": "activebackup"}, + "ports": { + "eth0": { + "link_watch": { + "name": "tipc", + "tipc_bearer": "vlan0" + }, + "sticky": true, + "prio": 10 + }, + "eth1": { + "link_watch": { + "name": "tipc", + "tipc_bearer": "vlan1" + }, + "sticky": true, + "prio": 10 + } + } +} diff --git a/teamd/teamd_link_watch.c b/teamd/teamd_link_watch.c index 568e3fe..f565138 100644 --- a/teamd/teamd_link_watch.c +++ b/teamd/teamd_link_watch.c @@ -36,6 +36,9 @@ extern const struct teamd_link_watch teamd_link_watch_ethtool; extern const struct teamd_link_watch teamd_link_watch_arp_ping; extern const struct teamd_link_watch teamd_link_watch_nsnap; +#ifdef TEAMD_ENABLE_TIPC +extern const struct teamd_link_watch teamd_link_watch_tipc; +#endif int __set_sockaddr(struct sockaddr *sa, socklen_t sa_len, sa_family_t family, const char *hostname) @@ -99,6 +102,9 @@ static const struct teamd_link_watch *teamd_link_watch_list[] = { &teamd_link_watch_ethtool, &teamd_link_watch_arp_ping, &teamd_link_watch_nsnap, +#ifdef TEAMD_ENABLE_TIPC + &teamd_link_watch_tipc, +#endif }; #define TEAMD_LINK_WATCH_LIST_SIZE ARRAY_SIZE(teamd_link_watch_list) diff --git a/teamd/teamd_lw_tipc.c b/teamd/teamd_lw_tipc.c new file mode 100644 index 0000000..f54a0d3 --- /dev/null +++ b/teamd/teamd_lw_tipc.c @@ -0,0 +1,263 @@ +/* + * teamd_lw_arp.c - Team port TIPC link watcher + * Copyright (C) 2014 Erik Hugne <erik.hugne(a)ericsson.com&gt; + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <sys/queue.h> +#include <sys/poll.h> +#include <linux/tipc.h> +#include <netinet/in.h> +#include <private/misc.h> +#include "teamd.h" +#include "teamd_link_watch.h" +#include "teamd_config.h" + +/* + * TIPC monitoring + */ + +#define LW_TIPC_TOPSRV_SOCKET "lw_tipc" + +struct tipc_link { + LIST_ENTRY(tipc_link) next; + char name[255]; + bool up; +}; + +struct lw_tipc_port_priv { + struct lw_common_port_priv common; + int topsrv_sock; + char bearer[255]; + LIST_HEAD(links, tipc_link) links; + int active_links; +}; + +static int lw_tipc_load_options(struct teamd_context *ctx, + struct teamd_port *tdport, + struct lw_tipc_port_priv *tipc_ppriv) +{ + int err; + const char *tipc_bearer; + struct teamd_config_path_cookie *cpcookie = tipc_ppriv->common.cpcookie; + err = teamd_config_string_get(ctx, &tipc_bearer, "@.tipc_bearer", cpcookie); + if (err) + return -EINVAL; + strcpy(tipc_ppriv->bearer, tipc_bearer); + + return 0; +} + + +static int lw_tipc_link_state_change(struct teamd_context *ctx, char *name, + struct lw_tipc_port_priv *priv, + bool link_up) +{ + struct tipc_link *link; + struct teamd_port *tdport = priv->common.tdport; + LIST_FOREACH(link, &priv->links, next) { + if (!strcmp(link->name, name)) { + teamd_log_info("tipc: link <%s> went %s.", name, + link_up ? "up" : "down"); + link->up = link_up; + if (!link_up && ((--(priv->active_links) == 0))) { + return teamd_link_watch_check_link_up(ctx, tdport, + (struct lw_common_port_priv *)priv, link_up); + } + goto link_up; + } + } + if (!link_up) { + teamd_log_err("tipc: received spurious down event for link <%s>", + name); + return -EINVAL; + } + teamd_log_dbg("tipc: established new link <%s>", name); + link = malloc(sizeof(struct tipc_link)); + strcpy(link->name, name); + link->up = link_up; + LIST_INSERT_HEAD(&priv->links, link, next); +link_up: + priv->active_links++; + return teamd_link_watch_check_link_up(ctx, tdport, + (struct lw_common_port_priv *)priv, + link_up); +} + +static int lw_tipc_filter_events(struct lw_tipc_port_priv *tipc_ppriv, + struct tipc_sioc_ln_req *lnr) +{ + char name[255]; + char needle[24]; + char *remote, *bearer; + + strcpy(name, lnr->linkname); + sprintf(needle, "-%u.%u.%u:", tipc_zone(lnr->peer), + tipc_cluster(lnr->peer), tipc_node(lnr->peer)); + remote = strstr(name, needle); + *(remote++) = '\0'; + bearer = strchr(name, ':') + 1; + return strcmp(bearer, tipc_ppriv->bearer); +} + +static int lw_tipc_callback_socket(struct teamd_context *ctx, int events, void *priv) +{ + int err; + struct lw_tipc_port_priv *tipc_ppriv = priv; + struct tipc_event event; + struct sockaddr_tipc sa; + struct tipc_sioc_ln_req lnr = {0}; + + err = teamd_recvfrom(tipc_ppriv->topsrv_sock, &event, sizeof(event), 0, + (struct sockaddr *)&sa, sizeof(sa)); + if ((err != sizeof(event)) || + (event.s.seq.type != htonl(TIPC_LINK_STATE))) + goto tipc_cb_err; + + lnr.peer = ntohl(event.found_lower); + lnr.bearer_id = ntohl(event.port.ref); + if (ioctl(tipc_ppriv->topsrv_sock, SIOCGETLINKNAME, &lnr) < 0) + goto tipc_cb_err; + + if (lw_tipc_filter_events(tipc_ppriv, &lnr)) + return 0; + if (event.event == htonl(TIPC_PUBLISHED)) + return lw_tipc_link_state_change(ctx, lnr.linkname, tipc_ppriv, true); + else if (event.event == htonl(TIPC_WITHDRAWN)) + return lw_tipc_link_state_change(ctx, lnr.linkname, tipc_ppriv, false); +tipc_cb_err: + teamd_log_dbg("tipc: link state event error"); + return -EINVAL; +} + +static int lw_tipc_topsrv_subscribe(struct teamd_context *ctx, struct lw_tipc_port_priv *priv) +{ + int err; + struct sockaddr_tipc sa_topsrv = { + .family = AF_TIPC, + .addrtype = TIPC_ADDR_NAME, + .addr.name.name.type = TIPC_TOP_SRV, + .addr.name.name.instance = TIPC_TOP_SRV, + }; + struct tipc_subscr sub = { + .seq.type = htonl(TIPC_LINK_STATE), + .seq.lower = htonl(0), + .seq.upper = htonl(~0), + .timeout = htonl(TIPC_WAIT_FOREVER), + .filter = htonl(TIPC_SUB_PORTS), + }; + + priv->topsrv_sock = socket(AF_TIPC, SOCK_SEQPACKET, 0); + if (priv->topsrv_sock == -1) { + teamd_log_err("Failed to create TIPC socket"); + return -errno; + } + + err = teamd_loop_callback_fd_add(ctx, LW_TIPC_TOPSRV_SOCKET, priv, + lw_tipc_callback_socket, + priv->topsrv_sock, + POLLIN); + if (err) { + teamd_log_err("Failed to add socket callback"); + err = -errno; + goto close_sock; + } + teamd_loop_callback_enable(ctx, LW_TIPC_TOPSRV_SOCKET, priv); + err = connect(priv->topsrv_sock, (struct sockaddr *) &sa_topsrv, sizeof(sa_topsrv)); + if (err < 0) { + teamd_log_err("Failed to connect to TIPC topology server"); + err = -errno; + goto close_sock; + } + err = send(priv->topsrv_sock, &sub, sizeof(sub), 0); + if (err != sizeof(sub)) { + teamd_log_err("Failed to subscribe for TIPC link status"); + goto close_sock; + } + + return 0; +close_sock: + close(priv->topsrv_sock); + return err; +} + +static int lw_tipc_port_added(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv, void *creator_priv) +{ + struct lw_tipc_port_priv *tipc_ppriv = priv; + int err; + + err = lw_tipc_load_options(ctx, tdport, priv); + if (err) { + teamd_log_err("tipc: Failed to load options"); + return err; + } + LIST_INIT(&tipc_ppriv->links); + err = lw_tipc_topsrv_subscribe(ctx, tipc_ppriv); + if (err) + return err; + return 0; +} + + + +static void lw_tipc_port_removed(struct teamd_context *ctx, + struct teamd_port *tdport, + void *priv, void *creator_priv) +{ + struct lw_tipc_port_priv *tipc_ppriv = priv; + + teamd_log_dbg("tipc port removed\n"); + close(tipc_ppriv->topsrv_sock); + while (tipc_ppriv->links.lh_first != NULL) + LIST_REMOVE(tipc_ppriv->links.lh_first, next); + +} + +int lw_tipc_state_bearer_get(struct teamd_context *ctx, + struct team_state_gsc *gsc, + void *priv) +{ + struct lw_tipc_port_priv *tipc_ppriv = priv; + gsc->data.str_val.ptr = tipc_ppriv->bearer; + return 0; +} + +static const struct teamd_state_val lw_tipc_state_vals[] = { + { + .subpath = "tipc_bearer", + .type = TEAMD_STATE_ITEM_TYPE_STRING, + .getter = lw_tipc_state_bearer_get, + }, +}; + + +const struct teamd_link_watch teamd_link_watch_tipc = { + .name = "tipc", + .state_vg = { + .vals = lw_tipc_state_vals, + .vals_count = ARRAY_SIZE(lw_tipc_state_vals), + }, + .port_priv = { + .init = lw_tipc_port_added, + .fini = lw_tipc_port_removed, + .priv_size = sizeof(struct lw_tipc_port_priv), + }, +}; + + + diff --git a/utils/teamdctl.c b/utils/teamdctl.c index 5d1228e..63bc3fc 100644 --- a/utils/teamdctl.c +++ b/utils/teamdctl.c @@ -256,7 +256,16 @@ static int stateview_json_link_watch_info_process(char *lw_name, pr_out2("interval: %d\n", interval); pr_out2("missed packets: %d/%d\n", missed, missed_max); pr_out2("initial wait: %d\n", init_wait); - } else { + } else if (!strcmp(lw_name, "tipc")) { + char *tipc_bearer; + + err = json_unpack(lw_json, "{s:s}", "tipc_bearer", &tipc_bearer); + if (err) { + pr_err("Failed to parse JSON tipc_bearer link watch dump\n"); + return -EINVAL; + } + pr_out2("tipc bearer: %s\n", tipc_bearer); + } else { pr_err("Failed to parse JSON unknown link watch info dump.\n"); return -EINVAL; } -- 1.8.3.2