1/* 2 * drivers/net/veth.c 3 * 4 * Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc 5 * 6 * Author: Pavel Emelianov <xemul@openvz.org> 7 * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com> 8 * 9 */ 10 11#include <linux/netdevice.h> 12#include <linux/slab.h> 13#include <linux/ethtool.h> 14#include <linux/etherdevice.h> 15 16#include <net/dst.h> 17#include <net/xfrm.h> 18#include <linux/veth.h> 19 20#define DRV_NAME "veth" 21#define DRV_VERSION "1.0" 22 23#define MIN_MTU 68 /* Min L3 MTU */ 24#define MAX_MTU 65535 /* Max L3 MTU (arbitrary) */ 25#define MTU_PAD (ETH_HLEN + 4) /* Max difference between L2 and L3 size MTU */ 26 27struct veth_net_stats { 28 unsigned long rx_packets; 29 unsigned long tx_packets; 30 unsigned long rx_bytes; 31 unsigned long tx_bytes; 32 unsigned long tx_dropped; 33 unsigned long rx_dropped; 34}; 35 36struct veth_priv { 37 struct net_device *peer; 38 struct veth_net_stats __percpu *stats; 39 unsigned ip_summed; 40}; 41 42/* 43 * ethtool interface 44 */ 45 46static struct { 47 const char string[ETH_GSTRING_LEN]; 48} ethtool_stats_keys[] = { 49 { "peer_ifindex" }, 50}; 51 52static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 53{ 54 cmd->supported = 0; 55 cmd->advertising = 0; 56 cmd->speed = SPEED_10000; 57 cmd->duplex = DUPLEX_FULL; 58 cmd->port = PORT_TP; 59 cmd->phy_address = 0; 60 cmd->transceiver = XCVR_INTERNAL; 61 cmd->autoneg = AUTONEG_DISABLE; 62 cmd->maxtxpkt = 0; 63 cmd->maxrxpkt = 0; 64 return 0; 65} 66 67static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 68{ 69 strcpy(info->driver, DRV_NAME); 70 strcpy(info->version, DRV_VERSION); 71 strcpy(info->fw_version, "N/A"); 72} 73 74static void veth_get_strings(struct net_device *dev, u32 stringset, u8 *buf) 75{ 76 switch(stringset) { 77 case ETH_SS_STATS: 78 memcpy(buf, ðtool_stats_keys, sizeof(ethtool_stats_keys)); 79 break; 80 } 81} 82 83static int veth_get_sset_count(struct net_device *dev, int sset) 84{ 85 switch (sset) { 86 case ETH_SS_STATS: 87 return ARRAY_SIZE(ethtool_stats_keys); 88 default: 89 return -EOPNOTSUPP; 90 } 91} 92 93static void veth_get_ethtool_stats(struct net_device *dev, 94 struct ethtool_stats *stats, u64 *data) 95{ 96 struct veth_priv *priv; 97 98 priv = netdev_priv(dev); 99 data[0] = priv->peer->ifindex; 100} 101 102static u32 veth_get_rx_csum(struct net_device *dev) 103{ 104 struct veth_priv *priv; 105 106 priv = netdev_priv(dev); 107 return priv->ip_summed == CHECKSUM_UNNECESSARY; 108} 109 110static int veth_set_rx_csum(struct net_device *dev, u32 data) 111{ 112 struct veth_priv *priv; 113 114 priv = netdev_priv(dev); 115 priv->ip_summed = data ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE; 116 return 0; 117} 118 119static u32 veth_get_tx_csum(struct net_device *dev) 120{ 121 return (dev->features & NETIF_F_NO_CSUM) != 0; 122} 123 124static int veth_set_tx_csum(struct net_device *dev, u32 data) 125{ 126 if (data) 127 dev->features |= NETIF_F_NO_CSUM; 128 else 129 dev->features &= ~NETIF_F_NO_CSUM; 130 return 0; 131} 132 133static const struct ethtool_ops veth_ethtool_ops = { 134 .get_settings = veth_get_settings, 135 .get_drvinfo = veth_get_drvinfo, 136 .get_link = ethtool_op_get_link, 137 .get_rx_csum = veth_get_rx_csum, 138 .set_rx_csum = veth_set_rx_csum, 139 .get_tx_csum = veth_get_tx_csum, 140 .set_tx_csum = veth_set_tx_csum, 141 .get_sg = ethtool_op_get_sg, 142 .set_sg = ethtool_op_set_sg, 143 .get_strings = veth_get_strings, 144 .get_sset_count = veth_get_sset_count, 145 .get_ethtool_stats = veth_get_ethtool_stats, 146}; 147 148/* 149 * xmit 150 */ 151 152static netdev_tx_t veth_xmit(struct sk_buff *skb, struct net_device *dev) 153{ 154 struct net_device *rcv = NULL; 155 struct veth_priv *priv, *rcv_priv; 156 struct veth_net_stats *stats, *rcv_stats; 157 int length; 158 159 priv = netdev_priv(dev); 160 rcv = priv->peer; 161 rcv_priv = netdev_priv(rcv); 162 163 stats = this_cpu_ptr(priv->stats); 164 rcv_stats = this_cpu_ptr(rcv_priv->stats); 165 166 if (!(rcv->flags & IFF_UP)) 167 goto tx_drop; 168 169 if (dev->features & NETIF_F_NO_CSUM) 170 skb->ip_summed = rcv_priv->ip_summed; 171 172 length = skb->len + ETH_HLEN; 173 if (dev_forward_skb(rcv, skb) != NET_RX_SUCCESS) 174 goto rx_drop; 175 176 stats->tx_bytes += length; 177 stats->tx_packets++; 178 179 rcv_stats->rx_bytes += length; 180 rcv_stats->rx_packets++; 181 182 return NETDEV_TX_OK; 183 184tx_drop: 185 kfree_skb(skb); 186 stats->tx_dropped++; 187 return NETDEV_TX_OK; 188 189rx_drop: 190 rcv_stats->rx_dropped++; 191 return NETDEV_TX_OK; 192} 193 194/* 195 * general routines 196 */ 197 198static struct net_device_stats *veth_get_stats(struct net_device *dev) 199{ 200 struct veth_priv *priv; 201 int cpu; 202 struct veth_net_stats *stats, total = {0}; 203 204 priv = netdev_priv(dev); 205 206 for_each_possible_cpu(cpu) { 207 stats = per_cpu_ptr(priv->stats, cpu); 208 209 total.rx_packets += stats->rx_packets; 210 total.tx_packets += stats->tx_packets; 211 total.rx_bytes += stats->rx_bytes; 212 total.tx_bytes += stats->tx_bytes; 213 total.tx_dropped += stats->tx_dropped; 214 total.rx_dropped += stats->rx_dropped; 215 } 216 dev->stats.rx_packets = total.rx_packets; 217 dev->stats.tx_packets = total.tx_packets; 218 dev->stats.rx_bytes = total.rx_bytes; 219 dev->stats.tx_bytes = total.tx_bytes; 220 dev->stats.tx_dropped = total.tx_dropped; 221 dev->stats.rx_dropped = total.rx_dropped; 222 223 return &dev->stats; 224} 225 226static int veth_open(struct net_device *dev) 227{ 228 struct veth_priv *priv; 229 230 priv = netdev_priv(dev); 231 if (priv->peer == NULL) 232 return -ENOTCONN; 233 234 if (priv->peer->flags & IFF_UP) { 235 netif_carrier_on(dev); 236 netif_carrier_on(priv->peer); 237 } 238 return 0; 239} 240 241static int veth_close(struct net_device *dev) 242{ 243 struct veth_priv *priv = netdev_priv(dev); 244 245 netif_carrier_off(dev); 246 netif_carrier_off(priv->peer); 247 248 return 0; 249} 250 251static int is_valid_veth_mtu(int new_mtu) 252{ 253 return (new_mtu >= MIN_MTU && new_mtu <= MAX_MTU); 254} 255 256static int veth_change_mtu(struct net_device *dev, int new_mtu) 257{ 258 if (!is_valid_veth_mtu(new_mtu)) 259 return -EINVAL; 260 dev->mtu = new_mtu; 261 return 0; 262} 263 264static int veth_dev_init(struct net_device *dev) 265{ 266 struct veth_net_stats __percpu *stats; 267 struct veth_priv *priv; 268 269 stats = alloc_percpu(struct veth_net_stats); 270 if (stats == NULL) 271 return -ENOMEM; 272 273 priv = netdev_priv(dev); 274 priv->stats = stats; 275 return 0; 276} 277 278static void veth_dev_free(struct net_device *dev) 279{ 280 struct veth_priv *priv; 281 282 priv = netdev_priv(dev); 283 free_percpu(priv->stats); 284 free_netdev(dev); 285} 286 287static const struct net_device_ops veth_netdev_ops = { 288 .ndo_init = veth_dev_init, 289 .ndo_open = veth_open, 290 .ndo_stop = veth_close, 291 .ndo_start_xmit = veth_xmit, 292 .ndo_change_mtu = veth_change_mtu, 293 .ndo_get_stats = veth_get_stats, 294 .ndo_set_mac_address = eth_mac_addr, 295}; 296 297static void veth_setup(struct net_device *dev) 298{ 299 ether_setup(dev); 300 301 dev->netdev_ops = &veth_netdev_ops; 302 dev->ethtool_ops = &veth_ethtool_ops; 303 dev->features |= NETIF_F_LLTX; 304 dev->destructor = veth_dev_free; 305} 306 307/* 308 * netlink interface 309 */ 310 311static int veth_validate(struct nlattr *tb[], struct nlattr *data[]) 312{ 313 if (tb[IFLA_ADDRESS]) { 314 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 315 return -EINVAL; 316 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 317 return -EADDRNOTAVAIL; 318 } 319 if (tb[IFLA_MTU]) { 320 if (!is_valid_veth_mtu(nla_get_u32(tb[IFLA_MTU]))) 321 return -EINVAL; 322 } 323 return 0; 324} 325 326static struct rtnl_link_ops veth_link_ops; 327 328static int veth_newlink(struct net *src_net, struct net_device *dev, 329 struct nlattr *tb[], struct nlattr *data[]) 330{ 331 int err; 332 struct net_device *peer; 333 struct veth_priv *priv; 334 char ifname[IFNAMSIZ]; 335 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp; 336 struct ifinfomsg *ifmp; 337 struct net *net; 338 339 /* 340 * create and register peer first 341 */ 342 if (data != NULL && data[VETH_INFO_PEER] != NULL) { 343 struct nlattr *nla_peer; 344 345 nla_peer = data[VETH_INFO_PEER]; 346 ifmp = nla_data(nla_peer); 347 err = nla_parse(peer_tb, IFLA_MAX, 348 nla_data(nla_peer) + sizeof(struct ifinfomsg), 349 nla_len(nla_peer) - sizeof(struct ifinfomsg), 350 ifla_policy); 351 if (err < 0) 352 return err; 353 354 err = veth_validate(peer_tb, NULL); 355 if (err < 0) 356 return err; 357 358 tbp = peer_tb; 359 } else { 360 ifmp = NULL; 361 tbp = tb; 362 } 363 364 if (tbp[IFLA_IFNAME]) 365 nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ); 366 else 367 snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d"); 368 369 net = rtnl_link_get_net(src_net, tbp); 370 if (IS_ERR(net)) 371 return PTR_ERR(net); 372 373 peer = rtnl_create_link(src_net, net, ifname, &veth_link_ops, tbp); 374 if (IS_ERR(peer)) { 375 put_net(net); 376 return PTR_ERR(peer); 377 } 378 379 if (tbp[IFLA_ADDRESS] == NULL) 380 random_ether_addr(peer->dev_addr); 381 382 err = register_netdevice(peer); 383 put_net(net); 384 net = NULL; 385 if (err < 0) 386 goto err_register_peer; 387 388 netif_carrier_off(peer); 389 390 err = rtnl_configure_link(peer, ifmp); 391 if (err < 0) 392 goto err_configure_peer; 393 394 /* 395 * register dev last 396 * 397 * note, that since we've registered new device the dev's name 398 * should be re-allocated 399 */ 400 401 if (tb[IFLA_ADDRESS] == NULL) 402 random_ether_addr(dev->dev_addr); 403 404 if (tb[IFLA_IFNAME]) 405 nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ); 406 else 407 snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d"); 408 409 if (strchr(dev->name, '%')) { 410 err = dev_alloc_name(dev, dev->name); 411 if (err < 0) 412 goto err_alloc_name; 413 } 414 415 err = register_netdevice(dev); 416 if (err < 0) 417 goto err_register_dev; 418 419 netif_carrier_off(dev); 420 421 /* 422 * tie the deviced together 423 */ 424 425 priv = netdev_priv(dev); 426 priv->peer = peer; 427 428 priv = netdev_priv(peer); 429 priv->peer = dev; 430 return 0; 431 432err_register_dev: 433 /* nothing to do */ 434err_alloc_name: 435err_configure_peer: 436 unregister_netdevice(peer); 437 return err; 438 439err_register_peer: 440 free_netdev(peer); 441 return err; 442} 443 444static void veth_dellink(struct net_device *dev, struct list_head *head) 445{ 446 struct veth_priv *priv; 447 struct net_device *peer; 448 449 priv = netdev_priv(dev); 450 peer = priv->peer; 451 452 unregister_netdevice_queue(dev, head); 453 unregister_netdevice_queue(peer, head); 454} 455 456static const struct nla_policy veth_policy[VETH_INFO_MAX + 1]; 457 458static struct rtnl_link_ops veth_link_ops = { 459 .kind = DRV_NAME, 460 .priv_size = sizeof(struct veth_priv), 461 .setup = veth_setup, 462 .validate = veth_validate, 463 .newlink = veth_newlink, 464 .dellink = veth_dellink, 465 .policy = veth_policy, 466 .maxtype = VETH_INFO_MAX, 467}; 468 469/* 470 * init/fini 471 */ 472 473static __init int veth_init(void) 474{ 475 return rtnl_link_register(&veth_link_ops); 476} 477 478static __exit void veth_exit(void) 479{ 480 rtnl_link_unregister(&veth_link_ops); 481} 482 483module_init(veth_init); 484module_exit(veth_exit); 485 486MODULE_DESCRIPTION("Virtual Ethernet Tunnel"); 487MODULE_LICENSE("GPL v2"); 488MODULE_ALIAS_RTNL_LINK(DRV_NAME); 489