datapath/dp_dev.c

   1 /*
   2  * Copyright (c) 2009 Nicira Networks.
   3  * Distributed under the terms of the GNU GPL version 2.
   4  *
   5  * Significant portions of this file may be copied from parts of the Linux
   6  * kernel, by Linus Torvalds and others.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/netdevice.h>
  11 #include <linux/etherdevice.h>
  12 #include <linux/ethtool.h>
  13 #include <linux/rcupdate.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/workqueue.h>
  16
  17 #include "datapath.h"
  18 #include "dp_dev.h"
  19
  20 struct pcpu_lstats {
  21         unsigned long rx_packets;
  22         unsigned long rx_bytes;
  23         unsigned long tx_packets;
  24         unsigned long tx_bytes;
  25 };
  26
  27 struct datapath *dp_dev_get_dp(struct net_device *netdev)
  28 {
  29         return dp_dev_priv(netdev)->dp;
  30 }
  31 EXPORT_SYMBOL(dp_dev_get_dp);
  32
  33 static struct net_device_stats *dp_dev_get_stats(struct net_device *netdev)
  34 {
  35         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  36         struct net_device_stats *stats;
  37         int i;
  38
  39         stats = &dp_dev->stats;
  40         memset(stats, 0, sizeof *stats);
  41         for_each_possible_cpu(i) {
  42                 const struct pcpu_lstats *lb_stats;
  43
  44                 lb_stats = per_cpu_ptr(dp_dev->lstats, i);
  45                 stats->rx_bytes   += lb_stats->rx_bytes;
  46                 stats->rx_packets += lb_stats->rx_packets;
  47                 stats->tx_bytes   += lb_stats->tx_bytes;
  48                 stats->tx_packets += lb_stats->tx_packets;
  49         }
  50         return stats;
  51 }
  52
  53 int dp_dev_recv(struct net_device *netdev, struct sk_buff *skb)
  54 {
  55         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  56         struct pcpu_lstats *lb_stats;
  57         int len;
  58         len = skb->len;
  59         skb->pkt_type = PACKET_HOST;
  60         skb->protocol = eth_type_trans(skb, netdev);
  61         if (in_interrupt())
  62                 netif_rx(skb);
  63         else
  64                 netif_rx_ni(skb);
  65         netdev->last_rx = jiffies;
  66         lb_stats = per_cpu_ptr(dp_dev->lstats, smp_processor_id());
  67         lb_stats->rx_packets++;
  68         lb_stats->rx_bytes += len;
  69         return len;
  70 }
  71
  72 static int dp_dev_mac_addr(struct net_device *dev, void *p)
  73 {
  74         struct sockaddr *addr = p;
  75
  76         if (!is_valid_ether_addr(addr->sa_data))
  77                 return -EADDRNOTAVAIL;
  78         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
  79         return 0;
  80 }
  81
  82 /* Not reentrant (because it is called with BHs disabled), but may be called
  83  * simultaneously on different CPUs. */
  84 static int dp_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
  85 {
  86         struct dp_dev *dp_dev = dp_dev_priv(netdev);
  87         struct pcpu_lstats *lb_stats;
  88
  89         /* dp_process_received_packet() needs its own clone. */
  90         skb = skb_share_check(skb, GFP_ATOMIC);
  91         if (!skb)
  92                 return 0;
  93
  94         lb_stats = per_cpu_ptr(dp_dev->lstats, smp_processor_id());
  95         lb_stats->tx_packets++;
  96         lb_stats->tx_bytes += skb->len;
  97
  98         skb_reset_mac_header(skb);
  99         rcu_read_lock_bh();
 100         dp_process_received_packet(skb, dp_dev->dp->ports[dp_dev->port_no]);
 101         rcu_read_unlock_bh();
 102
 103         return 0;
 104 }
 105
 106 static int dp_dev_open(struct net_device *netdev)
 107 {
 108         netif_start_queue(netdev);
 109         return 0;
 110 }
 111
 112 static int dp_dev_stop(struct net_device *netdev)
 113 {
 114         netif_stop_queue(netdev);
 115         return 0;
 116 }
 117
 118 static void dp_getinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
 119 {
 120         struct dp_dev *dp_dev = dp_dev_priv(netdev);
 121         strcpy(info->driver, "openvswitch");
 122         sprintf(info->bus_info, "%d", dp_dev->dp->dp_idx);
 123 }
 124
 125 static struct ethtool_ops dp_ethtool_ops = {
 126         .get_drvinfo = dp_getinfo,
 127         .get_link = ethtool_op_get_link,
 128         .get_sg = ethtool_op_get_sg,
 129         .get_tx_csum = ethtool_op_get_tx_csum,
 130         .get_tso = ethtool_op_get_tso,
 131 };
 132
 133 static int dp_dev_change_mtu(struct net_device *dev, int new_mtu)
 134 {
 135         if (new_mtu < 68 || new_mtu > dp_min_mtu(dp_dev_get_dp(dev)))
 136                 return -EINVAL;
 137
 138         dev->mtu = new_mtu;
 139         return 0;
 140 }
 141
 142 static int dp_dev_init(struct net_device *netdev)
 143 {
 144         struct dp_dev *dp_dev = dp_dev_priv(netdev);
 145
 146         dp_dev->lstats = alloc_percpu(struct pcpu_lstats);
 147         if (!dp_dev->lstats)
 148                 return -ENOMEM;
 149
 150         return 0;
 151 }
 152
 153 static void dp_dev_free(struct net_device *netdev)
 154 {
 155         struct dp_dev *dp_dev = dp_dev_priv(netdev);
 156
 157         free_percpu(dp_dev->lstats);
 158         free_netdev(netdev);
 159 }
 160
 161 static void
 162 do_setup(struct net_device *netdev)
 163 {
 164         ether_setup(netdev);
 165
 166         netdev->do_ioctl = dp_ioctl_hook;
 167         netdev->get_stats = dp_dev_get_stats;
 168         netdev->hard_start_xmit = dp_dev_xmit;
 169         netdev->open = dp_dev_open;
 170         SET_ETHTOOL_OPS(netdev, &dp_ethtool_ops);
 171         netdev->stop = dp_dev_stop;
 172         netdev->tx_queue_len = 0;
 173         netdev->set_mac_address = dp_dev_mac_addr;
 174         netdev->change_mtu = dp_dev_change_mtu;
 175         netdev->init = dp_dev_init;
 176         netdev->destructor = dp_dev_free;
 177
 178         netdev->flags = IFF_BROADCAST | IFF_MULTICAST;
 179         netdev->features = NETIF_F_LLTX; /* XXX other features? */
 180
 181         random_ether_addr(netdev->dev_addr);
 182
 183         /* Set the OUI to the Nicira one. */
 184         netdev->dev_addr[0] = 0x00;
 185         netdev->dev_addr[1] = 0x23;
 186         netdev->dev_addr[2] = 0x20;
 187
 188         /* Set the top bits to indicate random Nicira address. */
 189         netdev->dev_addr[3] |= 0xc0;
 190 }
 191
 192 /* Create a datapath device associated with 'dp'.  If 'dp_name' is null,
 193  * the device name will be of the form 'of<dp_idx>'.  Returns the new device or
 194  * an error code.
 195  *
 196  * Called with RTNL lock and dp_mutex. */
 197 struct net_device *dp_dev_create(struct datapath *dp, const char *dp_name, int port_no)
 198 {
 199         struct dp_dev *dp_dev;
 200         struct net_device *netdev;
 201         char dev_name[IFNAMSIZ];
 202         int err;
 203
 204         if (dp_name) {
 205                 if (strlen(dp_name) >= IFNAMSIZ)
 206                         return ERR_PTR(-EINVAL);
 207                 strncpy(dev_name, dp_name, sizeof(dev_name));
 208         } else
 209                 snprintf(dev_name, sizeof dev_name, "of%d", dp->dp_idx);
 210
 211         netdev = alloc_netdev(sizeof(struct dp_dev), dev_name, do_setup);
 212         if (!netdev)
 213                 return ERR_PTR(-ENOMEM);
 214
 215         err = register_netdevice(netdev);
 216         if (err) {
 217                 free_netdev(netdev);
 218                 return ERR_PTR(err);
 219         }
 220
 221         dp_dev = dp_dev_priv(netdev);
 222         dp_dev->dp = dp;
 223         dp_dev->port_no = port_no;
 224         dp_dev->dev = netdev;
 225         return netdev;
 226 }
 227
 228 /* Called with RTNL lock and dp_mutex.*/
 229 void dp_dev_destroy(struct net_device *netdev)
 230 {
 231         unregister_netdevice(netdev);
 232 }
 233
 234 int is_dp_dev(struct net_device *netdev)
 235 {
 236         return netdev->open == dp_dev_open;
 237 }
 238 EXPORT_SYMBOL(is_dp_dev);