2 * sch_plug.c Queue traffic until an explicit release command
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version
7 * 2 of the License, or (at your option) any later version.
9 * There are two ways to use this qdisc:
10 * 1. A simple "instantaneous" plug/unplug operation, by issuing an alternating
11 * sequence of TCQ_PLUG_BUFFER & TCQ_PLUG_RELEASE_INDEFINITE commands.
13 * 2. For network output buffering (a.k.a output commit) functionality.
14 * Output commit property is commonly used by applications using checkpoint
15 * based fault-tolerance to ensure that the checkpoint from which a system
16 * is being restored is consistent w.r.t outside world.
18 * Consider for e.g. Remus - a Virtual Machine checkpointing system,
19 * wherein a VM is checkpointed, say every 50ms. The checkpoint is replicated
20 * asynchronously to the backup host, while the VM continues executing the
21 * next epoch speculatively.
23 * The following is a typical sequence of output buffer operations:
24 * 1.At epoch i, start_buffer(i)
25 * 2. At end of epoch i (i.e. after 50ms):
26 * 2.1 Stop VM and take checkpoint(i).
27 * 2.2 start_buffer(i+1) and Resume VM
28 * 3. While speculatively executing epoch(i+1), asynchronously replicate
29 * checkpoint(i) to backup host.
30 * 4. When checkpoint_ack(i) is received from backup, release_buffer(i)
31 * Thus, this Qdisc would receive the following sequence of commands:
32 * TCQ_PLUG_BUFFER (epoch i)
33 * .. TCQ_PLUG_BUFFER (epoch i+1)
34 * ....TCQ_PLUG_RELEASE_ONE (epoch i)
35 * ......TCQ_PLUG_BUFFER (epoch i+2)
39 #include <linux/module.h>
40 #include <linux/types.h>
41 #include <linux/kernel.h>
42 #include <linux/errno.h>
43 #include <linux/netdevice.h>
44 #include <linux/skbuff.h>
45 #include <net/pkt_sched.h>
48 * State of the queue, when used for network output buffering:
50 * plug(i+1) plug(i) head
51 * ------------------+--------------------+---------------->
54 * pkts_current_epoch| pkts_last_epoch |pkts_to_release
55 * ----------------->|<--------+--------->|+--------------->
60 struct plug_sched_data
{
61 /* If true, the dequeue function releases all packets
62 * from head to end of the queue. The queue turns into
63 * a pass-through queue for newly arriving packets.
65 bool unplug_indefinite
;
69 /* Queue Limit in bytes */
72 /* Number of packets (output) from the current speculatively
75 u32 pkts_current_epoch
;
77 /* Number of packets corresponding to the recently finished
78 * epoch. These will be released when we receive a
79 * TCQ_PLUG_RELEASE_ONE command. This command is typically
80 * issued after committing a checkpoint at the target.
85 * Number of packets from the head of the queue, that can
86 * be released (committed checkpoint).
91 static int plug_enqueue(struct sk_buff
*skb
, struct Qdisc
*sch
)
93 struct plug_sched_data
*q
= qdisc_priv(sch
);
95 if (likely(sch
->qstats
.backlog
+ skb
->len
<= q
->limit
)) {
96 if (!q
->unplug_indefinite
)
97 q
->pkts_current_epoch
++;
98 return qdisc_enqueue_tail(skb
, sch
);
101 return qdisc_drop(skb
, sch
);
104 static struct sk_buff
*plug_dequeue(struct Qdisc
*sch
)
106 struct plug_sched_data
*q
= qdisc_priv(sch
);
111 if (!q
->unplug_indefinite
) {
112 if (!q
->pkts_to_release
) {
113 /* No more packets to dequeue. Block the queue
114 * and wait for the next release command.
119 q
->pkts_to_release
--;
122 return qdisc_dequeue_head(sch
);
125 static int plug_init(struct Qdisc
*sch
, struct nlattr
*opt
)
127 struct plug_sched_data
*q
= qdisc_priv(sch
);
129 q
->pkts_current_epoch
= 0;
130 q
->pkts_last_epoch
= 0;
131 q
->pkts_to_release
= 0;
132 q
->unplug_indefinite
= false;
135 q
->limit
= qdisc_dev(sch
)->tx_queue_len
136 * psched_mtu(qdisc_dev(sch
));
138 struct tc_plug_qopt
*ctl
= nla_data(opt
);
140 if (nla_len(opt
) < sizeof(*ctl
))
143 q
->limit
= ctl
->limit
;
150 /* Receives 4 types of messages:
151 * TCQ_PLUG_BUFFER: Inset a plug into the queue and
152 * buffer any incoming packets
153 * TCQ_PLUG_RELEASE_ONE: Dequeue packets from queue head
154 * to beginning of the next plug.
155 * TCQ_PLUG_RELEASE_INDEFINITE: Dequeue all packets from queue.
156 * Stop buffering packets until the next TCQ_PLUG_BUFFER
157 * command is received (just act as a pass-thru queue).
158 * TCQ_PLUG_LIMIT: Increase/decrease queue size
160 static int plug_change(struct Qdisc
*sch
, struct nlattr
*opt
)
162 struct plug_sched_data
*q
= qdisc_priv(sch
);
163 struct tc_plug_qopt
*msg
;
169 if (nla_len(opt
) < sizeof(*msg
))
172 switch (msg
->action
) {
173 case TCQ_PLUG_BUFFER
:
174 /* Save size of the current buffer */
175 q
->pkts_last_epoch
= q
->pkts_current_epoch
;
176 q
->pkts_current_epoch
= 0;
177 if (q
->unplug_indefinite
)
179 q
->unplug_indefinite
= false;
181 case TCQ_PLUG_RELEASE_ONE
:
182 /* Add packets from the last complete buffer to the
183 * packets to be released set.
185 q
->pkts_to_release
+= q
->pkts_last_epoch
;
186 q
->pkts_last_epoch
= 0;
187 q
->throttled
= false;
188 netif_schedule_queue(sch
->dev_queue
);
190 case TCQ_PLUG_RELEASE_INDEFINITE
:
191 q
->unplug_indefinite
= true;
192 q
->pkts_to_release
= 0;
193 q
->pkts_last_epoch
= 0;
194 q
->pkts_current_epoch
= 0;
195 q
->throttled
= false;
196 netif_schedule_queue(sch
->dev_queue
);
199 /* Limit is supplied in bytes */
200 q
->limit
= msg
->limit
;
209 static struct Qdisc_ops plug_qdisc_ops __read_mostly
= {
211 .priv_size
= sizeof(struct plug_sched_data
),
212 .enqueue
= plug_enqueue
,
213 .dequeue
= plug_dequeue
,
214 .peek
= qdisc_peek_head
,
216 .change
= plug_change
,
217 .reset
= qdisc_reset_queue
,
218 .owner
= THIS_MODULE
,
221 static int __init
plug_module_init(void)
223 return register_qdisc(&plug_qdisc_ops
);
226 static void __exit
plug_module_exit(void)
228 unregister_qdisc(&plug_qdisc_ops
);
230 module_init(plug_module_init
)
231 module_exit(plug_module_exit
)
232 MODULE_LICENSE("GPL");