~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3 : contents of tpm.c at revision 10

~pmdj/ubuntu/trusty/qemu/2.9+applesmc+fadtv3 : (revision 10)

/*
 * 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 "qemu/osdep.h"

#include "qapi/qmp/qerror.h"
#include "sysemu/tpm_backend.h"
#include "sysemu/tpm.h"
#include "qemu/config-file.h"
#include "qemu/error-report.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.");
        return 1;
    }

    id = qemu_opts_id(opts);
    if (id == NULL) {
        error_report(QERR_MISSING_PARAMETER, "id");
        return 1;
    }

    value = qemu_opt_get(opts, "type");
    if (!value) {
        error_report(QERR_MISSING_PARAMETER, "type");
        tpm_display_backend_drivers();
        return 1;
    }

    be = tpm_get_backend_driver(value);
    if (be == NULL) {
        error_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) {
        error_report_err(local_err);
        return 1;
    }

    drv = be->create(opts, id);
    if (!drv) {
        return 1;
    }

    tpm_backend_open(drv, &local_err);
    if (local_err) {
        error_report_err(local_err);
        return 1;
    }

    QLIST_INSERT_HEAD(&tpm_backends, drv, list);

    return 0;
}

static int tpm_init_tpmdev(void *dummy, QemuOpts *opts, Error **errp)
{
    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, NULL)) {
        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_noisily(opts_list, optarg, true);
    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->type = TPM_TYPE_OPTIONS_KIND_PASSTHROUGH;
        tpo = g_new0(TPMPassthroughOptions, 1);
        res->options->u.passthrough.data = 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;
}

1 by Michael Tokarev Import upstream version 2.8+dfsg	1	/*
	2	* TPM configuration
	3	*
	4	* Copyright (C) 2011-2013 IBM Corporation
	5	*
	6	* Authors:
	7	* Stefan Berger <stefanb@us.ibm.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*
	12	* Based on net.c
	13	*/
	14	#include "qemu/osdep.h"
	15
	16	#include "qapi/qmp/qerror.h"
	17	#include "sysemu/tpm_backend.h"
	18	#include "sysemu/tpm.h"
	19	#include "qemu/config-file.h"
	20	#include "qemu/error-report.h"
	21	#include "qmp-commands.h"
	22
	23	static QLIST_HEAD(, TPMBackend) tpm_backends =
	24	QLIST_HEAD_INITIALIZER(tpm_backends);
	25
	26
	27	#define TPM_MAX_MODELS 1
	28	#define TPM_MAX_DRIVERS 1
	29
	30	static TPMDriverOps const *be_drivers[TPM_MAX_DRIVERS] = {
	31	NULL,
	32	};
	33
	34	static enum TpmModel tpm_models[TPM_MAX_MODELS] = {
	35	TPM_MODEL__MAX,
	36	};
	37
	38	int tpm_register_model(enum TpmModel model)
	39	{
	40	int i;
	41
	42	for (i = 0; i < TPM_MAX_MODELS; i++) {
	43	if (tpm_models[i] == TPM_MODEL__MAX) {
	44	tpm_models[i] = model;
	45	return 0;
	46	}
	47	}
	48	error_report("Could not register TPM model");
	49	return 1;
	50	}
	51
	52	static bool tpm_model_is_registered(enum TpmModel model)
	53	{
	54	int i;
	55
	56	for (i = 0; i < TPM_MAX_MODELS; i++) {
	57	if (tpm_models[i] == model) {
	58	return true;
	59	}
	60	}
	61	return false;
	62	}
	63
	64	const TPMDriverOps tpm_get_backend_driver(const char type)
65	{
66	int i;
67
68	for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
69	if (!strcmp(TpmType_lookup[be_drivers[i]->type], type)) {
70	return be_drivers[i];
71	}
72	}
73
74	return NULL;
75	}
76
77	#ifdef CONFIG_TPM
78
79	int tpm_register_driver(const TPMDriverOps *tdo)
80	{
81	int i;
82
83	for (i = 0; i < TPM_MAX_DRIVERS; i++) {
84	if (!be_drivers[i]) {
85	be_drivers[i] = tdo;
86	return 0;
87	}
88	}
89	error_report("Could not register TPM driver");
90	return 1;
91	}
92
93	/*
94	* Walk the list of available TPM backend drivers and display them on the
95	* screen.
96	*/
97	static void tpm_display_backend_drivers(void)
98	{
99	int i;
100
101	fprintf(stderr, "Supported TPM types (choose only one):\n");
102
103	for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
104	fprintf(stderr, "%12s %s\n",
105	TpmType_lookup[be_drivers[i]->type], be_drivers[i]->desc());
106	}
107	fprintf(stderr, "\n");
108	}
109
110	/*
111	* Find the TPM with the given Id
112	*/
113	TPMBackend qemu_find_tpm(const char id)
114	{
115	TPMBackend *drv;
116
117	if (id) {
118	QLIST_FOREACH(drv, &tpm_backends, list) {
119	if (!strcmp(drv->id, id)) {
120	return drv;
121	}
122	}
123	}
124
125	return NULL;
126	}
127
128	static int configure_tpm(QemuOpts *opts)
129	{
130	const char *value;
131	const char *id;
132	const TPMDriverOps *be;
133	TPMBackend *drv;
134	Error *local_err = NULL;
135
136	if (!QLIST_EMPTY(&tpm_backends)) {
137	error_report("Only one TPM is allowed.");
138	return 1;
139	}
140
141	id = qemu_opts_id(opts);
142	if (id == NULL) {
143	error_report(QERR_MISSING_PARAMETER, "id");
144	return 1;
145	}
146
147	value = qemu_opt_get(opts, "type");
148	if (!value) {
149	error_report(QERR_MISSING_PARAMETER, "type");
150	tpm_display_backend_drivers();
151	return 1;
152	}
153
154	be = tpm_get_backend_driver(value);
155	if (be == NULL) {
156	error_report(QERR_INVALID_PARAMETER_VALUE,
157	"type", "a TPM backend type");
158	tpm_display_backend_drivers();
159	return 1;
160	}
161
162	/* validate backend specific opts */
163	qemu_opts_validate(opts, be->opts, &local_err);
164	if (local_err) {
165	error_report_err(local_err);
166	return 1;
167	}
168
169	drv = be->create(opts, id);
170	if (!drv) {
171	return 1;
172	}
173
174	tpm_backend_open(drv, &local_err);
175	if (local_err) {
176	error_report_err(local_err);
177	return 1;
178	}
179
180	QLIST_INSERT_HEAD(&tpm_backends, drv, list);
181
182	return 0;
183	}
184
185	static int tpm_init_tpmdev(void dummy, QemuOpts opts, Error **errp)
186	{
187	return configure_tpm(opts);
188	}
189
190	/*
191	* Walk the list of TPM backend drivers that are in use and call their
192	* destroy function to have them cleaned up.
193	*/
194	void tpm_cleanup(void)
195	{
196	TPMBackend drv, next;
197
198	QLIST_FOREACH_SAFE(drv, &tpm_backends, list, next) {
199	QLIST_REMOVE(drv, list);
200	tpm_backend_destroy(drv);
201	}
202	}
203
204	/*
205	* Initialize the TPM. Process the tpmdev command line options describing the
206	* TPM backend.
207	*/
208	int tpm_init(void)
209	{
210	if (qemu_opts_foreach(qemu_find_opts("tpmdev"),
211	tpm_init_tpmdev, NULL, NULL)) {
212	return -1;
213	}
214
215	atexit(tpm_cleanup);
216	return 0;
217	}
218
219	/*
220	* Parse the TPM configuration options.
221	* To display all available TPM backends the user may use '-tpmdev help'
222	*/
223	int tpm_config_parse(QemuOptsList opts_list, const char optarg)
224	{
225	QemuOpts *opts;
226
227	if (!strcmp(optarg, "help")) {
228	tpm_display_backend_drivers();
229	return -1;
230	}
231	opts = qemu_opts_parse_noisily(opts_list, optarg, true);
232	if (!opts) {
233	return -1;
234	}
235	return 0;
236	}
237
238	#endif /* CONFIG_TPM */
239
240	static const TPMDriverOps *tpm_driver_find_by_type(enum TpmType type)
241	{
242	int i;
243
244	for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
245	if (be_drivers[i]->type == type) {
246	return be_drivers[i];
247	}
248	}
249	return NULL;
250	}
251
252	static TPMInfo qmp_query_tpm_inst(TPMBackend drv)
253	{
254	TPMInfo *res = g_new0(TPMInfo, 1);
255	TPMPassthroughOptions *tpo;
256
257	res->id = g_strdup(drv->id);
258	res->model = drv->fe_model;
259	res->options = g_new0(TpmTypeOptions, 1);
260
261	switch (drv->ops->type) {
262	case TPM_TYPE_PASSTHROUGH:
263	res->options->type = TPM_TYPE_OPTIONS_KIND_PASSTHROUGH;
264	tpo = g_new0(TPMPassthroughOptions, 1);
265	res->options->u.passthrough.data = tpo;
266	if (drv->path) {
267	tpo->path = g_strdup(drv->path);
268	tpo->has_path = true;
269	}
270	if (drv->cancel_path) {
271	tpo->cancel_path = g_strdup(drv->cancel_path);
272	tpo->has_cancel_path = true;
273	}
274	break;
275	case TPM_TYPE__MAX:
276	break;
277	}
278
279	return res;
280	}
281
282	/*
283	* Walk the list of active TPM backends and collect information about them
284	* following the schema description in qapi-schema.json.
285	*/
286	TPMInfoList qmp_query_tpm(Error *errp)
287	{
288	TPMBackend *drv;
289	TPMInfoList info, head = NULL, *cur_item = NULL;
290
291	QLIST_FOREACH(drv, &tpm_backends, list) {
292	if (!tpm_model_is_registered(drv->fe_model)) {
293	continue;
294	}
295	info = g_new0(TPMInfoList, 1);
296	info->value = qmp_query_tpm_inst(drv);
297
298	if (!cur_item) {
299	head = cur_item = info;
300	} else {
301	cur_item->next = info;
302	cur_item = info;
303	}
304	}
305
306	return head;
307	}
308
309	TpmTypeList qmp_query_tpm_types(Error *errp)
310	{
311	unsigned int i = 0;
312	TpmTypeList head = NULL, prev = NULL, *cur_item;
313
314	for (i = 0; i < TPM_TYPE__MAX; i++) {
315	if (!tpm_driver_find_by_type(i)) {
316	continue;
317	}
318	cur_item = g_new0(TpmTypeList, 1);
319	cur_item->value = i;
320
321	if (prev) {
322	prev->next = cur_item;
323	}
324	if (!head) {
325	head = cur_item;
326	}
327	prev = cur_item;
328	}
329
330	return head;
331	}
332
333	TpmModelList qmp_query_tpm_models(Error *errp)
334	{
335	unsigned int i = 0;
336	TpmModelList head = NULL, prev = NULL, *cur_item;
337
338	for (i = 0; i < TPM_MODEL__MAX; i++) {
339	if (!tpm_model_is_registered(i)) {
340	continue;
341	}
342	cur_item = g_new0(TpmModelList, 1);
343	cur_item->value = i;
344
345	if (prev) {
346	prev->next = cur_item;
347	}
348	if (!head) {
349	head = cur_item;
350	}
351	prev = cur_item;
352	}
353
354	return head;
355	}