/src/qemu/tests/qtest/libqos/qos-intel-iommu.c
Line | Count | Source |
1 | | /* |
2 | | * QOS Intel IOMMU (VT-d) Module Implementation |
3 | | * |
4 | | * This module provides Intel IOMMU-specific helper functions for libqos tests. |
5 | | * |
6 | | * Copyright (c) 2026 Fengyuan Yu <15fengyuan@gmail.com> |
7 | | * |
8 | | * SPDX-License-Identifier: GPL-2.0-or-later |
9 | | */ |
10 | | |
11 | | #include "qemu/osdep.h" |
12 | | #include "hw/i386/intel_iommu_internal.h" |
13 | | #include "tests/qtest/libqos/pci.h" |
14 | | #include "tests/qtest/libqos/pci-pc.h" |
15 | | #include "qos-iommu-testdev.h" |
16 | | #include "qos-intel-iommu.h" |
17 | | |
18 | | /* Bounded poll for the invalidation-wait Status Write. */ |
19 | 0 | #define QVTD_INV_WAIT_POLL_MAX_ITERS 1000 |
20 | 0 | #define QVTD_INV_WAIT_POLL_INTERVAL_US 1000 |
21 | | |
22 | 0 | #define QVTD_AW_48BIT_ENCODING 2 |
23 | | |
24 | | uint32_t qvtd_expected_dma_result(QVTDTestContext *ctx) |
25 | 0 | { |
26 | 0 | return ctx->config.expected_result; |
27 | 0 | } |
28 | | |
29 | | uint32_t qvtd_build_dma_attrs(void) |
30 | 0 | { |
31 | | /* |
32 | | * VT-d obtains the Requester ID (Source ID) from PCI bus/devfn routing |
33 | | * via pci_device_iommu_address_space(), not from DMA attributes. |
34 | | * |
35 | | * For scalable mode, iommu-testdev does not set MemTxAttrs.pid, |
36 | | * so the device's VTDAddressSpace has pasid=PCI_NO_PASID. |
37 | | * vtd_do_iommu_translate() remaps PCI_NO_PASID to PASID_0 |
38 | | * when root_scalable is set, which matches the PASID=0 entry |
39 | | * we configure in qvtd_build_pasid_table_entry(). |
40 | | */ |
41 | 0 | return 0; |
42 | 0 | } |
43 | | |
44 | | static void qvtd_build_root_entry(QTestState *qts, uint8_t bus, |
45 | | uint64_t context_table_ptr, |
46 | | QVTDTransMode mode) |
47 | 0 | { |
48 | 0 | uint64_t root_entry_addr = QVTD_ROOT_TABLE_BASE + |
49 | 0 | (bus * sizeof(VTDRootEntry)); |
50 | 0 | uint64_t lo, hi; |
51 | |
|
52 | 0 | if (qvtd_is_scalable(mode)) { |
53 | | /* |
54 | | * Scalable-mode Root Entry (Section 9.2): |
55 | | * lo = Lower Context Table Pointer + LP (Lower Present) |
56 | | * hi = Upper Context Table Pointer + UP (Upper Present) |
57 | | * |
58 | | * Lower table covers devfn 0-127, Upper covers devfn 128-255. |
59 | | * Only lower half is needed for test device (devfn < 128). |
60 | | */ |
61 | 0 | lo = (context_table_ptr & VTD_ROOT_ENTRY_CTP) | VTD_ROOT_ENTRY_P; |
62 | 0 | hi = 0; /* UP=0: upper context table not present */ |
63 | 0 | } else { |
64 | | /* |
65 | | * Legacy Root Entry (Section 9.1): |
66 | | * lo = Context Table Pointer + Present |
67 | | * hi = Reserved |
68 | | */ |
69 | 0 | lo = (context_table_ptr & VTD_ROOT_ENTRY_CTP) | VTD_ROOT_ENTRY_P; |
70 | 0 | hi = 0; |
71 | 0 | } |
72 | |
|
73 | 0 | qtest_writeq(qts, root_entry_addr, lo); |
74 | 0 | qtest_writeq(qts, root_entry_addr + 8, hi); |
75 | 0 | } |
76 | | |
77 | | static void qvtd_build_context_entry(QTestState *qts, uint16_t sid, |
78 | | QVTDTransMode mode, uint64_t ssptptr) |
79 | 0 | { |
80 | 0 | uint8_t devfn = sid & 0xff; |
81 | 0 | uint64_t context_entry_addr = QVTD_CONTEXT_TABLE_BASE + |
82 | 0 | (devfn * VTD_CTX_ENTRY_LEGACY_SIZE); |
83 | 0 | uint64_t lo, hi; |
84 | |
|
85 | 0 | if (mode == QVTD_TM_LEGACY_PT) { |
86 | | /* |
87 | | * Pass-through mode (Section 9.3): |
88 | | * lo: P + FPD(=0, fault enabled) + TT(=Pass-through) |
89 | | * hi: DID + AW |
90 | | */ |
91 | 0 | lo = VTD_CONTEXT_ENTRY_P | VTD_CONTEXT_TT_PASS_THROUGH; |
92 | 0 | hi = ((uint64_t)QVTD_DOMAIN_ID << 8) | QVTD_AW_48BIT_ENCODING; |
93 | 0 | } else { |
94 | | /* |
95 | | * Translated mode (Section 9.3): |
96 | | * lo: P + FPD(=0, fault enabled) + TT(=Multi-level) + SSPTPTR |
97 | | * hi: DID + AW(=48-bit, 4-level) |
98 | | */ |
99 | 0 | lo = VTD_CONTEXT_ENTRY_P | VTD_CONTEXT_TT_MULTI_LEVEL | |
100 | 0 | (ssptptr & VTD_CONTEXT_ENTRY_SSPTPTR); |
101 | 0 | hi = ((uint64_t)QVTD_DOMAIN_ID << 8) | QVTD_AW_48BIT_ENCODING; |
102 | 0 | } |
103 | |
|
104 | 0 | qtest_writeq(qts, context_entry_addr, lo); |
105 | 0 | qtest_writeq(qts, context_entry_addr + 8, hi); |
106 | 0 | } |
107 | | |
108 | | static void qvtd_build_scalable_context_entry(QTestState *qts, uint16_t sid) |
109 | 0 | { |
110 | 0 | uint8_t devfn = sid & 0xff; |
111 | 0 | uint64_t ce_addr = QVTD_CONTEXT_TABLE_BASE + |
112 | 0 | (devfn * VTD_CTX_ENTRY_SCALABLE_SIZE); |
113 | | |
114 | | /* |
115 | | * Scalable-Mode Context Entry (Section 9.4), 32 bytes = 4 qwords: |
116 | | * |
117 | | * val[0]: P + FPD(=0) + DTE(=0) + PASIDE(=0) + PRE(=0) + HPTE(=0) |
118 | | * + EPTR(=0) + PDTS(=0) + PASIDDIRPTR |
119 | | * val[1]: RID_PASID(=0) + PDTTE(=0) + PRE(=0) + RID_CG(=0) |
120 | | * val[2]: Reserved (must be 0) |
121 | | * val[3]: Reserved (must be 0) |
122 | | */ |
123 | 0 | qtest_writeq(qts, ce_addr, |
124 | 0 | (QVTD_PASID_DIR_BASE & VTD_PASID_DIR_BASE_ADDR_MASK) | |
125 | 0 | VTD_CONTEXT_ENTRY_P); |
126 | 0 | qtest_writeq(qts, ce_addr + 8, 0); |
127 | 0 | qtest_writeq(qts, ce_addr + 16, 0); |
128 | 0 | qtest_writeq(qts, ce_addr + 24, 0); |
129 | 0 | } |
130 | | |
131 | | static void qvtd_build_pasid_dir_entry(QTestState *qts) |
132 | 0 | { |
133 | 0 | uint64_t addr = QVTD_PASID_DIR_BASE + |
134 | 0 | VTD_PASID_DIR_INDEX(0) * VTD_PASID_DIR_ENTRY_SIZE; |
135 | | |
136 | | /* |
137 | | * PASID Directory Entry (Section 9.5): |
138 | | * P + FPD(=0, fault enabled) + SMPTBLPTR |
139 | | */ |
140 | 0 | qtest_writeq(qts, addr, |
141 | 0 | (QVTD_PASID_TABLE_BASE & VTD_PASID_TABLE_BASE_ADDR_MASK) | |
142 | 0 | VTD_PASID_ENTRY_P); |
143 | 0 | } |
144 | | |
145 | | static void qvtd_build_pasid_table_entry(QTestState *qts, QVTDTransMode mode, |
146 | | uint64_t ptptr) |
147 | 0 | { |
148 | 0 | uint64_t addr = QVTD_PASID_TABLE_BASE + |
149 | 0 | VTD_PASID_TABLE_INDEX(0) * VTD_PASID_ENTRY_SIZE; |
150 | 0 | uint64_t val0, val1, val2; |
151 | | |
152 | | /* |
153 | | * Scalable-Mode PASID Table Entry (Section 9.6), 64 bytes = 8 qwords: |
154 | | * |
155 | | * val[0]: P + FPD(=0) + AW + PGTT + SSADE(=0) + SSPTPTR |
156 | | * val[1]: DID + PWSNP(=0) + PGSNP(=0) |
157 | | * + CD(=0) + EMTE(=0) + PAT(=0): Memory Type, |
158 | | * all Reserved(0) since QEMU ECAP.MTS=0 |
159 | | * val[2]: SRE(=0) + FSPM(=0, 4-level) + WPE(=0) + IGN + EAFE(=0) + FSPTPTR |
160 | | * val[3]: Reserved (must be 0) |
161 | | * val[4]: HPT fields, Reserved(0) since QEMU ECAP.HPTS=0 |
162 | | * val[5]: HPT fields, Reserved(0) since QEMU ECAP.HPTS=0 |
163 | | * val[6]: Reserved (must be 0) |
164 | | * val[7]: Reserved (must be 0) |
165 | | */ |
166 | 0 | switch (mode) { |
167 | 0 | case QVTD_TM_SCALABLE_PT: |
168 | 0 | val0 = VTD_PASID_ENTRY_P | |
169 | 0 | ((uint64_t)VTD_SM_PASID_ENTRY_PT << 6); |
170 | 0 | val1 = (uint64_t)QVTD_DOMAIN_ID; |
171 | 0 | val2 = 0; |
172 | 0 | break; |
173 | 0 | case QVTD_TM_SCALABLE_SLT: |
174 | 0 | val0 = VTD_PASID_ENTRY_P | |
175 | 0 | ((uint64_t)VTD_SM_PASID_ENTRY_SST << 6) | |
176 | 0 | ((uint64_t)QVTD_AW_48BIT_ENCODING << 2) | |
177 | 0 | (ptptr & VTD_SM_PASID_ENTRY_SSPTPTR); |
178 | 0 | val1 = (uint64_t)QVTD_DOMAIN_ID; |
179 | 0 | val2 = 0; |
180 | 0 | break; |
181 | 0 | case QVTD_TM_SCALABLE_FLT: |
182 | | /* |
183 | | * val[2] fields for FLT (Section 9.6): |
184 | | * SRE(=0, user-level DMA only) + FSPM(=0, 4-level) + |
185 | | * WPE(=0, no supervisor write-protect) + IGN + EAFE(=0) + FSPTPTR |
186 | | */ |
187 | 0 | val0 = VTD_PASID_ENTRY_P | |
188 | 0 | ((uint64_t)VTD_SM_PASID_ENTRY_FST << 6); |
189 | 0 | val1 = (uint64_t)QVTD_DOMAIN_ID; |
190 | 0 | val2 = ptptr & QVTD_SM_PASID_ENTRY_FSPTPTR; |
191 | 0 | break; |
192 | 0 | default: |
193 | 0 | g_assert_not_reached(); |
194 | 0 | } |
195 | | |
196 | 0 | qtest_writeq(qts, addr, val0); |
197 | 0 | qtest_writeq(qts, addr + 8, val1); |
198 | 0 | qtest_writeq(qts, addr + 16, val2); |
199 | 0 | qtest_writeq(qts, addr + 24, 0); |
200 | 0 | qtest_writeq(qts, addr + 32, 0); |
201 | 0 | qtest_writeq(qts, addr + 40, 0); |
202 | 0 | qtest_writeq(qts, addr + 48, 0); |
203 | 0 | qtest_writeq(qts, addr + 56, 0); |
204 | 0 | } |
205 | | |
206 | | /* |
207 | | * VT-d second-level paging helpers. |
208 | | * 4-level, 48-bit address space, 9 bits per level index. |
209 | | */ |
210 | | static uint32_t qvtd_get_table_index(uint64_t iova, int level) |
211 | 0 | { |
212 | 0 | int shift = VTD_PAGE_SHIFT + VTD_LEVEL_BITS * (level - 1); |
213 | |
|
214 | 0 | return (iova >> shift) & ((1u << VTD_LEVEL_BITS) - 1); |
215 | 0 | } |
216 | | |
217 | | static uint64_t qvtd_get_table_addr(uint64_t base, int level, uint64_t iova) |
218 | 0 | { |
219 | 0 | return base + (qvtd_get_table_index(iova, level) * QVTD_PTE_SIZE); |
220 | 0 | } |
221 | | |
222 | | static uint64_t qvtd_get_pte_attrs(void) |
223 | 0 | { |
224 | | /* Second-level: R/W in every paging entry (Section 3.7.1) */ |
225 | 0 | return VTD_SS_R | VTD_SS_W; |
226 | 0 | } |
227 | | |
228 | | static uint64_t qvtd_get_fl_pte_attrs(bool is_leaf) |
229 | 0 | { |
230 | | /* First-level: x86 page table format (VT-d spec Section 9.9) */ |
231 | 0 | uint64_t attrs = VTD_FS_P | VTD_FS_RW | VTD_FS_US | VTD_FS_A; |
232 | |
|
233 | 0 | if (is_leaf) { |
234 | 0 | attrs |= VTD_FS_D; |
235 | 0 | } |
236 | 0 | return attrs; |
237 | 0 | } |
238 | | |
239 | | uint64_t qvtd_leaf_pte_addr(uint64_t iova) |
240 | 0 | { |
241 | 0 | return qvtd_get_table_addr(QVTD_PT_L1_BASE, 1, iova); |
242 | 0 | } |
243 | | |
244 | | uint64_t qvtd_make_leaf_pte(uint64_t pa, QVTDTransMode mode) |
245 | 0 | { |
246 | 0 | uint64_t attrs; |
247 | | |
248 | | /* |
249 | | * Reuse the same leaf attributes qvtd_setup_translation_tables() writes, |
250 | | * so a rewritten PTE stays consistent with the initial mapping. US=1 in |
251 | | * the first-level format is required because the PASID entry runs with |
252 | | * SRE=0, which makes every DMA appear as a user-mode access |
253 | | * (VT-d 3.6.2 / 9.9). |
254 | | */ |
255 | 0 | if (mode == QVTD_TM_SCALABLE_FLT) { |
256 | 0 | attrs = qvtd_get_fl_pte_attrs(true); |
257 | 0 | } else { |
258 | 0 | attrs = qvtd_get_pte_attrs(); |
259 | 0 | } |
260 | 0 | return (pa & VTD_PAGE_MASK_4K) | attrs; |
261 | 0 | } |
262 | | |
263 | | void qvtd_setup_translation_tables(QTestState *qts, uint64_t iova, |
264 | | QVTDTransMode mode) |
265 | 0 | { |
266 | 0 | bool is_fl = (mode == QVTD_TM_SCALABLE_FLT); |
267 | 0 | uint64_t non_leaf_attrs, leaf_attrs; |
268 | |
|
269 | 0 | if (is_fl) { |
270 | 0 | non_leaf_attrs = qvtd_get_fl_pte_attrs(false); |
271 | 0 | leaf_attrs = qvtd_get_fl_pte_attrs(true); |
272 | 0 | } else { |
273 | | /* Second-level: all levels use identical R/W attrs (spec 3.7.1) */ |
274 | 0 | non_leaf_attrs = qvtd_get_pte_attrs(); |
275 | 0 | leaf_attrs = non_leaf_attrs; |
276 | 0 | } |
277 | |
|
278 | 0 | g_test_message("Page table setup: IOVA=0x%" PRIx64 |
279 | 0 | " PA=0x%" PRIx64 " %s", |
280 | 0 | (uint64_t)iova, (uint64_t)QVTD_PT_VAL, |
281 | 0 | is_fl ? "first-level" : "second-level"); |
282 | | |
283 | | /* PML4 (L4) -> PDPT (L3) -> PD (L2) -> PT (L1) -> PA */ |
284 | 0 | qtest_writeq(qts, qvtd_get_table_addr(QVTD_PT_L4_BASE, 4, iova), |
285 | 0 | QVTD_PT_L3_BASE | non_leaf_attrs); |
286 | 0 | qtest_writeq(qts, qvtd_get_table_addr(QVTD_PT_L3_BASE, 3, iova), |
287 | 0 | QVTD_PT_L2_BASE | non_leaf_attrs); |
288 | 0 | qtest_writeq(qts, qvtd_get_table_addr(QVTD_PT_L2_BASE, 2, iova), |
289 | 0 | QVTD_PT_L1_BASE | non_leaf_attrs); |
290 | 0 | qtest_writeq(qts, qvtd_get_table_addr(QVTD_PT_L1_BASE, 1, iova), |
291 | 0 | (QVTD_PT_VAL & VTD_PAGE_MASK_4K) | leaf_attrs); |
292 | 0 | } |
293 | | |
294 | | void qvtd_program_regs(QTestState *qts, uint64_t iommu_base, |
295 | | QVTDTransMode mode) |
296 | 0 | { |
297 | 0 | uint32_t gcmd = 0; |
298 | 0 | uint64_t rtaddr = QVTD_ROOT_TABLE_BASE; |
299 | | |
300 | | /* Set SMT bit for scalable mode (VT-d spec Section 9.1) */ |
301 | 0 | if (qvtd_is_scalable(mode)) { |
302 | 0 | rtaddr |= VTD_RTADDR_SMT; |
303 | 0 | } |
304 | | |
305 | | /* Set Root Table Address */ |
306 | 0 | qtest_writeq(qts, iommu_base + DMAR_RTADDR_REG, rtaddr); |
307 | | |
308 | | /* Set Root Table Pointer and verify */ |
309 | 0 | gcmd |= VTD_GCMD_SRTP; |
310 | 0 | qtest_writel(qts, iommu_base + DMAR_GCMD_REG, gcmd); |
311 | 0 | g_assert(qtest_readl(qts, iommu_base + DMAR_GSTS_REG) & VTD_GSTS_RTPS); |
312 | | |
313 | | /* Setup Invalidation Queue */ |
314 | 0 | qtest_writeq(qts, iommu_base + DMAR_IQA_REG, |
315 | 0 | QVTD_IQ_BASE | QVTD_IQ_QS); |
316 | 0 | qtest_writeq(qts, iommu_base + DMAR_IQH_REG, 0); |
317 | 0 | qtest_writeq(qts, iommu_base + DMAR_IQT_REG, 0); |
318 | | |
319 | | /* Enable Queued Invalidation and verify */ |
320 | 0 | gcmd |= VTD_GCMD_QIE; |
321 | 0 | qtest_writel(qts, iommu_base + DMAR_GCMD_REG, gcmd); |
322 | 0 | g_assert(qtest_readl(qts, iommu_base + DMAR_GSTS_REG) & VTD_GSTS_QIES); |
323 | | |
324 | | /* Setup Fault Event MSI */ |
325 | 0 | qtest_writel(qts, iommu_base + DMAR_FECTL_REG, 0x0); |
326 | 0 | qtest_writel(qts, iommu_base + DMAR_FEDATA_REG, QVTD_FAULT_IRQ_DATA); |
327 | 0 | qtest_writel(qts, iommu_base + DMAR_FEADDR_REG, QVTD_FAULT_IRQ_ADDR); |
328 | | |
329 | | /* Enable translation and verify */ |
330 | 0 | gcmd |= VTD_GCMD_TE; |
331 | 0 | qtest_writel(qts, iommu_base + DMAR_GCMD_REG, gcmd); |
332 | 0 | g_assert(qtest_readl(qts, iommu_base + DMAR_GSTS_REG) & VTD_GSTS_TES); |
333 | 0 | } |
334 | | |
335 | | uint32_t qvtd_build_translation(QTestState *qts, QVTDTransMode mode, |
336 | | uint16_t sid) |
337 | 0 | { |
338 | 0 | uint8_t bus = (sid >> 8) & 0xff; |
339 | |
|
340 | 0 | g_test_message("Build translation: IOVA=0x%" PRIx64 " PA=0x%" PRIx64 |
341 | 0 | " mode=%d", |
342 | 0 | (uint64_t)QVTD_IOVA, (uint64_t)QVTD_PT_VAL, mode); |
343 | | |
344 | | /* Clear IOMMU structure regions to avoid stale entries */ |
345 | 0 | qtest_memset(qts, QVTD_ROOT_TABLE_BASE, 0, 0x1000); |
346 | 0 | qtest_memset(qts, QVTD_PT_L4_BASE, 0, 0x4000); |
347 | |
|
348 | 0 | if (qvtd_is_scalable(mode)) { |
349 | | /* Scalable: 32B context entries need 8KB */ |
350 | 0 | qtest_memset(qts, QVTD_CONTEXT_TABLE_BASE, 0, 0x2000); |
351 | 0 | qtest_memset(qts, QVTD_PASID_DIR_BASE, 0, 0x1000); |
352 | 0 | qtest_memset(qts, QVTD_PASID_TABLE_BASE, 0, 0x1000); |
353 | 0 | } else { |
354 | 0 | qtest_memset(qts, QVTD_CONTEXT_TABLE_BASE, 0, 0x1000); |
355 | 0 | } |
356 | |
|
357 | 0 | qvtd_build_root_entry(qts, bus, QVTD_CONTEXT_TABLE_BASE, mode); |
358 | |
|
359 | 0 | if (qvtd_is_scalable(mode)) { |
360 | | /* Scalable path: context -> PASID dir -> PASID entry -> page tables */ |
361 | 0 | qvtd_build_scalable_context_entry(qts, sid); |
362 | 0 | qvtd_build_pasid_dir_entry(qts); |
363 | |
|
364 | 0 | if (mode == QVTD_TM_SCALABLE_PT) { |
365 | 0 | qvtd_build_pasid_table_entry(qts, mode, 0); |
366 | 0 | } else { |
367 | 0 | qvtd_setup_translation_tables(qts, QVTD_IOVA, mode); |
368 | 0 | qvtd_build_pasid_table_entry(qts, mode, QVTD_PT_L4_BASE); |
369 | 0 | } |
370 | 0 | } else { |
371 | | /* Legacy path */ |
372 | 0 | if (mode == QVTD_TM_LEGACY_PT) { |
373 | 0 | qvtd_build_context_entry(qts, sid, mode, 0); |
374 | 0 | } else { |
375 | 0 | qvtd_setup_translation_tables(qts, QVTD_IOVA, mode); |
376 | 0 | qvtd_build_context_entry(qts, sid, mode, QVTD_PT_L4_BASE); |
377 | 0 | } |
378 | 0 | } |
379 | |
|
380 | 0 | return 0; |
381 | 0 | } |
382 | | |
383 | | uint32_t qvtd_setup_and_enable_translation(QVTDTestContext *ctx) |
384 | 0 | { |
385 | 0 | uint32_t build_result; |
386 | | |
387 | | /* Build translation structures first */ |
388 | 0 | build_result = qvtd_build_translation(ctx->qts, ctx->config.trans_mode, |
389 | 0 | ctx->sid); |
390 | 0 | if (build_result != 0) { |
391 | 0 | g_test_message("Build failed: mode=%u sid=%u status=0x%x", |
392 | 0 | ctx->config.trans_mode, ctx->sid, build_result); |
393 | 0 | ctx->trans_status = build_result; |
394 | 0 | return ctx->trans_status; |
395 | 0 | } |
396 | | |
397 | | /* Program IOMMU registers (sets root table pointer, enables translation) */ |
398 | 0 | qvtd_program_regs(ctx->qts, ctx->iommu_base, ctx->config.trans_mode); |
399 | |
|
400 | 0 | ctx->trans_status = 0; |
401 | 0 | return ctx->trans_status; |
402 | 0 | } |
403 | | |
404 | | static bool qvtd_validate_test_result(QVTDTestContext *ctx) |
405 | 0 | { |
406 | 0 | uint32_t expected = qvtd_expected_dma_result(ctx); |
407 | |
|
408 | 0 | g_test_message("-> Validating result: expected=0x%x actual=0x%x", |
409 | 0 | expected, ctx->dma_result); |
410 | 0 | return (ctx->dma_result == expected); |
411 | 0 | } |
412 | | |
413 | | static uint32_t qvtd_single_translation_setup(void *opaque) |
414 | 0 | { |
415 | 0 | return qvtd_setup_and_enable_translation(opaque); |
416 | 0 | } |
417 | | |
418 | | static uint32_t qvtd_single_translation_attrs(void *opaque) |
419 | 0 | { |
420 | 0 | return qvtd_build_dma_attrs(); |
421 | 0 | } |
422 | | |
423 | | static bool qvtd_single_translation_validate(void *opaque) |
424 | 0 | { |
425 | 0 | return qvtd_validate_test_result(opaque); |
426 | 0 | } |
427 | | |
428 | | static void qvtd_single_translation_report(void *opaque, uint32_t dma_result) |
429 | 0 | { |
430 | 0 | QVTDTestContext *ctx = opaque; |
431 | |
|
432 | 0 | if (dma_result != 0) { |
433 | 0 | g_test_message("DMA failed: mode=%u result=0x%x", |
434 | 0 | ctx->config.trans_mode, dma_result); |
435 | 0 | } else { |
436 | 0 | g_test_message("-> DMA succeeded: mode=%u", |
437 | 0 | ctx->config.trans_mode); |
438 | 0 | } |
439 | 0 | } |
440 | | |
441 | | void qvtd_run_translation_case(QTestState *qts, QPCIDevice *dev, |
442 | | QPCIBar bar, uint64_t iommu_base, |
443 | | const QVTDTestConfig *cfg) |
444 | 0 | { |
445 | 0 | QVTDTestContext ctx = { |
446 | 0 | .qts = qts, |
447 | 0 | .dev = dev, |
448 | 0 | .bar = bar, |
449 | 0 | .iommu_base = iommu_base, |
450 | 0 | .config = *cfg, |
451 | 0 | .sid = dev->devfn, |
452 | 0 | }; |
453 | |
|
454 | 0 | QOSIOMMUTestdevDmaCfg dma = { |
455 | 0 | .dev = dev, |
456 | 0 | .bar = bar, |
457 | 0 | .iova = QVTD_IOVA, |
458 | 0 | .gpa = cfg->dma_gpa, |
459 | 0 | .len = cfg->dma_len, |
460 | 0 | }; |
461 | |
|
462 | 0 | qtest_memset(qts, cfg->dma_gpa, 0x00, cfg->dma_len); |
463 | 0 | qos_iommu_testdev_single_translation(&dma, &ctx, |
464 | 0 | qvtd_single_translation_setup, |
465 | 0 | qvtd_single_translation_attrs, |
466 | 0 | qvtd_single_translation_validate, |
467 | 0 | qvtd_single_translation_report, |
468 | 0 | &ctx.dma_result); |
469 | |
|
470 | 0 | if (ctx.dma_result == 0 && ctx.config.expected_result == 0) { |
471 | 0 | g_autofree uint8_t *buf = NULL; |
472 | |
|
473 | 0 | buf = g_malloc(ctx.config.dma_len); |
474 | 0 | qtest_memread(ctx.qts, ctx.config.dma_gpa, buf, ctx.config.dma_len); |
475 | |
|
476 | 0 | for (int i = 0; i < ctx.config.dma_len; i++) { |
477 | 0 | uint8_t expected; |
478 | |
|
479 | 0 | expected = (ITD_DMA_WRITE_VAL >> ((i % 4) * 8)) & 0xff; |
480 | 0 | g_assert_cmpuint(buf[i], ==, expected); |
481 | 0 | } |
482 | 0 | } |
483 | 0 | } |
484 | | |
485 | | const char *qvtd_iommu_args(QVTDTransMode mode) |
486 | 0 | { |
487 | 0 | switch (mode) { |
488 | 0 | case QVTD_TM_SCALABLE_FLT: |
489 | 0 | return "-device intel-iommu,scalable-mode=on,fsts=on "; |
490 | 0 | case QVTD_TM_SCALABLE_PT: |
491 | 0 | case QVTD_TM_SCALABLE_SLT: |
492 | 0 | return "-device intel-iommu,scalable-mode=on "; |
493 | 0 | default: |
494 | 0 | return "-device intel-iommu "; |
495 | 0 | } |
496 | 0 | } |
497 | | |
498 | | bool qvtd_check_caps(QTestState *qts, QVTDTransMode mode) |
499 | 0 | { |
500 | 0 | uint64_t ecap = qtest_readq(qts, |
501 | 0 | Q35_HOST_BRIDGE_IOMMU_ADDR + DMAR_ECAP_REG); |
502 | | |
503 | | /* All scalable modes require SMTS */ |
504 | 0 | if (qvtd_is_scalable(mode) && !(ecap & VTD_ECAP_SMTS)) { |
505 | 0 | g_test_skip("ECAP.SMTS not supported"); |
506 | 0 | return false; |
507 | 0 | } |
508 | | |
509 | 0 | switch (mode) { |
510 | 0 | case QVTD_TM_SCALABLE_PT: |
511 | 0 | if (!(ecap & VTD_ECAP_PT)) { |
512 | 0 | g_test_skip("ECAP.PT not supported"); |
513 | 0 | return false; |
514 | 0 | } |
515 | 0 | break; |
516 | 0 | case QVTD_TM_SCALABLE_SLT: |
517 | 0 | if (!(ecap & VTD_ECAP_SSTS)) { |
518 | 0 | g_test_skip("ECAP.SSTS not supported"); |
519 | 0 | return false; |
520 | 0 | } |
521 | 0 | break; |
522 | 0 | case QVTD_TM_SCALABLE_FLT: |
523 | 0 | if (!(ecap & VTD_ECAP_FSTS)) { |
524 | 0 | g_test_skip("ECAP.FSTS not supported"); |
525 | 0 | return false; |
526 | 0 | } |
527 | 0 | break; |
528 | 0 | default: |
529 | 0 | break; |
530 | 0 | } |
531 | | |
532 | 0 | return true; |
533 | 0 | } |
534 | | |
535 | | static void qvtd_save_pci_dev(QPCIDevice *dev, int devfn, void *data) |
536 | 0 | { |
537 | 0 | QPCIDevice **pdev = (QPCIDevice **)data; |
538 | |
|
539 | 0 | *pdev = dev; |
540 | 0 | } |
541 | | |
542 | | QPCIDevice *qvtd_setup_qtest_pci_device(QTestState *qts, QPCIBus **pcibus, |
543 | | QPCIBar *bar) |
544 | 0 | { |
545 | 0 | QPCIDevice *dev = NULL; |
546 | |
|
547 | 0 | *pcibus = qpci_new_pc(qts, NULL); |
548 | 0 | g_assert(*pcibus != NULL); |
549 | | |
550 | 0 | qpci_device_foreach(*pcibus, IOMMU_TESTDEV_VENDOR_ID, |
551 | 0 | IOMMU_TESTDEV_DEVICE_ID, qvtd_save_pci_dev, &dev); |
552 | |
|
553 | 0 | g_assert(dev); |
554 | 0 | qpci_device_enable(dev); |
555 | 0 | *bar = qpci_iomap(dev, 0, NULL); |
556 | 0 | g_assert_false(bar->is_io); |
557 | |
|
558 | 0 | return dev; |
559 | 0 | } |
560 | | |
561 | | /* |
562 | | * Write a 128-bit invalidation descriptor at the current tail and advance |
563 | | * IQT_REG. Internal helper for the IOTLB / wait variants below. |
564 | | */ |
565 | | static uint32_t qvtd_submit_inv_desc(QTestState *qts, uint64_t iommu_base, |
566 | | uint64_t desc_lo, uint64_t desc_hi, |
567 | | uint32_t tail) |
568 | 0 | { |
569 | 0 | uint64_t desc_addr = QVTD_IQ_BASE + (uint64_t)tail * QVTD_IQ_DESC_SIZE; |
570 | |
|
571 | 0 | qtest_writeq(qts, desc_addr, desc_lo); |
572 | 0 | qtest_writeq(qts, desc_addr + 8, desc_hi); |
573 | 0 | tail++; |
574 | |
|
575 | 0 | qtest_writeq(qts, iommu_base + DMAR_IQT_REG, |
576 | 0 | (uint64_t)tail << QVTD_IQT_SHIFT); |
577 | 0 | return tail; |
578 | 0 | } |
579 | | |
580 | | uint32_t qvtd_submit_inv_wait_and_poll(QTestState *qts, uint64_t iommu_base, |
581 | | uint32_t tail) |
582 | 0 | { |
583 | 0 | uint64_t lo, hi; |
584 | 0 | uint32_t status = 0; |
585 | 0 | int i; |
586 | |
|
587 | 0 | qtest_writel(qts, QVTD_INV_WAIT_ADDR, 0); |
588 | |
|
589 | 0 | lo = VTD_INV_DESC_WAIT | VTD_INV_DESC_WAIT_SW | |
590 | 0 | ((uint64_t)QVTD_INV_WAIT_DATA << VTD_INV_DESC_WAIT_DATA_SHIFT); |
591 | 0 | hi = QVTD_INV_WAIT_ADDR; |
592 | |
|
593 | 0 | tail = qvtd_submit_inv_desc(qts, iommu_base, lo, hi, tail); |
594 | |
|
595 | 0 | for (i = 0; i < QVTD_INV_WAIT_POLL_MAX_ITERS; i++) { |
596 | 0 | status = qtest_readl(qts, QVTD_INV_WAIT_ADDR); |
597 | 0 | if (status == QVTD_INV_WAIT_DATA) { |
598 | 0 | return tail; |
599 | 0 | } |
600 | 0 | g_usleep(QVTD_INV_WAIT_POLL_INTERVAL_US); |
601 | 0 | } |
602 | | |
603 | 0 | g_assert_cmphex(status, ==, QVTD_INV_WAIT_DATA); |
604 | 0 | return tail; |
605 | 0 | } |
606 | | |
607 | | uint32_t qvtd_submit_iotlb_global_inv(QTestState *qts, uint64_t iommu_base, |
608 | | uint32_t tail) |
609 | 0 | { |
610 | 0 | uint64_t lo = VTD_INV_DESC_IOTLB | VTD_INV_DESC_IOTLB_GLOBAL; |
611 | |
|
612 | 0 | return qvtd_submit_inv_desc(qts, iommu_base, lo, 0, tail); |
613 | 0 | } |
614 | | |
615 | | uint32_t qvtd_submit_iotlb_domain_inv(QTestState *qts, uint64_t iommu_base, |
616 | | uint16_t domain_id, uint32_t tail) |
617 | 0 | { |
618 | 0 | uint64_t lo = VTD_INV_DESC_IOTLB | VTD_INV_DESC_IOTLB_DOMAIN | |
619 | 0 | ((uint64_t)domain_id << 16); |
620 | |
|
621 | 0 | return qvtd_submit_inv_desc(qts, iommu_base, lo, 0, tail); |
622 | 0 | } |
623 | | |
624 | | uint32_t qvtd_submit_iotlb_page_inv(QTestState *qts, uint64_t iommu_base, |
625 | | uint16_t domain_id, uint64_t addr, |
626 | | uint8_t am, uint32_t tail) |
627 | 0 | { |
628 | 0 | uint64_t lo = VTD_INV_DESC_IOTLB | VTD_INV_DESC_IOTLB_PAGE | |
629 | 0 | ((uint64_t)domain_id << 16); |
630 | | /* |
631 | | * AM selects the invalidation range per VT-d 6.5.2.4: |
632 | | * am=0 → 4 KB, am=9 → 2 MB, am=18 → 1 GB. |
633 | | * IH (hi[6]) is left clear, requesting full invalidation |
634 | | * including non-leaf paging-structure caches. |
635 | | */ |
636 | 0 | uint64_t hi = (addr & ~0xfffULL) | (am & 0x3fULL); |
637 | |
|
638 | 0 | return qvtd_submit_inv_desc(qts, iommu_base, lo, hi, tail); |
639 | 0 | } |