xenbus.c

   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
 198/*
 199 * Handle the creation of the hotplug script environment.  We add the script
 200 * and vif variables to the environment, for the benefit of the vif-* hotplug
 201 * scripts.
 202 */
 203static int netback_uevent(const struct xenbus_device *xdev,
 204			  struct kobj_uevent_env *env)
 205{
 206	struct backend_info *be = dev_get_drvdata(&xdev->dev);
 207
 208	if (!be)
 209		return 0;
 210
 211	if (add_uevent_var(env, "script=%s", be->hotplug_script))
 212		return -ENOMEM;
 213
 214	if (!be->vif)
 215		return 0;
 216
 217	return add_uevent_var(env, "vif=%s", be->vif->dev->name);
 218}
 219
 220
 221static int backend_create_xenvif(struct backend_info *be)
 222{
 223	int err;
 224	long handle;
 225	struct xenbus_device *dev = be->dev;
 226	struct xenvif *vif;
 227
 228	if (be->vif != NULL)
 229		return 0;
 230
 231	err = xenbus_scanf(XBT_NIL, dev->nodename, "handle", "%li", &handle);
 232	if (err != 1) {
 233		xenbus_dev_fatal(dev, err, "reading handle");
 234		return (err < 0) ? err : -EINVAL;
 235	}
 236
 237	vif = xenvif_alloc(&dev->dev, dev->otherend_id, handle);
 238	if (IS_ERR(vif)) {
 239		err = PTR_ERR(vif);
 240		xenbus_dev_fatal(dev, err, "creating interface");
 241		return err;
 242	}
 243	be->vif = vif;
 244	vif->be = be;
 245
 246	kobject_uevent(&dev->dev.kobj, KOBJ_ONLINE);
 247	return 0;
 248}
 249
 250static void backend_disconnect(struct backend_info *be)
 251{
 252	struct xenvif *vif = be->vif;
 253
 254	if (vif) {
 255		unsigned int num_queues = vif->num_queues;
 256		unsigned int queue_index;
 257
 258		xen_unregister_watchers(vif);
 259#ifdef CONFIG_DEBUG_FS
 260		xenvif_debugfs_delif(vif);
 261#endif /* CONFIG_DEBUG_FS */
 262		xenvif_disconnect_data(vif);
 263
 264		/* At this point some of the handlers may still be active
 265		 * so we need to have additional synchronization here.
 266		 */
 267		vif->num_queues = 0;
 268		synchronize_net();
 269
 270		for (queue_index = 0; queue_index < num_queues; ++queue_index)
 271			xenvif_deinit_queue(&vif->queues[queue_index]);
 272
 273		vfree(vif->queues);
 274		vif->queues = NULL;
 275
 276		xenvif_disconnect_ctrl(vif);
 277	}
 278}
 279
 280static void backend_connect(struct backend_info *be)
 281{
 282	if (be->vif)
 283		connect(be);
 284}
 285
 286static inline void backend_switch_state(struct backend_info *be,
 287					enum xenbus_state state)
 288{
 289	struct xenbus_device *dev = be->dev;
 290
 291	pr_debug("%s -> %s\n", dev->nodename, xenbus_strstate(state));
 292	be->state = state;
 293
 294	/* If we are waiting for a hotplug script then defer the
 295	 * actual xenbus state change.
 296	 */
 297	if (!be->have_hotplug_status_watch)
 298		xenbus_switch_state(dev, state);
 299}
 300
 301/* Handle backend state transitions:
 302 *
 303 * The backend state starts in Initialising and the following transitions are
 304 * allowed.
 305 *
 306 * Initialising -> InitWait -> Connected
 307 *          \
 308 *           \        ^    \         |
 309 *            \       |     \        |
 310 *             \      |      \       |
 311 *              \     |       \      |
 312 *               \    |        \     |
 313 *                \   |         \    |
 314 *                 V  |          V   V
 315 *
 316 *                  Closed  <-> Closing
 317 *
 318 * The state argument specifies the eventual state of the backend and the
 319 * function transitions to that state via the shortest path.
 320 */
 321static void set_backend_state(struct backend_info *be,
 322			      enum xenbus_state state)
 323{
 324	while (be->state != state) {
 325		switch (be->state) {
 326		case XenbusStateInitialising:
 327			switch (state) {
 328			case XenbusStateInitWait:
 329			case XenbusStateConnected:
 330			case XenbusStateClosing:
 331				backend_switch_state(be, XenbusStateInitWait);
 332				break;
 333			case XenbusStateClosed:
 334				backend_switch_state(be, XenbusStateClosed);
 335				break;
 336			default:
 337				BUG();
 338			}
 339			break;
 340		case XenbusStateClosed:
 341			switch (state) {
 342			case XenbusStateInitWait:
 343			case XenbusStateConnected:
 344				backend_switch_state(be, XenbusStateInitWait);
 345				break;
 346			case XenbusStateClosing:
 347				backend_switch_state(be, XenbusStateClosing);
 348				break;
 349			default:
 350				BUG();
 351			}
 352			break;
 353		case XenbusStateInitWait:
 354			switch (state) {
 355			case XenbusStateConnected:
 356				backend_connect(be);
 357				backend_switch_state(be, XenbusStateConnected);
 358				break;
 359			case XenbusStateClosing:
 360			case XenbusStateClosed:
 361				backend_switch_state(be, XenbusStateClosing);
 362				break;
 363			default:
 364				BUG();
 365			}
 366			break;
 367		case XenbusStateConnected:
 368			switch (state) {
 369			case XenbusStateInitWait:
 370			case XenbusStateClosing:
 371			case XenbusStateClosed:
 372				backend_disconnect(be);
 373				backend_switch_state(be, XenbusStateClosing);
 374				break;
 375			default:
 376				BUG();
 377			}
 378			break;
 379		case XenbusStateClosing:
 380			switch (state) {
 381			case XenbusStateInitWait:
 382			case XenbusStateConnected:
 383			case XenbusStateClosed:
 384				backend_switch_state(be, XenbusStateClosed);
 385				break;
 386			default:
 387				BUG();
 388			}
 389			break;
 390		default:
 391			BUG();
 392		}
 393	}
 394}
 395
 396static void read_xenbus_frontend_xdp(struct backend_info *be,
 397				      struct xenbus_device *dev)
 398{
 399	struct xenvif *vif = be->vif;
 400	u16 headroom;
 401	int err;
 402
 403	err = xenbus_scanf(XBT_NIL, dev->otherend,
 404			   "xdp-headroom", "%hu", &headroom);
 405	if (err != 1) {
 406		vif->xdp_headroom = 0;
 407		return;
 408	}
 409	if (headroom > XEN_NETIF_MAX_XDP_HEADROOM)
 410		headroom = XEN_NETIF_MAX_XDP_HEADROOM;
 411	vif->xdp_headroom = headroom;
 412}
 413
 414/*
 415 * Callback received when the frontend's state changes.
 416 */
 417static void frontend_changed(struct xenbus_device *dev,
 418			     enum xenbus_state frontend_state)
 419{
 420	struct backend_info *be = dev_get_drvdata(&dev->dev);
 421
 422	pr_debug("%s -> %s\n", dev->otherend, xenbus_strstate(frontend_state));
 423
 424	be->frontend_state = frontend_state;
 425
 426	switch (frontend_state) {
 427	case XenbusStateInitialising:
 428		set_backend_state(be, XenbusStateInitWait);
 429		break;
 430
 431	case XenbusStateInitialised:
 432		break;
 433
 434	case XenbusStateConnected:
 435		set_backend_state(be, XenbusStateConnected);
 436		break;
 437
 438	case XenbusStateReconfiguring:
 439		read_xenbus_frontend_xdp(be, dev);
 440		xenbus_switch_state(dev, XenbusStateReconfigured);
 441		break;
 442
 443	case XenbusStateClosing:
 444		set_backend_state(be, XenbusStateClosing);
 445		break;
 446
 447	case XenbusStateClosed:
 448		set_backend_state(be, XenbusStateClosed);
 449		if (xenbus_dev_is_online(dev))
 450			break;
 451		fallthrough;	/* if not online */
 452	case XenbusStateUnknown:
 453		set_backend_state(be, XenbusStateClosed);
 454		device_unregister(&dev->dev);
 455		break;
 456
 457	default:
 458		xenbus_dev_fatal(dev, -EINVAL, "saw state %d at frontend",
 459				 frontend_state);
 460		break;
 461	}
 462}
 463
 464
 465static void xen_net_read_rate(struct xenbus_device *dev,
 466			      unsigned long *bytes, unsigned long *usec)
 467{
 468	char *s, *e;
 469	unsigned long b, u;
 470	char *ratestr;
 471
 472	/* Default to unlimited bandwidth. */
 473	*bytes = ~0UL;
 474	*usec = 0;
 475
 476	ratestr = xenbus_read(XBT_NIL, dev->nodename, "rate", NULL);
 477	if (IS_ERR(ratestr))
 478		return;
 479
 480	s = ratestr;
 481	b = simple_strtoul(s, &e, 10);
 482	if ((s == e) || (*e != ','))
 483		goto fail;
 484
 485	s = e + 1;
 486	u = simple_strtoul(s, &e, 10);
 487	if ((s == e) || (*e != '\0'))
 488		goto fail;
 489
 490	*bytes = b;
 491	*usec = u;
 492
 493	kfree(ratestr);
 494	return;
 495
 496 fail:
 497	pr_warn("Failed to parse network rate limit. Traffic unlimited.\n");
 498	kfree(ratestr);
 499}
 500
 501static int xen_net_read_mac(struct xenbus_device *dev, u8 mac[])
 502{
 503	char *s, *e, *macstr;
 504	int i;
 505
 506	macstr = s = xenbus_read(XBT_NIL, dev->nodename, "mac", NULL);
 507	if (IS_ERR(macstr))
 508		return PTR_ERR(macstr);
 509
 510	for (i = 0; i < ETH_ALEN; i++) {
 511		mac[i] = simple_strtoul(s, &e, 16);
 512		if ((s == e) || (*e != ((i == ETH_ALEN-1) ? '\0' : ':'))) {
 513			kfree(macstr);
 514			return -ENOENT;
 515		}
 516		s = e+1;
 517	}
 518
 519	kfree(macstr);
 520	return 0;
 521}
 522
 523static void xen_net_rate_changed(struct xenbus_watch *watch,
 524				 const char *path, const char *token)
 525{
 526	struct xenvif *vif = container_of(watch, struct xenvif, credit_watch);
 527	struct xenbus_device *dev = xenvif_to_xenbus_device(vif);
 528	unsigned long   credit_bytes;
 529	unsigned long   credit_usec;
 530	unsigned int queue_index;
 531
 532	xen_net_read_rate(dev, &credit_bytes, &credit_usec);
 533	for (queue_index = 0; queue_index < vif->num_queues; queue_index++) {
 534		struct xenvif_queue *queue = &vif->queues[queue_index];
 535
 536		queue->credit_bytes = credit_bytes;
 537		queue->credit_usec = credit_usec;
 538		if (!mod_timer_pending(&queue->credit_timeout, jiffies) &&
 539			queue->remaining_credit > queue->credit_bytes) {
 540			queue->remaining_credit = queue->credit_bytes;
 541		}
 542	}
 543}
 544
 545static int xen_register_credit_watch(struct xenbus_device *dev,
 546				     struct xenvif *vif)
 547{
 548	int err = 0;
 549	char *node;
 550	unsigned maxlen = strlen(dev->nodename) + sizeof("/rate");
 551
 552	if (vif->credit_watch.node)
 553		return -EADDRINUSE;
 554
 555	node = kmalloc(maxlen, GFP_KERNEL);
 556	if (!node)
 557		return -ENOMEM;
 558	snprintf(node, maxlen, "%s/rate", dev->nodename);
 559	vif->credit_watch.node = node;
 560	vif->credit_watch.will_handle = NULL;
 561	vif->credit_watch.callback = xen_net_rate_changed;
 562	err = register_xenbus_watch(&vif->credit_watch);
 563	if (err) {
 564		pr_err("Failed to set watcher %s\n", vif->credit_watch.node);
 565		kfree(node);
 566		vif->credit_watch.node = NULL;
 567		vif->credit_watch.will_handle = NULL;
 568		vif->credit_watch.callback = NULL;
 569	}
 570	return err;
 571}
 572
 573static void xen_unregister_credit_watch(struct xenvif *vif)
 574{
 575	if (vif->credit_watch.node) {
 576		unregister_xenbus_watch(&vif->credit_watch);
 577		kfree(vif->credit_watch.node);
 578		vif->credit_watch.node = NULL;
 579	}
 580}
 581
 582static void xen_mcast_ctrl_changed(struct xenbus_watch *watch,
 583				   const char *path, const char *token)
 584{
 585	struct xenvif *vif = container_of(watch, struct xenvif,
 586					  mcast_ctrl_watch);
 587	struct xenbus_device *dev = xenvif_to_xenbus_device(vif);
 588
 589	vif->multicast_control = !!xenbus_read_unsigned(dev->otherend,
 590					"request-multicast-control", 0);
 591}
 592
 593static int xen_register_mcast_ctrl_watch(struct xenbus_device *dev,
 594					 struct xenvif *vif)
 595{
 596	int err = 0;
 597	char *node;
 598	unsigned maxlen = strlen(dev->otherend) +
 599		sizeof("/request-multicast-control");
 600
 601	if (vif->mcast_ctrl_watch.node) {
 602		pr_err_ratelimited("Watch is already registered\n");
 603		return -EADDRINUSE;
 604	}
 605
 606	node = kmalloc(maxlen, GFP_KERNEL);
 607	if (!node) {
 608		pr_err("Failed to allocate memory for watch\n");
 609		return -ENOMEM;
 610	}
 611	snprintf(node, maxlen, "%s/request-multicast-control",
 612		 dev->otherend);
 613	vif->mcast_ctrl_watch.node = node;
 614	vif->mcast_ctrl_watch.will_handle = NULL;
 615	vif->mcast_ctrl_watch.callback = xen_mcast_ctrl_changed;
 616	err = register_xenbus_watch(&vif->mcast_ctrl_watch);
 617	if (err) {
 618		pr_err("Failed to set watcher %s\n",
 619		       vif->mcast_ctrl_watch.node);
 620		kfree(node);
 621		vif->mcast_ctrl_watch.node = NULL;
 622		vif->mcast_ctrl_watch.will_handle = NULL;
 623		vif->mcast_ctrl_watch.callback = NULL;
 624	}
 625	return err;
 626}
 627
 628static void xen_unregister_mcast_ctrl_watch(struct xenvif *vif)
 629{
 630	if (vif->mcast_ctrl_watch.node) {
 631		unregister_xenbus_watch(&vif->mcast_ctrl_watch);
 632		kfree(vif->mcast_ctrl_watch.node);
 633		vif->mcast_ctrl_watch.node = NULL;
 634	}
 635}
 636
 637static void xen_register_watchers(struct xenbus_device *dev,
 638				  struct xenvif *vif)
 639{
 640	xen_register_credit_watch(dev, vif);
 641	xen_register_mcast_ctrl_watch(dev, vif);
 642}
 643
 644static void xen_unregister_watchers(struct xenvif *vif)
 645{
 646	xen_unregister_mcast_ctrl_watch(vif);
 647	xen_unregister_credit_watch(vif);
 648}
 649
 650static void unregister_hotplug_status_watch(struct backend_info *be)
 651{
 652	if (be->have_hotplug_status_watch) {
 653		unregister_xenbus_watch(&be->hotplug_status_watch);
 654		kfree(be->hotplug_status_watch.node);
 655	}
 656	be->have_hotplug_status_watch = 0;
 657}
 658
 659static void hotplug_status_changed(struct xenbus_watch *watch,
 660				   const char *path,
 661				   const char *token)
 662{
 663	struct backend_info *be = container_of(watch,
 664					       struct backend_info,
 665					       hotplug_status_watch);
 666	char *str;
 667	unsigned int len;
 668
 669	str = xenbus_read(XBT_NIL, be->dev->nodename, "hotplug-status", &len);
 670	if (IS_ERR(str))
 671		return;
 672	if (len == sizeof("connected")-1 && !memcmp(str, "connected", len)) {
 673		/* Complete any pending state change */
 674		xenbus_switch_state(be->dev, be->state);
 675
 676		/* Not interested in this watch anymore. */
 677		unregister_hotplug_status_watch(be);
 678	}
 679	kfree(str);
 680}
 681
 682static int connect_ctrl_ring(struct backend_info *be)
 683{
 684	struct xenbus_device *dev = be->dev;
 685	struct xenvif *vif = be->vif;
 686	unsigned int val;
 687	grant_ref_t ring_ref;
 688	unsigned int evtchn;
 689	int err;
 690
 691	err = xenbus_scanf(XBT_NIL, dev->otherend,
 692			   "ctrl-ring-ref", "%u", &val);
 693	if (err < 0)
 694		goto done; /* The frontend does not have a control ring */
 695
 696	ring_ref = val;
 697
 698	err = xenbus_scanf(XBT_NIL, dev->otherend,
 699			   "event-channel-ctrl", "%u", &val);
 700	if (err < 0) {
 701		xenbus_dev_fatal(dev, err,
 702				 "reading %s/event-channel-ctrl",
 703				 dev->otherend);
 704		goto fail;
 705	}
 706
 707	evtchn = val;
 708
 709	err = xenvif_connect_ctrl(vif, ring_ref, evtchn);
 710	if (err) {
 711		xenbus_dev_fatal(dev, err,
 712				 "mapping shared-frame %u port %u",
 713				 ring_ref, evtchn);
 714		goto fail;
 715	}
 716
 717done:
 718	return 0;
 719
 720fail:
 721	return err;
 722}
 723
 724static void connect(struct backend_info *be)
 725{
 726	int err;
 727	struct xenbus_device *dev = be->dev;
 728	unsigned long credit_bytes, credit_usec;
 729	unsigned int queue_index;
 730	unsigned int requested_num_queues;
 731	struct xenvif_queue *queue;
 732
 733	/* Check whether the frontend requested multiple queues
 734	 * and read the number requested.
 735	 */
 736	requested_num_queues = xenbus_read_unsigned(dev->otherend,
 737					"multi-queue-num-queues", 1);
 738	if (requested_num_queues > xenvif_max_queues ||
 739	    requested_num_queues == 0) {
 740		/* buggy or malicious guest */
 741		xenbus_dev_fatal(dev, -EINVAL,
 742				 "guest requested %u queues, but valid range is 1 - %u.",
 743				 requested_num_queues, xenvif_max_queues);
 744		return;
 745	}
 746
 747	err = xen_net_read_mac(dev, be->vif->fe_dev_addr);
 748	if (err) {
 749		xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
 750		return;
 751	}
 752
 753	xen_net_read_rate(dev, &credit_bytes, &credit_usec);
 754	xen_unregister_watchers(be->vif);
 755	xen_register_watchers(dev, be->vif);
 756	read_xenbus_vif_flags(be);
 757
 758	err = connect_ctrl_ring(be);
 759	if (err) {
 760		xenbus_dev_fatal(dev, err, "connecting control ring");
 761		return;
 762	}
 763
 764	/* Use the number of queues requested by the frontend */
 765	be->vif->queues = vzalloc(array_size(requested_num_queues,
 766					     sizeof(struct xenvif_queue)));
 767	if (!be->vif->queues) {
 768		xenbus_dev_fatal(dev, -ENOMEM,
 769				 "allocating queues");
 770		return;
 771	}
 772
 773	be->vif->num_queues = requested_num_queues;
 774	be->vif->stalled_queues = requested_num_queues;
 775
 776	for (queue_index = 0; queue_index < requested_num_queues; ++queue_index) {
 777		queue = &be->vif->queues[queue_index];
 778		queue->vif = be->vif;
 779		queue->id = queue_index;
 780		snprintf(queue->name, sizeof(queue->name), "%s-q%u",
 781				be->vif->dev->name, queue->id);
 782
 783		err = xenvif_init_queue(queue);
 784		if (err) {
 785			/* xenvif_init_queue() cleans up after itself on
 786			 * failure, but we need to clean up any previously
 787			 * initialised queues. Set num_queues to i so that
 788			 * earlier queues can be destroyed using the regular
 789			 * disconnect logic.
 790			 */
 791			be->vif->num_queues = queue_index;
 792			goto err;
 793		}
 794
 795		queue->credit_bytes = credit_bytes;
 796		queue->remaining_credit = credit_bytes;
 797		queue->credit_usec = credit_usec;
 798
 799		err = connect_data_rings(be, queue);
 800		if (err) {
 801			/* connect_data_rings() cleans up after itself on
 802			 * failure, but we need to clean up after
 803			 * xenvif_init_queue() here, and also clean up any
 804			 * previously initialised queues.
 805			 */
 806			xenvif_deinit_queue(queue);
 807			be->vif->num_queues = queue_index;
 808			goto err;
 809		}
 810	}
 811
 812#ifdef CONFIG_DEBUG_FS
 813	xenvif_debugfs_addif(be->vif);
 814#endif /* CONFIG_DEBUG_FS */
 815
 816	/* Initialisation completed, tell core driver the number of
 817	 * active queues.
 818	 */
 819	rtnl_lock();
 820	netif_set_real_num_tx_queues(be->vif->dev, requested_num_queues);
 821	netif_set_real_num_rx_queues(be->vif->dev, requested_num_queues);
 822	rtnl_unlock();
 823
 824	xenvif_carrier_on(be->vif);
 825
 826	unregister_hotplug_status_watch(be);
 827	err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, NULL,
 828				   hotplug_status_changed,
 829				   "%s/%s", dev->nodename, "hotplug-status");
 830	if (!err)
 831		be->have_hotplug_status_watch = 1;
 832
 833	netif_tx_wake_all_queues(be->vif->dev);
 834
 835	return;
 836
 837err:
 838	if (be->vif->num_queues > 0)
 839		xenvif_disconnect_data(be->vif); /* Clean up existing queues */
 840	for (queue_index = 0; queue_index < be->vif->num_queues; ++queue_index)
 841		xenvif_deinit_queue(&be->vif->queues[queue_index]);
 842	vfree(be->vif->queues);
 843	be->vif->queues = NULL;
 844	be->vif->num_queues = 0;
 845	xenvif_disconnect_ctrl(be->vif);
 846	return;
 847}
 848
 849
 850static int connect_data_rings(struct backend_info *be,
 851			      struct xenvif_queue *queue)
 852{
 853	struct xenbus_device *dev = be->dev;
 854	unsigned int num_queues = queue->vif->num_queues;
 855	unsigned long tx_ring_ref, rx_ring_ref;
 856	unsigned int tx_evtchn, rx_evtchn;
 857	int err;
 858	char *xspath;
 859	size_t xspathsize;
 860	const size_t xenstore_path_ext_size = 11; /* sufficient for "/queue-NNN" */
 861
 862	/* If the frontend requested 1 queue, or we have fallen back
 863	 * to single queue due to lack of frontend support for multi-
 864	 * queue, expect the remaining XenStore keys in the toplevel
 865	 * directory. Otherwise, expect them in a subdirectory called
 866	 * queue-N.
 867	 */
 868	if (num_queues == 1) {
 869		xspath = kstrdup(dev->otherend, GFP_KERNEL);
 870		if (!xspath) {
 871			xenbus_dev_fatal(dev, -ENOMEM,
 872					 "reading ring references");
 873			return -ENOMEM;
 874		}
 875	} else {
 876		xspathsize = strlen(dev->otherend) + xenstore_path_ext_size;
 877		xspath = kzalloc(xspathsize, GFP_KERNEL);
 878		if (!xspath) {
 879			xenbus_dev_fatal(dev, -ENOMEM,
 880					 "reading ring references");
 881			return -ENOMEM;
 882		}
 883		snprintf(xspath, xspathsize, "%s/queue-%u", dev->otherend,
 884			 queue->id);
 885	}
 886
 887	err = xenbus_gather(XBT_NIL, xspath,
 888			    "tx-ring-ref", "%lu", &tx_ring_ref,
 889			    "rx-ring-ref", "%lu", &rx_ring_ref, NULL);
 890	if (err) {
 891		xenbus_dev_fatal(dev, err,
 892				 "reading %s/ring-ref",
 893				 xspath);
 894		goto err;
 895	}
 896
 897	/* Try split event channels first, then single event channel. */
 898	err = xenbus_gather(XBT_NIL, xspath,
 899			    "event-channel-tx", "%u", &tx_evtchn,
 900			    "event-channel-rx", "%u", &rx_evtchn, NULL);
 901	if (err < 0) {
 902		err = xenbus_scanf(XBT_NIL, xspath,
 903				   "event-channel", "%u", &tx_evtchn);
 904		if (err < 0) {
 905			xenbus_dev_fatal(dev, err,
 906					 "reading %s/event-channel(-tx/rx)",
 907					 xspath);
 908			goto err;
 909		}
 910		rx_evtchn = tx_evtchn;
 911	}
 912
 913	/* Map the shared frame, irq etc. */
 914	err = xenvif_connect_data(queue, tx_ring_ref, rx_ring_ref,
 915				  tx_evtchn, rx_evtchn);
 916	if (err) {
 917		xenbus_dev_fatal(dev, err,
 918				 "mapping shared-frames %lu/%lu port tx %u rx %u",
 919				 tx_ring_ref, rx_ring_ref,
 920				 tx_evtchn, rx_evtchn);
 921		goto err;
 922	}
 923
 924	err = 0;
 925err: /* Regular return falls through with err == 0 */
 926	kfree(xspath);
 927	return err;
 928}
 929
 930static int read_xenbus_vif_flags(struct backend_info *be)
 931{
 932	struct xenvif *vif = be->vif;
 933	struct xenbus_device *dev = be->dev;
 934	unsigned int rx_copy;
 935	int err;
 936
 937	err = xenbus_scanf(XBT_NIL, dev->otherend, "request-rx-copy", "%u",
 938			   &rx_copy);
 939	if (err == -ENOENT) {
 940		err = 0;
 941		rx_copy = 0;
 942	}
 943	if (err < 0) {
 944		xenbus_dev_fatal(dev, err, "reading %s/request-rx-copy",
 945				 dev->otherend);
 946		return err;
 947	}
 948	if (!rx_copy)
 949		return -EOPNOTSUPP;
 950
 951	if (!xenbus_read_unsigned(dev->otherend, "feature-rx-notify", 0)) {
 952		/* - Reduce drain timeout to poll more frequently for
 953		 *   Rx requests.
 954		 * - Disable Rx stall detection.
 955		 */
 956		be->vif->drain_timeout = msecs_to_jiffies(30);
 957		be->vif->stall_timeout = 0;
 958	}
 959
 960	vif->can_sg = !!xenbus_read_unsigned(dev->otherend, "feature-sg", 0);
 961
 962	vif->gso_mask = 0;
 963
 964	if (xenbus_read_unsigned(dev->otherend, "feature-gso-tcpv4", 0))
 965		vif->gso_mask |= GSO_BIT(TCPV4);
 966
 967	if (xenbus_read_unsigned(dev->otherend, "feature-gso-tcpv6", 0))
 968		vif->gso_mask |= GSO_BIT(TCPV6);
 969
 970	vif->ip_csum = !xenbus_read_unsigned(dev->otherend,
 971					     "feature-no-csum-offload", 0);
 972
 973	vif->ipv6_csum = !!xenbus_read_unsigned(dev->otherend,
 974						"feature-ipv6-csum-offload", 0);
 975
 976	read_xenbus_frontend_xdp(be, dev);
 977
 978	return 0;
 979}
 980
 981static void netback_remove(struct xenbus_device *dev)
 982{
 983	struct backend_info *be = dev_get_drvdata(&dev->dev);
 984
 985	unregister_hotplug_status_watch(be);
 986	xenbus_rm(XBT_NIL, dev->nodename, "hotplug-status");
 987	if (be->vif) {
 988		kobject_uevent(&dev->dev.kobj, KOBJ_OFFLINE);
 989		backend_disconnect(be);
 990		xenvif_free(be->vif);
 991		be->vif = NULL;
 992	}
 993	kfree(be->hotplug_script);
 994	kfree(be);
 995	dev_set_drvdata(&dev->dev, NULL);
 996}
 997
 998/*
 999 * Entry point to this code when a new device is created.  Allocate the basic
1000 * structures and switch to InitWait.
1001 */
1002static int netback_probe(struct xenbus_device *dev,
1003			 const struct xenbus_device_id *id)
1004{
1005	const char *message;
1006	struct xenbus_transaction xbt;
1007	int err;
1008	int sg;
1009	const char *script;
1010	struct backend_info *be = kzalloc(sizeof(*be), GFP_KERNEL);
1011
1012	if (!be) {
1013		xenbus_dev_fatal(dev, -ENOMEM,
1014				 "allocating backend structure");
1015		return -ENOMEM;
1016	}
1017
1018	be->dev = dev;
1019	dev_set_drvdata(&dev->dev, be);
1020
1021	sg = 1;
1022
1023	do {
1024		err = xenbus_transaction_start(&xbt);
1025		if (err) {
1026			xenbus_dev_fatal(dev, err, "starting transaction");
1027			goto fail;
1028		}
1029
1030		err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", sg);
1031		if (err) {
1032			message = "writing feature-sg";
1033			goto abort_transaction;
1034		}
1035
1036		err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4",
1037				    "%d", sg);
1038		if (err) {
1039			message = "writing feature-gso-tcpv4";
1040			goto abort_transaction;
1041		}
1042
1043		err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv6",
1044				    "%d", sg);
1045		if (err) {
1046			message = "writing feature-gso-tcpv6";
1047			goto abort_transaction;
1048		}
1049
1050		/* We support partial checksum setup for IPv6 packets */
1051		err = xenbus_printf(xbt, dev->nodename,
1052				    "feature-ipv6-csum-offload",
1053				    "%d", 1);
1054		if (err) {
1055			message = "writing feature-ipv6-csum-offload";
1056			goto abort_transaction;
1057		}
1058
1059		/* We support rx-copy path. */
1060		err = xenbus_printf(xbt, dev->nodename,
1061				    "feature-rx-copy", "%d", 1);
1062		if (err) {
1063			message = "writing feature-rx-copy";
1064			goto abort_transaction;
1065		}
1066
1067		/* we can adjust a headroom for netfront XDP processing */
1068		err = xenbus_printf(xbt, dev->nodename,
1069				    "feature-xdp-headroom", "%d",
1070				    provides_xdp_headroom);
1071		if (err) {
1072			message = "writing feature-xdp-headroom";
1073			goto abort_transaction;
1074		}
1075
1076		/* We don't support rx-flip path (except old guests who
1077		 * don't grok this feature flag).
1078		 */
1079		err = xenbus_printf(xbt, dev->nodename,
1080				    "feature-rx-flip", "%d", 0);
1081		if (err) {
1082			message = "writing feature-rx-flip";
1083			goto abort_transaction;
1084		}
1085
1086		/* We support dynamic multicast-control. */
1087		err = xenbus_printf(xbt, dev->nodename,
1088				    "feature-multicast-control", "%d", 1);
1089		if (err) {
1090			message = "writing feature-multicast-control";
1091			goto abort_transaction;
1092		}
1093
1094		err = xenbus_printf(xbt, dev->nodename,
1095				    "feature-dynamic-multicast-control",
1096				    "%d", 1);
1097		if (err) {
1098			message = "writing feature-dynamic-multicast-control";
1099			goto abort_transaction;
1100		}
1101
1102		err = xenbus_transaction_end(xbt, 0);
1103	} while (err == -EAGAIN);
1104
1105	if (err) {
1106		xenbus_dev_fatal(dev, err, "completing transaction");
1107		goto fail;
1108	}
1109
1110	/* Split event channels support, this is optional so it is not
1111	 * put inside the above loop.
1112	 */
1113	err = xenbus_printf(XBT_NIL, dev->nodename,
1114			    "feature-split-event-channels",
1115			    "%u", separate_tx_rx_irq);
1116	if (err)
1117		pr_debug("Error writing feature-split-event-channels\n");
1118
1119	/* Multi-queue support: This is an optional feature. */
1120	err = xenbus_printf(XBT_NIL, dev->nodename,
1121			    "multi-queue-max-queues", "%u", xenvif_max_queues);
1122	if (err)
1123		pr_debug("Error writing multi-queue-max-queues\n");
1124
1125	err = xenbus_printf(XBT_NIL, dev->nodename,
1126			    "feature-ctrl-ring",
1127			    "%u", true);
1128	if (err)
1129		pr_debug("Error writing feature-ctrl-ring\n");
1130
1131	backend_switch_state(be, XenbusStateInitWait);
1132
1133	script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL);
1134	if (IS_ERR(script)) {
1135		err = PTR_ERR(script);
1136		xenbus_dev_fatal(dev, err, "reading script");
1137		goto fail;
1138	}
1139
1140	be->hotplug_script = script;
1141
1142	/* This kicks hotplug scripts, so do it immediately. */
1143	err = backend_create_xenvif(be);
1144	if (err)
1145		goto fail;
1146
1147	return 0;
1148
1149abort_transaction:
1150	xenbus_transaction_end(xbt, 1);
1151	xenbus_dev_fatal(dev, err, "%s", message);
1152fail:
1153	pr_debug("failed\n");
1154	netback_remove(dev);
1155	return err;
1156}
1157
1158static const struct xenbus_device_id netback_ids[] = {
1159	{ "vif" },
1160	{ "" }
1161};
1162
1163static struct xenbus_driver netback_driver = {
1164	.ids = netback_ids,
1165	.probe = netback_probe,
1166	.remove = netback_remove,
1167	.uevent = netback_uevent,
1168	.otherend_changed = frontend_changed,
1169	.allow_rebind = true,
1170};
1171
1172int xenvif_xenbus_init(void)
1173{
1174	return xenbus_register_backend(&netback_driver);
1175}
1176
1177void xenvif_xenbus_fini(void)
1178{
1179	return xenbus_unregister_driver(&netback_driver);
1180}