mirror of
https://github.com/qemu/qemu.git
synced 2024-12-06 02:03:38 +08:00
84d18f065f
error_is_set(&var) is the same as var != NULL, but it takes whole-program analysis to figure that out. Unnecessarily hard for optimizers, static checkers, and human readers. Dumb it down to obvious. Gets rid of several dozen Coverity false positives. Note that the obvious form is already used in many places. Signed-off-by: Markus Armbruster <armbru@redhat.com> Reviewed-by: Eric Blake <eblake@redhat.com> Reviewed-by: Andreas Färber <afaerber@suse.de> Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
359 lines
7.6 KiB
C
359 lines
7.6 KiB
C
/*
|
|
* 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 "sysemu/tpm_backend.h"
|
|
#include "sysemu/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] = {
|
|
TPM_MODEL_MAX,
|
|
};
|
|
|
|
int tpm_register_model(enum TpmModel model)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < TPM_MAX_MODELS; i++) {
|
|
if (tpm_models[i] == TPM_MODEL_MAX) {
|
|
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.
|
|
*/
|
|
static 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;
|
|
Error *local_err = NULL;
|
|
|
|
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;
|
|
}
|
|
|
|
/* validate backend specific opts */
|
|
qemu_opts_validate(opts, be->opts, &local_err);
|
|
if (local_err) {
|
|
qerror_report_err(local_err);
|
|
error_free(local_err);
|
|
return 1;
|
|
}
|
|
|
|
drv = be->create(opts, id);
|
|
if (!drv) {
|
|
return 1;
|
|
}
|
|
|
|
tpm_backend_open(drv, &local_err);
|
|
if (local_err) {
|
|
qerror_report_err(local_err);
|
|
error_free(local_err);
|
|
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);
|
|
tpm_backend_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->options = g_new0(TpmTypeOptions, 1);
|
|
|
|
switch (drv->ops->type) {
|
|
case TPM_TYPE_PASSTHROUGH:
|
|
res->options->kind = TPM_TYPE_OPTIONS_KIND_PASSTHROUGH;
|
|
tpo = g_new0(TPMPassthroughOptions, 1);
|
|
res->options->passthrough = 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);
|
|
cur_item->value = i;
|
|
|
|
if (prev) {
|
|
prev->next = cur_item;
|
|
}
|
|
if (!head) {
|
|
head = cur_item;
|
|
}
|
|
prev = cur_item;
|
|
}
|
|
|
|
return head;
|
|
}
|