1 /* 2 * Xenbus code for netif backend 3 * 4 * Copyright (C) 2005 Rusty Russell <rusty@rustcorp.com.au> 5 * Copyright (C) 2005 XenSource Ltd 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 * 12 * This program is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * GNU General Public License for more details. 16 * 17 * You should have received a copy of the GNU General Public License 18 * along with this program; if not, see <http://www.gnu.org/licenses/>. 19 */ 20 21 #include "common.h" 22 #include <linux/vmalloc.h> 23 #include <linux/rtnetlink.h> 24 25 struct backend_info { 26 struct xenbus_device *dev; 27 struct xenvif *vif; 28 29 /* This is the state that will be reflected in xenstore when any 30 * active hotplug script completes. 31 */ 32 enum xenbus_state state; 33 34 enum xenbus_state frontend_state; 35 struct xenbus_watch hotplug_status_watch; 36 u8 have_hotplug_status_watch:1; 37 38 const char *hotplug_script; 39 }; 40 41 static int connect_rings(struct backend_info *be, struct xenvif_queue *queue); 42 static void connect(struct backend_info *be); 43 static int read_xenbus_vif_flags(struct backend_info *be); 44 static int backend_create_xenvif(struct backend_info *be); 45 static void unregister_hotplug_status_watch(struct backend_info *be); 46 static void xen_unregister_watchers(struct xenvif *vif); 47 static void set_backend_state(struct backend_info *be, 48 enum xenbus_state state); 49 50 #ifdef CONFIG_DEBUG_FS 51 struct dentry *xen_netback_dbg_root = NULL; 52 53 static int xenvif_read_io_ring(struct seq_file *m, void *v) 54 { 55 struct xenvif_queue *queue = m->private; 56 struct xen_netif_tx_back_ring *tx_ring = &queue->tx; 57 struct xen_netif_rx_back_ring *rx_ring = &queue->rx; 58 struct netdev_queue *dev_queue; 59 60 if (tx_ring->sring) { 61 struct xen_netif_tx_sring *sring = tx_ring->sring; 62 63 seq_printf(m, "Queue %d\nTX: nr_ents %u\n", queue->id, 64 tx_ring->nr_ents); 65 seq_printf(m, "req prod %u (%d) cons %u (%d) event %u (%d)\n", 66 sring->req_prod, 67 sring->req_prod - sring->rsp_prod, 68 tx_ring->req_cons, 69 tx_ring->req_cons - sring->rsp_prod, 70 sring->req_event, 71 sring->req_event - sring->rsp_prod); 72 seq_printf(m, "rsp prod %u (base) pvt %u (%d) event %u (%d)\n", 73 sring->rsp_prod, 74 tx_ring->rsp_prod_pvt, 75 tx_ring->rsp_prod_pvt - sring->rsp_prod, 76 sring->rsp_event, 77 sring->rsp_event - sring->rsp_prod); 78 seq_printf(m, "pending prod %u pending cons %u nr_pending_reqs %u\n", 79 queue->pending_prod, 80 queue->pending_cons, 81 nr_pending_reqs(queue)); 82 seq_printf(m, "dealloc prod %u dealloc cons %u dealloc_queue %u\n\n", 83 queue->dealloc_prod, 84 queue->dealloc_cons, 85 queue->dealloc_prod - queue->dealloc_cons); 86 } 87 88 if (rx_ring->sring) { 89 struct xen_netif_rx_sring *sring = rx_ring->sring; 90 91 seq_printf(m, "RX: nr_ents %u\n", rx_ring->nr_ents); 92 seq_printf(m, "req prod %u (%d) cons %u (%d) event %u (%d)\n", 93 sring->req_prod, 94 sring->req_prod - sring->rsp_prod, 95 rx_ring->req_cons, 96 rx_ring->req_cons - sring->rsp_prod, 97 sring->req_event, 98 sring->req_event - sring->rsp_prod); 99 seq_printf(m, "rsp prod %u (base) pvt %u (%d) event %u (%d)\n\n", 100 sring->rsp_prod, 101 rx_ring->rsp_prod_pvt, 102 rx_ring->rsp_prod_pvt - sring->rsp_prod, 103 sring->rsp_event, 104 sring->rsp_event - sring->rsp_prod); 105 } 106 107 seq_printf(m, "NAPI state: %lx NAPI weight: %d TX queue len %u\n" 108 "Credit timer_pending: %d, credit: %lu, usec: %lu\n" 109 "remaining: %lu, expires: %lu, now: %lu\n", 110 queue->napi.state, queue->napi.weight, 111 skb_queue_len(&queue->tx_queue), 112 timer_pending(&queue->credit_timeout), 113 queue->credit_bytes, 114 queue->credit_usec, 115 queue->remaining_credit, 116 queue->credit_timeout.expires, 117 jiffies); 118 119 dev_queue = netdev_get_tx_queue(queue->vif->dev, queue->id); 120 121 seq_printf(m, "\nRx internal queue: len %u max %u pkts %u %s\n", 122 queue->rx_queue_len, queue->rx_queue_max, 123 skb_queue_len(&queue->rx_queue), 124 netif_tx_queue_stopped(dev_queue) ? "stopped" : "running"); 125 126 return 0; 127 } 128 129 #define XENVIF_KICK_STR "kick" 130 #define BUFFER_SIZE 32 131 132 static ssize_t 133 xenvif_write_io_ring(struct file *filp, const char __user *buf, size_t count, 134 loff_t *ppos) 135 { 136 struct xenvif_queue *queue = 137 ((struct seq_file *)filp->private_data)->private; 138 int len; 139 char write[BUFFER_SIZE]; 140 141 /* don't allow partial writes and check the length */ 142 if (*ppos != 0) 143 return 0; 144 if (count >= sizeof(write)) 145 return -ENOSPC; 146 147 len = simple_write_to_buffer(write, 148 sizeof(write) - 1, 149 ppos, 150 buf, 151 count); 152 if (len < 0) 153 return len; 154 155 write[len] = '\0'; 156 157 if (!strncmp(write, XENVIF_KICK_STR, sizeof(XENVIF_KICK_STR) - 1)) 158 xenvif_interrupt(0, (void *)queue); 159 else { 160 pr_warn("Unknown command to io_ring_q%d. Available: kick\n", 161 queue->id); 162 count = -EINVAL; 163 } 164 return count; 165 } 166 167 static int xenvif_dump_open(struct inode *inode, struct file *filp) 168 { 169 int ret; 170 void *queue = NULL; 171 172 if (inode->i_private) 173 queue = inode->i_private; 174 ret = single_open(filp, xenvif_read_io_ring, queue); 175 filp->f_mode |= FMODE_PWRITE; 176 return ret; 177 } 178 179 static const struct file_operations xenvif_dbg_io_ring_ops_fops = { 180 .owner = THIS_MODULE, 181 .open = xenvif_dump_open, 182 .read = seq_read, 183 .llseek = seq_lseek, 184 .release = single_release, 185 .write = xenvif_write_io_ring, 186 }; 187 188 static void xenvif_debugfs_addif(struct xenvif *vif) 189 { 190 struct dentry *pfile; 191 int i; 192 193 if (IS_ERR_OR_NULL(xen_netback_dbg_root)) 194 return; 195 196 vif->xenvif_dbg_root = debugfs_create_dir(vif->dev->name, 197 xen_netback_dbg_root); 198 if (!IS_ERR_OR_NULL(vif->xenvif_dbg_root)) { 199 for (i = 0; i < vif->num_queues; ++i) { 200 char filename[sizeof("io_ring_q") + 4]; 201 202 snprintf(filename, sizeof(filename), "io_ring_q%d", i); 203 pfile = debugfs_create_file(filename, 204 S_IRUSR | S_IWUSR, 205 vif->xenvif_dbg_root, 206 &vif->queues[i], 207 &xenvif_dbg_io_ring_ops_fops); 208 if (IS_ERR_OR_NULL(pfile)) 209 pr_warn("Creation of io_ring file returned %ld!\n", 210 PTR_ERR(pfile)); 211 } 212 } else 213 netdev_warn(vif->dev, 214 "Creation of vif debugfs dir returned %ld!\n", 215 PTR_ERR(vif->xenvif_dbg_root)); 216 } 217 218 static void xenvif_debugfs_delif(struct xenvif *vif) 219 { 220 if (IS_ERR_OR_NULL(xen_netback_dbg_root)) 221 return; 222 223 if (!IS_ERR_OR_NULL(vif->xenvif_dbg_root)) 224 debugfs_remove_recursive(vif->xenvif_dbg_root); 225 vif->xenvif_dbg_root = NULL; 226 } 227 #endif /* CONFIG_DEBUG_FS */ 228 229 static int netback_remove(struct xenbus_device *dev) 230 { 231 struct backend_info *be = dev_get_drvdata(&dev->dev); 232 233 set_backend_state(be, XenbusStateClosed); 234 235 unregister_hotplug_status_watch(be); 236 if (be->vif) { 237 kobject_uevent(&dev->dev.kobj, KOBJ_OFFLINE); 238 xen_unregister_watchers(be->vif); 239 xenbus_rm(XBT_NIL, dev->nodename, "hotplug-status"); 240 xenvif_free(be->vif); 241 be->vif = NULL; 242 } 243 kfree(be->hotplug_script); 244 kfree(be); 245 dev_set_drvdata(&dev->dev, NULL); 246 return 0; 247 } 248 249 250 /** 251 * Entry point to this code when a new device is created. Allocate the basic 252 * structures and switch to InitWait. 253 */ 254 static int netback_probe(struct xenbus_device *dev, 255 const struct xenbus_device_id *id) 256 { 257 const char *message; 258 struct xenbus_transaction xbt; 259 int err; 260 int sg; 261 const char *script; 262 struct backend_info *be = kzalloc(sizeof(struct backend_info), 263 GFP_KERNEL); 264 if (!be) { 265 xenbus_dev_fatal(dev, -ENOMEM, 266 "allocating backend structure"); 267 return -ENOMEM; 268 } 269 270 be->dev = dev; 271 dev_set_drvdata(&dev->dev, be); 272 273 sg = 1; 274 275 do { 276 err = xenbus_transaction_start(&xbt); 277 if (err) { 278 xenbus_dev_fatal(dev, err, "starting transaction"); 279 goto fail; 280 } 281 282 err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", sg); 283 if (err) { 284 message = "writing feature-sg"; 285 goto abort_transaction; 286 } 287 288 err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4", 289 "%d", sg); 290 if (err) { 291 message = "writing feature-gso-tcpv4"; 292 goto abort_transaction; 293 } 294 295 err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv6", 296 "%d", sg); 297 if (err) { 298 message = "writing feature-gso-tcpv6"; 299 goto abort_transaction; 300 } 301 302 /* We support partial checksum setup for IPv6 packets */ 303 err = xenbus_printf(xbt, dev->nodename, 304 "feature-ipv6-csum-offload", 305 "%d", 1); 306 if (err) { 307 message = "writing feature-ipv6-csum-offload"; 308 goto abort_transaction; 309 } 310 311 /* We support rx-copy path. */ 312 err = xenbus_printf(xbt, dev->nodename, 313 "feature-rx-copy", "%d", 1); 314 if (err) { 315 message = "writing feature-rx-copy"; 316 goto abort_transaction; 317 } 318 319 /* 320 * We don't support rx-flip path (except old guests who don't 321 * grok this feature flag). 322 */ 323 err = xenbus_printf(xbt, dev->nodename, 324 "feature-rx-flip", "%d", 0); 325 if (err) { 326 message = "writing feature-rx-flip"; 327 goto abort_transaction; 328 } 329 330 /* We support multicast-control. */ 331 err = xenbus_printf(xbt, dev->nodename, 332 "feature-multicast-control", "%d", 1); 333 if (err) { 334 message = "writing feature-multicast-control"; 335 goto abort_transaction; 336 } 337 338 err = xenbus_transaction_end(xbt, 0); 339 } while (err == -EAGAIN); 340 341 if (err) { 342 xenbus_dev_fatal(dev, err, "completing transaction"); 343 goto fail; 344 } 345 346 /* 347 * Split event channels support, this is optional so it is not 348 * put inside the above loop. 349 */ 350 err = xenbus_printf(XBT_NIL, dev->nodename, 351 "feature-split-event-channels", 352 "%u", separate_tx_rx_irq); 353 if (err) 354 pr_debug("Error writing feature-split-event-channels\n"); 355 356 /* Multi-queue support: This is an optional feature. */ 357 err = xenbus_printf(XBT_NIL, dev->nodename, 358 "multi-queue-max-queues", "%u", xenvif_max_queues); 359 if (err) 360 pr_debug("Error writing multi-queue-max-queues\n"); 361 362 script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL); 363 if (IS_ERR(script)) { 364 err = PTR_ERR(script); 365 xenbus_dev_fatal(dev, err, "reading script"); 366 goto fail; 367 } 368 369 be->hotplug_script = script; 370 371 err = xenbus_switch_state(dev, XenbusStateInitWait); 372 if (err) 373 goto fail; 374 375 be->state = XenbusStateInitWait; 376 377 /* This kicks hotplug scripts, so do it immediately. */ 378 err = backend_create_xenvif(be); 379 if (err) 380 goto fail; 381 382 return 0; 383 384 abort_transaction: 385 xenbus_transaction_end(xbt, 1); 386 xenbus_dev_fatal(dev, err, "%s", message); 387 fail: 388 pr_debug("failed\n"); 389 netback_remove(dev); 390 return err; 391 } 392 393 394 /* 395 * Handle the creation of the hotplug script environment. We add the script 396 * and vif variables to the environment, for the benefit of the vif-* hotplug 397 * scripts. 398 */ 399 static int netback_uevent(struct xenbus_device *xdev, 400 struct kobj_uevent_env *env) 401 { 402 struct backend_info *be = dev_get_drvdata(&xdev->dev); 403 404 if (!be) 405 return 0; 406 407 if (add_uevent_var(env, "script=%s", be->hotplug_script)) 408 return -ENOMEM; 409 410 if (!be->vif) 411 return 0; 412 413 return add_uevent_var(env, "vif=%s", be->vif->dev->name); 414 } 415 416 417 static int backend_create_xenvif(struct backend_info *be) 418 { 419 int err; 420 long handle; 421 struct xenbus_device *dev = be->dev; 422 struct xenvif *vif; 423 424 if (be->vif != NULL) 425 return 0; 426 427 err = xenbus_scanf(XBT_NIL, dev->nodename, "handle", "%li", &handle); 428 if (err != 1) { 429 xenbus_dev_fatal(dev, err, "reading handle"); 430 return (err < 0) ? err : -EINVAL; 431 } 432 433 vif = xenvif_alloc(&dev->dev, dev->otherend_id, handle); 434 if (IS_ERR(vif)) { 435 err = PTR_ERR(vif); 436 xenbus_dev_fatal(dev, err, "creating interface"); 437 return err; 438 } 439 be->vif = vif; 440 441 kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE); 442 return 0; 443 } 444 445 static void backend_disconnect(struct backend_info *be) 446 { 447 if (be->vif) { 448 xen_unregister_watchers(be->vif); 449 #ifdef CONFIG_DEBUG_FS 450 xenvif_debugfs_delif(be->vif); 451 #endif /* CONFIG_DEBUG_FS */ 452 xenvif_disconnect(be->vif); 453 } 454 } 455 456 static void backend_connect(struct backend_info *be) 457 { 458 if (be->vif) 459 connect(be); 460 } 461 462 static inline void backend_switch_state(struct backend_info *be, 463 enum xenbus_state state) 464 { 465 struct xenbus_device *dev = be->dev; 466 467 pr_debug("%s -> %s\n", dev->nodename, xenbus_strstate(state)); 468 be->state = state; 469 470 /* If we are waiting for a hotplug script then defer the 471 * actual xenbus state change. 472 */ 473 if (!be->have_hotplug_status_watch) 474 xenbus_switch_state(dev, state); 475 } 476 477 /* Handle backend state transitions: 478 * 479 * The backend state starts in InitWait and the following transitions are 480 * allowed. 481 * 482 * InitWait -> Connected 483 * 484 * ^ \ | 485 * | \ | 486 * | \ | 487 * | \ | 488 * | \ | 489 * | \ | 490 * | V V 491 * 492 * Closed <-> Closing 493 * 494 * The state argument specifies the eventual state of the backend and the 495 * function transitions to that state via the shortest path. 496 */ 497 static void set_backend_state(struct backend_info *be, 498 enum xenbus_state state) 499 { 500 while (be->state != state) { 501 switch (be->state) { 502 case XenbusStateClosed: 503 switch (state) { 504 case XenbusStateInitWait: 505 case XenbusStateConnected: 506 pr_info("%s: prepare for reconnect\n", 507 be->dev->nodename); 508 backend_switch_state(be, XenbusStateInitWait); 509 break; 510 case XenbusStateClosing: 511 backend_switch_state(be, XenbusStateClosing); 512 break; 513 default: 514 BUG(); 515 } 516 break; 517 case XenbusStateInitWait: 518 switch (state) { 519 case XenbusStateConnected: 520 backend_connect(be); 521 backend_switch_state(be, XenbusStateConnected); 522 break; 523 case XenbusStateClosing: 524 case XenbusStateClosed: 525 backend_switch_state(be, XenbusStateClosing); 526 break; 527 default: 528 BUG(); 529 } 530 break; 531 case XenbusStateConnected: 532 switch (state) { 533 case XenbusStateInitWait: 534 case XenbusStateClosing: 535 case XenbusStateClosed: 536 backend_disconnect(be); 537 backend_switch_state(be, XenbusStateClosing); 538 break; 539 default: 540 BUG(); 541 } 542 break; 543 case XenbusStateClosing: 544 switch (state) { 545 case XenbusStateInitWait: 546 case XenbusStateConnected: 547 case XenbusStateClosed: 548 backend_switch_state(be, XenbusStateClosed); 549 break; 550 default: 551 BUG(); 552 } 553 break; 554 default: 555 BUG(); 556 } 557 } 558 } 559 560 /** 561 * Callback received when the frontend's state changes. 562 */ 563 static void frontend_changed(struct xenbus_device *dev, 564 enum xenbus_state frontend_state) 565 { 566 struct backend_info *be = dev_get_drvdata(&dev->dev); 567 568 pr_debug("%s -> %s\n", dev->otherend, xenbus_strstate(frontend_state)); 569 570 be->frontend_state = frontend_state; 571 572 switch (frontend_state) { 573 case XenbusStateInitialising: 574 set_backend_state(be, XenbusStateInitWait); 575 break; 576 577 case XenbusStateInitialised: 578 break; 579 580 case XenbusStateConnected: 581 set_backend_state(be, XenbusStateConnected); 582 break; 583 584 case XenbusStateClosing: 585 set_backend_state(be, XenbusStateClosing); 586 break; 587 588 case XenbusStateClosed: 589 set_backend_state(be, XenbusStateClosed); 590 if (xenbus_dev_is_online(dev)) 591 break; 592 /* fall through if not online */ 593 case XenbusStateUnknown: 594 set_backend_state(be, XenbusStateClosed); 595 device_unregister(&dev->dev); 596 break; 597 598 default: 599 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend", 600 frontend_state); 601 break; 602 } 603 } 604 605 606 static void xen_net_read_rate(struct xenbus_device *dev, 607 unsigned long *bytes, unsigned long *usec) 608 { 609 char *s, *e; 610 unsigned long b, u; 611 char *ratestr; 612 613 /* Default to unlimited bandwidth. */ 614 *bytes = ~0UL; 615 *usec = 0; 616 617 ratestr = xenbus_read(XBT_NIL, dev->nodename, "rate", NULL); 618 if (IS_ERR(ratestr)) 619 return; 620 621 s = ratestr; 622 b = simple_strtoul(s, &e, 10); 623 if ((s == e) || (*e != ',')) 624 goto fail; 625 626 s = e + 1; 627 u = simple_strtoul(s, &e, 10); 628 if ((s == e) || (*e != '\0')) 629 goto fail; 630 631 *bytes = b; 632 *usec = u; 633 634 kfree(ratestr); 635 return; 636 637 fail: 638 pr_warn("Failed to parse network rate limit. Traffic unlimited.\n"); 639 kfree(ratestr); 640 } 641 642 static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[]) 643 { 644 char *s, *e, *macstr; 645 int i; 646 647 macstr = s = xenbus_read(XBT_NIL, dev->nodename, "mac", NULL); 648 if (IS_ERR(macstr)) 649 return PTR_ERR(macstr); 650 651 for (i = 0; i < ETH_ALEN; i++) { 652 mac[i] = simple_strtoul(s, &e, 16); 653 if ((s == e) || (*e != ((i == ETH_ALEN-1) ? '\0' : ':'))) { 654 kfree(macstr); 655 return -ENOENT; 656 } 657 s = e+1; 658 } 659 660 kfree(macstr); 661 return 0; 662 } 663 664 static void xen_net_rate_changed(struct xenbus_watch *watch, 665 const char **vec, unsigned int len) 666 { 667 struct xenvif *vif = container_of(watch, struct xenvif, credit_watch); 668 struct xenbus_device *dev = xenvif_to_xenbus_device(vif); 669 unsigned long credit_bytes; 670 unsigned long credit_usec; 671 unsigned int queue_index; 672 673 xen_net_read_rate(dev, &credit_bytes, &credit_usec); 674 for (queue_index = 0; queue_index < vif->num_queues; queue_index++) { 675 struct xenvif_queue *queue = &vif->queues[queue_index]; 676 677 queue->credit_bytes = credit_bytes; 678 queue->credit_usec = credit_usec; 679 if (!mod_timer_pending(&queue->credit_timeout, jiffies) && 680 queue->remaining_credit > queue->credit_bytes) { 681 queue->remaining_credit = queue->credit_bytes; 682 } 683 } 684 } 685 686 static int xen_register_watchers(struct xenbus_device *dev, struct xenvif *vif) 687 { 688 int err = 0; 689 char *node; 690 unsigned maxlen = strlen(dev->nodename) + sizeof("/rate"); 691 692 if (vif->credit_watch.node) 693 return -EADDRINUSE; 694 695 node = kmalloc(maxlen, GFP_KERNEL); 696 if (!node) 697 return -ENOMEM; 698 snprintf(node, maxlen, "%s/rate", dev->nodename); 699 vif->credit_watch.node = node; 700 vif->credit_watch.callback = xen_net_rate_changed; 701 err = register_xenbus_watch(&vif->credit_watch); 702 if (err) { 703 pr_err("Failed to set watcher %s\n", vif->credit_watch.node); 704 kfree(node); 705 vif->credit_watch.node = NULL; 706 vif->credit_watch.callback = NULL; 707 } 708 return err; 709 } 710 711 static void xen_unregister_watchers(struct xenvif *vif) 712 { 713 if (vif->credit_watch.node) { 714 unregister_xenbus_watch(&vif->credit_watch); 715 kfree(vif->credit_watch.node); 716 vif->credit_watch.node = NULL; 717 } 718 } 719 720 static void unregister_hotplug_status_watch(struct backend_info *be) 721 { 722 if (be->have_hotplug_status_watch) { 723 unregister_xenbus_watch(&be->hotplug_status_watch); 724 kfree(be->hotplug_status_watch.node); 725 } 726 be->have_hotplug_status_watch = 0; 727 } 728 729 static void hotplug_status_changed(struct xenbus_watch *watch, 730 const char **vec, 731 unsigned int vec_size) 732 { 733 struct backend_info *be = container_of(watch, 734 struct backend_info, 735 hotplug_status_watch); 736 char *str; 737 unsigned int len; 738 739 str = xenbus_read(XBT_NIL, be->dev->nodename, "hotplug-status", &len); 740 if (IS_ERR(str)) 741 return; 742 if (len == sizeof("connected")-1 && !memcmp(str, "connected", len)) { 743 /* Complete any pending state change */ 744 xenbus_switch_state(be->dev, be->state); 745 746 /* Not interested in this watch anymore. */ 747 unregister_hotplug_status_watch(be); 748 } 749 kfree(str); 750 } 751 752 static void connect(struct backend_info *be) 753 { 754 int err; 755 struct xenbus_device *dev = be->dev; 756 unsigned long credit_bytes, credit_usec; 757 unsigned int queue_index; 758 unsigned int requested_num_queues; 759 struct xenvif_queue *queue; 760 761 /* Check whether the frontend requested multiple queues 762 * and read the number requested. 763 */ 764 err = xenbus_scanf(XBT_NIL, dev->otherend, 765 "multi-queue-num-queues", 766 "%u", &requested_num_queues); 767 if (err < 0) { 768 requested_num_queues = 1; /* Fall back to single queue */ 769 } else if (requested_num_queues > xenvif_max_queues) { 770 /* buggy or malicious guest */ 771 xenbus_dev_fatal(dev, err, 772 "guest requested %u queues, exceeding the maximum of %u.", 773 requested_num_queues, xenvif_max_queues); 774 return; 775 } 776 777 err = xen_net_read_mac(dev, be->vif->fe_dev_addr); 778 if (err) { 779 xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename); 780 return; 781 } 782 783 xen_net_read_rate(dev, &credit_bytes, &credit_usec); 784 xen_unregister_watchers(be->vif); 785 xen_register_watchers(dev, be->vif); 786 read_xenbus_vif_flags(be); 787 788 /* Use the number of queues requested by the frontend */ 789 be->vif->queues = vzalloc(requested_num_queues * 790 sizeof(struct xenvif_queue)); 791 if (!be->vif->queues) { 792 xenbus_dev_fatal(dev, -ENOMEM, 793 "allocating queues"); 794 return; 795 } 796 797 be->vif->num_queues = requested_num_queues; 798 be->vif->stalled_queues = requested_num_queues; 799 800 for (queue_index = 0; queue_index < requested_num_queues; ++queue_index) { 801 queue = &be->vif->queues[queue_index]; 802 queue->vif = be->vif; 803 queue->id = queue_index; 804 snprintf(queue->name, sizeof(queue->name), "%s-q%u", 805 be->vif->dev->name, queue->id); 806 807 err = xenvif_init_queue(queue); 808 if (err) { 809 /* xenvif_init_queue() cleans up after itself on 810 * failure, but we need to clean up any previously 811 * initialised queues. Set num_queues to i so that 812 * earlier queues can be destroyed using the regular 813 * disconnect logic. 814 */ 815 be->vif->num_queues = queue_index; 816 goto err; 817 } 818 819 queue->credit_bytes = credit_bytes; 820 queue->remaining_credit = credit_bytes; 821 queue->credit_usec = credit_usec; 822 823 err = connect_rings(be, queue); 824 if (err) { 825 /* connect_rings() cleans up after itself on failure, 826 * but we need to clean up after xenvif_init_queue() here, 827 * and also clean up any previously initialised queues. 828 */ 829 xenvif_deinit_queue(queue); 830 be->vif->num_queues = queue_index; 831 goto err; 832 } 833 } 834 835 #ifdef CONFIG_DEBUG_FS 836 xenvif_debugfs_addif(be->vif); 837 #endif /* CONFIG_DEBUG_FS */ 838 839 /* Initialisation completed, tell core driver the number of 840 * active queues. 841 */ 842 rtnl_lock(); 843 netif_set_real_num_tx_queues(be->vif->dev, requested_num_queues); 844 netif_set_real_num_rx_queues(be->vif->dev, requested_num_queues); 845 rtnl_unlock(); 846 847 xenvif_carrier_on(be->vif); 848 849 unregister_hotplug_status_watch(be); 850 err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, 851 hotplug_status_changed, 852 "%s/%s", dev->nodename, "hotplug-status"); 853 if (!err) 854 be->have_hotplug_status_watch = 1; 855 856 netif_tx_wake_all_queues(be->vif->dev); 857 858 return; 859 860 err: 861 if (be->vif->num_queues > 0) 862 xenvif_disconnect(be->vif); /* Clean up existing queues */ 863 vfree(be->vif->queues); 864 be->vif->queues = NULL; 865 be->vif->num_queues = 0; 866 return; 867 } 868 869 870 static int connect_rings(struct backend_info *be, struct xenvif_queue *queue) 871 { 872 struct xenbus_device *dev = be->dev; 873 unsigned int num_queues = queue->vif->num_queues; 874 unsigned long tx_ring_ref, rx_ring_ref; 875 unsigned int tx_evtchn, rx_evtchn; 876 int err; 877 char *xspath; 878 size_t xspathsize; 879 const size_t xenstore_path_ext_size = 11; /* sufficient for "/queue-NNN" */ 880 881 /* If the frontend requested 1 queue, or we have fallen back 882 * to single queue due to lack of frontend support for multi- 883 * queue, expect the remaining XenStore keys in the toplevel 884 * directory. Otherwise, expect them in a subdirectory called 885 * queue-N. 886 */ 887 if (num_queues == 1) { 888 xspath = kzalloc(strlen(dev->otherend) + 1, GFP_KERNEL); 889 if (!xspath) { 890 xenbus_dev_fatal(dev, -ENOMEM, 891 "reading ring references"); 892 return -ENOMEM; 893 } 894 strcpy(xspath, dev->otherend); 895 } else { 896 xspathsize = strlen(dev->otherend) + xenstore_path_ext_size; 897 xspath = kzalloc(xspathsize, GFP_KERNEL); 898 if (!xspath) { 899 xenbus_dev_fatal(dev, -ENOMEM, 900 "reading ring references"); 901 return -ENOMEM; 902 } 903 snprintf(xspath, xspathsize, "%s/queue-%u", dev->otherend, 904 queue->id); 905 } 906 907 err = xenbus_gather(XBT_NIL, xspath, 908 "tx-ring-ref", "%lu", &tx_ring_ref, 909 "rx-ring-ref", "%lu", &rx_ring_ref, NULL); 910 if (err) { 911 xenbus_dev_fatal(dev, err, 912 "reading %s/ring-ref", 913 xspath); 914 goto err; 915 } 916 917 /* Try split event channels first, then single event channel. */ 918 err = xenbus_gather(XBT_NIL, xspath, 919 "event-channel-tx", "%u", &tx_evtchn, 920 "event-channel-rx", "%u", &rx_evtchn, NULL); 921 if (err < 0) { 922 err = xenbus_scanf(XBT_NIL, xspath, 923 "event-channel", "%u", &tx_evtchn); 924 if (err < 0) { 925 xenbus_dev_fatal(dev, err, 926 "reading %s/event-channel(-tx/rx)", 927 xspath); 928 goto err; 929 } 930 rx_evtchn = tx_evtchn; 931 } 932 933 /* Map the shared frame, irq etc. */ 934 err = xenvif_connect(queue, tx_ring_ref, rx_ring_ref, 935 tx_evtchn, rx_evtchn); 936 if (err) { 937 xenbus_dev_fatal(dev, err, 938 "mapping shared-frames %lu/%lu port tx %u rx %u", 939 tx_ring_ref, rx_ring_ref, 940 tx_evtchn, rx_evtchn); 941 goto err; 942 } 943 944 err = 0; 945 err: /* Regular return falls through with err == 0 */ 946 kfree(xspath); 947 return err; 948 } 949 950 static int read_xenbus_vif_flags(struct backend_info *be) 951 { 952 struct xenvif *vif = be->vif; 953 struct xenbus_device *dev = be->dev; 954 unsigned int rx_copy; 955 int err, val; 956 957 err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u", 958 &rx_copy); 959 if (err == -ENOENT) { 960 err = 0; 961 rx_copy = 0; 962 } 963 if (err < 0) { 964 xenbus_dev_fatal(dev, err, "reading %s/request-rx-copy", 965 dev->otherend); 966 return err; 967 } 968 if (!rx_copy) 969 return -EOPNOTSUPP; 970 971 if (xenbus_scanf(XBT_NIL, dev->otherend, 972 "feature-rx-notify", "%d", &val) < 0) 973 val = 0; 974 if (!val) { 975 /* - Reduce drain timeout to poll more frequently for 976 * Rx requests. 977 * - Disable Rx stall detection. 978 */ 979 be->vif->drain_timeout = msecs_to_jiffies(30); 980 be->vif->stall_timeout = 0; 981 } 982 983 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-sg", 984 "%d", &val) < 0) 985 val = 0; 986 vif->can_sg = !!val; 987 988 vif->gso_mask = 0; 989 vif->gso_prefix_mask = 0; 990 991 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4", 992 "%d", &val) < 0) 993 val = 0; 994 if (val) 995 vif->gso_mask |= GSO_BIT(TCPV4); 996 997 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4-prefix", 998 "%d", &val) < 0) 999 val = 0; 1000 if (val) 1001 vif->gso_prefix_mask |= GSO_BIT(TCPV4); 1002 1003 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv6", 1004 "%d", &val) < 0) 1005 val = 0; 1006 if (val) 1007 vif->gso_mask |= GSO_BIT(TCPV6); 1008 1009 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv6-prefix", 1010 "%d", &val) < 0) 1011 val = 0; 1012 if (val) 1013 vif->gso_prefix_mask |= GSO_BIT(TCPV6); 1014 1015 if (vif->gso_mask & vif->gso_prefix_mask) { 1016 xenbus_dev_fatal(dev, err, 1017 "%s: gso and gso prefix flags are not " 1018 "mutually exclusive", 1019 dev->otherend); 1020 return -EOPNOTSUPP; 1021 } 1022 1023 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-no-csum-offload", 1024 "%d", &val) < 0) 1025 val = 0; 1026 vif->ip_csum = !val; 1027 1028 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-ipv6-csum-offload", 1029 "%d", &val) < 0) 1030 val = 0; 1031 vif->ipv6_csum = !!val; 1032 1033 if (xenbus_scanf(XBT_NIL, dev->otherend, "request-multicast-control", 1034 "%d", &val) < 0) 1035 val = 0; 1036 vif->multicast_control = !!val; 1037 1038 return 0; 1039 } 1040 1041 static const struct xenbus_device_id netback_ids[] = { 1042 { "vif" }, 1043 { "" } 1044 }; 1045 1046 static struct xenbus_driver netback_driver = { 1047 .ids = netback_ids, 1048 .probe = netback_probe, 1049 .remove = netback_remove, 1050 .uevent = netback_uevent, 1051 .otherend_changed = frontend_changed, 1052 }; 1053 1054 int xenvif_xenbus_init(void) 1055 { 1056 return xenbus_register_backend(&netback_driver); 1057 } 1058 1059 void xenvif_xenbus_fini(void) 1060 { 1061 return xenbus_unregister_driver(&netback_driver); 1062 } 1063