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 25struct 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 41static int connect_rings(struct backend_info *be, struct xenvif_queue *queue); 42static void connect(struct backend_info *be); 43static int read_xenbus_vif_flags(struct backend_info *be); 44static int backend_create_xenvif(struct backend_info *be); 45static void unregister_hotplug_status_watch(struct backend_info *be); 46static void xen_unregister_watchers(struct xenvif *vif); 47static void set_backend_state(struct backend_info *be, 48 enum xenbus_state state); 49 50#ifdef CONFIG_DEBUG_FS 51struct dentry *xen_netback_dbg_root = NULL; 52 53static 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 132static ssize_t 133xenvif_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 167static 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 179static 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 188static 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 218static 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 229static 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 */ 254static 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 err = xenbus_transaction_end(xbt, 0); 331 } while (err == -EAGAIN); 332 333 if (err) { 334 xenbus_dev_fatal(dev, err, "completing transaction"); 335 goto fail; 336 } 337 338 /* 339 * Split event channels support, this is optional so it is not 340 * put inside the above loop. 341 */ 342 err = xenbus_printf(XBT_NIL, dev->nodename, 343 "feature-split-event-channels", 344 "%u", separate_tx_rx_irq); 345 if (err) 346 pr_debug("Error writing feature-split-event-channels\n"); 347 348 /* Multi-queue support: This is an optional feature. */ 349 err = xenbus_printf(XBT_NIL, dev->nodename, 350 "multi-queue-max-queues", "%u", xenvif_max_queues); 351 if (err) 352 pr_debug("Error writing multi-queue-max-queues\n"); 353 354 script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL); 355 if (IS_ERR(script)) { 356 err = PTR_ERR(script); 357 xenbus_dev_fatal(dev, err, "reading script"); 358 goto fail; 359 } 360 361 be->hotplug_script = script; 362 363 err = xenbus_switch_state(dev, XenbusStateInitWait); 364 if (err) 365 goto fail; 366 367 be->state = XenbusStateInitWait; 368 369 /* This kicks hotplug scripts, so do it immediately. */ 370 err = backend_create_xenvif(be); 371 if (err) 372 goto fail; 373 374 return 0; 375 376abort_transaction: 377 xenbus_transaction_end(xbt, 1); 378 xenbus_dev_fatal(dev, err, "%s", message); 379fail: 380 pr_debug("failed\n"); 381 netback_remove(dev); 382 return err; 383} 384 385 386/* 387 * Handle the creation of the hotplug script environment. We add the script 388 * and vif variables to the environment, for the benefit of the vif-* hotplug 389 * scripts. 390 */ 391static int netback_uevent(struct xenbus_device *xdev, 392 struct kobj_uevent_env *env) 393{ 394 struct backend_info *be = dev_get_drvdata(&xdev->dev); 395 396 if (!be) 397 return 0; 398 399 if (add_uevent_var(env, "script=%s", be->hotplug_script)) 400 return -ENOMEM; 401 402 if (!be->vif) 403 return 0; 404 405 return add_uevent_var(env, "vif=%s", be->vif->dev->name); 406} 407 408 409static int backend_create_xenvif(struct backend_info *be) 410{ 411 int err; 412 long handle; 413 struct xenbus_device *dev = be->dev; 414 struct xenvif *vif; 415 416 if (be->vif != NULL) 417 return 0; 418 419 err = xenbus_scanf(XBT_NIL, dev->nodename, "handle", "%li", &handle); 420 if (err != 1) { 421 xenbus_dev_fatal(dev, err, "reading handle"); 422 return (err < 0) ? err : -EINVAL; 423 } 424 425 vif = xenvif_alloc(&dev->dev, dev->otherend_id, handle); 426 if (IS_ERR(vif)) { 427 err = PTR_ERR(vif); 428 xenbus_dev_fatal(dev, err, "creating interface"); 429 return err; 430 } 431 be->vif = vif; 432 433 kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE); 434 return 0; 435} 436 437static void backend_disconnect(struct backend_info *be) 438{ 439 if (be->vif) { 440 xen_unregister_watchers(be->vif); 441#ifdef CONFIG_DEBUG_FS 442 xenvif_debugfs_delif(be->vif); 443#endif /* CONFIG_DEBUG_FS */ 444 xenvif_disconnect(be->vif); 445 } 446} 447 448static void backend_connect(struct backend_info *be) 449{ 450 if (be->vif) 451 connect(be); 452} 453 454static inline void backend_switch_state(struct backend_info *be, 455 enum xenbus_state state) 456{ 457 struct xenbus_device *dev = be->dev; 458 459 pr_debug("%s -> %s\n", dev->nodename, xenbus_strstate(state)); 460 be->state = state; 461 462 /* If we are waiting for a hotplug script then defer the 463 * actual xenbus state change. 464 */ 465 if (!be->have_hotplug_status_watch) 466 xenbus_switch_state(dev, state); 467} 468 469/* Handle backend state transitions: 470 * 471 * The backend state starts in InitWait and the following transitions are 472 * allowed. 473 * 474 * InitWait -> Connected 475 * 476 * ^ \ | 477 * | \ | 478 * | \ | 479 * | \ | 480 * | \ | 481 * | \ | 482 * | V V 483 * 484 * Closed <-> Closing 485 * 486 * The state argument specifies the eventual state of the backend and the 487 * function transitions to that state via the shortest path. 488 */ 489static void set_backend_state(struct backend_info *be, 490 enum xenbus_state state) 491{ 492 while (be->state != state) { 493 switch (be->state) { 494 case XenbusStateClosed: 495 switch (state) { 496 case XenbusStateInitWait: 497 case XenbusStateConnected: 498 pr_info("%s: prepare for reconnect\n", 499 be->dev->nodename); 500 backend_switch_state(be, XenbusStateInitWait); 501 break; 502 case XenbusStateClosing: 503 backend_switch_state(be, XenbusStateClosing); 504 break; 505 default: 506 BUG(); 507 } 508 break; 509 case XenbusStateInitWait: 510 switch (state) { 511 case XenbusStateConnected: 512 backend_connect(be); 513 backend_switch_state(be, XenbusStateConnected); 514 break; 515 case XenbusStateClosing: 516 case XenbusStateClosed: 517 backend_switch_state(be, XenbusStateClosing); 518 break; 519 default: 520 BUG(); 521 } 522 break; 523 case XenbusStateConnected: 524 switch (state) { 525 case XenbusStateInitWait: 526 case XenbusStateClosing: 527 case XenbusStateClosed: 528 backend_disconnect(be); 529 backend_switch_state(be, XenbusStateClosing); 530 break; 531 default: 532 BUG(); 533 } 534 break; 535 case XenbusStateClosing: 536 switch (state) { 537 case XenbusStateInitWait: 538 case XenbusStateConnected: 539 case XenbusStateClosed: 540 backend_switch_state(be, XenbusStateClosed); 541 break; 542 default: 543 BUG(); 544 } 545 break; 546 default: 547 BUG(); 548 } 549 } 550} 551 552/** 553 * Callback received when the frontend's state changes. 554 */ 555static void frontend_changed(struct xenbus_device *dev, 556 enum xenbus_state frontend_state) 557{ 558 struct backend_info *be = dev_get_drvdata(&dev->dev); 559 560 pr_debug("%s -> %s\n", dev->otherend, xenbus_strstate(frontend_state)); 561 562 be->frontend_state = frontend_state; 563 564 switch (frontend_state) { 565 case XenbusStateInitialising: 566 set_backend_state(be, XenbusStateInitWait); 567 break; 568 569 case XenbusStateInitialised: 570 break; 571 572 case XenbusStateConnected: 573 set_backend_state(be, XenbusStateConnected); 574 break; 575 576 case XenbusStateClosing: 577 set_backend_state(be, XenbusStateClosing); 578 break; 579 580 case XenbusStateClosed: 581 set_backend_state(be, XenbusStateClosed); 582 if (xenbus_dev_is_online(dev)) 583 break; 584 /* fall through if not online */ 585 case XenbusStateUnknown: 586 set_backend_state(be, XenbusStateClosed); 587 device_unregister(&dev->dev); 588 break; 589 590 default: 591 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend", 592 frontend_state); 593 break; 594 } 595} 596 597 598static void xen_net_read_rate(struct xenbus_device *dev, 599 unsigned long *bytes, unsigned long *usec) 600{ 601 char *s, *e; 602 unsigned long b, u; 603 char *ratestr; 604 605 /* Default to unlimited bandwidth. */ 606 *bytes = ~0UL; 607 *usec = 0; 608 609 ratestr = xenbus_read(XBT_NIL, dev->nodename, "rate", NULL); 610 if (IS_ERR(ratestr)) 611 return; 612 613 s = ratestr; 614 b = simple_strtoul(s, &e, 10); 615 if ((s == e) || (*e != ',')) 616 goto fail; 617 618 s = e + 1; 619 u = simple_strtoul(s, &e, 10); 620 if ((s == e) || (*e != '\0')) 621 goto fail; 622 623 *bytes = b; 624 *usec = u; 625 626 kfree(ratestr); 627 return; 628 629 fail: 630 pr_warn("Failed to parse network rate limit. Traffic unlimited.\n"); 631 kfree(ratestr); 632} 633 634static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[]) 635{ 636 char *s, *e, *macstr; 637 int i; 638 639 macstr = s = xenbus_read(XBT_NIL, dev->nodename, "mac", NULL); 640 if (IS_ERR(macstr)) 641 return PTR_ERR(macstr); 642 643 for (i = 0; i < ETH_ALEN; i++) { 644 mac[i] = simple_strtoul(s, &e, 16); 645 if ((s == e) || (*e != ((i == ETH_ALEN-1) ? '\0' : ':'))) { 646 kfree(macstr); 647 return -ENOENT; 648 } 649 s = e+1; 650 } 651 652 kfree(macstr); 653 return 0; 654} 655 656static void xen_net_rate_changed(struct xenbus_watch *watch, 657 const char **vec, unsigned int len) 658{ 659 struct xenvif *vif = container_of(watch, struct xenvif, credit_watch); 660 struct xenbus_device *dev = xenvif_to_xenbus_device(vif); 661 unsigned long credit_bytes; 662 unsigned long credit_usec; 663 unsigned int queue_index; 664 665 xen_net_read_rate(dev, &credit_bytes, &credit_usec); 666 for (queue_index = 0; queue_index < vif->num_queues; queue_index++) { 667 struct xenvif_queue *queue = &vif->queues[queue_index]; 668 669 queue->credit_bytes = credit_bytes; 670 queue->credit_usec = credit_usec; 671 if (!mod_timer_pending(&queue->credit_timeout, jiffies) && 672 queue->remaining_credit > queue->credit_bytes) { 673 queue->remaining_credit = queue->credit_bytes; 674 } 675 } 676} 677 678static int xen_register_watchers(struct xenbus_device *dev, struct xenvif *vif) 679{ 680 int err = 0; 681 char *node; 682 unsigned maxlen = strlen(dev->nodename) + sizeof("/rate"); 683 684 if (vif->credit_watch.node) 685 return -EADDRINUSE; 686 687 node = kmalloc(maxlen, GFP_KERNEL); 688 if (!node) 689 return -ENOMEM; 690 snprintf(node, maxlen, "%s/rate", dev->nodename); 691 vif->credit_watch.node = node; 692 vif->credit_watch.callback = xen_net_rate_changed; 693 err = register_xenbus_watch(&vif->credit_watch); 694 if (err) { 695 pr_err("Failed to set watcher %s\n", vif->credit_watch.node); 696 kfree(node); 697 vif->credit_watch.node = NULL; 698 vif->credit_watch.callback = NULL; 699 } 700 return err; 701} 702 703static void xen_unregister_watchers(struct xenvif *vif) 704{ 705 if (vif->credit_watch.node) { 706 unregister_xenbus_watch(&vif->credit_watch); 707 kfree(vif->credit_watch.node); 708 vif->credit_watch.node = NULL; 709 } 710} 711 712static void unregister_hotplug_status_watch(struct backend_info *be) 713{ 714 if (be->have_hotplug_status_watch) { 715 unregister_xenbus_watch(&be->hotplug_status_watch); 716 kfree(be->hotplug_status_watch.node); 717 } 718 be->have_hotplug_status_watch = 0; 719} 720 721static void hotplug_status_changed(struct xenbus_watch *watch, 722 const char **vec, 723 unsigned int vec_size) 724{ 725 struct backend_info *be = container_of(watch, 726 struct backend_info, 727 hotplug_status_watch); 728 char *str; 729 unsigned int len; 730 731 str = xenbus_read(XBT_NIL, be->dev->nodename, "hotplug-status", &len); 732 if (IS_ERR(str)) 733 return; 734 if (len == sizeof("connected")-1 && !memcmp(str, "connected", len)) { 735 /* Complete any pending state change */ 736 xenbus_switch_state(be->dev, be->state); 737 738 /* Not interested in this watch anymore. */ 739 unregister_hotplug_status_watch(be); 740 } 741 kfree(str); 742} 743 744static void connect(struct backend_info *be) 745{ 746 int err; 747 struct xenbus_device *dev = be->dev; 748 unsigned long credit_bytes, credit_usec; 749 unsigned int queue_index; 750 unsigned int requested_num_queues; 751 struct xenvif_queue *queue; 752 753 /* Check whether the frontend requested multiple queues 754 * and read the number requested. 755 */ 756 err = xenbus_scanf(XBT_NIL, dev->otherend, 757 "multi-queue-num-queues", 758 "%u", &requested_num_queues); 759 if (err < 0) { 760 requested_num_queues = 1; /* Fall back to single queue */ 761 } else if (requested_num_queues > xenvif_max_queues) { 762 /* buggy or malicious guest */ 763 xenbus_dev_fatal(dev, err, 764 "guest requested %u queues, exceeding the maximum of %u.", 765 requested_num_queues, xenvif_max_queues); 766 return; 767 } 768 769 err = xen_net_read_mac(dev, be->vif->fe_dev_addr); 770 if (err) { 771 xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename); 772 return; 773 } 774 775 xen_net_read_rate(dev, &credit_bytes, &credit_usec); 776 xen_unregister_watchers(be->vif); 777 xen_register_watchers(dev, be->vif); 778 read_xenbus_vif_flags(be); 779 780 /* Use the number of queues requested by the frontend */ 781 be->vif->queues = vzalloc(requested_num_queues * 782 sizeof(struct xenvif_queue)); 783 be->vif->num_queues = requested_num_queues; 784 be->vif->stalled_queues = requested_num_queues; 785 786 for (queue_index = 0; queue_index < requested_num_queues; ++queue_index) { 787 queue = &be->vif->queues[queue_index]; 788 queue->vif = be->vif; 789 queue->id = queue_index; 790 snprintf(queue->name, sizeof(queue->name), "%s-q%u", 791 be->vif->dev->name, queue->id); 792 793 err = xenvif_init_queue(queue); 794 if (err) { 795 /* xenvif_init_queue() cleans up after itself on 796 * failure, but we need to clean up any previously 797 * initialised queues. Set num_queues to i so that 798 * earlier queues can be destroyed using the regular 799 * disconnect logic. 800 */ 801 be->vif->num_queues = queue_index; 802 goto err; 803 } 804 805 queue->credit_bytes = credit_bytes; 806 queue->remaining_credit = credit_bytes; 807 queue->credit_usec = credit_usec; 808 809 err = connect_rings(be, queue); 810 if (err) { 811 /* connect_rings() cleans up after itself on failure, 812 * but we need to clean up after xenvif_init_queue() here, 813 * and also clean up any previously initialised queues. 814 */ 815 xenvif_deinit_queue(queue); 816 be->vif->num_queues = queue_index; 817 goto err; 818 } 819 } 820 821#ifdef CONFIG_DEBUG_FS 822 xenvif_debugfs_addif(be->vif); 823#endif /* CONFIG_DEBUG_FS */ 824 825 /* Initialisation completed, tell core driver the number of 826 * active queues. 827 */ 828 rtnl_lock(); 829 netif_set_real_num_tx_queues(be->vif->dev, requested_num_queues); 830 netif_set_real_num_rx_queues(be->vif->dev, requested_num_queues); 831 rtnl_unlock(); 832 833 xenvif_carrier_on(be->vif); 834 835 unregister_hotplug_status_watch(be); 836 err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, 837 hotplug_status_changed, 838 "%s/%s", dev->nodename, "hotplug-status"); 839 if (!err) 840 be->have_hotplug_status_watch = 1; 841 842 netif_tx_wake_all_queues(be->vif->dev); 843 844 return; 845 846err: 847 if (be->vif->num_queues > 0) 848 xenvif_disconnect(be->vif); /* Clean up existing queues */ 849 vfree(be->vif->queues); 850 be->vif->queues = NULL; 851 be->vif->num_queues = 0; 852 return; 853} 854 855 856static int connect_rings(struct backend_info *be, struct xenvif_queue *queue) 857{ 858 struct xenbus_device *dev = be->dev; 859 unsigned int num_queues = queue->vif->num_queues; 860 unsigned long tx_ring_ref, rx_ring_ref; 861 unsigned int tx_evtchn, rx_evtchn; 862 int err; 863 char *xspath; 864 size_t xspathsize; 865 const size_t xenstore_path_ext_size = 11; /* sufficient for "/queue-NNN" */ 866 867 /* If the frontend requested 1 queue, or we have fallen back 868 * to single queue due to lack of frontend support for multi- 869 * queue, expect the remaining XenStore keys in the toplevel 870 * directory. Otherwise, expect them in a subdirectory called 871 * queue-N. 872 */ 873 if (num_queues == 1) { 874 xspath = kzalloc(strlen(dev->otherend) + 1, GFP_KERNEL); 875 if (!xspath) { 876 xenbus_dev_fatal(dev, -ENOMEM, 877 "reading ring references"); 878 return -ENOMEM; 879 } 880 strcpy(xspath, dev->otherend); 881 } else { 882 xspathsize = strlen(dev->otherend) + xenstore_path_ext_size; 883 xspath = kzalloc(xspathsize, GFP_KERNEL); 884 if (!xspath) { 885 xenbus_dev_fatal(dev, -ENOMEM, 886 "reading ring references"); 887 return -ENOMEM; 888 } 889 snprintf(xspath, xspathsize, "%s/queue-%u", dev->otherend, 890 queue->id); 891 } 892 893 err = xenbus_gather(XBT_NIL, xspath, 894 "tx-ring-ref", "%lu", &tx_ring_ref, 895 "rx-ring-ref", "%lu", &rx_ring_ref, NULL); 896 if (err) { 897 xenbus_dev_fatal(dev, err, 898 "reading %s/ring-ref", 899 xspath); 900 goto err; 901 } 902 903 /* Try split event channels first, then single event channel. */ 904 err = xenbus_gather(XBT_NIL, xspath, 905 "event-channel-tx", "%u", &tx_evtchn, 906 "event-channel-rx", "%u", &rx_evtchn, NULL); 907 if (err < 0) { 908 err = xenbus_scanf(XBT_NIL, xspath, 909 "event-channel", "%u", &tx_evtchn); 910 if (err < 0) { 911 xenbus_dev_fatal(dev, err, 912 "reading %s/event-channel(-tx/rx)", 913 xspath); 914 goto err; 915 } 916 rx_evtchn = tx_evtchn; 917 } 918 919 /* Map the shared frame, irq etc. */ 920 err = xenvif_connect(queue, tx_ring_ref, rx_ring_ref, 921 tx_evtchn, rx_evtchn); 922 if (err) { 923 xenbus_dev_fatal(dev, err, 924 "mapping shared-frames %lu/%lu port tx %u rx %u", 925 tx_ring_ref, rx_ring_ref, 926 tx_evtchn, rx_evtchn); 927 goto err; 928 } 929 930 err = 0; 931err: /* Regular return falls through with err == 0 */ 932 kfree(xspath); 933 return err; 934} 935 936static int read_xenbus_vif_flags(struct backend_info *be) 937{ 938 struct xenvif *vif = be->vif; 939 struct xenbus_device *dev = be->dev; 940 unsigned int rx_copy; 941 int err, val; 942 943 err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u", 944 &rx_copy); 945 if (err == -ENOENT) { 946 err = 0; 947 rx_copy = 0; 948 } 949 if (err < 0) { 950 xenbus_dev_fatal(dev, err, "reading %s/request-rx-copy", 951 dev->otherend); 952 return err; 953 } 954 if (!rx_copy) 955 return -EOPNOTSUPP; 956 957 if (xenbus_scanf(XBT_NIL, dev->otherend, 958 "feature-rx-notify", "%d", &val) < 0) 959 val = 0; 960 if (!val) { 961 /* - Reduce drain timeout to poll more frequently for 962 * Rx requests. 963 * - Disable Rx stall detection. 964 */ 965 be->vif->drain_timeout = msecs_to_jiffies(30); 966 be->vif->stall_timeout = 0; 967 } 968 969 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-sg", 970 "%d", &val) < 0) 971 val = 0; 972 vif->can_sg = !!val; 973 974 vif->gso_mask = 0; 975 vif->gso_prefix_mask = 0; 976 977 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4", 978 "%d", &val) < 0) 979 val = 0; 980 if (val) 981 vif->gso_mask |= GSO_BIT(TCPV4); 982 983 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4-prefix", 984 "%d", &val) < 0) 985 val = 0; 986 if (val) 987 vif->gso_prefix_mask |= GSO_BIT(TCPV4); 988 989 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv6", 990 "%d", &val) < 0) 991 val = 0; 992 if (val) 993 vif->gso_mask |= GSO_BIT(TCPV6); 994 995 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv6-prefix", 996 "%d", &val) < 0) 997 val = 0; 998 if (val) 999 vif->gso_prefix_mask |= GSO_BIT(TCPV6); 1000 1001 if (vif->gso_mask & vif->gso_prefix_mask) { 1002 xenbus_dev_fatal(dev, err, 1003 "%s: gso and gso prefix flags are not " 1004 "mutually exclusive", 1005 dev->otherend); 1006 return -EOPNOTSUPP; 1007 } 1008 1009 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-no-csum-offload", 1010 "%d", &val) < 0) 1011 val = 0; 1012 vif->ip_csum = !val; 1013 1014 if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-ipv6-csum-offload", 1015 "%d", &val) < 0) 1016 val = 0; 1017 vif->ipv6_csum = !!val; 1018 1019 return 0; 1020} 1021 1022static const struct xenbus_device_id netback_ids[] = { 1023 { "vif" }, 1024 { "" } 1025}; 1026 1027static struct xenbus_driver netback_driver = { 1028 .ids = netback_ids, 1029 .probe = netback_probe, 1030 .remove = netback_remove, 1031 .uevent = netback_uevent, 1032 .otherend_changed = frontend_changed, 1033}; 1034 1035int xenvif_xenbus_init(void) 1036{ 1037 return xenbus_register_backend(&netback_driver); 1038} 1039 1040void xenvif_xenbus_fini(void) 1041{ 1042 return xenbus_unregister_driver(&netback_driver); 1043} 1044