1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2014 Ian Lepore <ian@freebsd.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 __FBSDID("$FreeBSD$"); 31 32 #include "opt_acpi.h" 33 #include "opt_ddb.h" 34 35 /* 36 * Routines for describing and initializing anything related to physical memory. 37 */ 38 39 #include <sys/param.h> 40 #include <sys/systm.h> 41 #include <sys/kernel.h> 42 #include <sys/physmem.h> 43 #include <vm/vm.h> 44 #include <vm/vm_param.h> 45 #include <vm/vm_page.h> 46 #include <vm/vm_phys.h> 47 #include <vm/vm_dumpset.h> 48 #include <machine/md_var.h> 49 50 /* 51 * These structures are used internally to keep track of regions of physical 52 * ram, and regions within the physical ram that need to be excluded. An 53 * exclusion region can be excluded from crash dumps, from the vm pool of pages 54 * that can be allocated, or both, depending on the exclusion flags associated 55 * with the region. 56 */ 57 #ifdef DEV_ACPI 58 #define MAX_HWCNT 32 /* ACPI needs more regions */ 59 #define MAX_EXCNT 32 60 #else 61 #define MAX_HWCNT 16 62 #define MAX_EXCNT 16 63 #endif 64 65 #if defined(__arm__) 66 #define MAX_PHYS_ADDR 0xFFFFFFFFull 67 #elif defined(__aarch64__) || defined(__riscv) 68 #define MAX_PHYS_ADDR 0xFFFFFFFFFFFFFFFFull 69 #endif 70 71 struct region { 72 vm_paddr_t addr; 73 vm_size_t size; 74 uint32_t flags; 75 }; 76 77 static struct region hwregions[MAX_HWCNT]; 78 static struct region exregions[MAX_EXCNT]; 79 80 static size_t hwcnt; 81 static size_t excnt; 82 83 /* 84 * realmem is the total number of hardware pages, excluded or not. 85 * Maxmem is one greater than the last physical page number. 86 */ 87 long realmem; 88 long Maxmem; 89 90 /* 91 * Print the contents of the physical and excluded region tables using the 92 * provided printf-like output function (which will be either printf or 93 * db_printf). 94 */ 95 static void 96 physmem_dump_tables(int (*prfunc)(const char *, ...)) 97 { 98 int flags, i; 99 uintmax_t addr, size; 100 const unsigned int mbyte = 1024 * 1024; 101 102 prfunc("Physical memory chunk(s):\n"); 103 for (i = 0; i < hwcnt; ++i) { 104 addr = hwregions[i].addr; 105 size = hwregions[i].size; 106 prfunc(" 0x%08jx - 0x%08jx, %5ju MB (%7ju pages)\n", addr, 107 addr + size - 1, size / mbyte, size / PAGE_SIZE); 108 } 109 110 prfunc("Excluded memory regions:\n"); 111 for (i = 0; i < excnt; ++i) { 112 addr = exregions[i].addr; 113 size = exregions[i].size; 114 flags = exregions[i].flags; 115 prfunc(" 0x%08jx - 0x%08jx, %5ju MB (%7ju pages) %s %s\n", 116 addr, addr + size - 1, size / mbyte, size / PAGE_SIZE, 117 (flags & EXFLAG_NOALLOC) ? "NoAlloc" : "", 118 (flags & EXFLAG_NODUMP) ? "NoDump" : ""); 119 } 120 121 #ifdef DEBUG 122 prfunc("Avail lists:\n"); 123 for (i = 0; phys_avail[i] != 0; ++i) { 124 prfunc(" phys_avail[%d] 0x%08x\n", i, phys_avail[i]); 125 } 126 for (i = 0; dump_avail[i] != 0; ++i) { 127 prfunc(" dump_avail[%d] 0x%08x\n", i, dump_avail[i]); 128 } 129 #endif 130 } 131 132 /* 133 * Print the contents of the static mapping table. Used for bootverbose. 134 */ 135 void 136 physmem_print_tables(void) 137 { 138 139 physmem_dump_tables(printf); 140 } 141 142 /* 143 * Walk the list of hardware regions, processing it against the list of 144 * exclusions that contain the given exflags, and generating an "avail list". 145 * 146 * If maxphyssz is not zero it sets upper limit, in bytes, for the total 147 * "avail list" size. Walk stops once the limit is reached and the last region 148 * is cut short if necessary. 149 * 150 * Updates the value at *pavail with the sum of all pages in all hw regions. 151 * 152 * Returns the number of pages of non-excluded memory added to the avail list. 153 */ 154 static size_t 155 regions_to_avail(vm_paddr_t *avail, uint32_t exflags, size_t maxavail, 156 uint64_t maxphyssz, long *pavail, long *prealmem) 157 { 158 size_t acnt, exi, hwi; 159 uint64_t end, start, xend, xstart; 160 long availmem, totalmem; 161 const struct region *exp, *hwp; 162 uint64_t availsz; 163 164 totalmem = 0; 165 availmem = 0; 166 availsz = 0; 167 acnt = 0; 168 for (hwi = 0, hwp = hwregions; hwi < hwcnt; ++hwi, ++hwp) { 169 start = hwp->addr; 170 end = hwp->size + start; 171 totalmem += atop((vm_offset_t)(end - start)); 172 for (exi = 0, exp = exregions; exi < excnt; ++exi, ++exp) { 173 /* 174 * If the excluded region does not match given flags, 175 * continue checking with the next excluded region. 176 */ 177 if ((exp->flags & exflags) == 0) 178 continue; 179 xstart = exp->addr; 180 xend = exp->size + xstart; 181 /* 182 * If the excluded region ends before this hw region, 183 * continue checking with the next excluded region. 184 */ 185 if (xend <= start) 186 continue; 187 /* 188 * If the excluded region begins after this hw region 189 * we're done because both lists are sorted. 190 */ 191 if (xstart >= end) 192 break; 193 /* 194 * If the excluded region completely covers this hw 195 * region, shrink this hw region to zero size. 196 */ 197 if ((start >= xstart) && (end <= xend)) { 198 start = xend; 199 end = xend; 200 break; 201 } 202 /* 203 * If the excluded region falls wholly within this hw 204 * region without abutting or overlapping the beginning 205 * or end, create an available entry from the leading 206 * fragment, then adjust the start of this hw region to 207 * the end of the excluded region, and continue checking 208 * the next excluded region because another exclusion 209 * could affect the remainder of this hw region. 210 */ 211 if ((xstart > start) && (xend < end)) { 212 213 if ((maxphyssz != 0) && 214 (availsz + xstart - start > maxphyssz)) { 215 xstart = maxphyssz + start - availsz; 216 } 217 if (xstart <= start) 218 continue; 219 if (acnt > 0 && 220 avail[acnt - 1] == (vm_paddr_t)start) { 221 avail[acnt - 1] = (vm_paddr_t)xstart; 222 } else { 223 avail[acnt++] = (vm_paddr_t)start; 224 avail[acnt++] = (vm_paddr_t)xstart; 225 } 226 availsz += (xstart - start); 227 availmem += atop((vm_offset_t)(xstart - start)); 228 start = xend; 229 continue; 230 } 231 /* 232 * We know the excluded region overlaps either the start 233 * or end of this hardware region (but not both), trim 234 * the excluded portion off the appropriate end. 235 */ 236 if (xstart <= start) 237 start = xend; 238 else 239 end = xstart; 240 } 241 /* 242 * If the trimming actions above left a non-zero size, create an 243 * available entry for it. 244 */ 245 if (end > start) { 246 if ((maxphyssz != 0) && 247 (availsz + end - start > maxphyssz)) { 248 end = maxphyssz + start - availsz; 249 } 250 if (end <= start) 251 break; 252 253 if (acnt > 0 && avail[acnt - 1] == (vm_paddr_t)start) { 254 avail[acnt - 1] = (vm_paddr_t)end; 255 } else { 256 avail[acnt++] = (vm_paddr_t)start; 257 avail[acnt++] = (vm_paddr_t)end; 258 } 259 availsz += end - start; 260 availmem += atop((vm_offset_t)(end - start)); 261 } 262 if (acnt >= maxavail) 263 panic("Not enough space in the dump/phys_avail arrays"); 264 } 265 266 if (pavail != NULL) 267 *pavail = availmem; 268 if (prealmem != NULL) 269 *prealmem = totalmem; 270 return (acnt); 271 } 272 273 /* 274 * Insertion-sort a new entry into a regions list; sorted by start address. 275 */ 276 static size_t 277 insert_region(struct region *regions, size_t rcnt, vm_paddr_t addr, 278 vm_size_t size, uint32_t flags) 279 { 280 size_t i; 281 struct region *ep, *rp; 282 283 ep = regions + rcnt; 284 for (i = 0, rp = regions; i < rcnt; ++i, ++rp) { 285 if (rp->addr == addr && rp->size == size) /* Pure dup. */ 286 return (rcnt); 287 if (flags == rp->flags) { 288 if (addr + size == rp->addr) { 289 rp->addr = addr; 290 rp->size += size; 291 return (rcnt); 292 } else if (rp->addr + rp->size == addr) { 293 rp->size += size; 294 return (rcnt); 295 } 296 } 297 if (addr < rp->addr) { 298 bcopy(rp, rp + 1, (ep - rp) * sizeof(*rp)); 299 break; 300 } 301 } 302 rp->addr = addr; 303 rp->size = size; 304 rp->flags = flags; 305 rcnt++; 306 307 return (rcnt); 308 } 309 310 /* 311 * Add a hardware memory region. 312 */ 313 void 314 physmem_hardware_region(uint64_t pa, uint64_t sz) 315 { 316 vm_offset_t adj; 317 318 /* 319 * Filter out the page at PA 0x00000000. The VM can't handle it, as 320 * pmap_extract() == 0 means failure. 321 */ 322 if (pa == 0) { 323 if (sz <= PAGE_SIZE) 324 return; 325 pa = PAGE_SIZE; 326 sz -= PAGE_SIZE; 327 } else if (pa > MAX_PHYS_ADDR) { 328 /* This range is past usable memory, ignore it */ 329 return; 330 } 331 332 /* 333 * Also filter out the page at the end of the physical address space -- 334 * if addr is non-zero and addr+size is zero we wrapped to the next byte 335 * beyond what vm_paddr_t can express. That leads to a NULL pointer 336 * deref early in startup; work around it by leaving the last page out. 337 * 338 * XXX This just in: subtract out a whole megabyte, not just 1 page. 339 * Reducing the size by anything less than 1MB results in the NULL 340 * pointer deref in _vm_map_lock_read(). Better to give up a megabyte 341 * than leave some folks with an unusable system while we investigate. 342 */ 343 if ((pa + sz) > (MAX_PHYS_ADDR - 1024 * 1024)) { 344 sz = MAX_PHYS_ADDR - pa + 1; 345 if (sz <= 1024 * 1024) 346 return; 347 sz -= 1024 * 1024; 348 } 349 350 /* 351 * Round the starting address up to a page boundary, and truncate the 352 * ending page down to a page boundary. 353 */ 354 adj = round_page(pa) - pa; 355 pa = round_page(pa); 356 sz = trunc_page(sz - adj); 357 358 if (sz > 0 && hwcnt < nitems(hwregions)) 359 hwcnt = insert_region(hwregions, hwcnt, pa, sz, 0); 360 } 361 362 /* 363 * Add an exclusion region. 364 */ 365 void 366 physmem_exclude_region(vm_paddr_t pa, vm_size_t sz, uint32_t exflags) 367 { 368 vm_offset_t adj; 369 370 /* 371 * Truncate the starting address down to a page boundary, and round the 372 * ending page up to a page boundary. 373 */ 374 adj = pa - trunc_page(pa); 375 pa = trunc_page(pa); 376 sz = round_page(sz + adj); 377 378 if (excnt >= nitems(exregions)) 379 panic("failed to exclude region %#jx-%#jx", (uintmax_t)pa, 380 (uintmax_t)(pa + sz)); 381 excnt = insert_region(exregions, excnt, pa, sz, exflags); 382 } 383 384 size_t 385 physmem_avail(vm_paddr_t *avail, size_t maxavail) 386 { 387 388 return (regions_to_avail(avail, EXFLAG_NOALLOC, maxavail, 0, NULL, NULL)); 389 } 390 391 /* 392 * Process all the regions added earlier into the global avail lists. 393 * 394 * Updates the kernel global 'physmem' with the number of physical pages 395 * available for use (all pages not in any exclusion region). 396 * 397 * Updates the kernel global 'Maxmem' with the page number one greater then the 398 * last page of physical memory in the system. 399 */ 400 void 401 physmem_init_kernel_globals(void) 402 { 403 size_t nextidx; 404 u_long hwphyssz; 405 406 hwphyssz = 0; 407 TUNABLE_ULONG_FETCH("hw.physmem", &hwphyssz); 408 409 regions_to_avail(dump_avail, EXFLAG_NODUMP, PHYS_AVAIL_ENTRIES, 410 hwphyssz, NULL, NULL); 411 nextidx = regions_to_avail(phys_avail, EXFLAG_NOALLOC, 412 PHYS_AVAIL_ENTRIES, hwphyssz, &physmem, &realmem); 413 if (nextidx == 0) 414 panic("No memory entries in phys_avail"); 415 Maxmem = atop(phys_avail[nextidx - 1]); 416 } 417 418 #ifdef DDB 419 #include <ddb/ddb.h> 420 421 DB_SHOW_COMMAND(physmem, db_show_physmem) 422 { 423 424 physmem_dump_tables(db_printf); 425 } 426 427 #endif /* DDB */ 428