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(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		/* buggy or malicious guest */
740		xenbus_dev_fatal(dev, -EINVAL,
741				 "guest requested %u queues, exceeding the maximum of %u.",
742				 requested_num_queues, xenvif_max_queues);
743		return;
744	}
745
746	err = xen_net_read_mac(dev, be->vif->fe_dev_addr);
747	if (err) {
748		xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
749		return;
750	}
751
752	xen_net_read_rate(dev, &credit_bytes, &credit_usec);
753	xen_unregister_watchers(be->vif);
754	xen_register_watchers(dev, be->vif);
755	read_xenbus_vif_flags(be);
756
757	err = connect_ctrl_ring(be);
758	if (err) {
759		xenbus_dev_fatal(dev, err, "connecting control ring");
760		return;
761	}
762
763	/* Use the number of queues requested by the frontend */
764	be->vif->queues = vzalloc(array_size(requested_num_queues,
765					     sizeof(struct xenvif_queue)));
766	if (!be->vif->queues) {
767		xenbus_dev_fatal(dev, -ENOMEM,
768				 "allocating queues");
769		return;
770	}
771
772	be->vif->num_queues = requested_num_queues;
773	be->vif->stalled_queues = requested_num_queues;
774
775	for (queue_index = 0; queue_index < requested_num_queues; ++queue_index) {
776		queue = &be->vif->queues[queue_index];
777		queue->vif = be->vif;
778		queue->id = queue_index;
779		snprintf(queue->name, sizeof(queue->name), "%s-q%u",
780				be->vif->dev->name, queue->id);
781
782		err = xenvif_init_queue(queue);
783		if (err) {
784			/* xenvif_init_queue() cleans up after itself on
785			 * failure, but we need to clean up any previously
786			 * initialised queues. Set num_queues to i so that
787			 * earlier queues can be destroyed using the regular
788			 * disconnect logic.
789			 */
790			be->vif->num_queues = queue_index;
791			goto err;
792		}
793
794		queue->credit_bytes = credit_bytes;
795		queue->remaining_credit = credit_bytes;
796		queue->credit_usec = credit_usec;
797
798		err = connect_data_rings(be, queue);
799		if (err) {
800			/* connect_data_rings() cleans up after itself on
801			 * failure, but we need to clean up after
802			 * xenvif_init_queue() here, and also clean up any
803			 * previously initialised queues.
804			 */
805			xenvif_deinit_queue(queue);
806			be->vif->num_queues = queue_index;
807			goto err;
808		}
809	}
810
811#ifdef CONFIG_DEBUG_FS
812	xenvif_debugfs_addif(be->vif);
813#endif /* CONFIG_DEBUG_FS */
814
815	/* Initialisation completed, tell core driver the number of
816	 * active queues.
817	 */
818	rtnl_lock();
819	netif_set_real_num_tx_queues(be->vif->dev, requested_num_queues);
820	netif_set_real_num_rx_queues(be->vif->dev, requested_num_queues);
821	rtnl_unlock();
822
823	xenvif_carrier_on(be->vif);
824
825	unregister_hotplug_status_watch(be);
826	err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, NULL,
827				   hotplug_status_changed,
828				   "%s/%s", dev->nodename, "hotplug-status");
829	if (!err)
830		be->have_hotplug_status_watch = 1;
831
832	netif_tx_wake_all_queues(be->vif->dev);
833
834	return;
835
836err:
837	if (be->vif->num_queues > 0)
838		xenvif_disconnect_data(be->vif); /* Clean up existing queues */
839	for (queue_index = 0; queue_index < be->vif->num_queues; ++queue_index)
840		xenvif_deinit_queue(&be->vif->queues[queue_index]);
841	vfree(be->vif->queues);
842	be->vif->queues = NULL;
843	be->vif->num_queues = 0;
844	xenvif_disconnect_ctrl(be->vif);
845	return;
846}
847
848
849static int connect_data_rings(struct backend_info *be,
850			      struct xenvif_queue *queue)
851{
852	struct xenbus_device *dev = be->dev;
853	unsigned int num_queues = queue->vif->num_queues;
854	unsigned long tx_ring_ref, rx_ring_ref;
855	unsigned int tx_evtchn, rx_evtchn;
856	int err;
857	char *xspath;
858	size_t xspathsize;
859	const size_t xenstore_path_ext_size = 11; /* sufficient for "/queue-NNN" */
860
861	/* If the frontend requested 1 queue, or we have fallen back
862	 * to single queue due to lack of frontend support for multi-
863	 * queue, expect the remaining XenStore keys in the toplevel
864	 * directory. Otherwise, expect them in a subdirectory called
865	 * queue-N.
866	 */
867	if (num_queues == 1) {
868		xspath = kzalloc(strlen(dev->otherend) + 1, GFP_KERNEL);
869		if (!xspath) {
870			xenbus_dev_fatal(dev, -ENOMEM,
871					 "reading ring references");
872			return -ENOMEM;
873		}
874		strcpy(xspath, dev->otherend);
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 int 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	return 0;
997}
998
999/**
1000 * Entry point to this code when a new device is created.  Allocate the basic
1001 * structures and switch to InitWait.
1002 */
1003static int netback_probe(struct xenbus_device *dev,
1004			 const struct xenbus_device_id *id)
1005{
1006	const char *message;
1007	struct xenbus_transaction xbt;
1008	int err;
1009	int sg;
1010	const char *script;
1011	struct backend_info *be = kzalloc(sizeof(*be), GFP_KERNEL);
1012
1013	if (!be) {
1014		xenbus_dev_fatal(dev, -ENOMEM,
1015				 "allocating backend structure");
1016		return -ENOMEM;
1017	}
1018
1019	be->dev = dev;
1020	dev_set_drvdata(&dev->dev, be);
1021
1022	sg = 1;
1023
1024	do {
1025		err = xenbus_transaction_start(&xbt);
1026		if (err) {
1027			xenbus_dev_fatal(dev, err, "starting transaction");
1028			goto fail;
1029		}
1030
1031		err = xenbus_printf(xbt, dev->nodename, "feature-sg", "%d", sg);
1032		if (err) {
1033			message = "writing feature-sg";
1034			goto abort_transaction;
1035		}
1036
1037		err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv4",
1038				    "%d", sg);
1039		if (err) {
1040			message = "writing feature-gso-tcpv4";
1041			goto abort_transaction;
1042		}
1043
1044		err = xenbus_printf(xbt, dev->nodename, "feature-gso-tcpv6",
1045				    "%d", sg);
1046		if (err) {
1047			message = "writing feature-gso-tcpv6";
1048			goto abort_transaction;
1049		}
1050
1051		/* We support partial checksum setup for IPv6 packets */
1052		err = xenbus_printf(xbt, dev->nodename,
1053				    "feature-ipv6-csum-offload",
1054				    "%d", 1);
1055		if (err) {
1056			message = "writing feature-ipv6-csum-offload";
1057			goto abort_transaction;
1058		}
1059
1060		/* We support rx-copy path. */
1061		err = xenbus_printf(xbt, dev->nodename,
1062				    "feature-rx-copy", "%d", 1);
1063		if (err) {
1064			message = "writing feature-rx-copy";
1065			goto abort_transaction;
1066		}
1067
1068		/* we can adjust a headroom for netfront XDP processing */
1069		err = xenbus_printf(xbt, dev->nodename,
1070				    "feature-xdp-headroom", "%d",
1071				    provides_xdp_headroom);
1072		if (err) {
1073			message = "writing feature-xdp-headroom";
1074			goto abort_transaction;
1075		}
1076
1077		/* We don't support rx-flip path (except old guests who
1078		 * don't grok this feature flag).
1079		 */
1080		err = xenbus_printf(xbt, dev->nodename,
1081				    "feature-rx-flip", "%d", 0);
1082		if (err) {
1083			message = "writing feature-rx-flip";
1084			goto abort_transaction;
1085		}
1086
1087		/* We support dynamic multicast-control. */
1088		err = xenbus_printf(xbt, dev->nodename,
1089				    "feature-multicast-control", "%d", 1);
1090		if (err) {
1091			message = "writing feature-multicast-control";
1092			goto abort_transaction;
1093		}
1094
1095		err = xenbus_printf(xbt, dev->nodename,
1096				    "feature-dynamic-multicast-control",
1097				    "%d", 1);
1098		if (err) {
1099			message = "writing feature-dynamic-multicast-control";
1100			goto abort_transaction;
1101		}
1102
1103		err = xenbus_transaction_end(xbt, 0);
1104	} while (err == -EAGAIN);
1105
1106	if (err) {
1107		xenbus_dev_fatal(dev, err, "completing transaction");
1108		goto fail;
1109	}
1110
1111	/* Split event channels support, this is optional so it is not
1112	 * put inside the above loop.
1113	 */
1114	err = xenbus_printf(XBT_NIL, dev->nodename,
1115			    "feature-split-event-channels",
1116			    "%u", separate_tx_rx_irq);
1117	if (err)
1118		pr_debug("Error writing feature-split-event-channels\n");
1119
1120	/* Multi-queue support: This is an optional feature. */
1121	err = xenbus_printf(XBT_NIL, dev->nodename,
1122			    "multi-queue-max-queues", "%u", xenvif_max_queues);
1123	if (err)
1124		pr_debug("Error writing multi-queue-max-queues\n");
1125
1126	err = xenbus_printf(XBT_NIL, dev->nodename,
1127			    "feature-ctrl-ring",
1128			    "%u", true);
1129	if (err)
1130		pr_debug("Error writing feature-ctrl-ring\n");
1131
1132	backend_switch_state(be, XenbusStateInitWait);
1133
1134	script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL);
1135	if (IS_ERR(script)) {
1136		err = PTR_ERR(script);
1137		xenbus_dev_fatal(dev, err, "reading script");
1138		goto fail;
1139	}
1140
1141	be->hotplug_script = script;
1142
1143	/* This kicks hotplug scripts, so do it immediately. */
1144	err = backend_create_xenvif(be);
1145	if (err)
1146		goto fail;
1147
1148	return 0;
1149
1150abort_transaction:
1151	xenbus_transaction_end(xbt, 1);
1152	xenbus_dev_fatal(dev, err, "%s", message);
1153fail:
1154	pr_debug("failed\n");
1155	netback_remove(dev);
1156	return err;
1157}
1158
1159static const struct xenbus_device_id netback_ids[] = {
1160	{ "vif" },
1161	{ "" }
1162};
1163
1164static struct xenbus_driver netback_driver = {
1165	.ids = netback_ids,
1166	.probe = netback_probe,
1167	.remove = netback_remove,
1168	.uevent = netback_uevent,
1169	.otherend_changed = frontend_changed,
1170	.allow_rebind = true,
1171};
1172
1173int xenvif_xenbus_init(void)
1174{
1175	return xenbus_register_backend(&netback_driver);
1176}
1177
1178void xenvif_xenbus_fini(void)
1179{
1180	return xenbus_unregister_driver(&netback_driver);
1181}
1182