datapath/vport-internal_dev.c

   1 /*
   2  * Copyright (c) 2009, 2010 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/percpu.h>
  14 #include <linux/preempt.h>
  15 #include <linux/rcupdate.h>
  16 #include <linux/skbuff.h>
  17 #include <linux/workqueue.h>
  18
  19 #include "datapath.h"
  20 #include "vport-internal_dev.h"
  21 #include "vport-netdev.h"
  22
  23 struct pcpu_lstats {
  24         unsigned long rx_packets;
  25         unsigned long rx_bytes;
  26         unsigned long tx_packets;
  27         unsigned long tx_bytes;
  28 };
  29
  30 struct internal_dev {
  31         struct vport *vport;
  32
  33         struct net_device_stats stats;
  34         struct pcpu_lstats *lstats;
  35 };
  36
  37 struct vport_ops internal_vport_ops;
  38
  39 static inline struct internal_dev *internal_dev_priv(struct net_device *netdev)
  40 {
  41         return netdev_priv(netdev);
  42 }
  43
  44 static struct net_device_stats *internal_dev_get_stats(struct net_device *netdev)
  45 {
  46         struct internal_dev *internal_dev = internal_dev_priv(netdev);
  47         struct net_device_stats *stats;
  48         int i;
  49
  50         stats = &internal_dev->stats;
  51         memset(stats, 0, sizeof(struct net_device_stats));
  52         for_each_possible_cpu(i) {
  53                 const struct pcpu_lstats *lb_stats;
  54
  55                 lb_stats = per_cpu_ptr(internal_dev->lstats, i);
  56                 stats->rx_bytes   += lb_stats->rx_bytes;
  57                 stats->rx_packets += lb_stats->rx_packets;
  58                 stats->tx_bytes   += lb_stats->tx_bytes;
  59                 stats->tx_packets += lb_stats->tx_packets;
  60         }
  61         return stats;
  62 }
  63
  64 static int internal_dev_mac_addr(struct net_device *dev, void *p)
  65 {
  66         struct sockaddr *addr = p;
  67
  68         if (!is_valid_ether_addr(addr->sa_data))
  69                 return -EADDRNOTAVAIL;
  70         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
  71         return 0;
  72 }
  73
  74 /* Not reentrant (because it is called with BHs disabled), but may be called
  75  * simultaneously on different CPUs. */
  76 static int internal_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
  77 {
  78         struct internal_dev *internal_dev = internal_dev_priv(netdev);
  79         struct vport *vport = internal_dev_get_vport(netdev);
  80         struct pcpu_lstats *lb_stats;
  81
  82         /* We need our own clone. */
  83         skb = skb_share_check(skb, GFP_ATOMIC);
  84         if (!skb)
  85                 return 0;
  86
  87         lb_stats = per_cpu_ptr(internal_dev->lstats, smp_processor_id());
  88         lb_stats->tx_packets++;
  89         lb_stats->tx_bytes += skb->len;
  90
  91         skb_reset_mac_header(skb);
  92         rcu_read_lock_bh();
  93         vport_receive(vport, skb);
  94         rcu_read_unlock_bh();
  95
  96         return 0;
  97 }
  98
  99 static int internal_dev_open(struct net_device *netdev)
 100 {
 101         netif_start_queue(netdev);
 102         return 0;
 103 }
 104
 105 static int internal_dev_stop(struct net_device *netdev)
 106 {
 107         netif_stop_queue(netdev);
 108         return 0;
 109 }
 110
 111 static void internal_dev_getinfo(struct net_device *netdev,
 112                                  struct ethtool_drvinfo *info)
 113 {
 114         struct dp_port *dp_port = vport_get_dp_port(internal_dev_get_vport(netdev));
 115
 116         strcpy(info->driver, "openvswitch");
 117         if (dp_port)
 118                 sprintf(info->bus_info, "%d.%d", dp_port->dp->dp_idx, dp_port->port_no);
 119 }
 120
 121 static struct ethtool_ops internal_dev_ethtool_ops = {
 122         .get_drvinfo = internal_dev_getinfo,
 123         .get_link = ethtool_op_get_link,
 124         .get_sg = ethtool_op_get_sg,
 125         .get_tx_csum = ethtool_op_get_tx_csum,
 126         .get_tso = ethtool_op_get_tso,
 127 };
 128
 129 static int internal_dev_change_mtu(struct net_device *netdev, int new_mtu)
 130 {
 131         struct dp_port *dp_port = vport_get_dp_port(internal_dev_get_vport(netdev));
 132
 133         if (new_mtu < 68)
 134                 return -EINVAL;
 135
 136         if (dp_port) {
 137                 int min_mtu;
 138
 139                 mutex_lock(&dp_port->dp->mutex);
 140                 min_mtu = dp_min_mtu(dp_port->dp);
 141                 mutex_unlock(&dp_port->dp->mutex);
 142
 143                 if (new_mtu > min_mtu)
 144                         return -EINVAL;
 145         }
 146
 147         netdev->mtu = new_mtu;
 148         return 0;
 149 }
 150
 151 static int internal_dev_init(struct net_device *netdev)
 152 {
 153         struct internal_dev *internal_dev = internal_dev_priv(netdev);
 154
 155         internal_dev->lstats = alloc_percpu(struct pcpu_lstats);
 156         if (!internal_dev->lstats)
 157                 return -ENOMEM;
 158
 159         return 0;
 160 }
 161
 162 static void internal_dev_free(struct net_device *netdev)
 163 {
 164         struct internal_dev *internal_dev = internal_dev_priv(netdev);
 165
 166         free_percpu(internal_dev->lstats);
 167         free_netdev(netdev);
 168 }
 169
 170 static int internal_dev_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
 171 {
 172         if (dp_ioctl_hook)
 173                 return dp_ioctl_hook(dev, ifr, cmd);
 174         return -EOPNOTSUPP;
 175 }
 176
 177 #ifdef HAVE_NET_DEVICE_OPS
 178 static const struct net_device_ops internal_dev_netdev_ops = {
 179         .ndo_init = internal_dev_init,
 180         .ndo_open = internal_dev_open,
 181         .ndo_stop = internal_dev_stop,
 182         .ndo_start_xmit = internal_dev_xmit,
 183         .ndo_set_mac_address = internal_dev_mac_addr,
 184         .ndo_do_ioctl = internal_dev_do_ioctl,
 185         .ndo_change_mtu = internal_dev_change_mtu,
 186         .ndo_get_stats = internal_dev_get_stats,
 187 };
 188 #endif
 189
 190 static void
 191 do_setup(struct net_device *netdev)
 192 {
 193         ether_setup(netdev);
 194
 195 #ifdef HAVE_NET_DEVICE_OPS
 196         netdev->netdev_ops = &internal_dev_netdev_ops;
 197 #else
 198         netdev->do_ioctl = internal_dev_do_ioctl;
 199         netdev->get_stats = internal_dev_get_stats;
 200         netdev->hard_start_xmit = internal_dev_xmit;
 201         netdev->open = internal_dev_open;
 202         netdev->stop = internal_dev_stop;
 203         netdev->set_mac_address = internal_dev_mac_addr;
 204         netdev->change_mtu = internal_dev_change_mtu;
 205         netdev->init = internal_dev_init;
 206 #endif
 207
 208         netdev->destructor = internal_dev_free;
 209         SET_ETHTOOL_OPS(netdev, &internal_dev_ethtool_ops);
 210         netdev->tx_queue_len = 0;
 211
 212         netdev->flags = IFF_BROADCAST | IFF_MULTICAST;
 213         netdev->features = NETIF_F_LLTX; /* XXX other features? */
 214
 215         vport_gen_ether_addr(netdev->dev_addr);
 216 }
 217
 218 static struct vport *
 219 internal_dev_create(const char *name, const void __user *config)
 220 {
 221         struct vport *vport;
 222         struct netdev_vport *netdev_vport;
 223         struct internal_dev *internal_dev;
 224         int err;
 225
 226         vport = vport_alloc(sizeof(struct netdev_vport), &internal_vport_ops);
 227         if (IS_ERR(vport)) {
 228                 err = PTR_ERR(vport);
 229                 goto error;
 230         }
 231
 232         netdev_vport = netdev_vport_priv(vport);
 233
 234         netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev), name, do_setup);
 235         if (!netdev_vport->dev) {
 236                 err = -ENOMEM;
 237                 goto error_free_vport;
 238         }
 239
 240         internal_dev = internal_dev_priv(netdev_vport->dev);
 241         internal_dev->vport = vport;
 242
 243         err = register_netdevice(netdev_vport->dev);
 244         if (err)
 245                 goto error_free_netdev;
 246
 247         return vport;
 248
 249 error_free_netdev:
 250         free_netdev(netdev_vport->dev);
 251 error_free_vport:
 252         vport_free(vport);
 253 error:
 254         return ERR_PTR(err);
 255 }
 256
 257 static int
 258 internal_dev_destroy(struct vport *vport)
 259 {
 260         struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
 261
 262         unregister_netdevice(netdev_vport->dev);
 263         vport_free(vport);
 264
 265         return 0;
 266 }
 267
 268 static int
 269 internal_dev_attach(struct vport *vport)
 270 {
 271         struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
 272
 273         dev_set_promiscuity(netdev_vport->dev, 1);
 274
 275         /* It would make sense to assign dev->br_port here too, but
 276          * that causes packets received on internal ports to get caught
 277          * in netdev_frame_hook().  In turn netdev_frame_hook() can reject them
 278          * back to the network stack, but that's a waste of time. */
 279
 280         return 0;
 281 }
 282
 283 static int
 284 internal_dev_detach(struct vport *vport)
 285 {
 286         struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
 287
 288         dev_set_promiscuity(netdev_vport->dev, -1);
 289
 290         /* Make sure that no packets arrive from now on, since
 291          * internal_dev_xmit() will try to find itself through
 292          * p->dp->ports[], and we're about to set that to null. */
 293         netif_tx_disable(netdev_vport->dev);
 294
 295         return 0;
 296 }
 297
 298 static int
 299 internal_dev_recv(struct vport *vport, struct sk_buff *skb)
 300 {
 301         struct net_device *netdev = netdev_vport_priv(vport)->dev;
 302         struct internal_dev *internal_dev = internal_dev_priv(netdev);
 303         struct pcpu_lstats *lb_stats;
 304         int len;
 305
 306         skb->dev = netdev;
 307         len = skb->len;
 308         skb->pkt_type = PACKET_HOST;
 309         skb->protocol = eth_type_trans(skb, netdev);
 310
 311         if (in_interrupt())
 312                 netif_rx(skb);
 313         else
 314                 netif_rx_ni(skb);
 315         netdev->last_rx = jiffies;
 316
 317         preempt_disable();
 318         lb_stats = per_cpu_ptr(internal_dev->lstats, smp_processor_id());
 319         lb_stats->rx_packets++;
 320         lb_stats->rx_bytes += len;
 321         preempt_enable();
 322
 323         return len;
 324 }
 325
 326 struct vport_ops internal_vport_ops = {
 327         .type           = "internal",
 328         .flags          = VPORT_F_REQUIRED,
 329         .create         = internal_dev_create,
 330         .destroy        = internal_dev_destroy,
 331         .attach         = internal_dev_attach,
 332         .detach         = internal_dev_detach,
 333         .set_mtu        = netdev_set_mtu,
 334         .set_addr       = netdev_set_addr,
 335         .get_name       = netdev_get_name,
 336         .get_addr       = netdev_get_addr,
 337         .get_kobj       = netdev_get_kobj,
 338         .get_stats      = netdev_get_stats,
 339         .get_dev_flags  = netdev_get_dev_flags,
 340         .is_running     = netdev_is_running,
 341         .get_operstate  = netdev_get_operstate,
 342         .get_ifindex    = netdev_get_ifindex,
 343         .get_iflink     = netdev_get_iflink,
 344         .get_mtu        = netdev_get_mtu,
 345         .send           = internal_dev_recv,
 346 };
 347
 348 int is_internal_dev(const struct net_device *netdev)
 349 {
 350 #ifdef HAVE_NET_DEVICE_OPS
 351         return netdev->netdev_ops == &internal_dev_netdev_ops;
 352 #else
 353         return netdev->open == internal_dev_open;
 354 #endif
 355 }
 356
 357 int
 358 is_internal_vport(const struct vport *vport)
 359 {
 360         return vport->ops == &internal_vport_ops;
 361 }
 362
 363 struct vport *
 364 internal_dev_get_vport(struct net_device *netdev)
 365 {
 366         struct internal_dev *internal_dev = internal_dev_priv(netdev);
 367         return rcu_dereference(internal_dev->vport);
 368 }