1 /* 2 * Network-device interface management. 3 * 4 * Copyright (c) 2004-2005, Keir Fraser 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation; or, when distributed 9 * separately from the Linux kernel or incorporated into other 10 * software packages, subject to the following license: 11 * 12 * Permission is hereby granted, free of charge, to any person obtaining a copy 13 * of this source file (the "Software"), to deal in the Software without 14 * restriction, including without limitation the rights to use, copy, modify, 15 * merge, publish, distribute, sublicense, and/or sell copies of the Software, 16 * and to permit persons to whom the Software is furnished to do so, subject to 17 * the following conditions: 18 * 19 * The above copyright notice and this permission notice shall be included in 20 * all copies or substantial portions of the Software. 21 * 22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 25 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 28 * IN THE SOFTWARE. 29 */ 30 31 #include "common.h" 32 33 #include <linux/kthread.h> 34 #include <linux/ethtool.h> 35 #include <linux/rtnetlink.h> 36 #include <linux/if_vlan.h> 37 38 #include <xen/events.h> 39 #include <asm/xen/hypercall.h> 40 41 #define XENVIF_QUEUE_LENGTH 32 42 #define XENVIF_NAPI_WEIGHT 64 43 44 int xenvif_schedulable(struct xenvif *vif) 45 { 46 return netif_running(vif->dev) && netif_carrier_ok(vif->dev); 47 } 48 49 static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id) 50 { 51 struct xenvif *vif = dev_id; 52 53 if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx)) 54 napi_schedule(&vif->napi); 55 56 return IRQ_HANDLED; 57 } 58 59 static int xenvif_poll(struct napi_struct *napi, int budget) 60 { 61 struct xenvif *vif = container_of(napi, struct xenvif, napi); 62 int work_done; 63 64 work_done = xenvif_tx_action(vif, budget); 65 66 if (work_done < budget) { 67 int more_to_do = 0; 68 unsigned long flags; 69 70 /* It is necessary to disable IRQ before calling 71 * RING_HAS_UNCONSUMED_REQUESTS. Otherwise we might 72 * lose event from the frontend. 73 * 74 * Consider: 75 * RING_HAS_UNCONSUMED_REQUESTS 76 * <frontend generates event to trigger napi_schedule> 77 * __napi_complete 78 * 79 * This handler is still in scheduled state so the 80 * event has no effect at all. After __napi_complete 81 * this handler is descheduled and cannot get 82 * scheduled again. We lose event in this case and the ring 83 * will be completely stalled. 84 */ 85 86 local_irq_save(flags); 87 88 RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do); 89 if (!more_to_do) 90 __napi_complete(napi); 91 92 local_irq_restore(flags); 93 } 94 95 return work_done; 96 } 97 98 static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id) 99 { 100 struct xenvif *vif = dev_id; 101 102 vif->rx_event = true; 103 xenvif_kick_thread(vif); 104 105 return IRQ_HANDLED; 106 } 107 108 static irqreturn_t xenvif_interrupt(int irq, void *dev_id) 109 { 110 xenvif_tx_interrupt(irq, dev_id); 111 xenvif_rx_interrupt(irq, dev_id); 112 113 return IRQ_HANDLED; 114 } 115 116 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) 117 { 118 struct xenvif *vif = netdev_priv(dev); 119 int min_slots_needed; 120 121 BUG_ON(skb->dev != dev); 122 123 /* Drop the packet if vif is not ready */ 124 if (vif->task == NULL || !xenvif_schedulable(vif)) 125 goto drop; 126 127 /* At best we'll need one slot for the header and one for each 128 * frag. 129 */ 130 min_slots_needed = 1 + skb_shinfo(skb)->nr_frags; 131 132 /* If the skb is GSO then we'll also need an extra slot for the 133 * metadata. 134 */ 135 if (skb_shinfo(skb)->gso_type & SKB_GSO_TCPV4 || 136 skb_shinfo(skb)->gso_type & SKB_GSO_TCPV6) 137 min_slots_needed++; 138 139 /* If the skb can't possibly fit in the remaining slots 140 * then turn off the queue to give the ring a chance to 141 * drain. 142 */ 143 if (!xenvif_rx_ring_slots_available(vif, min_slots_needed)) 144 xenvif_stop_queue(vif); 145 146 skb_queue_tail(&vif->rx_queue, skb); 147 xenvif_kick_thread(vif); 148 149 return NETDEV_TX_OK; 150 151 drop: 152 vif->dev->stats.tx_dropped++; 153 dev_kfree_skb(skb); 154 return NETDEV_TX_OK; 155 } 156 157 static struct net_device_stats *xenvif_get_stats(struct net_device *dev) 158 { 159 struct xenvif *vif = netdev_priv(dev); 160 return &vif->dev->stats; 161 } 162 163 static void xenvif_up(struct xenvif *vif) 164 { 165 napi_enable(&vif->napi); 166 enable_irq(vif->tx_irq); 167 if (vif->tx_irq != vif->rx_irq) 168 enable_irq(vif->rx_irq); 169 xenvif_check_rx_xenvif(vif); 170 } 171 172 static void xenvif_down(struct xenvif *vif) 173 { 174 napi_disable(&vif->napi); 175 disable_irq(vif->tx_irq); 176 if (vif->tx_irq != vif->rx_irq) 177 disable_irq(vif->rx_irq); 178 del_timer_sync(&vif->credit_timeout); 179 } 180 181 static int xenvif_open(struct net_device *dev) 182 { 183 struct xenvif *vif = netdev_priv(dev); 184 if (netif_carrier_ok(dev)) 185 xenvif_up(vif); 186 netif_start_queue(dev); 187 return 0; 188 } 189 190 static int xenvif_close(struct net_device *dev) 191 { 192 struct xenvif *vif = netdev_priv(dev); 193 if (netif_carrier_ok(dev)) 194 xenvif_down(vif); 195 netif_stop_queue(dev); 196 return 0; 197 } 198 199 static int xenvif_change_mtu(struct net_device *dev, int mtu) 200 { 201 struct xenvif *vif = netdev_priv(dev); 202 int max = vif->can_sg ? 65535 - VLAN_ETH_HLEN : ETH_DATA_LEN; 203 204 if (mtu > max) 205 return -EINVAL; 206 dev->mtu = mtu; 207 return 0; 208 } 209 210 static netdev_features_t xenvif_fix_features(struct net_device *dev, 211 netdev_features_t features) 212 { 213 struct xenvif *vif = netdev_priv(dev); 214 215 if (!vif->can_sg) 216 features &= ~NETIF_F_SG; 217 if (~(vif->gso_mask | vif->gso_prefix_mask) & GSO_BIT(TCPV4)) 218 features &= ~NETIF_F_TSO; 219 if (~(vif->gso_mask | vif->gso_prefix_mask) & GSO_BIT(TCPV6)) 220 features &= ~NETIF_F_TSO6; 221 if (!vif->ip_csum) 222 features &= ~NETIF_F_IP_CSUM; 223 if (!vif->ipv6_csum) 224 features &= ~NETIF_F_IPV6_CSUM; 225 226 return features; 227 } 228 229 static const struct xenvif_stat { 230 char name[ETH_GSTRING_LEN]; 231 u16 offset; 232 } xenvif_stats[] = { 233 { 234 "rx_gso_checksum_fixup", 235 offsetof(struct xenvif, rx_gso_checksum_fixup) 236 }, 237 }; 238 239 static int xenvif_get_sset_count(struct net_device *dev, int string_set) 240 { 241 switch (string_set) { 242 case ETH_SS_STATS: 243 return ARRAY_SIZE(xenvif_stats); 244 default: 245 return -EINVAL; 246 } 247 } 248 249 static void xenvif_get_ethtool_stats(struct net_device *dev, 250 struct ethtool_stats *stats, u64 * data) 251 { 252 void *vif = netdev_priv(dev); 253 int i; 254 255 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) 256 data[i] = *(unsigned long *)(vif + xenvif_stats[i].offset); 257 } 258 259 static void xenvif_get_strings(struct net_device *dev, u32 stringset, u8 * data) 260 { 261 int i; 262 263 switch (stringset) { 264 case ETH_SS_STATS: 265 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) 266 memcpy(data + i * ETH_GSTRING_LEN, 267 xenvif_stats[i].name, ETH_GSTRING_LEN); 268 break; 269 } 270 } 271 272 static const struct ethtool_ops xenvif_ethtool_ops = { 273 .get_link = ethtool_op_get_link, 274 275 .get_sset_count = xenvif_get_sset_count, 276 .get_ethtool_stats = xenvif_get_ethtool_stats, 277 .get_strings = xenvif_get_strings, 278 }; 279 280 static const struct net_device_ops xenvif_netdev_ops = { 281 .ndo_start_xmit = xenvif_start_xmit, 282 .ndo_get_stats = xenvif_get_stats, 283 .ndo_open = xenvif_open, 284 .ndo_stop = xenvif_close, 285 .ndo_change_mtu = xenvif_change_mtu, 286 .ndo_fix_features = xenvif_fix_features, 287 .ndo_set_mac_address = eth_mac_addr, 288 .ndo_validate_addr = eth_validate_addr, 289 }; 290 291 struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, 292 unsigned int handle) 293 { 294 int err; 295 struct net_device *dev; 296 struct xenvif *vif; 297 char name[IFNAMSIZ] = {}; 298 int i; 299 300 snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle); 301 dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup); 302 if (dev == NULL) { 303 pr_warn("Could not allocate netdev for %s\n", name); 304 return ERR_PTR(-ENOMEM); 305 } 306 307 SET_NETDEV_DEV(dev, parent); 308 309 vif = netdev_priv(dev); 310 vif->domid = domid; 311 vif->handle = handle; 312 vif->can_sg = 1; 313 vif->ip_csum = 1; 314 vif->dev = dev; 315 316 vif->credit_bytes = vif->remaining_credit = ~0UL; 317 vif->credit_usec = 0UL; 318 init_timer(&vif->credit_timeout); 319 vif->credit_window_start = get_jiffies_64(); 320 321 dev->netdev_ops = &xenvif_netdev_ops; 322 dev->hw_features = NETIF_F_SG | 323 NETIF_F_IP_CSUM | NETIF_F_IPV6_CSUM | 324 NETIF_F_TSO | NETIF_F_TSO6; 325 dev->features = dev->hw_features | NETIF_F_RXCSUM; 326 SET_ETHTOOL_OPS(dev, &xenvif_ethtool_ops); 327 328 dev->tx_queue_len = XENVIF_QUEUE_LENGTH; 329 330 skb_queue_head_init(&vif->rx_queue); 331 skb_queue_head_init(&vif->tx_queue); 332 333 vif->pending_cons = 0; 334 vif->pending_prod = MAX_PENDING_REQS; 335 for (i = 0; i < MAX_PENDING_REQS; i++) 336 vif->pending_ring[i] = i; 337 for (i = 0; i < MAX_PENDING_REQS; i++) 338 vif->mmap_pages[i] = NULL; 339 340 /* 341 * Initialise a dummy MAC address. We choose the numerically 342 * largest non-broadcast address to prevent the address getting 343 * stolen by an Ethernet bridge for STP purposes. 344 * (FE:FF:FF:FF:FF:FF) 345 */ 346 memset(dev->dev_addr, 0xFF, ETH_ALEN); 347 dev->dev_addr[0] &= ~0x01; 348 349 netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT); 350 351 netif_carrier_off(dev); 352 353 err = register_netdev(dev); 354 if (err) { 355 netdev_warn(dev, "Could not register device: err=%d\n", err); 356 free_netdev(dev); 357 return ERR_PTR(err); 358 } 359 360 netdev_dbg(dev, "Successfully created xenvif\n"); 361 362 __module_get(THIS_MODULE); 363 364 return vif; 365 } 366 367 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, 368 unsigned long rx_ring_ref, unsigned int tx_evtchn, 369 unsigned int rx_evtchn) 370 { 371 struct task_struct *task; 372 int err = -ENOMEM; 373 374 BUG_ON(vif->tx_irq); 375 BUG_ON(vif->task); 376 377 err = xenvif_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref); 378 if (err < 0) 379 goto err; 380 381 init_waitqueue_head(&vif->wq); 382 383 if (tx_evtchn == rx_evtchn) { 384 /* feature-split-event-channels == 0 */ 385 err = bind_interdomain_evtchn_to_irqhandler( 386 vif->domid, tx_evtchn, xenvif_interrupt, 0, 387 vif->dev->name, vif); 388 if (err < 0) 389 goto err_unmap; 390 vif->tx_irq = vif->rx_irq = err; 391 disable_irq(vif->tx_irq); 392 } else { 393 /* feature-split-event-channels == 1 */ 394 snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name), 395 "%s-tx", vif->dev->name); 396 err = bind_interdomain_evtchn_to_irqhandler( 397 vif->domid, tx_evtchn, xenvif_tx_interrupt, 0, 398 vif->tx_irq_name, vif); 399 if (err < 0) 400 goto err_unmap; 401 vif->tx_irq = err; 402 disable_irq(vif->tx_irq); 403 404 snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name), 405 "%s-rx", vif->dev->name); 406 err = bind_interdomain_evtchn_to_irqhandler( 407 vif->domid, rx_evtchn, xenvif_rx_interrupt, 0, 408 vif->rx_irq_name, vif); 409 if (err < 0) 410 goto err_tx_unbind; 411 vif->rx_irq = err; 412 disable_irq(vif->rx_irq); 413 } 414 415 task = kthread_create(xenvif_kthread, 416 (void *)vif, "%s", vif->dev->name); 417 if (IS_ERR(task)) { 418 pr_warn("Could not allocate kthread for %s\n", vif->dev->name); 419 err = PTR_ERR(task); 420 goto err_rx_unbind; 421 } 422 423 vif->task = task; 424 425 rtnl_lock(); 426 if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN) 427 dev_set_mtu(vif->dev, ETH_DATA_LEN); 428 netdev_update_features(vif->dev); 429 netif_carrier_on(vif->dev); 430 if (netif_running(vif->dev)) 431 xenvif_up(vif); 432 rtnl_unlock(); 433 434 wake_up_process(vif->task); 435 436 return 0; 437 438 err_rx_unbind: 439 unbind_from_irqhandler(vif->rx_irq, vif); 440 vif->rx_irq = 0; 441 err_tx_unbind: 442 unbind_from_irqhandler(vif->tx_irq, vif); 443 vif->tx_irq = 0; 444 err_unmap: 445 xenvif_unmap_frontend_rings(vif); 446 err: 447 module_put(THIS_MODULE); 448 return err; 449 } 450 451 void xenvif_carrier_off(struct xenvif *vif) 452 { 453 struct net_device *dev = vif->dev; 454 455 rtnl_lock(); 456 netif_carrier_off(dev); /* discard queued packets */ 457 if (netif_running(dev)) 458 xenvif_down(vif); 459 rtnl_unlock(); 460 } 461 462 void xenvif_disconnect(struct xenvif *vif) 463 { 464 if (netif_carrier_ok(vif->dev)) 465 xenvif_carrier_off(vif); 466 467 if (vif->task) { 468 kthread_stop(vif->task); 469 vif->task = NULL; 470 } 471 472 if (vif->tx_irq) { 473 if (vif->tx_irq == vif->rx_irq) 474 unbind_from_irqhandler(vif->tx_irq, vif); 475 else { 476 unbind_from_irqhandler(vif->tx_irq, vif); 477 unbind_from_irqhandler(vif->rx_irq, vif); 478 } 479 vif->tx_irq = 0; 480 } 481 482 xenvif_unmap_frontend_rings(vif); 483 } 484 485 void xenvif_free(struct xenvif *vif) 486 { 487 netif_napi_del(&vif->napi); 488 489 unregister_netdev(vif->dev); 490 491 free_netdev(vif->dev); 492 493 module_put(THIS_MODULE); 494 } 495