1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2013 The FreeBSD Foundation
5 * All rights reserved.
6 *
7 * This software was developed by Konstantin Belousov <kib@FreeBSD.org>
8 * under sponsorship from the FreeBSD Foundation.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __FBSDID("$FreeBSD$");
34
35 #define RB_AUGMENT(entry) dmar_gas_augment_entry(entry)
36
37 #include <sys/param.h>
38 #include <sys/systm.h>
39 #include <sys/malloc.h>
40 #include <sys/bus.h>
41 #include <sys/interrupt.h>
42 #include <sys/kernel.h>
43 #include <sys/ktr.h>
44 #include <sys/lock.h>
45 #include <sys/proc.h>
46 #include <sys/rwlock.h>
47 #include <sys/memdesc.h>
48 #include <sys/mutex.h>
49 #include <sys/sysctl.h>
50 #include <sys/rman.h>
51 #include <sys/taskqueue.h>
52 #include <sys/tree.h>
53 #include <sys/uio.h>
54 #include <sys/vmem.h>
55 #include <dev/pci/pcivar.h>
56 #include <vm/vm.h>
57 #include <vm/vm_extern.h>
58 #include <vm/vm_kern.h>
59 #include <vm/vm_object.h>
60 #include <vm/vm_page.h>
61 #include <vm/vm_map.h>
62 #include <vm/uma.h>
63 #include <machine/atomic.h>
64 #include <machine/bus.h>
65 #include <machine/md_var.h>
66 #include <machine/specialreg.h>
67 #include <x86/include/busdma_impl.h>
68 #include <x86/iommu/intel_reg.h>
69 #include <x86/iommu/busdma_dmar.h>
70 #include <dev/pci/pcireg.h>
71 #include <x86/iommu/intel_dmar.h>
72
73 /*
74 * Guest Address Space management.
75 */
76
77 static uma_zone_t dmar_map_entry_zone;
78
79 static void
80 intel_gas_init(void)
81 {
82
83 dmar_map_entry_zone = uma_zcreate("DMAR_MAP_ENTRY",
84 sizeof(struct dmar_map_entry), NULL, NULL,
85 NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_NODUMP);
86 }
87 SYSINIT(intel_gas, SI_SUB_DRIVERS, SI_ORDER_FIRST, intel_gas_init, NULL);
88
89 struct dmar_map_entry *
90 dmar_gas_alloc_entry(struct dmar_domain *domain, u_int flags)
91 {
92 struct dmar_map_entry *res;
93
94 KASSERT((flags & ~(DMAR_PGF_WAITOK)) == 0,
95 ("unsupported flags %x", flags));
96
97 res = uma_zalloc(dmar_map_entry_zone, ((flags & DMAR_PGF_WAITOK) !=
98 0 ? M_WAITOK : M_NOWAIT) | M_ZERO);
99 if (res != NULL) {
100 res->domain = domain;
101 atomic_add_int(&domain->entries_cnt, 1);
102 }
103 return (res);
104 }
105
106 void
107 dmar_gas_free_entry(struct dmar_domain *domain, struct dmar_map_entry *entry)
108 {
109
110 KASSERT(domain == entry->domain,
111 ("mismatched free domain %p entry %p entry->domain %p", domain,
112 entry, entry->domain));
113 atomic_subtract_int(&domain->entries_cnt, 1);
114 uma_zfree(dmar_map_entry_zone, entry);
115 }
116
117 static int
118 dmar_gas_cmp_entries(struct dmar_map_entry *a, struct dmar_map_entry *b)
119 {
120
121 /* Last entry have zero size, so <= */
122 KASSERT(a->start <= a->end, ("inverted entry %p (%jx, %jx)",
123 a, (uintmax_t)a->start, (uintmax_t)a->end));
124 KASSERT(b->start <= b->end, ("inverted entry %p (%jx, %jx)",
125 b, (uintmax_t)b->start, (uintmax_t)b->end));
126 KASSERT(a->end <= b->start || b->end <= a->start ||
127 a->end == a->start || b->end == b->start,
128 ("overlapping entries %p (%jx, %jx) %p (%jx, %jx)",
129 a, (uintmax_t)a->start, (uintmax_t)a->end,
130 b, (uintmax_t)b->start, (uintmax_t)b->end));
131
132 if (a->end < b->end)
133 return (-1);
134 else if (b->end < a->end)
135 return (1);
136 return (0);
137 }
138
139 static void
140 dmar_gas_augment_entry(struct dmar_map_entry *entry)
141 {
142 struct dmar_map_entry *l, *r;
143
144 for (; entry != NULL; entry = RB_PARENT(entry, rb_entry)) {
145 l = RB_LEFT(entry, rb_entry);
146 r = RB_RIGHT(entry, rb_entry);
147 if (l == NULL && r == NULL) {
148 entry->free_down = entry->free_after;
149 } else if (l == NULL && r != NULL) {
150 entry->free_down = MAX(entry->free_after, r->free_down);
151 } else if (/*l != NULL && */ r == NULL) {
152 entry->free_down = MAX(entry->free_after, l->free_down);
153 } else /* if (l != NULL && r != NULL) */ {
154 entry->free_down = MAX(entry->free_after, l->free_down);
155 entry->free_down = MAX(entry->free_down, r->free_down);
156 }
157 }
158 }
159
160 RB_GENERATE(dmar_gas_entries_tree, dmar_map_entry, rb_entry,
161 dmar_gas_cmp_entries);
162
163 static void
164 dmar_gas_fix_free(struct dmar_domain *domain, struct dmar_map_entry *entry)
165 {
166 struct dmar_map_entry *next;
167
168 next = RB_NEXT(dmar_gas_entries_tree, &domain->rb_root, entry);
169 entry->free_after = (next != NULL ? next->start : domain->end) -
170 entry->end;
171 dmar_gas_augment_entry(entry);
172 }
173
174 #ifdef INVARIANTS
175 static void
176 dmar_gas_check_free(struct dmar_domain *domain)
177 {
178 struct dmar_map_entry *entry, *next, *l, *r;
179 dmar_gaddr_t v;
180
181 RB_FOREACH(entry, dmar_gas_entries_tree, &domain->rb_root) {
182 KASSERT(domain == entry->domain,
183 ("mismatched free domain %p entry %p entry->domain %p",
184 domain, entry, entry->domain));
185 next = RB_NEXT(dmar_gas_entries_tree, &domain->rb_root, entry);
186 if (next == NULL) {
187 MPASS(entry->free_after == domain->end - entry->end);
188 } else {
189 MPASS(entry->free_after = next->start - entry->end);
190 MPASS(entry->end <= next->start);
191 }
192 l = RB_LEFT(entry, rb_entry);
193 r = RB_RIGHT(entry, rb_entry);
194 if (l == NULL && r == NULL) {
195 MPASS(entry->free_down == entry->free_after);
196 } else if (l == NULL && r != NULL) {
197 MPASS(entry->free_down = MAX(entry->free_after,
198 r->free_down));
199 } else if (r == NULL) {
200 MPASS(entry->free_down = MAX(entry->free_after,
201 l->free_down));
202 } else {
203 v = MAX(entry->free_after, l->free_down);
204 v = MAX(v, r->free_down);
205 MPASS(entry->free_down == v);
206 }
207 }
208 }
209 #endif
210
211 static bool
212 dmar_gas_rb_insert(struct dmar_domain *domain, struct dmar_map_entry *entry)
213 {
214 struct dmar_map_entry *prev, *found;
215
216 found = RB_INSERT(dmar_gas_entries_tree, &domain->rb_root, entry);
217 dmar_gas_fix_free(domain, entry);
218 prev = RB_PREV(dmar_gas_entries_tree, &domain->rb_root, entry);
219 if (prev != NULL)
220 dmar_gas_fix_free(domain, prev);
221 return (found == NULL);
222 }
223
224 static void
225 dmar_gas_rb_remove(struct dmar_domain *domain, struct dmar_map_entry *entry)
226 {
227 struct dmar_map_entry *prev;
228
229 prev = RB_PREV(dmar_gas_entries_tree, &domain->rb_root, entry);
230 RB_REMOVE(dmar_gas_entries_tree, &domain->rb_root, entry);
231 if (prev != NULL)
232 dmar_gas_fix_free(domain, prev);
233 }
234
235 void
236 dmar_gas_init_domain(struct dmar_domain *domain)
237 {
238 struct dmar_map_entry *begin, *end;
239
240 begin = dmar_gas_alloc_entry(domain, DMAR_PGF_WAITOK);
241 end = dmar_gas_alloc_entry(domain, DMAR_PGF_WAITOK);
242
243 DMAR_DOMAIN_LOCK(domain);
244 KASSERT(domain->entries_cnt == 2, ("dirty domain %p", domain));
245 KASSERT(RB_EMPTY(&domain->rb_root), ("non-empty entries %p", domain));
246
247 begin->start = 0;
248 begin->end = DMAR_PAGE_SIZE;
249 begin->free_after = domain->end - begin->end;
250 begin->flags = DMAR_MAP_ENTRY_PLACE | DMAR_MAP_ENTRY_UNMAPPED;
251 dmar_gas_rb_insert(domain, begin);
252
253 end->start = domain->end;
254 end->end = domain->end;
255 end->free_after = 0;
256 end->flags = DMAR_MAP_ENTRY_PLACE | DMAR_MAP_ENTRY_UNMAPPED;
257 dmar_gas_rb_insert(domain, end);
258
259 domain->first_place = begin;
260 domain->last_place = end;
261 domain->flags |= DMAR_DOMAIN_GAS_INITED;
262 DMAR_DOMAIN_UNLOCK(domain);
263 }
264
265 void
266 dmar_gas_fini_domain(struct dmar_domain *domain)
267 {
268 struct dmar_map_entry *entry, *entry1;
269
270 DMAR_DOMAIN_ASSERT_LOCKED(domain);
271 KASSERT(domain->entries_cnt == 2, ("domain still in use %p", domain));
272
273 entry = RB_MIN(dmar_gas_entries_tree, &domain->rb_root);
274 KASSERT(entry->start == 0, ("start entry start %p", domain));
275 KASSERT(entry->end == DMAR_PAGE_SIZE, ("start entry end %p", domain));
276 KASSERT(entry->flags == DMAR_MAP_ENTRY_PLACE,
277 ("start entry flags %p", domain));
278 RB_REMOVE(dmar_gas_entries_tree, &domain->rb_root, entry);
279 dmar_gas_free_entry(domain, entry);
280
281 entry = RB_MAX(dmar_gas_entries_tree, &domain->rb_root);
282 KASSERT(entry->start == domain->end, ("end entry start %p", domain));
283 KASSERT(entry->end == domain->end, ("end entry end %p", domain));
284 KASSERT(entry->free_after == 0, ("end entry free_after %p", domain));
285 KASSERT(entry->flags == DMAR_MAP_ENTRY_PLACE,
286 ("end entry flags %p", domain));
287 RB_REMOVE(dmar_gas_entries_tree, &domain->rb_root, entry);
288 dmar_gas_free_entry(domain, entry);
289
290 RB_FOREACH_SAFE(entry, dmar_gas_entries_tree, &domain->rb_root,
291 entry1) {
292 KASSERT((entry->flags & DMAR_MAP_ENTRY_RMRR) != 0,
293 ("non-RMRR entry left %p", domain));
294 RB_REMOVE(dmar_gas_entries_tree, &domain->rb_root, entry);
295 dmar_gas_free_entry(domain, entry);
296 }
297 }
298
299 struct dmar_gas_match_args {
300 struct dmar_domain *domain;
301 dmar_gaddr_t size;
302 int offset;
303 const struct bus_dma_tag_common *common;
304 u_int gas_flags;
305 struct dmar_map_entry *entry;
306 };
307
308 static bool
309 dmar_gas_match_one(struct dmar_gas_match_args *a, struct dmar_map_entry *prev,
310 dmar_gaddr_t end)
311 {
312 dmar_gaddr_t bs, start;
313
314 if (a->entry->start + a->size > end)
315 return (false);
316
317 /* DMAR_PAGE_SIZE to create gap after new entry. */
318 if (a->entry->start < prev->end + DMAR_PAGE_SIZE ||
319 a->entry->start + a->size + a->offset + DMAR_PAGE_SIZE >
320 prev->end + prev->free_after)
321 return (false);
322
323 /* No boundary crossing. */
324 if (dmar_test_boundary(a->entry->start + a->offset, a->size,
325 a->common->boundary))
326 return (true);
327
328 /*
329 * The start + offset to start + offset + size region crosses
330 * the boundary. Check if there is enough space after the
331 * next boundary after the prev->end.
332 */
333 bs = rounddown2(a->entry->start + a->offset + a->common->boundary,
334 a->common->boundary);
335 start = roundup2(bs, a->common->alignment);
336 /* DMAR_PAGE_SIZE to create gap after new entry. */
337 if (start + a->offset + a->size + DMAR_PAGE_SIZE <=
338 prev->end + prev->free_after &&
339 start + a->offset + a->size <= end &&
340 dmar_test_boundary(start + a->offset, a->size,
341 a->common->boundary)) {
342 a->entry->start = start;
343 return (true);
344 }
345
346 /*
347 * Not enough space to align at the requested boundary, or
348 * boundary is smaller than the size, but allowed to split.
349 * We already checked that start + size does not overlap end.
350 *
351 * XXXKIB. It is possible that bs is exactly at the start of
352 * the next entry, then we do not have gap. Ignore for now.
353 */
354 if ((a->gas_flags & DMAR_GM_CANSPLIT) != 0) {
355 a->size = bs - a->entry->start;
356 return (true);
357 }
358
359 return (false);
360 }
361
362 static void
363 dmar_gas_match_insert(struct dmar_gas_match_args *a,
364 struct dmar_map_entry *prev)
365 {
366 struct dmar_map_entry *next;
367 bool found;
368
369 /*
370 * The prev->end is always aligned on the page size, which
371 * causes page alignment for the entry->start too. The size
372 * is checked to be multiple of the page size.
373 *
374 * The page sized gap is created between consequent
375 * allocations to ensure that out-of-bounds accesses fault.
376 */
377 a->entry->end = a->entry->start + a->size;
378
379 next = RB_NEXT(dmar_gas_entries_tree, &a->domain->rb_root, prev);
380 KASSERT(next->start >= a->entry->end &&
381 next->start - a->entry->start >= a->size &&
382 prev->end <= a->entry->end,
383 ("dmar_gas_match_insert hole failed %p prev (%jx, %jx) "
384 "free_after %jx next (%jx, %jx) entry (%jx, %jx)", a->domain,
385 (uintmax_t)prev->start, (uintmax_t)prev->end,
386 (uintmax_t)prev->free_after,
387 (uintmax_t)next->start, (uintmax_t)next->end,
388 (uintmax_t)a->entry->start, (uintmax_t)a->entry->end));
389
390 prev->free_after = a->entry->start - prev->end;
391 a->entry->free_after = next->start - a->entry->end;
392
393 found = dmar_gas_rb_insert(a->domain, a->entry);
394 KASSERT(found, ("found dup %p start %jx size %jx",
395 a->domain, (uintmax_t)a->entry->start, (uintmax_t)a->size));
396 a->entry->flags = DMAR_MAP_ENTRY_MAP;
397
398 KASSERT(RB_PREV(dmar_gas_entries_tree, &a->domain->rb_root,
399 a->entry) == prev,
400 ("entry %p prev %p inserted prev %p", a->entry, prev,
401 RB_PREV(dmar_gas_entries_tree, &a->domain->rb_root, a->entry)));
402 KASSERT(RB_NEXT(dmar_gas_entries_tree, &a->domain->rb_root,
403 a->entry) == next,
404 ("entry %p next %p inserted next %p", a->entry, next,
405 RB_NEXT(dmar_gas_entries_tree, &a->domain->rb_root, a->entry)));
406 }
407
408 static int
409 dmar_gas_lowermatch(struct dmar_gas_match_args *a, struct dmar_map_entry *prev)
410 {
411 struct dmar_map_entry *l;
412 int ret;
413
414 if (prev->end < a->common->lowaddr) {
415 a->entry->start = roundup2(prev->end + DMAR_PAGE_SIZE,
416 a->common->alignment);
417 if (dmar_gas_match_one(a, prev, a->common->lowaddr)) {
418 dmar_gas_match_insert(a, prev);
419 return (0);
420 }
421 }
422 if (prev->free_down < a->size + a->offset + DMAR_PAGE_SIZE)
423 return (ENOMEM);
424 l = RB_LEFT(prev, rb_entry);
425 if (l != NULL) {
426 ret = dmar_gas_lowermatch(a, l);
427 if (ret == 0)
428 return (0);
429 }
430 l = RB_RIGHT(prev, rb_entry);
431 if (l != NULL)
432 return (dmar_gas_lowermatch(a, l));
433 return (ENOMEM);
434 }
435
436 static int
437 dmar_gas_uppermatch(struct dmar_gas_match_args *a)
438 {
439 struct dmar_map_entry *next, *prev, find_entry;
440
441 find_entry.start = a->common->highaddr;
442 next = RB_NFIND(dmar_gas_entries_tree, &a->domain->rb_root,
443 &find_entry);
444 if (next == NULL)
445 return (ENOMEM);
446 prev = RB_PREV(dmar_gas_entries_tree, &a->domain->rb_root, next);
447 KASSERT(prev != NULL, ("no prev %p %jx", a->domain,
448 (uintmax_t)find_entry.start));
449 for (;;) {
450 a->entry->start = prev->start + DMAR_PAGE_SIZE;
451 if (a->entry->start < a->common->highaddr)
452 a->entry->start = a->common->highaddr;
453 a->entry->start = roundup2(a->entry->start,
454 a->common->alignment);
455 if (dmar_gas_match_one(a, prev, a->domain->end)) {
456 dmar_gas_match_insert(a, prev);
457 return (0);
458 }
459
460 /*
461 * XXXKIB. This falls back to linear iteration over
462 * the free space in the high region. But high
463 * regions are almost unused, the code should be
464 * enough to cover the case, although in the
465 * non-optimal way.
466 */
467 prev = next;
468 next = RB_NEXT(dmar_gas_entries_tree, &a->domain->rb_root,
469 prev);
470 KASSERT(next != NULL, ("no next %p %jx", a->domain,
471 (uintmax_t)find_entry.start));
472 if (next->end >= a->domain->end)
473 return (ENOMEM);
474 }
475 }
476
477 static int
478 dmar_gas_find_space(struct dmar_domain *domain,
479 const struct bus_dma_tag_common *common, dmar_gaddr_t size,
480 int offset, u_int flags, struct dmar_map_entry *entry)
481 {
482 struct dmar_gas_match_args a;
483 int error;
484
485 DMAR_DOMAIN_ASSERT_LOCKED(domain);
486 KASSERT(entry->flags == 0, ("dirty entry %p %p", domain, entry));
487 KASSERT((size & DMAR_PAGE_MASK) == 0, ("size %jx", (uintmax_t)size));
488
489 a.domain = domain;
490 a.size = size;
491 a.offset = offset;
492 a.common = common;
493 a.gas_flags = flags;
494 a.entry = entry;
495
496 /* Handle lower region. */
497 if (common->lowaddr > 0) {
498 error = dmar_gas_lowermatch(&a, RB_ROOT(&domain->rb_root));
499 if (error == 0)
500 return (0);
501 KASSERT(error == ENOMEM,
502 ("error %d from dmar_gas_lowermatch", error));
503 }
504 /* Handle upper region. */
505 if (common->highaddr >= domain->end)
506 return (ENOMEM);
507 error = dmar_gas_uppermatch(&a);
508 KASSERT(error == ENOMEM,
509 ("error %d from dmar_gas_uppermatch", error));
510 return (error);
511 }
512
513 static int
514 dmar_gas_alloc_region(struct dmar_domain *domain, struct dmar_map_entry *entry,
515 u_int flags)
516 {
517 struct dmar_map_entry *next, *prev;
518 bool found;
519
520 DMAR_DOMAIN_ASSERT_LOCKED(domain);
521
522 if ((entry->start & DMAR_PAGE_MASK) != 0 ||
523 (entry->end & DMAR_PAGE_MASK) != 0)
524 return (EINVAL);
525 if (entry->start >= entry->end)
526 return (EINVAL);
527 if (entry->end >= domain->end)
528 return (EINVAL);
529
530 next = RB_NFIND(dmar_gas_entries_tree, &domain->rb_root, entry);
531 KASSERT(next != NULL, ("next must be non-null %p %jx", domain,
532 (uintmax_t)entry->start));
533 prev = RB_PREV(dmar_gas_entries_tree, &domain->rb_root, next);
534 /* prev could be NULL */
535
536 /*
537 * Adapt to broken BIOSes which specify overlapping RMRR
538 * entries.
539 *
540 * XXXKIB: this does not handle a case when prev or next
541 * entries are completely covered by the current one, which
542 * extends both ways.
543 */
544 if (prev != NULL && prev->end > entry->start &&
545 (prev->flags & DMAR_MAP_ENTRY_PLACE) == 0) {
546 if ((flags & DMAR_GM_RMRR) == 0 ||
547 (prev->flags & DMAR_MAP_ENTRY_RMRR) == 0)
548 return (EBUSY);
549 entry->start = prev->end;
550 }
551 if (next != NULL && next->start < entry->end &&
552 (next->flags & DMAR_MAP_ENTRY_PLACE) == 0) {
553 if ((flags & DMAR_GM_RMRR) == 0 ||
554 (next->flags & DMAR_MAP_ENTRY_RMRR) == 0)
555 return (EBUSY);
556 entry->end = next->start;
557 }
558 if (entry->end == entry->start)
559 return (0);
560
561 if (prev != NULL && prev->end > entry->start) {
562 /* This assumes that prev is the placeholder entry. */
563 dmar_gas_rb_remove(domain, prev);
564 prev = NULL;
565 }
566 if (next != NULL && next->start < entry->end) {
567 dmar_gas_rb_remove(domain, next);
568 next = NULL;
569 }
570
571 found = dmar_gas_rb_insert(domain, entry);
572 KASSERT(found, ("found RMRR dup %p start %jx end %jx",
573 domain, (uintmax_t)entry->start, (uintmax_t)entry->end));
574 if ((flags & DMAR_GM_RMRR) != 0)
575 entry->flags = DMAR_MAP_ENTRY_RMRR;
576
577 #ifdef INVARIANTS
578 struct dmar_map_entry *ip, *in;
579 ip = RB_PREV(dmar_gas_entries_tree, &domain->rb_root, entry);
580 in = RB_NEXT(dmar_gas_entries_tree, &domain->rb_root, entry);
581 KASSERT(prev == NULL || ip == prev,
582 ("RMRR %p (%jx %jx) prev %p (%jx %jx) ins prev %p (%jx %jx)",
583 entry, entry->start, entry->end, prev,
584 prev == NULL ? 0 : prev->start, prev == NULL ? 0 : prev->end,
585 ip, ip == NULL ? 0 : ip->start, ip == NULL ? 0 : ip->end));
586 KASSERT(next == NULL || in == next,
587 ("RMRR %p (%jx %jx) next %p (%jx %jx) ins next %p (%jx %jx)",
588 entry, entry->start, entry->end, next,
589 next == NULL ? 0 : next->start, next == NULL ? 0 : next->end,
590 in, in == NULL ? 0 : in->start, in == NULL ? 0 : in->end));
591 #endif
592
593 return (0);
594 }
595
596 void
597 dmar_gas_free_space(struct dmar_domain *domain, struct dmar_map_entry *entry)
598 {
599
600 DMAR_DOMAIN_ASSERT_LOCKED(domain);
601 KASSERT((entry->flags & (DMAR_MAP_ENTRY_PLACE | DMAR_MAP_ENTRY_RMRR |
602 DMAR_MAP_ENTRY_MAP)) == DMAR_MAP_ENTRY_MAP,
603 ("permanent entry %p %p", domain, entry));
604
605 dmar_gas_rb_remove(domain, entry);
606 entry->flags &= ~DMAR_MAP_ENTRY_MAP;
607 #ifdef INVARIANTS
608 if (dmar_check_free)
609 dmar_gas_check_free(domain);
610 #endif
611 }
612
613 void
614 dmar_gas_free_region(struct dmar_domain *domain, struct dmar_map_entry *entry)
615 {
616 struct dmar_map_entry *next, *prev;
617
618 DMAR_DOMAIN_ASSERT_LOCKED(domain);
619 KASSERT((entry->flags & (DMAR_MAP_ENTRY_PLACE | DMAR_MAP_ENTRY_RMRR |
620 DMAR_MAP_ENTRY_MAP)) == DMAR_MAP_ENTRY_RMRR,
621 ("non-RMRR entry %p %p", domain, entry));
622
623 prev = RB_PREV(dmar_gas_entries_tree, &domain->rb_root, entry);
624 next = RB_NEXT(dmar_gas_entries_tree, &domain->rb_root, entry);
625 dmar_gas_rb_remove(domain, entry);
626 entry->flags &= ~DMAR_MAP_ENTRY_RMRR;
627
628 if (prev == NULL)
629 dmar_gas_rb_insert(domain, domain->first_place);
630 if (next == NULL)
631 dmar_gas_rb_insert(domain, domain->last_place);
632 }
633
634 int
635 dmar_gas_map(struct dmar_domain *domain,
636 const struct bus_dma_tag_common *common, dmar_gaddr_t size, int offset,
637 u_int eflags, u_int flags, vm_page_t *ma, struct dmar_map_entry **res)
638 {
639 struct dmar_map_entry *entry;
640 int error;
641
642 KASSERT((flags & ~(DMAR_GM_CANWAIT | DMAR_GM_CANSPLIT)) == 0,
643 ("invalid flags 0x%x", flags));
644
645 entry = dmar_gas_alloc_entry(domain, (flags & DMAR_GM_CANWAIT) != 0 ?
646 DMAR_PGF_WAITOK : 0);
647 if (entry == NULL)
648 return (ENOMEM);
649 DMAR_DOMAIN_LOCK(domain);
650 error = dmar_gas_find_space(domain, common, size, offset, flags,
651 entry);
652 if (error == ENOMEM) {
653 DMAR_DOMAIN_UNLOCK(domain);
654 dmar_gas_free_entry(domain, entry);
655 return (error);
656 }
657 #ifdef INVARIANTS
658 if (dmar_check_free)
659 dmar_gas_check_free(domain);
660 #endif
661 KASSERT(error == 0,
662 ("unexpected error %d from dmar_gas_find_entry", error));
663 KASSERT(entry->end < domain->end, ("allocated GPA %jx, max GPA %jx",
664 (uintmax_t)entry->end, (uintmax_t)domain->end));
665 entry->flags |= eflags;
666 DMAR_DOMAIN_UNLOCK(domain);
667
668 error = domain_map_buf(domain, entry->start, entry->end - entry->start,
669 ma,
670 ((eflags & DMAR_MAP_ENTRY_READ) != 0 ? DMAR_PTE_R : 0) |
671 ((eflags & DMAR_MAP_ENTRY_WRITE) != 0 ? DMAR_PTE_W : 0) |
672 ((eflags & DMAR_MAP_ENTRY_SNOOP) != 0 ? DMAR_PTE_SNP : 0) |
673 ((eflags & DMAR_MAP_ENTRY_TM) != 0 ? DMAR_PTE_TM : 0),
674 (flags & DMAR_GM_CANWAIT) != 0 ? DMAR_PGF_WAITOK : 0);
675 if (error == ENOMEM) {
676 dmar_domain_unload_entry(entry, true);
677 return (error);
678 }
679 KASSERT(error == 0,
680 ("unexpected error %d from domain_map_buf", error));
681
682 *res = entry;
683 return (0);
684 }
685
686 int
687 dmar_gas_map_region(struct dmar_domain *domain, struct dmar_map_entry *entry,
688 u_int eflags, u_int flags, vm_page_t *ma)
689 {
690 dmar_gaddr_t start;
691 int error;
692
693 KASSERT(entry->flags == 0, ("used RMRR entry %p %p %x", domain,
694 entry, entry->flags));
695 KASSERT((flags & ~(DMAR_GM_CANWAIT | DMAR_GM_RMRR)) == 0,
696 ("invalid flags 0x%x", flags));
697
698 start = entry->start;
699 DMAR_DOMAIN_LOCK(domain);
700 error = dmar_gas_alloc_region(domain, entry, flags);
701 if (error != 0) {
702 DMAR_DOMAIN_UNLOCK(domain);
703 return (error);
704 }
705 entry->flags |= eflags;
706 DMAR_DOMAIN_UNLOCK(domain);
707 if (entry->end == entry->start)
708 return (0);
709
710 error = domain_map_buf(domain, entry->start, entry->end - entry->start,
711 ma + OFF_TO_IDX(start - entry->start),
712 ((eflags & DMAR_MAP_ENTRY_READ) != 0 ? DMAR_PTE_R : 0) |
713 ((eflags & DMAR_MAP_ENTRY_WRITE) != 0 ? DMAR_PTE_W : 0) |
714 ((eflags & DMAR_MAP_ENTRY_SNOOP) != 0 ? DMAR_PTE_SNP : 0) |
715 ((eflags & DMAR_MAP_ENTRY_TM) != 0 ? DMAR_PTE_TM : 0),
716 (flags & DMAR_GM_CANWAIT) != 0 ? DMAR_PGF_WAITOK : 0);
717 if (error == ENOMEM) {
718 dmar_domain_unload_entry(entry, false);
719 return (error);
720 }
721 KASSERT(error == 0,
722 ("unexpected error %d from domain_map_buf", error));
723
724 return (0);
725 }
726
727 int
728 dmar_gas_reserve_region(struct dmar_domain *domain, dmar_gaddr_t start,
729 dmar_gaddr_t end)
730 {
731 struct dmar_map_entry *entry;
732 int error;
733
734 entry = dmar_gas_alloc_entry(domain, DMAR_PGF_WAITOK);
735 entry->start = start;
736 entry->end = end;
737 DMAR_DOMAIN_LOCK(domain);
738 error = dmar_gas_alloc_region(domain, entry, DMAR_GM_CANWAIT);
739 if (error == 0)
740 entry->flags |= DMAR_MAP_ENTRY_UNMAPPED;
741 DMAR_DOMAIN_UNLOCK(domain);
742 if (error != 0)
743 dmar_gas_free_entry(domain, entry);
744 return (error);
745 }
Cache object: b327689003da2b29dc94cc8a95f68566
|