This source file includes following definitions.
- alloc_pdev
- xen_pcibk_disconnect
- free_pdev
- xen_pcibk_do_attach
- xen_pcibk_attach
- xen_pcibk_publish_pci_dev
- xen_pcibk_export_device
- xen_pcibk_remove_device
- xen_pcibk_publish_pci_root
- xen_pcibk_reconfigure
- xen_pcibk_frontend_changed
- xen_pcibk_setup_backend
- xen_pcibk_be_watch
- xen_pcibk_xenbus_probe
- xen_pcibk_xenbus_remove
- xen_pcibk_xenbus_register
- xen_pcibk_xenbus_unregister
1
2
3
4
5
6
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/moduleparam.h>
11 #include <linux/init.h>
12 #include <linux/list.h>
13 #include <linux/vmalloc.h>
14 #include <linux/workqueue.h>
15 #include <xen/xenbus.h>
16 #include <xen/events.h>
17 #include <asm/xen/pci.h>
18 #include "pciback.h"
19
20 #define INVALID_EVTCHN_IRQ (-1)
21
22 static bool __read_mostly passthrough;
23 module_param(passthrough, bool, S_IRUGO);
24 MODULE_PARM_DESC(passthrough,
25 "Option to specify how to export PCI topology to guest:\n"\
26 " 0 - (default) Hide the true PCI topology and makes the frontend\n"\
27 " there is a single PCI bus with only the exported devices on it.\n"\
28 " For example, a device at 03:05.0 will be re-assigned to 00:00.0\n"\
29 " while second device at 02:1a.1 will be re-assigned to 00:01.1.\n"\
30 " 1 - Passthrough provides a real view of the PCI topology to the\n"\
31 " frontend (for example, a device at 06:01.b will still appear at\n"\
32 " 06:01.b to the frontend). This is similar to how Xen 2.0.x\n"\
33 " exposed PCI devices to its driver domains. This may be required\n"\
34 " for drivers which depend on finding their hardward in certain\n"\
35 " bus/slot locations.");
36
37 static struct xen_pcibk_device *alloc_pdev(struct xenbus_device *xdev)
38 {
39 struct xen_pcibk_device *pdev;
40
41 pdev = kzalloc(sizeof(struct xen_pcibk_device), GFP_KERNEL);
42 if (pdev == NULL)
43 goto out;
44 dev_dbg(&xdev->dev, "allocated pdev @ 0x%p\n", pdev);
45
46 pdev->xdev = xdev;
47
48 mutex_init(&pdev->dev_lock);
49
50 pdev->sh_info = NULL;
51 pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
52 pdev->be_watching = 0;
53
54 INIT_WORK(&pdev->op_work, xen_pcibk_do_op);
55
56 if (xen_pcibk_init_devices(pdev)) {
57 kfree(pdev);
58 pdev = NULL;
59 }
60
61 dev_set_drvdata(&xdev->dev, pdev);
62
63 out:
64 return pdev;
65 }
66
67 static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev)
68 {
69 mutex_lock(&pdev->dev_lock);
70
71 if (pdev->evtchn_irq != INVALID_EVTCHN_IRQ) {
72 unbind_from_irqhandler(pdev->evtchn_irq, pdev);
73 pdev->evtchn_irq = INVALID_EVTCHN_IRQ;
74 }
75
76
77
78
79 flush_work(&pdev->op_work);
80
81 if (pdev->sh_info != NULL) {
82 xenbus_unmap_ring_vfree(pdev->xdev, pdev->sh_info);
83 pdev->sh_info = NULL;
84 }
85 mutex_unlock(&pdev->dev_lock);
86 }
87
88 static void free_pdev(struct xen_pcibk_device *pdev)
89 {
90 if (pdev->be_watching) {
91 unregister_xenbus_watch(&pdev->be_watch);
92 pdev->be_watching = 0;
93 }
94
95 xen_pcibk_disconnect(pdev);
96
97
98
99 xen_pcibk_release_devices(pdev);
100
101 dev_set_drvdata(&pdev->xdev->dev, NULL);
102 pdev->xdev = NULL;
103
104 kfree(pdev);
105 }
106
107 static int xen_pcibk_do_attach(struct xen_pcibk_device *pdev, int gnt_ref,
108 int remote_evtchn)
109 {
110 int err = 0;
111 void *vaddr;
112
113 dev_dbg(&pdev->xdev->dev,
114 "Attaching to frontend resources - gnt_ref=%d evtchn=%d\n",
115 gnt_ref, remote_evtchn);
116
117 err = xenbus_map_ring_valloc(pdev->xdev, &gnt_ref, 1, &vaddr);
118 if (err < 0) {
119 xenbus_dev_fatal(pdev->xdev, err,
120 "Error mapping other domain page in ours.");
121 goto out;
122 }
123
124 pdev->sh_info = vaddr;
125
126 err = bind_interdomain_evtchn_to_irqhandler(
127 pdev->xdev->otherend_id, remote_evtchn, xen_pcibk_handle_event,
128 0, DRV_NAME, pdev);
129 if (err < 0) {
130 xenbus_dev_fatal(pdev->xdev, err,
131 "Error binding event channel to IRQ");
132 goto out;
133 }
134 pdev->evtchn_irq = err;
135 err = 0;
136
137 dev_dbg(&pdev->xdev->dev, "Attached!\n");
138 out:
139 return err;
140 }
141
142 static int xen_pcibk_attach(struct xen_pcibk_device *pdev)
143 {
144 int err = 0;
145 int gnt_ref, remote_evtchn;
146 char *magic = NULL;
147
148
149 mutex_lock(&pdev->dev_lock);
150
151 if (xenbus_read_driver_state(pdev->xdev->nodename) !=
152 XenbusStateInitialised)
153 goto out;
154
155
156 if (xenbus_read_driver_state(pdev->xdev->otherend) !=
157 XenbusStateInitialised)
158 goto out;
159
160 dev_dbg(&pdev->xdev->dev, "Reading frontend config\n");
161
162 err = xenbus_gather(XBT_NIL, pdev->xdev->otherend,
163 "pci-op-ref", "%u", &gnt_ref,
164 "event-channel", "%u", &remote_evtchn,
165 "magic", NULL, &magic, NULL);
166 if (err) {
167
168 xenbus_dev_fatal(pdev->xdev, err,
169 "Error reading configuration from frontend");
170 goto out;
171 }
172
173 if (magic == NULL || strcmp(magic, XEN_PCI_MAGIC) != 0) {
174 xenbus_dev_fatal(pdev->xdev, -EFAULT,
175 "version mismatch (%s/%s) with pcifront - "
176 "halting " DRV_NAME,
177 magic, XEN_PCI_MAGIC);
178 err = -EFAULT;
179 goto out;
180 }
181
182 err = xen_pcibk_do_attach(pdev, gnt_ref, remote_evtchn);
183 if (err)
184 goto out;
185
186 dev_dbg(&pdev->xdev->dev, "Connecting...\n");
187
188 err = xenbus_switch_state(pdev->xdev, XenbusStateConnected);
189 if (err)
190 xenbus_dev_fatal(pdev->xdev, err,
191 "Error switching to connected state!");
192
193 dev_dbg(&pdev->xdev->dev, "Connected? %d\n", err);
194 out:
195 mutex_unlock(&pdev->dev_lock);
196
197 kfree(magic);
198
199 return err;
200 }
201
202 static int xen_pcibk_publish_pci_dev(struct xen_pcibk_device *pdev,
203 unsigned int domain, unsigned int bus,
204 unsigned int devfn, unsigned int devid)
205 {
206 int err;
207 int len;
208 char str[64];
209
210 len = snprintf(str, sizeof(str), "vdev-%d", devid);
211 if (unlikely(len >= (sizeof(str) - 1))) {
212 err = -ENOMEM;
213 goto out;
214 }
215
216
217 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str,
218 "%04x:%02x:%02x.%02x", domain, bus,
219 PCI_SLOT(devfn), PCI_FUNC(devfn));
220
221 out:
222 return err;
223 }
224
225 static int xen_pcibk_export_device(struct xen_pcibk_device *pdev,
226 int domain, int bus, int slot, int func,
227 int devid)
228 {
229 struct pci_dev *dev;
230 int err = 0;
231
232 dev_dbg(&pdev->xdev->dev, "exporting dom %x bus %x slot %x func %x\n",
233 domain, bus, slot, func);
234
235 dev = pcistub_get_pci_dev_by_slot(pdev, domain, bus, slot, func);
236 if (!dev) {
237 err = -EINVAL;
238 xenbus_dev_fatal(pdev->xdev, err,
239 "Couldn't locate PCI device "
240 "(%04x:%02x:%02x.%d)! "
241 "perhaps already in-use?",
242 domain, bus, slot, func);
243 goto out;
244 }
245
246 err = xen_pcibk_add_pci_dev(pdev, dev, devid,
247 xen_pcibk_publish_pci_dev);
248 if (err)
249 goto out;
250
251 dev_info(&dev->dev, "registering for %d\n", pdev->xdev->otherend_id);
252 if (xen_register_device_domain_owner(dev,
253 pdev->xdev->otherend_id) != 0) {
254 dev_err(&dev->dev, "Stealing ownership from dom%d.\n",
255 xen_find_device_domain_owner(dev));
256 xen_unregister_device_domain_owner(dev);
257 xen_register_device_domain_owner(dev, pdev->xdev->otherend_id);
258 }
259
260
261
262
263
264
265
266
267
268 out:
269 return err;
270 }
271
272 static int xen_pcibk_remove_device(struct xen_pcibk_device *pdev,
273 int domain, int bus, int slot, int func)
274 {
275 int err = 0;
276 struct pci_dev *dev;
277
278 dev_dbg(&pdev->xdev->dev, "removing dom %x bus %x slot %x func %x\n",
279 domain, bus, slot, func);
280
281 dev = xen_pcibk_get_pci_dev(pdev, domain, bus, PCI_DEVFN(slot, func));
282 if (!dev) {
283 err = -EINVAL;
284 dev_dbg(&pdev->xdev->dev, "Couldn't locate PCI device "
285 "(%04x:%02x:%02x.%d)! not owned by this domain\n",
286 domain, bus, slot, func);
287 goto out;
288 }
289
290 dev_dbg(&dev->dev, "unregistering for %d\n", pdev->xdev->otherend_id);
291 xen_unregister_device_domain_owner(dev);
292
293
294
295 xen_pcibk_release_pci_dev(pdev, dev, true );
296
297 out:
298 return err;
299 }
300
301 static int xen_pcibk_publish_pci_root(struct xen_pcibk_device *pdev,
302 unsigned int domain, unsigned int bus)
303 {
304 unsigned int d, b;
305 int i, root_num, len, err;
306 char str[64];
307
308 dev_dbg(&pdev->xdev->dev, "Publishing pci roots\n");
309
310 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,
311 "root_num", "%d", &root_num);
312 if (err == 0 || err == -ENOENT)
313 root_num = 0;
314 else if (err < 0)
315 goto out;
316
317
318 for (i = 0; i < root_num; i++) {
319 len = snprintf(str, sizeof(str), "root-%d", i);
320 if (unlikely(len >= (sizeof(str) - 1))) {
321 err = -ENOMEM;
322 goto out;
323 }
324
325 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,
326 str, "%x:%x", &d, &b);
327 if (err < 0)
328 goto out;
329 if (err != 2) {
330 err = -EINVAL;
331 goto out;
332 }
333
334 if (d == domain && b == bus) {
335 err = 0;
336 goto out;
337 }
338 }
339
340 len = snprintf(str, sizeof(str), "root-%d", root_num);
341 if (unlikely(len >= (sizeof(str) - 1))) {
342 err = -ENOMEM;
343 goto out;
344 }
345
346 dev_dbg(&pdev->xdev->dev, "writing root %d at %04x:%02x\n",
347 root_num, domain, bus);
348
349 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str,
350 "%04x:%02x", domain, bus);
351 if (err)
352 goto out;
353
354 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename,
355 "root_num", "%d", (root_num + 1));
356
357 out:
358 return err;
359 }
360
361 static int xen_pcibk_reconfigure(struct xen_pcibk_device *pdev)
362 {
363 int err = 0;
364 int num_devs;
365 int domain, bus, slot, func;
366 unsigned int substate;
367 int i, len;
368 char state_str[64];
369 char dev_str[64];
370
371
372 dev_dbg(&pdev->xdev->dev, "Reconfiguring device ...\n");
373
374 mutex_lock(&pdev->dev_lock);
375
376 if (xenbus_read_driver_state(pdev->xdev->nodename) !=
377 XenbusStateReconfiguring)
378 goto out;
379
380 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, "num_devs", "%d",
381 &num_devs);
382 if (err != 1) {
383 if (err >= 0)
384 err = -EINVAL;
385 xenbus_dev_fatal(pdev->xdev, err,
386 "Error reading number of devices");
387 goto out;
388 }
389
390 for (i = 0; i < num_devs; i++) {
391 len = snprintf(state_str, sizeof(state_str), "state-%d", i);
392 if (unlikely(len >= (sizeof(state_str) - 1))) {
393 err = -ENOMEM;
394 xenbus_dev_fatal(pdev->xdev, err,
395 "String overflow while reading "
396 "configuration");
397 goto out;
398 }
399 substate = xenbus_read_unsigned(pdev->xdev->nodename, state_str,
400 XenbusStateUnknown);
401
402 switch (substate) {
403 case XenbusStateInitialising:
404 dev_dbg(&pdev->xdev->dev, "Attaching dev-%d ...\n", i);
405
406 len = snprintf(dev_str, sizeof(dev_str), "dev-%d", i);
407 if (unlikely(len >= (sizeof(dev_str) - 1))) {
408 err = -ENOMEM;
409 xenbus_dev_fatal(pdev->xdev, err,
410 "String overflow while "
411 "reading configuration");
412 goto out;
413 }
414 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,
415 dev_str, "%x:%x:%x.%x",
416 &domain, &bus, &slot, &func);
417 if (err < 0) {
418 xenbus_dev_fatal(pdev->xdev, err,
419 "Error reading device "
420 "configuration");
421 goto out;
422 }
423 if (err != 4) {
424 err = -EINVAL;
425 xenbus_dev_fatal(pdev->xdev, err,
426 "Error parsing pci device "
427 "configuration");
428 goto out;
429 }
430
431 err = xen_pcibk_export_device(pdev, domain, bus, slot,
432 func, i);
433 if (err)
434 goto out;
435
436
437 err = xen_pcibk_publish_pci_roots(pdev,
438 xen_pcibk_publish_pci_root);
439 if (err) {
440 xenbus_dev_fatal(pdev->xdev, err,
441 "Error while publish PCI root"
442 "buses for frontend");
443 goto out;
444 }
445
446 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename,
447 state_str, "%d",
448 XenbusStateInitialised);
449 if (err) {
450 xenbus_dev_fatal(pdev->xdev, err,
451 "Error switching substate of "
452 "dev-%d\n", i);
453 goto out;
454 }
455 break;
456
457 case XenbusStateClosing:
458 dev_dbg(&pdev->xdev->dev, "Detaching dev-%d ...\n", i);
459
460 len = snprintf(dev_str, sizeof(dev_str), "vdev-%d", i);
461 if (unlikely(len >= (sizeof(dev_str) - 1))) {
462 err = -ENOMEM;
463 xenbus_dev_fatal(pdev->xdev, err,
464 "String overflow while "
465 "reading configuration");
466 goto out;
467 }
468 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename,
469 dev_str, "%x:%x:%x.%x",
470 &domain, &bus, &slot, &func);
471 if (err < 0) {
472 xenbus_dev_fatal(pdev->xdev, err,
473 "Error reading device "
474 "configuration");
475 goto out;
476 }
477 if (err != 4) {
478 err = -EINVAL;
479 xenbus_dev_fatal(pdev->xdev, err,
480 "Error parsing pci device "
481 "configuration");
482 goto out;
483 }
484
485 err = xen_pcibk_remove_device(pdev, domain, bus, slot,
486 func);
487 if (err)
488 goto out;
489
490
491
492
493
494
495 break;
496
497 default:
498 break;
499 }
500 }
501
502 err = xenbus_switch_state(pdev->xdev, XenbusStateReconfigured);
503 if (err) {
504 xenbus_dev_fatal(pdev->xdev, err,
505 "Error switching to reconfigured state!");
506 goto out;
507 }
508
509 out:
510 mutex_unlock(&pdev->dev_lock);
511 return 0;
512 }
513
514 static void xen_pcibk_frontend_changed(struct xenbus_device *xdev,
515 enum xenbus_state fe_state)
516 {
517 struct xen_pcibk_device *pdev = dev_get_drvdata(&xdev->dev);
518
519 dev_dbg(&xdev->dev, "fe state changed %d\n", fe_state);
520
521 switch (fe_state) {
522 case XenbusStateInitialised:
523 xen_pcibk_attach(pdev);
524 break;
525
526 case XenbusStateReconfiguring:
527 xen_pcibk_reconfigure(pdev);
528 break;
529
530 case XenbusStateConnected:
531
532
533
534 xenbus_switch_state(xdev, XenbusStateConnected);
535 break;
536
537 case XenbusStateClosing:
538 xen_pcibk_disconnect(pdev);
539 xenbus_switch_state(xdev, XenbusStateClosing);
540 break;
541
542 case XenbusStateClosed:
543 xen_pcibk_disconnect(pdev);
544 xenbus_switch_state(xdev, XenbusStateClosed);
545 if (xenbus_dev_is_online(xdev))
546 break;
547
548 case XenbusStateUnknown:
549 dev_dbg(&xdev->dev, "frontend is gone! unregister device\n");
550 device_unregister(&xdev->dev);
551 break;
552
553 default:
554 break;
555 }
556 }
557
558 static int xen_pcibk_setup_backend(struct xen_pcibk_device *pdev)
559 {
560
561 int domain, bus, slot, func;
562 int err = 0;
563 int i, num_devs;
564 char dev_str[64];
565 char state_str[64];
566
567 mutex_lock(&pdev->dev_lock);
568
569
570
571 if (xenbus_read_driver_state(pdev->xdev->nodename) !=
572 XenbusStateInitWait)
573 goto out;
574
575 dev_dbg(&pdev->xdev->dev, "getting be setup\n");
576
577 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, "num_devs", "%d",
578 &num_devs);
579 if (err != 1) {
580 if (err >= 0)
581 err = -EINVAL;
582 xenbus_dev_fatal(pdev->xdev, err,
583 "Error reading number of devices");
584 goto out;
585 }
586
587 for (i = 0; i < num_devs; i++) {
588 int l = snprintf(dev_str, sizeof(dev_str), "dev-%d", i);
589 if (unlikely(l >= (sizeof(dev_str) - 1))) {
590 err = -ENOMEM;
591 xenbus_dev_fatal(pdev->xdev, err,
592 "String overflow while reading "
593 "configuration");
594 goto out;
595 }
596
597 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, dev_str,
598 "%x:%x:%x.%x", &domain, &bus, &slot, &func);
599 if (err < 0) {
600 xenbus_dev_fatal(pdev->xdev, err,
601 "Error reading device configuration");
602 goto out;
603 }
604 if (err != 4) {
605 err = -EINVAL;
606 xenbus_dev_fatal(pdev->xdev, err,
607 "Error parsing pci device "
608 "configuration");
609 goto out;
610 }
611
612 err = xen_pcibk_export_device(pdev, domain, bus, slot, func, i);
613 if (err)
614 goto out;
615
616
617 l = snprintf(state_str, sizeof(state_str), "state-%d", i);
618 if (unlikely(l >= (sizeof(state_str) - 1))) {
619 err = -ENOMEM;
620 xenbus_dev_fatal(pdev->xdev, err,
621 "String overflow while reading "
622 "configuration");
623 goto out;
624 }
625 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, state_str,
626 "%d", XenbusStateInitialised);
627 if (err) {
628 xenbus_dev_fatal(pdev->xdev, err, "Error switching "
629 "substate of dev-%d\n", i);
630 goto out;
631 }
632 }
633
634 err = xen_pcibk_publish_pci_roots(pdev, xen_pcibk_publish_pci_root);
635 if (err) {
636 xenbus_dev_fatal(pdev->xdev, err,
637 "Error while publish PCI root buses "
638 "for frontend");
639 goto out;
640 }
641
642 err = xenbus_switch_state(pdev->xdev, XenbusStateInitialised);
643 if (err)
644 xenbus_dev_fatal(pdev->xdev, err,
645 "Error switching to initialised state!");
646
647 out:
648 mutex_unlock(&pdev->dev_lock);
649 if (!err)
650
651 xen_pcibk_attach(pdev);
652 return err;
653 }
654
655 static void xen_pcibk_be_watch(struct xenbus_watch *watch,
656 const char *path, const char *token)
657 {
658 struct xen_pcibk_device *pdev =
659 container_of(watch, struct xen_pcibk_device, be_watch);
660
661 switch (xenbus_read_driver_state(pdev->xdev->nodename)) {
662 case XenbusStateInitWait:
663 xen_pcibk_setup_backend(pdev);
664 break;
665
666 default:
667 break;
668 }
669 }
670
671 static int xen_pcibk_xenbus_probe(struct xenbus_device *dev,
672 const struct xenbus_device_id *id)
673 {
674 int err = 0;
675 struct xen_pcibk_device *pdev = alloc_pdev(dev);
676
677 if (pdev == NULL) {
678 err = -ENOMEM;
679 xenbus_dev_fatal(dev, err,
680 "Error allocating xen_pcibk_device struct");
681 goto out;
682 }
683
684
685 err = xenbus_switch_state(dev, XenbusStateInitWait);
686 if (err)
687 goto out;
688
689
690 err = xenbus_watch_path(dev, dev->nodename, &pdev->be_watch,
691 xen_pcibk_be_watch);
692 if (err)
693 goto out;
694
695 pdev->be_watching = 1;
696
697
698
699
700 xen_pcibk_be_watch(&pdev->be_watch, NULL, NULL);
701
702 out:
703 return err;
704 }
705
706 static int xen_pcibk_xenbus_remove(struct xenbus_device *dev)
707 {
708 struct xen_pcibk_device *pdev = dev_get_drvdata(&dev->dev);
709
710 if (pdev != NULL)
711 free_pdev(pdev);
712
713 return 0;
714 }
715
716 static const struct xenbus_device_id xen_pcibk_ids[] = {
717 {"pci"},
718 {""},
719 };
720
721 static struct xenbus_driver xen_pcibk_driver = {
722 .name = DRV_NAME,
723 .ids = xen_pcibk_ids,
724 .probe = xen_pcibk_xenbus_probe,
725 .remove = xen_pcibk_xenbus_remove,
726 .otherend_changed = xen_pcibk_frontend_changed,
727 };
728
729 const struct xen_pcibk_backend *__read_mostly xen_pcibk_backend;
730
731 int __init xen_pcibk_xenbus_register(void)
732 {
733 xen_pcibk_backend = &xen_pcibk_vpci_backend;
734 if (passthrough)
735 xen_pcibk_backend = &xen_pcibk_passthrough_backend;
736 pr_info("backend is %s\n", xen_pcibk_backend->name);
737 return xenbus_register_backend(&xen_pcibk_driver);
738 }
739
740 void __exit xen_pcibk_xenbus_unregister(void)
741 {
742 xenbus_unregister_driver(&xen_pcibk_driver);
743 }