Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next

Pull networking merge from David Miller:
 "1) Move ixgbe driver over to purely page based buffering on receive.
     From Alexander Duyck.

  2) Add receive packet steering support to e1000e, from Bruce Allan.

  3) Convert TCP MD5 support over to RCU, from Eric Dumazet.

  4) Reduce cpu usage in handling out-of-order TCP packets on modern
     systems, also from Eric Dumazet.

  5) Support the IP{,V6}_UNICAST_IF socket options, making the wine
     folks happy, from Erich Hoover.

  6) Support VLAN trunking from guests in hyperv driver, from Haiyang
     Zhang.

  7) Support byte-queue-limtis in r8169, from Igor Maravic.

  8) Outline code intended for IP_RECVTOS in IP_PKTOPTIONS existed but
     was never properly implemented, Jiri Benc fixed that.

  9) 64-bit statistics support in r8169 and 8139too, from Junchang Wang.

  10) Support kernel side dump filtering by ctmark in netfilter
      ctnetlink, from Pablo Neira Ayuso.

  11) Support byte-queue-limits in gianfar driver, from Paul Gortmaker.

  12) Add new peek socket options to assist with socket migration, from
      Pavel Emelyanov.

  13) Add sch_plug packet scheduler whose queue is controlled by
      userland daemons using explicit freeze and release commands.  From
      Shriram Rajagopalan.

  14) Fix FCOE checksum offload handling on transmit, from Yi Zou."

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next: (1846 commits)
  Fix pppol2tp getsockname()
  Remove printk from rds_sendmsg
  ipv6: fix incorrent ipv6 ipsec packet fragment
  cpsw: Hook up default ndo_change_mtu.
  net: qmi_wwan: fix build error due to cdc-wdm dependecy
  netdev: driver: ethernet: Add TI CPSW driver
  netdev: driver: ethernet: add cpsw address lookup engine support
  phy: add am79c874 PHY support
  mlx4_core: fix race on comm channel
  bonding: send igmp report for its master
  fs_enet: Add MPC5125 FEC support and PHY interface selection
  net: bpf_jit: fix BPF_S_LDX_B_MSH compilation
  net: update the usage of CHECKSUM_UNNECESSARY
  fcoe: use CHECKSUM_UNNECESSARY instead of CHECKSUM_PARTIAL on tx
  net: do not do gso for CHECKSUM_UNNECESSARY in netif_needs_gso
  ixgbe: Fix issues with SR-IOV loopback when flow control is disabled
  net/hyperv: Fix the code handling tx busy
  ixgbe: fix namespace issues when FCoE/DCB is not enabled
  rtlwifi: Remove unused ETH_ADDR_LEN defines
  igbvf: Use ETH_ALEN
  ...

Fix up fairly trivial conflicts in drivers/isdn/gigaset/interface.c and
drivers/net/usb/{Kconfig,qmi_wwan.c} as per David.

1 files changed, 233 insertions, 0 deletions

diff --git a/net/sched/sch_plug.c b/net/sched/sch_plug.c
new file mode 100644
index 000000000000..89f8fcf73f18
--- /dev/null
+++ b/net/sched/sch_plug.c
@@ -0,0 +1,233 @@
+/*
+ * sch_plug.c Queue traffic until an explicit release command
+ *
+ *             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.
+ *
+ * There are two ways to use this qdisc:
+ * 1. A simple "instantaneous" plug/unplug operation, by issuing an alternating
+ *    sequence of TCQ_PLUG_BUFFER & TCQ_PLUG_RELEASE_INDEFINITE commands.
+ *
+ * 2. For network output buffering (a.k.a output commit) functionality.
+ *    Output commit property is commonly used by applications using checkpoint
+ *    based fault-tolerance to ensure that the checkpoint from which a system
+ *    is being restored is consistent w.r.t outside world.
+ *
+ *    Consider for e.g. Remus - a Virtual Machine checkpointing system,
+ *    wherein a VM is checkpointed, say every 50ms. The checkpoint is replicated
+ *    asynchronously to the backup host, while the VM continues executing the
+ *    next epoch speculatively.
+ *
+ *    The following is a typical sequence of output buffer operations:
+ *       1.At epoch i, start_buffer(i)
+ *       2. At end of epoch i (i.e. after 50ms):
+ *          2.1 Stop VM and take checkpoint(i).
+ *          2.2 start_buffer(i+1) and Resume VM
+ *       3. While speculatively executing epoch(i+1), asynchronously replicate
+ *          checkpoint(i) to backup host.
+ *       4. When checkpoint_ack(i) is received from backup, release_buffer(i)
+ *    Thus, this Qdisc would receive the following sequence of commands:
+ *       TCQ_PLUG_BUFFER (epoch i)
+ *       .. TCQ_PLUG_BUFFER (epoch i+1)
+ *       ....TCQ_PLUG_RELEASE_ONE (epoch i)
+ *       ......TCQ_PLUG_BUFFER (epoch i+2)
+ *       ........
+ */
+
+#include <linux/module.h>
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/netdevice.h>
+#include <linux/skbuff.h>
+#include <net/pkt_sched.h>
+
+/*
+ * State of the queue, when used for network output buffering:
+ *
+ *                 plug(i+1)            plug(i)          head
+ * ------------------+--------------------+---------------->
+ *                   |                    |
+ *                   |                    |
+ * pkts_current_epoch| pkts_last_epoch    |pkts_to_release
+ * ----------------->|<--------+--------->|+--------------->
+ *                   v                    v
+ *
+ */
+
+struct plug_sched_data {
+        /* If true, the dequeue function releases all packets
+         * from head to end of the queue. The queue turns into
+         * a pass-through queue for newly arriving packets.
+         */
+        bool unplug_indefinite;
+
+        /* Queue Limit in bytes */
+        u32 limit;
+
+        /* Number of packets (output) from the current speculatively
+         * executing epoch.
+         */
+        u32 pkts_current_epoch;
+
+        /* Number of packets corresponding to the recently finished
+         * epoch. These will be released when we receive a
+         * TCQ_PLUG_RELEASE_ONE command. This command is typically
+         * issued after committing a checkpoint at the target.
+         */
+        u32 pkts_last_epoch;
+
+        /*
+         * Number of packets from the head of the queue, that can
+         * be released (committed checkpoint).
+         */
+        u32 pkts_to_release;
+};
+
+static int plug_enqueue(struct sk_buff *skb, struct Qdisc *sch)
+{
+        struct plug_sched_data *q = qdisc_priv(sch);
+
+        if (likely(sch->qstats.backlog + skb->len <= q->limit)) {
+                if (!q->unplug_indefinite)
+                        q->pkts_current_epoch++;
+                return qdisc_enqueue_tail(skb, sch);
+        }
+
+        return qdisc_reshape_fail(skb, sch);
+}
+
+static struct sk_buff *plug_dequeue(struct Qdisc *sch)
+{
+        struct plug_sched_data *q = qdisc_priv(sch);
+
+        if (qdisc_is_throttled(sch))
+                return NULL;
+
+        if (!q->unplug_indefinite) {
+                if (!q->pkts_to_release) {
+                        /* No more packets to dequeue. Block the queue
+                         * and wait for the next release command.
+                         */
+                        qdisc_throttled(sch);
+                        return NULL;
+                }
+                q->pkts_to_release--;
+        }
+
+        return qdisc_dequeue_head(sch);
+}
+
+static int plug_init(struct Qdisc *sch, struct nlattr *opt)
+{
+        struct plug_sched_data *q = qdisc_priv(sch);
+
+        q->pkts_current_epoch = 0;
+        q->pkts_last_epoch = 0;
+        q->pkts_to_release = 0;
+        q->unplug_indefinite = false;
+
+        if (opt == NULL) {
+                /* We will set a default limit of 100 pkts (~150kB)
+                 * in case tx_queue_len is not available. The
+                 * default value is completely arbitrary.
+                 */
+                u32 pkt_limit = qdisc_dev(sch)->tx_queue_len ? : 100;
+                q->limit = pkt_limit * psched_mtu(qdisc_dev(sch));
+        } else {
+                struct tc_plug_qopt *ctl = nla_data(opt);
+
+                if (nla_len(opt) < sizeof(*ctl))
+                        return -EINVAL;
+
+                q->limit = ctl->limit;
+        }
+
+        qdisc_throttled(sch);
+        return 0;
+}
+
+/* Receives 4 types of messages:
+ * TCQ_PLUG_BUFFER: Inset a plug into the queue and
+ *  buffer any incoming packets
+ * TCQ_PLUG_RELEASE_ONE: Dequeue packets from queue head
+ *   to beginning of the next plug.
+ * TCQ_PLUG_RELEASE_INDEFINITE: Dequeue all packets from queue.
+ *   Stop buffering packets until the next TCQ_PLUG_BUFFER
+ *   command is received (just act as a pass-thru queue).
+ * TCQ_PLUG_LIMIT: Increase/decrease queue size
+ */
+static int plug_change(struct Qdisc *sch, struct nlattr *opt)
+{
+        struct plug_sched_data *q = qdisc_priv(sch);
+        struct tc_plug_qopt *msg;
+
+        if (opt == NULL)
+                return -EINVAL;
+
+        msg = nla_data(opt);
+        if (nla_len(opt) < sizeof(*msg))
+                return -EINVAL;
+
+        switch (msg->action) {
+        case TCQ_PLUG_BUFFER:
+                /* Save size of the current buffer */
+                q->pkts_last_epoch = q->pkts_current_epoch;
+                q->pkts_current_epoch = 0;
+                if (q->unplug_indefinite)
+                        qdisc_throttled(sch);
+                q->unplug_indefinite = false;
+                break;
+        case TCQ_PLUG_RELEASE_ONE:
+                /* Add packets from the last complete buffer to the
+                 * packets to be released set.
+                 */
+                q->pkts_to_release += q->pkts_last_epoch;
+                q->pkts_last_epoch = 0;
+                qdisc_unthrottled(sch);
+                netif_schedule_queue(sch->dev_queue);
+                break;
+        case TCQ_PLUG_RELEASE_INDEFINITE:
+                q->unplug_indefinite = true;
+                q->pkts_to_release = 0;
+                q->pkts_last_epoch = 0;
+                q->pkts_current_epoch = 0;
+                qdisc_unthrottled(sch);
+                netif_schedule_queue(sch->dev_queue);
+                break;
+        case TCQ_PLUG_LIMIT:
+                /* Limit is supplied in bytes */
+                q->limit = msg->limit;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+static struct Qdisc_ops plug_qdisc_ops __read_mostly = {
+        .id          =       "plug",
+        .priv_size   =       sizeof(struct plug_sched_data),
+        .enqueue     =       plug_enqueue,
+        .dequeue     =       plug_dequeue,
+        .peek        =       qdisc_peek_head,
+        .init        =       plug_init,
+        .change      =       plug_change,
+        .owner       =       THIS_MODULE,
+};
+
+static int __init plug_module_init(void)
+{
+        return register_qdisc(&plug_qdisc_ops);
+}
+
+static void __exit plug_module_exit(void)
+{
+        unregister_qdisc(&plug_qdisc_ops);
+}
+module_init(plug_module_init)
+module_exit(plug_module_exit)
+MODULE_LICENSE("GPL");