* 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
* [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-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
* 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: [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: [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
* [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: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
* 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: 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
* 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: [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: 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] 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
* [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
* [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] 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
* 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 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
* [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 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 5/8] per-netns ipv4 sysctl_tcp_mem
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 allows each namespace to independently set up
its levels for tcp memory pressure thresholds. This patch
alone does not buy much: we need to make this values
per group of process somehow. This is achieved in the
patches that follows in this patchset.
Signed-off-by: Glauber Costa <glommer@parallels.com>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
CC: David S. Miller <davem@davemloft.net>
CC: Eric W. Biederman <ebiederm@xmission.com>
---
include/net/netns/ipv4.h | 1 +
include/net/tcp.h | 1 -
mm/memcontrol.c | 8 ++++--
net/ipv4/sysctl_net_ipv4.c | 51 +++++++++++++++++++++++++++++++++++++------
net/ipv4/tcp.c | 13 ++--------
5 files changed, 53 insertions(+), 21 deletions(-)
diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h
index d786b4f..bbd023a 100644
--- a/include/net/netns/ipv4.h
+++ b/include/net/netns/ipv4.h
@@ -55,6 +55,7 @@ struct netns_ipv4 {
int current_rt_cache_rebuild_count;
unsigned int sysctl_ping_group_range[2];
+ long sysctl_tcp_mem[3];
atomic_t rt_genid;
atomic_t dev_addr_genid;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 7ae7b4b..04fedf7 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -231,7 +231,6 @@ extern int sysctl_tcp_fack;
extern int sysctl_tcp_reordering;
extern int sysctl_tcp_ecn;
extern int sysctl_tcp_dsack;
-extern long sysctl_tcp_mem[3];
extern int sysctl_tcp_wmem[3];
extern int sysctl_tcp_rmem[3];
extern int sysctl_tcp_app_win;
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 9598e3e..39e575e 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -309,6 +309,7 @@ static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
#ifdef CONFIG_INET
#include <net/sock.h>
#include <net/ip.h>
+#include <linux/nsproxy.h>
void sock_update_memcg(struct sock *sk)
{
@@ -434,14 +435,15 @@ int tcp_init_cgroup(struct proto *prot, struct cgroup *cgrp,
struct cgroup_subsys *ss)
{
struct mem_cgroup *cg = mem_cgroup_from_cont(cgrp);
+ struct net *net = current->nsproxy->net_ns;
/*
* We need to initialize it at populate, not create time.
* This is because net sysctl tables are not up until much
* later
*/
- cg->tcp.tcp_prot_mem[0] = sysctl_tcp_mem[0];
- cg->tcp.tcp_prot_mem[1] = sysctl_tcp_mem[1];
- cg->tcp.tcp_prot_mem[2] = sysctl_tcp_mem[2];
+ cg->tcp.tcp_prot_mem[0] = net->ipv4.sysctl_tcp_mem[0];
+ cg->tcp.tcp_prot_mem[1] = net->ipv4.sysctl_tcp_mem[1];
+ cg->tcp.tcp_prot_mem[2] = net->ipv4.sysctl_tcp_mem[2];
return 0;
}
diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c
index 69fd720..bbd67ab 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/swap.h>
#include <net/snmp.h>
#include <net/icmp.h>
#include <net/ip.h>
@@ -174,6 +175,36 @@ static int proc_allowed_congestion_control(ctl_table *ctl,
return ret;
}
+static int ipv4_tcp_mem(ctl_table *ctl, int write,
+ void __user *buffer, size_t *lenp,
+ loff_t *ppos)
+{
+ int ret;
+ unsigned long vec[3];
+ struct net *net = current->nsproxy->net_ns;
+
+ ctl_table tmp = {
+ .data = &vec,
+ .maxlen = sizeof(vec),
+ .mode = ctl->mode,
+ };
+
+ if (!write) {
+ ctl->data = &net->ipv4.sysctl_tcp_mem;
+ return proc_doulongvec_minmax(ctl, write, buffer, lenp, ppos);
+ }
+
+ ret = proc_doulongvec_minmax(&tmp, write, buffer, lenp, ppos);
+ if (ret)
+ return ret;
+
+ net->ipv4.sysctl_tcp_mem[0] = vec[0];
+ net->ipv4.sysctl_tcp_mem[1] = vec[1];
+ net->ipv4.sysctl_tcp_mem[2] = vec[2];
+
+ return 0;
+}
+
static struct ctl_table ipv4_table[] = {
{
.procname = "tcp_timestamps",
@@ -433,13 +464,6 @@ static struct ctl_table ipv4_table[] = {
.proc_handler = proc_dointvec
},
{
- .procname = "tcp_mem",
- .data = &sysctl_tcp_mem,
- .maxlen = sizeof(sysctl_tcp_mem),
- .mode = 0644,
- .proc_handler = proc_doulongvec_minmax
- },
- {
.procname = "tcp_wmem",
.data = &sysctl_tcp_wmem,
.maxlen = sizeof(sysctl_tcp_wmem),
@@ -721,6 +745,12 @@ static struct ctl_table ipv4_net_table[] = {
.mode = 0644,
.proc_handler = ipv4_ping_group_range,
},
+ {
+ .procname = "tcp_mem",
+ .maxlen = sizeof(init_net.ipv4.sysctl_tcp_mem),
+ .mode = 0644,
+ .proc_handler = ipv4_tcp_mem,
+ },
{ }
};
@@ -734,6 +764,7 @@ EXPORT_SYMBOL_GPL(net_ipv4_ctl_path);
static __net_init int ipv4_sysctl_init_net(struct net *net)
{
struct ctl_table *table;
+ unsigned long limit;
table = ipv4_net_table;
if (!net_eq(net, &init_net)) {
@@ -769,6 +800,12 @@ static __net_init int ipv4_sysctl_init_net(struct net *net)
net->ipv4.sysctl_rt_cache_rebuild_count = 4;
+ limit = nr_free_buffer_pages() / 8;
+ limit = max(limit, 128UL);
+ net->ipv4.sysctl_tcp_mem[0] = limit / 4 * 3;
+ net->ipv4.sysctl_tcp_mem[1] = limit;
+ net->ipv4.sysctl_tcp_mem[2] = net->ipv4.sysctl_tcp_mem[0] * 2;
+
net->ipv4.ipv4_hdr = register_net_sysctl_table(net,
net_ipv4_ctl_path, table);
if (net->ipv4.ipv4_hdr == NULL)
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index bbd3989..cd386df 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -282,11 +282,9 @@ int sysctl_tcp_fin_timeout __read_mostly = TCP_FIN_TIMEOUT;
struct percpu_counter tcp_orphan_count;
EXPORT_SYMBOL_GPL(tcp_orphan_count);
-long sysctl_tcp_mem[3] __read_mostly;
int sysctl_tcp_wmem[3] __read_mostly;
int sysctl_tcp_rmem[3] __read_mostly;
-EXPORT_SYMBOL(sysctl_tcp_mem);
EXPORT_SYMBOL(sysctl_tcp_rmem);
EXPORT_SYMBOL(sysctl_tcp_wmem);
@@ -333,7 +331,7 @@ EXPORT_SYMBOL(tcp_enter_memory_pressure_nocg);
long *tcp_sysctl_mem_nocg(struct mem_cgroup *memcg)
{
- return sysctl_tcp_mem;
+ return init_net.ipv4.sysctl_tcp_mem;
}
EXPORT_SYMBOL(tcp_sysctl_mem_nocg);
@@ -3296,14 +3294,9 @@ void __init tcp_init(void)
sysctl_tcp_max_orphans = cnt / 2;
sysctl_max_syn_backlog = max(128, cnt / 256);
- limit = nr_free_buffer_pages() / 8;
- limit = max(limit, 128UL);
- sysctl_tcp_mem[0] = limit / 4 * 3;
- sysctl_tcp_mem[1] = limit;
- sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;
-
/* Set per-socket limits to no more than 1/128 the pressure threshold */
- limit = ((unsigned long)sysctl_tcp_mem[1]) << (PAGE_SHIFT - 7);
+ limit = ((unsigned long)init_net.ipv4.sysctl_tcp_mem[1])
+ << (PAGE_SHIFT - 7);
max_share = min(4UL*1024*1024, limit);
sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
--
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 4/8] per-cgroup tcp buffers control
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>
With all the infrastructure in place, this patch implements
per-cgroup control for tcp memory pressure handling.
Signed-off-by: Glauber Costa <glommer@parallels.com>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtisu.com>
CC: David S. Miller <davem@davemloft.net>
CC: Eric W. Biederman <ebiederm@xmission.com>
---
include/linux/memcontrol.h | 4 ++
include/net/sock.h | 15 ++++++-
include/net/tcp.h | 15 +++++++
mm/memcontrol.c | 97 ++++++++++++++++++++++++++++++++++++++++++++
net/core/sock.c | 39 ++++++++++++++++-
net/ipv4/tcp.c | 44 +++++++++----------
net/ipv4/tcp_ipv4.c | 12 +++++-
net/ipv6/tcp_ipv6.c | 10 ++++-
8 files changed, 207 insertions(+), 29 deletions(-)
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 2012060..50af61d 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -391,6 +391,10 @@ void memcg_sock_mem_alloc(struct mem_cgroup *memcg, struct proto *prot,
void memcg_sock_mem_free(struct mem_cgroup *memcg, struct proto *prot, int amt);
void memcg_sockets_allocated_dec(struct mem_cgroup *memcg, struct proto *prot);
void memcg_sockets_allocated_inc(struct mem_cgroup *memcg, struct proto *prot);
+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);
#else
/* memcontrol includes sockets.h, that includes memcontrol.h ... */
static inline void memcg_sock_mem_alloc(struct mem_cgroup *memcg,
diff --git a/include/net/sock.h b/include/net/sock.h
index c6983cf..0625d79 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -64,6 +64,8 @@
#include <net/dst.h>
#include <net/checksum.h>
+int sockets_populate(struct cgroup *cgrp, struct cgroup_subsys *ss);
+void sockets_destroy(struct cgroup *cgrp, struct cgroup_subsys *ss);
/*
* This structure really needs to be cleaned up.
* Most of it is for TCP, and not used by any of
@@ -814,7 +816,18 @@ struct proto {
int *(*memory_pressure)(struct mem_cgroup *memcg);
/* Pointer to the per-cgroup version of the the sysctl_mem field */
long *(*prot_mem)(struct mem_cgroup *memcg);
-
+ /*
+ * cgroup specific init/deinit functions. Called once for all
+ * protocols that implement it, from cgroups populate function.
+ * This function has to setup any files the protocol want to
+ * appear in the kmem cgroup filesystem.
+ */
+ int (*init_cgroup)(struct proto *prot,
+ struct cgroup *cgrp,
+ struct cgroup_subsys *ss);
+ void (*destroy_cgroup)(struct proto *prot,
+ struct cgroup *cgrp,
+ struct cgroup_subsys *ss);
int *sysctl_wmem;
int *sysctl_rmem;
int max_header;
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 2cbbc13..7ae7b4b 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -255,6 +255,20 @@ extern int sysctl_tcp_thin_linear_timeouts;
extern int sysctl_tcp_thin_dupack;
struct mem_cgroup;
+struct tcp_memcontrol {
+ /* per-cgroup tcp memory pressure knobs */
+ atomic_long_t tcp_memory_allocated;
+ struct percpu_counter tcp_sockets_allocated;
+ /* those two are read-mostly, leave them at the end */
+ long tcp_prot_mem[3];
+ int tcp_memory_pressure;
+};
+
+extern long *tcp_sysctl_mem_nocg(struct mem_cgroup *memcg);
+struct percpu_counter *sockets_allocated_tcp_nocg(struct mem_cgroup *memcg);
+int *memory_pressure_tcp_nocg(struct mem_cgroup *memcg);
+atomic_long_t *memory_allocated_tcp_nocg(struct mem_cgroup *memcg);
+
extern long *tcp_sysctl_mem(struct mem_cgroup *memcg);
struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg);
int *memory_pressure_tcp(struct mem_cgroup *memcg);
@@ -1022,6 +1036,7 @@ static inline void tcp_openreq_init(struct request_sock *req,
ireq->loc_port = tcp_hdr(skb)->dest;
}
+extern void tcp_enter_memory_pressure_nocg(struct sock *sk);
extern void tcp_enter_memory_pressure(struct sock *sk);
static inline int keepalive_intvl_when(const struct tcp_sock *tp)
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 60ab41d..9598e3e 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -49,6 +49,9 @@
#include <linux/cpu.h>
#include <linux/oom.h>
#include "internal.h"
+#ifdef CONFIG_INET
+#include <net/tcp.h>
+#endif
#include <asm/uaccess.h>
@@ -294,6 +297,10 @@ struct mem_cgroup {
*/
struct mem_cgroup_stat_cpu nocpu_base;
spinlock_t pcp_counter_lock;
+
+#ifdef CONFIG_INET
+ struct tcp_memcontrol tcp;
+#endif
};
static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
@@ -301,6 +308,7 @@ static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
#ifdef CONFIG_INET
#include <net/sock.h>
+#include <net/ip.h>
void sock_update_memcg(struct sock *sk)
{
@@ -373,6 +381,80 @@ void memcg_sockets_allocated_inc(struct mem_cgroup *memcg, struct proto *prot)
percpu_counter_inc(prot->sockets_allocated(memcg));
}
EXPORT_SYMBOL(memcg_sockets_allocated_inc);
+
+static struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont);
+/*
+ * Pressure flag: try to collapse.
+ * Technical note: it is used by multiple contexts non atomically.
+ * All the __sk_mem_schedule() is of this nature: accounting
+ * is strict, actions are advisory and have some latency.
+ */
+void tcp_enter_memory_pressure(struct sock *sk)
+{
+ struct mem_cgroup *memcg = sk->sk_cgrp;
+ if (!memcg->tcp.tcp_memory_pressure) {
+ NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
+ memcg->tcp.tcp_memory_pressure = 1;
+ }
+}
+EXPORT_SYMBOL(tcp_enter_memory_pressure);
+
+long *tcp_sysctl_mem(struct mem_cgroup *cg)
+{
+ return cg->tcp.tcp_prot_mem;
+}
+EXPORT_SYMBOL(tcp_sysctl_mem);
+
+atomic_long_t *memory_allocated_tcp(struct mem_cgroup *cg)
+{
+ return &(cg->tcp.tcp_memory_allocated);
+}
+EXPORT_SYMBOL(memory_allocated_tcp);
+
+int *memory_pressure_tcp(struct mem_cgroup *memcg)
+{
+ return &memcg->tcp.tcp_memory_pressure;
+}
+EXPORT_SYMBOL(memory_pressure_tcp);
+
+struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg)
+{
+ return &memcg->tcp.tcp_sockets_allocated;
+}
+EXPORT_SYMBOL(sockets_allocated_tcp);
+
+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);
+ percpu_counter_init(&cg->tcp.tcp_sockets_allocated, 0);
+}
+
+int tcp_init_cgroup(struct proto *prot, struct cgroup *cgrp,
+ struct cgroup_subsys *ss)
+{
+ struct mem_cgroup *cg = mem_cgroup_from_cont(cgrp);
+ /*
+ * We need to initialize it at populate, not create time.
+ * This is because net sysctl tables are not up until much
+ * later
+ */
+ cg->tcp.tcp_prot_mem[0] = sysctl_tcp_mem[0];
+ cg->tcp.tcp_prot_mem[1] = sysctl_tcp_mem[1];
+ cg->tcp.tcp_prot_mem[2] = sysctl_tcp_mem[2];
+
+ return 0;
+}
+EXPORT_SYMBOL(tcp_init_cgroup);
+
+void tcp_destroy_cgroup(struct proto *prot, struct cgroup *cgrp,
+ struct cgroup_subsys *ss)
+{
+ struct mem_cgroup *cg = mem_cgroup_from_cont(cgrp);
+
+ percpu_counter_destroy(&cg->tcp.tcp_sockets_allocated);
+}
+EXPORT_SYMBOL(tcp_destroy_cgroup);
#endif /* CONFIG_INET */
#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
@@ -4864,9 +4946,18 @@ static int register_kmem_files(struct cgroup *cont, struct cgroup_subsys *ss)
if (!mem_cgroup_is_root(memcg))
ret = cgroup_add_files(cont, ss, kmem_cgroup_files,
ARRAY_SIZE(kmem_cgroup_files));
+
+ if (!ret)
+ ret = sockets_populate(cont, ss);
+
return ret;
};
+static void kmem_cgroup_destroy(struct cgroup_subsys *ss,
+ struct cgroup *cont)
+{
+ sockets_destroy(cont, ss);
+}
#else
static int register_kmem_files(struct cgroup *cont, struct cgroup_subsys *ss)
{
@@ -5089,6 +5180,10 @@ mem_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cont)
mem->last_scanned_node = MAX_NUMNODES;
INIT_LIST_HEAD(&mem->oom_notify);
+#if defined(CONFIG_CGROUP_MEM_RES_CTLR_KMEM) && defined(CONFIG_INET)
+ tcp_create_cgroup(mem, ss);
+#endif
+
if (parent)
mem->swappiness = mem_cgroup_swappiness(parent);
atomic_set(&mem->refcnt, 1);
@@ -5114,6 +5209,8 @@ static void mem_cgroup_destroy(struct cgroup_subsys *ss,
{
struct mem_cgroup *mem = mem_cgroup_from_cont(cont);
+ kmem_cgroup_destroy(ss, cont);
+
mem_cgroup_put(mem);
}
diff --git a/net/core/sock.c b/net/core/sock.c
index 6e3ace7..ef3a9a4 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -135,6 +135,42 @@
#include <net/tcp.h>
#endif
+static DEFINE_RWLOCK(proto_list_lock);
+static LIST_HEAD(proto_list);
+
+int sockets_populate(struct cgroup *cgrp, struct cgroup_subsys *ss)
+{
+ struct proto *proto;
+ int ret = 0;
+
+ read_lock(&proto_list_lock);
+ list_for_each_entry(proto, &proto_list, node) {
+ if (proto->init_cgroup)
+ ret = proto->init_cgroup(proto, cgrp, ss);
+ if (ret)
+ goto out;
+ }
+
+ read_unlock(&proto_list_lock);
+ return ret;
+out:
+ list_for_each_entry_continue_reverse(proto, &proto_list, node)
+ if (proto->destroy_cgroup)
+ proto->destroy_cgroup(proto, cgrp, ss);
+ read_unlock(&proto_list_lock);
+ return ret;
+}
+
+void sockets_destroy(struct cgroup *cgrp, struct cgroup_subsys *ss)
+{
+ struct proto *proto;
+ read_lock(&proto_list_lock);
+ list_for_each_entry_reverse(proto, &proto_list, node)
+ if (proto->destroy_cgroup)
+ proto->destroy_cgroup(proto, cgrp, ss);
+ read_unlock(&proto_list_lock);
+}
+
/*
* Each address family might have different locking rules, so we have
* one slock key per address family:
@@ -2262,9 +2298,6 @@ void sk_common_release(struct sock *sk)
}
EXPORT_SYMBOL(sk_common_release);
-static DEFINE_RWLOCK(proto_list_lock);
-static LIST_HEAD(proto_list);
-
#ifdef CONFIG_PROC_FS
#define PROTO_INUSE_NR 64 /* should be enough for the first time */
struct prot_inuse {
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index ca82b90..bbd3989 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -290,13 +290,6 @@ EXPORT_SYMBOL(sysctl_tcp_mem);
EXPORT_SYMBOL(sysctl_tcp_rmem);
EXPORT_SYMBOL(sysctl_tcp_wmem);
-atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
-
-/*
- * Current number of TCP sockets.
- */
-struct percpu_counter tcp_sockets_allocated;
-
/*
* TCP splice context
*/
@@ -306,46 +299,49 @@ struct tcp_splice_state {
unsigned int flags;
};
-/*
- * Pressure flag: try to collapse.
- * Technical note: it is used by multiple contexts non atomically.
- * All the __sk_mem_schedule() is of this nature: accounting
- * is strict, actions are advisory and have some latency.
- */
+/* Current number of TCP sockets. */
+struct percpu_counter tcp_sockets_allocated;
+atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
int tcp_memory_pressure __read_mostly;
-int *memory_pressure_tcp(struct mem_cgroup *memcg)
+int *memory_pressure_tcp_nocg(struct mem_cgroup *memcg)
{
return &tcp_memory_pressure;
}
-EXPORT_SYMBOL(memory_pressure_tcp);
+EXPORT_SYMBOL(memory_pressure_tcp_nocg);
-struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg)
+struct percpu_counter *sockets_allocated_tcp_nocg(struct mem_cgroup *memcg)
{
return &tcp_sockets_allocated;
}
-EXPORT_SYMBOL(sockets_allocated_tcp);
+EXPORT_SYMBOL(sockets_allocated_tcp_nocg);
-void tcp_enter_memory_pressure(struct sock *sk)
+/*
+ * Pressure flag: try to collapse.
+ * Technical note: it is used by multiple contexts non atomically.
+ * All the __sk_mem_schedule() is of this nature: accounting
+ * is strict, actions are advisory and have some latency.
+ */
+void tcp_enter_memory_pressure_nocg(struct sock *sk)
{
if (!tcp_memory_pressure) {
NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
tcp_memory_pressure = 1;
}
}
-EXPORT_SYMBOL(tcp_enter_memory_pressure);
+EXPORT_SYMBOL(tcp_enter_memory_pressure_nocg);
-long *tcp_sysctl_mem(struct mem_cgroup *memcg)
+long *tcp_sysctl_mem_nocg(struct mem_cgroup *memcg)
{
return sysctl_tcp_mem;
}
-EXPORT_SYMBOL(tcp_sysctl_mem);
+EXPORT_SYMBOL(tcp_sysctl_mem_nocg);
-atomic_long_t *memory_allocated_tcp(struct mem_cgroup *memcg)
+atomic_long_t *memory_allocated_tcp_nocg(struct mem_cgroup *memcg)
{
return &tcp_memory_allocated;
}
-EXPORT_SYMBOL(memory_allocated_tcp);
+EXPORT_SYMBOL(memory_allocated_tcp_nocg);
/* Convert seconds to retransmits based on initial and max timeout */
static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
@@ -3247,7 +3243,9 @@ void __init tcp_init(void)
BUILD_BUG_ON(sizeof(struct tcp_skb_cb) > sizeof(skb->cb));
+#ifndef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
percpu_counter_init(&tcp_sockets_allocated, 0);
+#endif
percpu_counter_init(&tcp_orphan_count, 0);
tcp_hashinfo.bind_bucket_cachep =
kmem_cache_create("tcp_bind_bucket",
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index 3227f6a..0377af3 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -2604,12 +2604,22 @@ struct proto tcp_prot = {
.hash = inet_hash,
.unhash = inet_unhash,
.get_port = inet_csk_get_port,
+ .orphan_count = &tcp_orphan_count,
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
+ .init_cgroup = tcp_init_cgroup,
+ .destroy_cgroup = tcp_destroy_cgroup,
.enter_memory_pressure = tcp_enter_memory_pressure,
.memory_pressure = memory_pressure_tcp,
.sockets_allocated = sockets_allocated_tcp,
- .orphan_count = &tcp_orphan_count,
.memory_allocated = memory_allocated_tcp,
.prot_mem = tcp_sysctl_mem,
+#else
+ .enter_memory_pressure = tcp_enter_memory_pressure_nocg,
+ .memory_pressure = memory_pressure_tcp_nocg,
+ .sockets_allocated = sockets_allocated_tcp_nocg,
+ .memory_allocated = memory_allocated_tcp_nocg,
+ .prot_mem = tcp_sysctl_mem_nocg,
+#endif
.sysctl_wmem = sysctl_tcp_wmem,
.sysctl_rmem = sysctl_tcp_rmem,
.max_header = MAX_TCP_HEADER,
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 962fb56..5597807 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -2195,12 +2195,20 @@ struct proto tcpv6_prot = {
.hash = tcp_v6_hash,
.unhash = inet_unhash,
.get_port = inet_csk_get_port,
+ .orphan_count = &tcp_orphan_count,
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
.enter_memory_pressure = tcp_enter_memory_pressure,
.sockets_allocated = sockets_allocated_tcp,
.memory_allocated = memory_allocated_tcp,
.memory_pressure = memory_pressure_tcp,
- .orphan_count = &tcp_orphan_count,
.prot_mem = tcp_sysctl_mem,
+#else
+ .enter_memory_pressure = tcp_enter_memory_pressure_nocg,
+ .sockets_allocated = sockets_allocated_tcp_nocg,
+ .memory_allocated = memory_allocated_tcp_nocg,
+ .memory_pressure = memory_pressure_tcp_nocg,
+ .prot_mem = tcp_sysctl_mem_nocg,
+#endif
.sysctl_wmem = sysctl_tcp_wmem,
.sysctl_rmem = sysctl_tcp_rmem,
.max_header = MAX_TCP_HEADER,
--
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 3/8] foundations of per-cgroup memory pressure controlling.
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 converts struct sock fields memory_pressure,
memory_allocated, sockets_allocated, and sysctl_mem (now prot_mem)
to function pointers, receiving a struct mem_cgroup parameter.
enter_memory_pressure is kept the same, since all its callers
have socket a context, and the kmem_cgroup can be derived from
the socket itself.
To keep things working, the patch convert all users of those fields
to use acessor functions.
In my benchmarks I didn't see a significant performance difference
with this patch applied compared to a baseline (around 1 % diff, thus
inside error margin).
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>
---
crypto/af_alg.c | 7 ++-
include/linux/memcontrol.h | 29 +++++++++++-
include/net/sock.h | 112 +++++++++++++++++++++++++++++++++++++++++--
include/net/tcp.h | 11 +++--
include/net/udp.h | 3 +-
include/trace/events/sock.h | 10 ++--
mm/memcontrol.c | 45 +++++++++++++++++-
net/core/sock.c | 62 ++++++++++++++----------
net/decnet/af_decnet.c | 21 +++++++-
net/ipv4/proc.c | 7 ++-
net/ipv4/tcp.c | 27 +++++++++-
net/ipv4/tcp_input.c | 12 ++--
net/ipv4/tcp_ipv4.c | 12 ++--
net/ipv4/tcp_output.c | 2 +-
net/ipv4/tcp_timer.c | 2 +-
net/ipv4/udp.c | 20 ++++++--
net/ipv6/tcp_ipv6.c | 10 ++--
net/ipv6/udp.c | 4 +-
net/sctp/socket.c | 35 ++++++++++---
19 files changed, 345 insertions(+), 86 deletions(-)
diff --git a/crypto/af_alg.c b/crypto/af_alg.c
index ac33d5f..9f41324 100644
--- a/crypto/af_alg.c
+++ b/crypto/af_alg.c
@@ -29,10 +29,15 @@ struct alg_type_list {
static atomic_long_t alg_memory_allocated;
+static atomic_long_t *memory_allocated_alg(struct mem_cgroup *memcg)
+{
+ return &alg_memory_allocated;
+}
+
static struct proto alg_proto = {
.name = "ALG",
.owner = THIS_MODULE,
- .memory_allocated = &alg_memory_allocated,
+ .memory_allocated = memory_allocated_alg,
.obj_size = sizeof(struct alg_sock),
};
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 88aea1b..2012060 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -361,6 +361,10 @@ static inline
void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
{
}
+static inline struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p)
+{
+ return NULL;
+}
#endif /* CONFIG_CGROUP_MEM_CONT */
#if !defined(CONFIG_CGROUP_MEM_RES_CTLR) || !defined(CONFIG_DEBUG_VM)
@@ -378,11 +382,34 @@ mem_cgroup_print_bad_page(struct page *page)
#ifdef CONFIG_INET
struct sock;
+struct proto;
#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
void sock_update_memcg(struct sock *sk);
void sock_release_memcg(struct sock *sk);
-
+void memcg_sock_mem_alloc(struct mem_cgroup *memcg, struct proto *prot,
+ int amt, int *parent_failure);
+void memcg_sock_mem_free(struct mem_cgroup *memcg, struct proto *prot, int amt);
+void memcg_sockets_allocated_dec(struct mem_cgroup *memcg, struct proto *prot);
+void memcg_sockets_allocated_inc(struct mem_cgroup *memcg, struct proto *prot);
#else
+/* memcontrol includes sockets.h, that includes memcontrol.h ... */
+static inline void memcg_sock_mem_alloc(struct mem_cgroup *memcg,
+ struct proto *prot, int amt,
+ int *parent_failure)
+{
+}
+static inline void memcg_sock_mem_free(struct mem_cgroup *memcg,
+ struct proto *prot, int amt)
+{
+}
+static inline void memcg_sockets_allocated_dec(struct mem_cgroup *memcg,
+ struct proto *prot)
+{
+}
+static inline void memcg_sockets_allocated_inc(struct mem_cgroup *memcg,
+ struct proto *prot)
+{
+}
static inline void sock_update_memcg(struct sock *sk)
{
}
diff --git a/include/net/sock.h b/include/net/sock.h
index afe1467..c6983cf 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -54,6 +54,7 @@
#include <linux/security.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
+#include <linux/cgroup.h>
#include <linux/filter.h>
#include <linux/rculist_nulls.h>
@@ -168,6 +169,8 @@ struct sock_common {
/* public: */
};
+struct mem_cgroup;
+
/**
* struct sock - network layer representation of sockets
* @__sk_common: shared layout with inet_timewait_sock
@@ -786,18 +789,32 @@ struct proto {
unsigned int inuse_idx;
#endif
+ /*
+ * per-cgroup memory tracking:
+ *
+ * The following functions track memory consumption of network buffers
+ * by cgroup (kmem_cgroup) for the current protocol. As of the rest
+ * of the fields in this structure, not all protocols are required
+ * to implement them. Protocols that don't want to do per-cgroup
+ * memory pressure management, can just assume the root cgroup is used.
+ *
+ */
/* Memory pressure */
void (*enter_memory_pressure)(struct sock *sk);
- atomic_long_t *memory_allocated; /* Current allocated memory. */
- struct percpu_counter *sockets_allocated; /* Current number of sockets. */
+ /* Pointer to the current memory allocation of this cgroup. */
+ atomic_long_t *(*memory_allocated)(struct mem_cgroup *memcg);
+ /* Pointer to the current number of sockets in this cgroup. */
+ struct percpu_counter *(*sockets_allocated)(struct mem_cgroup *memcg);
/*
- * Pressure flag: try to collapse.
+ * Per cgroup pointer to the pressure flag: try to collapse.
* Technical note: it is used by multiple contexts non atomically.
* All the __sk_mem_schedule() is of this nature: accounting
* is strict, actions are advisory and have some latency.
*/
- int *memory_pressure;
- long *sysctl_mem;
+ int *(*memory_pressure)(struct mem_cgroup *memcg);
+ /* Pointer to the per-cgroup version of the the sysctl_mem field */
+ long *(*prot_mem)(struct mem_cgroup *memcg);
+
int *sysctl_wmem;
int *sysctl_rmem;
int max_header;
@@ -856,6 +873,91 @@ static inline void sk_refcnt_debug_release(const struct sock *sk)
#define sk_refcnt_debug_release(sk) do { } while (0)
#endif /* SOCK_REFCNT_DEBUG */
+#include <linux/memcontrol.h>
+static inline int *sk_memory_pressure(struct sock *sk)
+{
+ int *ret = NULL;
+ if (sk->sk_prot->memory_pressure)
+ ret = sk->sk_prot->memory_pressure(sk->sk_cgrp);
+ return ret;
+}
+
+static inline long sk_prot_mem(struct sock *sk, int index)
+{
+ long *prot = sk->sk_prot->prot_mem(sk->sk_cgrp);
+ return prot[index];
+}
+
+static inline long
+sk_memory_allocated(struct sock *sk)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+
+ return atomic_long_read(prot->memory_allocated(cg));
+}
+
+static inline long
+sk_memory_allocated_add(struct sock *sk, int amt, int *parent_failure)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+ long allocated;
+
+ allocated = atomic_long_add_return(amt, prot->memory_allocated(cg));
+ memcg_sock_mem_alloc(cg, prot, amt, parent_failure);
+ return allocated;
+}
+
+static inline void
+sk_memory_allocated_sub(struct sock *sk, int amt)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+
+ atomic_long_sub(amt, prot->memory_allocated(cg));
+ memcg_sock_mem_free(cg, prot, amt);
+}
+
+static inline void sk_sockets_allocated_dec(struct sock *sk)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+
+ percpu_counter_dec(prot->sockets_allocated(cg));
+ memcg_sockets_allocated_dec(cg, prot);
+}
+
+static inline void sk_sockets_allocated_inc(struct sock *sk)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+
+ percpu_counter_inc(prot->sockets_allocated(cg));
+ memcg_sockets_allocated_inc(cg, prot);
+}
+
+static inline int
+sk_sockets_allocated_read_positive(struct sock *sk)
+{
+ struct proto *prot = sk->sk_prot;
+ struct mem_cgroup *cg = sk->sk_cgrp;
+
+ return percpu_counter_sum_positive(prot->sockets_allocated(cg));
+}
+
+static inline int
+kcg_sockets_allocated_sum_positive(struct proto *prot, struct mem_cgroup *cg)
+{
+ return percpu_counter_sum_positive(prot->sockets_allocated(cg));
+}
+
+static inline long
+kcg_memory_allocated(struct proto *prot, struct mem_cgroup *cg)
+{
+ return atomic_long_read(prot->memory_allocated(cg));
+}
+
#ifdef CONFIG_PROC_FS
/* Called with local bh disabled */
diff --git a/include/net/tcp.h b/include/net/tcp.h
index acc620a..2cbbc13 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -45,6 +45,7 @@
#include <net/dst.h>
#include <linux/seq_file.h>
+#include <linux/memcontrol.h>
extern struct inet_hashinfo tcp_hashinfo;
@@ -253,9 +254,11 @@ extern int sysctl_tcp_cookie_size;
extern int sysctl_tcp_thin_linear_timeouts;
extern int sysctl_tcp_thin_dupack;
-extern atomic_long_t tcp_memory_allocated;
-extern struct percpu_counter tcp_sockets_allocated;
-extern int tcp_memory_pressure;
+struct mem_cgroup;
+extern long *tcp_sysctl_mem(struct mem_cgroup *memcg);
+struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg);
+int *memory_pressure_tcp(struct mem_cgroup *memcg);
+atomic_long_t *memory_allocated_tcp(struct mem_cgroup *memcg);
/*
* The next routines deal with comparing 32 bit unsigned ints
@@ -286,7 +289,7 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
}
if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
- atomic_long_read(&tcp_memory_allocated) > sysctl_tcp_mem[2])
+ sk_memory_allocated(sk) > sk_prot_mem(sk, 2))
return true;
return false;
}
diff --git a/include/net/udp.h b/include/net/udp.h
index 67ea6fc..b96ed51 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -105,7 +105,8 @@ static inline struct udp_hslot *udp_hashslot2(struct udp_table *table,
extern struct proto udp_prot;
-extern atomic_long_t udp_memory_allocated;
+atomic_long_t *memory_allocated_udp(struct mem_cgroup *memcg);
+long *udp_sysctl_mem(struct mem_cgroup *memcg);
/* sysctl variables for udp */
extern long sysctl_udp_mem[3];
diff --git a/include/trace/events/sock.h b/include/trace/events/sock.h
index 779abb9..12a6083 100644
--- a/include/trace/events/sock.h
+++ b/include/trace/events/sock.h
@@ -37,7 +37,7 @@ TRACE_EVENT(sock_exceed_buf_limit,
TP_STRUCT__entry(
__array(char, name, 32)
- __field(long *, sysctl_mem)
+ __field(long *, prot_mem)
__field(long, allocated)
__field(int, sysctl_rmem)
__field(int, rmem_alloc)
@@ -45,7 +45,7 @@ TRACE_EVENT(sock_exceed_buf_limit,
TP_fast_assign(
strncpy(__entry->name, prot->name, 32);
- __entry->sysctl_mem = prot->sysctl_mem;
+ __entry->prot_mem = sk->sk_prot->prot_mem(sk->sk_cgrp);
__entry->allocated = allocated;
__entry->sysctl_rmem = prot->sysctl_rmem[0];
__entry->rmem_alloc = atomic_read(&sk->sk_rmem_alloc);
@@ -54,9 +54,9 @@ TRACE_EVENT(sock_exceed_buf_limit,
TP_printk("proto:%s sysctl_mem=%ld,%ld,%ld allocated=%ld "
"sysctl_rmem=%d rmem_alloc=%d",
__entry->name,
- __entry->sysctl_mem[0],
- __entry->sysctl_mem[1],
- __entry->sysctl_mem[2],
+ __entry->prot_mem[0],
+ __entry->prot_mem[1],
+ __entry->prot_mem[2],
__entry->allocated,
__entry->sysctl_rmem,
__entry->rmem_alloc)
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index b1dcba9..60ab41d 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -296,6 +296,7 @@ struct mem_cgroup {
spinlock_t pcp_counter_lock;
};
+static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg);
/* Writing them here to avoid exposing memcg's inner layout */
#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
#ifdef CONFIG_INET
@@ -329,6 +330,49 @@ 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)
+{
+ memcg = parent_mem_cgroup(memcg);
+ for (; memcg != NULL; memcg = parent_mem_cgroup(memcg)) {
+ long alloc;
+ long *prot_mem = prot->prot_mem(memcg);
+ /*
+ * Large nestings are not the common case, and stopping in the
+ * middle would be complicated enough, that we bill it all the
+ * way through the root, and if needed, unbill everything later
+ */
+ alloc = atomic_long_add_return(amt,
+ prot->memory_allocated(memcg));
+ *parent_failure |= (alloc > prot_mem[2]);
+ }
+}
+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));
+}
+EXPORT_SYMBOL(memcg_sock_mem_free);
+
+void memcg_sockets_allocated_dec(struct mem_cgroup *memcg, struct proto *prot)
+{
+ memcg = parent_mem_cgroup(memcg);
+ for (; memcg; memcg = parent_mem_cgroup(memcg))
+ percpu_counter_dec(prot->sockets_allocated(memcg));
+}
+EXPORT_SYMBOL(memcg_sockets_allocated_dec);
+
+void memcg_sockets_allocated_inc(struct mem_cgroup *memcg, struct proto *prot)
+{
+ memcg = parent_mem_cgroup(memcg);
+ for (; memcg; memcg = parent_mem_cgroup(memcg))
+ percpu_counter_inc(prot->sockets_allocated(memcg));
+}
+EXPORT_SYMBOL(memcg_sockets_allocated_inc);
#endif /* CONFIG_INET */
#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
@@ -414,7 +458,6 @@ enum mem_type {
static void mem_cgroup_get(struct mem_cgroup *mem);
static void mem_cgroup_put(struct mem_cgroup *mem);
-static struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *mem);
static void drain_all_stock_async(struct mem_cgroup *mem);
static struct mem_cgroup_per_zone *
diff --git a/net/core/sock.c b/net/core/sock.c
index 5426ba0..6e3ace7 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1293,7 +1293,7 @@ struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
newsk->sk_wq = NULL;
if (newsk->sk_prot->sockets_allocated)
- percpu_counter_inc(newsk->sk_prot->sockets_allocated);
+ sk_sockets_allocated_inc(newsk);
if (sock_flag(newsk, SOCK_TIMESTAMP) ||
sock_flag(newsk, SOCK_TIMESTAMPING_RX_SOFTWARE))
@@ -1684,30 +1684,33 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind)
struct proto *prot = sk->sk_prot;
int amt = sk_mem_pages(size);
long allocated;
+ int *memory_pressure;
+ int parent_failure = 0;
sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
- allocated = atomic_long_add_return(amt, prot->memory_allocated);
+
+ memory_pressure = sk_memory_pressure(sk);
+ allocated = sk_memory_allocated_add(sk, amt, &parent_failure);
+
+ /* Over hard limit (we, or our parents) */
+ if (parent_failure || (allocated > sk_prot_mem(sk, 2)))
+ goto suppress_allocation;
/* Under limit. */
- if (allocated <= prot->sysctl_mem[0]) {
- if (prot->memory_pressure && *prot->memory_pressure)
- *prot->memory_pressure = 0;
- return 1;
- }
+ if (allocated <= sk_prot_mem(sk, 0))
+ if (memory_pressure && *memory_pressure)
+ *memory_pressure = 0;
/* Under pressure. */
- if (allocated > prot->sysctl_mem[1])
+ if (allocated > sk_prot_mem(sk, 1))
if (prot->enter_memory_pressure)
prot->enter_memory_pressure(sk);
- /* Over hard limit. */
- if (allocated > prot->sysctl_mem[2])
- goto suppress_allocation;
-
/* guarantee minimum buffer size under pressure */
if (kind == SK_MEM_RECV) {
if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
return 1;
+
} else { /* SK_MEM_SEND */
if (sk->sk_type == SOCK_STREAM) {
if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
@@ -1717,13 +1720,13 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind)
return 1;
}
- if (prot->memory_pressure) {
+ if (memory_pressure) {
int alloc;
- if (!*prot->memory_pressure)
+ if (!*memory_pressure)
return 1;
- alloc = percpu_counter_read_positive(prot->sockets_allocated);
- if (prot->sysctl_mem[2] > alloc *
+ alloc = sk_sockets_allocated_read_positive(sk);
+ if (sk_prot_mem(sk, 2) > alloc *
sk_mem_pages(sk->sk_wmem_queued +
atomic_read(&sk->sk_rmem_alloc) +
sk->sk_forward_alloc))
@@ -1746,7 +1749,9 @@ suppress_allocation:
/* Alas. Undo changes. */
sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
- atomic_long_sub(amt, prot->memory_allocated);
+
+ sk_memory_allocated_sub(sk, amt);
+
return 0;
}
EXPORT_SYMBOL(__sk_mem_schedule);
@@ -1757,15 +1762,15 @@ EXPORT_SYMBOL(__sk_mem_schedule);
*/
void __sk_mem_reclaim(struct sock *sk)
{
- struct proto *prot = sk->sk_prot;
+ int *memory_pressure = sk_memory_pressure(sk);
- atomic_long_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
- prot->memory_allocated);
+ sk_memory_allocated_sub(sk,
+ sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT);
sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
- if (prot->memory_pressure && *prot->memory_pressure &&
- (atomic_long_read(prot->memory_allocated) < prot->sysctl_mem[0]))
- *prot->memory_pressure = 0;
+ if (memory_pressure && *memory_pressure &&
+ (sk_memory_allocated(sk) < sk_prot_mem(sk, 0)))
+ *memory_pressure = 0;
}
EXPORT_SYMBOL(__sk_mem_reclaim);
@@ -2484,13 +2489,20 @@ static char proto_method_implemented(const void *method)
static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
{
+ struct mem_cgroup *cg = mem_cgroup_from_task(current);
+ int *memory_pressure = NULL;
+
+ if (proto->memory_pressure)
+ memory_pressure = proto->memory_pressure(cg);
+
seq_printf(seq, "%-9s %4u %6d %6ld %-3s %6u %-3s %-10s "
"%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
proto->name,
proto->obj_size,
sock_prot_inuse_get(seq_file_net(seq), proto),
- proto->memory_allocated != NULL ? atomic_long_read(proto->memory_allocated) : -1L,
- proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
+ proto->memory_allocated != NULL ?
+ kcg_memory_allocated(proto, cg) : -1L,
+ memory_pressure != NULL ? *memory_pressure ? "yes" : "no" : "NI",
proto->max_header,
proto->slab == NULL ? "no" : "yes",
module_name(proto->owner),
diff --git a/net/decnet/af_decnet.c b/net/decnet/af_decnet.c
index 19acd00..39f83b4 100644
--- a/net/decnet/af_decnet.c
+++ b/net/decnet/af_decnet.c
@@ -458,13 +458,28 @@ static void dn_enter_memory_pressure(struct sock *sk)
}
}
+static atomic_long_t *memory_allocated_dn(struct mem_cgroup *memcg)
+{
+ return &decnet_memory_allocated;
+}
+
+static int *memory_pressure_dn(struct mem_cgroup *memcg)
+{
+ return &dn_memory_pressure;
+}
+
+static long *dn_sysctl_mem(struct mem_cgroup *memcg)
+{
+ return sysctl_decnet_mem;
+}
+
static struct proto dn_proto = {
.name = "NSP",
.owner = THIS_MODULE,
.enter_memory_pressure = dn_enter_memory_pressure,
- .memory_pressure = &dn_memory_pressure,
- .memory_allocated = &decnet_memory_allocated,
- .sysctl_mem = sysctl_decnet_mem,
+ .memory_pressure = memory_pressure_dn,
+ .memory_allocated = memory_allocated_dn,
+ .prot_mem = dn_sysctl_mem,
.sysctl_wmem = sysctl_decnet_wmem,
.sysctl_rmem = sysctl_decnet_rmem,
.max_header = DN_MAX_NSP_DATA_HEADER + 64,
diff --git a/net/ipv4/proc.c b/net/ipv4/proc.c
index 4bfad5d..535456d 100644
--- a/net/ipv4/proc.c
+++ b/net/ipv4/proc.c
@@ -52,20 +52,21 @@ static int sockstat_seq_show(struct seq_file *seq, void *v)
{
struct net *net = seq->private;
int orphans, sockets;
+ struct mem_cgroup *cg = mem_cgroup_from_task(current);
local_bh_disable();
orphans = percpu_counter_sum_positive(&tcp_orphan_count);
- sockets = percpu_counter_sum_positive(&tcp_sockets_allocated);
+ sockets = kcg_sockets_allocated_sum_positive(&tcp_prot, cg);
local_bh_enable();
socket_seq_show(seq);
seq_printf(seq, "TCP: inuse %d orphan %d tw %d alloc %d mem %ld\n",
sock_prot_inuse_get(net, &tcp_prot), orphans,
tcp_death_row.tw_count, sockets,
- atomic_long_read(&tcp_memory_allocated));
+ kcg_memory_allocated(&tcp_prot, cg));
seq_printf(seq, "UDP: inuse %d mem %ld\n",
sock_prot_inuse_get(net, &udp_prot),
- atomic_long_read(&udp_memory_allocated));
+ kcg_memory_allocated(&udp_prot, cg));
seq_printf(seq, "UDPLITE: inuse %d\n",
sock_prot_inuse_get(net, &udplite_prot));
seq_printf(seq, "RAW: inuse %d\n",
diff --git a/net/ipv4/tcp.c b/net/ipv4/tcp.c
index 46febca..ca82b90 100644
--- a/net/ipv4/tcp.c
+++ b/net/ipv4/tcp.c
@@ -291,13 +291,11 @@ EXPORT_SYMBOL(sysctl_tcp_rmem);
EXPORT_SYMBOL(sysctl_tcp_wmem);
atomic_long_t tcp_memory_allocated; /* Current allocated memory. */
-EXPORT_SYMBOL(tcp_memory_allocated);
/*
* Current number of TCP sockets.
*/
struct percpu_counter tcp_sockets_allocated;
-EXPORT_SYMBOL(tcp_sockets_allocated);
/*
* TCP splice context
@@ -315,7 +313,18 @@ struct tcp_splice_state {
* is strict, actions are advisory and have some latency.
*/
int tcp_memory_pressure __read_mostly;
-EXPORT_SYMBOL(tcp_memory_pressure);
+
+int *memory_pressure_tcp(struct mem_cgroup *memcg)
+{
+ return &tcp_memory_pressure;
+}
+EXPORT_SYMBOL(memory_pressure_tcp);
+
+struct percpu_counter *sockets_allocated_tcp(struct mem_cgroup *memcg)
+{
+ return &tcp_sockets_allocated;
+}
+EXPORT_SYMBOL(sockets_allocated_tcp);
void tcp_enter_memory_pressure(struct sock *sk)
{
@@ -326,6 +335,18 @@ void tcp_enter_memory_pressure(struct sock *sk)
}
EXPORT_SYMBOL(tcp_enter_memory_pressure);
+long *tcp_sysctl_mem(struct mem_cgroup *memcg)
+{
+ return sysctl_tcp_mem;
+}
+EXPORT_SYMBOL(tcp_sysctl_mem);
+
+atomic_long_t *memory_allocated_tcp(struct mem_cgroup *memcg)
+{
+ return &tcp_memory_allocated;
+}
+EXPORT_SYMBOL(memory_allocated_tcp);
+
/* Convert seconds to retransmits based on initial and max timeout */
static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
{
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 21fab3e..1529fbe 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -316,7 +316,7 @@ static void tcp_grow_window(struct sock *sk, struct sk_buff *skb)
/* Check #1 */
if (tp->rcv_ssthresh < tp->window_clamp &&
(int)tp->rcv_ssthresh < tcp_space(sk) &&
- !tcp_memory_pressure) {
+ !sk_memory_pressure(sk)) {
int incr;
/* Check #2. Increase window, if skb with such overhead
@@ -398,8 +398,8 @@ static void tcp_clamp_window(struct sock *sk)
if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
!(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
- !tcp_memory_pressure &&
- atomic_long_read(&tcp_memory_allocated) < sysctl_tcp_mem[0]) {
+ !sk_memory_pressure(sk) &&
+ sk_memory_allocated(sk) < sk_prot_mem(sk, 0)) {
sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
sysctl_tcp_rmem[2]);
}
@@ -4806,7 +4806,7 @@ static int tcp_prune_queue(struct sock *sk)
if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
tcp_clamp_window(sk);
- else if (tcp_memory_pressure)
+ else if (sk_memory_pressure(sk))
tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);
tcp_collapse_ofo_queue(sk);
@@ -4872,11 +4872,11 @@ static int tcp_should_expand_sndbuf(struct sock *sk)
return 0;
/* If we are under global TCP memory pressure, do not expand. */
- if (tcp_memory_pressure)
+ if (sk_memory_pressure(sk))
return 0;
/* If we are under soft global TCP memory pressure, do not expand. */
- if (atomic_long_read(&tcp_memory_allocated) >= sysctl_tcp_mem[0])
+ if (sk_memory_allocated(sk) >= sk_prot_mem(sk, 0))
return 0;
/* If we filled the congestion window, do not expand. */
diff --git a/net/ipv4/tcp_ipv4.c b/net/ipv4/tcp_ipv4.c
index c34f015..3227f6a 100644
--- a/net/ipv4/tcp_ipv4.c
+++ b/net/ipv4/tcp_ipv4.c
@@ -1908,7 +1908,7 @@ static int tcp_v4_init_sock(struct sock *sk)
sk->sk_rcvbuf = sysctl_tcp_rmem[1];
local_bh_disable();
- percpu_counter_inc(&tcp_sockets_allocated);
+ sk_sockets_allocated_inc(sk);
local_bh_enable();
return 0;
@@ -1964,7 +1964,7 @@ void tcp_v4_destroy_sock(struct sock *sk)
tp->cookie_values = NULL;
}
- percpu_counter_dec(&tcp_sockets_allocated);
+ sk_sockets_allocated_dec(sk);
}
EXPORT_SYMBOL(tcp_v4_destroy_sock);
@@ -2605,11 +2605,11 @@ struct proto tcp_prot = {
.unhash = inet_unhash,
.get_port = inet_csk_get_port,
.enter_memory_pressure = tcp_enter_memory_pressure,
- .sockets_allocated = &tcp_sockets_allocated,
+ .memory_pressure = memory_pressure_tcp,
+ .sockets_allocated = sockets_allocated_tcp,
.orphan_count = &tcp_orphan_count,
- .memory_allocated = &tcp_memory_allocated,
- .memory_pressure = &tcp_memory_pressure,
- .sysctl_mem = sysctl_tcp_mem,
+ .memory_allocated = memory_allocated_tcp,
+ .prot_mem = tcp_sysctl_mem,
.sysctl_wmem = sysctl_tcp_wmem,
.sysctl_rmem = sysctl_tcp_rmem,
.max_header = MAX_TCP_HEADER,
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 882e0b0..06aeb31 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -1912,7 +1912,7 @@ u32 __tcp_select_window(struct sock *sk)
if (free_space < (full_space >> 1)) {
icsk->icsk_ack.quick = 0;
- if (tcp_memory_pressure)
+ if (sk_memory_pressure(sk))
tp->rcv_ssthresh = min(tp->rcv_ssthresh,
4U * tp->advmss);
diff --git a/net/ipv4/tcp_timer.c b/net/ipv4/tcp_timer.c
index ecd44b0..2c67617 100644
--- a/net/ipv4/tcp_timer.c
+++ b/net/ipv4/tcp_timer.c
@@ -261,7 +261,7 @@ static void tcp_delack_timer(unsigned long data)
}
out:
- if (tcp_memory_pressure)
+ if (sk_memory_pressure(sk))
sk_mem_reclaim(sk);
out_unlock:
bh_unlock_sock(sk);
diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c
index 1b5a193..f8d72ce 100644
--- a/net/ipv4/udp.c
+++ b/net/ipv4/udp.c
@@ -120,9 +120,6 @@ EXPORT_SYMBOL(sysctl_udp_rmem_min);
int sysctl_udp_wmem_min __read_mostly;
EXPORT_SYMBOL(sysctl_udp_wmem_min);
-atomic_long_t udp_memory_allocated;
-EXPORT_SYMBOL(udp_memory_allocated);
-
#define MAX_UDP_PORTS 65536
#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
@@ -1918,6 +1915,19 @@ unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait)
}
EXPORT_SYMBOL(udp_poll);
+static atomic_long_t udp_memory_allocated;
+atomic_long_t *memory_allocated_udp(struct mem_cgroup *memcg)
+{
+ return &udp_memory_allocated;
+}
+EXPORT_SYMBOL(memory_allocated_udp);
+
+long *udp_sysctl_mem(struct mem_cgroup *memcg)
+{
+ return sysctl_udp_mem;
+}
+EXPORT_SYMBOL(udp_sysctl_mem);
+
struct proto udp_prot = {
.name = "UDP",
.owner = THIS_MODULE,
@@ -1936,8 +1946,8 @@ struct proto udp_prot = {
.unhash = udp_lib_unhash,
.rehash = udp_v4_rehash,
.get_port = udp_v4_get_port,
- .memory_allocated = &udp_memory_allocated,
- .sysctl_mem = sysctl_udp_mem,
+ .memory_allocated = &memory_allocated_udp,
+ .prot_mem = udp_sysctl_mem,
.sysctl_wmem = &sysctl_udp_wmem_min,
.sysctl_rmem = &sysctl_udp_rmem_min,
.obj_size = sizeof(struct udp_sock),
diff --git a/net/ipv6/tcp_ipv6.c b/net/ipv6/tcp_ipv6.c
index 3c9fa61..962fb56 100644
--- a/net/ipv6/tcp_ipv6.c
+++ b/net/ipv6/tcp_ipv6.c
@@ -1987,7 +1987,7 @@ static int tcp_v6_init_sock(struct sock *sk)
sk->sk_rcvbuf = sysctl_tcp_rmem[1];
local_bh_disable();
- percpu_counter_inc(&tcp_sockets_allocated);
+ sk_sockets_allocated_inc(sk);
local_bh_enable();
return 0;
@@ -2196,11 +2196,11 @@ struct proto tcpv6_prot = {
.unhash = inet_unhash,
.get_port = inet_csk_get_port,
.enter_memory_pressure = tcp_enter_memory_pressure,
- .sockets_allocated = &tcp_sockets_allocated,
- .memory_allocated = &tcp_memory_allocated,
- .memory_pressure = &tcp_memory_pressure,
+ .sockets_allocated = sockets_allocated_tcp,
+ .memory_allocated = memory_allocated_tcp,
+ .memory_pressure = memory_pressure_tcp,
.orphan_count = &tcp_orphan_count,
- .sysctl_mem = sysctl_tcp_mem,
+ .prot_mem = tcp_sysctl_mem,
.sysctl_wmem = sysctl_tcp_wmem,
.sysctl_rmem = sysctl_tcp_rmem,
.max_header = MAX_TCP_HEADER,
diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
index bb95e8e..00611b8 100644
--- a/net/ipv6/udp.c
+++ b/net/ipv6/udp.c
@@ -1465,8 +1465,8 @@ struct proto udpv6_prot = {
.unhash = udp_lib_unhash,
.rehash = udp_v6_rehash,
.get_port = udp_v6_get_port,
- .memory_allocated = &udp_memory_allocated,
- .sysctl_mem = sysctl_udp_mem,
+ .memory_allocated = memory_allocated_udp,
+ .prot_mem = udp_sysctl_mem,
.sysctl_wmem = &sysctl_udp_wmem_min,
.sysctl_rmem = &sysctl_udp_rmem_min,
.obj_size = sizeof(struct udp6_sock),
diff --git a/net/sctp/socket.c b/net/sctp/socket.c
index 836aa63..62eb178 100644
--- a/net/sctp/socket.c
+++ b/net/sctp/socket.c
@@ -119,11 +119,30 @@ static int sctp_memory_pressure;
static atomic_long_t sctp_memory_allocated;
struct percpu_counter sctp_sockets_allocated;
+static long *sctp_sysctl_mem(struct mem_cgroup *memcg)
+{
+ return sysctl_sctp_mem;
+}
+
static void sctp_enter_memory_pressure(struct sock *sk)
{
sctp_memory_pressure = 1;
}
+static int *memory_pressure_sctp(struct mem_cgroup *memcg)
+{
+ return &sctp_memory_pressure;
+}
+
+static atomic_long_t *memory_allocated_sctp(struct mem_cgroup *memcg)
+{
+ return &sctp_memory_allocated;
+}
+
+static struct percpu_counter *sockets_allocated_sctp(struct mem_cgroup *memcg)
+{
+ return &sctp_sockets_allocated;
+}
/* Get the sndbuf space available at the time on the association. */
static inline int sctp_wspace(struct sctp_association *asoc)
@@ -6831,13 +6850,13 @@ struct proto sctp_prot = {
.unhash = sctp_unhash,
.get_port = sctp_get_port,
.obj_size = sizeof(struct sctp_sock),
- .sysctl_mem = sysctl_sctp_mem,
+ .prot_mem = sctp_sysctl_mem,
.sysctl_rmem = sysctl_sctp_rmem,
.sysctl_wmem = sysctl_sctp_wmem,
- .memory_pressure = &sctp_memory_pressure,
+ .memory_pressure = memory_pressure_sctp,
.enter_memory_pressure = sctp_enter_memory_pressure,
- .memory_allocated = &sctp_memory_allocated,
- .sockets_allocated = &sctp_sockets_allocated,
+ .memory_allocated = memory_allocated_sctp,
+ .sockets_allocated = sockets_allocated_sctp,
};
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
@@ -6863,12 +6882,12 @@ struct proto sctpv6_prot = {
.unhash = sctp_unhash,
.get_port = sctp_get_port,
.obj_size = sizeof(struct sctp6_sock),
- .sysctl_mem = sysctl_sctp_mem,
+ .prot_mem = sctp_sysctl_mem,
.sysctl_rmem = sysctl_sctp_rmem,
.sysctl_wmem = sysctl_sctp_wmem,
- .memory_pressure = &sctp_memory_pressure,
+ .memory_pressure = memory_pressure_sctp,
.enter_memory_pressure = sctp_enter_memory_pressure,
- .memory_allocated = &sctp_memory_allocated,
- .sockets_allocated = &sctp_sockets_allocated,
+ .memory_allocated = memory_allocated_sctp,
+ .sockets_allocated = sockets_allocated_sctp,
};
#endif /* defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) */
--
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 2/8] socket: initial cgroup code.
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>
We aim to control the amount of kernel memory pinned at any
time by tcp sockets. To lay the foundations for this work,
this patch adds a pointer to the kmem_cgroup to the socket
structure.
Signed-off-by: Glauber Costa <glommer@parallels.com>
Acked-by: Kirill A. Shutemov<kirill@shutemov.name>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtsu.com>
CC: David S. Miller <davem@davemloft.net>
CC: Eric W. Biederman <ebiederm@xmission.com>
---
include/linux/memcontrol.h | 15 +++++++++++++++
include/net/sock.h | 2 ++
mm/memcontrol.c | 36 ++++++++++++++++++++++++++++++++++++
net/core/sock.c | 3 +++
4 files changed, 56 insertions(+), 0 deletions(-)
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 343bd76..88aea1b 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -376,5 +376,20 @@ mem_cgroup_print_bad_page(struct page *page)
}
#endif
+#ifdef CONFIG_INET
+struct sock;
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
+void sock_update_memcg(struct sock *sk);
+void sock_release_memcg(struct sock *sk);
+
+#else
+static inline void sock_update_memcg(struct sock *sk)
+{
+}
+static inline void sock_release_memcg(struct sock *sk)
+{
+}
+#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
+#endif /* CONFIG_INET */
#endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/net/sock.h b/include/net/sock.h
index 8e4062f..afe1467 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -228,6 +228,7 @@ struct sock_common {
* @sk_security: used by security modules
* @sk_mark: generic packet mark
* @sk_classid: this socket's cgroup classid
+ * @sk_cgrp: this socket's kernel memory (kmem) cgroup
* @sk_write_pending: a write to stream socket waits to start
* @sk_state_change: callback to indicate change in the state of the sock
* @sk_data_ready: callback to indicate there is data to be processed
@@ -339,6 +340,7 @@ struct sock {
#endif
__u32 sk_mark;
u32 sk_classid;
+ struct mem_cgroup *sk_cgrp;
void (*sk_state_change)(struct sock *sk);
void (*sk_data_ready)(struct sock *sk, int bytes);
void (*sk_write_space)(struct sock *sk);
diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 0871e3f..b1dcba9 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -296,6 +296,42 @@ struct mem_cgroup {
spinlock_t pcp_counter_lock;
};
+/* Writing them here to avoid exposing memcg's inner layout */
+#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
+#ifdef CONFIG_INET
+#include <net/sock.h>
+
+void sock_update_memcg(struct sock *sk)
+{
+ /* right now a socket spends its whole life in the same cgroup */
+ if (sk->sk_cgrp) {
+ WARN_ON(1);
+ return;
+ }
+
+ 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));
+}
+#endif /* CONFIG_INET */
+#endif /* CONFIG_CGROUP_MEM_RES_CTLR_KMEM */
+
/* Stuffs for move charges at task migration. */
/*
* Types of charges to be moved. "move_charge_at_immitgrate" is treated as a
diff --git a/net/core/sock.c b/net/core/sock.c
index bc745d0..5426ba0 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -125,6 +125,7 @@
#include <net/xfrm.h>
#include <linux/ipsec.h>
#include <net/cls_cgroup.h>
+#include <linux/memcontrol.h>
#include <linux/filter.h>
@@ -1141,6 +1142,7 @@ struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
atomic_set(&sk->sk_wmem_alloc, 1);
sock_update_classid(sk);
+ sock_update_memcg(sk);
}
return sk;
@@ -1172,6 +1174,7 @@ static void __sk_free(struct sock *sk)
put_cred(sk->sk_peer_cred);
put_pid(sk->sk_peer_pid);
put_net(sock_net(sk));
+ sock_release_memcg(sk);
sk_prot_free(sk->sk_prot_creator, sk);
}
--
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
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