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