]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/net/ifb.c
net: rename skb->iif to skb->skb_iif
[net-next-2.6.git] / drivers / net / ifb.c
CommitLineData
6aa20a22 1/* drivers/net/ifb.c:
253af423
JHS
2
3 The purpose of this driver is to provide a device that allows
4 for sharing of resources:
5
6 1) qdiscs/policies that are per device as opposed to system wide.
7 ifb allows for a device which can be redirected to thus providing
8 an impression of sharing.
9
10 2) Allows for queueing incoming traffic for shaping instead of
6aa20a22
JG
11 dropping.
12
253af423
JHS
13 The original concept is based on what is known as the IMQ
14 driver initially written by Martin Devera, later rewritten
15 by Patrick McHardy and then maintained by Andre Correa.
16
17 You need the tc action mirror or redirect to feed this device
18 packets.
19
20 This program is free software; you can redistribute it and/or
21 modify it under the terms of the GNU General Public License
22 as published by the Free Software Foundation; either version
23 2 of the License, or (at your option) any later version.
6aa20a22 24
253af423 25 Authors: Jamal Hadi Salim (2005)
6aa20a22 26
253af423
JHS
27*/
28
29
253af423
JHS
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/netdevice.h>
33#include <linux/etherdevice.h>
34#include <linux/init.h>
35#include <linux/moduleparam.h>
6aa20a22 36#include <net/pkt_sched.h>
881d966b 37#include <net/net_namespace.h>
253af423
JHS
38
39#define TX_TIMEOUT (2*HZ)
6aa20a22 40
253af423
JHS
41#define TX_Q_LIMIT 32
42struct ifb_private {
253af423
JHS
43 struct tasklet_struct ifb_tasklet;
44 int tasklet_pending;
45 /* mostly debug stats leave in for now */
46 unsigned long st_task_enter; /* tasklet entered */
47 unsigned long st_txq_refl_try; /* transmit queue refill attempt */
48 unsigned long st_rxq_enter; /* receive queue entered */
49 unsigned long st_rx2tx_tran; /* receive to trasmit transfers */
50 unsigned long st_rxq_notenter; /*receiveQ not entered, resched */
51 unsigned long st_rx_frm_egr; /* received from egress path */
52 unsigned long st_rx_frm_ing; /* received from ingress path */
53 unsigned long st_rxq_check;
54 unsigned long st_rxq_rsch;
55 struct sk_buff_head rq;
56 struct sk_buff_head tq;
57};
58
35eaa31e 59static int numifbs = 2;
253af423
JHS
60
61static void ri_tasklet(unsigned long dev);
424efe9c 62static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev);
253af423
JHS
63static int ifb_open(struct net_device *dev);
64static int ifb_close(struct net_device *dev);
65
6aa20a22 66static void ri_tasklet(unsigned long dev)
253af423
JHS
67{
68
69 struct net_device *_dev = (struct net_device *)dev;
70 struct ifb_private *dp = netdev_priv(_dev);
09f75cd7 71 struct net_device_stats *stats = &_dev->stats;
c3f26a26 72 struct netdev_queue *txq;
253af423
JHS
73 struct sk_buff *skb;
74
c3f26a26 75 txq = netdev_get_tx_queue(_dev, 0);
253af423
JHS
76 dp->st_task_enter++;
77 if ((skb = skb_peek(&dp->tq)) == NULL) {
78 dp->st_txq_refl_try++;
c3f26a26 79 if (__netif_tx_trylock(txq)) {
253af423
JHS
80 dp->st_rxq_enter++;
81 while ((skb = skb_dequeue(&dp->rq)) != NULL) {
82 skb_queue_tail(&dp->tq, skb);
83 dp->st_rx2tx_tran++;
84 }
c3f26a26 85 __netif_tx_unlock(txq);
253af423
JHS
86 } else {
87 /* reschedule */
88 dp->st_rxq_notenter++;
89 goto resched;
90 }
91 }
92
93 while ((skb = skb_dequeue(&dp->tq)) != NULL) {
94 u32 from = G_TC_FROM(skb->tc_verd);
95
96 skb->tc_verd = 0;
97 skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
98 stats->tx_packets++;
99 stats->tx_bytes +=skb->len;
c01003c2 100
05e8689c 101 rcu_read_lock();
8964be4a 102 skb->dev = dev_get_by_index_rcu(&init_net, skb->skb_iif);
c01003c2 103 if (!skb->dev) {
05e8689c 104 rcu_read_unlock();
c01003c2
PM
105 dev_kfree_skb(skb);
106 stats->tx_dropped++;
107 break;
108 }
05e8689c 109 rcu_read_unlock();
8964be4a 110 skb->skb_iif = _dev->ifindex;
c01003c2 111
253af423
JHS
112 if (from & AT_EGRESS) {
113 dp->st_rx_frm_egr++;
114 dev_queue_xmit(skb);
115 } else if (from & AT_INGRESS) {
253af423 116 dp->st_rx_frm_ing++;
c01003c2 117 skb_pull(skb, skb->dev->hard_header_len);
253af423 118 netif_rx(skb);
c01003c2
PM
119 } else
120 BUG();
253af423
JHS
121 }
122
c3f26a26 123 if (__netif_tx_trylock(txq)) {
253af423
JHS
124 dp->st_rxq_check++;
125 if ((skb = skb_peek(&dp->rq)) == NULL) {
126 dp->tasklet_pending = 0;
127 if (netif_queue_stopped(_dev))
128 netif_wake_queue(_dev);
129 } else {
130 dp->st_rxq_rsch++;
c3f26a26 131 __netif_tx_unlock(txq);
253af423
JHS
132 goto resched;
133 }
c3f26a26 134 __netif_tx_unlock(txq);
253af423
JHS
135 } else {
136resched:
137 dp->tasklet_pending = 1;
138 tasklet_schedule(&dp->ifb_tasklet);
139 }
140
141}
142
8dfcdf34 143static const struct net_device_ops ifb_netdev_ops = {
8dfcdf34
SH
144 .ndo_open = ifb_open,
145 .ndo_stop = ifb_close,
00829823
SH
146 .ndo_start_xmit = ifb_xmit,
147 .ndo_validate_addr = eth_validate_addr,
8dfcdf34
SH
148};
149
9ba2cd65 150static void ifb_setup(struct net_device *dev)
253af423
JHS
151{
152 /* Initialize the device structure. */
9ba2cd65 153 dev->destructor = free_netdev;
8dfcdf34 154 dev->netdev_ops = &ifb_netdev_ops;
253af423
JHS
155
156 /* Fill in device structure with ethernet-generic values. */
157 ether_setup(dev);
158 dev->tx_queue_len = TX_Q_LIMIT;
8dfcdf34 159
253af423
JHS
160 dev->flags |= IFF_NOARP;
161 dev->flags &= ~IFF_MULTICAST;
93f154b5 162 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
253af423
JHS
163 random_ether_addr(dev->dev_addr);
164}
165
424efe9c 166static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
253af423
JHS
167{
168 struct ifb_private *dp = netdev_priv(dev);
09f75cd7 169 struct net_device_stats *stats = &dev->stats;
253af423
JHS
170 u32 from = G_TC_FROM(skb->tc_verd);
171
3136dcb3 172 stats->rx_packets++;
173 stats->rx_bytes+=skb->len;
253af423 174
8964be4a 175 if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->skb_iif) {
253af423
JHS
176 dev_kfree_skb(skb);
177 stats->rx_dropped++;
424efe9c 178 return NETDEV_TX_OK;
253af423
JHS
179 }
180
181 if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
182 netif_stop_queue(dev);
183 }
184
185 dev->trans_start = jiffies;
186 skb_queue_tail(&dp->rq, skb);
187 if (!dp->tasklet_pending) {
188 dp->tasklet_pending = 1;
189 tasklet_schedule(&dp->ifb_tasklet);
190 }
191
424efe9c 192 return NETDEV_TX_OK;
253af423
JHS
193}
194
253af423
JHS
195static int ifb_close(struct net_device *dev)
196{
197 struct ifb_private *dp = netdev_priv(dev);
198
199 tasklet_kill(&dp->ifb_tasklet);
200 netif_stop_queue(dev);
201 skb_queue_purge(&dp->rq);
202 skb_queue_purge(&dp->tq);
203 return 0;
204}
205
206static int ifb_open(struct net_device *dev)
207{
208 struct ifb_private *dp = netdev_priv(dev);
209
210 tasklet_init(&dp->ifb_tasklet, ri_tasklet, (unsigned long)dev);
211 skb_queue_head_init(&dp->rq);
212 skb_queue_head_init(&dp->tq);
213 netif_start_queue(dev);
214
215 return 0;
216}
217
0e06877c
PM
218static int ifb_validate(struct nlattr *tb[], struct nlattr *data[])
219{
220 if (tb[IFLA_ADDRESS]) {
221 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
222 return -EINVAL;
223 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
224 return -EADDRNOTAVAIL;
225 }
226 return 0;
227}
228
9ba2cd65
PM
229static struct rtnl_link_ops ifb_link_ops __read_mostly = {
230 .kind = "ifb",
231 .priv_size = sizeof(struct ifb_private),
232 .setup = ifb_setup,
0e06877c 233 .validate = ifb_validate,
9ba2cd65
PM
234};
235
2d85cba2
PM
236/* Number of ifb devices to be set up by this module. */
237module_param(numifbs, int, 0);
238MODULE_PARM_DESC(numifbs, "Number of ifb devices");
239
253af423
JHS
240static int __init ifb_init_one(int index)
241{
242 struct net_device *dev_ifb;
243 int err;
244
245 dev_ifb = alloc_netdev(sizeof(struct ifb_private),
246 "ifb%d", ifb_setup);
247
248 if (!dev_ifb)
249 return -ENOMEM;
250
9ba2cd65
PM
251 err = dev_alloc_name(dev_ifb, dev_ifb->name);
252 if (err < 0)
253 goto err;
253af423 254
9ba2cd65
PM
255 dev_ifb->rtnl_link_ops = &ifb_link_ops;
256 err = register_netdevice(dev_ifb);
257 if (err < 0)
258 goto err;
94833dfb 259
9ba2cd65 260 return 0;
62b7ffca 261
9ba2cd65
PM
262err:
263 free_netdev(dev_ifb);
264 return err;
6aa20a22 265}
253af423
JHS
266
267static int __init ifb_init_module(void)
6aa20a22 268{
9ba2cd65
PM
269 int i, err;
270
271 rtnl_lock();
272 err = __rtnl_link_register(&ifb_link_ops);
62b7ffca 273
253af423 274 for (i = 0; i < numifbs && !err; i++)
6aa20a22 275 err = ifb_init_one(i);
2d85cba2 276 if (err)
9ba2cd65 277 __rtnl_link_unregister(&ifb_link_ops);
9ba2cd65 278 rtnl_unlock();
253af423
JHS
279
280 return err;
6aa20a22 281}
253af423
JHS
282
283static void __exit ifb_cleanup_module(void)
284{
2d85cba2 285 rtnl_link_unregister(&ifb_link_ops);
253af423
JHS
286}
287
288module_init(ifb_init_module);
289module_exit(ifb_cleanup_module);
290MODULE_LICENSE("GPL");
291MODULE_AUTHOR("Jamal Hadi Salim");
9ba2cd65 292MODULE_ALIAS_RTNL_LINK("ifb");