* [PATCH v5 6/8] tcp buffer limitation: per-cgroup limit
From: Glauber Costa @ 2011-10-04 12:17 UTC (permalink / raw)
To: linux-kernel
Cc: paul, lizf, kamezawa.hiroyu, ebiederm, davem, gthelen, netdev,
linux-mm, kirill, avagin, devel, Glauber Costa
In-Reply-To: <1317730680-24352-1-git-send-email-glommer@parallels.com>
This patch uses the "tcp_max_mem" field of the kmem_cgroup to
effectively control the amount of kernel memory pinned by a cgroup.
We have to make sure that none of the memory pressure thresholds
specified in the namespace are bigger than the current cgroup.
Signed-off-by: Glauber Costa <glommer@parallels.com>
CC: David S. Miller <davem@davemloft.net>
CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com>
CC: Eric W. Biederman <ebiederm@xmission.com>
---
Documentation/cgroups/memory.txt | 1 +
include/linux/memcontrol.h | 10 +++++
include/net/tcp.h | 1 +
mm/memcontrol.c | 80 +++++++++++++++++++++++++++++++++++---
net/ipv4/sysctl_net_ipv4.c | 20 +++++++++
5 files changed, 106 insertions(+), 6 deletions(-)
diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt
index bf00cd2..c1db134 100644
--- a/Documentation/cgroups/memory.txt
+++ b/Documentation/cgroups/memory.txt
@@ -78,6 +78,7 @@ Brief summary of control files.
memory.independent_kmem_limit # select whether or not kernel memory limits are
independent of user limits
+ memory.kmem.tcp.limit_in_bytes # set/show hard limit for tcp buf memory
1. History
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 50af61d..6191ba1 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -395,6 +395,9 @@ int tcp_init_cgroup(struct proto *prot, struct cgroup *cgrp,
struct cgroup_subsys *ss);
void tcp_destroy_cgroup(struct proto *prot, struct cgroup *cgrp,
struct cgroup_subsys *ss);
+
+unsigned long tcp_max_memory(struct mem_cgroup *cg);
+void tcp_prot_mem(struct mem_cgroup *cg, long val, int idx);
#else
/* memcontrol includes sockets.h, that includes memcontrol.h ... */
static inline void memcg_sock_mem_alloc(struct mem_cgroup *memcg,
@@ -420,6 +423,13 @@ static inline void sock_update_memcg(struct sock *sk)
static inline void sock_release_memcg(struct sock *sk)
{
}
+static inline unsigned long tcp_max_memory(struct mem_cgroup *cg)
+{
+ return 0;
+}
+static inline void tcp_prot_mem(struct mem_cgroup *cg, long val, int idx)
+{
+}
#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
#endif /* CONFIG_INET */
#endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 04fedf7..716a42e 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -256,6 +256,7 @@ extern int sysctl_tcp_thin_dupack;
struct mem_cgroup;
struct tcp_memcontrol {
/* per-cgroup tcp memory pressure knobs */
+ int tcp_max_memory;
atomic_long_t tcp_memory_allocated;
struct percpu_counter tcp_sockets_allocated;
/* those two are read-mostly, leave them at the end */
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 39e575e..6fb14bb 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -304,6 +304,13 @@ struct mem_cgroup {
};
static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
+
+static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
+{
+ return (memcg == root_mem_cgroup);
+}
+
+static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *mem);
/* Writing them here to avoid exposing memcg's inner layout */
#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
#ifdef CONFIG_INET
@@ -424,6 +431,48 @@ struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg)
}
EXPORT_SYMBOL(sockets_allocated_tcp);
+static int tcp_write_limit(struct cgroup *cgrp, struct cftype *cft, u64 val)
+{
+ struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+ struct mem_cgroup *parent = parent_mem_cgroup(memcg);
+ struct net *net = current->nsproxy->net_ns;
+ int i;
+
+ if (parent && parent->use_hierarchy)
+ return -EINVAL;
+
+ /*
+ * We can't allow more memory than our parents. Since this
+ * will be tested for all calls, by induction, there is no need
+ * to test any parent other than our own
+ * */
+ val >>= PAGE_SHIFT;
+ if (parent && (val > parent->tcp.tcp_max_memory))
+ val = parent->tcp.tcp_max_memory;
+
+ memcg->tcp.tcp_max_memory = val;
+
+ for (i = 0; i < 3; i++)
+ memcg->tcp.tcp_prot_mem[i] = min_t(long, val,
+ net->ipv4.sysctl_tcp_mem[i]);
+
+ return 0;
+}
+
+static u64 tcp_read_limit(struct cgroup *cgrp, struct cftype *cft)
+{
+ struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+ return memcg->tcp.tcp_max_memory << PAGE_SHIFT;
+}
+
+static struct cftype tcp_files[] = {
+ {
+ .name = "kmem.tcp.limit_in_bytes",
+ .write_u64 = tcp_write_limit,
+ .read_u64 = tcp_read_limit,
+ },
+};
+
static void tcp_create_cgroup(struct mem_cgroup *cg, struct cgroup_subsys *ss)
{
cg->tcp.tcp_memory_pressure = 0;
@@ -435,6 +484,7 @@ int tcp_init_cgroup(struct proto *prot, struct cgroup *cgrp,
struct cgroup_subsys *ss)
{
struct mem_cgroup *cg = mem_cgroup_from_cont(cgrp);
+ struct mem_cgroup *parent = parent_mem_cgroup(cg);
struct net *net = current->nsproxy->net_ns;
/*
* We need to initialize it at populate, not create time.
@@ -445,6 +495,20 @@ int tcp_init_cgroup(struct proto *prot, struct cgroup *cgrp,
cg->tcp.tcp_prot_mem[1] = net->ipv4.sysctl_tcp_mem[1];
cg->tcp.tcp_prot_mem[2] = net->ipv4.sysctl_tcp_mem[2];
+
+ if (parent && parent->use_hierarchy)
+ cg->tcp.tcp_max_memory = parent->tcp.tcp_max_memory;
+ else {
+ unsigned long limit;
+ limit = nr_free_buffer_pages() / 8;
+ limit = max(limit, 128UL);
+ cg->tcp.tcp_max_memory = limit * 2;
+ }
+
+
+ if (!mem_cgroup_is_root(cg))
+ return cgroup_add_files(cgrp, ss, tcp_files,
+ ARRAY_SIZE(tcp_files));
return 0;
}
EXPORT_SYMBOL(tcp_init_cgroup);
@@ -457,6 +521,16 @@ void tcp_destroy_cgroup(struct proto *prot, struct cgroup *cgrp,
percpu_counter_destroy(&cg->tcp.tcp_sockets_allocated);
}
EXPORT_SYMBOL(tcp_destroy_cgroup);
+
+unsigned long tcp_max_memory(struct mem_cgroup *memcg)
+{
+ return memcg->tcp.tcp_max_memory;
+}
+
+void tcp_prot_mem(struct mem_cgroup *memcg, long val, int idx)
+{
+ memcg->tcp.tcp_prot_mem[idx] = val;
+}
#endif /* CONFIG_INET */
#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
@@ -1035,12 +1109,6 @@ static struct mem_cgroup *mem_cgroup_get_next(struct mem_cgroup *iter,
#define for_each_mem_cgroup_all(iter) \
for_each_mem_cgroup_tree_cond(iter, NULL, true)
-
-static inline bool mem_cgroup_is_root(struct mem_cgroup *mem)
-{
- return (mem == root_mem_cgroup);
-}
-
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
{
struct mem_cgroup *mem;
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index bbd67ab..cdc35f6 100644
--- a/net/ipv4/sysctl_net_ipv4.c
+++ b/net/ipv4/sysctl_net_ipv4.c
@@ -14,6 +14,7 @@
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/nsproxy.h>
+#include <linux/memcontrol.h>
#include <linux/swap.h>
#include <net/snmp.h>
#include <net/icmp.h>
@@ -182,6 +183,10 @@ static int ipv4_tcp_mem(ctl_table *ctl, int write,
int ret;
unsigned long vec[3];
struct net *net = current->nsproxy->net_ns;
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
+ int i;
+ struct mem_cgroup *cg;
+#endif
ctl_table tmp = {
.data = &vec,
@@ -198,6 +203,21 @@ static int ipv4_tcp_mem(ctl_table *ctl, int write,
if (ret)
return ret;
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
+ rcu_read_lock();
+ cg = mem_cgroup_from_task(current);
+ for (i = 0; i < 3; i++)
+ if (vec[i] > tcp_max_memory(cg)) {
+ rcu_read_unlock();
+ return -EINVAL;
+ }
+
+ tcp_prot_mem(cg, vec[0], 0);
+ tcp_prot_mem(cg, vec[1], 1);
+ tcp_prot_mem(cg, vec[2], 2);
+ rcu_read_unlock();
+#endif
+
net->ipv4.sysctl_tcp_mem[0] = vec[0];
net->ipv4.sysctl_tcp_mem[1] = vec[1];
net->ipv4.sysctl_tcp_mem[2] = vec[2];
--
1.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related
* [PATCH v5 7/8] Display current tcp memory allocation in kmem cgroup
From: Glauber Costa @ 2011-10-04 12:17 UTC (permalink / raw)
To: linux-kernel
Cc: paul, lizf, kamezawa.hiroyu, ebiederm, davem, gthelen, netdev,
linux-mm, kirill, avagin, devel, Glauber Costa
In-Reply-To: <1317730680-24352-1-git-send-email-glommer@parallels.com>
This patch introduces kmem.tcp_current_memory file, living in the
kmem_cgroup filesystem. It is a simple read-only file that displays the
amount of kernel memory currently consumed by the cgroup.
Signed-off-by: Glauber Costa <glommer@parallels.com>
CC: David S. Miller <davem@davemloft.net>
CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com>
CC: Eric W. Biederman <ebiederm@xmission.com>
---
Documentation/cgroups/memory.txt | 1 +
mm/memcontrol.c | 11 +++++++++++
2 files changed, 12 insertions(+), 0 deletions(-)
diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt
index c1db134..00f1a88 100644
--- a/Documentation/cgroups/memory.txt
+++ b/Documentation/cgroups/memory.txt
@@ -79,6 +79,7 @@ Brief summary of control files.
memory.independent_kmem_limit # select whether or not kernel memory limits are
independent of user limits
memory.kmem.tcp.limit_in_bytes # set/show hard limit for tcp buf memory
+ memory.kmem.tcp.usage_in_bytes # show current tcp buf memory allocation
1. History
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 6fb14bb..f178a64 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -465,12 +465,23 @@ static u64 tcp_read_limit(struct cgroup *cgrp, struct cftype *cft)
return memcg->tcp.tcp_max_memory << PAGE_SHIFT;
}
+static u64 tcp_usage_in_bytes(struct cgroup *cgrp, struct cftype *cft)
+{
+ struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
+
+ return atomic_long_read(&memcg->tcp.tcp_memory_allocated) << PAGE_SHIFT;
+}
+
static struct cftype tcp_files[] = {
{
.name = "kmem.tcp.limit_in_bytes",
.write_u64 = tcp_write_limit,
.read_u64 = tcp_read_limit,
},
+ {
+ .name = "kmem.tcp.usage_in_bytes",
+ .read_u64 = tcp_usage_in_bytes,
+ },
};
static void tcp_create_cgroup(struct mem_cgroup *cg, struct cgroup_subsys *ss)
--
1.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related
* [PATCH v5 8/8] Disable task moving when using kernel memory accounting
From: Glauber Costa @ 2011-10-04 12:18 UTC (permalink / raw)
To: linux-kernel
Cc: paul, lizf, kamezawa.hiroyu, ebiederm, davem, gthelen, netdev,
linux-mm, kirill, avagin, devel, Glauber Costa
In-Reply-To: <1317730680-24352-1-git-send-email-glommer@parallels.com>
Since this code is still experimental, we are leaving the exact
details of how to move tasks between cgroups when kernel memory
accounting is used as future work.
For now, we simply disallow movement if there are any pending
accounted memory.
Signed-off-by: Glauber Costa <glommer@parallels.com>
CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com>
---
include/net/tcp.h | 1 +
mm/memcontrol.c | 37 ++++++++++++++++++++++---------------
2 files changed, 23 insertions(+), 15 deletions(-)
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 716a42e..62ad282 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -257,6 +257,7 @@ struct mem_cgroup;
struct tcp_memcontrol {
/* per-cgroup tcp memory pressure knobs */
int tcp_max_memory;
+ atomic_t refcnt;
atomic_long_t tcp_memory_allocated;
struct percpu_counter tcp_sockets_allocated;
/* those two are read-mostly, leave them at the end */
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index f178a64..db1f511 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -328,28 +328,17 @@ void sock_update_memcg(struct sock *sk)
rcu_read_lock();
sk->sk_cgrp = mem_cgroup_from_task(current);
-
- /*
- * We don't need to protect against anything task-related, because
- * we are basically stuck with the sock pointer that won't change,
- * even if the task that originated the socket changes cgroups.
- *
- * What we do have to guarantee, is that the chain leading us to
- * the top level won't change under our noses. Incrementing the
- * reference count via cgroup_exclude_rmdir guarantees that.
- */
- cgroup_exclude_rmdir(mem_cgroup_css(sk->sk_cgrp));
rcu_read_unlock();
}
void sock_release_memcg(struct sock *sk)
{
- cgroup_release_and_wakeup_rmdir(mem_cgroup_css(sk->sk_cgrp));
}
void memcg_sock_mem_alloc(struct mem_cgroup *memcg, struct proto *prot,
int amt, int *parent_failure)
{
+ atomic_inc(&memcg->tcp.refcnt);
memcg = parent_mem_cgroup(memcg);
for (; memcg != NULL; memcg = parent_mem_cgroup(memcg)) {
long alloc;
@@ -368,9 +357,12 @@ EXPORT_SYMBOL(memcg_sock_mem_alloc);
void memcg_sock_mem_free(struct mem_cgroup *memcg, struct proto *prot, int amt)
{
- memcg = parent_mem_cgroup(memcg);
- for (; memcg != NULL; memcg = parent_mem_cgroup(memcg))
- atomic_long_sub(amt, prot->memory_allocated(memcg));
+ struct mem_cgroup *parent;
+ parent = parent_mem_cgroup(memcg);
+ for (; parent != NULL; parent = parent_mem_cgroup(parent))
+ atomic_long_sub(amt, prot->memory_allocated(parent));
+
+ atomic_dec(&memcg->tcp.refcnt);
}
EXPORT_SYMBOL(memcg_sock_mem_free);
@@ -488,6 +480,7 @@ static void tcp_create_cgroup(struct mem_cgroup *cg, struct cgroup_subsys *ss)
{
cg->tcp.tcp_memory_pressure = 0;
atomic_long_set(&cg->tcp.tcp_memory_allocated, 0);
+ atomic_set(&cg->tcp.refcnt, 0);
percpu_counter_init(&cg->tcp.tcp_sockets_allocated, 0);
}
@@ -5633,6 +5626,12 @@ static int mem_cgroup_can_attach(struct cgroup_subsys *ss,
int ret = 0;
struct mem_cgroup *mem = mem_cgroup_from_cont(cgroup);
+ if (atomic_read(&mem->tcp.refcnt)) {
+ printk(KERN_WARNING "Can't move tasks between cgroups: "
+ "Kernel memory held. task: %s\n", p->comm);
+ return 1;
+ }
+
if (mem->move_charge_at_immigrate) {
struct mm_struct *mm;
struct mem_cgroup *from = mem_cgroup_from_task(p);
@@ -5803,6 +5802,14 @@ static int mem_cgroup_can_attach(struct cgroup_subsys *ss,
struct cgroup *cgroup,
struct task_struct *p)
{
+ struct mem_cgroup *mem = mem_cgroup_from_cont(cgroup);
+
+ if (atomic_read(&mem->tcp.refcnt)) {
+ printk(KERN_WARNING "Can't move tasks between cgroups: "
+ "Kernel memory held. task: %s\n", p->comm);
+ return 1;
+ }
+
return 0;
}
static void mem_cgroup_cancel_attach(struct cgroup_subsys *ss,
--
1.7.6
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply related
* Re: [PATCH v5 6/8] tcp buffer limitation: per-cgroup limit
From: Eric Dumazet @ 2011-10-04 12:48 UTC (permalink / raw)
To: Glauber Costa
Cc: linux-kernel, paul, lizf, kamezawa.hiroyu, ebiederm, davem,
gthelen, netdev, linux-mm, kirill, avagin, devel
In-Reply-To: <1317730680-24352-7-git-send-email-glommer@parallels.com>
Le mardi 04 octobre 2011 à 16:17 +0400, Glauber Costa a écrit :
> This patch uses the "tcp_max_mem" field of the kmem_cgroup to
> effectively control the amount of kernel memory pinned by a cgroup.
>
> We have to make sure that none of the memory pressure thresholds
> specified in the namespace are bigger than the current cgroup.
>
> Signed-off-by: Glauber Costa <glommer@parallels.com>
> CC: David S. Miller <davem@davemloft.net>
> CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com>
> CC: Eric W. Biederman <ebiederm@xmission.com>
> ---
> --- a/include/net/tcp.h
> +++ b/include/net/tcp.h
> @@ -256,6 +256,7 @@ extern int sysctl_tcp_thin_dupack;
> struct mem_cgroup;
> struct tcp_memcontrol {
> /* per-cgroup tcp memory pressure knobs */
> + int tcp_max_memory;
> atomic_long_t tcp_memory_allocated;
> struct percpu_counter tcp_sockets_allocated;
> /* those two are read-mostly, leave them at the end */
> diff --git a/mm/memcontrol.c b/mm/memcontrol.c
So tcp_max_memory is an "int".
> +static u64 tcp_read_limit(struct cgroup *cgrp, struct cftype *cft)
> +{
> + struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp);
> + return memcg->tcp.tcp_max_memory << PAGE_SHIFT;
> +}
1) Typical integer overflow here.
You need :
return ((u64)memcg->tcp.tcp_max_memory) << PAGE_SHIFT;
2) Could you add const qualifiers when possible to your pointers ?
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to majordomo@kvack.org. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"dont@kvack.org"> email@kvack.org </a>
^ permalink raw reply
* [PATCH] x25: Validate incoming call user data lengths
From: Matthew Daley @ 2011-10-04 14:00 UTC (permalink / raw)
To: netdev; +Cc: Eric Dumazet, Andrew Hendry
X.25 call user data is being copied in its entirety from incoming messages
without consideration to the size of the destination buffers, leading to
possible buffer overflows. Validate incoming call user data lengths before
these copies are performed.
It appears this issue was noticed some time ago, however nothing seemed to
come of it: see http://www.spinics.net/lists/linux-x25/msg00043.html and
commit 8db09f26f912f7c90c764806e804b558da520d4f.
Signed-off-by: Matthew Daley <mattjd@gmail.com>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Andrew Hendry <andrew.hendry@gmail.com>
Cc: stable <stable@kernel.org>
---
Hopefully this is acceptable; I thought someone with greater knowledge of
X.25 might step in :) It should take into account Andrew's suggestion to
move af_x25.c's check to before the call acception.
net/x25/af_x25.c | 6 ++++++
net/x25/x25_in.c | 3 +++
2 files changed, 9 insertions(+), 0 deletions(-)
diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c
index d306154..a4bd172 100644
--- a/net/x25/af_x25.c
+++ b/net/x25/af_x25.c
@@ -959,6 +959,12 @@ int x25_rx_call_request(struct sk_buff *skb,
struct x25_neigh *nb,
skb_pull(skb,len);
/*
+ * Ensure that the amount of call user data is valid.
+ */
+ if (skb->len > X25_MAX_CUD_LEN)
+ goto out_clear_request;
+
+ /*
* Find a listener for the particular address/cud pair.
*/
sk = x25_find_listener(&source_addr,skb);
diff --git a/net/x25/x25_in.c b/net/x25/x25_in.c
index 0b073b5..63488fd 100644
--- a/net/x25/x25_in.c
+++ b/net/x25/x25_in.c
@@ -127,6 +127,9 @@ static int x25_state1_machine(struct sock *sk,
struct sk_buff *skb, int frametyp
* Copy any Call User Data.
*/
if (skb->len > 0) {
+ if (skb->len > X25_MAX_CUD_LEN)
+ goto out_clear;
+
skb_copy_from_linear_data(skb,
x25->calluserdata.cuddata,
skb->len);
--
1.7.2.5
^ permalink raw reply related
* [PATCH] net: fix typos in Documentation/networking/scaling.txt
From: Benjamin Poirier @ 2011-10-04 14:00 UTC (permalink / raw)
To: netdev, davem; +Cc: linux-doc, Willem de Bruijn
The second hunk fixes rps_sock_flow_table but has to re-wrap the paragraph.
Signed-off-by: Benjamin Poirier <benjamin.poirier@gmail.com>
---
Documentation/networking/scaling.txt | 10 +++++-----
1 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/Documentation/networking/scaling.txt b/Documentation/networking/scaling.txt
index 8ce7c30..fe67b5c 100644
--- a/Documentation/networking/scaling.txt
+++ b/Documentation/networking/scaling.txt
@@ -27,7 +27,7 @@ applying a filter to each packet that assigns it to one of a small number
of logical flows. Packets for each flow are steered to a separate receive
queue, which in turn can be processed by separate CPUs. This mechanism is
generally known as “Receive-side Scaling” (RSS). The goal of RSS and
-the other scaling techniques to increase performance uniformly.
+the other scaling techniques is to increase performance uniformly.
Multi-queue distribution can also be used for traffic prioritization, but
that is not the focus of these techniques.
@@ -186,10 +186,10 @@ are steered using plain RPS. Multiple table entries may point to the
same CPU. Indeed, with many flows and few CPUs, it is very likely that
a single application thread handles flows with many different flow hashes.
-rps_sock_table is a global flow table that contains the *desired* CPU for
-flows: the CPU that is currently processing the flow in userspace. Each
-table value is a CPU index that is updated during calls to recvmsg and
-sendmsg (specifically, inet_recvmsg(), inet_sendmsg(), inet_sendpage()
+rps_sock_flow_table is a global flow table that contains the *desired* CPU
+for flows: the CPU that is currently processing the flow in userspace.
+Each table value is a CPU index that is updated during calls to recvmsg
+and sendmsg (specifically, inet_recvmsg(), inet_sendmsg(), inet_sendpage()
and tcp_splice_read()).
When the scheduler moves a thread to a new CPU while it has outstanding
--
1.7.6.3
^ permalink raw reply related
* [patch net-next-2.6] net: introduce ethernet teaming device
From: Jiri Pirko @ 2011-10-04 14:15 UTC (permalink / raw)
To: netdev
Cc: davem, eric.dumazet, bhutchings, shemminger, fubar, andy, tgraf,
ebiederm, mirqus, kaber, greearb, jesse
This patch introduces new network device called team. It supposes to be
very fast, simple, userspace-driven alternative to existing bonding
driver.
Userspace library called libteam with couple of demo apps is available
here:
https://github.com/jpirko/libteam
Note it's still in its dipers atm.
team<->libteam use generic netlink for communication. That and rtnl
suppose to be the only way to configure team device, no sysfs etc.
In near future python binding for libteam will be introduced. Also
daemon providing arpmon/miimon active-backup functionality will
be introduced. All what's necessary is already implemented in kernel team
driver.
Signed-off-by: Jiri Pirko <jpirko@redhat.com>
---
Documentation/networking/team.txt | 2 +
MAINTAINERS | 7 +
drivers/net/Kconfig | 15 +
drivers/net/Makefile | 1 +
drivers/net/team.c | 1819 +++++++++++++++++++++++++++++++++++++
include/linux/Kbuild | 1 +
include/linux/if.h | 1 +
include/linux/if_team.h | 126 +++
8 files changed, 1972 insertions(+), 0 deletions(-)
create mode 100644 Documentation/networking/team.txt
create mode 100644 drivers/net/team.c
create mode 100644 include/linux/if_team.h
diff --git a/Documentation/networking/team.txt b/Documentation/networking/team.txt
new file mode 100644
index 0000000..5a01368
--- /dev/null
+++ b/Documentation/networking/team.txt
@@ -0,0 +1,2 @@
+Team devices are driven from userspace via libteam library which is here:
+ https://github.com/jpirko/libteam
diff --git a/MAINTAINERS b/MAINTAINERS
index 65ca7ea..f846c6b 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -6372,6 +6372,13 @@ W: http://tcp-lp-mod.sourceforge.net/
S: Maintained
F: net/ipv4/tcp_lp.c
+TEAM DRIVER
+M: Jiri Pirko <jpirko@redhat.com>
+L: netdev@vger.kernel.org
+S: Supported
+F: drivers/net/team.c
+F: include/linux/team.h
+
TEGRA SUPPORT
M: Colin Cross <ccross@android.com>
M: Erik Gilling <konkers@android.com>
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 583f66c..0d74e9d 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -125,6 +125,21 @@ config IFB
'ifb1' etc.
Look at the iproute2 documentation directory for usage etc
+config NET_TEAM
+ tristate "Ethernet teaming support (EXPERIMENTAL)"
+ depends on EXPERIMENTAL
+ ---help---
+ This allows one to create virtual interfaces that teams together
+ multiple ethernet devices.
+
+ Team devices can be added using the "ip" command from the
+ iproute2 package:
+
+ "ip link add link [ address MAC ] [ NAME ] type team"
+
+ To compile this driver as a module, choose M here: the module
+ will be called team.
+
config MACVLAN
tristate "MAC-VLAN support (EXPERIMENTAL)"
depends on EXPERIMENTAL
diff --git a/drivers/net/Makefile b/drivers/net/Makefile
index fa877cd..e3d3e81 100644
--- a/drivers/net/Makefile
+++ b/drivers/net/Makefile
@@ -17,6 +17,7 @@ obj-$(CONFIG_NET) += Space.o loopback.o
obj-$(CONFIG_NETCONSOLE) += netconsole.o
obj-$(CONFIG_PHYLIB) += phy/
obj-$(CONFIG_RIONET) += rionet.o
+obj-$(CONFIG_NET_TEAM) += team.o
obj-$(CONFIG_TUN) += tun.o
obj-$(CONFIG_VETH) += veth.o
obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
diff --git a/drivers/net/team.c b/drivers/net/team.c
new file mode 100644
index 0000000..c9ae388
--- /dev/null
+++ b/drivers/net/team.c
@@ -0,0 +1,1819 @@
+/*
+ * net/drivers/team.c - Network team device driver
+ * Copyright (c) 2011 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/slab.h>
+#include <linux/rcupdate.h>
+#include <linux/errno.h>
+#include <linux/notifier.h>
+#include <linux/netdevice.h>
+#include <linux/if_arp.h>
+#include <linux/socket.h>
+#include <linux/etherdevice.h>
+#include <linux/rtnetlink.h>
+#include <net/rtnetlink.h>
+#include <net/genetlink.h>
+#include <net/netlink.h>
+#include <linux/if_team.h>
+
+#define DRV_NAME "team"
+
+
+/*************************************
+ * Structures and helpers definitions
+ *************************************/
+
+struct team;
+
+struct team_port {
+ struct net_device *dev;
+ struct hlist_node hlist; /* node in hash list */
+ struct list_head list; /* node in ordinary list */
+ struct team *team;
+ int index;
+
+ /*
+ * A place for storing original values of the device before it
+ * become a port.
+ */
+ struct {
+ unsigned char dev_addr[MAX_ADDR_LEN];
+ unsigned int mtu;
+ } orig;
+
+ bool linkup;
+ u32 speed;
+ u8 duplex;
+
+ struct rcu_head rcu;
+};
+
+struct team_mode_ops {
+ int (*init)(struct team *team);
+ void (*exit)(struct team *team);
+ rx_handler_result_t (*receive)(struct team *team,
+ struct team_port *port,
+ struct sk_buff *skb);
+ bool (*transmit)(struct team *team, struct sk_buff *skb);
+ int (*port_enter)(struct team *team, struct team_port *port);
+ void (*port_leave)(struct team *team, struct team_port *port);
+ void (*port_change_mac)(struct team *team, struct team_port *port);
+};
+
+enum team_option_type {
+ TEAM_OPTION_TYPE_U32,
+ TEAM_OPTION_TYPE_STRING,
+};
+
+struct team_option {
+ struct list_head list;
+ const char *name;
+ enum team_option_type type;
+ int (*getter)(struct team *team, void *arg);
+ int (*setter)(struct team *team, void *arg);
+};
+
+struct team_mode {
+ const char *kind;
+ const struct team_mode_ops *ops;
+};
+
+struct rr_priv {
+ unsigned int sent_packets;
+};
+
+struct ab_priv {
+ struct team_port __rcu *active_port;
+};
+
+struct team {
+ struct net_device *dev; /* associated netdevice */
+ spinlock_t lock; /* used for overall locking, e.g. port lists write */
+
+ /*
+ * port lists with port count
+ */
+ int port_count;
+ struct hlist_head *port_hlist;
+ struct list_head port_list;
+
+ struct list_head option_list;
+
+ const char *mode_kind;
+ struct team_mode_ops mode_ops;
+ union {
+ char priv_first_byte;
+ struct ab_priv ab_priv;
+ struct rr_priv rr_priv;
+ };
+};
+
+#define TEAM_PORT_HASHBITS 4
+#define TEAM_PORT_HASHENTRIES (1 << TEAM_PORT_HASHBITS)
+
+static struct hlist_head *team_port_index_hash(const struct team *team,
+ int port_index)
+{
+ return &team->port_hlist[port_index & (TEAM_PORT_HASHENTRIES - 1)];
+}
+
+static struct team_port *team_get_port_by_index_rcu(const struct team *team,
+ int port_index)
+{
+ struct hlist_node *p;
+ struct team_port *port;
+ struct hlist_head *head = team_port_index_hash(team, port_index);
+
+ hlist_for_each_entry_rcu(port, p, head, hlist)
+ if (port->index == port_index)
+ return port;
+ return NULL;
+}
+
+static bool team_port_find(const struct team *team,
+ const struct team_port *port)
+{
+ struct team_port *cur;
+
+ list_for_each_entry(cur, &team->port_list, list)
+ if (cur == port)
+ return true;
+ return false;
+}
+
+#define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
+
+static struct team_port *team_port_get_rcu(const struct net_device *dev)
+{
+ struct team_port *port = rcu_dereference(dev->rx_handler_data);
+
+ return team_port_exists(dev) ? port : NULL;
+}
+
+static struct team_port *team_port_get_rtnl(const struct net_device *dev)
+{
+ struct team_port *port = rtnl_dereference(dev->rx_handler_data);
+
+ return team_port_exists(dev) ? port : NULL;
+}
+
+/*
+ * Since the ability to change mac address for open port device is tested in
+ * team_port_add, this function can be called without control of return value
+ */
+static int __set_port_mac(struct net_device *port_dev,
+ const unsigned char *dev_addr)
+{
+ struct sockaddr addr;
+
+ memcpy(addr.sa_data, dev_addr, ETH_ALEN);
+ addr.sa_family = ARPHRD_ETHER;
+ return dev_set_mac_address(port_dev, &addr);
+}
+
+static int team_port_set_orig_mac(struct team_port *port)
+{
+ return __set_port_mac(port->dev, port->orig.dev_addr);
+}
+
+static int team_port_set_team_mac(struct team_port *port)
+{
+ return __set_port_mac(port->dev, port->team->dev->dev_addr);
+}
+
+
+/*******************
+ * Options handling
+ *******************/
+
+static void team_options_register(struct team *team,
+ struct team_option *option,
+ size_t option_count)
+{
+ int i;
+
+ for (i = 0; i < option_count; i++, option++)
+ list_add_tail(&option->list, &team->option_list);
+}
+
+static void __team_options_change_check(struct team *team,
+ struct team_option *changed_option);
+
+static void __team_options_unregister(struct team *team,
+ struct team_option *option,
+ size_t option_count)
+{
+ int i;
+
+ for (i = 0; i < option_count; i++, option++)
+ list_del(&option->list);
+}
+
+static void team_options_unregister(struct team *team,
+ struct team_option *option,
+ size_t option_count)
+{
+ __team_options_unregister(team, option, option_count);
+ __team_options_change_check(team, NULL);
+}
+
+static int team_option_get(struct team *team, struct team_option *option,
+ void *arg)
+{
+ return option->getter(team, arg);
+}
+
+static int team_option_set(struct team *team, struct team_option *option,
+ void *arg)
+{
+ int err;
+
+ err = option->setter(team, arg);
+ if (err)
+ return err;
+
+ __team_options_change_check(team, option);
+ return err;
+}
+
+/******************************
+ * Round-robin mode definition
+ ******************************/
+
+static struct team_port *__get_first_port_up(struct team *team,
+ struct team_port *port)
+{
+ struct team_port *cur;
+
+ if (port->linkup)
+ return port;
+ cur = port;
+ list_for_each_entry_continue_rcu(cur, &team->port_list, list)
+ if (cur->linkup)
+ return cur;
+ list_for_each_entry_rcu(cur, &team->port_list, list) {
+ if (cur == port)
+ break;
+ if (cur->linkup)
+ return cur;
+ }
+ return NULL;
+}
+
+static bool rr_transmit(struct team *team, struct sk_buff *skb)
+{
+ struct team_port *port;
+ int port_index;
+
+ port_index = team->rr_priv.sent_packets++ % team->port_count;
+ port = team_get_port_by_index_rcu(team, port_index);
+ port = __get_first_port_up(team, port);
+ if (unlikely(!port))
+ goto drop;
+ skb->dev = port->dev;
+ if (dev_queue_xmit(skb))
+ goto drop;
+
+ return true;
+
+drop:
+ dev_kfree_skb(skb);
+ return false;
+}
+
+static int rr_port_enter(struct team *team, struct team_port *port)
+{
+ return team_port_set_team_mac(port);
+}
+
+static void rr_port_change_mac(struct team *team, struct team_port *port)
+{
+ team_port_set_team_mac(port);
+}
+
+static const struct team_mode_ops rr_mode_ops = {
+ .transmit = rr_transmit,
+ .port_enter = rr_port_enter,
+ .port_change_mac = rr_port_change_mac,
+};
+
+static const struct team_mode rr_mode = {
+ .kind = "roundrobin",
+ .ops = &rr_mode_ops,
+};
+
+
+/********************************
+ * Active-backup mode definition
+ ********************************/
+
+static rx_handler_result_t ab_receive(struct team *team, struct team_port *port,
+ struct sk_buff *skb) {
+ struct team_port *active_port;
+
+ active_port = rcu_dereference(team->ab_priv.active_port);
+ if (active_port != port)
+ return RX_HANDLER_EXACT;
+ return RX_HANDLER_ANOTHER;
+}
+
+static bool ab_transmit(struct team *team, struct sk_buff *skb)
+{
+ struct team_port *active_port;
+
+ active_port = rcu_dereference(team->ab_priv.active_port);
+ if (unlikely(!active_port))
+ goto drop;
+ skb->dev = active_port->dev;
+ if (dev_queue_xmit(skb))
+ goto drop;
+ return true;
+
+drop:
+ dev_kfree_skb(skb);
+ return false;
+}
+
+static void ab_port_leave(struct team *team, struct team_port *port)
+{
+ if (team->ab_priv.active_port == port)
+ rcu_assign_pointer(team->ab_priv.active_port, NULL);
+}
+
+static void ab_port_change_mac(struct team *team, struct team_port *port)
+{
+ if (team->ab_priv.active_port == port)
+ team_port_set_team_mac(port);
+}
+
+static int ab_active_port_get(struct team *team, void *arg)
+{
+ u32 *ifindex = arg;
+
+ *ifindex = 0;
+ if (team->ab_priv.active_port)
+ *ifindex = team->ab_priv.active_port->dev->ifindex;
+ return 0;
+}
+
+static int ab_active_port_set(struct team *team, void *arg)
+{
+ u32 *ifindex = arg;
+ struct team_port *port;
+
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ if (port->dev->ifindex == *ifindex) {
+ struct team_port *ac_port = team->ab_priv.active_port;
+
+ /* rtnl_lock needs to be held when setting macs */
+ rtnl_lock();
+ if (ac_port)
+ team_port_set_orig_mac(ac_port);
+ rcu_assign_pointer(team->ab_priv.active_port, port);
+ team_port_set_team_mac(port);
+ rtnl_unlock();
+ return 0;
+ }
+ }
+ return -ENOENT;
+}
+
+static struct team_option ab_options[] = {
+ {
+ .name = "activeport",
+ .type = TEAM_OPTION_TYPE_U32,
+ .getter = ab_active_port_get,
+ .setter = ab_active_port_set,
+ },
+};
+
+int ab_init(struct team *team)
+{
+ team_options_register(team, ab_options, ARRAY_SIZE(ab_options));
+ return 0;
+}
+
+void ab_exit(struct team *team)
+{
+ team_options_unregister(team, ab_options, ARRAY_SIZE(ab_options));
+}
+
+static const struct team_mode_ops ab_mode_ops = {
+ .init = ab_init,
+ .exit = ab_exit,
+ .receive = ab_receive,
+ .transmit = ab_transmit,
+ .port_leave = ab_port_leave,
+ .port_change_mac = ab_port_change_mac,
+};
+
+static const struct team_mode ab_mode = {
+ .kind = "activebackup",
+ .ops = &ab_mode_ops,
+};
+
+
+/****************
+ * Mode handling
+ ****************/
+
+static const struct team_mode *team_modes[] = {
+ &rr_mode,
+ &ab_mode,
+};
+
+static const int team_mode_count = ARRAY_SIZE(team_modes);
+
+static int team_find_mode(const char *kind)
+{
+ int i;
+
+ for (i = 0; i < team_mode_count; i++) {
+ const struct team_mode *mode = team_modes[i];
+
+ if (strcmp(mode->kind, kind) == 0)
+ return i;
+ }
+ return -ENOENT;
+}
+
+/*
+ * We can benefit from the fact that it's ensured no port is present
+ * at the time of mode change.
+ */
+static void __team_change_mode(struct team *team, const int mode_index)
+{
+ const struct team_mode *mode = team_modes[mode_index];
+
+ if (team->mode_ops.exit)
+ team->mode_ops.exit(team);
+
+ if (mode_index < 0)
+ return;
+
+ memcpy(&team->mode_ops, mode->ops, sizeof(struct team_mode_ops));
+
+ /* zero private data area */
+ memset(&team->priv_first_byte, 0,
+ sizeof(struct team) - offsetof(struct team, priv_first_byte));
+
+ team->mode_kind = mode->kind;
+ if (team->mode_ops.init)
+ team->mode_ops.init(team);
+
+ return;
+}
+
+static int team_change_mode(struct team *team, const char *kind)
+{
+ int mode_index;
+ struct net_device *dev = team->dev;
+
+ if (!list_empty(&team->port_list)) {
+ netdev_err(dev, "No ports can be present during "
+ "mode change\n");
+ return -EBUSY;
+ }
+
+ if (strcmp(team->mode_kind, kind) == 0) {
+ netdev_err(dev, "Unable to change to the same mode "
+ "the team is in\n");
+ return -EINVAL;
+ }
+
+ mode_index = team_find_mode(kind);
+ if (mode_index < 0) {
+ netdev_err(dev, "Mode \"%s\" is not loaded\n", kind);
+ return -EINVAL;
+ }
+
+ __team_change_mode(team, mode_index);
+
+ netdev_info(dev, "Mode changed to \"%s\"\n", kind);
+ return 0;
+}
+
+
+/************************
+ * Rx path frame handler
+ ************************/
+
+/* note: already called with rcu_read_lock */
+static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
+{
+ struct sk_buff *skb = *pskb;
+ struct team_port *port;
+ struct team *team;
+ rx_handler_result_t res = RX_HANDLER_ANOTHER;
+
+ skb = skb_share_check(skb, GFP_ATOMIC);
+ if (!skb)
+ return RX_HANDLER_CONSUMED;
+
+ *pskb = skb;
+
+ port = team_port_get_rcu(skb->dev);
+ team = port->team;
+
+ if (team->mode_ops.receive)
+ res = team->mode_ops.receive(team, port, skb);
+
+ if (res == RX_HANDLER_ANOTHER)
+ skb->dev = team->dev;
+
+ return res;
+}
+
+
+/****************
+ * Port handling
+ ****************/
+
+static int team_port_list_init(struct team *team)
+{
+ int i;
+ struct hlist_head *hash;
+
+ hash = kmalloc(sizeof(*hash) * TEAM_PORT_HASHENTRIES, GFP_KERNEL);
+ if (hash != NULL) {
+ for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
+ INIT_HLIST_HEAD(&hash[i]);
+ } else {
+ return -ENOMEM;
+ }
+ team->port_hlist = hash;
+ INIT_LIST_HEAD(&team->port_list);
+ return 0;
+}
+
+static void team_port_list_fini(struct team *team)
+{
+ kfree(team->port_hlist);
+}
+
+/*
+ * Add/delete port to the team port list. Write guarded by rtnl_lock.
+ * Takes care of correct port->index setup (might be racy).
+ */
+static void team_port_list_add_port(struct team *team,
+ struct team_port *port)
+{
+ port->index = team->port_count++;
+ hlist_add_head_rcu(&port->hlist,
+ team_port_index_hash(team, port->index));
+ list_add_tail_rcu(&port->list, &team->port_list);
+}
+
+static void __reconstruct_port_hlist(struct team *team, int rm_index)
+{
+ int i;
+ struct team_port *port;
+
+ for (i = rm_index + 1; i < team->port_count; i++) {
+ port = team_get_port_by_index_rcu(team, i);
+ hlist_del_rcu(&port->hlist);
+ port->index--;
+ hlist_add_head_rcu(&port->hlist,
+ team_port_index_hash(team, port->index));
+ }
+}
+
+static void team_port_list_del_port(struct team *team,
+ struct team_port *port)
+{
+ int rm_index = port->index;
+
+ hlist_del_rcu(&port->hlist);
+ list_del_rcu(&port->list);
+ __reconstruct_port_hlist(team, rm_index);
+ team->port_count--;
+}
+
+#define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
+ NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
+ NETIF_F_HIGHDMA | NETIF_F_LRO)
+
+static void __team_compute_features(struct team *team)
+{
+ struct team_port *port;
+ u32 vlan_features = TEAM_VLAN_FEATURES;
+ unsigned short max_hard_header_len = ETH_HLEN;
+
+ list_for_each_entry(port, &team->port_list, list) {
+ vlan_features = netdev_increment_features(vlan_features,
+ port->dev->vlan_features,
+ TEAM_VLAN_FEATURES);
+
+ if (port->dev->hard_header_len > max_hard_header_len)
+ max_hard_header_len = port->dev->hard_header_len;
+ }
+
+ team->dev->vlan_features = vlan_features;
+ team->dev->hard_header_len = max_hard_header_len;
+
+ netdev_change_features(team->dev);
+}
+
+static void team_compute_features(struct team *team)
+{
+ spin_lock(&team->lock);
+ __team_compute_features(team);
+ spin_unlock(&team->lock);
+}
+
+static int team_port_enter(struct team *team, struct team_port *port)
+{
+ int err = 0;
+
+ dev_hold(team->dev);
+ port->dev->priv_flags |= IFF_TEAM_PORT;
+ if (team->mode_ops.port_enter) {
+ err = team->mode_ops.port_enter(team, port);
+ if (err)
+ netdev_err(team->dev, "Device %s failed to "
+ "enter team mode\n",
+ port->dev->name);
+ }
+ return err;
+}
+
+static void team_port_leave(struct team *team, struct team_port *port)
+{
+ if (team->mode_ops.port_leave)
+ team->mode_ops.port_leave(team, port);
+ port->dev->priv_flags &= ~IFF_TEAM_PORT;
+ dev_put(team->dev);
+}
+
+static void __team_port_change_check(struct team_port *port, bool linkup);
+
+static int team_port_add(struct team *team, struct net_device *port_dev)
+{
+ struct net_device *dev = team->dev;
+ struct team_port *port;
+ char *portname = port_dev->name;
+ char tmp_addr[ETH_ALEN];
+ int err;
+
+ if (port_dev->flags & IFF_LOOPBACK ||
+ port_dev->type != ARPHRD_ETHER) {
+ netdev_err(dev, "Device %s is of an unsupported type\n",
+ portname);
+ return -EINVAL;
+ }
+
+ if (team_port_exists(port_dev)) {
+ netdev_err(dev, "Device %s is already a port "
+ "of a team device\n", portname);
+ return -EBUSY;
+ }
+
+ if (port_dev->flags & IFF_UP) {
+ netdev_err(dev, "Device %s is up. Set it down before "
+ "adding it as a team port\n", portname);
+ return -EBUSY;
+ }
+
+ port = kzalloc(sizeof(struct team_port), GFP_KERNEL);
+ if (!port)
+ return -ENOMEM;
+
+ port->dev = port_dev;
+ port->team = team;
+
+ port->orig.mtu = port_dev->mtu;
+ err = dev_set_mtu(port_dev, dev->mtu);
+ if (err) {
+ netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err);
+ goto err_set_mtu;
+ }
+
+ memcpy(port->orig.dev_addr, port_dev->dev_addr, ETH_ALEN);
+ random_ether_addr(tmp_addr);
+ err = __set_port_mac(port_dev, tmp_addr);
+ if (err) {
+ netdev_dbg(dev, "Device %s mac addr set failed\n",
+ portname);
+ goto err_set_mac_rand;
+ }
+
+ err = dev_open(port_dev);
+ if (err) {
+ netdev_dbg(dev, "Device %s opening failed\n",
+ portname);
+ goto err_dev_open;
+ }
+
+ err = team_port_set_orig_mac(port);
+ if (err) {
+ netdev_dbg(dev, "Device %s mac addr set failed - Device does "
+ "not support addr change when it's opened\n",
+ portname);
+ goto err_set_mac_opened;
+ }
+
+ err = team_port_enter(team, port);
+ if (err) {
+ netdev_err(dev, "Device %s failed to enter team mode\n",
+ portname);
+ goto err_port_enter;
+ }
+
+ err = netdev_set_master(port_dev, dev);
+ if (err) {
+ netdev_err(dev, "Device %s failed to set "
+ "master\n", portname);
+ goto err_set_master;
+ }
+
+ err = netdev_rx_handler_register(port_dev, team_handle_frame,
+ port);
+ if (err) {
+ netdev_err(dev, "Device %s failed to register "
+ "rx_handler\n", portname);
+ goto err_handler_register;
+ }
+
+ team_port_list_add_port(team, port);
+ __team_compute_features(team);
+ __team_port_change_check(port, !!netif_carrier_ok(port_dev));
+
+ netdev_info(dev, "Port device %s added\n", portname);
+
+ return 0;
+
+err_handler_register:
+ netdev_set_master(port_dev, NULL);
+
+err_set_master:
+ team_port_leave(team, port);
+
+err_port_enter:
+err_set_mac_opened:
+ dev_close(port_dev);
+
+err_dev_open:
+ team_port_set_orig_mac(port);
+
+err_set_mac_rand:
+ dev_set_mtu(port_dev, port->orig.mtu);
+
+err_set_mtu:
+ kfree(port);
+
+ return err;
+}
+
+static int team_port_del(struct team *team, struct net_device *port_dev)
+{
+ struct net_device *dev = team->dev;
+ struct team_port *port;
+ char *portname = port_dev->name;
+
+ port = team_port_get_rtnl(port_dev);
+ if (!port || !team_port_find(team, port)) {
+ netdev_err(dev, "Device %s does not act as a port "
+ "of this team\n", portname);
+ return -ENOENT;
+ }
+
+ __team_port_change_check(port, false);
+ team_port_list_del_port(team, port);
+ netdev_rx_handler_unregister(port_dev);
+ netdev_set_master(port_dev, NULL);
+ team_port_leave(team, port);
+ dev_close(port_dev);
+ team_port_set_orig_mac(port);
+ dev_set_mtu(port_dev, port->orig.mtu);
+ synchronize_rcu();
+ kfree(port);
+ netdev_info(dev, "Port device %s removed\n", portname);
+ __team_compute_features(team);
+
+ return 0;
+}
+
+
+/*****************
+ * Net device ops
+ ****************/
+
+static int team_mode_option_get(struct team *team, void *arg)
+{
+ const char **str = arg;
+
+ *str = team->mode_kind;
+ return 0;
+}
+
+static int team_mode_option_set(struct team *team, void *arg)
+{
+ const char **str = arg;
+
+ return team_change_mode(team, *str);
+}
+
+static struct team_option team_options[] = {
+ {
+ .name = "mode",
+ .type = TEAM_OPTION_TYPE_STRING,
+ .getter = team_mode_option_get,
+ .setter = team_mode_option_set,
+ },
+};
+
+static int team_init(struct net_device *dev)
+{
+ struct team *team = netdev_priv(dev);
+ int err;
+
+ team->dev = dev;
+ spin_lock_init(&team->lock);
+
+ err = team_port_list_init(team);
+ if (err)
+ return err;
+
+ INIT_LIST_HEAD(&team->option_list);
+ team_options_register(team, team_options, ARRAY_SIZE(team_options));
+ __team_change_mode(team, 0); /* set default mode */
+ netif_carrier_off(dev);
+
+ return 0;
+}
+
+static void team_uninit(struct net_device *dev)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+ struct team_port *tmp;
+
+ spin_lock(&team->lock);
+ list_for_each_entry_safe(port, tmp, &team->port_list, list)
+ team_port_del(team, port->dev);
+
+ __team_change_mode(team, -1); /* cleanup */
+ __team_options_unregister(team, team_options, ARRAY_SIZE(team_options));
+ spin_unlock(&team->lock);
+}
+
+static void team_destructor(struct net_device *dev)
+{
+ struct team *team = netdev_priv(dev);
+
+ team_port_list_fini(team);
+ free_netdev(dev);
+}
+
+static int team_open(struct net_device *dev)
+{
+ netif_carrier_on(dev);
+ return 0;
+}
+
+static int team_close(struct net_device *dev)
+{
+ netif_carrier_off(dev);
+ return 0;
+}
+
+/*
+ * note: already called with rcu_read_lock
+ */
+static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
+{
+ struct team *team = netdev_priv(dev);
+
+ /*
+ * Ensure transmit function is called only in case there is at least
+ * one port present.
+ */
+ if (likely(!list_empty(&team->port_list)))
+ team->mode_ops.transmit(team, skb);
+
+ return NETDEV_TX_OK;
+}
+
+static void team_change_rx_flags(struct net_device *dev, int change)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+ int inc;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ if (change & IFF_PROMISC) {
+ inc = dev->flags & IFF_PROMISC ? 1 : -1;
+ dev_set_promiscuity(port->dev, inc);
+ }
+ if (change & IFF_ALLMULTI) {
+ inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
+ dev_set_allmulti(port->dev, inc);
+ }
+ }
+ rcu_read_unlock();
+}
+
+static void team_set_rx_mode(struct net_device *dev)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ dev_uc_sync(port->dev, dev);
+ dev_mc_sync(port->dev, dev);
+ }
+ rcu_read_unlock();
+}
+
+static int team_set_mac_address(struct net_device *dev, void *p)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+ struct sockaddr *addr = p;
+
+ memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list)
+ if (team->mode_ops.port_change_mac)
+ team->mode_ops.port_change_mac(team, port);
+ rcu_read_unlock();
+ return 0;
+}
+
+static int team_change_mtu(struct net_device *dev, int new_mtu)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+ int err;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ err = dev_set_mtu(port->dev, new_mtu);
+ if (err) {
+ netdev_err(dev, "Device %s failed to change mtu",
+ port->dev->name);
+ goto unwind;
+ }
+ }
+ rcu_read_unlock();
+
+ dev->mtu = new_mtu;
+
+ return 0;
+
+unwind:
+ list_for_each_entry_continue_reverse(port, &team->port_list, list)
+ dev_set_mtu(port->dev, dev->mtu);
+
+ rcu_read_unlock();
+ return err;
+}
+
+static struct rtnl_link_stats64 *team_get_stats(struct net_device *dev,
+ struct rtnl_link_stats64 *stats)
+{
+ struct team *team = netdev_priv(dev);
+ struct rtnl_link_stats64 temp;
+ struct team_port *port;
+
+ memset(stats, 0, sizeof(*stats));
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ const struct rtnl_link_stats64 *pstats;
+
+ pstats = dev_get_stats(port->dev, &temp);
+
+ stats->rx_packets += pstats->rx_packets;
+ stats->rx_bytes += pstats->rx_bytes;
+ stats->rx_errors += pstats->rx_errors;
+ stats->rx_dropped += pstats->rx_dropped;
+
+ stats->tx_packets += pstats->tx_packets;
+ stats->tx_bytes += pstats->tx_bytes;
+ stats->tx_errors += pstats->tx_errors;
+ stats->tx_dropped += pstats->tx_dropped;
+
+ stats->multicast += pstats->multicast;
+ stats->collisions += pstats->collisions;
+
+ stats->rx_length_errors += pstats->rx_length_errors;
+ stats->rx_over_errors += pstats->rx_over_errors;
+ stats->rx_crc_errors += pstats->rx_crc_errors;
+ stats->rx_frame_errors += pstats->rx_frame_errors;
+ stats->rx_fifo_errors += pstats->rx_fifo_errors;
+ stats->rx_missed_errors += pstats->rx_missed_errors;
+
+ stats->tx_aborted_errors += pstats->tx_aborted_errors;
+ stats->tx_carrier_errors += pstats->tx_carrier_errors;
+ stats->tx_fifo_errors += pstats->tx_fifo_errors;
+ stats->tx_heartbeat_errors += pstats->tx_heartbeat_errors;
+ stats->tx_window_errors += pstats->tx_window_errors;
+ }
+ rcu_read_unlock();
+
+ return stats;
+}
+
+static void team_vlan_rx_add_vid(struct net_device *dev, uint16_t vid)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ const struct net_device_ops *ops = port->dev->netdev_ops;
+
+ ops->ndo_vlan_rx_add_vid(port->dev, vid);
+ }
+ rcu_read_unlock();
+}
+
+static void team_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
+{
+ struct team *team = netdev_priv(dev);
+ struct team_port *port;
+
+ rcu_read_lock();
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ const struct net_device_ops *ops = port->dev->netdev_ops;
+
+ ops->ndo_vlan_rx_kill_vid(port->dev, vid);
+ }
+ rcu_read_unlock();
+}
+
+static int team_add_slave(struct net_device *dev, struct net_device *port_dev)
+{
+ struct team *team = netdev_priv(dev);
+ int err;
+
+ spin_lock(&team->lock);
+ err = team_port_add(team, port_dev);
+ spin_unlock(&team->lock);
+ return err;
+}
+
+static int team_del_slave(struct net_device *dev, struct net_device *port_dev)
+{
+ struct team *team = netdev_priv(dev);
+ int err;
+
+ spin_lock(&team->lock);
+ err = team_port_del(team, port_dev);
+ spin_unlock(&team->lock);
+ return err;
+}
+
+static const struct net_device_ops team_netdev_ops = {
+ .ndo_init = team_init,
+ .ndo_uninit = team_uninit,
+ .ndo_open = team_open,
+ .ndo_stop = team_close,
+ .ndo_start_xmit = team_xmit,
+ .ndo_change_rx_flags = team_change_rx_flags,
+ .ndo_set_rx_mode = team_set_rx_mode,
+ .ndo_set_mac_address = team_set_mac_address,
+ .ndo_change_mtu = team_change_mtu,
+ .ndo_get_stats64 = team_get_stats,
+ .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
+ .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
+ .ndo_add_slave = team_add_slave,
+ .ndo_del_slave = team_del_slave,
+};
+
+
+/***********************
+ * rt netlink interface
+ ***********************/
+
+static void team_setup(struct net_device *dev)
+{
+ ether_setup(dev);
+
+ dev->netdev_ops = &team_netdev_ops;
+ dev->destructor = team_destructor;
+ dev->tx_queue_len = 0;
+ dev->flags |= IFF_MULTICAST;
+ dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
+
+ /*
+ * Indicate we support unicast address filtering. That way core won't
+ * bring us to promisc mode in case a unicast addr is added.
+ * Let this up to underlay drivers.
+ */
+ dev->priv_flags |= IFF_UNICAST_FLT;
+
+ dev->features |= NETIF_F_LLTX;
+ dev->features |= NETIF_F_GRO;
+ dev->hw_features = NETIF_F_HW_VLAN_TX |
+ NETIF_F_HW_VLAN_RX |
+ NETIF_F_HW_VLAN_FILTER;
+
+ dev->features |= dev->hw_features;
+}
+
+static int team_newlink(struct net *src_net, struct net_device *dev,
+ struct nlattr *tb[], struct nlattr *data[])
+{
+ int err;
+
+ if (tb[IFLA_ADDRESS] == NULL)
+ random_ether_addr(dev->dev_addr);
+
+ err = register_netdevice(dev);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+static int team_validate(struct nlattr *tb[], struct nlattr *data[])
+{
+ if (tb[IFLA_ADDRESS]) {
+ if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
+ return -EINVAL;
+ if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
+ return -EADDRNOTAVAIL;
+ }
+ return 0;
+}
+
+static struct rtnl_link_ops team_link_ops __read_mostly = {
+ .kind = DRV_NAME,
+ .priv_size = sizeof(struct team),
+ .setup = team_setup,
+ .newlink = team_newlink,
+ .validate = team_validate,
+};
+
+
+/***********************************
+ * Generic netlink custom interface
+ ***********************************/
+
+static struct genl_family team_nl_family = {
+ .id = GENL_ID_GENERATE,
+ .name = TEAM_GENL_NAME,
+ .version = TEAM_GENL_VERSION,
+ .maxattr = TEAM_ATTR_MAX,
+ .netnsok = true,
+};
+
+static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
+ [TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, },
+ [TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 },
+ [TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED },
+ [TEAM_ATTR_LIST_MODE] = { .type = NLA_NESTED },
+ [TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED },
+};
+
+static const struct nla_policy team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
+ [TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, },
+ [TEAM_ATTR_OPTION_NAME] = {
+ .type = NLA_STRING,
+ .len = TEAM_STRING_MAX_LEN,
+ },
+ [TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
+ [TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
+ [TEAM_ATTR_OPTION_DATA] = {
+ .type = NLA_BINARY,
+ .len = TEAM_STRING_MAX_LEN,
+ },
+};
+
+static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
+{
+ struct sk_buff *msg;
+ void *hdr;
+ int err;
+
+ msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+ if (!msg)
+ return -ENOMEM;
+
+ hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
+ &team_nl_family, 0, TEAM_CMD_NOOP);
+ if (IS_ERR(hdr)) {
+ err = PTR_ERR(hdr);
+ goto err_msg_put;
+ }
+
+ genlmsg_end(msg, hdr);
+
+ return genlmsg_unicast(genl_info_net(info), msg, info->snd_pid);
+
+err_msg_put:
+ nlmsg_free(msg);
+
+ return err;
+}
+
+/*
+ * Netlink cmd functions should be locked by following two functions.
+ * To ensure team_uninit would not be called in between, hold rcu_read_lock
+ * all the time.
+ */
+static struct team *team_nl_team_get(struct genl_info *info)
+{
+ struct net *net = genl_info_net(info);
+ int ifindex;
+ struct net_device *dev;
+ struct team *team;
+
+ if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
+ return NULL;
+
+ ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
+ rcu_read_lock();
+ dev = dev_get_by_index_rcu(net, ifindex);
+ if (!dev || dev->netdev_ops != &team_netdev_ops) {
+ rcu_read_unlock();
+ return NULL;
+ }
+
+ team = netdev_priv(dev);
+ spin_lock(&team->lock);
+ return team;
+}
+
+static void team_nl_team_put(struct team *team)
+{
+ spin_unlock(&team->lock);
+ rcu_read_unlock();
+}
+
+static int team_nl_send_generic(struct genl_info *info, struct team *team,
+ int (*fill_func)(struct sk_buff *skb,
+ struct genl_info *info,
+ int flags, struct team *team))
+{
+ struct sk_buff *skb;
+ int err;
+
+ skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+ if (!skb)
+ return -ENOMEM;
+
+ err = fill_func(skb, info, NLM_F_ACK, team);
+ if (err < 0)
+ goto err_fill;
+
+ err = genlmsg_unicast(genl_info_net(info), skb, info->snd_pid);
+ return err;
+
+err_fill:
+ nlmsg_free(skb);
+ return err;
+}
+
+static int team_nl_fill_options_get_changed(struct sk_buff *skb,
+ u32 pid, u32 seq, int flags,
+ struct team *team,
+ struct team_option *changed_option)
+{
+ struct nlattr *option_list;
+ void *hdr;
+ struct team_option *option;
+
+ hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
+ TEAM_CMD_OPTIONS_GET);
+ if (IS_ERR(hdr))
+ return PTR_ERR(hdr);
+
+ NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
+ option_list = nla_nest_start(skb, TEAM_ATTR_LIST_OPTION);
+ if (!option_list)
+ return -EMSGSIZE;
+
+ list_for_each_entry(option, &team->option_list, list) {
+ struct nlattr *option_item;
+ long arg;
+
+ option_item = nla_nest_start(skb, TEAM_ATTR_ITEM_OPTION);
+ if (!option_item)
+ goto nla_put_failure;
+ NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_NAME, option->name);
+ if (option == changed_option)
+ NLA_PUT_FLAG(skb, TEAM_ATTR_OPTION_CHANGED);
+ switch (option->type) {
+ case TEAM_OPTION_TYPE_U32:
+ NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE, NLA_U32);
+ team_option_get(team, option, &arg);
+ NLA_PUT_U32(skb, TEAM_ATTR_OPTION_DATA, arg);
+ break;
+ case TEAM_OPTION_TYPE_STRING:
+ NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE, NLA_STRING);
+ team_option_get(team, option, &arg);
+ NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_DATA, (char *) arg);
+ break;
+ default:
+ BUG();
+ }
+ nla_nest_end(skb, option_item);
+ }
+
+ nla_nest_end(skb, option_list);
+ return genlmsg_end(skb, hdr);
+
+nla_put_failure:
+ genlmsg_cancel(skb, hdr);
+ return -EMSGSIZE;
+}
+
+static int team_nl_fill_options_get(struct sk_buff *skb,
+ struct genl_info *info, int flags,
+ struct team *team)
+{
+ return team_nl_fill_options_get_changed(skb, info->snd_pid,
+ info->snd_seq, NLM_F_ACK,
+ team, NULL);
+}
+
+static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info)
+{
+ struct team *team;
+ int err;
+
+ team = team_nl_team_get(info);
+ if (!team)
+ return -EINVAL;
+
+ err = team_nl_send_generic(info, team, team_nl_fill_options_get);
+
+ team_nl_team_put(team);
+
+ return err;
+}
+
+static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
+{
+ struct team *team;
+ int err = 0;
+ int i;
+ struct nlattr *nl_option;
+
+ team = team_nl_team_get(info);
+ if (!team)
+ return -EINVAL;
+
+ err = -EINVAL;
+ if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
+ err = -EINVAL;
+ goto team_put;
+ }
+
+ nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) {
+ struct nlattr *mode_attrs[TEAM_ATTR_OPTION_MAX + 1];
+ enum team_option_type opt_type;
+ struct team_option *option;
+ char *opt_name;
+
+ if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) {
+ err = -EINVAL;
+ goto team_put;
+ }
+ err = nla_parse_nested(mode_attrs, TEAM_ATTR_OPTION_MAX,
+ nl_option, team_nl_option_policy);
+ if (err)
+ goto team_put;
+ if (!mode_attrs[TEAM_ATTR_OPTION_NAME] ||
+ !mode_attrs[TEAM_ATTR_OPTION_TYPE] ||
+ !mode_attrs[TEAM_ATTR_OPTION_DATA]) {
+ err = -EINVAL;
+ goto team_put;
+ }
+ switch (nla_get_u8(mode_attrs[TEAM_ATTR_OPTION_TYPE])) {
+ case NLA_U32:
+ opt_type = TEAM_OPTION_TYPE_U32;
+ break;
+ case NLA_STRING:
+ opt_type = TEAM_OPTION_TYPE_STRING;
+ break;
+ default:
+ goto team_put;
+ }
+
+ opt_name = nla_data(mode_attrs[TEAM_ATTR_OPTION_NAME]);
+ list_for_each_entry(option, &team->option_list, list) {
+ long arg;
+
+ if (option->type != opt_type ||
+ strcmp(option->name, opt_name))
+ continue;
+ switch (opt_type) {
+ case TEAM_OPTION_TYPE_U32:
+ arg = nla_get_u32(mode_attrs[TEAM_ATTR_OPTION_DATA]);
+ break;
+ case TEAM_OPTION_TYPE_STRING:
+ arg = (long) nla_data(mode_attrs[TEAM_ATTR_OPTION_DATA]);
+ break;
+ default:
+ BUG();
+ }
+ err = team_option_set(team, option, &arg);
+ if (err)
+ goto team_put;
+ }
+ }
+
+team_put:
+ team_nl_team_put(team);
+
+ return err;
+}
+
+static int team_nl_fill_mode_list_get(struct sk_buff *skb,
+ struct genl_info *info, int flags,
+ struct team *team)
+{
+ struct nlattr *mode_list;
+ void *hdr;
+ int i;
+
+ hdr = genlmsg_put(skb, info->snd_pid, info->snd_seq,
+ &team_nl_family, flags, TEAM_CMD_MODE_LIST_GET);
+ if (IS_ERR(hdr))
+ return PTR_ERR(hdr);
+
+ NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
+ mode_list = nla_nest_start(skb, TEAM_ATTR_LIST_MODE);
+ if (!mode_list)
+ return -EMSGSIZE;
+
+ for (i = 0; i < team_mode_count; i++) {
+ const struct team_mode *mode = team_modes[i];
+ struct nlattr *mode_item;
+
+ mode_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
+ if (!mode_item)
+ goto nla_put_failure;
+ NLA_PUT_STRING(skb, TEAM_ATTR_MODE_NAME, mode->kind);
+ nla_nest_end(skb, mode_item);
+ }
+
+ nla_nest_end(skb, mode_list);
+ return genlmsg_end(skb, hdr);
+
+nla_put_failure:
+ genlmsg_cancel(skb, hdr);
+ return -EMSGSIZE;
+}
+
+static int team_nl_cmd_mode_list_get(struct sk_buff *skb,
+ struct genl_info *info)
+{
+ struct team *team;
+ int err;
+
+ team = team_nl_team_get(info);
+ if (!team)
+ return -EINVAL;
+
+ err = team_nl_send_generic(info, team, team_nl_fill_mode_list_get);
+
+ team_nl_team_put(team);
+
+ return err;
+}
+
+static int team_nl_fill_port_list_get_changed(struct sk_buff *skb,
+ u32 pid, u32 seq, int flags,
+ struct team *team,
+ struct team_port *changed_port)
+{
+ struct nlattr *port_list;
+ void *hdr;
+ struct team_port *port;
+
+ hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
+ TEAM_CMD_PORT_LIST_GET);
+ if (IS_ERR(hdr))
+ return PTR_ERR(hdr);
+
+ NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
+ port_list = nla_nest_start(skb, TEAM_ATTR_LIST_PORT);
+ if (!port_list)
+ return -EMSGSIZE;
+
+ list_for_each_entry_rcu(port, &team->port_list, list) {
+ struct nlattr *port_item;
+
+ port_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
+ if (!port_item)
+ goto nla_put_failure;
+ NLA_PUT_U32(skb, TEAM_ATTR_PORT_IFINDEX, port->dev->ifindex);
+ if (port == changed_port)
+ NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_CHANGED);
+ if (port->linkup)
+ NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_LINKUP);
+ NLA_PUT_U32(skb, TEAM_ATTR_PORT_SPEED, port->speed);
+ NLA_PUT_U8(skb, TEAM_ATTR_PORT_DUPLEX, port->duplex);
+ nla_nest_end(skb, port_item);
+ }
+
+ nla_nest_end(skb, port_list);
+ return genlmsg_end(skb, hdr);
+
+nla_put_failure:
+ genlmsg_cancel(skb, hdr);
+ return -EMSGSIZE;
+}
+
+static int team_nl_fill_port_list_get(struct sk_buff *skb,
+ struct genl_info *info, int flags,
+ struct team *team)
+{
+ return team_nl_fill_port_list_get_changed(skb, info->snd_pid,
+ info->snd_seq, NLM_F_ACK,
+ team, NULL);
+}
+
+static int team_nl_cmd_port_list_get(struct sk_buff *skb,
+ struct genl_info *info)
+{
+ struct team *team;
+ int err;
+
+ team = team_nl_team_get(info);
+ if (!team)
+ return -EINVAL;
+
+ err = team_nl_send_generic(info, team, team_nl_fill_port_list_get);
+
+ team_nl_team_put(team);
+
+ return err;
+}
+
+static struct genl_ops team_nl_ops[] = {
+ {
+ .cmd = TEAM_CMD_NOOP,
+ .doit = team_nl_cmd_noop,
+ .policy = team_nl_policy,
+ },
+ {
+ .cmd = TEAM_CMD_OPTIONS_SET,
+ .doit = team_nl_cmd_options_set,
+ .policy = team_nl_policy,
+ .flags = GENL_ADMIN_PERM,
+ },
+ {
+ .cmd = TEAM_CMD_OPTIONS_GET,
+ .doit = team_nl_cmd_options_get,
+ .policy = team_nl_policy,
+ .flags = GENL_ADMIN_PERM,
+ },
+ {
+ .cmd = TEAM_CMD_MODE_LIST_GET,
+ .doit = team_nl_cmd_mode_list_get,
+ .policy = team_nl_policy,
+ .flags = GENL_ADMIN_PERM,
+ },
+ {
+ .cmd = TEAM_CMD_PORT_LIST_GET,
+ .doit = team_nl_cmd_port_list_get,
+ .policy = team_nl_policy,
+ .flags = GENL_ADMIN_PERM,
+ },
+};
+
+static struct genl_multicast_group team_change_event_mcgrp = {
+ .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME,
+};
+
+static int team_nl_send_event_options_get(struct team *team,
+ struct team_option *changed_option)
+{
+ struct sk_buff *skb;
+ int err;
+ struct net *net = dev_net(team->dev);
+
+ skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+ if (!skb)
+ return -ENOMEM;
+
+ err = team_nl_fill_options_get_changed(skb, 0, 0, 0, team,
+ changed_option);
+ if (err < 0)
+ goto err_fill;
+
+ err = genlmsg_multicast_netns(net, skb, 0, team_change_event_mcgrp.id,
+ GFP_KERNEL);
+ return err;
+
+err_fill:
+ nlmsg_free(skb);
+ return err;
+}
+
+static int team_nl_send_event_port_list_get(struct team_port *port)
+{
+ struct sk_buff *skb;
+ int err;
+ struct net *net = dev_net(port->team->dev);
+
+ skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
+ if (!skb)
+ return -ENOMEM;
+
+ err = team_nl_fill_port_list_get_changed(skb, 0, 0, 0,
+ port->team, port);
+ if (err < 0)
+ goto err_fill;
+
+ err = genlmsg_multicast_netns(net, skb, 0, team_change_event_mcgrp.id,
+ GFP_KERNEL);
+ return err;
+
+err_fill:
+ nlmsg_free(skb);
+ return err;
+}
+
+static int team_nl_init(void)
+{
+ int err;
+
+ err = genl_register_family_with_ops(&team_nl_family, team_nl_ops,
+ ARRAY_SIZE(team_nl_ops));
+ if (err)
+ return err;
+
+ err = genl_register_mc_group(&team_nl_family, &team_change_event_mcgrp);
+ if (err)
+ goto err_change_event_grp_reg;
+
+ return 0;
+
+err_change_event_grp_reg:
+ genl_unregister_family(&team_nl_family);
+
+ return err;
+}
+
+static void team_nl_fini(void)
+{
+ genl_unregister_family(&team_nl_family);
+}
+
+
+/******************
+ * Change checkers
+ ******************/
+
+static void __team_options_change_check(struct team *team,
+ struct team_option *changed_option)
+{
+ int err;
+
+ err = team_nl_send_event_options_get(team, changed_option);
+ if (err)
+ netdev_warn(team->dev, "Failed to send options change "
+ "via netlink\n");
+}
+
+/* rtnl lock is held */
+static void __team_port_change_check(struct team_port *port, bool linkup)
+{
+ int err;
+
+ if (port->linkup == linkup)
+ return;
+
+ port->linkup = linkup;
+ if (linkup) {
+ struct ethtool_cmd ecmd;
+
+ err = __ethtool_get_settings(port->dev, &ecmd);
+ if (!err) {
+ port->speed = ethtool_cmd_speed(&ecmd);
+ port->duplex = ecmd.duplex;
+ goto send_event;
+ }
+ }
+ port->speed = 0;
+ port->duplex = 0;
+
+send_event:
+ err = team_nl_send_event_port_list_get(port);
+ if (err)
+ netdev_warn(port->team->dev, "Failed to send port change of "
+ "device %s via netlink\n",
+ port->dev->name);
+
+}
+
+static void team_port_change_check(struct team_port *port, bool linkup)
+{
+ struct team *team = port->team;
+
+ spin_lock(&team->lock);
+ __team_port_change_check(port, linkup);
+ spin_unlock(&team->lock);
+}
+
+/************************************
+ * Net device notifier event handler
+ ************************************/
+
+static int team_device_event(struct notifier_block *unused,
+ unsigned long event, void *ptr)
+{
+ struct net_device *dev = (struct net_device *) ptr;
+ struct team_port *port;
+
+ port = team_port_get_rtnl(dev);
+ if (!port)
+ return NOTIFY_DONE;
+
+ switch (event) {
+ case NETDEV_UP:
+ if (netif_carrier_ok(dev));
+ team_port_change_check(port, true);
+ case NETDEV_DOWN:
+ team_port_change_check(port, false);
+ case NETDEV_CHANGE:
+ if (netif_running(port->dev))
+ team_port_change_check(port,
+ !!netif_carrier_ok(port->dev));
+ break;
+ case NETDEV_UNREGISTER:
+ team_del_slave(port->team->dev, dev);
+ break;
+ case NETDEV_FEAT_CHANGE:
+ team_compute_features(port->team);
+ break;
+ case NETDEV_CHANGEMTU:
+ /* Forbid to change mtu of underlaying device */
+ return NOTIFY_BAD;
+ case NETDEV_CHANGEADDR:
+ /* Forbid to change addr of underlaying device */
+ return NOTIFY_BAD;
+ case NETDEV_PRE_TYPE_CHANGE:
+ /* Forbid to change type of underlaying device */
+ return NOTIFY_BAD;
+ }
+ return NOTIFY_DONE;
+}
+
+static struct notifier_block team_notifier_block __read_mostly = {
+ .notifier_call = team_device_event,
+};
+
+
+/***********************
+ * Module init and exit
+ ***********************/
+
+static int __init team_module_init(void)
+{
+ int err;
+
+ register_netdevice_notifier(&team_notifier_block);
+
+ err = rtnl_link_register(&team_link_ops);
+ if (err)
+ goto err_rtln_reg;
+
+ err = team_nl_init();
+ if (err)
+ goto err_nl_init;
+
+ return 0;
+
+err_nl_init:
+ rtnl_link_unregister(&team_link_ops);
+
+err_rtln_reg:
+ unregister_netdevice_notifier(&team_notifier_block);
+
+ return err;
+}
+
+static void __exit team_module_exit(void)
+{
+ team_nl_fini();
+ rtnl_link_unregister(&team_link_ops);
+ unregister_netdevice_notifier(&team_notifier_block);
+}
+
+module_init(team_module_init);
+module_exit(team_module_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
+MODULE_DESCRIPTION("Ethernet team device driver");
+MODULE_ALIAS_RTNL_LINK(DRV_NAME);
diff --git a/include/linux/Kbuild b/include/linux/Kbuild
index 619b565..0b091b3 100644
--- a/include/linux/Kbuild
+++ b/include/linux/Kbuild
@@ -185,6 +185,7 @@ header-y += if_pppol2tp.h
header-y += if_pppox.h
header-y += if_slip.h
header-y += if_strip.h
+header-y += if_team.h
header-y += if_tr.h
header-y += if_tun.h
header-y += if_tunnel.h
diff --git a/include/linux/if.h b/include/linux/if.h
index db20bd4..e98f39d 100644
--- a/include/linux/if.h
+++ b/include/linux/if.h
@@ -79,6 +79,7 @@
#define IFF_TX_SKB_SHARING 0x10000 /* The interface supports sharing
* skbs on transmit */
#define IFF_UNICAST_FLT 0x20000 /* Supports unicast filtering */
+#define IFF_TEAM_PORT 0x40000 /* device used as teaming port */
#define IF_GET_IFACE 0x0001 /* for querying only */
#define IF_GET_PROTO 0x0002
diff --git a/include/linux/if_team.h b/include/linux/if_team.h
new file mode 100644
index 0000000..b451c9e
--- /dev/null
+++ b/include/linux/if_team.h
@@ -0,0 +1,126 @@
+/*
+ * include/linux/if_team.h - Network team device driver header
+ * Copyright (c) 2011 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.
+ */
+
+#ifndef _LINUX_IF_TEAM_H_
+#define _LINUX_IF_TEAM_H_
+
+#define TEAM_STRING_MAX_LEN 32
+
+/**********************************
+ * NETLINK_GENERIC netlink family.
+ **********************************/
+
+enum {
+ TEAM_CMD_NOOP,
+ TEAM_CMD_OPTIONS_SET,
+ TEAM_CMD_OPTIONS_GET,
+ TEAM_CMD_MODE_LIST_GET,
+ TEAM_CMD_PORT_LIST_GET,
+
+ __TEAM_CMD_MAX,
+ TEAM_CMD_MAX = (__TEAM_CMD_MAX - 1),
+};
+
+enum {
+ TEAM_ATTR_UNSPEC,
+ TEAM_ATTR_TEAM_IFINDEX, /* u32 */
+ TEAM_ATTR_LIST_OPTION, /* nest */
+ TEAM_ATTR_LIST_MODE, /* nest */
+ TEAM_ATTR_LIST_PORT, /* nest */
+
+ __TEAM_ATTR_MAX,
+ TEAM_ATTR_MAX = __TEAM_ATTR_MAX - 1,
+};
+
+/* Nested layout of get/set msg:
+ *
+ * [TEAM_ATTR_LIST_OPTION]
+ * [TEAM_ATTR_ITEM_OPTION]
+ * [TEAM_ATTR_OPTION_*], ...
+ * [TEAM_ATTR_ITEM_OPTION]
+ * [TEAM_ATTR_OPTION_*], ...
+ * ...
+ * [TEAM_ATTR_LIST_MODE]
+ * [TEAM_ATTR_ITEM_MODE]
+ * [TEAM_ATTR_MODE_*], ...
+ * [TEAM_ATTR_ITEM_MODE]
+ * [TEAM_ATTR_MODE_*], ...
+ * ...
+ * [TEAM_ATTR_LIST_PORT]
+ * [TEAM_ATTR_ITEM_PORT]
+ * [TEAM_ATTR_PORT_*], ...
+ * [TEAM_ATTR_ITEM_PORT]
+ * [TEAM_ATTR_PORT_*], ...
+ * ...
+ */
+
+enum {
+ TEAM_ATTR_ITEM_OPTION_UNSPEC,
+ TEAM_ATTR_ITEM_OPTION, /* nest */
+
+ __TEAM_ATTR_ITEM_OPTION_MAX,
+ TEAM_ATTR_ITEM_OPTION_MAX = __TEAM_ATTR_ITEM_OPTION_MAX - 1,
+};
+
+enum {
+ TEAM_ATTR_OPTION_UNSPEC,
+ TEAM_ATTR_OPTION_NAME, /* string */
+ TEAM_ATTR_OPTION_CHANGED, /* flag */
+ TEAM_ATTR_OPTION_TYPE, /* u8 */
+ TEAM_ATTR_OPTION_DATA, /* dynamic */
+
+ __TEAM_ATTR_OPTION_MAX,
+ TEAM_ATTR_OPTION_MAX = __TEAM_ATTR_OPTION_MAX - 1,
+};
+
+enum {
+ TEAM_ATTR_ITEM_MODE_UNSPEC,
+ TEAM_ATTR_ITEM_MODE, /* nest */
+
+ __TEAM_ATTR_ITEM_MODE_MAX,
+ TEAM_ATTR_ITEM_MODE_MAX = __TEAM_ATTR_ITEM_MODE_MAX - 1,
+};
+
+enum {
+ TEAM_ATTR_MODE_UNSPEC,
+ TEAM_ATTR_MODE_NAME, /* string */
+
+ __TEAM_ATTR_MODE_MAX,
+ TEAM_ATTR_MODE_MAX = __TEAM_ATTR_MODE_MAX - 1,
+};
+
+enum {
+ TEAM_ATTR_ITEM_PORT_UNSPEC,
+ TEAM_ATTR_ITEM_PORT, /* nest */
+
+ __TEAM_ATTR_ITEM_PORT_MAX,
+ TEAM_ATTR_ITEM_PORT_MAX = __TEAM_ATTR_ITEM_PORT_MAX - 1,
+};
+
+enum {
+ TEAM_ATTR_PORT_UNSPEC,
+ TEAM_ATTR_PORT_IFINDEX, /* u32 */
+ TEAM_ATTR_PORT_CHANGED, /* flag */
+ TEAM_ATTR_PORT_LINKUP, /* flag */
+ TEAM_ATTR_PORT_SPEED, /* u32 */
+ TEAM_ATTR_PORT_DUPLEX, /* u8 */
+
+ __TEAM_ATTR_PORT_MAX,
+ TEAM_ATTR_PORT_MAX = __TEAM_ATTR_PORT_MAX - 1,
+};
+
+/*
+ * NETLINK_GENERIC related info
+ */
+#define TEAM_GENL_NAME "team"
+#define TEAM_GENL_VERSION 0x1
+#define TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME "change_event"
+
+#endif
--
1.7.6
^ permalink raw reply related
* Re: [PATCH] x25: Validate incoming call user data lengths
From: Eric Dumazet @ 2011-10-04 14:33 UTC (permalink / raw)
To: Matthew Daley; +Cc: netdev, Andrew Hendry
In-Reply-To: <CA+nUz_J73agjPQPqdbTraUPLyv39sqQ4kvZTmrZrFXLW1faqwg@mail.gmail.com>
Le mardi 04 octobre 2011 à 14:00 +0000, Matthew Daley a écrit :
> X.25 call user data is being copied in its entirety from incoming messages
> without consideration to the size of the destination buffers, leading to
> possible buffer overflows. Validate incoming call user data lengths before
> these copies are performed.
>
> It appears this issue was noticed some time ago, however nothing seemed to
> come of it: see http://www.spinics.net/lists/linux-x25/msg00043.html and
> commit 8db09f26f912f7c90c764806e804b558da520d4f.
>
> Signed-off-by: Matthew Daley <mattjd@gmail.com>
> Cc: Eric Dumazet <eric.dumazet@gmail.com>
> Cc: Andrew Hendry <andrew.hendry@gmail.com>
> Cc: stable <stable@kernel.org>
> ---
> Hopefully this is acceptable; I thought someone with greater knowledge of
> X.25 might step in :) It should take into account Andrew's suggestion to
> move af_x25.c's check to before the call acception.
>
> net/x25/af_x25.c | 6 ++++++
> net/x25/x25_in.c | 3 +++
> 2 files changed, 9 insertions(+), 0 deletions(-)
>
> diff --git a/net/x25/af_x25.c b/net/x25/af_x25.c
> index d306154..a4bd172 100644
> --- a/net/x25/af_x25.c
> +++ b/net/x25/af_x25.c
> @@ -959,6 +959,12 @@ int x25_rx_call_request(struct sk_buff *skb,
> struct x25_neigh *nb,
> skb_pull(skb,len);
>
> /*
> + * Ensure that the amount of call user data is valid.
> + */
> + if (skb->len > X25_MAX_CUD_LEN)
> + goto out_clear_request;
> +
> + /*
> * Find a listener for the particular address/cud pair.
> */
> sk = x25_find_listener(&source_addr,skb);
> diff --git a/net/x25/x25_in.c b/net/x25/x25_in.c
> index 0b073b5..63488fd 100644
> --- a/net/x25/x25_in.c
> +++ b/net/x25/x25_in.c
> @@ -127,6 +127,9 @@ static int x25_state1_machine(struct sock *sk,
> struct sk_buff *skb, int frametyp
> * Copy any Call User Data.
> */
> if (skb->len > 0) {
> + if (skb->len > X25_MAX_CUD_LEN)
> + goto out_clear;
> +
> skb_copy_from_linear_data(skb,
> x25->calluserdata.cuddata,
> skb->len);
> --
It seems fine to me.
Acked-by: Eric Dumazet <eric.dumazet@gmail.com>
Now, you could also fix x25 for undersized/frags frames :
Apparently, no check is done in this respect (missing pskb_may_pull()
calls)...
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Flavio Leitner @ 2011-10-04 14:53 UTC (permalink / raw)
To: Jiri Pirko
Cc: netdev, davem, eric.dumazet, bhutchings, shemminger, fubar, andy,
tgraf, ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <1317737703-19457-1-git-send-email-jpirko@redhat.com>
On Tue, 4 Oct 2011 16:15:03 +0200
Jiri Pirko <jpirko@redhat.com> wrote:
> This patch introduces new network device called team. It supposes to
> be very fast, simple, userspace-driven alternative to existing bonding
> driver.
>
> Userspace library called libteam with couple of demo apps is available
> here:
> https://github.com/jpirko/libteam
> Note it's still in its dipers atm.
>
> team<->libteam use generic netlink for communication. That and rtnl
> suppose to be the only way to configure team device, no sysfs etc.
>
> In near future python binding for libteam will be introduced. Also
> daemon providing arpmon/miimon active-backup functionality will
> be introduced. All what's necessary is already implemented in kernel
> team driver.
>
> Signed-off-by: Jiri Pirko <jpirko@redhat.com>
> ---
> Documentation/networking/team.txt | 2 +
> MAINTAINERS | 7 +
> drivers/net/Kconfig | 15 +
> drivers/net/Makefile | 1 +
> drivers/net/team.c | 1819
> +++++++++++++++++++++++++++++++++++++
> include/linux/Kbuild | 1 +
> include/linux/if.h | 1 +
> include/linux/if_team.h | 126 +++ 8 files changed, 1972
> insertions(+), 0 deletions(-) create mode 100644
> Documentation/networking/team.txt create mode 100644
> drivers/net/team.c create mode 100644 include/linux/if_team.h
>
> diff --git a/Documentation/networking/team.txt
> b/Documentation/networking/team.txt new file mode 100644
> index 0000000..5a01368
> --- /dev/null
> +++ b/Documentation/networking/team.txt
> @@ -0,0 +1,2 @@
> +Team devices are driven from userspace via libteam library which is
> here:
> + https://github.com/jpirko/libteam
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 65ca7ea..f846c6b 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -6372,6 +6372,13 @@ W: http://tcp-lp-mod.sourceforge.net/
> S: Maintained
> F: net/ipv4/tcp_lp.c
>
> +TEAM DRIVER
> +M: Jiri Pirko <jpirko@redhat.com>
> +L: netdev@vger.kernel.org
> +S: Supported
> +F: drivers/net/team.c
> +F: include/linux/team.h
> +
> TEGRA SUPPORT
> M: Colin Cross <ccross@android.com>
> M: Erik Gilling <konkers@android.com>
> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
> index 583f66c..0d74e9d 100644
> --- a/drivers/net/Kconfig
> +++ b/drivers/net/Kconfig
> @@ -125,6 +125,21 @@ config IFB
> 'ifb1' etc.
> Look at the iproute2 documentation directory for usage etc
>
> +config NET_TEAM
> + tristate "Ethernet teaming support (EXPERIMENTAL)"
> + depends on EXPERIMENTAL
> + ---help---
> + This allows one to create virtual interfaces that teams
> together
> + multiple ethernet devices.
> +
> + Team devices can be added using the "ip" command from the
> + iproute2 package:
> +
> + "ip link add link [ address MAC ] [ NAME ] type team"
> +
> + To compile this driver as a module, choose M here: the
> module
> + will be called team.
> +
> config MACVLAN
> tristate "MAC-VLAN support (EXPERIMENTAL)"
> depends on EXPERIMENTAL
> diff --git a/drivers/net/Makefile b/drivers/net/Makefile
> index fa877cd..e3d3e81 100644
> --- a/drivers/net/Makefile
> +++ b/drivers/net/Makefile
> @@ -17,6 +17,7 @@ obj-$(CONFIG_NET) += Space.o loopback.o
> obj-$(CONFIG_NETCONSOLE) += netconsole.o
> obj-$(CONFIG_PHYLIB) += phy/
> obj-$(CONFIG_RIONET) += rionet.o
> +obj-$(CONFIG_NET_TEAM) += team.o
> obj-$(CONFIG_TUN) += tun.o
> obj-$(CONFIG_VETH) += veth.o
> obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
> diff --git a/drivers/net/team.c b/drivers/net/team.c
> new file mode 100644
> index 0000000..c9ae388
> --- /dev/null
> +++ b/drivers/net/team.c
> @@ -0,0 +1,1819 @@
> +/*
> + * net/drivers/team.c - Network team device driver
> + * Copyright (c) 2011 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/slab.h>
> +#include <linux/rcupdate.h>
> +#include <linux/errno.h>
> +#include <linux/notifier.h>
> +#include <linux/netdevice.h>
> +#include <linux/if_arp.h>
> +#include <linux/socket.h>
> +#include <linux/etherdevice.h>
> +#include <linux/rtnetlink.h>
> +#include <net/rtnetlink.h>
> +#include <net/genetlink.h>
> +#include <net/netlink.h>
> +#include <linux/if_team.h>
> +
> +#define DRV_NAME "team"
> +
> +
> +/*************************************
> + * Structures and helpers definitions
> + *************************************/
> +
> +struct team;
> +
> +struct team_port {
> + struct net_device *dev;
> + struct hlist_node hlist; /* node in hash list */
> + struct list_head list; /* node in ordinary list */
> + struct team *team;
> + int index;
> +
> + /*
> + * A place for storing original values of the device before
> it
> + * become a port.
> + */
> + struct {
> + unsigned char dev_addr[MAX_ADDR_LEN];
> + unsigned int mtu;
> + } orig;
> +
> + bool linkup;
> + u32 speed;
> + u8 duplex;
> +
> + struct rcu_head rcu;
> +};
> +
> +struct team_mode_ops {
> + int (*init)(struct team *team);
> + void (*exit)(struct team *team);
> + rx_handler_result_t (*receive)(struct team *team,
> + struct team_port *port,
> + struct sk_buff *skb);
nitpick:
As it doesn't have any other type of results, I would suggest
to rename rx_handler_result_t be to shorter, i.e. rx_result_t.
> + bool (*transmit)(struct team *team, struct sk_buff *skb);
> + int (*port_enter)(struct team *team, struct team_port *port);
Perhaps instead of 'port_enter', use 'port_join'.
> + void (*port_leave)(struct team *team, struct team_port
> *port);
> + void (*port_change_mac)(struct team *team, struct team_port
> *port); +};
> +
> +enum team_option_type {
> + TEAM_OPTION_TYPE_U32,
> + TEAM_OPTION_TYPE_STRING,
> +};
> +
> +struct team_option {
> + struct list_head list;
> + const char *name;
> + enum team_option_type type;
> + int (*getter)(struct team *team, void *arg);
> + int (*setter)(struct team *team, void *arg);
What means getter and setter?
> +};
> +
> +struct team_mode {
> + const char *kind;
> + const struct team_mode_ops *ops;
> +};
> +
> +struct rr_priv {
> + unsigned int sent_packets;
> +};
> +
> +struct ab_priv {
> + struct team_port __rcu *active_port;
> +};
> +
> +struct team {
> + struct net_device *dev; /* associated netdevice */
> + spinlock_t lock; /* used for overall locking, e.g. port
> lists write */ +
> + /*
> + * port lists with port count
> + */
> + int port_count;
> + struct hlist_head *port_hlist;
> + struct list_head port_list;
> +
> + struct list_head option_list;
> +
> + const char *mode_kind;
> + struct team_mode_ops mode_ops;
> + union {
> + char priv_first_byte;
> + struct ab_priv ab_priv;
> + struct rr_priv rr_priv;
> + };
I think the union should be a pointer or work in the same
way as netdev_priv() does.
> +};
> +
> +#define TEAM_PORT_HASHBITS 4
> +#define TEAM_PORT_HASHENTRIES (1 << TEAM_PORT_HASHBITS)
> +
> +static struct hlist_head *team_port_index_hash(const struct team
> *team,
> + int port_index)
> +{
> + return &team->port_hlist[port_index & (TEAM_PORT_HASHENTRIES
> - 1)]; +}
> +
> +static struct team_port *team_get_port_by_index_rcu(const struct
> team *team,
> + int port_index)
> +{
> + struct hlist_node *p;
> + struct team_port *port;
> + struct hlist_head *head = team_port_index_hash(team,
> port_index); +
> + hlist_for_each_entry_rcu(port, p, head, hlist)
> + if (port->index == port_index)
> + return port;
> + return NULL;
> +}
> +
> +static bool team_port_find(const struct team *team,
> + const struct team_port *port)
> +{
> + struct team_port *cur;
> +
> + list_for_each_entry(cur, &team->port_list, list)
> + if (cur == port)
> + return true;
> + return false;
> +}
> +
> +#define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
> +
> +static struct team_port *team_port_get_rcu(const struct net_device
> *dev) +{
> + struct team_port *port =
> rcu_dereference(dev->rx_handler_data); +
> + return team_port_exists(dev) ? port : NULL;
> +}
> +
> +static struct team_port *team_port_get_rtnl(const struct net_device
> *dev) +{
> + struct team_port *port =
> rtnl_dereference(dev->rx_handler_data); +
> + return team_port_exists(dev) ? port : NULL;
> +}
> +
> +/*
> + * Since the ability to change mac address for open port device is
> tested in
> + * team_port_add, this function can be called without control of
> return value
> + */
> +static int __set_port_mac(struct net_device *port_dev,
> + const unsigned char *dev_addr)
> +{
> + struct sockaddr addr;
> +
> + memcpy(addr.sa_data, dev_addr, ETH_ALEN);
> + addr.sa_family = ARPHRD_ETHER;
> + return dev_set_mac_address(port_dev, &addr);
> +}
> +
> +static int team_port_set_orig_mac(struct team_port *port)
> +{
> + return __set_port_mac(port->dev, port->orig.dev_addr);
> +}
> +
> +static int team_port_set_team_mac(struct team_port *port)
> +{
> + return __set_port_mac(port->dev, port->team->dev->dev_addr);
> +}
> +
> +
> +/*******************
> + * Options handling
> + *******************/
> +
> +static void team_options_register(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + int i;
> +
> + for (i = 0; i < option_count; i++, option++)
> + list_add_tail(&option->list, &team->option_list);
> +}
> +
> +static void __team_options_change_check(struct team *team,
> + struct team_option
> *changed_option); +
> +static void __team_options_unregister(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + int i;
> +
> + for (i = 0; i < option_count; i++, option++)
> + list_del(&option->list);
> +}
> +
> +static void team_options_unregister(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + __team_options_unregister(team, option, option_count);
> + __team_options_change_check(team, NULL);
> +}
> +
> +static int team_option_get(struct team *team, struct team_option
> *option,
> + void *arg)
> +{
> + return option->getter(team, arg);
> +}
> +
> +static int team_option_set(struct team *team, struct team_option
> *option,
> + void *arg)
> +{
> + int err;
> +
> + err = option->setter(team, arg);
> + if (err)
> + return err;
> +
> + __team_options_change_check(team, option);
> + return err;
> +}
> +
> +/******************************
> + * Round-robin mode definition
> + ******************************/
> +
> +static struct team_port *__get_first_port_up(struct team *team,
> + struct team_port *port)
> +{
> + struct team_port *cur;
> +
> + if (port->linkup)
> + return port;
> + cur = port;
> + list_for_each_entry_continue_rcu(cur, &team->port_list, list)
> + if (cur->linkup)
> + return cur;
> + list_for_each_entry_rcu(cur, &team->port_list, list) {
> + if (cur == port)
> + break;
> + if (cur->linkup)
> + return cur;
> + }
> + return NULL;
> +}
> +
> +static bool rr_transmit(struct team *team, struct sk_buff *skb)
> +{
> + struct team_port *port;
> + int port_index;
> +
> + port_index = team->rr_priv.sent_packets++ % team->port_count;
> + port = team_get_port_by_index_rcu(team, port_index);
> + port = __get_first_port_up(team, port);
Well, __get_first_port_up() will frequently just do:
if (port->linkup)
return port;
so, as it is in the hot TX path, can this be modified to be something
like below to avoid one function call?
port = team_get_port_by_index_rcu(team, port_index);
if (unlikely(port->linkup))
port = __get_first_port_up(team, port);
> + if (unlikely(!port))
> + goto drop;
> + skb->dev = port->dev;
> + if (dev_queue_xmit(skb))
> + goto drop;
> +
> + return true;
> +
> +drop:
> + dev_kfree_skb(skb);
> + return false;
> +}
> +
> +static int rr_port_enter(struct team *team, struct team_port *port)
> +{
> + return team_port_set_team_mac(port);
> +}
> +
> +static void rr_port_change_mac(struct team *team, struct team_port
> *port) +{
> + team_port_set_team_mac(port);
> +}
> +
> +static const struct team_mode_ops rr_mode_ops = {
> + .transmit = rr_transmit,
> + .port_enter = rr_port_enter,
> + .port_change_mac = rr_port_change_mac,
> +};
> +
> +static const struct team_mode rr_mode = {
> + .kind = "roundrobin",
> + .ops = &rr_mode_ops,
> +};
> +
> +
> +/********************************
> + * Active-backup mode definition
> + ********************************/
> +
> +static rx_handler_result_t ab_receive(struct team *team, struct
> team_port *port,
> + struct sk_buff *skb) {
> + struct team_port *active_port;
> +
> + active_port = rcu_dereference(team->ab_priv.active_port);
> + if (active_port != port)
> + return RX_HANDLER_EXACT;
> + return RX_HANDLER_ANOTHER;
> +}
> +
> +static bool ab_transmit(struct team *team, struct sk_buff *skb)
> +{
> + struct team_port *active_port;
> +
> + active_port = rcu_dereference(team->ab_priv.active_port);
> + if (unlikely(!active_port))
> + goto drop;
> + skb->dev = active_port->dev;
> + if (dev_queue_xmit(skb))
> + goto drop;
> + return true;
> +
> +drop:
> + dev_kfree_skb(skb);
> + return false;
> +}
> +
> +static void ab_port_leave(struct team *team, struct team_port *port)
> +{
> + if (team->ab_priv.active_port == port)
> + rcu_assign_pointer(team->ab_priv.active_port, NULL);
> +}
> +
> +static void ab_port_change_mac(struct team *team, struct team_port
> *port) +{
> + if (team->ab_priv.active_port == port)
> + team_port_set_team_mac(port);
> +}
> +
> +static int ab_active_port_get(struct team *team, void *arg)
> +{
> + u32 *ifindex = arg;
> +
> + *ifindex = 0;
> + if (team->ab_priv.active_port)
> + *ifindex = team->ab_priv.active_port->dev->ifindex;
> + return 0;
> +}
> +
> +static int ab_active_port_set(struct team *team, void *arg)
> +{
> + u32 *ifindex = arg;
> + struct team_port *port;
> +
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + if (port->dev->ifindex == *ifindex) {
> + struct team_port *ac_port =
> team->ab_priv.active_port; +
> + /* rtnl_lock needs to be held when setting
> macs */
> + rtnl_lock();
> + if (ac_port)
> + team_port_set_orig_mac(ac_port);
> +
> rcu_assign_pointer(team->ab_priv.active_port, port);
> + team_port_set_team_mac(port);
> + rtnl_unlock();
> + return 0;
> + }
> + }
> + return -ENOENT;
> +}
> +
> +static struct team_option ab_options[] = {
> + {
> + .name = "activeport",
> + .type = TEAM_OPTION_TYPE_U32,
> + .getter = ab_active_port_get,
> + .setter = ab_active_port_set,
> + },
> +};
> +
> +int ab_init(struct team *team)
> +{
> + team_options_register(team, ab_options,
> ARRAY_SIZE(ab_options));
> + return 0;
> +}
> +
> +void ab_exit(struct team *team)
> +{
> + team_options_unregister(team, ab_options,
> ARRAY_SIZE(ab_options)); +}
> +
> +static const struct team_mode_ops ab_mode_ops = {
> + .init = ab_init,
> + .exit = ab_exit,
> + .receive = ab_receive,
> + .transmit = ab_transmit,
> + .port_leave = ab_port_leave,
> + .port_change_mac = ab_port_change_mac,
> +};
> +
> +static const struct team_mode ab_mode = {
> + .kind = "activebackup",
> + .ops = &ab_mode_ops,
> +};
> +
I would suggest to move each of the ab and rr specifics
to their own module. The idea is to have the team module
as a generic module as possible and every mode on its module.
Not sure what your plans are for this.
> +/****************
> + * Mode handling
> + ****************/
> +
> +static const struct team_mode *team_modes[] = {
> + &rr_mode,
> + &ab_mode,
> +};
Following the above suggestion, this would require
register/unregister ops.
> +
> +static const int team_mode_count = ARRAY_SIZE(team_modes);
> +
> +static int team_find_mode(const char *kind)
> +{
> + int i;
> +
> + for (i = 0; i < team_mode_count; i++) {
> + const struct team_mode *mode = team_modes[i];
> +
> + if (strcmp(mode->kind, kind) == 0)
> + return i;
> + }
> + return -ENOENT;
> +}
> +
> +/*
> + * We can benefit from the fact that it's ensured no port is present
> + * at the time of mode change.
> + */
> +static void __team_change_mode(struct team *team, const int
> mode_index) +{
> + const struct team_mode *mode = team_modes[mode_index];
> +
> + if (team->mode_ops.exit)
> + team->mode_ops.exit(team);
> +
> + if (mode_index < 0)
> + return;
> +
> + memcpy(&team->mode_ops, mode->ops, sizeof(struct
> team_mode_ops)); +
> + /* zero private data area */
> + memset(&team->priv_first_byte, 0,
> + sizeof(struct team) - offsetof(struct team,
> priv_first_byte)); +
> + team->mode_kind = mode->kind;
> + if (team->mode_ops.init)
> + team->mode_ops.init(team);
> +
> + return;
> +}
> +
> +static int team_change_mode(struct team *team, const char *kind)
> +{
> + int mode_index;
> + struct net_device *dev = team->dev;
> +
> + if (!list_empty(&team->port_list)) {
> + netdev_err(dev, "No ports can be present during "
> + "mode change\n");
> + return -EBUSY;
> + }
> +
> + if (strcmp(team->mode_kind, kind) == 0) {
> + netdev_err(dev, "Unable to change to the same mode "
> + "the team is in\n");
> + return -EINVAL;
> + }
> +
> + mode_index = team_find_mode(kind);
> + if (mode_index < 0) {
> + netdev_err(dev, "Mode \"%s\" is not loaded\n", kind);
> + return -EINVAL;
> + }
> +
> + __team_change_mode(team, mode_index);
> +
> + netdev_info(dev, "Mode changed to \"%s\"\n", kind);
> + return 0;
> +}
> +
> +
> +/************************
> + * Rx path frame handler
> + ************************/
> +
> +/* note: already called with rcu_read_lock */
> +static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
> +{
> + struct sk_buff *skb = *pskb;
> + struct team_port *port;
> + struct team *team;
> + rx_handler_result_t res = RX_HANDLER_ANOTHER;
> +
> + skb = skb_share_check(skb, GFP_ATOMIC);
> + if (!skb)
> + return RX_HANDLER_CONSUMED;
> +
> + *pskb = skb;
> +
> + port = team_port_get_rcu(skb->dev);
> + team = port->team;
> +
> + if (team->mode_ops.receive)
> + res = team->mode_ops.receive(team, port, skb);
> +
> + if (res == RX_HANDLER_ANOTHER)
> + skb->dev = team->dev;
> +
> + return res;
> +}
> +
> +
> +/****************
> + * Port handling
> + ****************/
> +
> +static int team_port_list_init(struct team *team)
> +{
> + int i;
> + struct hlist_head *hash;
> +
> + hash = kmalloc(sizeof(*hash) * TEAM_PORT_HASHENTRIES,
> GFP_KERNEL);
> + if (hash != NULL) {
> + for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
> + INIT_HLIST_HEAD(&hash[i]);
> + } else {
> + return -ENOMEM;
> + }
> + team->port_hlist = hash;
> + INIT_LIST_HEAD(&team->port_list);
> + return 0;
> +}
> +
> +static void team_port_list_fini(struct team *team)
> +{
> + kfree(team->port_hlist);
> +}
> +
> +/*
> + * Add/delete port to the team port list. Write guarded by rtnl_lock.
> + * Takes care of correct port->index setup (might be racy).
> + */
> +static void team_port_list_add_port(struct team *team,
> + struct team_port *port)
> +{
> + port->index = team->port_count++;
> + hlist_add_head_rcu(&port->hlist,
> + team_port_index_hash(team, port->index));
> + list_add_tail_rcu(&port->list, &team->port_list);
> +}
> +
> +static void __reconstruct_port_hlist(struct team *team, int rm_index)
> +{
> + int i;
> + struct team_port *port;
> +
> + for (i = rm_index + 1; i < team->port_count; i++) {
> + port = team_get_port_by_index_rcu(team, i);
> + hlist_del_rcu(&port->hlist);
> + port->index--;
> + hlist_add_head_rcu(&port->hlist,
> + team_port_index_hash(team,
> port->index));
> + }
> +}
> +
> +static void team_port_list_del_port(struct team *team,
> + struct team_port *port)
> +{
> + int rm_index = port->index;
> +
> + hlist_del_rcu(&port->hlist);
> + list_del_rcu(&port->list);
> + __reconstruct_port_hlist(team, rm_index);
> + team->port_count--;
> +}
> +
> +#define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
> + NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
> + NETIF_F_HIGHDMA | NETIF_F_LRO)
> +
> +static void __team_compute_features(struct team *team)
> +{
> + struct team_port *port;
> + u32 vlan_features = TEAM_VLAN_FEATURES;
> + unsigned short max_hard_header_len = ETH_HLEN;
> +
> + list_for_each_entry(port, &team->port_list, list) {
> + vlan_features =
> netdev_increment_features(vlan_features,
> + port->dev->vlan_features,
> + TEAM_VLAN_FEATURES);
> +
> + if (port->dev->hard_header_len > max_hard_header_len)
> + max_hard_header_len =
> port->dev->hard_header_len;
> + }
> +
> + team->dev->vlan_features = vlan_features;
> + team->dev->hard_header_len = max_hard_header_len;
> +
> + netdev_change_features(team->dev);
> +}
> +
> +static void team_compute_features(struct team *team)
> +{
> + spin_lock(&team->lock);
> + __team_compute_features(team);
> + spin_unlock(&team->lock);
> +}
> +
> +static int team_port_enter(struct team *team, struct team_port *port)
> +{
> + int err = 0;
> +
> + dev_hold(team->dev);
> + port->dev->priv_flags |= IFF_TEAM_PORT;
> + if (team->mode_ops.port_enter) {
> + err = team->mode_ops.port_enter(team, port);
> + if (err)
> + netdev_err(team->dev, "Device %s failed to "
> + "enter team mode\n",
> + port->dev->name);
> + }
> + return err;
> +}
s/port_enter/port_join/
> +
> +static void team_port_leave(struct team *team, struct team_port
> *port) +{
> + if (team->mode_ops.port_leave)
> + team->mode_ops.port_leave(team, port);
> + port->dev->priv_flags &= ~IFF_TEAM_PORT;
> + dev_put(team->dev);
> +}
> +
> +static void __team_port_change_check(struct team_port *port, bool
> linkup); +
> +static int team_port_add(struct team *team, struct net_device
> *port_dev) +{
> + struct net_device *dev = team->dev;
> + struct team_port *port;
> + char *portname = port_dev->name;
> + char tmp_addr[ETH_ALEN];
> + int err;
> +
> + if (port_dev->flags & IFF_LOOPBACK ||
> + port_dev->type != ARPHRD_ETHER) {
> + netdev_err(dev, "Device %s is of an unsupported
> type\n",
> + portname);
> + return -EINVAL;
> + }
> +
> + if (team_port_exists(port_dev)) {
> + netdev_err(dev, "Device %s is already a port "
> + "of a team device\n", portname);
> + return -EBUSY;
> + }
> +
> + if (port_dev->flags & IFF_UP) {
> + netdev_err(dev, "Device %s is up. Set it down before
> "
> + "adding it as a team port\n",
> portname);
> + return -EBUSY;
> + }
> +
> + port = kzalloc(sizeof(struct team_port), GFP_KERNEL);
> + if (!port)
> + return -ENOMEM;
> +
> + port->dev = port_dev;
> + port->team = team;
> +
> + port->orig.mtu = port_dev->mtu;
> + err = dev_set_mtu(port_dev, dev->mtu);
> + if (err) {
> + netdev_dbg(dev, "Error %d calling dev_set_mtu\n",
> err);
> + goto err_set_mtu;
> + }
> +
> + memcpy(port->orig.dev_addr, port_dev->dev_addr, ETH_ALEN);
> + random_ether_addr(tmp_addr);
> + err = __set_port_mac(port_dev, tmp_addr);
> + if (err) {
> + netdev_dbg(dev, "Device %s mac addr set failed\n",
> + portname);
> + goto err_set_mac_rand;
> + }
> +
> + err = dev_open(port_dev);
> + if (err) {
> + netdev_dbg(dev, "Device %s opening failed\n",
> + portname);
> + goto err_dev_open;
> + }
> +
> + err = team_port_set_orig_mac(port);
> + if (err) {
> + netdev_dbg(dev, "Device %s mac addr set failed -
> Device does "
> + "not support addr change when it's
> opened\n",
> + portname);
> + goto err_set_mac_opened;
> + }
> +
> + err = team_port_enter(team, port);
> + if (err) {
> + netdev_err(dev, "Device %s failed to enter team
> mode\n",
> + portname);
> + goto err_port_enter;
> + }
> +
> + err = netdev_set_master(port_dev, dev);
> + if (err) {
> + netdev_err(dev, "Device %s failed to set "
> + "master\n", portname);
> + goto err_set_master;
> + }
> +
> + err = netdev_rx_handler_register(port_dev, team_handle_frame,
> + port);
> + if (err) {
> + netdev_err(dev, "Device %s failed to register "
> + "rx_handler\n", portname);
> + goto err_handler_register;
> + }
> +
> + team_port_list_add_port(team, port);
> + __team_compute_features(team);
> + __team_port_change_check(port, !!netif_carrier_ok(port_dev));
> +
> + netdev_info(dev, "Port device %s added\n", portname);
> +
> + return 0;
> +
> +err_handler_register:
> + netdev_set_master(port_dev, NULL);
> +
> +err_set_master:
> + team_port_leave(team, port);
> +
> +err_port_enter:
> +err_set_mac_opened:
> + dev_close(port_dev);
> +
> +err_dev_open:
> + team_port_set_orig_mac(port);
> +
> +err_set_mac_rand:
> + dev_set_mtu(port_dev, port->orig.mtu);
> +
> +err_set_mtu:
> + kfree(port);
> +
> + return err;
> +}
> +
> +static int team_port_del(struct team *team, struct net_device
> *port_dev) +{
> + struct net_device *dev = team->dev;
> + struct team_port *port;
> + char *portname = port_dev->name;
> +
> + port = team_port_get_rtnl(port_dev);
> + if (!port || !team_port_find(team, port)) {
> + netdev_err(dev, "Device %s does not act as a port "
> + "of this team\n", portname);
> + return -ENOENT;
> + }
> +
> + __team_port_change_check(port, false);
> + team_port_list_del_port(team, port);
> + netdev_rx_handler_unregister(port_dev);
> + netdev_set_master(port_dev, NULL);
> + team_port_leave(team, port);
> + dev_close(port_dev);
> + team_port_set_orig_mac(port);
> + dev_set_mtu(port_dev, port->orig.mtu);
> + synchronize_rcu();
> + kfree(port);
> + netdev_info(dev, "Port device %s removed\n", portname);
> + __team_compute_features(team);
> +
> + return 0;
> +}
> +
> +
> +/*****************
> + * Net device ops
> + ****************/
> +
> +static int team_mode_option_get(struct team *team, void *arg)
> +{
> + const char **str = arg;
> +
> + *str = team->mode_kind;
> + return 0;
> +}
> +
> +static int team_mode_option_set(struct team *team, void *arg)
> +{
> + const char **str = arg;
> +
> + return team_change_mode(team, *str);
> +}
> +
> +static struct team_option team_options[] = {
> + {
> + .name = "mode",
> + .type = TEAM_OPTION_TYPE_STRING,
> + .getter = team_mode_option_get,
> + .setter = team_mode_option_set,
> + },
> +};
> +
> +static int team_init(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + team->dev = dev;
> + spin_lock_init(&team->lock);
> +
> + err = team_port_list_init(team);
> + if (err)
> + return err;
> +
> + INIT_LIST_HEAD(&team->option_list);
> + team_options_register(team, team_options,
> ARRAY_SIZE(team_options));
> + __team_change_mode(team, 0); /* set default mode */
> + netif_carrier_off(dev);
> +
> + return 0;
> +}
> +
> +static void team_uninit(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + struct team_port *tmp;
> +
> + spin_lock(&team->lock);
> + list_for_each_entry_safe(port, tmp, &team->port_list, list)
> + team_port_del(team, port->dev);
> +
> + __team_change_mode(team, -1); /* cleanup */
> + __team_options_unregister(team, team_options,
> ARRAY_SIZE(team_options));
> + spin_unlock(&team->lock);
> +}
> +
> +static void team_destructor(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> +
> + team_port_list_fini(team);
> + free_netdev(dev);
> +}
> +
> +static int team_open(struct net_device *dev)
> +{
> + netif_carrier_on(dev);
> + return 0;
> +}
> +
> +static int team_close(struct net_device *dev)
> +{
> + netif_carrier_off(dev);
> + return 0;
> +}
> +
> +/*
> + * note: already called with rcu_read_lock
> + */
> +static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device
> *dev) +{
> + struct team *team = netdev_priv(dev);
> +
> + /*
> + * Ensure transmit function is called only in case there is
> at least
> + * one port present.
> + */
> + if (likely(!list_empty(&team->port_list)))
> + team->mode_ops.transmit(team, skb);
> +
> + return NETDEV_TX_OK;
> +}
> +
> +static void team_change_rx_flags(struct net_device *dev, int change)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + int inc;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + if (change & IFF_PROMISC) {
> + inc = dev->flags & IFF_PROMISC ? 1 : -1;
> + dev_set_promiscuity(port->dev, inc);
> + }
> + if (change & IFF_ALLMULTI) {
> + inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
> + dev_set_allmulti(port->dev, inc);
> + }
> + }
> + rcu_read_unlock();
> +}
> +
> +static void team_set_rx_mode(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + dev_uc_sync(port->dev, dev);
> + dev_mc_sync(port->dev, dev);
> + }
> + rcu_read_unlock();
> +}
> +
> +static int team_set_mac_address(struct net_device *dev, void *p)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + struct sockaddr *addr = p;
> +
> + memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list)
> + if (team->mode_ops.port_change_mac)
> + team->mode_ops.port_change_mac(team, port);
> + rcu_read_unlock();
> + return 0;
> +}
> +
> +static int team_change_mtu(struct net_device *dev, int new_mtu)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + int err;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + err = dev_set_mtu(port->dev, new_mtu);
> + if (err) {
> + netdev_err(dev, "Device %s failed to change
> mtu",
> + port->dev->name);
> + goto unwind;
> + }
> + }
> + rcu_read_unlock();
> +
> + dev->mtu = new_mtu;
> +
> + return 0;
> +
> +unwind:
> + list_for_each_entry_continue_reverse(port, &team->port_list,
> list)
> + dev_set_mtu(port->dev, dev->mtu);
> +
> + rcu_read_unlock();
> + return err;
> +}
> +
> +static struct rtnl_link_stats64 *team_get_stats(struct net_device
> *dev,
> + struct
> rtnl_link_stats64 *stats) +{
> + struct team *team = netdev_priv(dev);
> + struct rtnl_link_stats64 temp;
> + struct team_port *port;
> +
> + memset(stats, 0, sizeof(*stats));
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct rtnl_link_stats64 *pstats;
> +
> + pstats = dev_get_stats(port->dev, &temp);
> +
> + stats->rx_packets += pstats->rx_packets;
> + stats->rx_bytes += pstats->rx_bytes;
> + stats->rx_errors += pstats->rx_errors;
> + stats->rx_dropped += pstats->rx_dropped;
> +
> + stats->tx_packets += pstats->tx_packets;
> + stats->tx_bytes += pstats->tx_bytes;
> + stats->tx_errors += pstats->tx_errors;
> + stats->tx_dropped += pstats->tx_dropped;
> +
> + stats->multicast += pstats->multicast;
> + stats->collisions += pstats->collisions;
> +
> + stats->rx_length_errors += pstats->rx_length_errors;
> + stats->rx_over_errors += pstats->rx_over_errors;
> + stats->rx_crc_errors += pstats->rx_crc_errors;
> + stats->rx_frame_errors += pstats->rx_frame_errors;
> + stats->rx_fifo_errors += pstats->rx_fifo_errors;
> + stats->rx_missed_errors += pstats->rx_missed_errors;
> +
> + stats->tx_aborted_errors +=
> pstats->tx_aborted_errors;
> + stats->tx_carrier_errors +=
> pstats->tx_carrier_errors;
> + stats->tx_fifo_errors += pstats->tx_fifo_errors;
> + stats->tx_heartbeat_errors +=
> pstats->tx_heartbeat_errors;
> + stats->tx_window_errors += pstats->tx_window_errors;
> + }
> + rcu_read_unlock();
> +
> + return stats;
> +}
I don't think computing stats like that is useful. We can do
that in userlevel with ethtool -S on each slave and sum all them.
I think it would be better to have the errors computed based on
events that happens inside of Team driver, so we can really see if
something is happening inside of the Team driver or on its slaves.
> +
> +static void team_vlan_rx_add_vid(struct net_device *dev, uint16_t
> vid) +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct net_device_ops *ops =
> port->dev->netdev_ops; +
> + ops->ndo_vlan_rx_add_vid(port->dev, vid);
> + }
> + rcu_read_unlock();
> +}
> +
> +static void team_vlan_rx_kill_vid(struct net_device *dev, uint16_t
> vid) +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct net_device_ops *ops =
> port->dev->netdev_ops; +
> + ops->ndo_vlan_rx_kill_vid(port->dev, vid);
> + }
> + rcu_read_unlock();
> +}
> +
> +static int team_add_slave(struct net_device *dev, struct net_device
> *port_dev) +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + spin_lock(&team->lock);
> + err = team_port_add(team, port_dev);
> + spin_unlock(&team->lock);
> + return err;
> +}
I am not seeing any difference between slave and port, so why not stick
with just one?
> +
> +static int team_del_slave(struct net_device *dev, struct net_device
> *port_dev) +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + spin_lock(&team->lock);
> + err = team_port_del(team, port_dev);
> + spin_unlock(&team->lock);
> + return err;
> +}
> +
> +static const struct net_device_ops team_netdev_ops = {
> + .ndo_init = team_init,
> + .ndo_uninit = team_uninit,
> + .ndo_open = team_open,
> + .ndo_stop = team_close,
> + .ndo_start_xmit = team_xmit,
> + .ndo_change_rx_flags = team_change_rx_flags,
> + .ndo_set_rx_mode = team_set_rx_mode,
> + .ndo_set_mac_address = team_set_mac_address,
> + .ndo_change_mtu = team_change_mtu,
> + .ndo_get_stats64 = team_get_stats,
> + .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
> + .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
> + .ndo_add_slave = team_add_slave,
> + .ndo_del_slave = team_del_slave,
> +};
> +
> +
> +/***********************
> + * rt netlink interface
> + ***********************/
> +
> +static void team_setup(struct net_device *dev)
> +{
> + ether_setup(dev);
> +
> + dev->netdev_ops = &team_netdev_ops;
> + dev->destructor = team_destructor;
> + dev->tx_queue_len = 0;
> + dev->flags |= IFF_MULTICAST;
> + dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE |
> IFF_TX_SKB_SHARING); +
> + /*
> + * Indicate we support unicast address filtering. That way
> core won't
> + * bring us to promisc mode in case a unicast addr is added.
> + * Let this up to underlay drivers.
> + */
> + dev->priv_flags |= IFF_UNICAST_FLT;
> +
> + dev->features |= NETIF_F_LLTX;
> + dev->features |= NETIF_F_GRO;
> + dev->hw_features = NETIF_F_HW_VLAN_TX |
> + NETIF_F_HW_VLAN_RX |
> + NETIF_F_HW_VLAN_FILTER;
> +
> + dev->features |= dev->hw_features;
> +}
> +
> +static int team_newlink(struct net *src_net, struct net_device *dev,
> + struct nlattr *tb[], struct nlattr *data[])
> +{
> + int err;
> +
> + if (tb[IFLA_ADDRESS] == NULL)
> + random_ether_addr(dev->dev_addr);
> +
> + err = register_netdevice(dev);
> + if (err)
> + return err;
> +
> + return 0;
> +}
> +
> +static int team_validate(struct nlattr *tb[], struct nlattr *data[])
> +{
> + if (tb[IFLA_ADDRESS]) {
> + if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
> + return -EINVAL;
> + if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
> + return -EADDRNOTAVAIL;
> + }
> + return 0;
> +}
> +
> +static struct rtnl_link_ops team_link_ops __read_mostly = {
> + .kind = DRV_NAME,
> + .priv_size = sizeof(struct team),
> + .setup = team_setup,
> + .newlink = team_newlink,
> + .validate = team_validate,
> +};
> +
> +
> +/***********************************
> + * Generic netlink custom interface
> + ***********************************/
> +
> +static struct genl_family team_nl_family = {
> + .id = GENL_ID_GENERATE,
> + .name = TEAM_GENL_NAME,
> + .version = TEAM_GENL_VERSION,
> + .maxattr = TEAM_ATTR_MAX,
> + .netnsok = true,
> +};
> +
> +static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
> + [TEAM_ATTR_UNSPEC] = { .type =
> NLA_UNSPEC, },
> + [TEAM_ATTR_TEAM_IFINDEX] = { .type =
> NLA_U32 },
> + [TEAM_ATTR_LIST_OPTION] = { .type =
> NLA_NESTED },
> + [TEAM_ATTR_LIST_MODE] = { .type =
> NLA_NESTED },
> + [TEAM_ATTR_LIST_PORT] = { .type =
> NLA_NESTED }, +};
> +
> +static const struct nla_policy
> team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
> + [TEAM_ATTR_OPTION_UNSPEC] = { .type =
> NLA_UNSPEC, },
> + [TEAM_ATTR_OPTION_NAME] = {
> + .type = NLA_STRING,
> + .len = TEAM_STRING_MAX_LEN,
> + },
> + [TEAM_ATTR_OPTION_CHANGED] = { .type =
> NLA_FLAG },
> + [TEAM_ATTR_OPTION_TYPE] = { .type =
> NLA_U8 },
> + [TEAM_ATTR_OPTION_DATA] = {
> + .type = NLA_BINARY,
> + .len = TEAM_STRING_MAX_LEN,
> + },
> +};
> +
> +static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info
> *info) +{
> + struct sk_buff *msg;
> + void *hdr;
> + int err;
> +
> + msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!msg)
> + return -ENOMEM;
> +
> + hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
> + &team_nl_family, 0, TEAM_CMD_NOOP);
> + if (IS_ERR(hdr)) {
> + err = PTR_ERR(hdr);
> + goto err_msg_put;
> + }
> +
> + genlmsg_end(msg, hdr);
> +
> + return genlmsg_unicast(genl_info_net(info), msg,
> info->snd_pid); +
> +err_msg_put:
> + nlmsg_free(msg);
> +
> + return err;
> +}
> +
> +/*
> + * Netlink cmd functions should be locked by following two functions.
> + * To ensure team_uninit would not be called in between, hold
> rcu_read_lock
> + * all the time.
> + */
> +static struct team *team_nl_team_get(struct genl_info *info)
> +{
> + struct net *net = genl_info_net(info);
> + int ifindex;
> + struct net_device *dev;
> + struct team *team;
> +
> + if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
> + return NULL;
> +
> + ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
> + rcu_read_lock();
> + dev = dev_get_by_index_rcu(net, ifindex);
> + if (!dev || dev->netdev_ops != &team_netdev_ops) {
> + rcu_read_unlock();
> + return NULL;
> + }
> +
> + team = netdev_priv(dev);
> + spin_lock(&team->lock);
> + return team;
> +}
> +
> +static void team_nl_team_put(struct team *team)
> +{
> + spin_unlock(&team->lock);
> + rcu_read_unlock();
> +}
> +
> +static int team_nl_send_generic(struct genl_info *info, struct team
> *team,
> + int (*fill_func)(struct sk_buff *skb,
> + struct genl_info
> *info,
> + int flags, struct
> team *team)) +{
> + struct sk_buff *skb;
> + int err;
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = fill_func(skb, info, NLM_F_ACK, team);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_unicast(genl_info_net(info), skb,
> info->snd_pid);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_fill_options_get_changed(struct sk_buff *skb,
> + u32 pid, u32 seq, int
> flags,
> + struct team *team,
> + struct team_option
> *changed_option) +{
> + struct nlattr *option_list;
> + void *hdr;
> + struct team_option *option;
> +
> + hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
> + TEAM_CMD_OPTIONS_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + option_list = nla_nest_start(skb, TEAM_ATTR_LIST_OPTION);
> + if (!option_list)
> + return -EMSGSIZE;
> +
> + list_for_each_entry(option, &team->option_list, list) {
> + struct nlattr *option_item;
> + long arg;
> +
> + option_item = nla_nest_start(skb,
> TEAM_ATTR_ITEM_OPTION);
> + if (!option_item)
> + goto nla_put_failure;
> + NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_NAME,
> option->name);
> + if (option == changed_option)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_OPTION_CHANGED);
> + switch (option->type) {
> + case TEAM_OPTION_TYPE_U32:
> + NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE,
> NLA_U32);
> + team_option_get(team, option, &arg);
> + NLA_PUT_U32(skb, TEAM_ATTR_OPTION_DATA, arg);
> + break;
> + case TEAM_OPTION_TYPE_STRING:
> + NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE,
> NLA_STRING);
> + team_option_get(team, option, &arg);
> + NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_DATA,
> (char *) arg);
> + break;
> + default:
> + BUG();
> + }
> + nla_nest_end(skb, option_item);
> + }
> +
> + nla_nest_end(skb, option_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_fill_options_get(struct sk_buff *skb,
> + struct genl_info *info, int
> flags,
> + struct team *team)
> +{
> + return team_nl_fill_options_get_changed(skb, info->snd_pid,
> + info->snd_seq,
> NLM_F_ACK,
> + team, NULL);
> +}
> +
> +static int team_nl_cmd_options_get(struct sk_buff *skb, struct
> genl_info *info) +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team,
> team_nl_fill_options_get); +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_cmd_options_set(struct sk_buff *skb, struct
> genl_info *info) +{
> + struct team *team;
> + int err = 0;
> + int i;
> + struct nlattr *nl_option;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = -EINVAL;
> + if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
> + err = -EINVAL;
> + goto team_put;
> + }
> +
> + nla_for_each_nested(nl_option,
> info->attrs[TEAM_ATTR_LIST_OPTION], i) {
> + struct nlattr *mode_attrs[TEAM_ATTR_OPTION_MAX + 1];
> + enum team_option_type opt_type;
> + struct team_option *option;
> + char *opt_name;
> +
> + if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) {
> + err = -EINVAL;
> + goto team_put;
> + }
> + err = nla_parse_nested(mode_attrs,
> TEAM_ATTR_OPTION_MAX,
> + nl_option,
> team_nl_option_policy);
> + if (err)
> + goto team_put;
> + if (!mode_attrs[TEAM_ATTR_OPTION_NAME] ||
> + !mode_attrs[TEAM_ATTR_OPTION_TYPE] ||
> + !mode_attrs[TEAM_ATTR_OPTION_DATA]) {
> + err = -EINVAL;
> + goto team_put;
> + }
> + switch
> (nla_get_u8(mode_attrs[TEAM_ATTR_OPTION_TYPE])) {
> + case NLA_U32:
> + opt_type = TEAM_OPTION_TYPE_U32;
> + break;
> + case NLA_STRING:
> + opt_type = TEAM_OPTION_TYPE_STRING;
> + break;
> + default:
> + goto team_put;
> + }
> +
> + opt_name =
> nla_data(mode_attrs[TEAM_ATTR_OPTION_NAME]);
> + list_for_each_entry(option, &team->option_list,
> list) {
> + long arg;
> +
> + if (option->type != opt_type ||
> + strcmp(option->name, opt_name))
> + continue;
> + switch (opt_type) {
> + case TEAM_OPTION_TYPE_U32:
> + arg =
> nla_get_u32(mode_attrs[TEAM_ATTR_OPTION_DATA]);
> + break;
> + case TEAM_OPTION_TYPE_STRING:
> + arg = (long)
> nla_data(mode_attrs[TEAM_ATTR_OPTION_DATA]);
> + break;
> + default:
> + BUG();
> + }
> + err = team_option_set(team, option, &arg);
> + if (err)
> + goto team_put;
> + }
> + }
> +
> +team_put:
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_fill_mode_list_get(struct sk_buff *skb,
> + struct genl_info *info, int
> flags,
> + struct team *team)
> +{
> + struct nlattr *mode_list;
> + void *hdr;
> + int i;
> +
> + hdr = genlmsg_put(skb, info->snd_pid, info->snd_seq,
> + &team_nl_family, flags,
> TEAM_CMD_MODE_LIST_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + mode_list = nla_nest_start(skb, TEAM_ATTR_LIST_MODE);
> + if (!mode_list)
> + return -EMSGSIZE;
> +
> + for (i = 0; i < team_mode_count; i++) {
> + const struct team_mode *mode = team_modes[i];
> + struct nlattr *mode_item;
> +
> + mode_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
> + if (!mode_item)
> + goto nla_put_failure;
> + NLA_PUT_STRING(skb, TEAM_ATTR_MODE_NAME, mode->kind);
> + nla_nest_end(skb, mode_item);
> + }
> +
> + nla_nest_end(skb, mode_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_cmd_mode_list_get(struct sk_buff *skb,
> + struct genl_info *info)
> +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team,
> team_nl_fill_mode_list_get); +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_fill_port_list_get_changed(struct sk_buff *skb,
> + u32 pid, u32 seq, int
> flags,
> + struct team *team,
> + struct team_port
> *changed_port) +{
> + struct nlattr *port_list;
> + void *hdr;
> + struct team_port *port;
> +
> + hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
> + TEAM_CMD_PORT_LIST_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + port_list = nla_nest_start(skb, TEAM_ATTR_LIST_PORT);
> + if (!port_list)
> + return -EMSGSIZE;
> +
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + struct nlattr *port_item;
> +
> + port_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
> + if (!port_item)
> + goto nla_put_failure;
> + NLA_PUT_U32(skb, TEAM_ATTR_PORT_IFINDEX,
> port->dev->ifindex);
> + if (port == changed_port)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_CHANGED);
> + if (port->linkup)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_LINKUP);
> + NLA_PUT_U32(skb, TEAM_ATTR_PORT_SPEED, port->speed);
> + NLA_PUT_U8(skb, TEAM_ATTR_PORT_DUPLEX, port->duplex);
> + nla_nest_end(skb, port_item);
> + }
> +
> + nla_nest_end(skb, port_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_fill_port_list_get(struct sk_buff *skb,
> + struct genl_info *info, int
> flags,
> + struct team *team)
> +{
> + return team_nl_fill_port_list_get_changed(skb, info->snd_pid,
> + info->snd_seq,
> NLM_F_ACK,
> + team, NULL);
> +}
> +
> +static int team_nl_cmd_port_list_get(struct sk_buff *skb,
> + struct genl_info *info)
> +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team,
> team_nl_fill_port_list_get); +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static struct genl_ops team_nl_ops[] = {
> + {
> + .cmd = TEAM_CMD_NOOP,
> + .doit = team_nl_cmd_noop,
> + .policy = team_nl_policy,
> + },
> + {
> + .cmd = TEAM_CMD_OPTIONS_SET,
> + .doit = team_nl_cmd_options_set,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_OPTIONS_GET,
> + .doit = team_nl_cmd_options_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_MODE_LIST_GET,
> + .doit = team_nl_cmd_mode_list_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_PORT_LIST_GET,
> + .doit = team_nl_cmd_port_list_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> +};
> +
> +static struct genl_multicast_group team_change_event_mcgrp = {
> + .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME,
> +};
> +
> +static int team_nl_send_event_options_get(struct team *team,
> + struct team_option
> *changed_option) +{
> + struct sk_buff *skb;
> + int err;
> + struct net *net = dev_net(team->dev);
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = team_nl_fill_options_get_changed(skb, 0, 0, 0, team,
> + changed_option);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_multicast_netns(net, skb, 0,
> team_change_event_mcgrp.id,
> + GFP_KERNEL);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_send_event_port_list_get(struct team_port *port)
> +{
> + struct sk_buff *skb;
> + int err;
> + struct net *net = dev_net(port->team->dev);
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = team_nl_fill_port_list_get_changed(skb, 0, 0, 0,
> + port->team, port);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_multicast_netns(net, skb, 0,
> team_change_event_mcgrp.id,
> + GFP_KERNEL);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_init(void)
> +{
> + int err;
> +
> + err = genl_register_family_with_ops(&team_nl_family,
> team_nl_ops,
> + ARRAY_SIZE(team_nl_ops));
> + if (err)
> + return err;
> +
> + err = genl_register_mc_group(&team_nl_family,
> &team_change_event_mcgrp);
> + if (err)
> + goto err_change_event_grp_reg;
> +
> + return 0;
> +
> +err_change_event_grp_reg:
> + genl_unregister_family(&team_nl_family);
> +
> + return err;
> +}
> +
> +static void team_nl_fini(void)
> +{
> + genl_unregister_family(&team_nl_family);
> +}
> +
> +
> +/******************
> + * Change checkers
> + ******************/
> +
> +static void __team_options_change_check(struct team *team,
> + struct team_option
> *changed_option) +{
> + int err;
> +
> + err = team_nl_send_event_options_get(team, changed_option);
> + if (err)
> + netdev_warn(team->dev, "Failed to send options
> change "
> + "via netlink\n");
> +}
> +
> +/* rtnl lock is held */
> +static void __team_port_change_check(struct team_port *port, bool
> linkup) +{
> + int err;
> +
> + if (port->linkup == linkup)
> + return;
> +
> + port->linkup = linkup;
> + if (linkup) {
> + struct ethtool_cmd ecmd;
> +
> + err = __ethtool_get_settings(port->dev, &ecmd);
> + if (!err) {
> + port->speed = ethtool_cmd_speed(&ecmd);
> + port->duplex = ecmd.duplex;
> + goto send_event;
> + }
> + }
> + port->speed = 0;
> + port->duplex = 0;
> +
> +send_event:
> + err = team_nl_send_event_port_list_get(port);
> + if (err)
> + netdev_warn(port->team->dev, "Failed to send port
> change of "
> + "device %s via
> netlink\n",
> + port->dev->name);
> +
> +}
> +
> +static void team_port_change_check(struct team_port *port, bool
> linkup) +{
> + struct team *team = port->team;
> +
> + spin_lock(&team->lock);
> + __team_port_change_check(port, linkup);
> + spin_unlock(&team->lock);
> +}
> +
> +/************************************
> + * Net device notifier event handler
> + ************************************/
> +
> +static int team_device_event(struct notifier_block *unused,
> + unsigned long event, void *ptr)
> +{
> + struct net_device *dev = (struct net_device *) ptr;
> + struct team_port *port;
> +
> + port = team_port_get_rtnl(dev);
> + if (!port)
> + return NOTIFY_DONE;
> +
> + switch (event) {
> + case NETDEV_UP:
> + if (netif_carrier_ok(dev));
> + team_port_change_check(port, true);
> + case NETDEV_DOWN:
> + team_port_change_check(port, false);
> + case NETDEV_CHANGE:
> + if (netif_running(port->dev))
> + team_port_change_check(port,
> + !!netif_carrier_ok(port->dev));
> + break;
> + case NETDEV_UNREGISTER:
> + team_del_slave(port->team->dev, dev);
> + break;
> + case NETDEV_FEAT_CHANGE:
> + team_compute_features(port->team);
> + break;
> + case NETDEV_CHANGEMTU:
> + /* Forbid to change mtu of underlaying device */
> + return NOTIFY_BAD;
> + case NETDEV_CHANGEADDR:
> + /* Forbid to change addr of underlaying device */
> + return NOTIFY_BAD;
> + case NETDEV_PRE_TYPE_CHANGE:
> + /* Forbid to change type of underlaying device */
> + return NOTIFY_BAD;
> + }
> + return NOTIFY_DONE;
> +}
> +
> +static struct notifier_block team_notifier_block __read_mostly = {
> + .notifier_call = team_device_event,
> +};
> +
> +
> +/***********************
> + * Module init and exit
> + ***********************/
> +
> +static int __init team_module_init(void)
> +{
> + int err;
> +
> + register_netdevice_notifier(&team_notifier_block);
> +
> + err = rtnl_link_register(&team_link_ops);
> + if (err)
> + goto err_rtln_reg;
> +
> + err = team_nl_init();
> + if (err)
> + goto err_nl_init;
> +
> + return 0;
> +
> +err_nl_init:
> + rtnl_link_unregister(&team_link_ops);
> +
> +err_rtln_reg:
> + unregister_netdevice_notifier(&team_notifier_block);
> +
> + return err;
> +}
> +
> +static void __exit team_module_exit(void)
> +{
> + team_nl_fini();
> + rtnl_link_unregister(&team_link_ops);
> + unregister_netdevice_notifier(&team_notifier_block);
> +}
> +
> +module_init(team_module_init);
> +module_exit(team_module_exit);
> +
> +MODULE_LICENSE("GPL v2");
> +MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
> +MODULE_DESCRIPTION("Ethernet team device driver");
> +MODULE_ALIAS_RTNL_LINK(DRV_NAME);
> diff --git a/include/linux/Kbuild b/include/linux/Kbuild
> index 619b565..0b091b3 100644
> --- a/include/linux/Kbuild
> +++ b/include/linux/Kbuild
> @@ -185,6 +185,7 @@ header-y += if_pppol2tp.h
> header-y += if_pppox.h
> header-y += if_slip.h
> header-y += if_strip.h
> +header-y += if_team.h
> header-y += if_tr.h
> header-y += if_tun.h
> header-y += if_tunnel.h
> diff --git a/include/linux/if.h b/include/linux/if.h
> index db20bd4..e98f39d 100644
> --- a/include/linux/if.h
> +++ b/include/linux/if.h
> @@ -79,6 +79,7 @@
> #define IFF_TX_SKB_SHARING 0x10000 /* The interface
> supports sharing
> * skbs on transmit */
> #define IFF_UNICAST_FLT 0x20000 /* Supports
> unicast filtering */ +#define IFF_TEAM_PORT
> 0x40000 /* device used as teaming port */
> #define IF_GET_IFACE 0x0001 /* for querying
> only */ #define IF_GET_PROTO 0x0002
> diff --git a/include/linux/if_team.h b/include/linux/if_team.h
> new file mode 100644
> index 0000000..b451c9e
> --- /dev/null
> +++ b/include/linux/if_team.h
> @@ -0,0 +1,126 @@
> +/*
> + * include/linux/if_team.h - Network team device driver header
> + * Copyright (c) 2011 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.
> + */
> +
> +#ifndef _LINUX_IF_TEAM_H_
> +#define _LINUX_IF_TEAM_H_
> +
> +#define TEAM_STRING_MAX_LEN 32
> +
> +/**********************************
> + * NETLINK_GENERIC netlink family.
> + **********************************/
> +
> +enum {
> + TEAM_CMD_NOOP,
> + TEAM_CMD_OPTIONS_SET,
> + TEAM_CMD_OPTIONS_GET,
> + TEAM_CMD_MODE_LIST_GET,
> + TEAM_CMD_PORT_LIST_GET,
> +
> + __TEAM_CMD_MAX,
> + TEAM_CMD_MAX = (__TEAM_CMD_MAX - 1),
> +};
> +
> +enum {
> + TEAM_ATTR_UNSPEC,
> + TEAM_ATTR_TEAM_IFINDEX, /* u32 */
> + TEAM_ATTR_LIST_OPTION, /* nest */
> + TEAM_ATTR_LIST_MODE, /* nest */
> + TEAM_ATTR_LIST_PORT, /* nest */
> +
> + __TEAM_ATTR_MAX,
> + TEAM_ATTR_MAX = __TEAM_ATTR_MAX - 1,
> +};
> +
> +/* Nested layout of get/set msg:
> + *
> + * [TEAM_ATTR_LIST_OPTION]
> + * [TEAM_ATTR_ITEM_OPTION]
> + * [TEAM_ATTR_OPTION_*], ...
> + * [TEAM_ATTR_ITEM_OPTION]
> + * [TEAM_ATTR_OPTION_*], ...
> + * ...
> + * [TEAM_ATTR_LIST_MODE]
> + * [TEAM_ATTR_ITEM_MODE]
> + * [TEAM_ATTR_MODE_*], ...
> + * [TEAM_ATTR_ITEM_MODE]
> + * [TEAM_ATTR_MODE_*], ...
> + * ...
> + * [TEAM_ATTR_LIST_PORT]
> + * [TEAM_ATTR_ITEM_PORT]
> + * [TEAM_ATTR_PORT_*], ...
> + * [TEAM_ATTR_ITEM_PORT]
> + * [TEAM_ATTR_PORT_*], ...
> + * ...
> + */
> +
> +enum {
> + TEAM_ATTR_ITEM_OPTION_UNSPEC,
> + TEAM_ATTR_ITEM_OPTION, /* nest */
> +
> + __TEAM_ATTR_ITEM_OPTION_MAX,
> + TEAM_ATTR_ITEM_OPTION_MAX = __TEAM_ATTR_ITEM_OPTION_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_OPTION_UNSPEC,
> + TEAM_ATTR_OPTION_NAME, /* string */
> + TEAM_ATTR_OPTION_CHANGED, /* flag */
> + TEAM_ATTR_OPTION_TYPE, /* u8 */
> + TEAM_ATTR_OPTION_DATA, /* dynamic */
> +
> + __TEAM_ATTR_OPTION_MAX,
> + TEAM_ATTR_OPTION_MAX = __TEAM_ATTR_OPTION_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_ITEM_MODE_UNSPEC,
> + TEAM_ATTR_ITEM_MODE, /* nest */
> +
> + __TEAM_ATTR_ITEM_MODE_MAX,
> + TEAM_ATTR_ITEM_MODE_MAX = __TEAM_ATTR_ITEM_MODE_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_MODE_UNSPEC,
> + TEAM_ATTR_MODE_NAME, /* string */
> +
> + __TEAM_ATTR_MODE_MAX,
> + TEAM_ATTR_MODE_MAX = __TEAM_ATTR_MODE_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_ITEM_PORT_UNSPEC,
> + TEAM_ATTR_ITEM_PORT, /* nest */
> +
> + __TEAM_ATTR_ITEM_PORT_MAX,
> + TEAM_ATTR_ITEM_PORT_MAX = __TEAM_ATTR_ITEM_PORT_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_PORT_UNSPEC,
> + TEAM_ATTR_PORT_IFINDEX, /* u32 */
> + TEAM_ATTR_PORT_CHANGED, /* flag */
> + TEAM_ATTR_PORT_LINKUP, /* flag */
> + TEAM_ATTR_PORT_SPEED, /* u32 */
> + TEAM_ATTR_PORT_DUPLEX, /* u8 */
> +
> + __TEAM_ATTR_PORT_MAX,
> + TEAM_ATTR_PORT_MAX = __TEAM_ATTR_PORT_MAX - 1,
> +};
> +
> +/*
> + * NETLINK_GENERIC related info
> + */
> +#define TEAM_GENL_NAME "team"
> +#define TEAM_GENL_VERSION 0x1
> +#define TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME "change_event"
> +
> +#endif
fbl
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Eric Dumazet @ 2011-10-04 15:14 UTC (permalink / raw)
To: Jiri Pirko
Cc: netdev, davem, bhutchings, shemminger, fubar, andy, tgraf,
ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <1317737703-19457-1-git-send-email-jpirko@redhat.com>
Le mardi 04 octobre 2011 à 16:15 +0200, Jiri Pirko a écrit :
> This patch introduces new network device called team. It supposes to be
> very fast, simple, userspace-driven alternative to existing bonding
> driver.
>
> Userspace library called libteam with couple of demo apps is available
> here:
> https://github.com/jpirko/libteam
> Note it's still in its dipers atm.
>
> team<->libteam use generic netlink for communication. That and rtnl
> suppose to be the only way to configure team device, no sysfs etc.
>
> In near future python binding for libteam will be introduced. Also
> daemon providing arpmon/miimon active-backup functionality will
> be introduced. All what's necessary is already implemented in kernel team
> driver.
>
> Signed-off-by: Jiri Pirko <jpirko@redhat.com>
> ---
Very nice work Jiri
> Documentation/networking/team.txt | 2 +
> MAINTAINERS | 7 +
> drivers/net/Kconfig | 15 +
> drivers/net/Makefile | 1 +
> drivers/net/team.c | 1819 +++++++++++++++++++++++++++++++++++++
> include/linux/Kbuild | 1 +
> include/linux/if.h | 1 +
> include/linux/if_team.h | 126 +++
> 8 files changed, 1972 insertions(+), 0 deletions(-)
> create mode 100644 Documentation/networking/team.txt
> create mode 100644 drivers/net/team.c
> create mode 100644 include/linux/if_team.h
>
> diff --git a/Documentation/networking/team.txt b/Documentation/networking/team.txt
> new file mode 100644
> index 0000000..5a01368
> --- /dev/null
> +++ b/Documentation/networking/team.txt
> @@ -0,0 +1,2 @@
> +Team devices are driven from userspace via libteam library which is here:
> + https://github.com/jpirko/libteam
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 65ca7ea..f846c6b 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -6372,6 +6372,13 @@ W: http://tcp-lp-mod.sourceforge.net/
> S: Maintained
> F: net/ipv4/tcp_lp.c
>
> +TEAM DRIVER
> +M: Jiri Pirko <jpirko@redhat.com>
> +L: netdev@vger.kernel.org
> +S: Supported
> +F: drivers/net/team.c
> +F: include/linux/team.h
> +
> TEGRA SUPPORT
> M: Colin Cross <ccross@android.com>
> M: Erik Gilling <konkers@android.com>
> diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
> index 583f66c..0d74e9d 100644
> --- a/drivers/net/Kconfig
> +++ b/drivers/net/Kconfig
> @@ -125,6 +125,21 @@ config IFB
> 'ifb1' etc.
> Look at the iproute2 documentation directory for usage etc
>
> +config NET_TEAM
> + tristate "Ethernet teaming support (EXPERIMENTAL)"
> + depends on EXPERIMENTAL
> + ---help---
> + This allows one to create virtual interfaces that teams together
> + multiple ethernet devices.
> +
> + Team devices can be added using the "ip" command from the
> + iproute2 package:
> +
> + "ip link add link [ address MAC ] [ NAME ] type team"
> +
> + To compile this driver as a module, choose M here: the module
> + will be called team.
> +
> config MACVLAN
> tristate "MAC-VLAN support (EXPERIMENTAL)"
> depends on EXPERIMENTAL
> diff --git a/drivers/net/Makefile b/drivers/net/Makefile
> index fa877cd..e3d3e81 100644
> --- a/drivers/net/Makefile
> +++ b/drivers/net/Makefile
> @@ -17,6 +17,7 @@ obj-$(CONFIG_NET) += Space.o loopback.o
> obj-$(CONFIG_NETCONSOLE) += netconsole.o
> obj-$(CONFIG_PHYLIB) += phy/
> obj-$(CONFIG_RIONET) += rionet.o
> +obj-$(CONFIG_NET_TEAM) += team.o
> obj-$(CONFIG_TUN) += tun.o
> obj-$(CONFIG_VETH) += veth.o
> obj-$(CONFIG_VIRTIO_NET) += virtio_net.o
> diff --git a/drivers/net/team.c b/drivers/net/team.c
> new file mode 100644
> index 0000000..c9ae388
> --- /dev/null
> +++ b/drivers/net/team.c
> @@ -0,0 +1,1819 @@
> +/*
> + * net/drivers/team.c - Network team device driver
> + * Copyright (c) 2011 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/slab.h>
> +#include <linux/rcupdate.h>
> +#include <linux/errno.h>
> +#include <linux/notifier.h>
> +#include <linux/netdevice.h>
> +#include <linux/if_arp.h>
> +#include <linux/socket.h>
> +#include <linux/etherdevice.h>
> +#include <linux/rtnetlink.h>
> +#include <net/rtnetlink.h>
> +#include <net/genetlink.h>
> +#include <net/netlink.h>
> +#include <linux/if_team.h>
> +
> +#define DRV_NAME "team"
> +
> +
> +/*************************************
> + * Structures and helpers definitions
> + *************************************/
> +
> +struct team;
> +
> +struct team_port {
> + struct net_device *dev;
> + struct hlist_node hlist; /* node in hash list */
> + struct list_head list; /* node in ordinary list */
> + struct team *team;
> + int index;
> +
> + /*
> + * A place for storing original values of the device before it
> + * become a port.
> + */
> + struct {
> + unsigned char dev_addr[MAX_ADDR_LEN];
> + unsigned int mtu;
> + } orig;
> +
> + bool linkup;
> + u32 speed;
> + u8 duplex;
> +
> + struct rcu_head rcu;
> +};
> +
> +struct team_mode_ops {
> + int (*init)(struct team *team);
> + void (*exit)(struct team *team);
> + rx_handler_result_t (*receive)(struct team *team,
> + struct team_port *port,
> + struct sk_buff *skb);
> + bool (*transmit)(struct team *team, struct sk_buff *skb);
> + int (*port_enter)(struct team *team, struct team_port *port);
> + void (*port_leave)(struct team *team, struct team_port *port);
> + void (*port_change_mac)(struct team *team, struct team_port *port);
> +};
> +
> +enum team_option_type {
> + TEAM_OPTION_TYPE_U32,
> + TEAM_OPTION_TYPE_STRING,
> +};
> +
> +struct team_option {
> + struct list_head list;
> + const char *name;
> + enum team_option_type type;
> + int (*getter)(struct team *team, void *arg);
> + int (*setter)(struct team *team, void *arg);
> +};
> +
> +struct team_mode {
> + const char *kind;
> + const struct team_mode_ops *ops;
> +};
> +
> +struct rr_priv {
> + unsigned int sent_packets;
> +};
> +
> +struct ab_priv {
> + struct team_port __rcu *active_port;
> +};
> +
> +struct team {
> + struct net_device *dev; /* associated netdevice */
> + spinlock_t lock; /* used for overall locking, e.g. port lists write */
> +
> + /*
> + * port lists with port count
> + */
> + int port_count;
> + struct hlist_head *port_hlist;
> + struct list_head port_list;
> +
> + struct list_head option_list;
> +
> + const char *mode_kind;
> + struct team_mode_ops mode_ops;
> + union {
> + char priv_first_byte;
> + struct ab_priv ab_priv;
> + struct rr_priv rr_priv;
> + };
> +};
> +
> +#define TEAM_PORT_HASHBITS 4
> +#define TEAM_PORT_HASHENTRIES (1 << TEAM_PORT_HASHBITS)
> +
> +static struct hlist_head *team_port_index_hash(const struct team *team,
> + int port_index)
> +{
> + return &team->port_hlist[port_index & (TEAM_PORT_HASHENTRIES - 1)];
> +}
> +
> +static struct team_port *team_get_port_by_index_rcu(const struct team *team,
> + int port_index)
> +{
> + struct hlist_node *p;
> + struct team_port *port;
> + struct hlist_head *head = team_port_index_hash(team, port_index);
> +
> + hlist_for_each_entry_rcu(port, p, head, hlist)
> + if (port->index == port_index)
> + return port;
> + return NULL;
> +}
> +
> +static bool team_port_find(const struct team *team,
> + const struct team_port *port)
> +{
> + struct team_port *cur;
> +
> + list_for_each_entry(cur, &team->port_list, list)
> + if (cur == port)
> + return true;
> + return false;
> +}
> +
> +#define team_port_exists(dev) (dev->priv_flags & IFF_TEAM_PORT)
> +
> +static struct team_port *team_port_get_rcu(const struct net_device *dev)
> +{
> + struct team_port *port = rcu_dereference(dev->rx_handler_data);
> +
> + return team_port_exists(dev) ? port : NULL;
> +}
> +
> +static struct team_port *team_port_get_rtnl(const struct net_device *dev)
> +{
> + struct team_port *port = rtnl_dereference(dev->rx_handler_data);
> +
> + return team_port_exists(dev) ? port : NULL;
> +}
> +
> +/*
> + * Since the ability to change mac address for open port device is tested in
> + * team_port_add, this function can be called without control of return value
> + */
> +static int __set_port_mac(struct net_device *port_dev,
> + const unsigned char *dev_addr)
> +{
> + struct sockaddr addr;
> +
> + memcpy(addr.sa_data, dev_addr, ETH_ALEN);
> + addr.sa_family = ARPHRD_ETHER;
> + return dev_set_mac_address(port_dev, &addr);
> +}
> +
> +static int team_port_set_orig_mac(struct team_port *port)
> +{
> + return __set_port_mac(port->dev, port->orig.dev_addr);
> +}
> +
> +static int team_port_set_team_mac(struct team_port *port)
> +{
> + return __set_port_mac(port->dev, port->team->dev->dev_addr);
> +}
> +
> +
> +/*******************
> + * Options handling
> + *******************/
> +
> +static void team_options_register(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + int i;
> +
> + for (i = 0; i < option_count; i++, option++)
> + list_add_tail(&option->list, &team->option_list);
> +}
> +
> +static void __team_options_change_check(struct team *team,
> + struct team_option *changed_option);
> +
> +static void __team_options_unregister(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + int i;
> +
> + for (i = 0; i < option_count; i++, option++)
> + list_del(&option->list);
> +}
> +
> +static void team_options_unregister(struct team *team,
> + struct team_option *option,
> + size_t option_count)
> +{
> + __team_options_unregister(team, option, option_count);
> + __team_options_change_check(team, NULL);
> +}
> +
> +static int team_option_get(struct team *team, struct team_option *option,
> + void *arg)
> +{
> + return option->getter(team, arg);
> +}
> +
> +static int team_option_set(struct team *team, struct team_option *option,
> + void *arg)
> +{
> + int err;
> +
> + err = option->setter(team, arg);
> + if (err)
> + return err;
> +
> + __team_options_change_check(team, option);
> + return err;
> +}
> +
> +/******************************
> + * Round-robin mode definition
> + ******************************/
> +
> +static struct team_port *__get_first_port_up(struct team *team,
> + struct team_port *port)
> +{
> + struct team_port *cur;
> +
> + if (port->linkup)
> + return port;
> + cur = port;
> + list_for_each_entry_continue_rcu(cur, &team->port_list, list)
> + if (cur->linkup)
> + return cur;
> + list_for_each_entry_rcu(cur, &team->port_list, list) {
> + if (cur == port)
> + break;
> + if (cur->linkup)
> + return cur;
> + }
> + return NULL;
> +}
> +
> +static bool rr_transmit(struct team *team, struct sk_buff *skb)
> +{
> + struct team_port *port;
> + int port_index;
> +
> + port_index = team->rr_priv.sent_packets++ % team->port_count;
This is a bit expensive (change of sent_packets (cache line ping pong)
and a modulo operation.
Thanks to LLTX, we run here lockless.
You could use a percpu pseudo random generator and a reciprocal divide.
static u32 random_N(unsigned int N)
{
return reciprocal_divide(random32(), N);
}
...
port_index = random_N(team->port_count);
> + port = team_get_port_by_index_rcu(team, port_index);
> + port = __get_first_port_up(team, port);
> + if (unlikely(!port))
> + goto drop;
> + skb->dev = port->dev;
> + if (dev_queue_xmit(skb))
> + goto drop;
> +
> + return true;
> +
> +drop:
Please always increment a counter on dropped frames ;)
> + dev_kfree_skb(skb);
> + return false;
> +}
> +
> +static int rr_port_enter(struct team *team, struct team_port *port)
> +{
> + return team_port_set_team_mac(port);
> +}
> +
> +static void rr_port_change_mac(struct team *team, struct team_port *port)
> +{
> + team_port_set_team_mac(port);
> +}
> +
> +static const struct team_mode_ops rr_mode_ops = {
> + .transmit = rr_transmit,
> + .port_enter = rr_port_enter,
> + .port_change_mac = rr_port_change_mac,
> +};
> +
> +static const struct team_mode rr_mode = {
> + .kind = "roundrobin",
> + .ops = &rr_mode_ops,
> +};
> +
> +
> +/********************************
> + * Active-backup mode definition
> + ********************************/
> +
> +static rx_handler_result_t ab_receive(struct team *team, struct team_port *port,
> + struct sk_buff *skb) {
> + struct team_port *active_port;
> +
> + active_port = rcu_dereference(team->ab_priv.active_port);
> + if (active_port != port)
> + return RX_HANDLER_EXACT;
> + return RX_HANDLER_ANOTHER;
> +}
> +
> +static bool ab_transmit(struct team *team, struct sk_buff *skb)
> +{
> + struct team_port *active_port;
> +
> + active_port = rcu_dereference(team->ab_priv.active_port);
> + if (unlikely(!active_port))
> + goto drop;
> + skb->dev = active_port->dev;
> + if (dev_queue_xmit(skb))
> + goto drop;
> + return true;
> +
> +drop:
Please always increment a counter on dropped frames ;)
> + dev_kfree_skb(skb);
> + return false;
> +}
> +
> +static void ab_port_leave(struct team *team, struct team_port *port)
> +{
> + if (team->ab_priv.active_port == port)
> + rcu_assign_pointer(team->ab_priv.active_port, NULL);
> +}
> +
> +static void ab_port_change_mac(struct team *team, struct team_port *port)
> +{
> + if (team->ab_priv.active_port == port)
> + team_port_set_team_mac(port);
> +}
> +
> +static int ab_active_port_get(struct team *team, void *arg)
> +{
> + u32 *ifindex = arg;
> +
> + *ifindex = 0;
> + if (team->ab_priv.active_port)
> + *ifindex = team->ab_priv.active_port->dev->ifindex;
> + return 0;
> +}
> +
> +static int ab_active_port_set(struct team *team, void *arg)
> +{
> + u32 *ifindex = arg;
> + struct team_port *port;
> +
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + if (port->dev->ifindex == *ifindex) {
> + struct team_port *ac_port = team->ab_priv.active_port;
> +
> + /* rtnl_lock needs to be held when setting macs */
> + rtnl_lock();
> + if (ac_port)
> + team_port_set_orig_mac(ac_port);
> + rcu_assign_pointer(team->ab_priv.active_port, port);
> + team_port_set_team_mac(port);
> + rtnl_unlock();
> + return 0;
> + }
> + }
> + return -ENOENT;
> +}
> +
> +static struct team_option ab_options[] = {
> + {
> + .name = "activeport",
> + .type = TEAM_OPTION_TYPE_U32,
> + .getter = ab_active_port_get,
> + .setter = ab_active_port_set,
> + },
> +};
> +
> +int ab_init(struct team *team)
> +{
> + team_options_register(team, ab_options, ARRAY_SIZE(ab_options));
> + return 0;
> +}
> +
> +void ab_exit(struct team *team)
> +{
> + team_options_unregister(team, ab_options, ARRAY_SIZE(ab_options));
> +}
> +
> +static const struct team_mode_ops ab_mode_ops = {
> + .init = ab_init,
> + .exit = ab_exit,
> + .receive = ab_receive,
> + .transmit = ab_transmit,
> + .port_leave = ab_port_leave,
> + .port_change_mac = ab_port_change_mac,
> +};
> +
> +static const struct team_mode ab_mode = {
> + .kind = "activebackup",
> + .ops = &ab_mode_ops,
> +};
> +
> +
> +/****************
> + * Mode handling
> + ****************/
> +
> +static const struct team_mode *team_modes[] = {
> + &rr_mode,
> + &ab_mode,
> +};
> +
> +static const int team_mode_count = ARRAY_SIZE(team_modes);
> +
> +static int team_find_mode(const char *kind)
> +{
> + int i;
> +
> + for (i = 0; i < team_mode_count; i++) {
> + const struct team_mode *mode = team_modes[i];
> +
> + if (strcmp(mode->kind, kind) == 0)
> + return i;
> + }
> + return -ENOENT;
> +}
> +
> +/*
> + * We can benefit from the fact that it's ensured no port is present
> + * at the time of mode change.
> + */
> +static void __team_change_mode(struct team *team, const int mode_index)
> +{
> + const struct team_mode *mode = team_modes[mode_index];
> +
> + if (team->mode_ops.exit)
> + team->mode_ops.exit(team);
> +
> + if (mode_index < 0)
> + return;
> +
> + memcpy(&team->mode_ops, mode->ops, sizeof(struct team_mode_ops));
> +
> + /* zero private data area */
> + memset(&team->priv_first_byte, 0,
> + sizeof(struct team) - offsetof(struct team, priv_first_byte));
> +
> + team->mode_kind = mode->kind;
> + if (team->mode_ops.init)
> + team->mode_ops.init(team);
> +
> + return;
> +}
> +
> +static int team_change_mode(struct team *team, const char *kind)
> +{
> + int mode_index;
> + struct net_device *dev = team->dev;
> +
> + if (!list_empty(&team->port_list)) {
> + netdev_err(dev, "No ports can be present during "
Current coding style now allows this to be a single line for new code
submission.
> + "mode change\n");
> + return -EBUSY;
> + }
> +
> + if (strcmp(team->mode_kind, kind) == 0) {
> + netdev_err(dev, "Unable to change to the same mode "
> + "the team is in\n");
> + return -EINVAL;
> + }
> +
> + mode_index = team_find_mode(kind);
> + if (mode_index < 0) {
> + netdev_err(dev, "Mode \"%s\" is not loaded\n", kind);
> + return -EINVAL;
> + }
> +
> + __team_change_mode(team, mode_index);
> +
> + netdev_info(dev, "Mode changed to \"%s\"\n", kind);
> + return 0;
> +}
> +
> +
> +/************************
> + * Rx path frame handler
> + ************************/
> +
> +/* note: already called with rcu_read_lock */
> +static rx_handler_result_t team_handle_frame(struct sk_buff **pskb)
> +{
> + struct sk_buff *skb = *pskb;
> + struct team_port *port;
> + struct team *team;
> + rx_handler_result_t res = RX_HANDLER_ANOTHER;
> +
> + skb = skb_share_check(skb, GFP_ATOMIC);
> + if (!skb)
> + return RX_HANDLER_CONSUMED;
> +
> + *pskb = skb;
> +
> + port = team_port_get_rcu(skb->dev);
> + team = port->team;
> +
> + if (team->mode_ops.receive)
> + res = team->mode_ops.receive(team, port, skb);
> +
> + if (res == RX_HANDLER_ANOTHER)
> + skb->dev = team->dev;
> +
> + return res;
> +}
> +
> +
> +/****************
> + * Port handling
> + ****************/
> +
> +static int team_port_list_init(struct team *team)
> +{
> + int i;
> + struct hlist_head *hash;
> +
> + hash = kmalloc(sizeof(*hash) * TEAM_PORT_HASHENTRIES, GFP_KERNEL);
> + if (hash != NULL) {
> + for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
> + INIT_HLIST_HEAD(&hash[i]);
> + } else {
> + return -ENOMEM;
> + }
if (!hash)
return -ENOMEM;
for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
INIT_HLIST_HEAD(&hash[i]);
>
> + team->port_hlist = hash;
> + INIT_LIST_HEAD(&team->port_list);
> + return 0;
> +}
> +
> +static void team_port_list_fini(struct team *team)
> +{
> + kfree(team->port_hlist);
> +}
> +
> +/*
> + * Add/delete port to the team port list. Write guarded by rtnl_lock.
> + * Takes care of correct port->index setup (might be racy).
> + */
> +static void team_port_list_add_port(struct team *team,
> + struct team_port *port)
> +{
> + port->index = team->port_count++;
> + hlist_add_head_rcu(&port->hlist,
> + team_port_index_hash(team, port->index));
> + list_add_tail_rcu(&port->list, &team->port_list);
> +}
> +
> +static void __reconstruct_port_hlist(struct team *team, int rm_index)
> +{
> + int i;
> + struct team_port *port;
> +
> + for (i = rm_index + 1; i < team->port_count; i++) {
> + port = team_get_port_by_index_rcu(team, i);
> + hlist_del_rcu(&port->hlist);
> + port->index--;
> + hlist_add_head_rcu(&port->hlist,
> + team_port_index_hash(team, port->index));
> + }
> +}
> +
> +static void team_port_list_del_port(struct team *team,
> + struct team_port *port)
> +{
> + int rm_index = port->index;
> +
> + hlist_del_rcu(&port->hlist);
> + list_del_rcu(&port->list);
> + __reconstruct_port_hlist(team, rm_index);
> + team->port_count--;
> +}
> +
> +#define TEAM_VLAN_FEATURES (NETIF_F_ALL_CSUM | NETIF_F_SG | \
> + NETIF_F_FRAGLIST | NETIF_F_ALL_TSO | \
> + NETIF_F_HIGHDMA | NETIF_F_LRO)
> +
> +static void __team_compute_features(struct team *team)
> +{
> + struct team_port *port;
> + u32 vlan_features = TEAM_VLAN_FEATURES;
> + unsigned short max_hard_header_len = ETH_HLEN;
> +
> + list_for_each_entry(port, &team->port_list, list) {
> + vlan_features = netdev_increment_features(vlan_features,
> + port->dev->vlan_features,
> + TEAM_VLAN_FEATURES);
> +
> + if (port->dev->hard_header_len > max_hard_header_len)
> + max_hard_header_len = port->dev->hard_header_len;
> + }
> +
> + team->dev->vlan_features = vlan_features;
> + team->dev->hard_header_len = max_hard_header_len;
> +
> + netdev_change_features(team->dev);
> +}
> +
> +static void team_compute_features(struct team *team)
> +{
> + spin_lock(&team->lock);
> + __team_compute_features(team);
> + spin_unlock(&team->lock);
> +}
> +
> +static int team_port_enter(struct team *team, struct team_port *port)
> +{
> + int err = 0;
> +
> + dev_hold(team->dev);
> + port->dev->priv_flags |= IFF_TEAM_PORT;
> + if (team->mode_ops.port_enter) {
> + err = team->mode_ops.port_enter(team, port);
> + if (err)
> + netdev_err(team->dev, "Device %s failed to "
> + "enter team mode\n",
> + port->dev->name);
> + }
> + return err;
> +}
> +
> +static void team_port_leave(struct team *team, struct team_port *port)
> +{
> + if (team->mode_ops.port_leave)
> + team->mode_ops.port_leave(team, port);
> + port->dev->priv_flags &= ~IFF_TEAM_PORT;
> + dev_put(team->dev);
> +}
> +
> +static void __team_port_change_check(struct team_port *port, bool linkup);
> +
> +static int team_port_add(struct team *team, struct net_device *port_dev)
> +{
> + struct net_device *dev = team->dev;
> + struct team_port *port;
> + char *portname = port_dev->name;
> + char tmp_addr[ETH_ALEN];
> + int err;
> +
> + if (port_dev->flags & IFF_LOOPBACK ||
> + port_dev->type != ARPHRD_ETHER) {
> + netdev_err(dev, "Device %s is of an unsupported type\n",
> + portname);
> + return -EINVAL;
> + }
> +
> + if (team_port_exists(port_dev)) {
> + netdev_err(dev, "Device %s is already a port "
> + "of a team device\n", portname);
> + return -EBUSY;
> + }
> +
> + if (port_dev->flags & IFF_UP) {
> + netdev_err(dev, "Device %s is up. Set it down before "
> + "adding it as a team port\n", portname);
> + return -EBUSY;
> + }
> +
> + port = kzalloc(sizeof(struct team_port), GFP_KERNEL);
> + if (!port)
> + return -ENOMEM;
> +
> + port->dev = port_dev;
> + port->team = team;
> +
> + port->orig.mtu = port_dev->mtu;
> + err = dev_set_mtu(port_dev, dev->mtu);
> + if (err) {
> + netdev_dbg(dev, "Error %d calling dev_set_mtu\n", err);
> + goto err_set_mtu;
> + }
> +
> + memcpy(port->orig.dev_addr, port_dev->dev_addr, ETH_ALEN);
> + random_ether_addr(tmp_addr);
> + err = __set_port_mac(port_dev, tmp_addr);
> + if (err) {
> + netdev_dbg(dev, "Device %s mac addr set failed\n",
> + portname);
> + goto err_set_mac_rand;
> + }
> +
> + err = dev_open(port_dev);
> + if (err) {
> + netdev_dbg(dev, "Device %s opening failed\n",
> + portname);
> + goto err_dev_open;
> + }
> +
> + err = team_port_set_orig_mac(port);
> + if (err) {
> + netdev_dbg(dev, "Device %s mac addr set failed - Device does "
> + "not support addr change when it's opened\n",
> + portname);
> + goto err_set_mac_opened;
> + }
> +
> + err = team_port_enter(team, port);
> + if (err) {
> + netdev_err(dev, "Device %s failed to enter team mode\n",
> + portname);
> + goto err_port_enter;
> + }
> +
> + err = netdev_set_master(port_dev, dev);
> + if (err) {
> + netdev_err(dev, "Device %s failed to set "
> + "master\n", portname);
> + goto err_set_master;
> + }
> +
> + err = netdev_rx_handler_register(port_dev, team_handle_frame,
> + port);
> + if (err) {
> + netdev_err(dev, "Device %s failed to register "
> + "rx_handler\n", portname);
> + goto err_handler_register;
> + }
> +
> + team_port_list_add_port(team, port);
> + __team_compute_features(team);
> + __team_port_change_check(port, !!netif_carrier_ok(port_dev));
> +
> + netdev_info(dev, "Port device %s added\n", portname);
> +
> + return 0;
> +
> +err_handler_register:
> + netdev_set_master(port_dev, NULL);
> +
> +err_set_master:
> + team_port_leave(team, port);
> +
> +err_port_enter:
> +err_set_mac_opened:
> + dev_close(port_dev);
> +
> +err_dev_open:
> + team_port_set_orig_mac(port);
> +
> +err_set_mac_rand:
> + dev_set_mtu(port_dev, port->orig.mtu);
> +
> +err_set_mtu:
> + kfree(port);
> +
> + return err;
> +}
> +
> +static int team_port_del(struct team *team, struct net_device *port_dev)
> +{
> + struct net_device *dev = team->dev;
> + struct team_port *port;
> + char *portname = port_dev->name;
> +
> + port = team_port_get_rtnl(port_dev);
> + if (!port || !team_port_find(team, port)) {
> + netdev_err(dev, "Device %s does not act as a port "
> + "of this team\n", portname);
> + return -ENOENT;
> + }
> +
> + __team_port_change_check(port, false);
> + team_port_list_del_port(team, port);
> + netdev_rx_handler_unregister(port_dev);
> + netdev_set_master(port_dev, NULL);
> + team_port_leave(team, port);
> + dev_close(port_dev);
> + team_port_set_orig_mac(port);
> + dev_set_mtu(port_dev, port->orig.mtu);
> + synchronize_rcu();
> + kfree(port);
> + netdev_info(dev, "Port device %s removed\n", portname);
> + __team_compute_features(team);
> +
> + return 0;
> +}
> +
> +
> +/*****************
> + * Net device ops
> + ****************/
> +
> +static int team_mode_option_get(struct team *team, void *arg)
> +{
> + const char **str = arg;
> +
> + *str = team->mode_kind;
> + return 0;
> +}
> +
> +static int team_mode_option_set(struct team *team, void *arg)
> +{
> + const char **str = arg;
> +
> + return team_change_mode(team, *str);
> +}
> +
> +static struct team_option team_options[] = {
> + {
> + .name = "mode",
> + .type = TEAM_OPTION_TYPE_STRING,
> + .getter = team_mode_option_get,
> + .setter = team_mode_option_set,
> + },
> +};
> +
> +static int team_init(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + team->dev = dev;
> + spin_lock_init(&team->lock);
> +
> + err = team_port_list_init(team);
> + if (err)
> + return err;
> +
> + INIT_LIST_HEAD(&team->option_list);
> + team_options_register(team, team_options, ARRAY_SIZE(team_options));
> + __team_change_mode(team, 0); /* set default mode */
> + netif_carrier_off(dev);
> +
> + return 0;
> +}
> +
> +static void team_uninit(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + struct team_port *tmp;
> +
> + spin_lock(&team->lock);
> + list_for_each_entry_safe(port, tmp, &team->port_list, list)
> + team_port_del(team, port->dev);
> +
> + __team_change_mode(team, -1); /* cleanup */
> + __team_options_unregister(team, team_options, ARRAY_SIZE(team_options));
> + spin_unlock(&team->lock);
> +}
> +
> +static void team_destructor(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> +
> + team_port_list_fini(team);
> + free_netdev(dev);
> +}
> +
> +static int team_open(struct net_device *dev)
> +{
> + netif_carrier_on(dev);
> + return 0;
> +}
> +
> +static int team_close(struct net_device *dev)
> +{
> + netif_carrier_off(dev);
> + return 0;
> +}
> +
> +/*
> + * note: already called with rcu_read_lock
> + */
> +static netdev_tx_t team_xmit(struct sk_buff *skb, struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> +
> + /*
> + * Ensure transmit function is called only in case there is at least
> + * one port present.
> + */
> + if (likely(!list_empty(&team->port_list)))
> + team->mode_ops.transmit(team, skb);
> +
> + return NETDEV_TX_OK;
> +}
> +
> +static void team_change_rx_flags(struct net_device *dev, int change)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + int inc;
> +
> + rcu_read_lock();
It seems there is a bit of confusion.
Dont we hold rtnl at this point ? (no rcu is needed)
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + if (change & IFF_PROMISC) {
> + inc = dev->flags & IFF_PROMISC ? 1 : -1;
> + dev_set_promiscuity(port->dev, inc);
> + }
> + if (change & IFF_ALLMULTI) {
> + inc = dev->flags & IFF_ALLMULTI ? 1 : -1;
> + dev_set_allmulti(port->dev, inc);
> + }
> + }
> + rcu_read_unlock();
> +}
> +
> +static void team_set_rx_mode(struct net_device *dev)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
same here ?
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + dev_uc_sync(port->dev, dev);
> + dev_mc_sync(port->dev, dev);
> + }
> + rcu_read_unlock();
> +}
> +
> +static int team_set_mac_address(struct net_device *dev, void *p)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + struct sockaddr *addr = p;
> +
> + memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
> + rcu_read_lock();
ditto
> + list_for_each_entry_rcu(port, &team->port_list, list)
> + if (team->mode_ops.port_change_mac)
> + team->mode_ops.port_change_mac(team, port);
> + rcu_read_unlock();
> + return 0;
> +}
> +
> +static int team_change_mtu(struct net_device *dev, int new_mtu)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> + int err;
> +
> + rcu_read_lock();
same here
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + err = dev_set_mtu(port->dev, new_mtu);
> + if (err) {
> + netdev_err(dev, "Device %s failed to change mtu",
> + port->dev->name);
> + goto unwind;
> + }
> + }
> + rcu_read_unlock();
> +
> + dev->mtu = new_mtu;
> +
> + return 0;
> +
> +unwind:
> + list_for_each_entry_continue_reverse(port, &team->port_list, list)
> + dev_set_mtu(port->dev, dev->mtu);
> +
> + rcu_read_unlock();
> + return err;
> +}
> +
> +static struct rtnl_link_stats64 *team_get_stats(struct net_device *dev,
> + struct rtnl_link_stats64 *stats)
> +{
> + struct team *team = netdev_priv(dev);
> + struct rtnl_link_stats64 temp;
> + struct team_port *port;
> +
> + memset(stats, 0, sizeof(*stats));
> +
> + rcu_read_lock();
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct rtnl_link_stats64 *pstats;
> +
> + pstats = dev_get_stats(port->dev, &temp);
> +
> + stats->rx_packets += pstats->rx_packets;
> + stats->rx_bytes += pstats->rx_bytes;
> + stats->rx_errors += pstats->rx_errors;
> + stats->rx_dropped += pstats->rx_dropped;
> +
> + stats->tx_packets += pstats->tx_packets;
> + stats->tx_bytes += pstats->tx_bytes;
> + stats->tx_errors += pstats->tx_errors;
> + stats->tx_dropped += pstats->tx_dropped;
> +
> + stats->multicast += pstats->multicast;
> + stats->collisions += pstats->collisions;
> +
> + stats->rx_length_errors += pstats->rx_length_errors;
> + stats->rx_over_errors += pstats->rx_over_errors;
> + stats->rx_crc_errors += pstats->rx_crc_errors;
> + stats->rx_frame_errors += pstats->rx_frame_errors;
> + stats->rx_fifo_errors += pstats->rx_fifo_errors;
> + stats->rx_missed_errors += pstats->rx_missed_errors;
> +
> + stats->tx_aborted_errors += pstats->tx_aborted_errors;
> + stats->tx_carrier_errors += pstats->tx_carrier_errors;
> + stats->tx_fifo_errors += pstats->tx_fifo_errors;
> + stats->tx_heartbeat_errors += pstats->tx_heartbeat_errors;
> + stats->tx_window_errors += pstats->tx_window_errors;
> + }
> + rcu_read_unlock();
> +
One thing that bothers me is stats are wrong when we add or remove a
slave.
We really should have a per master structure to take into account
offsets when we add/remove a slave, to keep monotonic master stats.
> + return stats;
> +}
> +
> +static void team_vlan_rx_add_vid(struct net_device *dev, uint16_t vid)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
rtnl instead of rcu ?
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct net_device_ops *ops = port->dev->netdev_ops;
> +
> + ops->ndo_vlan_rx_add_vid(port->dev, vid);
> + }
> + rcu_read_unlock();
> +}
> +
> +static void team_vlan_rx_kill_vid(struct net_device *dev, uint16_t vid)
> +{
> + struct team *team = netdev_priv(dev);
> + struct team_port *port;
> +
> + rcu_read_lock();
same here ?
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + const struct net_device_ops *ops = port->dev->netdev_ops;
> +
> + ops->ndo_vlan_rx_kill_vid(port->dev, vid);
> + }
> + rcu_read_unlock();
> +}
> +
> +static int team_add_slave(struct net_device *dev, struct net_device *port_dev)
> +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + spin_lock(&team->lock);
> + err = team_port_add(team, port_dev);
> + spin_unlock(&team->lock);
> + return err;
> +}
> +
> +static int team_del_slave(struct net_device *dev, struct net_device *port_dev)
> +{
> + struct team *team = netdev_priv(dev);
> + int err;
> +
> + spin_lock(&team->lock);
> + err = team_port_del(team, port_dev);
> + spin_unlock(&team->lock);
> + return err;
> +}
> +
> +static const struct net_device_ops team_netdev_ops = {
> + .ndo_init = team_init,
> + .ndo_uninit = team_uninit,
> + .ndo_open = team_open,
> + .ndo_stop = team_close,
> + .ndo_start_xmit = team_xmit,
> + .ndo_change_rx_flags = team_change_rx_flags,
> + .ndo_set_rx_mode = team_set_rx_mode,
> + .ndo_set_mac_address = team_set_mac_address,
> + .ndo_change_mtu = team_change_mtu,
> + .ndo_get_stats64 = team_get_stats,
> + .ndo_vlan_rx_add_vid = team_vlan_rx_add_vid,
> + .ndo_vlan_rx_kill_vid = team_vlan_rx_kill_vid,
> + .ndo_add_slave = team_add_slave,
> + .ndo_del_slave = team_del_slave,
> +};
> +
> +
> +/***********************
> + * rt netlink interface
> + ***********************/
> +
> +static void team_setup(struct net_device *dev)
> +{
> + ether_setup(dev);
> +
> + dev->netdev_ops = &team_netdev_ops;
> + dev->destructor = team_destructor;
> + dev->tx_queue_len = 0;
> + dev->flags |= IFF_MULTICAST;
> + dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);
> +
> + /*
> + * Indicate we support unicast address filtering. That way core won't
> + * bring us to promisc mode in case a unicast addr is added.
> + * Let this up to underlay drivers.
> + */
> + dev->priv_flags |= IFF_UNICAST_FLT;
> +
> + dev->features |= NETIF_F_LLTX;
> + dev->features |= NETIF_F_GRO;
> + dev->hw_features = NETIF_F_HW_VLAN_TX |
> + NETIF_F_HW_VLAN_RX |
> + NETIF_F_HW_VLAN_FILTER;
> +
> + dev->features |= dev->hw_features;
> +}
> +
> +static int team_newlink(struct net *src_net, struct net_device *dev,
> + struct nlattr *tb[], struct nlattr *data[])
> +{
> + int err;
> +
> + if (tb[IFLA_ADDRESS] == NULL)
> + random_ether_addr(dev->dev_addr);
> +
> + err = register_netdevice(dev);
> + if (err)
> + return err;
> +
> + return 0;
> +}
> +
> +static int team_validate(struct nlattr *tb[], struct nlattr *data[])
> +{
> + if (tb[IFLA_ADDRESS]) {
> + if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
> + return -EINVAL;
> + if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
> + return -EADDRNOTAVAIL;
> + }
> + return 0;
> +}
> +
> +static struct rtnl_link_ops team_link_ops __read_mostly = {
> + .kind = DRV_NAME,
> + .priv_size = sizeof(struct team),
> + .setup = team_setup,
> + .newlink = team_newlink,
> + .validate = team_validate,
> +};
> +
> +
> +/***********************************
> + * Generic netlink custom interface
> + ***********************************/
> +
> +static struct genl_family team_nl_family = {
> + .id = GENL_ID_GENERATE,
> + .name = TEAM_GENL_NAME,
> + .version = TEAM_GENL_VERSION,
> + .maxattr = TEAM_ATTR_MAX,
> + .netnsok = true,
> +};
> +
> +static const struct nla_policy team_nl_policy[TEAM_ATTR_MAX + 1] = {
> + [TEAM_ATTR_UNSPEC] = { .type = NLA_UNSPEC, },
> + [TEAM_ATTR_TEAM_IFINDEX] = { .type = NLA_U32 },
> + [TEAM_ATTR_LIST_OPTION] = { .type = NLA_NESTED },
> + [TEAM_ATTR_LIST_MODE] = { .type = NLA_NESTED },
> + [TEAM_ATTR_LIST_PORT] = { .type = NLA_NESTED },
> +};
> +
> +static const struct nla_policy team_nl_option_policy[TEAM_ATTR_OPTION_MAX + 1] = {
> + [TEAM_ATTR_OPTION_UNSPEC] = { .type = NLA_UNSPEC, },
> + [TEAM_ATTR_OPTION_NAME] = {
> + .type = NLA_STRING,
> + .len = TEAM_STRING_MAX_LEN,
> + },
> + [TEAM_ATTR_OPTION_CHANGED] = { .type = NLA_FLAG },
> + [TEAM_ATTR_OPTION_TYPE] = { .type = NLA_U8 },
> + [TEAM_ATTR_OPTION_DATA] = {
> + .type = NLA_BINARY,
> + .len = TEAM_STRING_MAX_LEN,
> + },
> +};
> +
> +static int team_nl_cmd_noop(struct sk_buff *skb, struct genl_info *info)
> +{
> + struct sk_buff *msg;
> + void *hdr;
> + int err;
> +
> + msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!msg)
> + return -ENOMEM;
> +
> + hdr = genlmsg_put(msg, info->snd_pid, info->snd_seq,
> + &team_nl_family, 0, TEAM_CMD_NOOP);
> + if (IS_ERR(hdr)) {
> + err = PTR_ERR(hdr);
> + goto err_msg_put;
> + }
> +
> + genlmsg_end(msg, hdr);
> +
> + return genlmsg_unicast(genl_info_net(info), msg, info->snd_pid);
> +
> +err_msg_put:
> + nlmsg_free(msg);
> +
> + return err;
> +}
> +
> +/*
> + * Netlink cmd functions should be locked by following two functions.
> + * To ensure team_uninit would not be called in between, hold rcu_read_lock
> + * all the time.
> + */
> +static struct team *team_nl_team_get(struct genl_info *info)
> +{
> + struct net *net = genl_info_net(info);
> + int ifindex;
> + struct net_device *dev;
> + struct team *team;
> +
> + if (!info->attrs[TEAM_ATTR_TEAM_IFINDEX])
> + return NULL;
> +
> + ifindex = nla_get_u32(info->attrs[TEAM_ATTR_TEAM_IFINDEX]);
> + rcu_read_lock();
> + dev = dev_get_by_index_rcu(net, ifindex);
> + if (!dev || dev->netdev_ops != &team_netdev_ops) {
> + rcu_read_unlock();
> + return NULL;
> + }
> +
> + team = netdev_priv(dev);
> + spin_lock(&team->lock);
> + return team;
> +}
> +
> +static void team_nl_team_put(struct team *team)
> +{
> + spin_unlock(&team->lock);
> + rcu_read_unlock();
> +}
> +
> +static int team_nl_send_generic(struct genl_info *info, struct team *team,
> + int (*fill_func)(struct sk_buff *skb,
> + struct genl_info *info,
> + int flags, struct team *team))
> +{
> + struct sk_buff *skb;
> + int err;
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = fill_func(skb, info, NLM_F_ACK, team);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_unicast(genl_info_net(info), skb, info->snd_pid);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_fill_options_get_changed(struct sk_buff *skb,
> + u32 pid, u32 seq, int flags,
> + struct team *team,
> + struct team_option *changed_option)
> +{
> + struct nlattr *option_list;
> + void *hdr;
> + struct team_option *option;
> +
> + hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
> + TEAM_CMD_OPTIONS_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + option_list = nla_nest_start(skb, TEAM_ATTR_LIST_OPTION);
> + if (!option_list)
> + return -EMSGSIZE;
> +
> + list_for_each_entry(option, &team->option_list, list) {
> + struct nlattr *option_item;
> + long arg;
> +
> + option_item = nla_nest_start(skb, TEAM_ATTR_ITEM_OPTION);
> + if (!option_item)
> + goto nla_put_failure;
> + NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_NAME, option->name);
> + if (option == changed_option)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_OPTION_CHANGED);
> + switch (option->type) {
> + case TEAM_OPTION_TYPE_U32:
> + NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE, NLA_U32);
> + team_option_get(team, option, &arg);
> + NLA_PUT_U32(skb, TEAM_ATTR_OPTION_DATA, arg);
> + break;
> + case TEAM_OPTION_TYPE_STRING:
> + NLA_PUT_U8(skb, TEAM_ATTR_OPTION_TYPE, NLA_STRING);
> + team_option_get(team, option, &arg);
> + NLA_PUT_STRING(skb, TEAM_ATTR_OPTION_DATA, (char *) arg);
> + break;
> + default:
> + BUG();
> + }
> + nla_nest_end(skb, option_item);
> + }
> +
> + nla_nest_end(skb, option_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_fill_options_get(struct sk_buff *skb,
> + struct genl_info *info, int flags,
> + struct team *team)
> +{
> + return team_nl_fill_options_get_changed(skb, info->snd_pid,
> + info->snd_seq, NLM_F_ACK,
> + team, NULL);
> +}
> +
> +static int team_nl_cmd_options_get(struct sk_buff *skb, struct genl_info *info)
> +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team, team_nl_fill_options_get);
> +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_cmd_options_set(struct sk_buff *skb, struct genl_info *info)
> +{
> + struct team *team;
> + int err = 0;
> + int i;
> + struct nlattr *nl_option;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = -EINVAL;
> + if (!info->attrs[TEAM_ATTR_LIST_OPTION]) {
> + err = -EINVAL;
> + goto team_put;
> + }
> +
> + nla_for_each_nested(nl_option, info->attrs[TEAM_ATTR_LIST_OPTION], i) {
> + struct nlattr *mode_attrs[TEAM_ATTR_OPTION_MAX + 1];
> + enum team_option_type opt_type;
> + struct team_option *option;
> + char *opt_name;
> +
> + if (nla_type(nl_option) != TEAM_ATTR_ITEM_OPTION) {
> + err = -EINVAL;
> + goto team_put;
> + }
> + err = nla_parse_nested(mode_attrs, TEAM_ATTR_OPTION_MAX,
> + nl_option, team_nl_option_policy);
> + if (err)
> + goto team_put;
> + if (!mode_attrs[TEAM_ATTR_OPTION_NAME] ||
> + !mode_attrs[TEAM_ATTR_OPTION_TYPE] ||
> + !mode_attrs[TEAM_ATTR_OPTION_DATA]) {
> + err = -EINVAL;
> + goto team_put;
> + }
> + switch (nla_get_u8(mode_attrs[TEAM_ATTR_OPTION_TYPE])) {
> + case NLA_U32:
> + opt_type = TEAM_OPTION_TYPE_U32;
> + break;
> + case NLA_STRING:
> + opt_type = TEAM_OPTION_TYPE_STRING;
> + break;
> + default:
> + goto team_put;
> + }
> +
> + opt_name = nla_data(mode_attrs[TEAM_ATTR_OPTION_NAME]);
> + list_for_each_entry(option, &team->option_list, list) {
> + long arg;
> +
> + if (option->type != opt_type ||
> + strcmp(option->name, opt_name))
> + continue;
> + switch (opt_type) {
> + case TEAM_OPTION_TYPE_U32:
> + arg = nla_get_u32(mode_attrs[TEAM_ATTR_OPTION_DATA]);
> + break;
> + case TEAM_OPTION_TYPE_STRING:
> + arg = (long) nla_data(mode_attrs[TEAM_ATTR_OPTION_DATA]);
> + break;
> + default:
> + BUG();
> + }
> + err = team_option_set(team, option, &arg);
> + if (err)
> + goto team_put;
> + }
> + }
> +
> +team_put:
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_fill_mode_list_get(struct sk_buff *skb,
> + struct genl_info *info, int flags,
> + struct team *team)
> +{
> + struct nlattr *mode_list;
> + void *hdr;
> + int i;
> +
> + hdr = genlmsg_put(skb, info->snd_pid, info->snd_seq,
> + &team_nl_family, flags, TEAM_CMD_MODE_LIST_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + mode_list = nla_nest_start(skb, TEAM_ATTR_LIST_MODE);
> + if (!mode_list)
> + return -EMSGSIZE;
> +
> + for (i = 0; i < team_mode_count; i++) {
> + const struct team_mode *mode = team_modes[i];
> + struct nlattr *mode_item;
> +
> + mode_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
> + if (!mode_item)
> + goto nla_put_failure;
> + NLA_PUT_STRING(skb, TEAM_ATTR_MODE_NAME, mode->kind);
> + nla_nest_end(skb, mode_item);
> + }
> +
> + nla_nest_end(skb, mode_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_cmd_mode_list_get(struct sk_buff *skb,
> + struct genl_info *info)
> +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team, team_nl_fill_mode_list_get);
> +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static int team_nl_fill_port_list_get_changed(struct sk_buff *skb,
> + u32 pid, u32 seq, int flags,
> + struct team *team,
> + struct team_port *changed_port)
> +{
> + struct nlattr *port_list;
> + void *hdr;
> + struct team_port *port;
> +
> + hdr = genlmsg_put(skb, pid, seq, &team_nl_family, flags,
> + TEAM_CMD_PORT_LIST_GET);
> + if (IS_ERR(hdr))
> + return PTR_ERR(hdr);
> +
> + NLA_PUT_U32(skb, TEAM_ATTR_TEAM_IFINDEX, team->dev->ifindex);
> + port_list = nla_nest_start(skb, TEAM_ATTR_LIST_PORT);
> + if (!port_list)
> + return -EMSGSIZE;
> +
> + list_for_each_entry_rcu(port, &team->port_list, list) {
> + struct nlattr *port_item;
> +
> + port_item = nla_nest_start(skb, TEAM_ATTR_ITEM_MODE);
> + if (!port_item)
> + goto nla_put_failure;
> + NLA_PUT_U32(skb, TEAM_ATTR_PORT_IFINDEX, port->dev->ifindex);
> + if (port == changed_port)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_CHANGED);
> + if (port->linkup)
> + NLA_PUT_FLAG(skb, TEAM_ATTR_PORT_LINKUP);
> + NLA_PUT_U32(skb, TEAM_ATTR_PORT_SPEED, port->speed);
> + NLA_PUT_U8(skb, TEAM_ATTR_PORT_DUPLEX, port->duplex);
> + nla_nest_end(skb, port_item);
> + }
> +
> + nla_nest_end(skb, port_list);
> + return genlmsg_end(skb, hdr);
> +
> +nla_put_failure:
> + genlmsg_cancel(skb, hdr);
> + return -EMSGSIZE;
> +}
> +
> +static int team_nl_fill_port_list_get(struct sk_buff *skb,
> + struct genl_info *info, int flags,
> + struct team *team)
> +{
> + return team_nl_fill_port_list_get_changed(skb, info->snd_pid,
> + info->snd_seq, NLM_F_ACK,
> + team, NULL);
> +}
> +
> +static int team_nl_cmd_port_list_get(struct sk_buff *skb,
> + struct genl_info *info)
> +{
> + struct team *team;
> + int err;
> +
> + team = team_nl_team_get(info);
> + if (!team)
> + return -EINVAL;
> +
> + err = team_nl_send_generic(info, team, team_nl_fill_port_list_get);
> +
> + team_nl_team_put(team);
> +
> + return err;
> +}
> +
> +static struct genl_ops team_nl_ops[] = {
> + {
> + .cmd = TEAM_CMD_NOOP,
> + .doit = team_nl_cmd_noop,
> + .policy = team_nl_policy,
> + },
> + {
> + .cmd = TEAM_CMD_OPTIONS_SET,
> + .doit = team_nl_cmd_options_set,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_OPTIONS_GET,
> + .doit = team_nl_cmd_options_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_MODE_LIST_GET,
> + .doit = team_nl_cmd_mode_list_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> + {
> + .cmd = TEAM_CMD_PORT_LIST_GET,
> + .doit = team_nl_cmd_port_list_get,
> + .policy = team_nl_policy,
> + .flags = GENL_ADMIN_PERM,
> + },
> +};
> +
> +static struct genl_multicast_group team_change_event_mcgrp = {
> + .name = TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME,
> +};
> +
> +static int team_nl_send_event_options_get(struct team *team,
> + struct team_option *changed_option)
> +{
> + struct sk_buff *skb;
> + int err;
> + struct net *net = dev_net(team->dev);
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = team_nl_fill_options_get_changed(skb, 0, 0, 0, team,
> + changed_option);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_multicast_netns(net, skb, 0, team_change_event_mcgrp.id,
> + GFP_KERNEL);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_send_event_port_list_get(struct team_port *port)
> +{
> + struct sk_buff *skb;
> + int err;
> + struct net *net = dev_net(port->team->dev);
> +
> + skb = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
> + if (!skb)
> + return -ENOMEM;
> +
> + err = team_nl_fill_port_list_get_changed(skb, 0, 0, 0,
> + port->team, port);
> + if (err < 0)
> + goto err_fill;
> +
> + err = genlmsg_multicast_netns(net, skb, 0, team_change_event_mcgrp.id,
> + GFP_KERNEL);
> + return err;
> +
> +err_fill:
> + nlmsg_free(skb);
> + return err;
> +}
> +
> +static int team_nl_init(void)
> +{
> + int err;
> +
> + err = genl_register_family_with_ops(&team_nl_family, team_nl_ops,
> + ARRAY_SIZE(team_nl_ops));
> + if (err)
> + return err;
> +
> + err = genl_register_mc_group(&team_nl_family, &team_change_event_mcgrp);
> + if (err)
> + goto err_change_event_grp_reg;
> +
> + return 0;
> +
> +err_change_event_grp_reg:
> + genl_unregister_family(&team_nl_family);
> +
> + return err;
> +}
> +
> +static void team_nl_fini(void)
> +{
> + genl_unregister_family(&team_nl_family);
> +}
> +
> +
> +/******************
> + * Change checkers
> + ******************/
> +
> +static void __team_options_change_check(struct team *team,
> + struct team_option *changed_option)
> +{
> + int err;
> +
> + err = team_nl_send_event_options_get(team, changed_option);
> + if (err)
> + netdev_warn(team->dev, "Failed to send options change "
> + "via netlink\n");
> +}
> +
> +/* rtnl lock is held */
> +static void __team_port_change_check(struct team_port *port, bool linkup)
> +{
> + int err;
> +
> + if (port->linkup == linkup)
> + return;
> +
> + port->linkup = linkup;
> + if (linkup) {
> + struct ethtool_cmd ecmd;
> +
> + err = __ethtool_get_settings(port->dev, &ecmd);
> + if (!err) {
> + port->speed = ethtool_cmd_speed(&ecmd);
> + port->duplex = ecmd.duplex;
> + goto send_event;
> + }
> + }
> + port->speed = 0;
> + port->duplex = 0;
> +
> +send_event:
> + err = team_nl_send_event_port_list_get(port);
> + if (err)
> + netdev_warn(port->team->dev, "Failed to send port change of "
> + "device %s via netlink\n",
> + port->dev->name);
> +
> +}
> +
> +static void team_port_change_check(struct team_port *port, bool linkup)
> +{
> + struct team *team = port->team;
> +
> + spin_lock(&team->lock);
> + __team_port_change_check(port, linkup);
> + spin_unlock(&team->lock);
> +}
> +
> +/************************************
> + * Net device notifier event handler
> + ************************************/
> +
> +static int team_device_event(struct notifier_block *unused,
> + unsigned long event, void *ptr)
> +{
> + struct net_device *dev = (struct net_device *) ptr;
> + struct team_port *port;
> +
> + port = team_port_get_rtnl(dev);
> + if (!port)
> + return NOTIFY_DONE;
> +
> + switch (event) {
> + case NETDEV_UP:
> + if (netif_carrier_ok(dev));
> + team_port_change_check(port, true);
> + case NETDEV_DOWN:
> + team_port_change_check(port, false);
> + case NETDEV_CHANGE:
> + if (netif_running(port->dev))
> + team_port_change_check(port,
> + !!netif_carrier_ok(port->dev));
> + break;
> + case NETDEV_UNREGISTER:
> + team_del_slave(port->team->dev, dev);
> + break;
> + case NETDEV_FEAT_CHANGE:
> + team_compute_features(port->team);
> + break;
> + case NETDEV_CHANGEMTU:
> + /* Forbid to change mtu of underlaying device */
> + return NOTIFY_BAD;
> + case NETDEV_CHANGEADDR:
> + /* Forbid to change addr of underlaying device */
> + return NOTIFY_BAD;
> + case NETDEV_PRE_TYPE_CHANGE:
> + /* Forbid to change type of underlaying device */
> + return NOTIFY_BAD;
> + }
> + return NOTIFY_DONE;
> +}
> +
> +static struct notifier_block team_notifier_block __read_mostly = {
> + .notifier_call = team_device_event,
> +};
> +
> +
> +/***********************
> + * Module init and exit
> + ***********************/
> +
> +static int __init team_module_init(void)
> +{
> + int err;
> +
> + register_netdevice_notifier(&team_notifier_block);
> +
> + err = rtnl_link_register(&team_link_ops);
> + if (err)
> + goto err_rtln_reg;
> +
> + err = team_nl_init();
> + if (err)
> + goto err_nl_init;
> +
> + return 0;
> +
> +err_nl_init:
> + rtnl_link_unregister(&team_link_ops);
> +
> +err_rtln_reg:
> + unregister_netdevice_notifier(&team_notifier_block);
> +
> + return err;
> +}
> +
> +static void __exit team_module_exit(void)
> +{
> + team_nl_fini();
> + rtnl_link_unregister(&team_link_ops);
> + unregister_netdevice_notifier(&team_notifier_block);
> +}
> +
> +module_init(team_module_init);
> +module_exit(team_module_exit);
> +
> +MODULE_LICENSE("GPL v2");
> +MODULE_AUTHOR("Jiri Pirko <jpirko@redhat.com>");
> +MODULE_DESCRIPTION("Ethernet team device driver");
> +MODULE_ALIAS_RTNL_LINK(DRV_NAME);
> diff --git a/include/linux/Kbuild b/include/linux/Kbuild
> index 619b565..0b091b3 100644
> --- a/include/linux/Kbuild
> +++ b/include/linux/Kbuild
> @@ -185,6 +185,7 @@ header-y += if_pppol2tp.h
> header-y += if_pppox.h
> header-y += if_slip.h
> header-y += if_strip.h
> +header-y += if_team.h
> header-y += if_tr.h
> header-y += if_tun.h
> header-y += if_tunnel.h
> diff --git a/include/linux/if.h b/include/linux/if.h
> index db20bd4..e98f39d 100644
> --- a/include/linux/if.h
> +++ b/include/linux/if.h
> @@ -79,6 +79,7 @@
> #define IFF_TX_SKB_SHARING 0x10000 /* The interface supports sharing
> * skbs on transmit */
> #define IFF_UNICAST_FLT 0x20000 /* Supports unicast filtering */
> +#define IFF_TEAM_PORT 0x40000 /* device used as teaming port */
>
> #define IF_GET_IFACE 0x0001 /* for querying only */
> #define IF_GET_PROTO 0x0002
> diff --git a/include/linux/if_team.h b/include/linux/if_team.h
> new file mode 100644
> index 0000000..b451c9e
> --- /dev/null
> +++ b/include/linux/if_team.h
> @@ -0,0 +1,126 @@
> +/*
> + * include/linux/if_team.h - Network team device driver header
> + * Copyright (c) 2011 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.
> + */
> +
> +#ifndef _LINUX_IF_TEAM_H_
> +#define _LINUX_IF_TEAM_H_
> +
> +#define TEAM_STRING_MAX_LEN 32
> +
> +/**********************************
> + * NETLINK_GENERIC netlink family.
> + **********************************/
> +
> +enum {
> + TEAM_CMD_NOOP,
> + TEAM_CMD_OPTIONS_SET,
> + TEAM_CMD_OPTIONS_GET,
> + TEAM_CMD_MODE_LIST_GET,
> + TEAM_CMD_PORT_LIST_GET,
> +
> + __TEAM_CMD_MAX,
> + TEAM_CMD_MAX = (__TEAM_CMD_MAX - 1),
> +};
> +
> +enum {
> + TEAM_ATTR_UNSPEC,
> + TEAM_ATTR_TEAM_IFINDEX, /* u32 */
> + TEAM_ATTR_LIST_OPTION, /* nest */
> + TEAM_ATTR_LIST_MODE, /* nest */
> + TEAM_ATTR_LIST_PORT, /* nest */
> +
> + __TEAM_ATTR_MAX,
> + TEAM_ATTR_MAX = __TEAM_ATTR_MAX - 1,
> +};
> +
> +/* Nested layout of get/set msg:
> + *
> + * [TEAM_ATTR_LIST_OPTION]
> + * [TEAM_ATTR_ITEM_OPTION]
> + * [TEAM_ATTR_OPTION_*], ...
> + * [TEAM_ATTR_ITEM_OPTION]
> + * [TEAM_ATTR_OPTION_*], ...
> + * ...
> + * [TEAM_ATTR_LIST_MODE]
> + * [TEAM_ATTR_ITEM_MODE]
> + * [TEAM_ATTR_MODE_*], ...
> + * [TEAM_ATTR_ITEM_MODE]
> + * [TEAM_ATTR_MODE_*], ...
> + * ...
> + * [TEAM_ATTR_LIST_PORT]
> + * [TEAM_ATTR_ITEM_PORT]
> + * [TEAM_ATTR_PORT_*], ...
> + * [TEAM_ATTR_ITEM_PORT]
> + * [TEAM_ATTR_PORT_*], ...
> + * ...
> + */
> +
> +enum {
> + TEAM_ATTR_ITEM_OPTION_UNSPEC,
> + TEAM_ATTR_ITEM_OPTION, /* nest */
> +
> + __TEAM_ATTR_ITEM_OPTION_MAX,
> + TEAM_ATTR_ITEM_OPTION_MAX = __TEAM_ATTR_ITEM_OPTION_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_OPTION_UNSPEC,
> + TEAM_ATTR_OPTION_NAME, /* string */
> + TEAM_ATTR_OPTION_CHANGED, /* flag */
> + TEAM_ATTR_OPTION_TYPE, /* u8 */
> + TEAM_ATTR_OPTION_DATA, /* dynamic */
> +
> + __TEAM_ATTR_OPTION_MAX,
> + TEAM_ATTR_OPTION_MAX = __TEAM_ATTR_OPTION_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_ITEM_MODE_UNSPEC,
> + TEAM_ATTR_ITEM_MODE, /* nest */
> +
> + __TEAM_ATTR_ITEM_MODE_MAX,
> + TEAM_ATTR_ITEM_MODE_MAX = __TEAM_ATTR_ITEM_MODE_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_MODE_UNSPEC,
> + TEAM_ATTR_MODE_NAME, /* string */
> +
> + __TEAM_ATTR_MODE_MAX,
> + TEAM_ATTR_MODE_MAX = __TEAM_ATTR_MODE_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_ITEM_PORT_UNSPEC,
> + TEAM_ATTR_ITEM_PORT, /* nest */
> +
> + __TEAM_ATTR_ITEM_PORT_MAX,
> + TEAM_ATTR_ITEM_PORT_MAX = __TEAM_ATTR_ITEM_PORT_MAX - 1,
> +};
> +
> +enum {
> + TEAM_ATTR_PORT_UNSPEC,
> + TEAM_ATTR_PORT_IFINDEX, /* u32 */
> + TEAM_ATTR_PORT_CHANGED, /* flag */
> + TEAM_ATTR_PORT_LINKUP, /* flag */
> + TEAM_ATTR_PORT_SPEED, /* u32 */
> + TEAM_ATTR_PORT_DUPLEX, /* u8 */
> +
> + __TEAM_ATTR_PORT_MAX,
> + TEAM_ATTR_PORT_MAX = __TEAM_ATTR_PORT_MAX - 1,
> +};
> +
> +/*
> + * NETLINK_GENERIC related info
> + */
> +#define TEAM_GENL_NAME "team"
> +#define TEAM_GENL_VERSION 0x1
> +#define TEAM_GENL_CHANGE_EVENT_MC_GRP_NAME "change_event"
> +
> +#endif
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Eric Dumazet @ 2011-10-04 15:18 UTC (permalink / raw)
To: Jiri Pirko
Cc: netdev, davem, bhutchings, shemminger, fubar, andy, tgraf,
ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <1317741242.24651.12.camel@edumazet-HP-Compaq-6005-Pro-SFF-PC>
Le mardi 04 octobre 2011 à 17:14 +0200, Eric Dumazet a écrit :
> Le mardi 04 octobre 2011 à 16:15 +0200, Jiri Pirko a écrit :
> > This patch introduces new network device called team. It supposes to be
> > very fast, simple, userspace-driven alternative to existing bonding
> > driver.
> >
> > Userspace library called libteam with couple of demo apps is available
> > here:
> > https://github.com/jpirko/libteam
> > Note it's still in its dipers atm.
> >
> > team<->libteam use generic netlink for communication. That and rtnl
> > suppose to be the only way to configure team device, no sysfs etc.
> >
> > In near future python binding for libteam will be introduced. Also
> > daemon providing arpmon/miimon active-backup functionality will
> > be introduced. All what's necessary is already implemented in kernel team
> > driver.
> >
> > Signed-off-by: Jiri Pirko <jpirko@redhat.com>
> > ---
>
> Very nice work Jiri
Sorry for the very long answer, I accidentally pressed the "Envoyer"
button before cutting out large part of your mail.
^ permalink raw reply
* Re: linux-next: manual merge of the staging tree with the net and wireless trees
From: Greg KH @ 2011-10-04 15:25 UTC (permalink / raw)
To: Stephen Rothwell
Cc: linux-next, linux-kernel, Eliad Peller, John W. Linville,
David Miller, netdev
In-Reply-To: <20111004171449.de5c45332510a453cc3ff879@canb.auug.org.au>
On Tue, Oct 04, 2011 at 05:14:49PM +1100, Stephen Rothwell wrote:
> Hi Greg,
>
> Today's linux-next merge of the staging tree got a conflict in
> drivers/staging/brcm80211/brcmsmac/mac80211_if.c between commit
> 37a41b4affa3 ("mac80211: add ieee80211_vif param to tsf functions") from
> the net tree, commit 8a3a3c85e44d ("mac80211: pass vif param to conf_tx()
> callback") from the wireless tree and several commits from the staging
> tree.
>
> I fixed it up (just removed the forward declarions that were changed by
> the former commits) and can carry the fix as necessary.
Thanks, that sounds correct.
Aren't you happy my trees are back now? :)
greg k-h
^ permalink raw reply
* TCP-RENO in Linux
From: sannikov @ 2011-10-04 15:10 UTC (permalink / raw)
To: netdev
Hello.
Sorry, maybe this question not for netdev mailing list.
Does anybody works with TCP congestion control (RENO)?
I'm observe strange behavior of RENO: number of
TCP-segments transmitted with some value of
window is much more than this value.
For example: if window size is 212 it is
transmits 450 segments with such window size.
Can you give me some ideas or search direction.
I will be very thankful to you.
--
With best regards, Alexander Sannikov.
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Jiri Pirko @ 2011-10-04 16:12 UTC (permalink / raw)
To: Flavio Leitner
Cc: netdev, davem, eric.dumazet, bhutchings, shemminger, fubar, andy,
tgraf, ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <20111004115344.0aca0fa1@asterix.rh>
Tue, Oct 04, 2011 at 04:53:44PM CEST, fbl@redhat.com wrote:
<snip>
>> +
>> +struct team_mode_ops {
>> + int (*init)(struct team *team);
>> + void (*exit)(struct team *team);
>> + rx_handler_result_t (*receive)(struct team *team,
>> + struct team_port *port,
>> + struct sk_buff *skb);
>
>nitpick:
>As it doesn't have any other type of results, I would suggest
>to rename rx_handler_result_t be to shorter, i.e. rx_result_t.
Well that type is defined already in include/linux/netdevice.h
I like the original name better because it has "handler" word in it
(which imo reduces possible confusion)
>
>
>> + bool (*transmit)(struct team *team, struct sk_buff *skb);
>> + int (*port_enter)(struct team *team, struct team_port *port);
>
>Perhaps instead of 'port_enter', use 'port_join'.
Might be more appropriate, not sure (my eng skills recognize these two
as very similar in this case)
>
>
>> + void (*port_leave)(struct team *team, struct team_port
>> *port);
>> + void (*port_change_mac)(struct team *team, struct team_port
>> *port); +};
>> +
>> +enum team_option_type {
>> + TEAM_OPTION_TYPE_U32,
>> + TEAM_OPTION_TYPE_STRING,
>> +};
>> +
>> +struct team_option {
>> + struct list_head list;
>> + const char *name;
>> + enum team_option_type type;
>> + int (*getter)(struct team *team, void *arg);
>> + int (*setter)(struct team *team, void *arg);
>
>What means getter and setter?
Option getter and setter. Function used to set and get the option.
>
>> +};
>> +
>> +struct team_mode {
>> + const char *kind;
>> + const struct team_mode_ops *ops;
>> +};
>> +
>> +struct rr_priv {
>> + unsigned int sent_packets;
>> +};
>> +
>> +struct ab_priv {
>> + struct team_port __rcu *active_port;
>> +};
>> +
>> +struct team {
>> + struct net_device *dev; /* associated netdevice */
>> + spinlock_t lock; /* used for overall locking, e.g. port
>> lists write */ +
>> + /*
>> + * port lists with port count
>> + */
>> + int port_count;
>> + struct hlist_head *port_hlist;
>> + struct list_head port_list;
>> +
>> + struct list_head option_list;
>> +
>> + const char *mode_kind;
>> + struct team_mode_ops mode_ops;
>> + union {
>> + char priv_first_byte;
>> + struct ab_priv ab_priv;
>> + struct rr_priv rr_priv;
>> + };
>
>I think the union should be a pointer or work in the same
>way as netdev_priv() does.
The reason I did this this way is saving one pointer dereference in hot
paths. In netdev priv the memory for priv data is allcated along with
netdev struct. In this case this is not possible because mode can be
changed during team device lifetime (and team priv is netdev priv).
<snip>
>> +
>> +static bool rr_transmit(struct team *team, struct sk_buff *skb)
>> +{
>> + struct team_port *port;
>> + int port_index;
>> +
>> + port_index = team->rr_priv.sent_packets++ % team->port_count;
>> + port = team_get_port_by_index_rcu(team, port_index);
>> + port = __get_first_port_up(team, port);
>
>Well, __get_first_port_up() will frequently just do:
>
> if (port->linkup)
> return port;
>
>so, as it is in the hot TX path, can this be modified to be something
>like below to avoid one function call?
>
> port = team_get_port_by_index_rcu(team, port_index);
> if (unlikely(port->linkup))
> port = __get_first_port_up(team, port);
Hmm, I don't think this is correct place to use "likely". Imagine you
have 2 ports and one of them is down all the team lifetime. You would
be hitting wrong branch always which will cause performance penalty.
>> +
>> +static const struct team_mode ab_mode = {
>> + .kind = "activebackup",
>> + .ops = &ab_mode_ops,
>> +};
>> +
>
>I would suggest to move each of the ab and rr specifics
>to their own module. The idea is to have the team module
>as a generic module as possible and every mode on its module.
>Not sure what your plans are for this.
Well I was thinking about this for sure. One reason to have this in one
place is the mode_priv union you were referring to.
Other reason is that mode parts should be very easy and short. Also
their number should be limited (~4).
>
>
>> +/****************
>> + * Mode handling
>> + ****************/
>> +
>> +static const struct team_mode *team_modes[] = {
>> + &rr_mode,
>> + &ab_mode,
>> +};
>
>Following the above suggestion, this would require
>register/unregister ops.
>
>
<snip>
>> +
>> +static struct rtnl_link_stats64 *team_get_stats(struct net_device
>> *dev,
>> + struct
>> rtnl_link_stats64 *stats) +{
>> + struct team *team = netdev_priv(dev);
>> + struct rtnl_link_stats64 temp;
>> + struct team_port *port;
>> +
>> + memset(stats, 0, sizeof(*stats));
>> +
>> + rcu_read_lock();
>> + list_for_each_entry_rcu(port, &team->port_list, list) {
>> + const struct rtnl_link_stats64 *pstats;
>> +
>> + pstats = dev_get_stats(port->dev, &temp);
>> +
>> + stats->rx_packets += pstats->rx_packets;
>> + stats->rx_bytes += pstats->rx_bytes;
>> + stats->rx_errors += pstats->rx_errors;
>> + stats->rx_dropped += pstats->rx_dropped;
>> +
>> + stats->tx_packets += pstats->tx_packets;
>> + stats->tx_bytes += pstats->tx_bytes;
>> + stats->tx_errors += pstats->tx_errors;
>> + stats->tx_dropped += pstats->tx_dropped;
>> +
>> + stats->multicast += pstats->multicast;
>> + stats->collisions += pstats->collisions;
>> +
>> + stats->rx_length_errors += pstats->rx_length_errors;
>> + stats->rx_over_errors += pstats->rx_over_errors;
>> + stats->rx_crc_errors += pstats->rx_crc_errors;
>> + stats->rx_frame_errors += pstats->rx_frame_errors;
>> + stats->rx_fifo_errors += pstats->rx_fifo_errors;
>> + stats->rx_missed_errors += pstats->rx_missed_errors;
>> +
>> + stats->tx_aborted_errors +=
>> pstats->tx_aborted_errors;
>> + stats->tx_carrier_errors +=
>> pstats->tx_carrier_errors;
>> + stats->tx_fifo_errors += pstats->tx_fifo_errors;
>> + stats->tx_heartbeat_errors +=
>> pstats->tx_heartbeat_errors;
>> + stats->tx_window_errors += pstats->tx_window_errors;
>> + }
>> + rcu_read_unlock();
>> +
>> + return stats;
>> +}
>
>I don't think computing stats like that is useful. We can do
>that in userlevel with ethtool -S on each slave and sum all them.
>I think it would be better to have the errors computed based on
>events that happens inside of Team driver, so we can really see if
>something is happening inside of the Team driver or on its slaves.
I was thinking about this as well. I did this in same ways it's done in
bonding driver. One of reasons were that I can't count dropped packets
in team_handle_frame because I do not call netif_rx there and only
return RX_HANDLER_ANOTHER to "reinject" (saving one function call).
<snip>
>> +
>> +static int team_add_slave(struct net_device *dev, struct net_device
>> *port_dev) +{
>> + struct team *team = netdev_priv(dev);
>> + int err;
>> +
>> + spin_lock(&team->lock);
>> + err = team_port_add(team, port_dev);
>> + spin_unlock(&team->lock);
>> + return err;
>> +}
>
>I am not seeing any difference between slave and port, so why not stick
>with just one?
I like "port" better. It's more accurate. team_add/del_slave has its name
only because ndo is named the same.
<snip>
>
>fbl
Thanks for review Flavio.
Jirka
^ permalink raw reply
* [RFC] iproute2: add br command
From: Stephen Hemminger @ 2011-10-04 16:34 UTC (permalink / raw)
To: Kevin Wilson, netdev
In-Reply-To: <CAGXs5wWeFcyHQ4vO562pTOdqLNEKrJwES3W_hFF_M2reNoe1rA@mail.gmail.com>
This adds a new 'br' command which is the bridging equivalent of
the ip command. More of a demo of how to use netlink and bridging
at this point.
---
Makefile | 2 +-
br/.gitignore | 1 +
br/Makefile | 14 +++
br/br.c | 104 ++++++++++++++++++++++++
br/br_common.h | 13 +++
br/fdb.c | 245 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
br/link.c | 142 ++++++++++++++++++++++++++++++++
br/monitor.c | 138 +++++++++++++++++++++++++++++++
man/man8/br.8 | 177 ++++++++++++++++++++++++++++++++++++++++
9 files changed, 835 insertions(+), 1 deletions(-)
create mode 100644 br/.gitignore
create mode 100644 br/Makefile
create mode 100644 br/br.c
create mode 100644 br/br_common.h
create mode 100644 br/fdb.c
create mode 100644 br/link.c
create mode 100644 br/monitor.c
create mode 100644 man/man8/br.8
diff --git a/Makefile b/Makefile
index d1ace1f..f1d360a 100644
--- a/Makefile
+++ b/Makefile
@@ -33,7 +33,7 @@ CCOPTS = -D_GNU_SOURCE -O2 -Wstrict-prototypes -Wall
CFLAGS = $(CCOPTS) -I../include $(DEFINES)
YACCFLAGS = -d -t -v
-SUBDIRS=lib ip tc misc netem genl
+SUBDIRS=lib ip tc br misc netem genl
LIBNETLINK=../lib/libnetlink.a ../lib/libutil.a
LDLIBS += $(LIBNETLINK)
diff --git a/br/.gitignore b/br/.gitignore
new file mode 100644
index 0000000..b9a724f
--- /dev/null
+++ b/br/.gitignore
@@ -0,0 +1 @@
+br
diff --git a/br/Makefile b/br/Makefile
new file mode 100644
index 0000000..2bb18a7
--- /dev/null
+++ b/br/Makefile
@@ -0,0 +1,14 @@
+BROBJ = br.o fdb.o monitor.o link.o
+
+include ../Config
+
+all: br
+
+br: $(BROBJ) $(LIBNETLINK)
+
+install: all
+ install -m 0755 br $(DESTDIR)$(SBINDIR)
+
+clean:
+ rm -f $(BROBJ) br
+
diff --git a/br/br.c b/br/br.c
new file mode 100644
index 0000000..9e5f69c
--- /dev/null
+++ b/br/br.c
@@ -0,0 +1,104 @@
+/*
+ * Get/set/delete bridge with netlink
+ *
+ * Authors: Stephen Hemminger <shemminger@vyatta.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <string.h>
+
+#include "SNAPSHOT.h"
+#include "utils.h"
+#include "br_common.h"
+
+struct rtnl_handle rth = { .fd = -1 };
+int resolve_hosts;
+int show_stats;
+int show_details;
+int timestamp;
+
+static void usage(void) __attribute__((noreturn));
+
+static void usage(void)
+{
+ fprintf(stderr,
+"Usage: br [ OPTIONS ] OBJECT { COMMAND | help }\n"
+"where OBJECT := { fdb | monitor }\n"
+" OPTIONS := { -V[ersion] | -s[tatistics] | -d[etails]\n" );
+ exit(-1);
+}
+
+static int do_help(int argc, char **argv)
+{
+ usage();
+}
+
+
+static const struct cmd {
+ const char *cmd;
+ int (*func)(int argc, char **argv);
+} cmds[] = {
+ { "fdb", do_fdb },
+ { "monitor", do_monitor },
+ { "help", do_help },
+ { 0 }
+};
+
+static int do_cmd(const char *argv0, int argc, char **argv)
+{
+ const struct cmd *c;
+
+ for (c = cmds; c->cmd; ++c) {
+ if (matches(argv0, c->cmd) == 0)
+ return c->func(argc-1, argv+1);
+ }
+
+ fprintf(stderr, "Object \"%s\" is unknown, try \"br help\".\n", argv0);
+ return -1;
+}
+
+int
+main(int argc, char **argv)
+{
+ while (argc > 1) {
+ char *opt = argv[1];
+ if (strcmp(opt,"--") == 0) {
+ argc--; argv++;
+ break;
+ }
+ if (opt[0] != '-')
+ break;
+ if (opt[1] == '-')
+ opt++;
+
+ if (matches(opt, "-help") == 0) {
+ usage();
+ } else if (matches(opt, "-Version") == 0) {
+ printf("br utility, 0.0\n");
+ exit(0);
+ } else if (matches(opt, "-stats") == 0 ||
+ matches(opt, "-statistics") == 0) {
+ ++show_stats;
+ } else if (matches(opt, "-details") == 0) {
+ ++show_details;
+ } else if (matches(opt, "-timestamp") == 0) {
+ ++timestamp;
+ } else {
+ fprintf(stderr, "Option \"%s\" is unknown, try \"br -help\".\n", opt);
+ exit(-1);
+ }
+ argc--; argv++;
+ }
+
+ if (rtnl_open(&rth, 0) < 0)
+ exit(1);
+
+ if (argc > 1)
+ return do_cmd(argv[1], argc-1, argv+1);
+
+ rtnl_close(&rth);
+ usage();
+}
diff --git a/br/br_common.h b/br/br_common.h
new file mode 100644
index 0000000..ec1671d
--- /dev/null
+++ b/br/br_common.h
@@ -0,0 +1,13 @@
+extern int print_linkinfo(const struct sockaddr_nl *who,
+ struct nlmsghdr *n,
+ void *arg);
+extern int print_fdb(const struct sockaddr_nl *who,
+ struct nlmsghdr *n, void *arg);
+
+extern int do_fdb(int argc, char **argv);
+extern int do_monitor(int argc, char **argv);
+
+extern int show_stats;
+extern int show_detail;
+extern int timestamp;
+extern struct rtnl_handle rth;
diff --git a/br/fdb.c b/br/fdb.c
new file mode 100644
index 0000000..d849f97
--- /dev/null
+++ b/br/fdb.c
@@ -0,0 +1,245 @@
+/*
+ * Get/set/delete fdb table with netlink
+ *
+ * Authors: Stephen Hemminger <shemminger@vyatta.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <linux/if_bridge.h>
+#include <linux/if_ether.h>
+#include <linux/neighbour.h>
+#include <string.h>
+
+#include "libnetlink.h"
+#include "br_common.h"
+#include "utils.h"
+
+int filter_index;
+
+static void usage(void)
+{
+ fprintf(stderr, "Usage: br fdb { add | del | replace } ADDR dev DEV\n");
+ fprintf(stderr, " br fdb {show} [ dev DEV ]\n");
+ exit(-1);
+}
+
+static const char *state_n2a(unsigned s)
+{
+ static char buf[32];
+
+ if (s & NUD_PERMANENT)
+ return "local";
+
+ if (s & NUD_NOARP)
+ return "static";
+
+ if (s & NUD_STALE)
+ return "stale";
+
+ if (s & NUD_REACHABLE)
+ return "";
+
+ sprintf(buf, "state=%#x", s);
+ return buf;
+}
+
+static char *fmt_time(char *b, size_t l, unsigned long tick)
+{
+ static int hz;
+
+ if (hz == 0)
+ hz = __get_user_hz();
+
+ snprintf(b, l, "%lu.%02lu", tick / hz, ((tick % hz) * hz) / 100);
+ return b;
+}
+
+int print_fdb(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
+{
+ FILE *fp = arg;
+ struct ndmsg *r = NLMSG_DATA(n);
+ int len = n->nlmsg_len;
+ struct rtattr * tb[NDA_MAX+1];
+ const __u8 *addr = NULL;
+ char b1[32];
+
+ len -= NLMSG_LENGTH(sizeof(*r));
+ if (len < 0) {
+ fprintf(stderr, "BUG: wrong nlmsg len %d\n", len);
+ return -1;
+ }
+
+ if (r->ndm_family != AF_BRIDGE)
+ return 0;
+
+ if (filter_index && filter_index != r->ndm_ifindex)
+ return 0;
+
+ parse_rtattr(tb, NDA_MAX, NDA_RTA(r),
+ n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
+
+ if (n->nlmsg_type == RTM_DELNEIGH)
+ fprintf(fp, "Deleted ");
+
+ if (tb[NDA_LLADDR])
+ addr = RTA_DATA(tb[NDA_LLADDR]);
+ else {
+ fprintf(stderr, "missing lladdr\n");
+ return -1;
+ }
+
+ fprintf(fp, "%s\t%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\t%s",
+ ll_index_to_name(r->ndm_ifindex),
+ addr[0], addr[1], addr[2],
+ addr[3], addr[4], addr[5],
+ state_n2a(r->ndm_state));
+
+ if (show_stats && tb[NDA_CACHEINFO]) {
+ struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
+
+ fprintf(fp, "\t%8s", fmt_time(b1, sizeof(b1), ci->ndm_updated));
+ fprintf(fp, " %8s", fmt_time(b1, sizeof(b1), ci->ndm_used));
+ }
+ fprintf(fp, "\n");
+ fflush(fp);
+ return 0;
+}
+
+static int fdb_show(int argc, char **argv)
+{
+ char *filter_dev = NULL;
+
+ while (argc > 0) {
+ if (strcmp(*argv, "dev") == 0) {
+ NEXT_ARG();
+ if (filter_dev)
+ duparg("dev", *argv);
+ filter_dev = *argv;
+ }
+ argc--; argv++;
+ }
+
+ if (filter_dev) {
+ if ((filter_index = if_nametoindex(filter_dev)) == 0) {
+ fprintf(stderr, "Cannot find device \"%s\"\n", filter_dev);
+ return -1;
+ }
+ }
+
+ if (rtnl_wilddump_request(&rth, PF_BRIDGE, RTM_GETNEIGH) < 0) {
+ perror("Cannot send dump request");
+ exit(1);
+ }
+
+ printf("port\tmac addr\t\tflags%s\n",
+ show_stats ? "\t updated used" : "");
+
+ if (rtnl_dump_filter(&rth, print_fdb, stdout, NULL, NULL) < 0) {
+ fprintf(stderr, "Dump terminated\n");
+ exit(1);
+ }
+
+ return 0;
+}
+
+static int fdb_modify(int cmd, int flags, int argc, char **argv)
+{
+ struct {
+ struct nlmsghdr n;
+ struct ndmsg ndm;
+ char buf[256];
+ } req;
+ char *addr = NULL;
+ char *d = NULL;
+ char abuf[ETH_ALEN];
+
+ memset(&req, 0, sizeof(req));
+
+ req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ndmsg));
+ req.n.nlmsg_flags = NLM_F_REQUEST|flags;
+ req.n.nlmsg_type = cmd;
+ req.ndm.ndm_family = PF_BRIDGE;
+ req.ndm.ndm_state = NUD_NOARP;
+
+ while (argc > 0) {
+ if (strcmp(*argv, "dev") == 0) {
+ NEXT_ARG();
+ d = *argv;
+ } else if (strcmp(*argv, "local") == 0) {
+ req.ndm.ndm_state = NUD_PERMANENT;
+ } else if (strcmp(*argv, "temp") == 0) {
+ req.ndm.ndm_state = NUD_REACHABLE;
+ } else {
+ if (strcmp(*argv, "to") == 0) {
+ NEXT_ARG();
+ }
+ if (matches(*argv, "help") == 0) {
+ NEXT_ARG();
+ }
+ if (addr)
+ duparg2("to", *argv);
+ addr = *argv;
+ }
+ argc--; argv++;
+ }
+
+ if (d == NULL || addr == NULL) {
+ fprintf(stderr, "Device and address are required arguments.\n");
+ exit(-1);
+ }
+
+ if (sscanf(addr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
+ abuf, abuf+1, abuf+2,
+ abuf+3, abuf+4, abuf+5) != 6) {
+ fprintf(stderr, "Invalid mac address %s\n", addr);
+ exit(-1);
+ }
+
+ addattr_l(&req.n, sizeof(req), NDA_LLADDR, abuf, ETH_ALEN);
+
+ req.ndm.ndm_ifindex = ll_name_to_index(d);
+ if (req.ndm.ndm_ifindex == 0) {
+ fprintf(stderr, "Cannot find device \"%s\"\n", d);
+ return -1;
+ }
+
+ if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
+ exit(2);
+
+ return 0;
+}
+
+int do_fdb(int argc, char **argv)
+{
+ ll_init_map(&rth);
+
+ if (argc > 0) {
+ if (matches(*argv, "add") == 0)
+ return fdb_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_EXCL, argc-1, argv+1);
+ if (matches(*argv, "change") == 0)
+ return fdb_modify(RTM_NEWNEIGH, NLM_F_REPLACE, argc-1, argv+1);
+
+ if (matches(*argv, "replace") == 0)
+ return fdb_modify(RTM_NEWNEIGH, NLM_F_CREATE|NLM_F_REPLACE, argc-1, argv+1);
+ if (matches(*argv, "delete") == 0)
+ return fdb_modify(RTM_DELNEIGH, 0, argc-1, argv+1);
+ if (matches(*argv, "show") == 0 ||
+ matches(*argv, "lst") == 0 ||
+ matches(*argv, "list") == 0)
+ return fdb_show(argc-1, argv+1);
+ if (matches(*argv, "help") == 0)
+ usage();
+ } else
+ return fdb_show(0, NULL);
+
+ fprintf(stderr, "Command \"%s\" is unknown, try \"ip neigh help\".\n", *argv);
+ exit(-1);
+}
diff --git a/br/link.c b/br/link.c
new file mode 100644
index 0000000..1b9541d
--- /dev/null
+++ b/br/link.c
@@ -0,0 +1,142 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <netinet/in.h>
+#include <linux/if.h>
+#include <linux/if_bridge.h>
+#include <string.h>
+
+#include "utils.h"
+#include "br_common.h"
+
+static const char *port_states[] = {
+ [BR_STATE_DISABLED] = "disabled",
+ [BR_STATE_LISTENING] = "listening",
+ [BR_STATE_LEARNING] = "learning",
+ [BR_STATE_FORWARDING] = "forwarding",
+ [BR_STATE_BLOCKING] = "blocking",
+};
+
+extern char *if_indextoname (unsigned int __ifindex, char *__ifname);
+
+static void print_link_flags(FILE *fp, unsigned flags)
+{
+ fprintf(fp, "<");
+ if (flags & IFF_UP && !(flags & IFF_RUNNING))
+ fprintf(fp, "NO-CARRIER%s", flags ? "," : "");
+ flags &= ~IFF_RUNNING;
+#define _PF(f) if (flags&IFF_##f) { \
+ flags &= ~IFF_##f ; \
+ fprintf(fp, #f "%s", flags ? "," : ""); }
+ _PF(LOOPBACK);
+ _PF(BROADCAST);
+ _PF(POINTOPOINT);
+ _PF(MULTICAST);
+ _PF(NOARP);
+ _PF(ALLMULTI);
+ _PF(PROMISC);
+ _PF(MASTER);
+ _PF(SLAVE);
+ _PF(DEBUG);
+ _PF(DYNAMIC);
+ _PF(AUTOMEDIA);
+ _PF(PORTSEL);
+ _PF(NOTRAILERS);
+ _PF(UP);
+ _PF(LOWER_UP);
+ _PF(DORMANT);
+ _PF(ECHO);
+#undef _PF
+ if (flags)
+ fprintf(fp, "%x", flags);
+ fprintf(fp, "> ");
+}
+
+static const char *oper_states[] = {
+ "UNKNOWN", "NOTPRESENT", "DOWN", "LOWERLAYERDOWN",
+ "TESTING", "DORMANT", "UP"
+};
+
+static void print_operstate(FILE *f, __u8 state)
+{
+ if (state >= sizeof(oper_states)/sizeof(oper_states[0]))
+ fprintf(f, "state %#x ", state);
+ else
+ fprintf(f, "state %s ", oper_states[state]);
+}
+
+int print_linkinfo(const struct sockaddr_nl *who,
+ struct nlmsghdr *n, void *arg)
+{
+ FILE *fp = arg;
+ int len = n->nlmsg_len;
+ struct ifinfomsg *ifi = NLMSG_DATA(n);
+ struct rtattr * tb[IFLA_MAX+1];
+ char b1[IFNAMSIZ];
+
+ len -= NLMSG_LENGTH(sizeof(*ifi));
+ if (len < 0) {
+ fprintf(stderr, "Message too short!\n");
+ return -1;
+ }
+
+ if (!(ifi->ifi_family == AF_BRIDGE || ifi->ifi_family == AF_UNSPEC))
+ return 0;
+
+ parse_rtattr(tb, IFLA_MAX, IFLA_RTA(ifi), len);
+
+ if (tb[IFLA_IFNAME] == NULL) {
+ fprintf(stderr, "BUG: nil ifname\n");
+ return -1;
+ }
+
+ if (n->nlmsg_type == RTM_DELLINK)
+ fprintf(fp, "Deleted ");
+
+ fprintf(fp, "%d: %s ", ifi->ifi_index,
+ tb[IFLA_IFNAME] ? (char*)RTA_DATA(tb[IFLA_IFNAME]) : "<nil>");
+
+ if (tb[IFLA_OPERSTATE])
+ print_operstate(fp, *(__u8 *)RTA_DATA(tb[IFLA_OPERSTATE]));
+
+ if (tb[IFLA_LINK]) {
+ SPRINT_BUF(b1);
+ int iflink = *(int*)RTA_DATA(tb[IFLA_LINK]);
+
+ if (iflink == 0)
+ fprintf(fp, "@NONE: ");
+ else {
+ fprintf(fp, "@%s: ",
+ if_indextoname(iflink, b1));
+ }
+ } else {
+ fprintf(fp, ": ");
+ }
+
+ print_link_flags(fp, ifi->ifi_flags);
+
+ if (tb[IFLA_MTU])
+ fprintf(fp, "mtu %u ", *(int*)RTA_DATA(tb[IFLA_MTU]));
+
+ if (tb[IFLA_MASTER]) {
+ fprintf(fp, "master %s ",
+ if_indextoname(*(int*)RTA_DATA(tb[IFLA_MASTER]), b1));
+ }
+
+ if (tb[IFLA_PROTINFO]) {
+ uint8_t state = *(uint8_t *)RTA_DATA(tb[IFLA_PROTINFO]);
+ if (state <= BR_STATE_BLOCKING)
+ fprintf(fp, "state %s", port_states[state]);
+ else
+ fprintf(fp, "state (%d)", state);
+ }
+
+
+ fprintf(fp, "\n");
+ fflush(fp);
+ return 0;
+}
diff --git a/br/monitor.c b/br/monitor.c
new file mode 100644
index 0000000..37468e6
--- /dev/null
+++ b/br/monitor.c
@@ -0,0 +1,138 @@
+/*
+ * brmonitor.c "br monitor"
+ *
+ * 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.
+ *
+ * Authors: Stephen Hemminger <shemminger@vyatta.com>
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <linux/if_bridge.h>
+#include <linux/neighbour.h>
+#include <string.h>
+
+#include "utils.h"
+#include "br_common.h"
+
+
+static void usage(void) __attribute__((noreturn));
+int prefix_banner;
+
+static void usage(void)
+{
+ fprintf(stderr, "Usage: br monitor\n");
+ exit(-1);
+}
+
+static int show_mark(FILE *fp, const struct nlmsghdr *n)
+{
+ char *tstr;
+ time_t secs = ((__u32*)NLMSG_DATA(n))[0];
+ long usecs = ((__u32*)NLMSG_DATA(n))[1];
+ tstr = asctime(localtime(&secs));
+ tstr[strlen(tstr)-1] = 0;
+ fprintf(fp, "Timestamp: %s %lu us\n", tstr, usecs);
+ return 0;
+}
+
+int accept_msg(const struct sockaddr_nl *who,
+ struct nlmsghdr *n, void *arg)
+{
+ FILE *fp = arg;
+
+ if (timestamp)
+ print_timestamp(fp);
+
+ switch (n->nlmsg_type) {
+ case RTM_NEWLINK:
+ case RTM_DELLINK:
+ if (prefix_banner)
+ fprintf(fp, "[LINK]");
+
+ return print_linkinfo(who, n, arg);
+
+ case RTM_NEWNEIGH:
+ case RTM_DELNEIGH:
+ if (prefix_banner)
+ fprintf(fp, "[NEIGH]");
+ return print_fdb(who, n, arg);
+
+ case 15:
+ return show_mark(fp, n);
+
+ default:
+ return 0;
+ }
+
+
+}
+
+int do_monitor(int argc, char **argv)
+{
+ char *file = NULL;
+ unsigned groups = ~RTMGRP_TC;
+ int llink=0;
+ int lneigh=0;
+
+ rtnl_close(&rth);
+
+ while (argc > 0) {
+ if (matches(*argv, "file") == 0) {
+ NEXT_ARG();
+ file = *argv;
+ } else if (matches(*argv, "link") == 0) {
+ llink=1;
+ groups = 0;
+ } else if (matches(*argv, "fdb") == 0) {
+ lneigh = 1;
+ groups = 0;
+ } else if (strcmp(*argv, "all") == 0) {
+ groups = ~RTMGRP_TC;
+ prefix_banner=1;
+ } else if (matches(*argv, "help") == 0) {
+ usage();
+ } else {
+ fprintf(stderr, "Argument \"%s\" is unknown, try \"br monitor help\".\n", *argv);
+ exit(-1);
+ }
+ argc--; argv++;
+ }
+
+ if (llink)
+ groups |= nl_mgrp(RTNLGRP_LINK);
+
+ if (lneigh) {
+ groups |= nl_mgrp(RTNLGRP_NEIGH);
+ }
+
+ if (file) {
+ FILE *fp;
+ fp = fopen(file, "r");
+ if (fp == NULL) {
+ perror("Cannot fopen");
+ exit(-1);
+ }
+ return rtnl_from_file(fp, accept_msg, stdout);
+ }
+
+ if (rtnl_open(&rth, groups) < 0)
+ exit(1);
+ ll_init_map(&rth);
+
+ if (rtnl_listen(&rth, accept_msg, stdout) < 0)
+ exit(2);
+
+ return 0;
+}
+
diff --git a/man/man8/br.8 b/man/man8/br.8
new file mode 100644
index 0000000..df2ad29
--- /dev/null
+++ b/man/man8/br.8
@@ -0,0 +1,177 @@
+.TH BR 8 "4 October 2011" "iproute2" "Linux"
+.SH NAME
+br \- show / manipulate bridge addresses and devices
+.SH SYNOPSIS
+
+.ad l
+.in +8
+.ti -8
+.B br
+.RI "[ " OPTIONS " ] " OBJECT " { " COMMAND " | "
+.BR help " }"
+.sp
+
+.ti -8
+.IR OBJECT " := { "
+.BR fdb " | " monitor " }"
+.sp
+
+.ti -8
+.IR OPTIONS " := { "
+\fB\-V\fR[\fIersion\fR] |
+\fB\-s\fR[\fItatistics\fR]
+
+.ti -8
+.BR "br fdb" " { " add " | " del " | " change " | " replace " } "
+.I LLADDR
+.B dev
+.IR DEV " { "
+.BR local " | " temp " }"
+
+.ti -8
+.BR "br fdb" " [ " show " ] [ "
+.B dev
+.IR DEV " ]"
+
+.ti -8
+.BR "br monitor" " [ " all " | " neigh " | " link " ]"
+
+.SH OPTIONS
+
+.TP
+.BR "\-V" , " -Version"
+print the version of the
+.B ip
+utility and exit.
+
+.TP
+.BR "\-s" , " \-stats", " \-statistics"
+output more information. If the option
+appears twice or more, the amount of information increases.
+As a rule, the information is statistics or some time values.
+
+
+.SH BR - COMMAND SYNTAX
+
+.SS
+.I OBJECT
+
+.TP
+.B fdb
+- Forwarding Database entry.
+
+.SS
+.I COMMAND
+
+Specifies the action to perform on the object.
+The set of possible actions depends on the object type.
+As a rule, it is possible to
+.BR "add" , " delete"
+and
+.B show
+(or
+.B list
+) objects, but some objects do not allow all of these operations
+or have some additional commands. The
+.B help
+command is available for all objects. It prints
+out a list of available commands and argument syntax conventions.
+.sp
+If no command is given, some default command is assumed.
+Usually it is
+.B list
+or, if the objects of this class cannot be listed,
+.BR "help" .
+
+.SH br fdb - forwarding database management
+
+.B fdb
+objects contain known ethernet addresses fona link.
+
+.P
+The corresponding commands display fdb entries, add new entries,
+and delete old ones.
+
+.SS br fdb add - add a new neighbour entry
+.SS br fdb change - change an existing entry
+.SS br fdb replace - add a new entry or change an existing one
+
+These commands create new neighbour records or update existing ones.
+
+.TP
+.BI "ADDRESS"
+the Ethernet MAC address.
+
+.TP
+.BI dev " NAME"
+the interface to which this address is associated.
+
+.TP
+.in +8
+.B local
+- the address is associated with a local interface on the system
+and is never forwarded.
+.sp
+
+.B temp
+- the address is a dynamic entry, and will be removed if not used.
+.sp
+
+.in -8
+
+.SS br fdb delete - delete a forwarding database entry
+This command removes an existing fdb entry.
+
+.PP
+The arguments are the same as with
+.BR "br fdb add" ,
+
+.SS br fdb show - list forwarding entries.
+
+This commands displays current forwarding table.
+
+.PP
+With the
+.B -statistics
+option, the command becomes verbose. It prints out the last updated
+and last used time for each entry.
+
+.SH br monitor - state monitoring
+
+The
+.B br
+utility can monitor the state of devices and addresses
+continuously. This option has a slightly different format.
+Namely, the
+.B monitor
+command is the first in the command line and then the object list follows:
+
+.BR "br monitor" " [ " all " |"
+.IR LISTofOBJECTS " ]"
+
+.I OBJECT-LIST
+is the list of object types that we want to monitor.
+It may contain
+.BR link ", and " fdb "."
+If no
+.B file
+argument is given,
+.B ip
+opens RTNETLINK, listens on it and dumps state changes in the format
+described in previous sections.
+
+.P
+If a file name is given, it does not listen on RTNETLINK,
+but opens the file containing RTNETLINK messages saved in binary format
+and dumps them. Such a history file can be generated with the
+
+.SH HISTORY
+.B br
+was written by Stephen Hemminger and uses kernel facilities added in Linux 3.0
+.SH SEE ALSO
+.BR ip (8)
+.br
+.RB "Please direct bugreports and patches to: " <netdev@vger.kernel.org>
+
+.SH AUTHOR
+Original Manpage by Stephen Hemminger
--
1.7.6.3
^ permalink raw reply related
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Jiri Pirko @ 2011-10-04 16:40 UTC (permalink / raw)
To: Eric Dumazet
Cc: netdev, davem, bhutchings, shemminger, fubar, andy, tgraf,
ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <1317741242.24651.12.camel@edumazet-HP-Compaq-6005-Pro-SFF-PC>
Tue, Oct 04, 2011 at 05:14:02PM CEST, eric.dumazet@gmail.com wrote:
<snip>
>> +
>> +static bool rr_transmit(struct team *team, struct sk_buff *skb)
>> +{
>> + struct team_port *port;
>> + int port_index;
>> +
>> + port_index = team->rr_priv.sent_packets++ % team->port_count;
>
>This is a bit expensive (change of sent_packets (cache line ping pong)
>and a modulo operation.
>
>Thanks to LLTX, we run here lockless.
>
>You could use a percpu pseudo random generator and a reciprocal divide.
>
>static u32 random_N(unsigned int N)
>{
> return reciprocal_divide(random32(), N);
>}
>...
> port_index = random_N(team->port_count);
Interesting, I will look at this more closely.
>> +
>> +static int team_port_list_init(struct team *team)
>> +{
>> + int i;
>> + struct hlist_head *hash;
>> +
>> + hash = kmalloc(sizeof(*hash) * TEAM_PORT_HASHENTRIES, GFP_KERNEL);
>> + if (hash != NULL) {
>> + for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
>> + INIT_HLIST_HEAD(&hash[i]);
>> + } else {
>> + return -ENOMEM;
>> + }
>
> if (!hash)
> return -ENOMEM;
>
> for (i = 0; i < TEAM_PORT_HASHENTRIES; i++)
> INIT_HLIST_HEAD(&hash[i]);
>
Yeah, nicer :) I stole the code without much thinking.
<snip>
>> +
>> +static void team_change_rx_flags(struct net_device *dev, int change)
>> +{
>> + struct team *team = netdev_priv(dev);
>> + struct team_port *port;
>> + int inc;
>> +
>> + rcu_read_lock();
>
>It seems there is a bit of confusion.
>
>Dont we hold rtnl at this point ? (no rcu is needed)
>
I'm glad you spotted this :) I was not absolutelly sure how to do this.
I'm aware rtnl is held. Anyway I try to not to depend on it in team
code. I use team->lock spinlock for writers and in this case the code
is reader -> rcu_read gets locked.
I think this approach is clean and makes sense don't it?
<snip>
>> +static struct rtnl_link_stats64 *team_get_stats(struct net_device *dev,
>> + struct rtnl_link_stats64 *stats)
>> +{
>> + struct team *team = netdev_priv(dev);
>> + struct rtnl_link_stats64 temp;
>> + struct team_port *port;
>> +
>> + memset(stats, 0, sizeof(*stats));
>> +
>> + rcu_read_lock();
>> + list_for_each_entry_rcu(port, &team->port_list, list) {
>> + const struct rtnl_link_stats64 *pstats;
>> +
>> + pstats = dev_get_stats(port->dev, &temp);
>> +
>> + stats->rx_packets += pstats->rx_packets;
>> + stats->rx_bytes += pstats->rx_bytes;
>> + stats->rx_errors += pstats->rx_errors;
>> + stats->rx_dropped += pstats->rx_dropped;
>> +
>> + stats->tx_packets += pstats->tx_packets;
>> + stats->tx_bytes += pstats->tx_bytes;
>> + stats->tx_errors += pstats->tx_errors;
>> + stats->tx_dropped += pstats->tx_dropped;
>> +
>> + stats->multicast += pstats->multicast;
>> + stats->collisions += pstats->collisions;
>> +
>> + stats->rx_length_errors += pstats->rx_length_errors;
>> + stats->rx_over_errors += pstats->rx_over_errors;
>> + stats->rx_crc_errors += pstats->rx_crc_errors;
>> + stats->rx_frame_errors += pstats->rx_frame_errors;
>> + stats->rx_fifo_errors += pstats->rx_fifo_errors;
>> + stats->rx_missed_errors += pstats->rx_missed_errors;
>> +
>> + stats->tx_aborted_errors += pstats->tx_aborted_errors;
>> + stats->tx_carrier_errors += pstats->tx_carrier_errors;
>> + stats->tx_fifo_errors += pstats->tx_fifo_errors;
>> + stats->tx_heartbeat_errors += pstats->tx_heartbeat_errors;
>> + stats->tx_window_errors += pstats->tx_window_errors;
>> + }
>> + rcu_read_unlock();
>> +
>
>One thing that bothers me is stats are wrong when we add or remove a
>slave.
>
>We really should have a per master structure to take into account
>offsets when we add/remove a slave, to keep monotonic master stats.
Please see my answer in previous reply to Flavio.
<snip>
Eric, thanks for review.
Jirka
^ permalink raw reply
* Re: [RFC] iproute2: add br command
From: Ben Hutchings @ 2011-10-04 16:58 UTC (permalink / raw)
To: Stephen Hemminger; +Cc: Kevin Wilson, netdev
In-Reply-To: <20111004093413.2f6bbd67@nehalam.linuxnetplumber.net>
On Tue, 2011-10-04 at 09:34 -0700, Stephen Hemminger wrote:
> This adds a new 'br' command which is the bridging equivalent of
> the ip command. More of a demo of how to use netlink and bridging
> at this point.
[...]
This command name is already in use:
http://packages.debian.org/sid/bottlerocket
Ben.
--
Ben Hutchings, Staff Engineer, Solarflare
Not speaking for my employer; that's the marketing department's job.
They asked us to note that Solarflare product names are trademarked.
^ permalink raw reply
* Re: [RFC] iproute2: add br command
From: Andi Kleen @ 2011-10-04 16:58 UTC (permalink / raw)
To: Stephen Hemminger; +Cc: Kevin Wilson, netdev
In-Reply-To: <20111004093413.2f6bbd67@nehalam.linuxnetplumber.net>
Stephen Hemminger <shemminger@vyatta.com> writes:
> This adds a new 'br' command which is the bridging equivalent of
> the ip command. More of a demo of how to use netlink and bridging
> at this point.
Please name it "bridge", not "br"
-Andi
--
ak@linux.intel.com -- Speaking for myself only
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: Flavio Leitner @ 2011-10-04 17:27 UTC (permalink / raw)
To: Jiri Pirko
Cc: netdev, davem, eric.dumazet, bhutchings, shemminger, fubar, andy,
tgraf, ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <20111004161241.GB2011@minipsycho>
On Tue, 4 Oct 2011 18:12:41 +0200
Jiri Pirko <jpirko@redhat.com> wrote:
> Tue, Oct 04, 2011 at 04:53:44PM CEST, fbl@redhat.com wrote:
>
> <snip>
>
> >> +
> >> +struct team_mode_ops {
> >> + int (*init)(struct team *team);
> >> + void (*exit)(struct team *team);
> >> + rx_handler_result_t (*receive)(struct team *team,
> >> + struct team_port *port,
> >> + struct sk_buff *skb);
> >
> >nitpick:
> >As it doesn't have any other type of results, I would suggest
> >to rename rx_handler_result_t be to shorter, i.e. rx_result_t.
>
> Well that type is defined already in include/linux/netdevice.h
> I like the original name better because it has "handler" word in it
> (which imo reduces possible confusion)
Alright, I missed that somehow. Sorry.
> >
> >> + bool (*transmit)(struct team *team, struct sk_buff *skb);
> >> + int (*port_enter)(struct team *team, struct team_port
> >> *port);
> >
> >Perhaps instead of 'port_enter', use 'port_join'.
>
> Might be more appropriate, not sure (my eng skills recognize these two
> as very similar in this case)
Yeah, I am just trying to find the term that is most used for this. We
used attach/detach terms in bonding driver and they seem appropriated
to me.
> >> + int (*getter)(struct team *team, void *arg);
> >> + int (*setter)(struct team *team, void *arg);
> >
> >What means getter and setter?
>
> Option getter and setter. Function used to set and get the option.
sorry, I meant the last part of it - "ter".
getoption and setoption would make more sense to me.
<snipped>
> >> + union {
> >> + char priv_first_byte;
> >> + struct ab_priv ab_priv;
> >> + struct rr_priv rr_priv;
> >> + };
> >
> >I think the union should be a pointer or work in the same
> >way as netdev_priv() does.
>
> The reason I did this this way is saving one pointer dereference in
> hot paths. In netdev priv the memory for priv data is allcated along
> with netdev struct. In this case this is not possible because mode
> can be changed during team device lifetime (and team priv is netdev
> priv).
>
but then any external/new team mode will require patching the
team driver.
> <snip>
>
> >> +
> >> +static bool rr_transmit(struct team *team, struct sk_buff *skb)
> >> +{
> >> + struct team_port *port;
> >> + int port_index;
> >> +
> >> + port_index = team->rr_priv.sent_packets++ %
> >> team->port_count;
> >> + port = team_get_port_by_index_rcu(team, port_index);
> >> + port = __get_first_port_up(team, port);
> >
> >Well, __get_first_port_up() will frequently just do:
> >
> > if (port->linkup)
> > return port;
> >
> >so, as it is in the hot TX path, can this be modified to be something
> >like below to avoid one function call?
> >
> > port = team_get_port_by_index_rcu(team, port_index);
> > if (unlikely(port->linkup))
> > port = __get_first_port_up(team, port);
>
> Hmm, I don't think this is correct place to use "likely". Imagine you
> have 2 ports and one of them is down all the team lifetime. You would
> be hitting wrong branch always which will cause performance penalty.
Right, my point was to avoid the extra function call.
I agree with you that using "likely" there might not be a good idea.
> >> +
> >> +static const struct team_mode ab_mode = {
> >> + .kind = "activebackup",
> >> + .ops = &ab_mode_ops,
> >> +};
> >> +
> >
> >I would suggest to move each of the ab and rr specifics
> >to their own module. The idea is to have the team module
> >as a generic module as possible and every mode on its module.
> >Not sure what your plans are for this.
>
> Well I was thinking about this for sure. One reason to have this in
> one place is the mode_priv union you were referring to.
> Other reason is that mode parts should be very easy and short. Also
> their number should be limited (~4).
>
Are you sure? :)
> <snip>
> >> +
> >> +static struct rtnl_link_stats64 *team_get_stats(struct net_device
> >> *dev,
> >> + struct
> >> rtnl_link_stats64 *stats) +{
> >> + struct team *team = netdev_priv(dev);
> >> + struct rtnl_link_stats64 temp;
> >> + struct team_port *port;
> >> +
> >> + memset(stats, 0, sizeof(*stats));
> >> +
> >> + rcu_read_lock();
> >> + list_for_each_entry_rcu(port, &team->port_list, list) {
> >> + const struct rtnl_link_stats64 *pstats;
> >> +
> >> + pstats = dev_get_stats(port->dev, &temp);
> >> +
> >> + stats->rx_packets += pstats->rx_packets;
> >> + stats->rx_bytes += pstats->rx_bytes;
> >> + stats->rx_errors += pstats->rx_errors;
> >> + stats->rx_dropped += pstats->rx_dropped;
> >> +
> >> + stats->tx_packets += pstats->tx_packets;
> >> + stats->tx_bytes += pstats->tx_bytes;
> >> + stats->tx_errors += pstats->tx_errors;
> >> + stats->tx_dropped += pstats->tx_dropped;
> >> +
> >> + stats->multicast += pstats->multicast;
> >> + stats->collisions += pstats->collisions;
> >> +
> >> + stats->rx_length_errors +=
> >> pstats->rx_length_errors;
> >> + stats->rx_over_errors += pstats->rx_over_errors;
> >> + stats->rx_crc_errors += pstats->rx_crc_errors;
> >> + stats->rx_frame_errors += pstats->rx_frame_errors;
> >> + stats->rx_fifo_errors += pstats->rx_fifo_errors;
> >> + stats->rx_missed_errors +=
> >> pstats->rx_missed_errors; +
> >> + stats->tx_aborted_errors +=
> >> pstats->tx_aborted_errors;
> >> + stats->tx_carrier_errors +=
> >> pstats->tx_carrier_errors;
> >> + stats->tx_fifo_errors += pstats->tx_fifo_errors;
> >> + stats->tx_heartbeat_errors +=
> >> pstats->tx_heartbeat_errors;
> >> + stats->tx_window_errors +=
> >> pstats->tx_window_errors;
> >> + }
> >> + rcu_read_unlock();
> >> +
> >> + return stats;
> >> +}
> >
> >I don't think computing stats like that is useful. We can do
> >that in userlevel with ethtool -S on each slave and sum all them.
> >I think it would be better to have the errors computed based on
> >events that happens inside of Team driver, so we can really see if
> >something is happening inside of the Team driver or on its slaves.
>
> I was thinking about this as well. I did this in same ways it's done
> in bonding driver. One of reasons were that I can't count dropped
> packets in team_handle_frame because I do not call netif_rx there and
> only return RX_HANDLER_ANOTHER to "reinject" (saving one function
> call).
>
My concern is that while debugging some issue, I cannot tell if Team
driver dropped packets or not. Actually, there are some places in the
patch dropping skbs without any sort of notification. So, I suggested
to compute the stats leaving the slave stats out of it but now I have
realized that the admin and monitoring tools will expect to find the
interface stats to be a sum of all its slaves.
I think the solution would be having a master stats set apart to keep
track of internal driver work and then sum the slaves stats like the
patch does right now. By doing so, I can grab ethtool -S of all slaves,
sum them, and check if Team dropped or not.
>
> <snip>
>
> >> +
> >> +static int team_add_slave(struct net_device *dev, struct
> >> net_device *port_dev) +{
> >> + struct team *team = netdev_priv(dev);
> >> + int err;
> >> +
> >> + spin_lock(&team->lock);
> >> + err = team_port_add(team, port_dev);
> >> + spin_unlock(&team->lock);
> >> + return err;
> >> +}
> >
> >I am not seeing any difference between slave and port, so why not
> >stick with just one?
>
> I like "port" better. It's more accurate.
Definitely.
> team_add/del_slave has its
> name only because ndo is named the same.
Hm, makes sense then.
Although I am still digesting the patch, nice work Jiri!
thanks,
fbl
^ permalink raw reply
* [GIT] Networking
From: David Miller @ 2011-10-04 17:28 UTC (permalink / raw)
To: torvalds; +Cc: akpm, netdev, linux-kernel
1) ipv6 accepted sockets forget to clear out ipv6_ac_list and ipv6_fl_list
causing crashes later. Fix from Zheng Yan.
2) RDSRDMA refcounting is busted, resulting in leaks and crashes on module
unload. Fix from Jonathan Lallinger.
3) Because of bugs in error code propagation, ibmveth gets OOPS when
request_irq() fails. Fix from Brian King.
4) Due to missing state checks, workqueues can get queued up after a bond
is shutdown, crashing us on unload. Fix from Andy Gospodarek.
5) Fix off-by-one corrupter in CAN BCM, from Oliver Hartkopp.
6) When link is brought down, pch_gbe can hang in NAPI poll or disable
HW interrupts forever. Fix from Toshiharu Okada.
7) When socket state overflow changes were added, this broke AF_PACKET
statistic reporting in the non-ring case. Fix from Willem de Bruijn.
8) PTP classifier incorrectly interprets general messages as event messages.
Fix from Richard Cochran.
9) XEN netback driver was broken by the commit that converted it to
hw_features. TX was never restarted correctly after a VM restore/migrate.
Fix from David Vrabel.
10) EEH recovery doesn't work in cxgb4 driver on PPC, need to set ->needs_freset.
Fix from Divy Le Ray.
Please pull, thanks a lot!
The following changes since commit 9b13776977d45505469edc6decc93e9e3799afe2:
Merge branch 'for-linus' of git://git.infradead.org/users/sameo/mfd-2.6 (2011-10-02 19:23:44 -0700)
are available in the git repository at:
git://github.com/davem330/net.git master
Andy Gospodarek (1):
bonding: properly stop queuing work when requested
Brian King (1):
ibmveth: Fix oops on request_irq failure
David Vrabel (1):
net: xen-netback: correctly restart Tx after a VM restore/migrate
Divy Le Ray (1):
cxgb4: Fix EEH on IBM P7IOC
Ian Campbell (1):
MAINTAINERS: tehuti: Alexander Indenbaum's address bounces
Jonathan Lallinger (1):
RDSRDMA: Fix cleanup of rds_iw_mr_pool
Oliver Hartkopp (2):
can bcm: fix tx_setup off-by-one errors
can bcm: fix incomplete tx_setup fix
Richard Cochran (2):
ptp: fix L2 event message recognition
dp83640: reduce driver noise
Roy.Li (1):
net: Documentation: Fix type of variables
Toshiharu Okada (2):
pch_gbe: Fixed the issue on which PC was frozen when link was downed.
pch_gbe: Fixed the issue on which a network freezes
Willem de Bruijn (1):
make PACKET_STATISTICS getsockopt report consistently between ring and non-ring
Yan, Zheng (1):
ipv6: nullify ipv6_ac_list and ipv6_fl_list when creating new socket
Documentation/networking/ip-sysctl.txt | 4 +-
MAINTAINERS | 1 -
drivers/net/bonding/bond_3ad.c | 3 +-
drivers/net/bonding/bond_alb.c | 3 +-
drivers/net/bonding/bond_main.c | 13 ++++---
drivers/net/cxgb4/cxgb4_main.c | 3 ++
drivers/net/ibmveth.c | 4 +-
drivers/net/pch_gbe/pch_gbe_main.c | 56 +++++++++++++++----------------
drivers/net/phy/dp83640.c | 4 +-
drivers/net/xen-netback/interface.c | 4 +-
include/linux/ptp_classify.h | 13 ++++++--
net/can/bcm.c | 53 +++++++++++++----------------
net/ipv6/tcp_ipv6.c | 3 ++
net/packet/af_packet.c | 5 ++-
net/rds/iw_rdma.c | 13 +++++--
15 files changed, 100 insertions(+), 82 deletions(-)
^ permalink raw reply
* Re: [PATCH] net-proc: expose the tos values in /proc/net/[tcp|udp]
From: MuraliRaja Muniraju @ 2011-10-04 17:38 UTC (permalink / raw)
To: David Miller; +Cc: kuznet, jmorris, yoshfuji, kaber, netdev, linux-kernel
In-Reply-To: <20110929.153259.169108824599752228.davem@davemloft.net>
I shall make the changes by exposing the tos values via the
netlink as suggested. I had a doubt is I have to modify the
inet_diag_sockid or export it via a new option. I am considering
that adding into inet_diag_sockid is better because the latter is a
bit of a over kill for a single value to be exposed and it also seems
to be logical fit.
Can you let me know your thoughts on this.
Thanks,
Murali
On Thu, Sep 29, 2011 at 12:32 PM, David Miller <davem@davemloft.net> wrote:
> From: Muraliraja Muniraju <muralira@google.com>
> Date: Thu, 29 Sep 2011 12:22:42 -0700
>
>> From: Murali Raja <muralira@google.com>
>>
>> This patch exports the tos values from the inet_sock struct
>> for tcp and udp into the /proc/net/tcp or /proc/net/udp respectively.
>> This will not pickup per packet tos changes but it will address most
>> of the cases. This is mainly useful as it would decrease reliance on
>> tcpdump and also people without root access will be able to read
>> the values.
>>
>> Signed-off-by: Murali Raja <muralira@google.com>
>
> You cannot change the layout of these files, they are parsed by userland
> problems and therefore have a fixed API.
>
> Netlink based socket dumping provides a proper, backwards compatible,
> way to extend what is reported, so please consider adding your changes
> there.
>
--
Thanks,
Murali
^ permalink raw reply
* Re: [patch net-next-2.6] net: introduce ethernet teaming device
From: David Miller @ 2011-10-04 17:51 UTC (permalink / raw)
To: jpirko
Cc: netdev, eric.dumazet, bhutchings, shemminger, fubar, andy, tgraf,
ebiederm, mirqus, kaber, greearb, jesse
In-Reply-To: <1317737703-19457-1-git-send-email-jpirko@redhat.com>
From: Jiri Pirko <jpirko@redhat.com>
Date: Tue, 4 Oct 2011 16:15:03 +0200
> This patch introduces new network device called team. It supposes to be
> very fast, simple, userspace-driven alternative to existing bonding
> driver.
>
> Userspace library called libteam with couple of demo apps is available
> here:
> https://github.com/jpirko/libteam
> Note it's still in its dipers atm.
>
> team<->libteam use generic netlink for communication. That and rtnl
> suppose to be the only way to configure team device, no sysfs etc.
>
> In near future python binding for libteam will be introduced. Also
> daemon providing arpmon/miimon active-backup functionality will
> be introduced. All what's necessary is already implemented in kernel team
> driver.
>
> Signed-off-by: Jiri Pirko <jpirko@redhat.com>
I just want to say that, besides the implementation detail feedback you've
received thus far, I really like this stuff. Please keep working on it!
^ permalink raw reply
* [PATCH 0/4] SUNRPC: rcbind clients virtualization
From: Stanislav Kinsbursky @ 2011-10-04 17:58 UTC (permalink / raw)
To: Trond.Myklebust
Cc: linux-nfs, xemul, neilb, netdev, linux-kernel, bfields, davem,
devel
This patch-set virtualizes rpcbind clients per network namespace context. IOW,
each network namespace will have its own pair of rpcbind clients (if the would
be created by request).
Note:
1) this patch-set depends on "SUNRPC: make rpcbind clients allocated and
destroyed dynamically" patch-set which has been send earlier.
2) init_net pointer is still used instead of current->nsproxy->net_ns,
because I'm not sure yet about how to virtualize services.
I.e. NFS callback services will be per netns. NFSd service will be per netns
too from my pow. But Lockd can be per netns or one for all.
And also we have NFSd file system, which is not virtualized yet.
The following series consists of:
---
Stanislav Kinsbursky (4):
SUNRPC: rpcbind clients internals virtualization
SUNRPC: use virtualized rpcbind internals instead of static ones
SUNRPC: optimize net_ns dereferencing in rpcbind creation calls
SUNRPC: optimize net_ns dereferencing in rpcbind registering calls
net/sunrpc/netns.h | 5 ++
net/sunrpc/rpcb_clnt.c | 103 ++++++++++++++++++++++++++----------------------
2 files changed, 61 insertions(+), 47 deletions(-)
--
Signature
^ permalink raw reply
* [PATCH 1/4] SUNRPC: rpcbind clients internals virtualization
From: Stanislav Kinsbursky @ 2011-10-04 17:58 UTC (permalink / raw)
To: Trond.Myklebust
Cc: linux-nfs, xemul, neilb, netdev, linux-kernel, bfields, davem,
devel
In-Reply-To: <20111004165637.6638.57399.stgit@localhost6.localdomain6>
This patch moves static rpcbind internals to sunrpc part of network namespace
context. This will allow to create rcpbind clients per network namespace.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
---
net/sunrpc/netns.h | 5 +++++
1 files changed, 5 insertions(+), 0 deletions(-)
diff --git a/net/sunrpc/netns.h b/net/sunrpc/netns.h
index d013bf2..83eede3 100644
--- a/net/sunrpc/netns.h
+++ b/net/sunrpc/netns.h
@@ -9,6 +9,11 @@ struct cache_detail;
struct sunrpc_net {
struct proc_dir_entry *proc_net_rpc;
struct cache_detail *ip_map_cache;
+
+ struct rpc_clnt *rpcb_local_clnt;
+ struct rpc_clnt *rpcb_local_clnt4;
+ spinlock_t rpcb_clnt_lock;
+ unsigned int rpcb_users;
};
extern int sunrpc_net_id;
^ permalink raw reply related
* [PATCH 2/4] SUNRPC: use virtualized rpcbind internals instead of static ones
From: Stanislav Kinsbursky @ 2011-10-04 17:59 UTC (permalink / raw)
To: Trond.Myklebust
Cc: linux-nfs, xemul, neilb, netdev, linux-kernel, bfields, davem,
devel
In-Reply-To: <20111004165637.6638.57399.stgit@localhost6.localdomain6>
This patch makes rpcbind logic works in network namespace context. IOW each
network namespace will have it's own unique rpcbind internals (clients and
friends) which is required for registering svc services per network namespace.
Signed-off-by: Stanislav Kinsbursky <skinsbursky@parallels.com>
---
net/sunrpc/rpcb_clnt.c | 64 ++++++++++++++++++++++++++----------------------
1 files changed, 35 insertions(+), 29 deletions(-)
diff --git a/net/sunrpc/rpcb_clnt.c b/net/sunrpc/rpcb_clnt.c
index c2054ae..18eba8e 100644
--- a/net/sunrpc/rpcb_clnt.c
+++ b/net/sunrpc/rpcb_clnt.c
@@ -23,12 +23,15 @@
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/slab.h>
+#include <linux/nsproxy.h>
#include <net/ipv6.h>
#include <linux/sunrpc/clnt.h>
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/xprtsock.h>
+#include "netns.h"
+
#ifdef RPC_DEBUG
# define RPCDBG_FACILITY RPCDBG_BIND
#endif
@@ -111,12 +114,6 @@ static void rpcb_getport_done(struct rpc_task *, void *);
static void rpcb_map_release(void *data);
static struct rpc_program rpcb_program;
-static struct rpc_clnt * rpcb_local_clnt;
-static struct rpc_clnt * rpcb_local_clnt4;
-
-DEFINE_SPINLOCK(rpcb_clnt_lock);
-unsigned int rpcb_users;
-
struct rpcbind_args {
struct rpc_xprt * r_xprt;
@@ -167,29 +164,31 @@ static void rpcb_map_release(void *data)
static int rpcb_get_local(void)
{
int cnt;
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
- spin_lock(&rpcb_clnt_lock);
- if (rpcb_users)
- rpcb_users++;
- cnt = rpcb_users;
- spin_unlock(&rpcb_clnt_lock);
+ spin_lock(&sn->rpcb_clnt_lock);
+ if (sn->rpcb_users)
+ sn->rpcb_users++;
+ cnt = sn->rpcb_users;
+ spin_unlock(&sn->rpcb_clnt_lock);
return cnt;
}
void rpcb_put_local(void)
{
- struct rpc_clnt *clnt = rpcb_local_clnt;
- struct rpc_clnt *clnt4 = rpcb_local_clnt4;
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
+ struct rpc_clnt *clnt = sn->rpcb_local_clnt;
+ struct rpc_clnt *clnt4 = sn->rpcb_local_clnt4;
int shutdown;
- spin_lock(&rpcb_clnt_lock);
- if (--rpcb_users == 0) {
- rpcb_local_clnt = NULL;
- rpcb_local_clnt4 = NULL;
+ spin_lock(&sn->rpcb_clnt_lock);
+ if (--sn->rpcb_users == 0) {
+ sn->rpcb_local_clnt = NULL;
+ sn->rpcb_local_clnt4 = NULL;
}
- shutdown = !rpcb_users;
- spin_unlock(&rpcb_clnt_lock);
+ shutdown = !sn->rpcb_users;
+ spin_unlock(&sn->rpcb_clnt_lock);
if (shutdown) {
/*
@@ -205,14 +204,16 @@ void rpcb_put_local(void)
static void rpcb_set_local(struct rpc_clnt *clnt, struct rpc_clnt *clnt4)
{
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
+
/* Protected by rpcb_create_local_mutex */
- rpcb_local_clnt = clnt;
- rpcb_local_clnt4 = clnt4;
+ sn->rpcb_local_clnt = clnt;
+ sn->rpcb_local_clnt4 = clnt4;
smp_wmb();
- rpcb_users = 1;
+ sn->rpcb_users = 1;
dprintk("RPC: created new rpcb local clients (rpcb_local_clnt: "
- "%p, rpcb_local_clnt4: %p)\n", rpcb_local_clnt,
- rpcb_local_clnt4);
+ "%p, rpcb_local_clnt4: %p)\n", sn->rpcb_local_clnt,
+ sn->rpcb_local_clnt4);
}
/*
@@ -432,6 +433,7 @@ int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port)
struct rpc_message msg = {
.rpc_argp = &map,
};
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
dprintk("RPC: %sregistering (%u, %u, %d, %u) with local "
"rpcbind\n", (port ? "" : "un"),
@@ -441,7 +443,7 @@ int rpcb_register(u32 prog, u32 vers, int prot, unsigned short port)
if (port)
msg.rpc_proc = &rpcb_procedures2[RPCBPROC_SET];
- return rpcb_register_call(rpcb_local_clnt, &msg);
+ return rpcb_register_call(sn->rpcb_local_clnt, &msg);
}
/*
@@ -454,6 +456,7 @@ static int rpcb_register_inet4(const struct sockaddr *sap,
struct rpcbind_args *map = msg->rpc_argp;
unsigned short port = ntohs(sin->sin_port);
int result;
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
map->r_addr = rpc_sockaddr2uaddr(sap);
@@ -466,7 +469,7 @@ static int rpcb_register_inet4(const struct sockaddr *sap,
if (port)
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
- result = rpcb_register_call(rpcb_local_clnt4, msg);
+ result = rpcb_register_call(sn->rpcb_local_clnt4, msg);
kfree(map->r_addr);
return result;
}
@@ -481,6 +484,7 @@ static int rpcb_register_inet6(const struct sockaddr *sap,
struct rpcbind_args *map = msg->rpc_argp;
unsigned short port = ntohs(sin6->sin6_port);
int result;
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
map->r_addr = rpc_sockaddr2uaddr(sap);
@@ -493,7 +497,7 @@ static int rpcb_register_inet6(const struct sockaddr *sap,
if (port)
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_SET];
- result = rpcb_register_call(rpcb_local_clnt4, msg);
+ result = rpcb_register_call(sn->rpcb_local_clnt4, msg);
kfree(map->r_addr);
return result;
}
@@ -501,6 +505,7 @@ static int rpcb_register_inet6(const struct sockaddr *sap,
static int rpcb_unregister_all_protofamilies(struct rpc_message *msg)
{
struct rpcbind_args *map = msg->rpc_argp;
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
dprintk("RPC: unregistering [%u, %u, '%s'] with "
"local rpcbind\n",
@@ -509,7 +514,7 @@ static int rpcb_unregister_all_protofamilies(struct rpc_message *msg)
map->r_addr = "";
msg->rpc_proc = &rpcb_procedures4[RPCBPROC_UNSET];
- return rpcb_register_call(rpcb_local_clnt4, msg);
+ return rpcb_register_call(sn->rpcb_local_clnt4, msg);
}
/**
@@ -567,8 +572,9 @@ int rpcb_v4_register(const u32 program, const u32 version,
struct rpc_message msg = {
.rpc_argp = &map,
};
+ struct sunrpc_net *sn = net_generic(&init_net, sunrpc_net_id);
- if (rpcb_local_clnt4 == NULL)
+ if (sn->rpcb_local_clnt4 == NULL)
return -EPROTONOSUPPORT;
if (address == NULL)
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox