Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
PCI/TSM: Add pci_tsm_guest_req() for managing TDIs
A PCIe device function interface assigned to a TVM is a TEE Device
Interface (TDI). A TDI instantiated by pci_tsm_bind() needs additional
steps taken by the TVM to be accepted into the TVM's Trusted Compute
Boundary (TCB) and transitioned to the RUN state.
pci_tsm_guest_req() is a channel for the guest to request TDISP collateral,
like Device Interface Reports, and effect TDISP state changes, like
LOCKED->RUN transititions. Similar to IDE establishment and pci_tsm_bind(),
these are long running operations involving SPDM message passing via the
DOE mailbox.
The path for a TVM to invoke pci_tsm_guest_req() is:
* TSM triggers exit via guest-to-host-interface ABI (implementation specific)
* VMM invokes handler (KVM handle_exit() -> userspace io)
* handler issues request (userspace io handler -> ioctl() ->
pci_tsm_guest_req())
* handler supplies response
* VMM posts response, notifies/re-enters TVM
This path is purely a transport for messages from TVM to platform TSM. By
design the host kernel does not and must not care about the content of
these messages. I.e. the host kernel is not in the TCB of the TVM.
As this is an opaque passthrough interface, similar to fwctl, the kernel
requires that implementations stay within the bounds defined by 'enum
pci_tsm_req_scope'. Violation of those expectations likely has market and
regulatory consequences. Out of scope requests are blocked by default.
Co-developed-by: Xu Yilun <yilun.xu@linux.intel.com>
Signed-off-by: Xu Yilun <yilun.xu@linux.intel.com>
Reviewed-by: Jonathan Cameron <jonathan.cameron@huawei.com>
Link: https://patch.msgid.link/20251113021446.436830-8-dan.j.williams@intel.com
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
+120
-2
+60
drivers/pci/tsm.c
+60
drivers/pci/tsm.c
···
353
353
}
354
354
EXPORT_SYMBOL_GPL(pci_tsm_bind);
355
355
356
+
/**
357
+
* pci_tsm_guest_req() - helper to marshal guest requests to the TSM driver
358
+
* @pdev: @pdev representing a bound tdi
359
+
* @scope: caller asserts this passthrough request is limited to TDISP operations
360
+
* @req_in: Input payload forwarded from the guest
361
+
* @in_len: Length of @req_in
362
+
* @req_out: Output payload buffer response to the guest
363
+
* @out_len: Length of @req_out on input, bytes filled in @req_out on output
364
+
* @tsm_code: Optional TSM arch specific result code for the guest TSM
365
+
*
366
+
* This is a common entry point for requests triggered by userspace KVM-exit
367
+
* service handlers responding to TDI information or state change requests. The
368
+
* scope parameter limits requests to TDISP state management, or limited debug.
369
+
* This path is only suitable for commands and results that are the host kernel
370
+
* has no use, the host is only facilitating guest to TSM communication.
371
+
*
372
+
* Returns 0 on success and -error on failure and positive "residue" on success
373
+
* but @req_out is filled with less then @out_len, or @req_out is NULL and a
374
+
* residue number of bytes were not consumed from @req_in. On success or
375
+
* failure @tsm_code may be populated with a TSM implementation specific result
376
+
* code for the guest to consume.
377
+
*
378
+
* Context: Caller is responsible for calling this within the pci_tsm_bind()
379
+
* state of the TDI.
380
+
*/
381
+
ssize_t pci_tsm_guest_req(struct pci_dev *pdev, enum pci_tsm_req_scope scope,
382
+
sockptr_t req_in, size_t in_len, sockptr_t req_out,
383
+
size_t out_len, u64 *tsm_code)
384
+
{
385
+
struct pci_tsm_pf0 *tsm_pf0;
386
+
struct pci_tdi *tdi;
387
+
int rc;
388
+
389
+
/* Forbid requests that are not directly related to TDISP operations */
390
+
if (scope > PCI_TSM_REQ_STATE_CHANGE)
391
+
return -EINVAL;
392
+
393
+
ACQUIRE(rwsem_read_intr, lock)(&pci_tsm_rwsem);
394
+
if ((rc = ACQUIRE_ERR(rwsem_read_intr, &lock)))
395
+
return rc;
396
+
397
+
if (!pdev->tsm)
398
+
return -ENXIO;
399
+
400
+
if (!is_link_tsm(pdev->tsm->tsm_dev))
401
+
return -ENXIO;
402
+
403
+
tsm_pf0 = to_pci_tsm_pf0(pdev->tsm);
404
+
ACQUIRE(mutex_intr, ops_lock)(&tsm_pf0->lock);
405
+
if ((rc = ACQUIRE_ERR(mutex_intr, &ops_lock)))
406
+
return rc;
407
+
408
+
tdi = pdev->tsm->tdi;
409
+
if (!tdi)
410
+
return -ENXIO;
411
+
return to_pci_tsm_ops(pdev->tsm)->guest_req(tdi, scope, req_in, in_len,
412
+
req_out, out_len, tsm_code);
413
+
}
414
+
EXPORT_SYMBOL_GPL(pci_tsm_guest_req);
415
+
356
416
static void pci_tsm_unbind_all(struct pci_dev *pdev)
357
417
{
358
418
pci_tsm_walk_fns_reverse(pdev, __pci_tsm_unbind, NULL);
+60
-2
include/linux/pci-tsm.h
+60
-2
include/linux/pci-tsm.h
···
3
3
#define __PCI_TSM_H
4
4
#include <linux/mutex.h>
5
5
#include <linux/pci.h>
6
+
#include <linux/sockptr.h>
6
7
7
8
struct pci_tsm;
8
9
struct tsm_dev;
···
34
33
* @disconnect: teardown the secure link
35
34
* @bind: bind a TDI in preparation for it to be accepted by a TVM
36
35
* @unbind: remove a TDI from secure operation with a TVM
36
+
* @guest_req: marshal TVM information and state change requests
37
37
*
38
38
* Context: @probe, @remove, @connect, and @disconnect run under
39
39
* pci_tsm_rwsem held for write to sync with TSM unregistration and
40
40
* mutual exclusion of @connect and @disconnect. @connect and
41
41
* @disconnect additionally run under the DSM lock (struct
42
42
* pci_tsm_pf0::lock) as well as @probe and @remove of the subfunctions.
43
-
* @bind and @unbind run under pci_tsm_rwsem held for read and the DSM
44
-
* lock.
43
+
* @bind, @unbind, and @guest_req run under pci_tsm_rwsem held for read
44
+
* and the DSM lock.
45
45
*/
46
46
struct_group_tagged(pci_tsm_link_ops, link_ops,
47
47
struct pci_tsm *(*probe)(struct tsm_dev *tsm_dev,
···
53
51
struct pci_tdi *(*bind)(struct pci_dev *pdev,
54
52
struct kvm *kvm, u32 tdi_id);
55
53
void (*unbind)(struct pci_tdi *tdi);
54
+
ssize_t (*guest_req)(struct pci_tdi *tdi,
55
+
enum pci_tsm_req_scope scope,
56
+
sockptr_t req_in, size_t in_len,
57
+
sockptr_t req_out, size_t out_len,
58
+
u64 *tsm_code);
56
59
);
57
60
58
61
/*
···
159
152
return PCI_FUNC(pdev->devfn) == 0;
160
153
}
161
154
155
+
/**
156
+
* enum pci_tsm_req_scope - Scope of guest requests to be validated by TSM
157
+
*
158
+
* Guest requests are a transport for a TVM to communicate with a TSM + DSM for
159
+
* a given TDI. A TSM driver is responsible for maintaining the kernel security
160
+
* model and limit commands that may affect the host, or are otherwise outside
161
+
* the typical TDISP operational model.
162
+
*/
163
+
enum pci_tsm_req_scope {
164
+
/**
165
+
* @PCI_TSM_REQ_INFO: Read-only, without side effects, request for
166
+
* typical TDISP collateral information like Device Interface Reports.
167
+
* No device secrets are permitted, and no device state is changed.
168
+
*/
169
+
PCI_TSM_REQ_INFO = 0,
170
+
/**
171
+
* @PCI_TSM_REQ_STATE_CHANGE: Request to change the TDISP state from
172
+
* UNLOCKED->LOCKED, LOCKED->RUN, or other architecture specific state
173
+
* changes to support those transitions for a TDI. No other (unrelated
174
+
* to TDISP) device / host state, configuration, or data change is
175
+
* permitted.
176
+
*/
177
+
PCI_TSM_REQ_STATE_CHANGE = 1,
178
+
/**
179
+
* @PCI_TSM_REQ_DEBUG_READ: Read-only request for debug information
180
+
*
181
+
* A method to facilitate TVM information retrieval outside of typical
182
+
* TDISP operational requirements. No device secrets are permitted.
183
+
*/
184
+
PCI_TSM_REQ_DEBUG_READ = 2,
185
+
/**
186
+
* @PCI_TSM_REQ_DEBUG_WRITE: Device state changes for debug purposes
187
+
*
188
+
* The request may affect the operational state of the device outside of
189
+
* the TDISP operational model. If allowed, requires CAP_SYS_RAW_IO, and
190
+
* will taint the kernel.
191
+
*/
192
+
PCI_TSM_REQ_DEBUG_WRITE = 3,
193
+
};
194
+
162
195
#ifdef CONFIG_PCI_TSM
163
196
int pci_tsm_register(struct tsm_dev *tsm_dev);
164
197
void pci_tsm_unregister(struct tsm_dev *tsm_dev);
···
213
166
void pci_tsm_unbind(struct pci_dev *pdev);
214
167
void pci_tsm_tdi_constructor(struct pci_dev *pdev, struct pci_tdi *tdi,
215
168
struct kvm *kvm, u32 tdi_id);
169
+
ssize_t pci_tsm_guest_req(struct pci_dev *pdev, enum pci_tsm_req_scope scope,
170
+
sockptr_t req_in, size_t in_len, sockptr_t req_out,
171
+
size_t out_len, u64 *tsm_code);
216
172
#else
217
173
static inline int pci_tsm_register(struct tsm_dev *tsm_dev)
218
174
{
···
230
180
}
231
181
static inline void pci_tsm_unbind(struct pci_dev *pdev)
232
182
{
183
+
}
184
+
static inline ssize_t pci_tsm_guest_req(struct pci_dev *pdev,
185
+
enum pci_tsm_req_scope scope,
186
+
sockptr_t req_in, size_t in_len,
187
+
sockptr_t req_out, size_t out_len,
188
+
u64 *tsm_code)
189
+
{
190
+
return -ENXIO;
233
191
}
234
192
#endif
235
193
#endif /*__PCI_TSM_H */