summaryrefslogtreecommitdiffstats
path: root/meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch
diff options
context:
space:
mode:
Diffstat (limited to 'meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch')
-rw-r--r--meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch417
1 files changed, 0 insertions, 417 deletions
diff --git a/meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch b/meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch
deleted file mode 100644
index 64e88b6de9..0000000000
--- a/meta/recipes-devtools/qemu/qemu/0004-tpm-backend-Move-thread-handling-inside-TPMBackend.patch
+++ /dev/null
@@ -1,417 +0,0 @@
1From 5767322022d54ceb5a2ed6c650f667a4d24aa150 Mon Sep 17 00:00:00 2001
2From: Amarnath Valluri <amarnath.valluri@intel.com>
3Date: Thu, 30 Mar 2017 16:20:25 +0300
4Subject: [PATCH 04/12] tpm-backend: Move thread handling inside TPMBackend
5MIME-Version: 1.0
6Content-Type: text/plain; charset=UTF-8
7Content-Transfer-Encoding: 8bit
8
9Move thread handling inside TPMBackend, this way backend implementations need
10not to maintain their own thread life cycle, instead they needs to implement
11'handle_request()' class method that always been called from a thread.
12
13This change made tpm_backend_int.h kind of useless, hence removed it.
14
15Signed-off-by: Amarnath Valluri <amarnath.valluri@intel.com>
16Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
17Reviewed-by: Stefan Berger <stefanb@linux.vnet.ibm.com>
18
19Upstream-Status: Backport [b19a5eea5a26e9bd83a48c742172d2a6aa8c4180]
20---
21 backends/tpm.c | 62 +++++++++++++++++++++++++---------------
22 hw/tpm/tpm_passthrough.c | 58 ++++++-------------------------------
23 include/sysemu/tpm_backend.h | 32 +++++++++++++--------
24 include/sysemu/tpm_backend_int.h | 41 --------------------------
25 4 files changed, 67 insertions(+), 126 deletions(-)
26 delete mode 100644 include/sysemu/tpm_backend_int.h
27
28diff --git a/backends/tpm.c b/backends/tpm.c
29index 536f262bb7..ce56c3b74d 100644
30--- a/backends/tpm.c
31+++ b/backends/tpm.c
32@@ -18,7 +18,24 @@
33 #include "qapi/qmp/qerror.h"
34 #include "sysemu/tpm.h"
35 #include "qemu/thread.h"
36-#include "sysemu/tpm_backend_int.h"
37+
38+static void tpm_backend_worker_thread(gpointer data, gpointer user_data)
39+{
40+ TPMBackend *s = TPM_BACKEND(user_data);
41+ TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
42+
43+ assert(k->handle_request != NULL);
44+ k->handle_request(s, (TPMBackendCmd)data);
45+}
46+
47+static void tpm_backend_thread_end(TPMBackend *s)
48+{
49+ if (s->thread_pool) {
50+ g_thread_pool_push(s->thread_pool, (gpointer)TPM_BACKEND_CMD_END, NULL);
51+ g_thread_pool_free(s->thread_pool, FALSE, TRUE);
52+ s->thread_pool = NULL;
53+ }
54+}
55
56 enum TpmType tpm_backend_get_type(TPMBackend *s)
57 {
58@@ -39,6 +56,8 @@ void tpm_backend_destroy(TPMBackend *s)
59 TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
60
61 k->ops->destroy(s);
62+
63+ tpm_backend_thread_end(s);
64 }
65
66 int tpm_backend_init(TPMBackend *s, TPMState *state,
67@@ -46,13 +65,23 @@ int tpm_backend_init(TPMBackend *s, TPMState *state,
68 {
69 TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
70
71- return k->ops->init(s, state, datacb);
72+ s->tpm_state = state;
73+ s->recv_data_callback = datacb;
74+
75+ return k->ops->init(s);
76 }
77
78 int tpm_backend_startup_tpm(TPMBackend *s)
79 {
80 TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
81
82+ /* terminate a running TPM */
83+ tpm_backend_thread_end(s);
84+
85+ s->thread_pool = g_thread_pool_new(tpm_backend_worker_thread, s, 1, TRUE,
86+ NULL);
87+ g_thread_pool_push(s->thread_pool, (gpointer)TPM_BACKEND_CMD_INIT, NULL);
88+
89 return k->ops->startup_tpm(s);
90 }
91
92@@ -72,9 +101,8 @@ size_t tpm_backend_realloc_buffer(TPMBackend *s, TPMSizedBuffer *sb)
93
94 void tpm_backend_deliver_request(TPMBackend *s)
95 {
96- TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
97-
98- k->ops->deliver_request(s);
99+ g_thread_pool_push(s->thread_pool, (gpointer)TPM_BACKEND_CMD_PROCESS_CMD,
100+ NULL);
101 }
102
103 void tpm_backend_reset(TPMBackend *s)
104@@ -82,6 +110,8 @@ void tpm_backend_reset(TPMBackend *s)
105 TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s);
106
107 k->ops->reset(s);
108+
109+ tpm_backend_thread_end(s);
110 }
111
112 void tpm_backend_cancel_cmd(TPMBackend *s)
113@@ -156,29 +186,14 @@ static void tpm_backend_instance_init(Object *obj)
114 tpm_backend_prop_get_opened,
115 tpm_backend_prop_set_opened,
116 NULL);
117-}
118
119-void tpm_backend_thread_deliver_request(TPMBackendThread *tbt)
120-{
121- g_thread_pool_push(tbt->pool, (gpointer)TPM_BACKEND_CMD_PROCESS_CMD, NULL);
122 }
123
124-void tpm_backend_thread_create(TPMBackendThread *tbt,
125- GFunc func, gpointer user_data)
126+static void tpm_backend_instance_finalize(Object *obj)
127 {
128- if (!tbt->pool) {
129- tbt->pool = g_thread_pool_new(func, user_data, 1, TRUE, NULL);
130- g_thread_pool_push(tbt->pool, (gpointer)TPM_BACKEND_CMD_INIT, NULL);
131- }
132-}
133+ TPMBackend *s = TPM_BACKEND(obj);
134
135-void tpm_backend_thread_end(TPMBackendThread *tbt)
136-{
137- if (tbt->pool) {
138- g_thread_pool_push(tbt->pool, (gpointer)TPM_BACKEND_CMD_END, NULL);
139- g_thread_pool_free(tbt->pool, FALSE, TRUE);
140- tbt->pool = NULL;
141- }
142+ tpm_backend_thread_end(s);
143 }
144
145 static const TypeInfo tpm_backend_info = {
146@@ -186,6 +201,7 @@ static const TypeInfo tpm_backend_info = {
147 .parent = TYPE_OBJECT,
148 .instance_size = sizeof(TPMBackend),
149 .instance_init = tpm_backend_instance_init,
150+ .instance_finalize = tpm_backend_instance_finalize,
151 .class_size = sizeof(TPMBackendClass),
152 .abstract = true,
153 };
154diff --git a/hw/tpm/tpm_passthrough.c b/hw/tpm/tpm_passthrough.c
155index a0baf5f080..f50d9cffd7 100644
156--- a/hw/tpm/tpm_passthrough.c
157+++ b/hw/tpm/tpm_passthrough.c
158@@ -30,7 +30,6 @@
159 #include "tpm_int.h"
160 #include "hw/hw.h"
161 #include "hw/i386/pc.h"
162-#include "sysemu/tpm_backend_int.h"
163 #include "tpm_tis.h"
164 #include "tpm_util.h"
165
166@@ -47,20 +46,9 @@
167 OBJECT_CHECK(TPMPassthruState, (obj), TYPE_TPM_PASSTHROUGH)
168
169 /* data structures */
170-typedef struct TPMPassthruThreadParams {
171- TPMState *tpm_state;
172-
173- TPMRecvDataCB *recv_data_callback;
174- TPMBackend *tb;
175-} TPMPassthruThreadParams;
176-
177 struct TPMPassthruState {
178 TPMBackend parent;
179
180- TPMBackendThread tbt;
181-
182- TPMPassthruThreadParams tpm_thread_params;
183-
184 char *tpm_dev;
185 int tpm_fd;
186 bool tpm_executing;
187@@ -214,12 +202,9 @@ static int tpm_passthrough_unix_transfer(TPMPassthruState *tpm_pt,
188 selftest_done);
189 }
190
191-static void tpm_passthrough_worker_thread(gpointer data,
192- gpointer user_data)
193+static void tpm_passthrough_handle_request(TPMBackend *tb, TPMBackendCmd cmd)
194 {
195- TPMPassthruThreadParams *thr_parms = user_data;
196- TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(thr_parms->tb);
197- TPMBackendCmd cmd = (TPMBackendCmd)data;
198+ TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
199 bool selftest_done = false;
200
201 DPRINTF("tpm_passthrough: processing command type %d\n", cmd);
202@@ -227,12 +212,12 @@ static void tpm_passthrough_worker_thread(gpointer data,
203 switch (cmd) {
204 case TPM_BACKEND_CMD_PROCESS_CMD:
205 tpm_passthrough_unix_transfer(tpm_pt,
206- thr_parms->tpm_state->locty_data,
207+ tb->tpm_state->locty_data,
208 &selftest_done);
209
210- thr_parms->recv_data_callback(thr_parms->tpm_state,
211- thr_parms->tpm_state->locty_number,
212- selftest_done);
213+ tb->recv_data_callback(tb->tpm_state,
214+ tb->tpm_state->locty_number,
215+ selftest_done);
216 break;
217 case TPM_BACKEND_CMD_INIT:
218 case TPM_BACKEND_CMD_END:
219@@ -248,15 +233,6 @@ static void tpm_passthrough_worker_thread(gpointer data,
220 */
221 static int tpm_passthrough_startup_tpm(TPMBackend *tb)
222 {
223- TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
224-
225- /* terminate a running TPM */
226- tpm_backend_thread_end(&tpm_pt->tbt);
227-
228- tpm_backend_thread_create(&tpm_pt->tbt,
229- tpm_passthrough_worker_thread,
230- &tpm_pt->tpm_thread_params);
231-
232 return 0;
233 }
234
235@@ -268,20 +244,11 @@ static void tpm_passthrough_reset(TPMBackend *tb)
236
237 tpm_passthrough_cancel_cmd(tb);
238
239- tpm_backend_thread_end(&tpm_pt->tbt);
240-
241 tpm_pt->had_startup_error = false;
242 }
243
244-static int tpm_passthrough_init(TPMBackend *tb, TPMState *s,
245- TPMRecvDataCB *recv_data_cb)
246+static int tpm_passthrough_init(TPMBackend *tb)
247 {
248- TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
249-
250- tpm_pt->tpm_thread_params.tpm_state = s;
251- tpm_pt->tpm_thread_params.recv_data_callback = recv_data_cb;
252- tpm_pt->tpm_thread_params.tb = tb;
253-
254 return 0;
255 }
256
257@@ -315,13 +282,6 @@ static size_t tpm_passthrough_realloc_buffer(TPMSizedBuffer *sb)
258 return sb->size;
259 }
260
261-static void tpm_passthrough_deliver_request(TPMBackend *tb)
262-{
263- TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
264-
265- tpm_backend_thread_deliver_request(&tpm_pt->tbt);
266-}
267-
268 static void tpm_passthrough_cancel_cmd(TPMBackend *tb)
269 {
270 TPMPassthruState *tpm_pt = TPM_PASSTHROUGH(tb);
271@@ -483,8 +443,6 @@ static void tpm_passthrough_destroy(TPMBackend *tb)
272
273 tpm_passthrough_cancel_cmd(tb);
274
275- tpm_backend_thread_end(&tpm_pt->tbt);
276-
277 qemu_close(tpm_pt->tpm_fd);
278 qemu_close(tpm_pt->cancel_fd);
279
280@@ -520,7 +478,6 @@ static const TPMDriverOps tpm_passthrough_driver = {
281 .realloc_buffer = tpm_passthrough_realloc_buffer,
282 .reset = tpm_passthrough_reset,
283 .had_startup_error = tpm_passthrough_get_startup_error,
284- .deliver_request = tpm_passthrough_deliver_request,
285 .cancel_cmd = tpm_passthrough_cancel_cmd,
286 .get_tpm_established_flag = tpm_passthrough_get_tpm_established_flag,
287 .reset_tpm_established_flag = tpm_passthrough_reset_tpm_established_flag,
288@@ -540,6 +497,7 @@ static void tpm_passthrough_class_init(ObjectClass *klass, void *data)
289 TPMBackendClass *tbc = TPM_BACKEND_CLASS(klass);
290
291 tbc->ops = &tpm_passthrough_driver;
292+ tbc->handle_request = tpm_passthrough_handle_request;
293 }
294
295 static const TypeInfo tpm_passthrough_info = {
296diff --git a/include/sysemu/tpm_backend.h b/include/sysemu/tpm_backend.h
297index 3708413035..58308b3687 100644
298--- a/include/sysemu/tpm_backend.h
299+++ b/include/sysemu/tpm_backend.h
300@@ -29,22 +29,24 @@
301
302 typedef struct TPMBackendClass TPMBackendClass;
303 typedef struct TPMBackend TPMBackend;
304-
305 typedef struct TPMDriverOps TPMDriverOps;
306+typedef void (TPMRecvDataCB)(TPMState *, uint8_t locty, bool selftest_done);
307
308-struct TPMBackendClass {
309- ObjectClass parent_class;
310-
311- const TPMDriverOps *ops;
312-
313- void (*opened)(TPMBackend *s, Error **errp);
314-};
315+typedef enum TPMBackendCmd {
316+ TPM_BACKEND_CMD_INIT = 1,
317+ TPM_BACKEND_CMD_PROCESS_CMD,
318+ TPM_BACKEND_CMD_END,
319+ TPM_BACKEND_CMD_TPM_RESET,
320+} TPMBackendCmd;
321
322 struct TPMBackend {
323 Object parent;
324
325 /*< protected >*/
326 bool opened;
327+ TPMState *tpm_state;
328+ GThreadPool *thread_pool;
329+ TPMRecvDataCB *recv_data_callback;
330
331 char *id;
332 enum TpmModel fe_model;
333@@ -54,7 +56,15 @@ struct TPMBackend {
334 QLIST_ENTRY(TPMBackend) list;
335 };
336
337-typedef void (TPMRecvDataCB)(TPMState *, uint8_t locty, bool selftest_done);
338+struct TPMBackendClass {
339+ ObjectClass parent_class;
340+
341+ const TPMDriverOps *ops;
342+
343+ void (*opened)(TPMBackend *s, Error **errp);
344+
345+ void (*handle_request)(TPMBackend *s, TPMBackendCmd cmd);
346+};
347
348 typedef struct TPMSizedBuffer {
349 uint32_t size;
350@@ -71,7 +81,7 @@ struct TPMDriverOps {
351 void (*destroy)(TPMBackend *t);
352
353 /* initialize the backend */
354- int (*init)(TPMBackend *t, TPMState *s, TPMRecvDataCB *datacb);
355+ int (*init)(TPMBackend *t);
356 /* start up the TPM on the backend */
357 int (*startup_tpm)(TPMBackend *t);
358 /* returns true if nothing will ever answer TPM requests */
359@@ -79,8 +89,6 @@ struct TPMDriverOps {
360
361 size_t (*realloc_buffer)(TPMSizedBuffer *sb);
362
363- void (*deliver_request)(TPMBackend *t);
364-
365 void (*reset)(TPMBackend *t);
366
367 void (*cancel_cmd)(TPMBackend *t);
368diff --git a/include/sysemu/tpm_backend_int.h b/include/sysemu/tpm_backend_int.h
369deleted file mode 100644
370index 00639dd7de..0000000000
371--- a/include/sysemu/tpm_backend_int.h
372+++ /dev/null
373@@ -1,41 +0,0 @@
374-/*
375- * common TPM backend driver functions
376- *
377- * Copyright (c) 2012-2013 IBM Corporation
378- * Authors:
379- * Stefan Berger <stefanb@us.ibm.com>
380- *
381- * This library is free software; you can redistribute it and/or
382- * modify it under the terms of the GNU Lesser General Public
383- * License as published by the Free Software Foundation; either
384- * version 2 of the License, or (at your option) any later version.
385- *
386- * This library is distributed in the hope that it will be useful,
387- * but WITHOUT ANY WARRANTY; without even the implied warranty of
388- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
389- * Lesser General Public License for more details.
390- *
391- * You should have received a copy of the GNU Lesser General Public
392- * License along with this library; if not, see <http://www.gnu.org/licenses/>
393- */
394-
395-#ifndef TPM_BACKEND_INT_H
396-#define TPM_BACKEND_INT_H
397-
398-typedef struct TPMBackendThread {
399- GThreadPool *pool;
400-} TPMBackendThread;
401-
402-void tpm_backend_thread_deliver_request(TPMBackendThread *tbt);
403-void tpm_backend_thread_create(TPMBackendThread *tbt,
404- GFunc func, gpointer user_data);
405-void tpm_backend_thread_end(TPMBackendThread *tbt);
406-
407-typedef enum TPMBackendCmd {
408- TPM_BACKEND_CMD_INIT = 1,
409- TPM_BACKEND_CMD_PROCESS_CMD,
410- TPM_BACKEND_CMD_END,
411- TPM_BACKEND_CMD_TPM_RESET,
412-} TPMBackendCmd;
413-
414-#endif /* TPM_BACKEND_INT_H */
415--
4162.11.0
417