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 | |
13 | static int connect_data_rings(struct backend_info *be, |
14 | struct xenvif_queue *queue); |
15 | static void connect(struct backend_info *be); |
16 | static int read_xenbus_vif_flags(struct backend_info *be); |
17 | static int backend_create_xenvif(struct backend_info *be); |
18 | static void unregister_hotplug_status_watch(struct backend_info *be); |
19 | static void xen_unregister_watchers(struct xenvif *vif); |
20 | static void set_backend_state(struct backend_info *be, |
21 | enum xenbus_state state); |
22 | |
23 | #ifdef CONFIG_DEBUG_FS |
24 | struct dentry *xen_netback_dbg_root = NULL; |
25 | |
26 | static 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, fmt: "Queue %d\nTX: nr_ents %u\n" , queue->id, |
37 | tx_ring->nr_ents); |
38 | seq_printf(m, fmt: "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, fmt: "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, fmt: "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, fmt: "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, fmt: "RX: nr_ents %u\n" , rx_ring->nr_ents); |
65 | seq_printf(m, fmt: "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, fmt: "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, fmt: "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(list_: &queue->tx_queue), |
85 | timer_pending(timer: &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(dev: queue->vif->dev, index: queue->id); |
93 | |
94 | seq_printf(m, fmt: "\nRx internal queue: len %u max %u pkts %u %s\n" , |
95 | queue->rx_queue_len, queue->rx_queue_max, |
96 | skb_queue_len(list_: &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 | |
105 | static ssize_t |
106 | xenvif_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(to: write, |
121 | available: sizeof(write) - 1, |
122 | ppos, |
123 | from: 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(irq: 0, dev_id: (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 | |
140 | static 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 | |
152 | static 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 | |
161 | static 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 | } |
169 | DEFINE_SHOW_ATTRIBUTE(xenvif_ctrl); |
170 | |
171 | static void xenvif_debugfs_addif(struct xenvif *vif) |
172 | { |
173 | int i; |
174 | |
175 | vif->xenvif_dbg_root = debugfs_create_dir(name: vif->dev->name, |
176 | parent: xen_netback_dbg_root); |
177 | for (i = 0; i < vif->num_queues; ++i) { |
178 | char filename[sizeof("io_ring_q" ) + 4]; |
179 | |
180 | snprintf(buf: filename, size: sizeof(filename), fmt: "io_ring_q%d" , i); |
181 | debugfs_create_file(name: filename, mode: 0600, parent: vif->xenvif_dbg_root, |
182 | data: &vif->queues[i], |
183 | fops: &xenvif_dbg_io_ring_ops_fops); |
184 | } |
185 | |
186 | if (vif->ctrl_irq) |
187 | debugfs_create_file(name: "ctrl" , mode: 0400, parent: vif->xenvif_dbg_root, data: vif, |
188 | fops: &xenvif_ctrl_fops); |
189 | } |
190 | |
191 | static void xenvif_debugfs_delif(struct xenvif *vif) |
192 | { |
193 | debugfs_remove_recursive(dentry: 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 | */ |
203 | static int netback_uevent(const struct xenbus_device *xdev, |
204 | struct kobj_uevent_env *env) |
205 | { |
206 | struct backend_info *be = dev_get_drvdata(dev: &xdev->dev); |
207 | |
208 | if (!be) |
209 | return 0; |
210 | |
211 | if (add_uevent_var(env, format: "script=%s" , be->hotplug_script)) |
212 | return -ENOMEM; |
213 | |
214 | if (!be->vif) |
215 | return 0; |
216 | |
217 | return add_uevent_var(env, format: "vif=%s" , be->vif->dev->name); |
218 | } |
219 | |
220 | |
221 | static 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, dir: dev->nodename, node: "handle" , fmt: "%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 | |
250 | static 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(queue: &vif->queues[queue_index]); |
272 | |
273 | vfree(addr: vif->queues); |
274 | vif->queues = NULL; |
275 | |
276 | xenvif_disconnect_ctrl(vif); |
277 | } |
278 | } |
279 | |
280 | static void backend_connect(struct backend_info *be) |
281 | { |
282 | if (be->vif) |
283 | connect(be); |
284 | } |
285 | |
286 | static 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, new_state: 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 | */ |
321 | static 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, state: XenbusStateInitWait); |
332 | break; |
333 | case XenbusStateClosed: |
334 | backend_switch_state(be, state: 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, state: XenbusStateInitWait); |
345 | break; |
346 | case XenbusStateClosing: |
347 | backend_switch_state(be, state: 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, state: XenbusStateConnected); |
358 | break; |
359 | case XenbusStateClosing: |
360 | case XenbusStateClosed: |
361 | backend_switch_state(be, state: 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, state: 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, state: XenbusStateClosed); |
385 | break; |
386 | default: |
387 | BUG(); |
388 | } |
389 | break; |
390 | default: |
391 | BUG(); |
392 | } |
393 | } |
394 | } |
395 | |
396 | static 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, dir: dev->otherend, |
404 | node: "xdp-headroom" , fmt: "%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 | */ |
417 | static void frontend_changed(struct xenbus_device *dev, |
418 | enum xenbus_state frontend_state) |
419 | { |
420 | struct backend_info *be = dev_get_drvdata(dev: &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, state: XenbusStateInitWait); |
429 | break; |
430 | |
431 | case XenbusStateInitialised: |
432 | break; |
433 | |
434 | case XenbusStateConnected: |
435 | set_backend_state(be, state: XenbusStateConnected); |
436 | break; |
437 | |
438 | case XenbusStateReconfiguring: |
439 | read_xenbus_frontend_xdp(be, dev); |
440 | xenbus_switch_state(dev, new_state: XenbusStateReconfigured); |
441 | break; |
442 | |
443 | case XenbusStateClosing: |
444 | set_backend_state(be, state: XenbusStateClosing); |
445 | break; |
446 | |
447 | case XenbusStateClosed: |
448 | set_backend_state(be, state: XenbusStateClosed); |
449 | if (xenbus_dev_is_online(dev)) |
450 | break; |
451 | fallthrough; /* if not online */ |
452 | case XenbusStateUnknown: |
453 | set_backend_state(be, state: XenbusStateClosed); |
454 | device_unregister(dev: &dev->dev); |
455 | break; |
456 | |
457 | default: |
458 | xenbus_dev_fatal(dev, err: -EINVAL, fmt: "saw state %d at frontend" , |
459 | frontend_state); |
460 | break; |
461 | } |
462 | } |
463 | |
464 | |
465 | static 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, dir: dev->nodename, node: "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 | |
501 | static 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, dir: dev->nodename, node: "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 | |
523 | static 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, bytes: &credit_bytes, usec: &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(timer: &queue->credit_timeout, expires: jiffies) && |
539 | queue->remaining_credit > queue->credit_bytes) { |
540 | queue->remaining_credit = queue->credit_bytes; |
541 | } |
542 | } |
543 | } |
544 | |
545 | static 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(size: maxlen, GFP_KERNEL); |
556 | if (!node) |
557 | return -ENOMEM; |
558 | snprintf(buf: node, size: maxlen, fmt: "%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(watch: &vif->credit_watch); |
563 | if (err) { |
564 | pr_err("Failed to set watcher %s\n" , vif->credit_watch.node); |
565 | kfree(objp: 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 | |
573 | static void xen_unregister_credit_watch(struct xenvif *vif) |
574 | { |
575 | if (vif->credit_watch.node) { |
576 | unregister_xenbus_watch(watch: &vif->credit_watch); |
577 | kfree(objp: vif->credit_watch.node); |
578 | vif->credit_watch.node = NULL; |
579 | } |
580 | } |
581 | |
582 | static 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(dir: dev->otherend, |
590 | node: "request-multicast-control" , default_val: 0); |
591 | } |
592 | |
593 | static 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(size: maxlen, GFP_KERNEL); |
607 | if (!node) { |
608 | pr_err("Failed to allocate memory for watch\n" ); |
609 | return -ENOMEM; |
610 | } |
611 | snprintf(buf: node, size: maxlen, fmt: "%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(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(objp: 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 | |
628 | static void xen_unregister_mcast_ctrl_watch(struct xenvif *vif) |
629 | { |
630 | if (vif->mcast_ctrl_watch.node) { |
631 | unregister_xenbus_watch(watch: &vif->mcast_ctrl_watch); |
632 | kfree(objp: vif->mcast_ctrl_watch.node); |
633 | vif->mcast_ctrl_watch.node = NULL; |
634 | } |
635 | } |
636 | |
637 | static 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 | |
644 | static void xen_unregister_watchers(struct xenvif *vif) |
645 | { |
646 | xen_unregister_mcast_ctrl_watch(vif); |
647 | xen_unregister_credit_watch(vif); |
648 | } |
649 | |
650 | static void unregister_hotplug_status_watch(struct backend_info *be) |
651 | { |
652 | if (be->have_hotplug_status_watch) { |
653 | unregister_xenbus_watch(watch: &be->hotplug_status_watch); |
654 | kfree(objp: be->hotplug_status_watch.node); |
655 | } |
656 | be->have_hotplug_status_watch = 0; |
657 | } |
658 | |
659 | static 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, dir: be->dev->nodename, node: "hotplug-status" , len: &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 | |
682 | static 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, dir: dev->otherend, |
692 | node: "ctrl-ring-ref" , fmt: "%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 | |
717 | done: |
718 | return 0; |
719 | |
720 | fail: |
721 | return err; |
722 | } |
723 | |
724 | static 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(dir: dev->otherend, |
737 | node: "multi-queue-num-queues" , default_val: 1); |
738 | if (requested_num_queues > xenvif_max_queues) { |
739 | /* buggy or malicious guest */ |
740 | xenbus_dev_fatal(dev, err: -EINVAL, |
741 | fmt: "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, mac: be->vif->fe_dev_addr); |
747 | if (err) { |
748 | xenbus_dev_fatal(dev, err, fmt: "parsing %s/mac" , dev->nodename); |
749 | return; |
750 | } |
751 | |
752 | xen_net_read_rate(dev, bytes: &credit_bytes, usec: &credit_usec); |
753 | xen_unregister_watchers(vif: be->vif); |
754 | xen_register_watchers(dev, vif: be->vif); |
755 | read_xenbus_vif_flags(be); |
756 | |
757 | err = connect_ctrl_ring(be); |
758 | if (err) { |
759 | xenbus_dev_fatal(dev, err, fmt: "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, err: -ENOMEM, |
768 | fmt: "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(buf: queue->name, size: sizeof(queue->name), fmt: "%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(vif: 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(dev: be->vif->dev, txq: requested_num_queues); |
820 | netif_set_real_num_rx_queues(dev: be->vif->dev, rxq: requested_num_queues); |
821 | rtnl_unlock(); |
822 | |
823 | xenvif_carrier_on(vif: be->vif); |
824 | |
825 | unregister_hotplug_status_watch(be); |
826 | err = xenbus_watch_pathfmt(dev, watch: &be->hotplug_status_watch, NULL, |
827 | callback: hotplug_status_changed, |
828 | pathfmt: "%s/%s" , dev->nodename, "hotplug-status" ); |
829 | if (!err) |
830 | be->have_hotplug_status_watch = 1; |
831 | |
832 | netif_tx_wake_all_queues(dev: be->vif->dev); |
833 | |
834 | return; |
835 | |
836 | err: |
837 | if (be->vif->num_queues > 0) |
838 | xenvif_disconnect_data(vif: be->vif); /* Clean up existing queues */ |
839 | for (queue_index = 0; queue_index < be->vif->num_queues; ++queue_index) |
840 | xenvif_deinit_queue(queue: &be->vif->queues[queue_index]); |
841 | vfree(addr: be->vif->queues); |
842 | be->vif->queues = NULL; |
843 | be->vif->num_queues = 0; |
844 | xenvif_disconnect_ctrl(vif: be->vif); |
845 | return; |
846 | } |
847 | |
848 | |
849 | static 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 = kstrdup(s: dev->otherend, GFP_KERNEL); |
869 | if (!xspath) { |
870 | xenbus_dev_fatal(dev, err: -ENOMEM, |
871 | fmt: "reading ring references" ); |
872 | return -ENOMEM; |
873 | } |
874 | } else { |
875 | xspathsize = strlen(dev->otherend) + xenstore_path_ext_size; |
876 | xspath = kzalloc(size: xspathsize, GFP_KERNEL); |
877 | if (!xspath) { |
878 | xenbus_dev_fatal(dev, err: -ENOMEM, |
879 | fmt: "reading ring references" ); |
880 | return -ENOMEM; |
881 | } |
882 | snprintf(buf: xspath, size: xspathsize, fmt: "%s/queue-%u" , dev->otherend, |
883 | queue->id); |
884 | } |
885 | |
886 | err = xenbus_gather(XBT_NIL, dir: xspath, |
887 | "tx-ring-ref" , "%lu" , &tx_ring_ref, |
888 | "rx-ring-ref" , "%lu" , &rx_ring_ref, NULL); |
889 | if (err) { |
890 | xenbus_dev_fatal(dev, err, |
891 | "reading %s/ring-ref" , |
892 | xspath); |
893 | goto err; |
894 | } |
895 | |
896 | /* Try split event channels first, then single event channel. */ |
897 | err = xenbus_gather(XBT_NIL, xspath, |
898 | "event-channel-tx" , "%u" , &tx_evtchn, |
899 | "event-channel-rx" , "%u" , &rx_evtchn, NULL); |
900 | if (err < 0) { |
901 | err = xenbus_scanf(XBT_NIL, xspath, |
902 | "event-channel" , "%u" , &tx_evtchn); |
903 | if (err < 0) { |
904 | xenbus_dev_fatal(dev, err, |
905 | "reading %s/event-channel(-tx/rx)" , |
906 | xspath); |
907 | goto err; |
908 | } |
909 | rx_evtchn = tx_evtchn; |
910 | } |
911 | |
912 | /* Map the shared frame, irq etc. */ |
913 | err = xenvif_connect_data(queue, tx_ring_ref, rx_ring_ref, |
914 | tx_evtchn, rx_evtchn); |
915 | if (err) { |
916 | xenbus_dev_fatal(dev, err, |
917 | "mapping shared-frames %lu/%lu port tx %u rx %u" , |
918 | tx_ring_ref, rx_ring_ref, |
919 | tx_evtchn, rx_evtchn); |
920 | goto err; |
921 | } |
922 | |
923 | err = 0; |
924 | err: /* Regular return falls through with err == 0 */ |
925 | kfree(xspath); |
926 | return err; |
927 | } |
928 | |
929 | static int read_xenbus_vif_flags(struct backend_info *be) |
930 | { |
931 | struct xenvif *vif = be->vif; |
932 | struct xenbus_device *dev = be->dev; |
933 | unsigned int rx_copy; |
934 | int err; |
935 | |
936 | err = xenbus_scanf(XBT_NIL, dir: dev->otherend, node: "request-rx-copy" , fmt: "%u" , |
937 | &rx_copy); |
938 | if (err == -ENOENT) { |
939 | err = 0; |
940 | rx_copy = 0; |
941 | } |
942 | if (err < 0) { |
943 | xenbus_dev_fatal(dev, err, "reading %s/request-rx-copy" , |
944 | dev->otherend); |
945 | return err; |
946 | } |
947 | if (!rx_copy) |
948 | return -EOPNOTSUPP; |
949 | |
950 | if (!xenbus_read_unsigned(dev->otherend, "feature-rx-notify" , 0)) { |
951 | /* - Reduce drain timeout to poll more frequently for |
952 | * Rx requests. |
953 | * - Disable Rx stall detection. |
954 | */ |
955 | be->vif->drain_timeout = msecs_to_jiffies(30); |
956 | be->vif->stall_timeout = 0; |
957 | } |
958 | |
959 | vif->can_sg = !!xenbus_read_unsigned(dev->otherend, "feature-sg" , 0); |
960 | |
961 | vif->gso_mask = 0; |
962 | |
963 | if (xenbus_read_unsigned(dev->otherend, "feature-gso-tcpv4" , 0)) |
964 | vif->gso_mask |= GSO_BIT(TCPV4); |
965 | |
966 | if (xenbus_read_unsigned(dev->otherend, "feature-gso-tcpv6" , 0)) |
967 | vif->gso_mask |= GSO_BIT(TCPV6); |
968 | |
969 | vif->ip_csum = !xenbus_read_unsigned(dev->otherend, |
970 | "feature-no-csum-offload" , 0); |
971 | |
972 | vif->ipv6_csum = !!xenbus_read_unsigned(dev->otherend, |
973 | "feature-ipv6-csum-offload" , 0); |
974 | |
975 | read_xenbus_frontend_xdp(be, dev); |
976 | |
977 | return 0; |
978 | } |
979 | |
980 | static void netback_remove(struct xenbus_device *dev) |
981 | { |
982 | struct backend_info *be = dev_get_drvdata(dev: &dev->dev); |
983 | |
984 | unregister_hotplug_status_watch(be); |
985 | xenbus_rm(XBT_NIL, dir: dev->nodename, node: "hotplug-status" ); |
986 | if (be->vif) { |
987 | kobject_uevent(&dev->dev.kobj, KOBJ_OFFLINE); |
988 | backend_disconnect(be); |
989 | xenvif_free(be->vif); |
990 | be->vif = NULL; |
991 | } |
992 | kfree(be->hotplug_script); |
993 | kfree(be); |
994 | dev_set_drvdata(&dev->dev, NULL); |
995 | } |
996 | |
997 | /* |
998 | * Entry point to this code when a new device is created. Allocate the basic |
999 | * structures and switch to InitWait. |
1000 | */ |
1001 | static int netback_probe(struct xenbus_device *dev, |
1002 | const struct xenbus_device_id *id) |
1003 | { |
1004 | const char *message; |
1005 | struct xenbus_transaction xbt; |
1006 | int err; |
1007 | int sg; |
1008 | const char *script; |
1009 | struct backend_info *be = kzalloc(size: sizeof(*be), GFP_KERNEL); |
1010 | |
1011 | if (!be) { |
1012 | xenbus_dev_fatal(dev, err: -ENOMEM, |
1013 | fmt: "allocating backend structure" ); |
1014 | return -ENOMEM; |
1015 | } |
1016 | |
1017 | be->dev = dev; |
1018 | dev_set_drvdata(dev: &dev->dev, data: be); |
1019 | |
1020 | sg = 1; |
1021 | |
1022 | do { |
1023 | err = xenbus_transaction_start(t: &xbt); |
1024 | if (err) { |
1025 | xenbus_dev_fatal(dev, err, fmt: "starting transaction" ); |
1026 | goto fail; |
1027 | } |
1028 | |
1029 | err = xenbus_printf(t: xbt, dir: dev->nodename, node: "feature-sg" , fmt: "%d" , sg); |
1030 | if (err) { |
1031 | message = "writing feature-sg" ; |
1032 | goto abort_transaction; |
1033 | } |
1034 | |
1035 | err = xenbus_printf(t: xbt, dir: dev->nodename, node: "feature-gso-tcpv4" , |
1036 | fmt: "%d" , sg); |
1037 | if (err) { |
1038 | message = "writing feature-gso-tcpv4" ; |
1039 | goto abort_transaction; |
1040 | } |
1041 | |
1042 | err = xenbus_printf(t: xbt, dir: dev->nodename, node: "feature-gso-tcpv6" , |
1043 | fmt: "%d" , sg); |
1044 | if (err) { |
1045 | message = "writing feature-gso-tcpv6" ; |
1046 | goto abort_transaction; |
1047 | } |
1048 | |
1049 | /* We support partial checksum setup for IPv6 packets */ |
1050 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1051 | node: "feature-ipv6-csum-offload" , |
1052 | fmt: "%d" , 1); |
1053 | if (err) { |
1054 | message = "writing feature-ipv6-csum-offload" ; |
1055 | goto abort_transaction; |
1056 | } |
1057 | |
1058 | /* We support rx-copy path. */ |
1059 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1060 | node: "feature-rx-copy" , fmt: "%d" , 1); |
1061 | if (err) { |
1062 | message = "writing feature-rx-copy" ; |
1063 | goto abort_transaction; |
1064 | } |
1065 | |
1066 | /* we can adjust a headroom for netfront XDP processing */ |
1067 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1068 | node: "feature-xdp-headroom" , fmt: "%d" , |
1069 | provides_xdp_headroom); |
1070 | if (err) { |
1071 | message = "writing feature-xdp-headroom" ; |
1072 | goto abort_transaction; |
1073 | } |
1074 | |
1075 | /* We don't support rx-flip path (except old guests who |
1076 | * don't grok this feature flag). |
1077 | */ |
1078 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1079 | node: "feature-rx-flip" , fmt: "%d" , 0); |
1080 | if (err) { |
1081 | message = "writing feature-rx-flip" ; |
1082 | goto abort_transaction; |
1083 | } |
1084 | |
1085 | /* We support dynamic multicast-control. */ |
1086 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1087 | node: "feature-multicast-control" , fmt: "%d" , 1); |
1088 | if (err) { |
1089 | message = "writing feature-multicast-control" ; |
1090 | goto abort_transaction; |
1091 | } |
1092 | |
1093 | err = xenbus_printf(t: xbt, dir: dev->nodename, |
1094 | node: "feature-dynamic-multicast-control" , |
1095 | fmt: "%d" , 1); |
1096 | if (err) { |
1097 | message = "writing feature-dynamic-multicast-control" ; |
1098 | goto abort_transaction; |
1099 | } |
1100 | |
1101 | err = xenbus_transaction_end(t: xbt, abort: 0); |
1102 | } while (err == -EAGAIN); |
1103 | |
1104 | if (err) { |
1105 | xenbus_dev_fatal(dev, err, fmt: "completing transaction" ); |
1106 | goto fail; |
1107 | } |
1108 | |
1109 | /* Split event channels support, this is optional so it is not |
1110 | * put inside the above loop. |
1111 | */ |
1112 | err = xenbus_printf(XBT_NIL, dir: dev->nodename, |
1113 | node: "feature-split-event-channels" , |
1114 | fmt: "%u" , separate_tx_rx_irq); |
1115 | if (err) |
1116 | pr_debug("Error writing feature-split-event-channels\n" ); |
1117 | |
1118 | /* Multi-queue support: This is an optional feature. */ |
1119 | err = xenbus_printf(XBT_NIL, dev->nodename, |
1120 | "multi-queue-max-queues" , "%u" , xenvif_max_queues); |
1121 | if (err) |
1122 | pr_debug("Error writing multi-queue-max-queues\n" ); |
1123 | |
1124 | err = xenbus_printf(XBT_NIL, dev->nodename, |
1125 | "feature-ctrl-ring" , |
1126 | "%u" , true); |
1127 | if (err) |
1128 | pr_debug("Error writing feature-ctrl-ring\n" ); |
1129 | |
1130 | backend_switch_state(be, XenbusStateInitWait); |
1131 | |
1132 | script = xenbus_read(XBT_NIL, dev->nodename, "script" , NULL); |
1133 | if (IS_ERR(script)) { |
1134 | err = PTR_ERR(script); |
1135 | xenbus_dev_fatal(dev, err, "reading script" ); |
1136 | goto fail; |
1137 | } |
1138 | |
1139 | be->hotplug_script = script; |
1140 | |
1141 | /* This kicks hotplug scripts, so do it immediately. */ |
1142 | err = backend_create_xenvif(be); |
1143 | if (err) |
1144 | goto fail; |
1145 | |
1146 | return 0; |
1147 | |
1148 | abort_transaction: |
1149 | xenbus_transaction_end(xbt, 1); |
1150 | xenbus_dev_fatal(dev, err, "%s" , message); |
1151 | fail: |
1152 | pr_debug("failed\n" ); |
1153 | netback_remove(dev); |
1154 | return err; |
1155 | } |
1156 | |
1157 | static const struct xenbus_device_id netback_ids[] = { |
1158 | { "vif" }, |
1159 | { "" } |
1160 | }; |
1161 | |
1162 | static struct xenbus_driver netback_driver = { |
1163 | .ids = netback_ids, |
1164 | .probe = netback_probe, |
1165 | .remove = netback_remove, |
1166 | .uevent = netback_uevent, |
1167 | .otherend_changed = frontend_changed, |
1168 | .allow_rebind = true, |
1169 | }; |
1170 | |
1171 | int xenvif_xenbus_init(void) |
1172 | { |
1173 | return xenbus_register_backend(&netback_driver); |
1174 | } |
1175 | |
1176 | void xenvif_xenbus_fini(void) |
1177 | { |
1178 | return xenbus_unregister_driver(drv: &netback_driver); |
1179 | } |
1180 | |