2019-06-04 15:11:33 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2013-07-31 00:29:47 +07:00
|
|
|
/*
|
|
|
|
* Implementation of the Xen vTPM device frontend
|
|
|
|
*
|
|
|
|
* Author: Daniel De Graaf <dgdegra@tycho.nsa.gov>
|
|
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/interrupt.h>
|
2017-10-18 03:32:29 +07:00
|
|
|
#include <linux/freezer.h>
|
2013-10-10 21:38:27 +07:00
|
|
|
#include <xen/xen.h>
|
2013-07-31 00:29:47 +07:00
|
|
|
#include <xen/events.h>
|
|
|
|
#include <xen/interface/io/tpmif.h>
|
|
|
|
#include <xen/grant_table.h>
|
|
|
|
#include <xen/xenbus.h>
|
|
|
|
#include <xen/page.h>
|
|
|
|
#include "tpm.h"
|
xen/pvhvm: If xen_platform_pci=0 is set don't blow up (v4).
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
2013-11-27 03:05:40 +07:00
|
|
|
#include <xen/platform_pci.h>
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
struct tpm_private {
|
|
|
|
struct tpm_chip *chip;
|
|
|
|
struct xenbus_device *dev;
|
|
|
|
|
|
|
|
struct vtpm_shared_page *shr;
|
|
|
|
|
|
|
|
unsigned int evtchn;
|
|
|
|
int ring_ref;
|
|
|
|
domid_t backend_id;
|
2016-04-01 03:56:56 +07:00
|
|
|
int irq;
|
2016-04-01 03:56:57 +07:00
|
|
|
wait_queue_head_t read_queue;
|
2013-07-31 00:29:47 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
enum status_bits {
|
|
|
|
VTPM_STATUS_RUNNING = 0x1,
|
|
|
|
VTPM_STATUS_IDLE = 0x2,
|
|
|
|
VTPM_STATUS_RESULT = 0x4,
|
|
|
|
VTPM_STATUS_CANCELED = 0x8,
|
|
|
|
};
|
|
|
|
|
2017-10-18 03:32:29 +07:00
|
|
|
static bool wait_for_tpm_stat_cond(struct tpm_chip *chip, u8 mask,
|
|
|
|
bool check_cancel, bool *canceled)
|
|
|
|
{
|
|
|
|
u8 status = chip->ops->status(chip);
|
|
|
|
|
|
|
|
*canceled = false;
|
|
|
|
if ((status & mask) == mask)
|
|
|
|
return true;
|
|
|
|
if (check_cancel && chip->ops->req_canceled(chip, status)) {
|
|
|
|
*canceled = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wait_for_tpm_stat(struct tpm_chip *chip, u8 mask,
|
|
|
|
unsigned long timeout, wait_queue_head_t *queue,
|
|
|
|
bool check_cancel)
|
|
|
|
{
|
|
|
|
unsigned long stop;
|
|
|
|
long rc;
|
|
|
|
u8 status;
|
|
|
|
bool canceled = false;
|
|
|
|
|
|
|
|
/* check current status */
|
|
|
|
status = chip->ops->status(chip);
|
|
|
|
if ((status & mask) == mask)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
stop = jiffies + timeout;
|
|
|
|
|
|
|
|
if (chip->flags & TPM_CHIP_FLAG_IRQ) {
|
|
|
|
again:
|
|
|
|
timeout = stop - jiffies;
|
|
|
|
if ((long)timeout <= 0)
|
|
|
|
return -ETIME;
|
|
|
|
rc = wait_event_interruptible_timeout(*queue,
|
|
|
|
wait_for_tpm_stat_cond(chip, mask, check_cancel,
|
|
|
|
&canceled),
|
|
|
|
timeout);
|
|
|
|
if (rc > 0) {
|
|
|
|
if (canceled)
|
|
|
|
return -ECANCELED;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (rc == -ERESTARTSYS && freezing(current)) {
|
|
|
|
clear_thread_flag(TIF_SIGPENDING);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
do {
|
|
|
|
tpm_msleep(TPM_TIMEOUT);
|
|
|
|
status = chip->ops->status(chip);
|
|
|
|
if ((status & mask) == mask)
|
|
|
|
return 0;
|
|
|
|
} while (time_before(jiffies, stop));
|
|
|
|
}
|
|
|
|
return -ETIME;
|
|
|
|
}
|
|
|
|
|
2013-07-31 00:29:47 +07:00
|
|
|
static u8 vtpm_status(struct tpm_chip *chip)
|
|
|
|
{
|
2016-04-01 03:57:00 +07:00
|
|
|
struct tpm_private *priv = dev_get_drvdata(&chip->dev);
|
2013-07-31 00:29:47 +07:00
|
|
|
switch (priv->shr->state) {
|
|
|
|
case VTPM_STATE_IDLE:
|
|
|
|
return VTPM_STATUS_IDLE | VTPM_STATUS_CANCELED;
|
|
|
|
case VTPM_STATE_FINISH:
|
|
|
|
return VTPM_STATUS_IDLE | VTPM_STATUS_RESULT;
|
|
|
|
case VTPM_STATE_SUBMIT:
|
|
|
|
case VTPM_STATE_CANCEL: /* cancel requested, not yet canceled */
|
|
|
|
return VTPM_STATUS_RUNNING;
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool vtpm_req_canceled(struct tpm_chip *chip, u8 status)
|
|
|
|
{
|
|
|
|
return status & VTPM_STATUS_CANCELED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void vtpm_cancel(struct tpm_chip *chip)
|
|
|
|
{
|
2016-04-01 03:57:00 +07:00
|
|
|
struct tpm_private *priv = dev_get_drvdata(&chip->dev);
|
2013-07-31 00:29:47 +07:00
|
|
|
priv->shr->state = VTPM_STATE_CANCEL;
|
|
|
|
wmb();
|
|
|
|
notify_remote_via_evtchn(priv->evtchn);
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int shr_data_offset(struct vtpm_shared_page *shr)
|
|
|
|
{
|
|
|
|
return sizeof(*shr) + sizeof(u32) * shr->nr_extra_pages;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int vtpm_send(struct tpm_chip *chip, u8 *buf, size_t count)
|
|
|
|
{
|
2016-04-01 03:57:00 +07:00
|
|
|
struct tpm_private *priv = dev_get_drvdata(&chip->dev);
|
2013-07-31 00:29:47 +07:00
|
|
|
struct vtpm_shared_page *shr = priv->shr;
|
|
|
|
unsigned int offset = shr_data_offset(shr);
|
|
|
|
|
|
|
|
u32 ordinal;
|
|
|
|
unsigned long duration;
|
|
|
|
|
|
|
|
if (offset > PAGE_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (offset + count > PAGE_SIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/* Wait for completion of any existing command or cancellation */
|
2016-04-01 03:56:59 +07:00
|
|
|
if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE, chip->timeout_c,
|
2016-04-01 03:56:57 +07:00
|
|
|
&priv->read_queue, true) < 0) {
|
2013-07-31 00:29:47 +07:00
|
|
|
vtpm_cancel(chip);
|
|
|
|
return -ETIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(offset + (u8 *)shr, buf, count);
|
|
|
|
shr->length = count;
|
|
|
|
barrier();
|
|
|
|
shr->state = VTPM_STATE_SUBMIT;
|
|
|
|
wmb();
|
|
|
|
notify_remote_via_evtchn(priv->evtchn);
|
|
|
|
|
2018-11-07 00:04:30 +07:00
|
|
|
ordinal = be32_to_cpu(((struct tpm_header *)buf)->ordinal);
|
2013-07-31 00:29:47 +07:00
|
|
|
duration = tpm_calc_ordinal_duration(chip, ordinal);
|
|
|
|
|
|
|
|
if (wait_for_tpm_stat(chip, VTPM_STATUS_IDLE, duration,
|
2016-04-01 03:56:57 +07:00
|
|
|
&priv->read_queue, true) < 0) {
|
2013-07-31 00:29:47 +07:00
|
|
|
/* got a signal or timeout, try to cancel */
|
|
|
|
vtpm_cancel(chip);
|
|
|
|
return -ETIME;
|
|
|
|
}
|
|
|
|
|
2019-02-08 23:30:58 +07:00
|
|
|
return 0;
|
2013-07-31 00:29:47 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int vtpm_recv(struct tpm_chip *chip, u8 *buf, size_t count)
|
|
|
|
{
|
2016-04-01 03:57:00 +07:00
|
|
|
struct tpm_private *priv = dev_get_drvdata(&chip->dev);
|
2013-07-31 00:29:47 +07:00
|
|
|
struct vtpm_shared_page *shr = priv->shr;
|
|
|
|
unsigned int offset = shr_data_offset(shr);
|
|
|
|
size_t length = shr->length;
|
|
|
|
|
|
|
|
if (shr->state == VTPM_STATE_IDLE)
|
|
|
|
return -ECANCELED;
|
|
|
|
|
|
|
|
/* In theory the wait at the end of _send makes this one unnecessary */
|
2016-04-01 03:56:59 +07:00
|
|
|
if (wait_for_tpm_stat(chip, VTPM_STATUS_RESULT, chip->timeout_c,
|
2016-04-01 03:56:57 +07:00
|
|
|
&priv->read_queue, true) < 0) {
|
2013-07-31 00:29:47 +07:00
|
|
|
vtpm_cancel(chip);
|
|
|
|
return -ETIME;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (offset > PAGE_SIZE)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
if (offset + length > PAGE_SIZE)
|
|
|
|
length = PAGE_SIZE - offset;
|
|
|
|
|
|
|
|
if (length > count)
|
|
|
|
length = count;
|
|
|
|
|
|
|
|
memcpy(buf, offset + (u8 *)shr, length);
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2013-11-27 03:30:43 +07:00
|
|
|
static const struct tpm_class_ops tpm_vtpm = {
|
2013-07-31 00:29:47 +07:00
|
|
|
.status = vtpm_status,
|
|
|
|
.recv = vtpm_recv,
|
|
|
|
.send = vtpm_send,
|
|
|
|
.cancel = vtpm_cancel,
|
|
|
|
.req_complete_mask = VTPM_STATUS_IDLE | VTPM_STATUS_RESULT,
|
|
|
|
.req_complete_val = VTPM_STATUS_IDLE | VTPM_STATUS_RESULT,
|
|
|
|
.req_canceled = vtpm_req_canceled,
|
|
|
|
};
|
|
|
|
|
|
|
|
static irqreturn_t tpmif_interrupt(int dummy, void *dev_id)
|
|
|
|
{
|
|
|
|
struct tpm_private *priv = dev_id;
|
|
|
|
|
|
|
|
switch (priv->shr->state) {
|
|
|
|
case VTPM_STATE_IDLE:
|
|
|
|
case VTPM_STATE_FINISH:
|
2016-04-01 03:56:57 +07:00
|
|
|
wake_up_interruptible(&priv->read_queue);
|
2013-07-31 00:29:47 +07:00
|
|
|
break;
|
|
|
|
case VTPM_STATE_SUBMIT:
|
|
|
|
case VTPM_STATE_CANCEL:
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_chip(struct device *dev, struct tpm_private *priv)
|
|
|
|
{
|
|
|
|
struct tpm_chip *chip;
|
|
|
|
|
2014-12-13 02:46:34 +07:00
|
|
|
chip = tpmm_chip_alloc(dev, &tpm_vtpm);
|
|
|
|
if (IS_ERR(chip))
|
|
|
|
return PTR_ERR(chip);
|
2013-07-31 00:29:47 +07:00
|
|
|
|
2016-04-01 03:56:57 +07:00
|
|
|
init_waitqueue_head(&priv->read_queue);
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
priv->chip = chip;
|
2016-04-01 03:57:00 +07:00
|
|
|
dev_set_drvdata(&chip->dev, priv);
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* caller must clean up in case of errors */
|
|
|
|
static int setup_ring(struct xenbus_device *dev, struct tpm_private *priv)
|
|
|
|
{
|
|
|
|
struct xenbus_transaction xbt;
|
|
|
|
const char *message = NULL;
|
|
|
|
int rv;
|
2015-04-03 13:44:59 +07:00
|
|
|
grant_ref_t gref;
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
priv->shr = (void *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
|
|
|
|
if (!priv->shr) {
|
|
|
|
xenbus_dev_fatal(dev, -ENOMEM, "allocating shared ring");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2018-09-18 05:53:33 +07:00
|
|
|
rv = xenbus_grant_ring(dev, priv->shr, 1, &gref);
|
2013-07-31 00:29:47 +07:00
|
|
|
if (rv < 0)
|
|
|
|
return rv;
|
|
|
|
|
2015-04-03 13:44:59 +07:00
|
|
|
priv->ring_ref = gref;
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
rv = xenbus_alloc_evtchn(dev, &priv->evtchn);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
rv = bind_evtchn_to_irqhandler(priv->evtchn, tpmif_interrupt, 0,
|
|
|
|
"tpmif", priv);
|
|
|
|
if (rv <= 0) {
|
|
|
|
xenbus_dev_fatal(dev, rv, "allocating TPM irq");
|
|
|
|
return rv;
|
|
|
|
}
|
2016-04-01 03:56:56 +07:00
|
|
|
priv->irq = rv;
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
again:
|
|
|
|
rv = xenbus_transaction_start(&xbt);
|
|
|
|
if (rv) {
|
|
|
|
xenbus_dev_fatal(dev, rv, "starting transaction");
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = xenbus_printf(xbt, dev->nodename,
|
|
|
|
"ring-ref", "%u", priv->ring_ref);
|
|
|
|
if (rv) {
|
|
|
|
message = "writing ring-ref";
|
|
|
|
goto abort_transaction;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = xenbus_printf(xbt, dev->nodename, "event-channel", "%u",
|
|
|
|
priv->evtchn);
|
|
|
|
if (rv) {
|
|
|
|
message = "writing event-channel";
|
|
|
|
goto abort_transaction;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = xenbus_printf(xbt, dev->nodename, "feature-protocol-v2", "1");
|
|
|
|
if (rv) {
|
|
|
|
message = "writing feature-protocol-v2";
|
|
|
|
goto abort_transaction;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = xenbus_transaction_end(xbt, 0);
|
|
|
|
if (rv == -EAGAIN)
|
|
|
|
goto again;
|
|
|
|
if (rv) {
|
|
|
|
xenbus_dev_fatal(dev, rv, "completing transaction");
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
xenbus_switch_state(dev, XenbusStateInitialised);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
abort_transaction:
|
|
|
|
xenbus_transaction_end(xbt, 1);
|
|
|
|
if (message)
|
|
|
|
xenbus_dev_error(dev, rv, "%s", message);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ring_free(struct tpm_private *priv)
|
|
|
|
{
|
|
|
|
if (!priv)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (priv->ring_ref)
|
|
|
|
gnttab_end_foreign_access(priv->ring_ref, 0,
|
|
|
|
(unsigned long)priv->shr);
|
|
|
|
else
|
|
|
|
free_page((unsigned long)priv->shr);
|
|
|
|
|
2016-04-01 03:56:56 +07:00
|
|
|
if (priv->irq)
|
|
|
|
unbind_from_irqhandler(priv->irq, priv);
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
kfree(priv);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tpmfront_probe(struct xenbus_device *dev,
|
|
|
|
const struct xenbus_device_id *id)
|
|
|
|
{
|
|
|
|
struct tpm_private *priv;
|
|
|
|
int rv;
|
|
|
|
|
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
|
|
|
|
if (!priv) {
|
|
|
|
xenbus_dev_fatal(dev, -ENOMEM, "allocating priv structure");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = setup_chip(&dev->dev, priv);
|
|
|
|
if (rv) {
|
|
|
|
kfree(priv);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
rv = setup_ring(dev, priv);
|
|
|
|
if (rv) {
|
|
|
|
ring_free(priv);
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
tpm_get_timeouts(priv->chip);
|
|
|
|
|
2014-12-13 02:46:34 +07:00
|
|
|
return tpm_chip_register(priv->chip);
|
2013-07-31 00:29:47 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int tpmfront_remove(struct xenbus_device *dev)
|
|
|
|
{
|
|
|
|
struct tpm_chip *chip = dev_get_drvdata(&dev->dev);
|
2016-04-01 03:57:00 +07:00
|
|
|
struct tpm_private *priv = dev_get_drvdata(&chip->dev);
|
2014-12-13 02:46:34 +07:00
|
|
|
tpm_chip_unregister(chip);
|
2013-07-31 00:29:47 +07:00
|
|
|
ring_free(priv);
|
2016-04-01 03:57:00 +07:00
|
|
|
dev_set_drvdata(&chip->dev, NULL);
|
2013-07-31 00:29:47 +07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int tpmfront_resume(struct xenbus_device *dev)
|
|
|
|
{
|
|
|
|
/* A suspend/resume/migrate will interrupt a vTPM anyway */
|
|
|
|
tpmfront_remove(dev);
|
|
|
|
return tpmfront_probe(dev, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void backend_changed(struct xenbus_device *dev,
|
|
|
|
enum xenbus_state backend_state)
|
|
|
|
{
|
|
|
|
switch (backend_state) {
|
|
|
|
case XenbusStateInitialised:
|
|
|
|
case XenbusStateConnected:
|
|
|
|
if (dev->state == XenbusStateConnected)
|
|
|
|
break;
|
|
|
|
|
2016-10-31 20:58:40 +07:00
|
|
|
if (!xenbus_read_unsigned(dev->otherend, "feature-protocol-v2",
|
|
|
|
0)) {
|
2013-07-31 00:29:47 +07:00
|
|
|
xenbus_dev_fatal(dev, -EINVAL,
|
|
|
|
"vTPM protocol 2 required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
xenbus_switch_state(dev, XenbusStateConnected);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XenbusStateClosing:
|
|
|
|
case XenbusStateClosed:
|
|
|
|
device_unregister(&dev->dev);
|
|
|
|
xenbus_frontend_closed(dev);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct xenbus_device_id tpmfront_ids[] = {
|
|
|
|
{ "vtpm" },
|
|
|
|
{ "" }
|
|
|
|
};
|
|
|
|
MODULE_ALIAS("xen:vtpm");
|
|
|
|
|
2014-09-08 23:30:41 +07:00
|
|
|
static struct xenbus_driver tpmfront_driver = {
|
|
|
|
.ids = tpmfront_ids,
|
|
|
|
.probe = tpmfront_probe,
|
|
|
|
.remove = tpmfront_remove,
|
|
|
|
.resume = tpmfront_resume,
|
|
|
|
.otherend_changed = backend_changed,
|
|
|
|
};
|
2013-07-31 00:29:47 +07:00
|
|
|
|
|
|
|
static int __init xen_tpmfront_init(void)
|
|
|
|
{
|
|
|
|
if (!xen_domain())
|
|
|
|
return -ENODEV;
|
|
|
|
|
xen/pvhvm: If xen_platform_pci=0 is set don't blow up (v4).
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
2013-11-27 03:05:40 +07:00
|
|
|
if (!xen_has_pv_devices())
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-07-31 00:29:47 +07:00
|
|
|
return xenbus_register_frontend(&tpmfront_driver);
|
|
|
|
}
|
|
|
|
module_init(xen_tpmfront_init);
|
|
|
|
|
|
|
|
static void __exit xen_tpmfront_exit(void)
|
|
|
|
{
|
|
|
|
xenbus_unregister_driver(&tpmfront_driver);
|
|
|
|
}
|
|
|
|
module_exit(xen_tpmfront_exit);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Daniel De Graaf <dgdegra@tycho.nsa.gov>");
|
|
|
|
MODULE_DESCRIPTION("Xen vTPM Driver");
|
|
|
|
MODULE_LICENSE("GPL");
|