Merge branch 'for-3.5' of ../cgroup into block/for-3.5/core-merged

cgroup/for-3.5 contains the following changes which blk-cgroup needs
to proceed with the on-going cleanup.

* Dynamic addition and removal of cftypes to make config/stat file
  handling modular for policies.

* cgroup removal update to not wait for css references to drain to fix
  blkcg removal hang caused by cfq caching cfqgs.

Pull in cgroup/for-3.5 into block/for-3.5/core.  This causes the
following conflicts in block/blk-cgroup.c.

* 761b3ef50e "cgroup: remove cgroup_subsys argument from callbacks"
  conflicts with blkiocg_pre_destroy() addition and blkiocg_attach()
  removal.  Resolved by removing @subsys from all subsys methods.

* 676f7c8f84 "cgroup: relocate cftype and cgroup_subsys definitions in
  controllers" conflicts with ->pre_destroy() and ->attach() updates
  and removal of modular config.  Resolved by dropping forward
  declarations of the methods and applying updates to the relocated
  blkio_subsys.

* 4baf6e3325 "cgroup: convert all non-memcg controllers to the new
  cftype interface" builds upon the previous item.  Resolved by adding
  ->base_cftypes to the relocated blkio_subsys.

Signed-off-by: Tejun Heo <tj@kernel.org>

6 files changed, 280 insertions, 29 deletions

diff --git a/net/sched/Kconfig b/net/sched/Kconfig
index 2590e91b3289..75b58f81d53d 100644
--- a/net/sched/Kconfig
+++ b/net/sched/Kconfig
@@ -260,6 +260,32 @@ config NET_SCH_INGRESS
           To compile this code as a module, choose M here: the
           module will be called sch_ingress.
 
+config NET_SCH_PLUG
+        tristate "Plug network traffic until release (PLUG)"
+        ---help---
+
+          This queuing discipline allows userspace to plug/unplug a network
+          output queue, using the netlink interface.  When it receives an
+          enqueue command it inserts a plug into the outbound queue that
+          causes following packets to enqueue until a dequeue command arrives
+          over netlink, causing the plug to be removed and resuming the normal
+          packet flow.
+
+          This module also provides a generic "network output buffering"
+          functionality (aka output commit), wherein upon arrival of a dequeue
+          command, only packets up to the first plug are released for delivery.
+          The Remus HA project uses this module to enable speculative execution
+          of virtual machines by allowing the generated network output to be rolled
+          back if needed.
+
+          For more information, please refer to http://wiki.xensource.com/xenwiki/Remus
+
+          Say Y here if you are using this kernel for Xen dom0 and
+          want to protect Xen guests with Remus.
+
+          To compile this code as a module, choose M here: the
+          module will be called sch_plug.
+
 comment "Classification"
 
 config NET_CLS
diff --git a/net/sched/Makefile b/net/sched/Makefile
index dc5889c0a15a..8cdf4e2b51d3 100644
--- a/net/sched/Makefile
+++ b/net/sched/Makefile
@@ -33,6 +33,7 @@ obj-$(CONFIG_NET_SCH_MULTIQ)	+= sch_multiq.o
 obj-$(CONFIG_NET_SCH_ATM)       += sch_atm.o
 obj-$(CONFIG_NET_SCH_NETEM)     += sch_netem.o
 obj-$(CONFIG_NET_SCH_DRR)       += sch_drr.o
+obj-$(CONFIG_NET_SCH_PLUG)      += sch_plug.o
 obj-$(CONFIG_NET_SCH_MQPRIO)    += sch_mqprio.o
 obj-$(CONFIG_NET_SCH_CHOKE)     += sch_choke.o
 obj-$(CONFIG_NET_SCH_QFQ)       += sch_qfq.o
diff --git a/net/sched/cls_cgroup.c b/net/sched/cls_cgroup.c
index f84fdc3a7f27..7743ea8d1d38 100644
--- a/net/sched/cls_cgroup.c
+++ b/net/sched/cls_cgroup.c
@@ -22,23 +22,6 @@
 #include <net/sock.h>
 #include <net/cls_cgroup.h>
 
-static struct cgroup_subsys_state *cgrp_create(struct cgroup_subsys *ss,
-                                               struct cgroup *cgrp);
-static void cgrp_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp);
-static int cgrp_populate(struct cgroup_subsys *ss, struct cgroup *cgrp);
-
-struct cgroup_subsys net_cls_subsys = {
-        .name           = "net_cls",
-        .create         = cgrp_create,
-        .destroy        = cgrp_destroy,
-        .populate       = cgrp_populate,
-#ifdef CONFIG_NET_CLS_CGROUP
-        .subsys_id      = net_cls_subsys_id,
-#endif
-        .module         = THIS_MODULE,
-};
-
-
 static inline struct cgroup_cls_state *cgrp_cls_state(struct cgroup *cgrp)
 {
         return container_of(cgroup_subsys_state(cgrp, net_cls_subsys_id),
@@ -51,8 +34,7 @@ static inline struct cgroup_cls_state *task_cls_state(struct task_struct *p)
                             struct cgroup_cls_state, css);
 }
 
-static struct cgroup_subsys_state *cgrp_create(struct cgroup_subsys *ss,
-                                                 struct cgroup *cgrp)
+static struct cgroup_subsys_state *cgrp_create(struct cgroup *cgrp)
 {
         struct cgroup_cls_state *cs;
 
@@ -66,7 +48,7 @@ static struct cgroup_subsys_state *cgrp_create(struct cgroup_subsys *ss,
         return &cs->css;
 }
 
-static void cgrp_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
+static void cgrp_destroy(struct cgroup *cgrp)
 {
         kfree(cgrp_cls_state(cgrp));
 }
@@ -88,12 +70,19 @@ static struct cftype ss_files[] = {
                 .read_u64 = read_classid,
                 .write_u64 = write_classid,
         },
+        { }     /* terminate */
 };
 
-static int cgrp_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
-{
-        return cgroup_add_files(cgrp, ss, ss_files, ARRAY_SIZE(ss_files));
-}
+struct cgroup_subsys net_cls_subsys = {
+        .name           = "net_cls",
+        .create         = cgrp_create,
+        .destroy        = cgrp_destroy,
+#ifdef CONFIG_NET_CLS_CGROUP
+        .subsys_id      = net_cls_subsys_id,
+#endif
+        .base_cftypes   = ss_files,
+        .module         = THIS_MODULE,
+};
 
 struct cls_cgroup_head {
         u32                     handle;
diff --git a/net/sched/sch_netem.c b/net/sched/sch_netem.c
index e83d61ca78ca..5da548fa7ae9 100644
--- a/net/sched/sch_netem.c
+++ b/net/sched/sch_netem.c
@@ -501,9 +501,8 @@ tfifo_dequeue:
 
                 /* if more time remaining? */
                 if (cb->time_to_send <= psched_get_time()) {
-                        skb = qdisc_dequeue_tail(sch);
-                        if (unlikely(!skb))
-                                goto qdisc_dequeue;
+                        __skb_unlink(skb, &sch->q);
+                        sch->qstats.backlog -= qdisc_pkt_len(skb);
 
 #ifdef CONFIG_NET_CLS_ACT
                         /*
@@ -539,7 +538,6 @@ deliver:
                 qdisc_watchdog_schedule(&q->watchdog, cb->time_to_send);
         }
 
-qdisc_dequeue:
         if (q->qdisc) {
                 skb = q->qdisc->ops->dequeue(q->qdisc);
                 if (skb)
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");
diff --git a/net/sched/sch_sfq.c b/net/sched/sch_sfq.c
index 60d47180f043..02a21abea65e 100644
--- a/net/sched/sch_sfq.c
+++ b/net/sched/sch_sfq.c
@@ -469,11 +469,15 @@ enqueue:
         if (slot->qlen == 1) {          /* The flow is new */
                 if (q->tail == NULL) {  /* It is the first flow */
                         slot->next = x;
-                        q->tail = slot;
                 } else {
                         slot->next = q->tail->next;
                         q->tail->next = x;
                 }
+                /* We put this flow at the end of our flow list.
+                 * This might sound unfair for a new flow to wait after old ones,
+                 * but we could endup servicing new flows only, and freeze old ones.
+                 */
+                q->tail = slot;
                 /* We could use a bigger initial quantum for new flows */
                 slot->allot = q->scaled_quantum;
         }