Commit d1a0cf73 authored by Stefan Berger's avatar Stefan Berger Committed by Anthony Liguori
Browse files

Support for TPM command line options



This patch adds support for TPM command line options.
The command line options supported here are

./qemu-... -tpmdev passthrough,path=<path to TPM device>,id=<id>
           -device tpm-tis,tpmdev=<id>,id=<other id>

and

./qemu-... -tpmdev help

where the latter works similar to -soundhw help and shows a list of
available TPM backends (for example 'passthrough').

Using the type parameter, the backend is chosen, i.e., 'passthrough' for the
passthrough driver. The interpretation of the other parameters along
with determining whether enough parameters were provided is pushed into
the backend driver, which needs to implement the interface function
'create' and return a TPMDriverOpts structure if the VM can be started or
'NULL' if not enough or bad parameters were provided.

Monitor support for 'info tpm' has been added. It for example prints the
following:

(qemu) info tpm
TPM devices:
 tpm0: model=tpm-tis
  \ tpm0: type=passthrough,path=/dev/tpm0,cancel-path=/sys/devices/pnp0/00:09/cancel
Signed-off-by: default avatarStefan Berger <stefanb@linux.vnet.ibm.com>
Reviewed-by: default avatarCorey Bryant <coreyb@linux.vnet.ibm.com>
Reviewed-by: default avatarJoel Schopp <jschopp@linux.vnet.ibm.com>
Message-id: 1361987275-26289-2-git-send-email-stefanb@linux.vnet.ibm.com
Signed-off-by: default avatarAnthony Liguori <aliguori@us.ibm.com>
parent fe3cc14f
......@@ -74,6 +74,7 @@ common-obj-y += bt-host.o bt-vhci.o
common-obj-y += dma-helpers.o
common-obj-y += vl.o
common-obj-y += tpm/
common-obj-$(CONFIG_SLIRP) += slirp/
......
......@@ -1642,6 +1642,8 @@ show device tree
show qdev device model list
@item info roms
show roms
@item info tpm
show the TPM device
@end table
ETEXI
......
......@@ -607,6 +607,50 @@ void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
}
}
void hmp_info_tpm(Monitor *mon, const QDict *qdict)
{
TPMInfoList *info_list, *info;
Error *err = NULL;
unsigned int c = 0;
TPMPassthroughOptions *tpo;
info_list = qmp_query_tpm(&err);
if (err) {
monitor_printf(mon, "TPM device not supported\n");
error_free(err);
return;
}
if (info_list) {
monitor_printf(mon, "TPM device:\n");
}
for (info = info_list; info; info = info->next) {
TPMInfo *ti = info->value;
monitor_printf(mon, " tpm%d: model=%s\n",
c, TpmModel_lookup[ti->model]);
monitor_printf(mon, " \\ %s: type=%s",
ti->id, TpmType_lookup[ti->type]);
switch (ti->tpm_options->kind) {
case TPM_TYPE_OPTIONS_KIND_TPM_PASSTHROUGH_OPTIONS:
tpo = ti->tpm_options->tpm_passthrough_options;
monitor_printf(mon, "%s%s%s%s",
tpo->has_path ? ",path=" : "",
tpo->has_path ? tpo->path : "",
tpo->has_cancel_path ? ",cancel-path=" : "",
tpo->has_cancel_path ? tpo->cancel_path : "");
break;
case TPM_TYPE_OPTIONS_KIND_MAX:
break;
}
monitor_printf(mon, "\n");
c++;
}
qapi_free_TPMInfoList(info_list);
}
void hmp_quit(Monitor *mon, const QDict *qdict)
{
monitor_suspend(mon);
......
......@@ -36,6 +36,7 @@ void hmp_info_spice(Monitor *mon, const QDict *qdict);
void hmp_info_balloon(Monitor *mon, const QDict *qdict);
void hmp_info_pci(Monitor *mon, const QDict *qdict);
void hmp_info_block_jobs(Monitor *mon, const QDict *qdict);
void hmp_info_tpm(Monitor *mon, const QDict *qdict);
void hmp_quit(Monitor *mon, const QDict *qdict);
void hmp_stop(Monitor *mon, const QDict *qdict);
void hmp_system_reset(Monitor *mon, const QDict *qdict);
......
/*
* Public TPM functions
*
* Copyright (C) 2011-2013 IBM Corporation
*
* Authors:
* Stefan Berger <stefanb@us.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*/
#ifndef QEMU_TPM_H
#define QEMU_TPM_H
#include "qemu/option.h"
int tpm_config_parse(QemuOptsList *opts_list, const char *optarg);
int tpm_init(void);
void tpm_cleanup(void);
#endif /* QEMU_TPM_H */
......@@ -47,6 +47,7 @@
#include "migration/migration.h"
#include "sysemu/kvm.h"
#include "qemu/acl.h"
#include "tpm/tpm.h"
#include "qapi/qmp/qint.h"
#include "qapi/qmp/qfloat.h"
#include "qapi/qmp/qlist.h"
......@@ -2721,6 +2722,13 @@ static mon_cmd_t info_cmds[] = {
.help = "show available trace-events & their state",
.mhandler.cmd = do_trace_print_events,
},
{
.name = "tpm",
.args_type = "",
.params = "",
.help = "show the TPM device",
.mhandler.cmd = hmp_info_tpm,
},
{
.name = NULL,
},
......
......@@ -3240,3 +3240,107 @@
# Since: 1.4
##
{ 'command': 'chardev-remove', 'data': {'id': 'str'} }
##
# @TpmModel:
#
# An enumeration of TPM models
#
# @tpm-tis: TPM TIS model
#
# Since: 1.5
##
{ 'enum': 'TpmModel', 'data': [ 'tpm-tis' ] }
##
# @query-tpm-models:
#
# Return a list of supported TPM models
#
# Returns: a list of TpmModel
#
# Since: 1.5
##
{ 'command': 'query-tpm-models', 'returns': ['TpmModel'] }
##
# @TpmType:
#
# An enumeration of TPM types
#
# @passthrough: TPM passthrough type
#
# Since: 1.5
##
{ 'enum': 'TpmType', 'data': [ 'passthrough' ] }
##
# @query-tpm-types:
#
# Return a list of supported TPM types
#
# Returns: a list of TpmType
#
# Since: 1.5
##
{ 'command': 'query-tpm-types', 'returns': ['TpmType'] }
##
# @TPMPassthroughOptions:
#
# Information about the TPM passthrough type
#
# @path: #optional string describing the path used for accessing the TPM device
#
# @cancel-path: #optional string showing the TPM's sysfs cancel file
# for cancellation of TPM commands while they are executing
#
# Since: 1.5
##
{ 'type': 'TPMPassthroughOptions', 'data': { '*path' : 'str',
'*cancel-path' : 'str'} }
##
# @TpmTypeOptions:
#
# A union referencing different TPM backend types' configuration options
#
# @tpm-passthough-options: TPMPassthroughOptions describing the TPM
# passthrough configuration options
#
# Since: 1.5
##
{ 'union': 'TpmTypeOptions',
'data': { 'tpm-passthrough-options' : 'TPMPassthroughOptions' } }
##
# @TpmInfo:
#
# Information about the TPM
#
# @id: The Id of the TPM
#
# @model: The TPM frontend model
#
# @type: The TPM (backend) type being used
#
# @tpm-options: The TPM (backend) type configuration options
#
# Since: 1.5
##
{ 'type': 'TPMInfo',
'data': {'id': 'str',
'model': 'TpmModel',
'type': 'TpmType',
'tpm-options': 'TpmTypeOptions' } }
##
# @query-tpm:
#
# Return information about the TPM device
#
# Returns: @TPMInfo on success
#
# Since: 1.5
##
{ 'command': 'query-tpm', 'returns': ['TPMInfo'] }
......@@ -2217,6 +2217,39 @@ STEXI
ETEXI
DEFHEADING()
#ifdef CONFIG_TPM
DEFHEADING(TPM device options:)
DEF("tpmdev", HAS_ARG, QEMU_OPTION_tpmdev, \
"-tpmdev [<type>],id=str[,option][,option][,...]\n",
QEMU_ARCH_ALL)
STEXI
The general form of a TPM device option is:
@table @option
@item -tpmdev @var{backend} ,id=@var{id} [,@var{options}]
@findex -tpmdev
Backend type must be:
The specific backend type will determine the applicable options.
The @code{-tpmdev} option requires a @code{-device} option.
Options to each backend are described below.
Use 'help' to print all available TPM backend types.
@example
qemu -tpmdev help
@end example
@end table
ETEXI
DEFHEADING()
#endif
DEFHEADING(Linux/Multiboot boot specific:)
STEXI
......
......@@ -2715,6 +2715,24 @@ EQMP
.mhandler.cmd_new = qmp_marshal_input_query_target,
},
{
.name = "query-tpm",
.args_type = "",
.mhandler.cmd_new = qmp_marshal_input_query_tpm,
},
{
.name = "query-tpm-models",
.args_type = "",
.mhandler.cmd_new = qmp_marshal_input_query_tpm_models,
},
{
.name = "query-tpm-types",
.args_type = "",
.mhandler.cmd_new = qmp_marshal_input_query_tpm_types,
},
{
.name = "chardev-add",
.args_type = "id:s,backend:q",
......
common-obj-y = tpm.o
/*
* TPM configuration
*
* Copyright (C) 2011-2013 IBM Corporation
*
* Authors:
* Stefan Berger <stefanb@us.ibm.com>
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*
* Based on net.c
*/
#include "config-host.h"
#include "monitor/monitor.h"
#include "qapi/qmp/qerror.h"
#include "tpm_int.h"
#include "tpm/tpm.h"
#include "qemu/config-file.h"
#include "qmp-commands.h"
static QLIST_HEAD(, TPMBackend) tpm_backends =
QLIST_HEAD_INITIALIZER(tpm_backends);
#define TPM_MAX_MODELS 1
#define TPM_MAX_DRIVERS 1
static TPMDriverOps const *be_drivers[TPM_MAX_DRIVERS] = {
NULL,
};
static enum TpmModel tpm_models[TPM_MAX_MODELS] = {
-1,
};
int tpm_register_model(enum TpmModel model)
{
int i;
for (i = 0; i < TPM_MAX_MODELS; i++) {
if (tpm_models[i] == -1) {
tpm_models[i] = model;
return 0;
}
}
error_report("Could not register TPM model");
return 1;
}
static bool tpm_model_is_registered(enum TpmModel model)
{
int i;
for (i = 0; i < TPM_MAX_MODELS; i++) {
if (tpm_models[i] == model) {
return true;
}
}
return false;
}
const TPMDriverOps *tpm_get_backend_driver(const char *type)
{
int i;
for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
if (!strcmp(TpmType_lookup[be_drivers[i]->type], type)) {
return be_drivers[i];
}
}
return NULL;
}
#ifdef CONFIG_TPM
int tpm_register_driver(const TPMDriverOps *tdo)
{
int i;
for (i = 0; i < TPM_MAX_DRIVERS; i++) {
if (!be_drivers[i]) {
be_drivers[i] = tdo;
return 0;
}
}
error_report("Could not register TPM driver");
return 1;
}
/*
* Walk the list of available TPM backend drivers and display them on the
* screen.
*/
void tpm_display_backend_drivers(void)
{
int i;
fprintf(stderr, "Supported TPM types (choose only one):\n");
for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
fprintf(stderr, "%12s %s\n",
TpmType_lookup[be_drivers[i]->type], be_drivers[i]->desc());
}
fprintf(stderr, "\n");
}
/*
* Find the TPM with the given Id
*/
TPMBackend *qemu_find_tpm(const char *id)
{
TPMBackend *drv;
if (id) {
QLIST_FOREACH(drv, &tpm_backends, list) {
if (!strcmp(drv->id, id)) {
return drv;
}
}
}
return NULL;
}
static int configure_tpm(QemuOpts *opts)
{
const char *value;
const char *id;
const TPMDriverOps *be;
TPMBackend *drv;
if (!QLIST_EMPTY(&tpm_backends)) {
error_report("Only one TPM is allowed.\n");
return 1;
}
id = qemu_opts_id(opts);
if (id == NULL) {
qerror_report(QERR_MISSING_PARAMETER, "id");
return 1;
}
value = qemu_opt_get(opts, "type");
if (!value) {
qerror_report(QERR_MISSING_PARAMETER, "type");
tpm_display_backend_drivers();
return 1;
}
be = tpm_get_backend_driver(value);
if (be == NULL) {
qerror_report(QERR_INVALID_PARAMETER_VALUE, "type",
"a TPM backend type");
tpm_display_backend_drivers();
return 1;
}
drv = be->create(opts, id);
if (!drv) {
return 1;
}
QLIST_INSERT_HEAD(&tpm_backends, drv, list);
return 0;
}
static int tpm_init_tpmdev(QemuOpts *opts, void *dummy)
{
return configure_tpm(opts);
}
/*
* Walk the list of TPM backend drivers that are in use and call their
* destroy function to have them cleaned up.
*/
void tpm_cleanup(void)
{
TPMBackend *drv, *next;
QLIST_FOREACH_SAFE(drv, &tpm_backends, list, next) {
QLIST_REMOVE(drv, list);
drv->ops->destroy(drv);
}
}
/*
* Initialize the TPM. Process the tpmdev command line options describing the
* TPM backend.
*/
int tpm_init(void)
{
if (qemu_opts_foreach(qemu_find_opts("tpmdev"),
tpm_init_tpmdev, NULL, 1) != 0) {
return -1;
}
atexit(tpm_cleanup);
return 0;
}
/*
* Parse the TPM configuration options.
* To display all available TPM backends the user may use '-tpmdev help'
*/
int tpm_config_parse(QemuOptsList *opts_list, const char *optarg)
{
QemuOpts *opts;
if (!strcmp(optarg, "help")) {
tpm_display_backend_drivers();
return -1;
}
opts = qemu_opts_parse(opts_list, optarg, 1);
if (!opts) {
return -1;
}
return 0;
}
#endif /* CONFIG_TPM */
static const TPMDriverOps *tpm_driver_find_by_type(enum TpmType type)
{
int i;
for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
if (be_drivers[i]->type == type) {
return be_drivers[i];
}
}
return NULL;
}
static TPMInfo *qmp_query_tpm_inst(TPMBackend *drv)
{
TPMInfo *res = g_new0(TPMInfo, 1);
TPMPassthroughOptions *tpo;
res->id = g_strdup(drv->id);
res->model = drv->fe_model;
res->type = drv->ops->type;
res->tpm_options = g_new0(TpmTypeOptions, 1);
switch (res->type) {
case TPM_TYPE_PASSTHROUGH:
res->tpm_options->kind = TPM_TYPE_OPTIONS_KIND_TPM_PASSTHROUGH_OPTIONS;
tpo = g_new0(TPMPassthroughOptions, 1);
res->tpm_options->tpm_passthrough_options = tpo;
if (drv->path) {
tpo->path = g_strdup(drv->path);
tpo->has_path = true;
}
if (drv->cancel_path) {
tpo->cancel_path = g_strdup(drv->cancel_path);
tpo->has_cancel_path = true;
}
break;
case TPM_TYPE_MAX:
break;
}
return res;
}
/*
* Walk the list of active TPM backends and collect information about them
* following the schema description in qapi-schema.json.
*/
TPMInfoList *qmp_query_tpm(Error **errp)
{
TPMBackend *drv;
TPMInfoList *info, *head = NULL, *cur_item = NULL;
QLIST_FOREACH(drv, &tpm_backends, list) {
if (!tpm_model_is_registered(drv->fe_model)) {
continue;
}
info = g_new0(TPMInfoList, 1);
info->value = qmp_query_tpm_inst(drv);
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
}
}
return head;
}
TpmTypeList *qmp_query_tpm_types(Error **errp)
{
unsigned int i = 0;
TpmTypeList *head = NULL, *prev = NULL, *cur_item;
for (i = 0; i < TPM_TYPE_MAX; i++) {
if (!tpm_driver_find_by_type(i)) {
continue;
}
cur_item = g_new0(TpmTypeList, 1);
cur_item->value = i;
if (prev) {
prev->next = cur_item;
}
if (!head) {
head = cur_item;
}
prev = cur_item;
}
return head;
}
TpmModelList *qmp_query_tpm_models(Error **errp)
{
unsigned int i = 0;
TpmModelList *head = NULL, *prev = NULL, *cur_item;
for (i = 0; i < TPM_MODEL_MAX; i++) {
if (!tpm_model_is_registered(i)) {
continue;
}
cur_item = g_new0(TpmModelList, 1);