[deliverable/linux.git] / drivers / net / team / team_mode_loadbalance.c

/*
 * drivers/net/team/team_mode_loadbalance.c - Load-balancing mode for team
 * Copyright (c) 2012 Jiri Pirko <jpirko@redhat.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */

#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/filter.h>
#include <linux/if_team.h>

static rx_handler_result_t lb_receive(struct team *team, struct team_port *port,
				      struct sk_buff *skb)
{
	if (unlikely(skb->protocol == htons(ETH_P_SLOW))) {
		/* LACPDU packets should go to exact delivery */
		const unsigned char *dest = eth_hdr(skb)->h_dest;

		if (is_link_local_ether_addr(dest) && dest[5] == 0x02)
			return RX_HANDLER_EXACT;
	}
	return RX_HANDLER_ANOTHER;
}

struct lb_priv;

typedef struct team_port *lb_select_tx_port_func_t(struct team *,
						   struct lb_priv *,
						   struct sk_buff *,
						   unsigned char);

#define LB_TX_HASHTABLE_SIZE 256 /* hash is a char */

struct lb_stats {
	u64 tx_bytes;
};

struct lb_pcpu_stats {
	struct lb_stats hash_stats[LB_TX_HASHTABLE_SIZE];
	struct u64_stats_sync syncp;
};

struct lb_stats_info {
	struct lb_stats stats;
	struct lb_stats last_stats;
	struct team_option_inst_info *opt_inst_info;
};

struct lb_port_mapping {
	struct team_port __rcu *port;
	struct team_option_inst_info *opt_inst_info;
};

struct lb_priv_ex {
	struct team *team;
	struct lb_port_mapping tx_hash_to_port_mapping[LB_TX_HASHTABLE_SIZE];
	struct sock_fprog_kern *orig_fprog;
	struct {
		unsigned int refresh_interval; /* in tenths of second */
		struct delayed_work refresh_dw;
		struct lb_stats_info info[LB_TX_HASHTABLE_SIZE];
	} stats;
};

struct lb_priv {
	struct bpf_prog __rcu *fp;
	lb_select_tx_port_func_t __rcu *select_tx_port_func;
	struct lb_pcpu_stats __percpu *pcpu_stats;
	struct lb_priv_ex *ex; /* priv extension */
};

static struct lb_priv *get_lb_priv(struct team *team)
{
	return (struct lb_priv *) &team->mode_priv;
}

struct lb_port_priv {
	struct lb_stats __percpu *pcpu_stats;
	struct lb_stats_info stats_info;
};

static struct lb_port_priv *get_lb_port_priv(struct team_port *port)
{
	return (struct lb_port_priv *) &port->mode_priv;
}

#define LB_HTPM_PORT_BY_HASH(lp_priv, hash) \
	(lb_priv)->ex->tx_hash_to_port_mapping[hash].port

#define LB_HTPM_OPT_INST_INFO_BY_HASH(lp_priv, hash) \
	(lb_priv)->ex->tx_hash_to_port_mapping[hash].opt_inst_info

static void lb_tx_hash_to_port_mapping_null_port(struct team *team,
						 struct team_port *port)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	bool changed = false;
	int i;

	for (i = 0; i < LB_TX_HASHTABLE_SIZE; i++) {
		struct lb_port_mapping *pm;

		pm = &lb_priv->ex->tx_hash_to_port_mapping[i];
		if (rcu_access_pointer(pm->port) == port) {
			RCU_INIT_POINTER(pm->port, NULL);
			team_option_inst_set_change(pm->opt_inst_info);
			changed = true;
		}
	}
	if (changed)
		team_options_change_check(team);
}

/* Basic tx selection based solely by hash */
static struct team_port *lb_hash_select_tx_port(struct team *team,
						struct lb_priv *lb_priv,
						struct sk_buff *skb,
						unsigned char hash)
{
	int port_index = team_num_to_port_index(team, hash);

	return team_get_port_by_index_rcu(team, port_index);
}

/* Hash to port mapping select tx port */
static struct team_port *lb_htpm_select_tx_port(struct team *team,
						struct lb_priv *lb_priv,
						struct sk_buff *skb,
						unsigned char hash)
{
	return rcu_dereference_bh(LB_HTPM_PORT_BY_HASH(lb_priv, hash));
}

struct lb_select_tx_port {
	char *name;
	lb_select_tx_port_func_t *func;
};

static const struct lb_select_tx_port lb_select_tx_port_list[] = {
	{
		.name = "hash",
		.func = lb_hash_select_tx_port,
	},
	{
		.name = "hash_to_port_mapping",
		.func = lb_htpm_select_tx_port,
	},
};
#define LB_SELECT_TX_PORT_LIST_COUNT ARRAY_SIZE(lb_select_tx_port_list)

static char *lb_select_tx_port_get_name(lb_select_tx_port_func_t *func)
{
	int i;

	for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
		const struct lb_select_tx_port *item;

		item = &lb_select_tx_port_list[i];
		if (item->func == func)
			return item->name;
	}
	return NULL;
}

static lb_select_tx_port_func_t *lb_select_tx_port_get_func(const char *name)
{
	int i;

	for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
		const struct lb_select_tx_port *item;

		item = &lb_select_tx_port_list[i];
		if (!strcmp(item->name, name))
			return item->func;
	}
	return NULL;
}

static unsigned int lb_get_skb_hash(struct lb_priv *lb_priv,
				    struct sk_buff *skb)
{
	struct bpf_prog *fp;
	uint32_t lhash;
	unsigned char *c;

	fp = rcu_dereference_bh(lb_priv->fp);
	if (unlikely(!fp))
		return 0;
	lhash = BPF_PROG_RUN(fp, skb);
	c = (char *) &lhash;
	return c[0] ^ c[1] ^ c[2] ^ c[3];
}

static void lb_update_tx_stats(unsigned int tx_bytes, struct lb_priv *lb_priv,
			       struct lb_port_priv *lb_port_priv,
			       unsigned char hash)
{
	struct lb_pcpu_stats *pcpu_stats;
	struct lb_stats *port_stats;
	struct lb_stats *hash_stats;

	pcpu_stats = this_cpu_ptr(lb_priv->pcpu_stats);
	port_stats = this_cpu_ptr(lb_port_priv->pcpu_stats);
	hash_stats = &pcpu_stats->hash_stats[hash];
	u64_stats_update_begin(&pcpu_stats->syncp);
	port_stats->tx_bytes += tx_bytes;
	hash_stats->tx_bytes += tx_bytes;
	u64_stats_update_end(&pcpu_stats->syncp);
}

static bool lb_transmit(struct team *team, struct sk_buff *skb)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	lb_select_tx_port_func_t *select_tx_port_func;
	struct team_port *port;
	unsigned char hash;
	unsigned int tx_bytes = skb->len;

	hash = lb_get_skb_hash(lb_priv, skb);
	select_tx_port_func = rcu_dereference_bh(lb_priv->select_tx_port_func);
	port = select_tx_port_func(team, lb_priv, skb, hash);
	if (unlikely(!port))
		goto drop;
	if (team_dev_queue_xmit(team, port, skb))
		return false;
	lb_update_tx_stats(tx_bytes, lb_priv, get_lb_port_priv(port), hash);
	return true;

drop:
	dev_kfree_skb_any(skb);
	return false;
}

static int lb_bpf_func_get(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);

	if (!lb_priv->ex->orig_fprog) {
		ctx->data.bin_val.len = 0;
		ctx->data.bin_val.ptr = NULL;
		return 0;
	}
	ctx->data.bin_val.len = lb_priv->ex->orig_fprog->len *
				sizeof(struct sock_filter);
	ctx->data.bin_val.ptr = lb_priv->ex->orig_fprog->filter;
	return 0;
}

static int __fprog_create(struct sock_fprog_kern **pfprog, u32 data_len,
			  const void *data)
{
	struct sock_fprog_kern *fprog;
	struct sock_filter *filter = (struct sock_filter *) data;

	if (data_len % sizeof(struct sock_filter))
		return -EINVAL;
	fprog = kmalloc(sizeof(*fprog), GFP_KERNEL);
	if (!fprog)
		return -ENOMEM;
	fprog->filter = kmemdup(filter, data_len, GFP_KERNEL);
	if (!fprog->filter) {
		kfree(fprog);
		return -ENOMEM;
	}
	fprog->len = data_len / sizeof(struct sock_filter);
	*pfprog = fprog;
	return 0;
}

static void __fprog_destroy(struct sock_fprog_kern *fprog)
{
	kfree(fprog->filter);
	kfree(fprog);
}

static int lb_bpf_func_set(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	struct bpf_prog *fp = NULL;
	struct bpf_prog *orig_fp = NULL;
	struct sock_fprog_kern *fprog = NULL;
	int err;

	if (ctx->data.bin_val.len) {
		err = __fprog_create(&fprog, ctx->data.bin_val.len,
				     ctx->data.bin_val.ptr);
		if (err)
			return err;
		err = bpf_prog_create(&fp, fprog);
		if (err) {
			__fprog_destroy(fprog);
			return err;
		}
	}

	if (lb_priv->ex->orig_fprog) {
		/* Clear old filter data */
		__fprog_destroy(lb_priv->ex->orig_fprog);
		orig_fp = rcu_dereference_protected(lb_priv->fp,
						lockdep_is_held(&team->lock));
	}

	rcu_assign_pointer(lb_priv->fp, fp);
	lb_priv->ex->orig_fprog = fprog;

	if (orig_fp) {
		synchronize_rcu();
		bpf_prog_destroy(orig_fp);
	}
	return 0;
}

static int lb_tx_method_get(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	lb_select_tx_port_func_t *func;
	char *name;

	func = rcu_dereference_protected(lb_priv->select_tx_port_func,
					 lockdep_is_held(&team->lock));
	name = lb_select_tx_port_get_name(func);
	BUG_ON(!name);
	ctx->data.str_val = name;
	return 0;
}

static int lb_tx_method_set(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	lb_select_tx_port_func_t *func;

	func = lb_select_tx_port_get_func(ctx->data.str_val);
	if (!func)
		return -EINVAL;
	rcu_assign_pointer(lb_priv->select_tx_port_func, func);
	return 0;
}

static int lb_tx_hash_to_port_mapping_init(struct team *team,
					   struct team_option_inst_info *info)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	unsigned char hash = info->array_index;

	LB_HTPM_OPT_INST_INFO_BY_HASH(lb_priv, hash) = info;
	return 0;
}

static int lb_tx_hash_to_port_mapping_get(struct team *team,
					  struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	struct team_port *port;
	unsigned char hash = ctx->info->array_index;

	port = LB_HTPM_PORT_BY_HASH(lb_priv, hash);
	ctx->data.u32_val = port ? port->dev->ifindex : 0;
	return 0;
}

static int lb_tx_hash_to_port_mapping_set(struct team *team,
					  struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	struct team_port *port;
	unsigned char hash = ctx->info->array_index;

	list_for_each_entry(port, &team->port_list, list) {
		if (ctx->data.u32_val == port->dev->ifindex &&
		    team_port_enabled(port)) {
			rcu_assign_pointer(LB_HTPM_PORT_BY_HASH(lb_priv, hash),
					   port);
			return 0;
		}
	}
	return -ENODEV;
}

static int lb_hash_stats_init(struct team *team,
			      struct team_option_inst_info *info)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	unsigned char hash = info->array_index;

	lb_priv->ex->stats.info[hash].opt_inst_info = info;
	return 0;
}

static int lb_hash_stats_get(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	unsigned char hash = ctx->info->array_index;

	ctx->data.bin_val.ptr = &lb_priv->ex->stats.info[hash].stats;
	ctx->data.bin_val.len = sizeof(struct lb_stats);
	return 0;
}

static int lb_port_stats_init(struct team *team,
			      struct team_option_inst_info *info)
{
	struct team_port *port = info->port;
	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);

	lb_port_priv->stats_info.opt_inst_info = info;
	return 0;
}

static int lb_port_stats_get(struct team *team, struct team_gsetter_ctx *ctx)
{
	struct team_port *port = ctx->info->port;
	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);

	ctx->data.bin_val.ptr = &lb_port_priv->stats_info.stats;
	ctx->data.bin_val.len = sizeof(struct lb_stats);
	return 0;
}

static void __lb_stats_info_refresh_prepare(struct lb_stats_info *s_info)
{
	memcpy(&s_info->last_stats, &s_info->stats, sizeof(struct lb_stats));
	memset(&s_info->stats, 0, sizeof(struct lb_stats));
}

static bool __lb_stats_info_refresh_check(struct lb_stats_info *s_info,
					  struct team *team)
{
	if (memcmp(&s_info->last_stats, &s_info->stats,
	    sizeof(struct lb_stats))) {
		team_option_inst_set_change(s_info->opt_inst_info);
		return true;
	}
	return false;
}

static void __lb_one_cpu_stats_add(struct lb_stats *acc_stats,
				   struct lb_stats *cpu_stats,
				   struct u64_stats_sync *syncp)
{
	unsigned int start;
	struct lb_stats tmp;

	do {
		start = u64_stats_fetch_begin_irq(syncp);
		tmp.tx_bytes = cpu_stats->tx_bytes;
	} while (u64_stats_fetch_retry_irq(syncp, start));
	acc_stats->tx_bytes += tmp.tx_bytes;
}

static void lb_stats_refresh(struct work_struct *work)
{
	struct team *team;
	struct lb_priv *lb_priv;
	struct lb_priv_ex *lb_priv_ex;
	struct lb_pcpu_stats *pcpu_stats;
	struct lb_stats *stats;
	struct lb_stats_info *s_info;
	struct team_port *port;
	bool changed = false;
	int i;
	int j;

	lb_priv_ex = container_of(work, struct lb_priv_ex,
				  stats.refresh_dw.work);

	team = lb_priv_ex->team;
	lb_priv = get_lb_priv(team);

	if (!mutex_trylock(&team->lock)) {
		schedule_delayed_work(&lb_priv_ex->stats.refresh_dw, 0);
		return;
	}

	for (j = 0; j < LB_TX_HASHTABLE_SIZE; j++) {
		s_info = &lb_priv->ex->stats.info[j];
		__lb_stats_info_refresh_prepare(s_info);
		for_each_possible_cpu(i) {
			pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
			stats = &pcpu_stats->hash_stats[j];
			__lb_one_cpu_stats_add(&s_info->stats, stats,
					       &pcpu_stats->syncp);
		}
		changed |= __lb_stats_info_refresh_check(s_info, team);
	}

	list_for_each_entry(port, &team->port_list, list) {
		struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);

		s_info = &lb_port_priv->stats_info;
		__lb_stats_info_refresh_prepare(s_info);
		for_each_possible_cpu(i) {
			pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
			stats = per_cpu_ptr(lb_port_priv->pcpu_stats, i);
			__lb_one_cpu_stats_add(&s_info->stats, stats,
					       &pcpu_stats->syncp);
		}
		changed |= __lb_stats_info_refresh_check(s_info, team);
	}

	if (changed)
		team_options_change_check(team);

	schedule_delayed_work(&lb_priv_ex->stats.refresh_dw,
			      (lb_priv_ex->stats.refresh_interval * HZ) / 10);

	mutex_unlock(&team->lock);
}

static int lb_stats_refresh_interval_get(struct team *team,
					 struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);

	ctx->data.u32_val = lb_priv->ex->stats.refresh_interval;
	return 0;
}

static int lb_stats_refresh_interval_set(struct team *team,
					 struct team_gsetter_ctx *ctx)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	unsigned int interval;

	interval = ctx->data.u32_val;
	if (lb_priv->ex->stats.refresh_interval == interval)
		return 0;
	lb_priv->ex->stats.refresh_interval = interval;
	if (interval)
		schedule_delayed_work(&lb_priv->ex->stats.refresh_dw, 0);
	else
		cancel_delayed_work(&lb_priv->ex->stats.refresh_dw);
	return 0;
}

static const struct team_option lb_options[] = {
	{
		.name = "bpf_hash_func",
		.type = TEAM_OPTION_TYPE_BINARY,
		.getter = lb_bpf_func_get,
		.setter = lb_bpf_func_set,
	},
	{
		.name = "lb_tx_method",
		.type = TEAM_OPTION_TYPE_STRING,
		.getter = lb_tx_method_get,
		.setter = lb_tx_method_set,
	},
	{
		.name = "lb_tx_hash_to_port_mapping",
		.array_size = LB_TX_HASHTABLE_SIZE,
		.type = TEAM_OPTION_TYPE_U32,
		.init = lb_tx_hash_to_port_mapping_init,
		.getter = lb_tx_hash_to_port_mapping_get,
		.setter = lb_tx_hash_to_port_mapping_set,
	},
	{
		.name = "lb_hash_stats",
		.array_size = LB_TX_HASHTABLE_SIZE,
		.type = TEAM_OPTION_TYPE_BINARY,
		.init = lb_hash_stats_init,
		.getter = lb_hash_stats_get,
	},
	{
		.name = "lb_port_stats",
		.per_port = true,
		.type = TEAM_OPTION_TYPE_BINARY,
		.init = lb_port_stats_init,
		.getter = lb_port_stats_get,
	},
	{
		.name = "lb_stats_refresh_interval",
		.type = TEAM_OPTION_TYPE_U32,
		.getter = lb_stats_refresh_interval_get,
		.setter = lb_stats_refresh_interval_set,
	},
};

static int lb_init(struct team *team)
{
	struct lb_priv *lb_priv = get_lb_priv(team);
	lb_select_tx_port_func_t *func;
	int i, err;

	/* set default tx port selector */
	func = lb_select_tx_port_get_func("hash");
	BUG_ON(!func);
	rcu_assign_pointer(lb_priv->select_tx_port_func, func);

	lb_priv->ex = kzalloc(sizeof(*lb_priv->ex), GFP_KERNEL);
	if (!lb_priv->ex)
		return -ENOMEM;
	lb_priv->ex->team = team;

	lb_priv->pcpu_stats = alloc_percpu(struct lb_pcpu_stats);
	if (!lb_priv->pcpu_stats) {
		err = -ENOMEM;
		goto err_alloc_pcpu_stats;
	}

	for_each_possible_cpu(i) {
		struct lb_pcpu_stats *team_lb_stats;
		team_lb_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
		u64_stats_init(&team_lb_stats->syncp);
	}


	INIT_DELAYED_WORK(&lb_priv->ex->stats.refresh_dw, lb_stats_refresh);

	err = team_options_register(team, lb_options, ARRAY_SIZE(lb_options));
	if (err)
		goto err_options_register;
	return 0;

err_options_register:
	free_percpu(lb_priv->pcpu_stats);
err_alloc_pcpu_stats:
	kfree(lb_priv->ex);
	return err;
}

static void lb_exit(struct team *team)
{
	struct lb_priv *lb_priv = get_lb_priv(team);

	team_options_unregister(team, lb_options,
				ARRAY_SIZE(lb_options));
	cancel_delayed_work_sync(&lb_priv->ex->stats.refresh_dw);
	free_percpu(lb_priv->pcpu_stats);
	kfree(lb_priv->ex);
}

static int lb_port_enter(struct team *team, struct team_port *port)
{
	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);

	lb_port_priv->pcpu_stats = alloc_percpu(struct lb_stats);
	if (!lb_port_priv->pcpu_stats)
		return -ENOMEM;
	return 0;
}

static void lb_port_leave(struct team *team, struct team_port *port)
{
	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);

	free_percpu(lb_port_priv->pcpu_stats);
}

static void lb_port_disabled(struct team *team, struct team_port *port)
{
	lb_tx_hash_to_port_mapping_null_port(team, port);
}

static const struct team_mode_ops lb_mode_ops = {
	.init			= lb_init,
	.exit			= lb_exit,
	.port_enter		= lb_port_enter,
	.port_leave		= lb_port_leave,
	.port_disabled		= lb_port_disabled,
	.receive		= lb_receive,
	.transmit		= lb_transmit,
};

static const struct team_mode lb_mode = {
	.kind		= "loadbalance",
	.owner		= THIS_MODULE,
	.priv_size	= sizeof(struct lb_priv),
	.port_priv_size	= sizeof(struct lb_port_priv),
	.ops		= &lb_mode_ops,
	.lag_tx_type	= NETDEV_LAG_TX_TYPE_HASH,
};

static int __init lb_init_module(void)
{
	return team_mode_register(&lb_mode);
}

static void __exit lb_cleanup_module(void)
{
	team_mode_unregister(&lb_mode);
}

module_init(lb_init_module);
module_exit(lb_cleanup_module);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
MODULE_DESCRIPTION("Load-balancing mode for team");
MODULE_ALIAS("team-mode-loadbalance");
Commit	Line	Data
01d7f30a JP	1	/*
	2	* drivers/net/team/team_mode_loadbalance.c - Load-balancing mode for team
	3	* Copyright (c) 2012 Jiri Pirko <jpirko@redhat.com>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/types.h>
	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/errno.h>
	16	#include <linux/netdevice.h>
c15e07b0	17	#include <linux/etherdevice.h>
01d7f30a JP	18	#include <linux/filter.h>
	19	#include <linux/if_team.h>
	20
c15e07b0 JP	21	static rx_handler_result_t lb_receive(struct team team, struct team_port port,
	22	struct sk_buff *skb)
	23	{
	24	if (unlikely(skb->protocol == htons(ETH_P_SLOW))) {
	25	/* LACPDU packets should go to exact delivery */
	26	const unsigned char *dest = eth_hdr(skb)->h_dest;
	27
	28	if (is_link_local_ether_addr(dest) && dest[5] == 0x02)
	29	return RX_HANDLER_EXACT;
	30	}
	31	return RX_HANDLER_ANOTHER;
	32	}
	33
ab8250d7 JP	34	struct lb_priv;
	35
	36	typedef struct team_port lb_select_tx_port_func_t(struct team ,
	37	struct lb_priv *,
	38	struct sk_buff *,
	39	unsigned char);
	40
	41	#define LB_TX_HASHTABLE_SIZE 256 /* hash is a char */
	42
	43	struct lb_stats {
	44	u64 tx_bytes;
	45	};
	46
	47	struct lb_pcpu_stats {
	48	struct lb_stats hash_stats[LB_TX_HASHTABLE_SIZE];
	49	struct u64_stats_sync syncp;
	50	};
	51
	52	struct lb_stats_info {
	53	struct lb_stats stats;
	54	struct lb_stats last_stats;
	55	struct team_option_inst_info *opt_inst_info;
	56	};
	57
	58	struct lb_port_mapping {
	59	struct team_port __rcu *port;
	60	struct team_option_inst_info *opt_inst_info;
	61	};
	62
	63	struct lb_priv_ex {
	64	struct team *team;
	65	struct lb_port_mapping tx_hash_to_port_mapping[LB_TX_HASHTABLE_SIZE];
b1fcd35c	66	struct sock_fprog_kern *orig_fprog;
ab8250d7 JP	67	struct {
	68	unsigned int refresh_interval; /* in tenths of second */
	69	struct delayed_work refresh_dw;
	70	struct lb_stats_info info[LB_TX_HASHTABLE_SIZE];
	71	} stats;
	72	};
	73
01d7f30a	74	struct lb_priv {
7ae457c1	75	struct bpf_prog __rcu *fp;
ab8250d7 JP	76	lb_select_tx_port_func_t __rcu *select_tx_port_func;
	77	struct lb_pcpu_stats __percpu *pcpu_stats;
	78	struct lb_priv_ex ex; / priv extension */
01d7f30a JP	79	};
01d7f30a JP	80
ab8250d7	81	static struct lb_priv get_lb_priv(struct team team)
01d7f30a JP	82	{
	83	return (struct lb_priv *) &team->mode_priv;
	84	}
	85
ab8250d7 JP	86	struct lb_port_priv {
	87	struct lb_stats __percpu *pcpu_stats;
	88	struct lb_stats_info stats_info;
	89	};
	90
	91	static struct lb_port_priv get_lb_port_priv(struct team_port port)
	92	{
	93	return (struct lb_port_priv *) &port->mode_priv;
	94	}
	95
	96	#define LB_HTPM_PORT_BY_HASH(lp_priv, hash) \
	97	(lb_priv)->ex->tx_hash_to_port_mapping[hash].port
	98
	99	#define LB_HTPM_OPT_INST_INFO_BY_HASH(lp_priv, hash) \
	100	(lb_priv)->ex->tx_hash_to_port_mapping[hash].opt_inst_info
	101
	102	static void lb_tx_hash_to_port_mapping_null_port(struct team *team,
	103	struct team_port *port)
	104	{
	105	struct lb_priv *lb_priv = get_lb_priv(team);
	106	bool changed = false;
	107	int i;
	108
	109	for (i = 0; i < LB_TX_HASHTABLE_SIZE; i++) {
	110	struct lb_port_mapping *pm;
	111
	112	pm = &lb_priv->ex->tx_hash_to_port_mapping[i];
6dab015c JP	113	if (rcu_access_pointer(pm->port) == port) {
6dab015c JP	114	RCU_INIT_POINTER(pm->port, NULL);
ab8250d7 JP	115	team_option_inst_set_change(pm->opt_inst_info);
	116	changed = true;
	117	}
	118	}
	119	if (changed)
	120	team_options_change_check(team);
	121	}
	122
	123	/* Basic tx selection based solely by hash */
	124	static struct team_port lb_hash_select_tx_port(struct team team,
	125	struct lb_priv *lb_priv,
	126	struct sk_buff *skb,
	127	unsigned char hash)
	128	{
735d381f	129	int port_index = team_num_to_port_index(team, hash);
ab8250d7	130
ab8250d7 JP	131	return team_get_port_by_index_rcu(team, port_index);
	132	}
	133
	134	/* Hash to port mapping select tx port */
	135	static struct team_port lb_htpm_select_tx_port(struct team team,
	136	struct lb_priv *lb_priv,
	137	struct sk_buff *skb,
	138	unsigned char hash)
	139	{
d1904fbd	140	return rcu_dereference_bh(LB_HTPM_PORT_BY_HASH(lb_priv, hash));
ab8250d7 JP	141	}
	142
	143	struct lb_select_tx_port {
	144	char *name;
	145	lb_select_tx_port_func_t *func;
	146	};
	147
	148	static const struct lb_select_tx_port lb_select_tx_port_list[] = {
	149	{
	150	.name = "hash",
	151	.func = lb_hash_select_tx_port,
	152	},
	153	{
	154	.name = "hash_to_port_mapping",
	155	.func = lb_htpm_select_tx_port,
	156	},
	157	};
	158	#define LB_SELECT_TX_PORT_LIST_COUNT ARRAY_SIZE(lb_select_tx_port_list)
	159
	160	static char lb_select_tx_port_get_name(lb_select_tx_port_func_t func)
	161	{
	162	int i;
	163
	164	for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
	165	const struct lb_select_tx_port *item;
	166
	167	item = &lb_select_tx_port_list[i];
	168	if (item->func == func)
	169	return item->name;
	170	}
	171	return NULL;
	172	}
	173
	174	static lb_select_tx_port_func_t lb_select_tx_port_get_func(const char name)
	175	{
	176	int i;
	177
	178	for (i = 0; i < LB_SELECT_TX_PORT_LIST_COUNT; i++) {
	179	const struct lb_select_tx_port *item;
	180
	181	item = &lb_select_tx_port_list[i];
	182	if (!strcmp(item->name, name))
	183	return item->func;
	184	}
	185	return NULL;
	186	}
	187
	188	static unsigned int lb_get_skb_hash(struct lb_priv *lb_priv,
	189	struct sk_buff *skb)
01d7f30a	190	{
7ae457c1	191	struct bpf_prog *fp;
596e2024 JP	192	uint32_t lhash;
	193	unsigned char *c;
	194
d1904fbd	195	fp = rcu_dereference_bh(lb_priv->fp);
596e2024 JP	196	if (unlikely(!fp))
596e2024 JP	197	return 0;
7ae457c1	198	lhash = BPF_PROG_RUN(fp, skb);
596e2024 JP	199	c = (char *) &lhash;
	200	return c[0] ^ c[1] ^ c[2] ^ c[3];
	201	}
	202
ab8250d7 JP	203	static void lb_update_tx_stats(unsigned int tx_bytes, struct lb_priv *lb_priv,
	204	struct lb_port_priv *lb_port_priv,
	205	unsigned char hash)
	206	{
	207	struct lb_pcpu_stats *pcpu_stats;
	208	struct lb_stats *port_stats;
	209	struct lb_stats *hash_stats;
	210
	211	pcpu_stats = this_cpu_ptr(lb_priv->pcpu_stats);
	212	port_stats = this_cpu_ptr(lb_port_priv->pcpu_stats);
	213	hash_stats = &pcpu_stats->hash_stats[hash];
	214	u64_stats_update_begin(&pcpu_stats->syncp);
	215	port_stats->tx_bytes += tx_bytes;
	216	hash_stats->tx_bytes += tx_bytes;
	217	u64_stats_update_end(&pcpu_stats->syncp);
	218	}
	219
596e2024 JP	220	static bool lb_transmit(struct team team, struct sk_buff skb)
596e2024 JP	221	{
ab8250d7 JP	222	struct lb_priv *lb_priv = get_lb_priv(team);
ab8250d7 JP	223	lb_select_tx_port_func_t *select_tx_port_func;
01d7f30a	224	struct team_port *port;
ab8250d7 JP	225	unsigned char hash;
ab8250d7 JP	226	unsigned int tx_bytes = skb->len;
01d7f30a	227
ab8250d7	228	hash = lb_get_skb_hash(lb_priv, skb);
d1904fbd	229	select_tx_port_func = rcu_dereference_bh(lb_priv->select_tx_port_func);
ab8250d7	230	port = select_tx_port_func(team, lb_priv, skb, hash);
01d7f30a JP	231	if (unlikely(!port))
01d7f30a JP	232	goto drop;
bd2d0837	233	if (team_dev_queue_xmit(team, port, skb))
01d7f30a	234	return false;
ab8250d7	235	lb_update_tx_stats(tx_bytes, lb_priv, get_lb_port_priv(port), hash);
01d7f30a JP	236	return true;
	237
	238	drop:
	239	dev_kfree_skb_any(skb);
	240	return false;
	241	}
	242
80f7c668	243	static int lb_bpf_func_get(struct team team, struct team_gsetter_ctx ctx)
01d7f30a	244	{
ab8250d7 JP	245	struct lb_priv *lb_priv = get_lb_priv(team);
	246
	247	if (!lb_priv->ex->orig_fprog) {
80f7c668 JP	248	ctx->data.bin_val.len = 0;
80f7c668 JP	249	ctx->data.bin_val.ptr = NULL;
01d7f30a	250	return 0;
80f7c668	251	}
ab8250d7	252	ctx->data.bin_val.len = lb_priv->ex->orig_fprog->len *
80f7c668	253	sizeof(struct sock_filter);
ab8250d7	254	ctx->data.bin_val.ptr = lb_priv->ex->orig_fprog->filter;
01d7f30a JP	255	return 0;
	256	}
	257
b1fcd35c	258	static int __fprog_create(struct sock_fprog_kern **pfprog, u32 data_len,
80f7c668	259	const void *data)
01d7f30a	260	{
b1fcd35c	261	struct sock_fprog_kern *fprog;
01d7f30a JP	262	struct sock_filter filter = (struct sock_filter ) data;
	263
	264	if (data_len % sizeof(struct sock_filter))
	265	return -EINVAL;
ea5930f4	266	fprog = kmalloc(sizeof(*fprog), GFP_KERNEL);
01d7f30a JP	267	if (!fprog)
	268	return -ENOMEM;
	269	fprog->filter = kmemdup(filter, data_len, GFP_KERNEL);
	270	if (!fprog->filter) {
	271	kfree(fprog);
	272	return -ENOMEM;
	273	}
	274	fprog->len = data_len / sizeof(struct sock_filter);
	275	*pfprog = fprog;
	276	return 0;
	277	}
	278
b1fcd35c	279	static void __fprog_destroy(struct sock_fprog_kern *fprog)
01d7f30a JP	280	{
	281	kfree(fprog->filter);
	282	kfree(fprog);
	283	}
	284
80f7c668	285	static int lb_bpf_func_set(struct team team, struct team_gsetter_ctx ctx)
01d7f30a	286	{
ab8250d7	287	struct lb_priv *lb_priv = get_lb_priv(team);
7ae457c1 AS	288	struct bpf_prog *fp = NULL;
7ae457c1 AS	289	struct bpf_prog *orig_fp = NULL;
b1fcd35c	290	struct sock_fprog_kern *fprog = NULL;
01d7f30a JP	291	int err;
01d7f30a JP	292
80f7c668 JP	293	if (ctx->data.bin_val.len) {
	294	err = __fprog_create(&fprog, ctx->data.bin_val.len,
	295	ctx->data.bin_val.ptr);
01d7f30a JP	296	if (err)
01d7f30a JP	297	return err;
7ae457c1	298	err = bpf_prog_create(&fp, fprog);
01d7f30a JP	299	if (err) {
	300	__fprog_destroy(fprog);
	301	return err;
	302	}
	303	}
	304
ab8250d7	305	if (lb_priv->ex->orig_fprog) {
01d7f30a	306	/* Clear old filter data */
ab8250d7	307	__fprog_destroy(lb_priv->ex->orig_fprog);
6dab015c JP	308	orig_fp = rcu_dereference_protected(lb_priv->fp,
6dab015c JP	309	lockdep_is_held(&team->lock));
01d7f30a JP	310	}
01d7f30a JP	311
ab8250d7 JP	312	rcu_assign_pointer(lb_priv->fp, fp);
ab8250d7 JP	313	lb_priv->ex->orig_fprog = fprog;
34c5bd66 PN	314
	315	if (orig_fp) {
	316	synchronize_rcu();
7ae457c1	317	bpf_prog_destroy(orig_fp);
34c5bd66	318	}
ab8250d7 JP	319	return 0;
	320	}
	321
	322	static int lb_tx_method_get(struct team team, struct team_gsetter_ctx ctx)
	323	{
	324	struct lb_priv *lb_priv = get_lb_priv(team);
6dab015c	325	lb_select_tx_port_func_t *func;
ab8250d7 JP	326	char *name;
ab8250d7 JP	327
6dab015c JP	328	func = rcu_dereference_protected(lb_priv->select_tx_port_func,
	329	lockdep_is_held(&team->lock));
	330	name = lb_select_tx_port_get_name(func);
ab8250d7 JP	331	BUG_ON(!name);
	332	ctx->data.str_val = name;
	333	return 0;
	334	}
	335
	336	static int lb_tx_method_set(struct team team, struct team_gsetter_ctx ctx)
	337	{
	338	struct lb_priv *lb_priv = get_lb_priv(team);
	339	lb_select_tx_port_func_t *func;
	340
	341	func = lb_select_tx_port_get_func(ctx->data.str_val);
	342	if (!func)
	343	return -EINVAL;
	344	rcu_assign_pointer(lb_priv->select_tx_port_func, func);
	345	return 0;
	346	}
	347
	348	static int lb_tx_hash_to_port_mapping_init(struct team *team,
	349	struct team_option_inst_info *info)
	350	{
	351	struct lb_priv *lb_priv = get_lb_priv(team);
	352	unsigned char hash = info->array_index;
	353
	354	LB_HTPM_OPT_INST_INFO_BY_HASH(lb_priv, hash) = info;
	355	return 0;
	356	}
	357
	358	static int lb_tx_hash_to_port_mapping_get(struct team *team,
	359	struct team_gsetter_ctx *ctx)
	360	{
	361	struct lb_priv *lb_priv = get_lb_priv(team);
	362	struct team_port *port;
	363	unsigned char hash = ctx->info->array_index;
	364
	365	port = LB_HTPM_PORT_BY_HASH(lb_priv, hash);
	366	ctx->data.u32_val = port ? port->dev->ifindex : 0;
	367	return 0;
	368	}
	369
	370	static int lb_tx_hash_to_port_mapping_set(struct team *team,
	371	struct team_gsetter_ctx *ctx)
	372	{
	373	struct lb_priv *lb_priv = get_lb_priv(team);
	374	struct team_port *port;
	375	unsigned char hash = ctx->info->array_index;
	376
	377	list_for_each_entry(port, &team->port_list, list) {
52a4fd77 JP	378	if (ctx->data.u32_val == port->dev->ifindex &&
52a4fd77 JP	379	team_port_enabled(port)) {
ab8250d7 JP	380	rcu_assign_pointer(LB_HTPM_PORT_BY_HASH(lb_priv, hash),
	381	port);
	382	return 0;
	383	}
	384	}
	385	return -ENODEV;
	386	}
	387
	388	static int lb_hash_stats_init(struct team *team,
	389	struct team_option_inst_info *info)
	390	{
	391	struct lb_priv *lb_priv = get_lb_priv(team);
	392	unsigned char hash = info->array_index;
	393
	394	lb_priv->ex->stats.info[hash].opt_inst_info = info;
	395	return 0;
	396	}
	397
	398	static int lb_hash_stats_get(struct team team, struct team_gsetter_ctx ctx)
	399	{
	400	struct lb_priv *lb_priv = get_lb_priv(team);
	401	unsigned char hash = ctx->info->array_index;
	402
	403	ctx->data.bin_val.ptr = &lb_priv->ex->stats.info[hash].stats;
	404	ctx->data.bin_val.len = sizeof(struct lb_stats);
	405	return 0;
	406	}
	407
	408	static int lb_port_stats_init(struct team *team,
	409	struct team_option_inst_info *info)
	410	{
	411	struct team_port *port = info->port;
	412	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
	413
	414	lb_port_priv->stats_info.opt_inst_info = info;
	415	return 0;
	416	}
	417
	418	static int lb_port_stats_get(struct team team, struct team_gsetter_ctx ctx)
	419	{
	420	struct team_port *port = ctx->info->port;
	421	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
	422
	423	ctx->data.bin_val.ptr = &lb_port_priv->stats_info.stats;
	424	ctx->data.bin_val.len = sizeof(struct lb_stats);
	425	return 0;
	426	}
	427
	428	static void __lb_stats_info_refresh_prepare(struct lb_stats_info *s_info)
	429	{
	430	memcpy(&s_info->last_stats, &s_info->stats, sizeof(struct lb_stats));
	431	memset(&s_info->stats, 0, sizeof(struct lb_stats));
	432	}
	433
	434	static bool __lb_stats_info_refresh_check(struct lb_stats_info *s_info,
	435	struct team *team)
	436	{
	437	if (memcmp(&s_info->last_stats, &s_info->stats,
	438	sizeof(struct lb_stats))) {
	439	team_option_inst_set_change(s_info->opt_inst_info);
	440	return true;
	441	}
	442	return false;
	443	}
444
445	static void __lb_one_cpu_stats_add(struct lb_stats *acc_stats,
446	struct lb_stats *cpu_stats,
447	struct u64_stats_sync *syncp)
448	{
449	unsigned int start;
450	struct lb_stats tmp;
451
452	do {
57a7744e	453	start = u64_stats_fetch_begin_irq(syncp);
ab8250d7	454	tmp.tx_bytes = cpu_stats->tx_bytes;
57a7744e	455	} while (u64_stats_fetch_retry_irq(syncp, start));
ab8250d7 JP	456	acc_stats->tx_bytes += tmp.tx_bytes;
	457	}
	458
	459	static void lb_stats_refresh(struct work_struct *work)
	460	{
	461	struct team *team;
	462	struct lb_priv *lb_priv;
	463	struct lb_priv_ex *lb_priv_ex;
	464	struct lb_pcpu_stats *pcpu_stats;
	465	struct lb_stats *stats;
	466	struct lb_stats_info *s_info;
	467	struct team_port *port;
	468	bool changed = false;
	469	int i;
	470	int j;
	471
	472	lb_priv_ex = container_of(work, struct lb_priv_ex,
	473	stats.refresh_dw.work);
	474
	475	team = lb_priv_ex->team;
	476	lb_priv = get_lb_priv(team);
	477
	478	if (!mutex_trylock(&team->lock)) {
	479	schedule_delayed_work(&lb_priv_ex->stats.refresh_dw, 0);
	480	return;
	481	}
	482
	483	for (j = 0; j < LB_TX_HASHTABLE_SIZE; j++) {
	484	s_info = &lb_priv->ex->stats.info[j];
	485	__lb_stats_info_refresh_prepare(s_info);
	486	for_each_possible_cpu(i) {
	487	pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
	488	stats = &pcpu_stats->hash_stats[j];
	489	__lb_one_cpu_stats_add(&s_info->stats, stats,
	490	&pcpu_stats->syncp);
	491	}
	492	changed \|= __lb_stats_info_refresh_check(s_info, team);
	493	}
	494
	495	list_for_each_entry(port, &team->port_list, list) {
	496	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
	497
	498	s_info = &lb_port_priv->stats_info;
	499	__lb_stats_info_refresh_prepare(s_info);
	500	for_each_possible_cpu(i) {
	501	pcpu_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
	502	stats = per_cpu_ptr(lb_port_priv->pcpu_stats, i);
	503	__lb_one_cpu_stats_add(&s_info->stats, stats,
	504	&pcpu_stats->syncp);
	505	}
	506	changed \|= __lb_stats_info_refresh_check(s_info, team);
	507	}
	508
	509	if (changed)
	510	team_options_change_check(team);
	511
	512	schedule_delayed_work(&lb_priv_ex->stats.refresh_dw,
	513	(lb_priv_ex->stats.refresh_interval * HZ) / 10);
	514
	515	mutex_unlock(&team->lock);
	516	}
	517
	518	static int lb_stats_refresh_interval_get(struct team *team,
	519	struct team_gsetter_ctx *ctx)
520	{
521	struct lb_priv *lb_priv = get_lb_priv(team);
522
523	ctx->data.u32_val = lb_priv->ex->stats.refresh_interval;
524	return 0;
525	}
526
527	static int lb_stats_refresh_interval_set(struct team *team,
528	struct team_gsetter_ctx *ctx)
529	{
530	struct lb_priv *lb_priv = get_lb_priv(team);
531	unsigned int interval;
532
533	interval = ctx->data.u32_val;
534	if (lb_priv->ex->stats.refresh_interval == interval)
535	return 0;
536	lb_priv->ex->stats.refresh_interval = interval;
537	if (interval)
538	schedule_delayed_work(&lb_priv->ex->stats.refresh_dw, 0);
539	else
540	cancel_delayed_work(&lb_priv->ex->stats.refresh_dw);
01d7f30a JP	541	return 0;
	542	}
	543
	544	static const struct team_option lb_options[] = {
	545	{
	546	.name = "bpf_hash_func",
	547	.type = TEAM_OPTION_TYPE_BINARY,
	548	.getter = lb_bpf_func_get,
	549	.setter = lb_bpf_func_set,
	550	},
ab8250d7 JP	551	{
	552	.name = "lb_tx_method",
	553	.type = TEAM_OPTION_TYPE_STRING,
	554	.getter = lb_tx_method_get,
	555	.setter = lb_tx_method_set,
	556	},
	557	{
	558	.name = "lb_tx_hash_to_port_mapping",
	559	.array_size = LB_TX_HASHTABLE_SIZE,
	560	.type = TEAM_OPTION_TYPE_U32,
	561	.init = lb_tx_hash_to_port_mapping_init,
	562	.getter = lb_tx_hash_to_port_mapping_get,
	563	.setter = lb_tx_hash_to_port_mapping_set,
	564	},
	565	{
	566	.name = "lb_hash_stats",
	567	.array_size = LB_TX_HASHTABLE_SIZE,
	568	.type = TEAM_OPTION_TYPE_BINARY,
	569	.init = lb_hash_stats_init,
	570	.getter = lb_hash_stats_get,
	571	},
	572	{
	573	.name = "lb_port_stats",
	574	.per_port = true,
	575	.type = TEAM_OPTION_TYPE_BINARY,
	576	.init = lb_port_stats_init,
	577	.getter = lb_port_stats_get,
	578	},
	579	{
	580	.name = "lb_stats_refresh_interval",
	581	.type = TEAM_OPTION_TYPE_U32,
	582	.getter = lb_stats_refresh_interval_get,
	583	.setter = lb_stats_refresh_interval_set,
	584	},
01d7f30a JP	585	};
01d7f30a JP	586
cade4555	587	static int lb_init(struct team *team)
01d7f30a	588	{
ab8250d7 JP	589	struct lb_priv *lb_priv = get_lb_priv(team);
ab8250d7 JP	590	lb_select_tx_port_func_t *func;
827da44c	591	int i, err;
ab8250d7 JP	592
	593	/* set default tx port selector */
	594	func = lb_select_tx_port_get_func("hash");
	595	BUG_ON(!func);
	596	rcu_assign_pointer(lb_priv->select_tx_port_func, func);
	597
	598	lb_priv->ex = kzalloc(sizeof(*lb_priv->ex), GFP_KERNEL);
	599	if (!lb_priv->ex)
	600	return -ENOMEM;
	601	lb_priv->ex->team = team;
	602
	603	lb_priv->pcpu_stats = alloc_percpu(struct lb_pcpu_stats);
	604	if (!lb_priv->pcpu_stats) {
	605	err = -ENOMEM;
	606	goto err_alloc_pcpu_stats;
	607	}
	608
827da44c JS	609	for_each_possible_cpu(i) {
	610	struct lb_pcpu_stats *team_lb_stats;
	611	team_lb_stats = per_cpu_ptr(lb_priv->pcpu_stats, i);
	612	u64_stats_init(&team_lb_stats->syncp);
	613	}
	614
	615
ab8250d7 JP	616	INIT_DELAYED_WORK(&lb_priv->ex->stats.refresh_dw, lb_stats_refresh);
	617
	618	err = team_options_register(team, lb_options, ARRAY_SIZE(lb_options));
	619	if (err)
	620	goto err_options_register;
	621	return 0;
	622
	623	err_options_register:
	624	free_percpu(lb_priv->pcpu_stats);
	625	err_alloc_pcpu_stats:
	626	kfree(lb_priv->ex);
	627	return err;
01d7f30a JP	628	}
01d7f30a JP	629
cade4555	630	static void lb_exit(struct team *team)
01d7f30a	631	{
ab8250d7 JP	632	struct lb_priv *lb_priv = get_lb_priv(team);
ab8250d7 JP	633
01d7f30a JP	634	team_options_unregister(team, lb_options,
01d7f30a JP	635	ARRAY_SIZE(lb_options));
ab8250d7 JP	636	cancel_delayed_work_sync(&lb_priv->ex->stats.refresh_dw);
	637	free_percpu(lb_priv->pcpu_stats);
	638	kfree(lb_priv->ex);
	639	}
	640
	641	static int lb_port_enter(struct team team, struct team_port port)
	642	{
	643	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
	644
	645	lb_port_priv->pcpu_stats = alloc_percpu(struct lb_stats);
	646	if (!lb_port_priv->pcpu_stats)
	647	return -ENOMEM;
	648	return 0;
	649	}
	650
	651	static void lb_port_leave(struct team team, struct team_port port)
	652	{
	653	struct lb_port_priv *lb_port_priv = get_lb_port_priv(port);
	654
	655	free_percpu(lb_port_priv->pcpu_stats);
	656	}
	657
	658	static void lb_port_disabled(struct team team, struct team_port port)
	659	{
	660	lb_tx_hash_to_port_mapping_null_port(team, port);
01d7f30a JP	661	}
01d7f30a JP	662
01d7f30a JP	663	static const struct team_mode_ops lb_mode_ops = {
	664	.init = lb_init,
	665	.exit = lb_exit,
ab8250d7 JP	666	.port_enter = lb_port_enter,
	667	.port_leave = lb_port_leave,
	668	.port_disabled = lb_port_disabled,
c15e07b0	669	.receive = lb_receive,
01d7f30a	670	.transmit = lb_transmit,
01d7f30a JP	671	};
01d7f30a JP	672
0402788a	673	static const struct team_mode lb_mode = {
01d7f30a JP	674	.kind = "loadbalance",
	675	.owner = THIS_MODULE,
	676	.priv_size = sizeof(struct lb_priv),
ab8250d7	677	.port_priv_size = sizeof(struct lb_port_priv),
01d7f30a	678	.ops = &lb_mode_ops,
8fd72856	679	.lag_tx_type = NETDEV_LAG_TX_TYPE_HASH,
01d7f30a JP	680	};
	681
	682	static int __init lb_init_module(void)
	683	{
	684	return team_mode_register(&lb_mode);
	685	}
	686
	687	static void __exit lb_cleanup_module(void)
	688	{
	689	team_mode_unregister(&lb_mode);
	690	}
	691
	692	module_init(lb_init_module);
	693	module_exit(lb_cleanup_module);
	694
	695	MODULE_LICENSE("GPL v2");
	696	MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
	697	MODULE_DESCRIPTION("Load-balancing mode for team");
	698	MODULE_ALIAS("team-mode-loadbalance");