mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-14 14:34:28 +08:00
51c71a3bba
The user has the option of disabling the platform driver: 00:02.0 Unassigned class [ff80]: XenSource, Inc. Xen Platform Device (rev 01) which is used to unplug the emulated drivers (IDE, Realtek 8169, etc) and allow the PV drivers to take over. If the user wishes to disable that they can set: xen_platform_pci=0 (in the guest config file) or xen_emul_unplug=never (on the Linux command line) except it does not work properly. The PV drivers still try to load and since the Xen platform driver is not run - and it has not initialized the grant tables, most of the PV drivers stumble upon: input: Xen Virtual Keyboard as /devices/virtual/input/input5 input: Xen Virtual Pointer as /devices/virtual/input/input6M ------------[ cut here ]------------ kernel BUG at /home/konrad/ssd/konrad/linux/drivers/xen/grant-table.c:1206! invalid opcode: 0000 [#1] SMP Modules linked in: xen_kbdfront(+) xenfs xen_privcmd CPU: 6 PID: 1389 Comm: modprobe Not tainted 3.13.0-rc1upstream-00021-ga6c892b-dirty #1 Hardware name: Xen HVM domU, BIOS 4.4-unstable 11/26/2013 RIP: 0010:[<ffffffff813ddc40>] [<ffffffff813ddc40>] get_free_entries+0x2e0/0x300 Call Trace: [<ffffffff8150d9a3>] ? evdev_connect+0x1e3/0x240 [<ffffffff813ddd0e>] gnttab_grant_foreign_access+0x2e/0x70 [<ffffffffa0010081>] xenkbd_connect_backend+0x41/0x290 [xen_kbdfront] [<ffffffffa0010a12>] xenkbd_probe+0x2f2/0x324 [xen_kbdfront] [<ffffffff813e5757>] xenbus_dev_probe+0x77/0x130 [<ffffffff813e7217>] xenbus_frontend_dev_probe+0x47/0x50 [<ffffffff8145e9a9>] driver_probe_device+0x89/0x230 [<ffffffff8145ebeb>] __driver_attach+0x9b/0xa0 [<ffffffff8145eb50>] ? driver_probe_device+0x230/0x230 [<ffffffff8145eb50>] ? driver_probe_device+0x230/0x230 [<ffffffff8145cf1c>] bus_for_each_dev+0x8c/0xb0 [<ffffffff8145e7d9>] driver_attach+0x19/0x20 [<ffffffff8145e260>] bus_add_driver+0x1a0/0x220 [<ffffffff8145f1ff>] driver_register+0x5f/0xf0 [<ffffffff813e55c5>] xenbus_register_driver_common+0x15/0x20 [<ffffffff813e76b3>] xenbus_register_frontend+0x23/0x40 [<ffffffffa0015000>] ? 0xffffffffa0014fff [<ffffffffa001502b>] xenkbd_init+0x2b/0x1000 [xen_kbdfront] [<ffffffff81002049>] do_one_initcall+0x49/0x170 .. snip.. which is hardly nice. This patch fixes this by having each PV driver check for: - if running in PV, then it is fine to execute (as that is their native environment). - if running in HVM, check if user wanted 'xen_emul_unplug=never', in which case bail out and don't load any PV drivers. - if running in HVM, and if PCI device 5853:0001 (xen_platform_pci) does not exist, then bail out and not load PV drivers. - (v2) if running in HVM, and if the user wanted 'xen_emul_unplug=ide-disks', then bail out for all PV devices _except_ the block one. Ditto for the network one ('nics'). - (v2) if running in HVM, and if the user wanted 'xen_emul_unplug=unnecessary' then load block PV driver, and also setup the legacy IDE paths. In (v3) make it actually load PV drivers. Reported-by: Sander Eikelenboom <linux@eikelenboom.it Reported-by: Anthony PERARD <anthony.perard@citrix.com> Reported-and-Tested-by: Fabio Fantoni <fabio.fantoni@m2r.biz> Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com> [v2: Add extra logic to handle the myrid ways 'xen_emul_unplug' can be used per Ian and Stefano suggestion] [v3: Make the unnecessary case work properly] [v4: s/disks/ide-disks/ spotted by Fabio] Reviewed-by: Stefano Stabellini <stefano.stabellini@eu.citrix.com> Acked-by: Bjorn Helgaas <bhelgaas@google.com> [for PCI parts] CC: stable@vger.kernel.org
401 lines
9.7 KiB
C
401 lines
9.7 KiB
C
/*
|
|
* Xen para-virtual input device
|
|
*
|
|
* Copyright (C) 2005 Anthony Liguori <aliguori@us.ibm.com>
|
|
* Copyright (C) 2006-2008 Red Hat, Inc., Markus Armbruster <armbru@redhat.com>
|
|
*
|
|
* Based on linux/drivers/input/mouse/sermouse.c
|
|
*
|
|
* This file is subject to the terms and conditions of the GNU General Public
|
|
* License. See the file COPYING in the main directory of this archive for
|
|
* more details.
|
|
*/
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/input.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <asm/xen/hypervisor.h>
|
|
|
|
#include <xen/xen.h>
|
|
#include <xen/events.h>
|
|
#include <xen/page.h>
|
|
#include <xen/grant_table.h>
|
|
#include <xen/interface/grant_table.h>
|
|
#include <xen/interface/io/fbif.h>
|
|
#include <xen/interface/io/kbdif.h>
|
|
#include <xen/xenbus.h>
|
|
#include <xen/platform_pci.h>
|
|
|
|
struct xenkbd_info {
|
|
struct input_dev *kbd;
|
|
struct input_dev *ptr;
|
|
struct xenkbd_page *page;
|
|
int gref;
|
|
int irq;
|
|
struct xenbus_device *xbdev;
|
|
char phys[32];
|
|
};
|
|
|
|
static int xenkbd_remove(struct xenbus_device *);
|
|
static int xenkbd_connect_backend(struct xenbus_device *, struct xenkbd_info *);
|
|
static void xenkbd_disconnect_backend(struct xenkbd_info *);
|
|
|
|
/*
|
|
* Note: if you need to send out events, see xenfb_do_update() for how
|
|
* to do that.
|
|
*/
|
|
|
|
static irqreturn_t input_handler(int rq, void *dev_id)
|
|
{
|
|
struct xenkbd_info *info = dev_id;
|
|
struct xenkbd_page *page = info->page;
|
|
__u32 cons, prod;
|
|
|
|
prod = page->in_prod;
|
|
if (prod == page->in_cons)
|
|
return IRQ_HANDLED;
|
|
rmb(); /* ensure we see ring contents up to prod */
|
|
for (cons = page->in_cons; cons != prod; cons++) {
|
|
union xenkbd_in_event *event;
|
|
struct input_dev *dev;
|
|
event = &XENKBD_IN_RING_REF(page, cons);
|
|
|
|
dev = info->ptr;
|
|
switch (event->type) {
|
|
case XENKBD_TYPE_MOTION:
|
|
input_report_rel(dev, REL_X, event->motion.rel_x);
|
|
input_report_rel(dev, REL_Y, event->motion.rel_y);
|
|
if (event->motion.rel_z)
|
|
input_report_rel(dev, REL_WHEEL,
|
|
-event->motion.rel_z);
|
|
break;
|
|
case XENKBD_TYPE_KEY:
|
|
dev = NULL;
|
|
if (test_bit(event->key.keycode, info->kbd->keybit))
|
|
dev = info->kbd;
|
|
if (test_bit(event->key.keycode, info->ptr->keybit))
|
|
dev = info->ptr;
|
|
if (dev)
|
|
input_report_key(dev, event->key.keycode,
|
|
event->key.pressed);
|
|
else
|
|
pr_warning("unhandled keycode 0x%x\n",
|
|
event->key.keycode);
|
|
break;
|
|
case XENKBD_TYPE_POS:
|
|
input_report_abs(dev, ABS_X, event->pos.abs_x);
|
|
input_report_abs(dev, ABS_Y, event->pos.abs_y);
|
|
if (event->pos.rel_z)
|
|
input_report_rel(dev, REL_WHEEL,
|
|
-event->pos.rel_z);
|
|
break;
|
|
}
|
|
if (dev)
|
|
input_sync(dev);
|
|
}
|
|
mb(); /* ensure we got ring contents */
|
|
page->in_cons = cons;
|
|
notify_remote_via_irq(info->irq);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
static int xenkbd_probe(struct xenbus_device *dev,
|
|
const struct xenbus_device_id *id)
|
|
{
|
|
int ret, i, abs;
|
|
struct xenkbd_info *info;
|
|
struct input_dev *kbd, *ptr;
|
|
|
|
info = kzalloc(sizeof(*info), GFP_KERNEL);
|
|
if (!info) {
|
|
xenbus_dev_fatal(dev, -ENOMEM, "allocating info structure");
|
|
return -ENOMEM;
|
|
}
|
|
dev_set_drvdata(&dev->dev, info);
|
|
info->xbdev = dev;
|
|
info->irq = -1;
|
|
info->gref = -1;
|
|
snprintf(info->phys, sizeof(info->phys), "xenbus/%s", dev->nodename);
|
|
|
|
info->page = (void *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
|
|
if (!info->page)
|
|
goto error_nomem;
|
|
|
|
if (xenbus_scanf(XBT_NIL, dev->otherend, "feature-abs-pointer", "%d", &abs) < 0)
|
|
abs = 0;
|
|
if (abs)
|
|
xenbus_printf(XBT_NIL, dev->nodename, "request-abs-pointer", "1");
|
|
|
|
/* keyboard */
|
|
kbd = input_allocate_device();
|
|
if (!kbd)
|
|
goto error_nomem;
|
|
kbd->name = "Xen Virtual Keyboard";
|
|
kbd->phys = info->phys;
|
|
kbd->id.bustype = BUS_PCI;
|
|
kbd->id.vendor = 0x5853;
|
|
kbd->id.product = 0xffff;
|
|
|
|
__set_bit(EV_KEY, kbd->evbit);
|
|
for (i = KEY_ESC; i < KEY_UNKNOWN; i++)
|
|
__set_bit(i, kbd->keybit);
|
|
for (i = KEY_OK; i < KEY_MAX; i++)
|
|
__set_bit(i, kbd->keybit);
|
|
|
|
ret = input_register_device(kbd);
|
|
if (ret) {
|
|
input_free_device(kbd);
|
|
xenbus_dev_fatal(dev, ret, "input_register_device(kbd)");
|
|
goto error;
|
|
}
|
|
info->kbd = kbd;
|
|
|
|
/* pointing device */
|
|
ptr = input_allocate_device();
|
|
if (!ptr)
|
|
goto error_nomem;
|
|
ptr->name = "Xen Virtual Pointer";
|
|
ptr->phys = info->phys;
|
|
ptr->id.bustype = BUS_PCI;
|
|
ptr->id.vendor = 0x5853;
|
|
ptr->id.product = 0xfffe;
|
|
|
|
if (abs) {
|
|
__set_bit(EV_ABS, ptr->evbit);
|
|
input_set_abs_params(ptr, ABS_X, 0, XENFB_WIDTH, 0, 0);
|
|
input_set_abs_params(ptr, ABS_Y, 0, XENFB_HEIGHT, 0, 0);
|
|
} else {
|
|
input_set_capability(ptr, EV_REL, REL_X);
|
|
input_set_capability(ptr, EV_REL, REL_Y);
|
|
}
|
|
input_set_capability(ptr, EV_REL, REL_WHEEL);
|
|
|
|
__set_bit(EV_KEY, ptr->evbit);
|
|
for (i = BTN_LEFT; i <= BTN_TASK; i++)
|
|
__set_bit(i, ptr->keybit);
|
|
|
|
ret = input_register_device(ptr);
|
|
if (ret) {
|
|
input_free_device(ptr);
|
|
xenbus_dev_fatal(dev, ret, "input_register_device(ptr)");
|
|
goto error;
|
|
}
|
|
info->ptr = ptr;
|
|
|
|
ret = xenkbd_connect_backend(dev, info);
|
|
if (ret < 0)
|
|
goto error;
|
|
|
|
return 0;
|
|
|
|
error_nomem:
|
|
ret = -ENOMEM;
|
|
xenbus_dev_fatal(dev, ret, "allocating device memory");
|
|
error:
|
|
xenkbd_remove(dev);
|
|
return ret;
|
|
}
|
|
|
|
static int xenkbd_resume(struct xenbus_device *dev)
|
|
{
|
|
struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
|
|
|
|
xenkbd_disconnect_backend(info);
|
|
memset(info->page, 0, PAGE_SIZE);
|
|
return xenkbd_connect_backend(dev, info);
|
|
}
|
|
|
|
static int xenkbd_remove(struct xenbus_device *dev)
|
|
{
|
|
struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
|
|
|
|
xenkbd_disconnect_backend(info);
|
|
if (info->kbd)
|
|
input_unregister_device(info->kbd);
|
|
if (info->ptr)
|
|
input_unregister_device(info->ptr);
|
|
free_page((unsigned long)info->page);
|
|
kfree(info);
|
|
return 0;
|
|
}
|
|
|
|
static int xenkbd_connect_backend(struct xenbus_device *dev,
|
|
struct xenkbd_info *info)
|
|
{
|
|
int ret, evtchn;
|
|
struct xenbus_transaction xbt;
|
|
|
|
ret = gnttab_grant_foreign_access(dev->otherend_id,
|
|
virt_to_mfn(info->page), 0);
|
|
if (ret < 0)
|
|
return ret;
|
|
info->gref = ret;
|
|
|
|
ret = xenbus_alloc_evtchn(dev, &evtchn);
|
|
if (ret)
|
|
goto error_grant;
|
|
ret = bind_evtchn_to_irqhandler(evtchn, input_handler,
|
|
0, dev->devicetype, info);
|
|
if (ret < 0) {
|
|
xenbus_dev_fatal(dev, ret, "bind_evtchn_to_irqhandler");
|
|
goto error_evtchan;
|
|
}
|
|
info->irq = ret;
|
|
|
|
again:
|
|
ret = xenbus_transaction_start(&xbt);
|
|
if (ret) {
|
|
xenbus_dev_fatal(dev, ret, "starting transaction");
|
|
goto error_irqh;
|
|
}
|
|
ret = xenbus_printf(xbt, dev->nodename, "page-ref", "%lu",
|
|
virt_to_mfn(info->page));
|
|
if (ret)
|
|
goto error_xenbus;
|
|
ret = xenbus_printf(xbt, dev->nodename, "page-gref", "%u", info->gref);
|
|
if (ret)
|
|
goto error_xenbus;
|
|
ret = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
|
|
evtchn);
|
|
if (ret)
|
|
goto error_xenbus;
|
|
ret = xenbus_transaction_end(xbt, 0);
|
|
if (ret) {
|
|
if (ret == -EAGAIN)
|
|
goto again;
|
|
xenbus_dev_fatal(dev, ret, "completing transaction");
|
|
goto error_irqh;
|
|
}
|
|
|
|
xenbus_switch_state(dev, XenbusStateInitialised);
|
|
return 0;
|
|
|
|
error_xenbus:
|
|
xenbus_transaction_end(xbt, 1);
|
|
xenbus_dev_fatal(dev, ret, "writing xenstore");
|
|
error_irqh:
|
|
unbind_from_irqhandler(info->irq, info);
|
|
info->irq = -1;
|
|
error_evtchan:
|
|
xenbus_free_evtchn(dev, evtchn);
|
|
error_grant:
|
|
gnttab_end_foreign_access_ref(info->gref, 0);
|
|
info->gref = -1;
|
|
return ret;
|
|
}
|
|
|
|
static void xenkbd_disconnect_backend(struct xenkbd_info *info)
|
|
{
|
|
if (info->irq >= 0)
|
|
unbind_from_irqhandler(info->irq, info);
|
|
info->irq = -1;
|
|
if (info->gref >= 0)
|
|
gnttab_end_foreign_access_ref(info->gref, 0);
|
|
info->gref = -1;
|
|
}
|
|
|
|
static void xenkbd_backend_changed(struct xenbus_device *dev,
|
|
enum xenbus_state backend_state)
|
|
{
|
|
struct xenkbd_info *info = dev_get_drvdata(&dev->dev);
|
|
int ret, val;
|
|
|
|
switch (backend_state) {
|
|
case XenbusStateInitialising:
|
|
case XenbusStateInitialised:
|
|
case XenbusStateReconfiguring:
|
|
case XenbusStateReconfigured:
|
|
case XenbusStateUnknown:
|
|
break;
|
|
|
|
case XenbusStateInitWait:
|
|
InitWait:
|
|
ret = xenbus_scanf(XBT_NIL, info->xbdev->otherend,
|
|
"feature-abs-pointer", "%d", &val);
|
|
if (ret < 0)
|
|
val = 0;
|
|
if (val) {
|
|
ret = xenbus_printf(XBT_NIL, info->xbdev->nodename,
|
|
"request-abs-pointer", "1");
|
|
if (ret)
|
|
pr_warning("xenkbd: can't request abs-pointer");
|
|
}
|
|
|
|
xenbus_switch_state(dev, XenbusStateConnected);
|
|
break;
|
|
|
|
case XenbusStateConnected:
|
|
/*
|
|
* Work around xenbus race condition: If backend goes
|
|
* through InitWait to Connected fast enough, we can
|
|
* get Connected twice here.
|
|
*/
|
|
if (dev->state != XenbusStateConnected)
|
|
goto InitWait; /* no InitWait seen yet, fudge it */
|
|
|
|
/* Set input abs params to match backend screen res */
|
|
if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
|
|
"width", "%d", &val) > 0)
|
|
input_set_abs_params(info->ptr, ABS_X, 0, val, 0, 0);
|
|
|
|
if (xenbus_scanf(XBT_NIL, info->xbdev->otherend,
|
|
"height", "%d", &val) > 0)
|
|
input_set_abs_params(info->ptr, ABS_Y, 0, val, 0, 0);
|
|
|
|
break;
|
|
|
|
case XenbusStateClosed:
|
|
if (dev->state == XenbusStateClosed)
|
|
break;
|
|
/* Missed the backend's CLOSING state -- fallthrough */
|
|
case XenbusStateClosing:
|
|
xenbus_frontend_closed(dev);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static const struct xenbus_device_id xenkbd_ids[] = {
|
|
{ "vkbd" },
|
|
{ "" }
|
|
};
|
|
|
|
static DEFINE_XENBUS_DRIVER(xenkbd, ,
|
|
.probe = xenkbd_probe,
|
|
.remove = xenkbd_remove,
|
|
.resume = xenkbd_resume,
|
|
.otherend_changed = xenkbd_backend_changed,
|
|
);
|
|
|
|
static int __init xenkbd_init(void)
|
|
{
|
|
if (!xen_domain())
|
|
return -ENODEV;
|
|
|
|
/* Nothing to do if running in dom0. */
|
|
if (xen_initial_domain())
|
|
return -ENODEV;
|
|
|
|
if (!xen_has_pv_devices())
|
|
return -ENODEV;
|
|
|
|
return xenbus_register_frontend(&xenkbd_driver);
|
|
}
|
|
|
|
static void __exit xenkbd_cleanup(void)
|
|
{
|
|
xenbus_unregister_driver(&xenkbd_driver);
|
|
}
|
|
|
|
module_init(xenkbd_init);
|
|
module_exit(xenkbd_cleanup);
|
|
|
|
MODULE_DESCRIPTION("Xen virtual keyboard/pointer device frontend");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_ALIAS("xen:vkbd");
|