drivers/net/ifb.c

   1 /* drivers/net/ifb.c:
   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
  11         dropping.
  12
  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.
  24
  25         Authors:        Jamal Hadi Salim (2005)
  26
  27 */
  28
  29
  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/interrupt.h>
  36 #include <linux/moduleparam.h>
  37 #include <net/pkt_sched.h>
  38 #include <net/net_namespace.h>
  39
  40 #define TX_Q_LIMIT    32
  41 struct ifb_private {
  42         struct tasklet_struct   ifb_tasklet;
  43         int     tasklet_pending;
  44         struct sk_buff_head     rq;
  45         struct sk_buff_head     tq;
  46 };
  47
  48 static int numifbs = 2;
  49
  50 static void ri_tasklet(unsigned long dev);
  51 static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev);
  52 static int ifb_open(struct net_device *dev);
  53 static int ifb_close(struct net_device *dev);
  54
  55 static void ri_tasklet(unsigned long dev)
  56 {
  57
  58         struct net_device *_dev = (struct net_device *)dev;
  59         struct ifb_private *dp = netdev_priv(_dev);
  60         struct net_device_stats *stats = &_dev->stats;
  61         struct netdev_queue *txq;
  62         struct sk_buff *skb;
  63
  64         txq = netdev_get_tx_queue(_dev, 0);
  65         if ((skb = skb_peek(&dp->tq)) == NULL) {
  66                 if (__netif_tx_trylock(txq)) {
  67                         skb_queue_splice_tail_init(&dp->rq, &dp->tq);
  68                         __netif_tx_unlock(txq);
  69                 } else {
  70                         /* reschedule */
  71                         goto resched;
  72                 }
  73         }
  74
  75         while ((skb = __skb_dequeue(&dp->tq)) != NULL) {
  76                 u32 from = G_TC_FROM(skb->tc_verd);
  77
  78                 skb->tc_verd = 0;
  79                 skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
  80                 stats->tx_packets++;
  81                 stats->tx_bytes +=skb->len;
  82
  83                 rcu_read_lock();
  84                 skb->dev = dev_get_by_index_rcu(&init_net, skb->skb_iif);
  85                 if (!skb->dev) {
  86                         rcu_read_unlock();
  87                         dev_kfree_skb(skb);
  88                         stats->tx_dropped++;
  89                         if (skb_queue_len(&dp->tq) != 0)
  90                                 goto resched;
  91                         break;
  92                 }
  93                 rcu_read_unlock();
  94                 skb->skb_iif = _dev->ifindex;
  95
  96                 if (from & AT_EGRESS) {
  97                         dev_queue_xmit(skb);
  98                 } else if (from & AT_INGRESS) {
  99                         skb_pull(skb, skb->dev->hard_header_len);
 100                         netif_receive_skb(skb);
 101                 } else
 102                         BUG();
 103         }
 104
 105         if (__netif_tx_trylock(txq)) {
 106                 if ((skb = skb_peek(&dp->rq)) == NULL) {
 107                         dp->tasklet_pending = 0;
 108                         if (netif_queue_stopped(_dev))
 109                                 netif_wake_queue(_dev);
 110                 } else {
 111                         __netif_tx_unlock(txq);
 112                         goto resched;
 113                 }
 114                 __netif_tx_unlock(txq);
 115         } else {
 116 resched:
 117                 dp->tasklet_pending = 1;
 118                 tasklet_schedule(&dp->ifb_tasklet);
 119         }
 120
 121 }
 122
 123 static const struct net_device_ops ifb_netdev_ops = {
 124         .ndo_open       = ifb_open,
 125         .ndo_stop       = ifb_close,
 126         .ndo_start_xmit = ifb_xmit,
 127         .ndo_validate_addr = eth_validate_addr,
 128 };
 129
 130 #define IFB_FEATURES (NETIF_F_NO_CSUM | NETIF_F_SG  | NETIF_F_FRAGLIST  | \
 131                       NETIF_F_TSO_ECN | NETIF_F_TSO | NETIF_F_TSO6      | \
 132                       NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_TX)
 133
 134 static void ifb_setup(struct net_device *dev)
 135 {
 136         /* Initialize the device structure. */
 137         dev->destructor = free_netdev;
 138         dev->netdev_ops = &ifb_netdev_ops;
 139
 140         /* Fill in device structure with ethernet-generic values. */
 141         ether_setup(dev);
 142         dev->tx_queue_len = TX_Q_LIMIT;
 143
 144         dev->features |= IFB_FEATURES;
 145         dev->vlan_features |= IFB_FEATURES;
 146
 147         dev->flags |= IFF_NOARP;
 148         dev->flags &= ~IFF_MULTICAST;
 149         dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
 150         random_ether_addr(dev->dev_addr);
 151 }
 152
 153 static netdev_tx_t ifb_xmit(struct sk_buff *skb, struct net_device *dev)
 154 {
 155         struct ifb_private *dp = netdev_priv(dev);
 156         struct net_device_stats *stats = &dev->stats;
 157         u32 from = G_TC_FROM(skb->tc_verd);
 158
 159         stats->rx_packets++;
 160         stats->rx_bytes+=skb->len;
 161
 162         if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->skb_iif) {
 163                 dev_kfree_skb(skb);
 164                 stats->rx_dropped++;
 165                 return NETDEV_TX_OK;
 166         }
 167
 168         if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
 169                 netif_stop_queue(dev);
 170         }
 171
 172         __skb_queue_tail(&dp->rq, skb);
 173         if (!dp->tasklet_pending) {
 174                 dp->tasklet_pending = 1;
 175                 tasklet_schedule(&dp->ifb_tasklet);
 176         }
 177
 178         return NETDEV_TX_OK;
 179 }
 180
 181 static int ifb_close(struct net_device *dev)
 182 {
 183         struct ifb_private *dp = netdev_priv(dev);
 184
 185         tasklet_kill(&dp->ifb_tasklet);
 186         netif_stop_queue(dev);
 187         __skb_queue_purge(&dp->rq);
 188         __skb_queue_purge(&dp->tq);
 189         return 0;
 190 }
 191
 192 static int ifb_open(struct net_device *dev)
 193 {
 194         struct ifb_private *dp = netdev_priv(dev);
 195
 196         tasklet_init(&dp->ifb_tasklet, ri_tasklet, (unsigned long)dev);
 197         __skb_queue_head_init(&dp->rq);
 198         __skb_queue_head_init(&dp->tq);
 199         netif_start_queue(dev);
 200
 201         return 0;
 202 }
 203
 204 static int ifb_validate(struct nlattr *tb[], struct nlattr *data[])
 205 {
 206         if (tb[IFLA_ADDRESS]) {
 207                 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
 208                         return -EINVAL;
 209                 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
 210                         return -EADDRNOTAVAIL;
 211         }
 212         return 0;
 213 }
 214
 215 static struct rtnl_link_ops ifb_link_ops __read_mostly = {
 216         .kind           = "ifb",
 217         .priv_size      = sizeof(struct ifb_private),
 218         .setup          = ifb_setup,
 219         .validate       = ifb_validate,
 220 };
 221
 222 /* Number of ifb devices to be set up by this module. */
 223 module_param(numifbs, int, 0);
 224 MODULE_PARM_DESC(numifbs, "Number of ifb devices");
 225
 226 static int __init ifb_init_one(int index)
 227 {
 228         struct net_device *dev_ifb;
 229         int err;
 230
 231         dev_ifb = alloc_netdev(sizeof(struct ifb_private),
 232                                  "ifb%d", ifb_setup);
 233
 234         if (!dev_ifb)
 235                 return -ENOMEM;
 236
 237         dev_ifb->rtnl_link_ops = &ifb_link_ops;
 238         err = register_netdevice(dev_ifb);
 239         if (err < 0)
 240                 goto err;
 241
 242         return 0;
 243
 244 err:
 245         free_netdev(dev_ifb);
 246         return err;
 247 }
 248
 249 static int __init ifb_init_module(void)
 250 {
 251         int i, err;
 252
 253         rtnl_lock();
 254         err = __rtnl_link_register(&ifb_link_ops);
 255
 256         for (i = 0; i < numifbs && !err; i++)
 257                 err = ifb_init_one(i);
 258         if (err)
 259                 __rtnl_link_unregister(&ifb_link_ops);
 260         rtnl_unlock();
 261
 262         return err;
 263 }
 264
 265 static void __exit ifb_cleanup_module(void)
 266 {
 267         rtnl_link_unregister(&ifb_link_ops);
 268 }
 269
 270 module_init(ifb_init_module);
 271 module_exit(ifb_cleanup_module);
 272 MODULE_LICENSE("GPL");
 273 MODULE_AUTHOR("Jamal Hadi Salim");
 274 MODULE_ALIAS_RTNL_LINK("ifb");