drivers/net/xen-netback/xenbus.c

   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, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20 */
  21
  22 #include "common.h"
  23
  24 struct backend_info {
  25         struct xenbus_device *dev;
  26         struct xenvif *vif;
  27
  28         /* This is the state that will be reflected in xenstore when any
  29          * active hotplug script completes.
  30          */
  31         enum xenbus_state state;
  32
  33         enum xenbus_state frontend_state;
  34         struct xenbus_watch hotplug_status_watch;
  35         u8 have_hotplug_status_watch:1;
  36 };
  37
  38 static int connect_rings(struct backend_info *);
  39 static void connect(struct backend_info *);
  40 static void backend_create_xenvif(struct backend_info *be);
  41 static void unregister_hotplug_status_watch(struct backend_info *be);
  42 static void set_backend_state(struct backend_info *be,
  43                               enum xenbus_state state);
  44
  45 static int netback_remove(struct xenbus_device *dev)
  46 {
  47         struct backend_info *be = dev_get_drvdata(&dev->dev);
  48
  49         set_backend_state(be, XenbusStateClosed);
  50
  51         unregister_hotplug_status_watch(be);
  52         if (be->vif) {
  53                 kobject_uevent(&dev->dev.kobj, KOBJ_OFFLINE);
  54                 xenbus_rm(XBT_NIL, dev->nodename, "hotplug-status");
  55                 xenvif_free(be->vif);
  56                 be->vif = NULL;
  57         }
  58         kfree(be);
  59         dev_set_drvdata(&dev->dev, NULL);
  60         return 0;
  61 }
  62
  63
  64 /**
  65  * Entry point to this code when a new device is created.  Allocate the basic
  66  * structures and switch to InitWait.
  67  */
  68 static int netback_probe(struct xenbus_device *dev,
  69                          const struct xenbus_device_id *id)
  70 {
  71         const char *message;
  72         struct xenbus_transaction xbt;
  73         int err;
  74         int sg;
  75         struct backend_info *be = kzalloc(sizeof(struct backend_info),
  76                                           GFP_KERNEL);
  77         if (!be) {
  78                 xenbus_dev_fatal(dev, -ENOMEM,
  79                                  "allocating backend structure");
  80                 return -ENOMEM;
  81         }
  82
  83         be->dev = dev;
  84         dev_set_drvdata(&dev->dev, be);
  85
  86         sg = 1;
  87
  88         do {
  89                 err = xenbus_transaction_start(&xbt);
  90                 if (err) {
  91                         xenbus_dev_fatal(dev, err, "starting transaction");
  92                         goto fail;
  93                 }
  94
  95                 err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", sg);
  96                 if (err) {
  97                         message = "writing feature-sg";
  98                         goto abort_transaction;
  99                 }
 100
 101                 err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4",
 102                                     "%d", sg);
 103                 if (err) {
 104                         message = "writing feature-gso-tcpv4";
 105                         goto abort_transaction;
 106                 }
 107
 108                 err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv6",
 109                                     "%d", sg);
 110                 if (err) {
 111                         message = "writing feature-gso-tcpv6";
 112                         goto abort_transaction;
 113                 }
 114
 115                 /* We support partial checksum setup for IPv6 packets */
 116                 err = xenbus_printf(xbt, dev->nodename,
 117                                     "feature-ipv6-csum-offload",
 118                                     "%d", 1);
 119                 if (err) {
 120                         message = "writing feature-ipv6-csum-offload";
 121                         goto abort_transaction;
 122                 }
 123
 124                 /* We support rx-copy path. */
 125                 err = xenbus_printf(xbt, dev->nodename,
 126                                     "feature-rx-copy", "%d", 1);
 127                 if (err) {
 128                         message = "writing feature-rx-copy";
 129                         goto abort_transaction;
 130                 }
 131
 132                 /*
 133                  * We don't support rx-flip path (except old guests who don't
 134                  * grok this feature flag).
 135                  */
 136                 err = xenbus_printf(xbt, dev->nodename,
 137                                     "feature-rx-flip", "%d", 0);
 138                 if (err) {
 139                         message = "writing feature-rx-flip";
 140                         goto abort_transaction;
 141                 }
 142
 143                 err = xenbus_transaction_end(xbt, 0);
 144         } while (err == -EAGAIN);
 145
 146         if (err) {
 147                 xenbus_dev_fatal(dev, err, "completing transaction");
 148                 goto fail;
 149         }
 150
 151         /*
 152          * Split event channels support, this is optional so it is not
 153          * put inside the above loop.
 154          */
 155         err = xenbus_printf(XBT_NIL, dev->nodename,
 156                             "feature-split-event-channels",
 157                             "%u", separate_tx_rx_irq);
 158         if (err)
 159                 pr_debug("Error writing feature-split-event-channels\n");
 160
 161         err = xenbus_switch_state(dev, XenbusStateInitWait);
 162         if (err)
 163                 goto fail;
 164
 165         be->state = XenbusStateInitWait;
 166
 167         /* This kicks hotplug scripts, so do it immediately. */
 168         backend_create_xenvif(be);
 169
 170         return 0;
 171
 172 abort_transaction:
 173         xenbus_transaction_end(xbt, 1);
 174         xenbus_dev_fatal(dev, err, "%s", message);
 175 fail:
 176         pr_debug("failed\n");
 177         netback_remove(dev);
 178         return err;
 179 }
 180
 181
 182 /*
 183  * Handle the creation of the hotplug script environment.  We add the script
 184  * and vif variables to the environment, for the benefit of the vif-* hotplug
 185  * scripts.
 186  */
 187 static int netback_uevent(struct xenbus_device *xdev,
 188                           struct kobj_uevent_env *env)
 189 {
 190         struct backend_info *be = dev_get_drvdata(&xdev->dev);
 191         char *val;
 192
 193         val = xenbus_read(XBT_NIL, xdev->nodename, "script", NULL);
 194         if (IS_ERR(val)) {
 195                 int err = PTR_ERR(val);
 196                 xenbus_dev_fatal(xdev, err, "reading script");
 197                 return err;
 198         } else {
 199                 if (add_uevent_var(env, "script=%s", val)) {
 200                         kfree(val);
 201                         return -ENOMEM;
 202                 }
 203                 kfree(val);
 204         }
 205
 206         if (!be || !be->vif)
 207                 return 0;
 208
 209         return add_uevent_var(env, "vif=%s", be->vif->dev->name);
 210 }
 211
 212
 213 static void backend_create_xenvif(struct backend_info *be)
 214 {
 215         int err;
 216         long handle;
 217         struct xenbus_device *dev = be->dev;
 218
 219         if (be->vif != NULL)
 220                 return;
 221
 222         err = xenbus_scanf(XBT_NIL, dev->nodename, "handle", "%li", &handle);
 223         if (err != 1) {
 224                 xenbus_dev_fatal(dev, err, "reading handle");
 225                 return;
 226         }
 227
 228         be->vif = xenvif_alloc(&dev->dev, dev->otherend_id, handle);
 229         if (IS_ERR(be->vif)) {
 230                 err = PTR_ERR(be->vif);
 231                 be->vif = NULL;
 232                 xenbus_dev_fatal(dev, err, "creating interface");
 233                 return;
 234         }
 235
 236         kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE);
 237 }
 238
 239 static void backend_disconnect(struct backend_info *be)
 240 {
 241         if (be->vif)
 242                 xenvif_disconnect(be->vif);
 243 }
 244
 245 static void backend_connect(struct backend_info *be)
 246 {
 247         if (be->vif)
 248                 connect(be);
 249 }
 250
 251 static inline void backend_switch_state(struct backend_info *be,
 252                                         enum xenbus_state state)
 253 {
 254         struct xenbus_device *dev = be->dev;
 255
 256         pr_debug("%s -> %s\n", dev->nodename, xenbus_strstate(state));
 257         be->state = state;
 258
 259         /* If we are waiting for a hotplug script then defer the
 260          * actual xenbus state change.
 261          */
 262         if (!be->have_hotplug_status_watch)
 263                 xenbus_switch_state(dev, state);
 264 }
 265
 266 /* Handle backend state transitions:
 267  *
 268  * The backend state starts in InitWait and the following transitions are
 269  * allowed.
 270  *
 271  * InitWait -> Connected
 272  *
 273  *    ^    \         |
 274  *    |     \        |
 275  *    |      \       |
 276  *    |       \      |
 277  *    |        \     |
 278  *    |         \    |
 279  *    |          V   V
 280  *
 281  *  Closed  <-> Closing
 282  *
 283  * The state argument specifies the eventual state of the backend and the
 284  * function transitions to that state via the shortest path.
 285  */
 286 static void set_backend_state(struct backend_info *be,
 287                               enum xenbus_state state)
 288 {
 289         while (be->state != state) {
 290                 switch (be->state) {
 291                 case XenbusStateClosed:
 292                         switch (state) {
 293                         case XenbusStateInitWait:
 294                         case XenbusStateConnected:
 295                                 pr_info("%s: prepare for reconnect\n",
 296                                         be->dev->nodename);
 297                                 backend_switch_state(be, XenbusStateInitWait);
 298                                 break;
 299                         case XenbusStateClosing:
 300                                 backend_switch_state(be, XenbusStateClosing);
 301                                 break;
 302                         default:
 303                                 BUG();
 304                         }
 305                         break;
 306                 case XenbusStateInitWait:
 307                         switch (state) {
 308                         case XenbusStateConnected:
 309                                 backend_connect(be);
 310                                 backend_switch_state(be, XenbusStateConnected);
 311                                 break;
 312                         case XenbusStateClosing:
 313                         case XenbusStateClosed:
 314                                 backend_switch_state(be, XenbusStateClosing);
 315                                 break;
 316                         default:
 317                                 BUG();
 318                         }
 319                         break;
 320                 case XenbusStateConnected:
 321                         switch (state) {
 322                         case XenbusStateInitWait:
 323                         case XenbusStateClosing:
 324                         case XenbusStateClosed:
 325                                 backend_disconnect(be);
 326                                 backend_switch_state(be, XenbusStateClosing);
 327                                 break;
 328                         default:
 329                                 BUG();
 330                         }
 331                         break;
 332                 case XenbusStateClosing:
 333                         switch (state) {
 334                         case XenbusStateInitWait:
 335                         case XenbusStateConnected:
 336                         case XenbusStateClosed:
 337                                 backend_switch_state(be, XenbusStateClosed);
 338                                 break;
 339                         default:
 340                                 BUG();
 341                         }
 342                         break;
 343                 default:
 344                         BUG();
 345                 }
 346         }
 347 }
 348
 349 /**
 350  * Callback received when the frontend's state changes.
 351  */
 352 static void frontend_changed(struct xenbus_device *dev,
 353                              enum xenbus_state frontend_state)
 354 {
 355         struct backend_info *be = dev_get_drvdata(&dev->dev);
 356
 357         pr_debug("%s -> %s\n", dev->otherend, xenbus_strstate(frontend_state));
 358
 359         be->frontend_state = frontend_state;
 360
 361         switch (frontend_state) {
 362         case XenbusStateInitialising:
 363                 set_backend_state(be, XenbusStateInitWait);
 364                 break;
 365
 366         case XenbusStateInitialised:
 367                 break;
 368
 369         case XenbusStateConnected:
 370                 set_backend_state(be, XenbusStateConnected);
 371                 break;
 372
 373         case XenbusStateClosing:
 374                 set_backend_state(be, XenbusStateClosing);
 375                 break;
 376
 377         case XenbusStateClosed:
 378                 set_backend_state(be, XenbusStateClosed);
 379                 if (xenbus_dev_is_online(dev))
 380                         break;
 381                 /* fall through if not online */
 382         case XenbusStateUnknown:
 383                 set_backend_state(be, XenbusStateClosed);
 384                 device_unregister(&dev->dev);
 385                 break;
 386
 387         default:
 388                 xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
 389                                  frontend_state);
 390                 break;
 391         }
 392 }
 393
 394
 395 static void xen_net_read_rate(struct xenbus_device *dev,
 396                               unsigned long *bytes, unsigned long *usec)
 397 {
 398         char *s, *e;
 399         unsigned long b, u;
 400         char *ratestr;
 401
 402         /* Default to unlimited bandwidth. */
 403         *bytes = ~0UL;
 404         *usec = 0;
 405
 406         ratestr = xenbus_read(XBT_NIL, dev->nodename, "rate", NULL);
 407         if (IS_ERR(ratestr))
 408                 return;
 409
 410         s = ratestr;
 411         b = simple_strtoul(s, &e, 10);
 412         if ((s == e) || (*e != ','))
 413                 goto fail;
 414
 415         s = e + 1;
 416         u = simple_strtoul(s, &e, 10);
 417         if ((s == e) || (*e != '\0'))
 418                 goto fail;
 419
 420         *bytes = b;
 421         *usec = u;
 422
 423         kfree(ratestr);
 424         return;
 425
 426  fail:
 427         pr_warn("Failed to parse network rate limit. Traffic unlimited.\n");
 428         kfree(ratestr);
 429 }
 430
 431 static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[])
 432 {
 433         char *s, *e, *macstr;
 434         int i;
 435
 436         macstr = s = xenbus_read(XBT_NIL, dev->nodename, "mac", NULL);
 437         if (IS_ERR(macstr))
 438                 return PTR_ERR(macstr);
 439
 440         for (i = 0; i < ETH_ALEN; i++) {
 441                 mac[i] = simple_strtoul(s, &e, 16);
 442                 if ((s == e) || (*e != ((i == ETH_ALEN-1) ? '\0' : ':'))) {
 443                         kfree(macstr);
 444                         return -ENOENT;
 445                 }
 446                 s = e+1;
 447         }
 448
 449         kfree(macstr);
 450         return 0;
 451 }
 452
 453 static void unregister_hotplug_status_watch(struct backend_info *be)
 454 {
 455         if (be->have_hotplug_status_watch) {
 456                 unregister_xenbus_watch(&be->hotplug_status_watch);
 457                 kfree(be->hotplug_status_watch.node);
 458         }
 459         be->have_hotplug_status_watch = 0;
 460 }
 461
 462 static void hotplug_status_changed(struct xenbus_watch *watch,
 463                                    const char **vec,
 464                                    unsigned int vec_size)
 465 {
 466         struct backend_info *be = container_of(watch,
 467                                                struct backend_info,
 468                                                hotplug_status_watch);
 469         char *str;
 470         unsigned int len;
 471
 472         str = xenbus_read(XBT_NIL, be->dev->nodename, "hotplug-status", &len);
 473         if (IS_ERR(str))
 474                 return;
 475         if (len == sizeof("connected")-1 && !memcmp(str, "connected", len)) {
 476                 /* Complete any pending state change */
 477                 xenbus_switch_state(be->dev, be->state);
 478
 479                 /* Not interested in this watch anymore. */
 480                 unregister_hotplug_status_watch(be);
 481         }
 482         kfree(str);
 483 }
 484
 485 static void connect(struct backend_info *be)
 486 {
 487         int err;
 488         struct xenbus_device *dev = be->dev;
 489
 490         err = connect_rings(be);
 491         if (err)
 492                 return;
 493
 494         err = xen_net_read_mac(dev, be->vif->fe_dev_addr);
 495         if (err) {
 496                 xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
 497                 return;
 498         }
 499
 500         xen_net_read_rate(dev, &be->vif->credit_bytes,
 501                           &be->vif->credit_usec);
 502         be->vif->remaining_credit = be->vif->credit_bytes;
 503
 504         unregister_hotplug_status_watch(be);
 505         err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch,
 506                                    hotplug_status_changed,
 507                                    "%s/%s", dev->nodename, "hotplug-status");
 508         if (!err)
 509                 be->have_hotplug_status_watch = 1;
 510
 511         netif_wake_queue(be->vif->dev);
 512 }
 513
 514
 515 static int connect_rings(struct backend_info *be)
 516 {
 517         struct xenvif *vif = be->vif;
 518         struct xenbus_device *dev = be->dev;
 519         unsigned long tx_ring_ref, rx_ring_ref;
 520         unsigned int tx_evtchn, rx_evtchn, rx_copy;
 521         int err;
 522         int val;
 523
 524         err = xenbus_gather(XBT_NIL, dev->otherend,
 525                             "tx-ring-ref", "%lu", &tx_ring_ref,
 526                             "rx-ring-ref", "%lu", &rx_ring_ref, NULL);
 527         if (err) {
 528                 xenbus_dev_fatal(dev, err,
 529                                  "reading %s/ring-ref",
 530                                  dev->otherend);
 531                 return err;
 532         }
 533
 534         /* Try split event channels first, then single event channel. */
 535         err = xenbus_gather(XBT_NIL, dev->otherend,
 536                             "event-channel-tx", "%u", &tx_evtchn,
 537                             "event-channel-rx", "%u", &rx_evtchn, NULL);
 538         if (err < 0) {
 539                 err = xenbus_scanf(XBT_NIL, dev->otherend,
 540                                    "event-channel", "%u", &tx_evtchn);
 541                 if (err < 0) {
 542                         xenbus_dev_fatal(dev, err,
 543                                          "reading %s/event-channel(-tx/rx)",
 544                                          dev->otherend);
 545                         return err;
 546                 }
 547                 rx_evtchn = tx_evtchn;
 548         }
 549
 550         err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u",
 551                            &rx_copy);
 552         if (err == -ENOENT) {
 553                 err = 0;
 554                 rx_copy = 0;
 555         }
 556         if (err < 0) {
 557                 xenbus_dev_fatal(dev, err, "reading %s/request-rx-copy",
 558                                  dev->otherend);
 559                 return err;
 560         }
 561         if (!rx_copy)
 562                 return -EOPNOTSUPP;
 563
 564         if (vif->dev->tx_queue_len != 0) {
 565                 if (xenbus_scanf(XBT_NIL, dev->otherend,
 566                                  "feature-rx-notify", "%d", &val) < 0)
 567                         val = 0;
 568                 if (val)
 569                         vif->can_queue = 1;
 570                 else
 571                         /* Must be non-zero for pfifo_fast to work. */
 572                         vif->dev->tx_queue_len = 1;
 573         }
 574
 575         if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-sg",
 576                          "%d", &val) < 0)
 577                 val = 0;
 578         vif->can_sg = !!val;
 579
 580         if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4",
 581                          "%d", &val) < 0)
 582                 val = 0;
 583         vif->gso = !!val;
 584
 585         if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-gso-tcpv4-prefix",
 586                          "%d", &val) < 0)
 587                 val = 0;
 588         vif->gso_prefix = !!val;
 589
 590         if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-no-csum-offload",
 591                          "%d", &val) < 0)
 592                 val = 0;
 593         vif->ip_csum = !val;
 594
 595         if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-ipv6-csum-offload",
 596                          "%d", &val) < 0)
 597                 val = 0;
 598         vif->ipv6_csum = !!val;
 599
 600         /* Map the shared frame, irq etc. */
 601         err = xenvif_connect(vif, tx_ring_ref, rx_ring_ref,
 602                              tx_evtchn, rx_evtchn);
 603         if (err) {
 604                 xenbus_dev_fatal(dev, err,
 605                                  "mapping shared-frames %lu/%lu port tx %u rx %u",
 606                                  tx_ring_ref, rx_ring_ref,
 607                                  tx_evtchn, rx_evtchn);
 608                 return err;
 609         }
 610         return 0;
 611 }
 612
 613
 614 /* ** Driver Registration ** */
 615
 616
 617 static const struct xenbus_device_id netback_ids[] = {
 618         { "vif" },
 619         { "" }
 620 };
 621
 622
 623 static DEFINE_XENBUS_DRIVER(netback, ,
 624         .probe = netback_probe,
 625         .remove = netback_remove,
 626         .uevent = netback_uevent,
 627         .otherend_changed = frontend_changed,
 628 );
 629
 630 int xenvif_xenbus_init(void)
 631 {
 632         return xenbus_register_backend(&netback_driver);
 633 }
 634
 635 void xenvif_xenbus_fini(void)
 636 {
 637         return xenbus_unregister_driver(&netback_driver);
 638 }