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