sys/x86/iommu/intel_gas.c

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