datapath/dp_dev.c

   1 #include <linux/kernel.h>
   2 #include <linux/netdevice.h>
   3 #include <linux/etherdevice.h>
   4 #include <linux/ethtool.h>
   5 #include <linux/rcupdate.h>
   6 #include <linux/skbuff.h>
   7 #include <linux/workqueue.h>
   8
   9 #include "datapath.h"
  10 #include "dp_dev.h"
  11
  12 struct datapath *dp_dev_get_dp(struct net_device *netdev)
  13 {
  14         return dp_dev_priv(netdev)->dp;
  15 }
  16 EXPORT_SYMBOL(dp_dev_get_dp);
  17
  18 static struct net_device_stats *dp_dev_get_stats(struct net_device *netdev)
  19 {
  20         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  21         return &dp_dev->stats;
  22 }
  23
  24 int dp_dev_recv(struct net_device *netdev, struct sk_buff *skb)
  25 {
  26         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  27         int len;
  28         len = skb->len;
  29         skb->pkt_type = PACKET_HOST;
  30         skb->protocol = eth_type_trans(skb, netdev);
  31         if (in_interrupt())
  32                 netif_rx(skb);
  33         else
  34                 netif_rx_ni(skb);
  35         netdev->last_rx = jiffies;
  36         dp_dev->stats.rx_packets++;
  37         dp_dev->stats.rx_bytes += len;
  38         return len;
  39 }
  40
  41 static int dp_dev_mac_addr(struct net_device *dev, void *p)
  42 {
  43         struct sockaddr *addr = p;
  44
  45         if (!is_valid_ether_addr(addr->sa_data))
  46                 return -EADDRNOTAVAIL;
  47         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
  48         return 0;
  49 }
  50
  51 static int dp_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
  52 {
  53         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  54
  55         /* By orphaning 'skb' we will screw up socket accounting slightly, but
  56          * the effect is limited to the device queue length.  If we don't
  57          * do this, then the sk_buff will be destructed eventually, but it is
  58          * harder to predict when. */
  59         skb_orphan(skb);
  60
  61         /* We are going to modify 'skb', by sticking it on &dp_dev->xmit_queue,
  62          * so we need to have our own clone.  (At any rate, fwd_port_input()
  63          * will need its own clone, so there's no benefit to queuing any other
  64          * way.) */
  65         skb = skb_share_check(skb, GFP_ATOMIC);
  66         if (!skb)
  67                 return 0;
  68
  69         dp_dev->stats.tx_packets++;
  70         dp_dev->stats.tx_bytes += skb->len;
  71
  72         if (skb_queue_len(&dp_dev->xmit_queue) >= netdev->tx_queue_len) {
  73                 /* Queue overflow.  Stop transmitter. */
  74                 netif_stop_queue(netdev);
  75
  76                 /* We won't see all dropped packets individually, so overrun
  77                  * error is appropriate. */
  78                 dp_dev->stats.tx_fifo_errors++;
  79         }
  80         skb_queue_tail(&dp_dev->xmit_queue, skb);
  81         netdev->trans_start = jiffies;
  82
  83         schedule_work(&dp_dev->xmit_work);
  84
  85         return 0;
  86 }
  87
  88 static void dp_dev_do_xmit(struct work_struct *work)
  89 {
  90         struct dp_dev *dp_dev = container_of(work, struct dp_dev, xmit_work);
  91         struct datapath *dp = dp_dev->dp;
  92         struct sk_buff *skb;
  93
  94         while ((skb = skb_dequeue(&dp_dev->xmit_queue)) != NULL) {
  95                 skb_reset_mac_header(skb);
  96                 rcu_read_lock_bh();
  97                 dp_process_received_packet(skb, dp->ports[dp_dev->port_no]);
  98                 rcu_read_unlock_bh();
  99         }
 100         netif_wake_queue(dp_dev->dev);
 101 }
 102
 103 static int dp_dev_open(struct net_device *netdev)
 104 {
 105         netif_start_queue(netdev);
 106         return 0;
 107 }
 108
 109 static int dp_dev_stop(struct net_device *netdev)
 110 {
 111         netif_stop_queue(netdev);
 112         return 0;
 113 }
 114
 115 static void dp_getinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
 116 {
 117         struct dp_dev *dp_dev = dp_dev_priv(netdev);
 118         strcpy(info->driver, "openvswitch");
 119         sprintf(info->bus_info, "%d", dp_dev->dp->dp_idx);
 120 }
 121
 122 static struct ethtool_ops dp_ethtool_ops = {
 123         .get_drvinfo = dp_getinfo,
 124         .get_link = ethtool_op_get_link,
 125         .get_sg = ethtool_op_get_sg,
 126         .get_tx_csum = ethtool_op_get_tx_csum,
 127         .get_tso = ethtool_op_get_tso,
 128 };
 129
 130 static void
 131 do_setup(struct net_device *netdev)
 132 {
 133         ether_setup(netdev);
 134
 135         netdev->do_ioctl = dp_ioctl_hook;
 136         netdev->get_stats = dp_dev_get_stats;
 137         netdev->hard_start_xmit = dp_dev_xmit;
 138         netdev->open = dp_dev_open;
 139         SET_ETHTOOL_OPS(netdev, &dp_ethtool_ops);
 140         netdev->stop = dp_dev_stop;
 141         netdev->tx_queue_len = 100;
 142         netdev->set_mac_address = dp_dev_mac_addr;
 143
 144         netdev->flags = IFF_BROADCAST | IFF_MULTICAST;
 145
 146         random_ether_addr(netdev->dev_addr);
 147
 148         /* Set the OUI to the Nicira one. */
 149         netdev->dev_addr[0] = 0x00;
 150         netdev->dev_addr[1] = 0x23;
 151         netdev->dev_addr[2] = 0x20;
 152
 153         /* Set the top bits to indicate random Nicira address. */
 154         netdev->dev_addr[3] |= 0xc0;
 155 }
 156
 157 /* Create a datapath device associated with 'dp'.  If 'dp_name' is null,
 158  * the device name will be of the form 'of<dp_idx>'.  Returns the new device or
 159  * an error code.
 160  *
 161  * Called with RTNL lock and dp_mutex. */
 162 struct net_device *dp_dev_create(struct datapath *dp, const char *dp_name, int port_no)
 163 {
 164         struct dp_dev *dp_dev;
 165         struct net_device *netdev;
 166         char dev_name[IFNAMSIZ];
 167         int err;
 168
 169         if (dp_name) {
 170                 if (strlen(dp_name) >= IFNAMSIZ)
 171                         return ERR_PTR(-EINVAL);
 172                 strncpy(dev_name, dp_name, sizeof(dev_name));
 173         } else
 174                 snprintf(dev_name, sizeof dev_name, "of%d", dp->dp_idx);
 175
 176         netdev = alloc_netdev(sizeof(struct dp_dev), dev_name, do_setup);
 177         if (!netdev)
 178                 return ERR_PTR(-ENOMEM);
 179
 180         err = register_netdevice(netdev);
 181         if (err) {
 182                 free_netdev(netdev);
 183                 return ERR_PTR(err);
 184         }
 185
 186         dp_dev = dp_dev_priv(netdev);
 187         dp_dev->dp = dp;
 188         dp_dev->port_no = port_no;
 189         dp_dev->dev = netdev;
 190         skb_queue_head_init(&dp_dev->xmit_queue);
 191         INIT_WORK(&dp_dev->xmit_work, dp_dev_do_xmit);
 192         return netdev;
 193 }
 194
 195 /* Called with RTNL lock and dp_mutex.*/
 196 void dp_dev_destroy(struct net_device *netdev)
 197 {
 198         struct dp_dev *dp_dev = dp_dev_priv(netdev);
 199
 200         netif_tx_disable(netdev);
 201         synchronize_net();
 202         skb_queue_purge(&dp_dev->xmit_queue);
 203         unregister_netdevice(netdev);
 204 }
 205
 206 int is_dp_dev(struct net_device *netdev)
 207 {
 208         return netdev->open == dp_dev_open;
 209 }
 210 EXPORT_SYMBOL(is_dp_dev);