GENERIC HEAD from 2013-07-31 06:23:10 UTC, r253382M, vmcore.22

GDB: no debug ports present
KDB: debugger backends: ddb
KDB: current backend: ddb
Copyright (c) 1992-2013 The FreeBSD Project.
Copyright (c) 1979, 1980, 1983, 1986, 1988, 1989, 1991, 1992, 1993, 1994
	The Regents of the University of California. All rights reserved.
FreeBSD is a registered trademark of The FreeBSD Foundation.
FreeBSD 10.0-CURRENT #3 r253832M: Wed Jul 31 09:21:00 CEST 2013
    pho@t2.osted.lan:/usr/src/sys/amd64/compile/PHO amd64
FreeBSD clang version 3.3 (tags/RELEASE_33/final 183502) 20130610
WARNING: WITNESS option enabled, expect reduced performance.
WARNING: DIAGNOSTIC option enabled, expect reduced performance.
CPU: Intel(R) Xeon(R) CPU E5-2620 0 @ 2.00GHz (1995.24-MHz K8-class CPU)
  Origin = "GenuineIntel"  Id = 0x206d7  Family = 0x6  Model = 0x2d  Stepping = 7
  Features=0xbfebfbff<FPU,VME,DE,PSE,TSC,MSR,PAE,MCE,CX8,APIC,SEP,MTRR,PGE,MCA,CMOV,PAT,PSE36,CLFLUSH,DTS,ACPI,MMX,FXSR,SSE,SSE2,SS,HTT,TM,PBE>
  Features2=0x1fbee3ff<SSE3,PCLMULQDQ,DTES64,MON,DS_CPL,VMX,SMX,EST,TM2,SSSE3,CX16,xTPR,PDCM,PCID,DCA,SSE4.1,SSE4.2,x2APIC,POPCNT,TSCDLT,AESNI,XSAVE,OSXSAVE,AVX>
  AMD Features=0x2c100800<SYSCALL,NX,Page1GB,RDTSCP,LM>
  AMD Features2=0x1<LAHF>
  TSC: P-state invariant, performance statistics
real memory  = 68719476736 (65536 MB)
avail memory = 30998609920 (29562 MB)
:
Trying to mount root from ufs:/dev/da0p2 [rw]...
Setting hostuuid: 2bde2bde-f4e2-e111-aab2-001e6756b69b.
Setting hostid: 0x0035ff86.
Starting ddb.
Entropy harvesting: interrupts ethernet kickstart.
blist: Allocated 0xffffff8022266000, 0xfffffe00574090c0
Starting file system checks:
/dev/da0p2: FILE SYSTEM CLEAN; SKIPPING CHECKS
/dev/da0p2: clean, 86450646 free (73302 frags, 10797168 blocks, 0.1% fragmentation)
/dev/da0p3: FILE SYSTEM CLEAN; SKIPPING CHECKS
/dev/da0p3: clean, 24050029 free (517 frags, 3006189 blocks, 0.0% fragmentation)
lock order reversal:
 1st 0xfffffe005753cc98 ufs (ufs) @ kern/vfs_subr.c:2099
 2nd 0xffffff87a5032278 bufwait (bufwait) @ ufs/ffs/ffs_vnops.c:262
 3rd 0xfffffe0057946a28 ufs (ufs) @ kern/vfs_subr.c:2099
KDB: stack backtrace:
db_trace_self_wrapper() at db_trace_self_wrapper+0x2b/frame 0xffffff881de0fcb0
kdb_backtrace() at kdb_backtrace+0x39/frame 0xffffff881de0fd60
witness_checkorder() at witness_checkorder+0xd4f/frame 0xffffff881de0fdf0
__lockmgr_args() at __lockmgr_args+0x6f2/frame 0xffffff881de0ff20
ffs_lock() at ffs_lock+0x92/frame 0xffffff881de0ff70
VOP_LOCK1_APV() at VOP_LOCK1_APV+0xf5/frame 0xffffff881de0ffa0
_vn_lock() at _vn_lock+0xc6/frame 0xffffff881de10010
vget() at vget+0x70/frame 0xffffff881de10060
vfs_hash_get() at vfs_hash_get+0xf5/frame 0xffffff881de100b0
ffs_vgetf() at ffs_vgetf+0x41/frame 0xffffff881de10140
softdep_sync_buf() at softdep_sync_buf+0x8fa/frame 0xffffff881de101f0
ffs_syncvnode() at ffs_syncvnode+0x258/frame 0xffffff881de10270
ffs_truncate() at ffs_truncate+0x5f3/frame 0xffffff881de10450
ufs_direnter() at ufs_direnter+0x891/frame 0xffffff881de10510
ufs_makeinode() at ufs_makeinode+0x573/frame 0xffffff881de106d0
VOP_CREATE_APV() at VOP_CREATE_APV+0x108/frame 0xffffff881de10700
vn_open_cred() at vn_open_cred+0x2f0/frame 0xffffff881de10850
kern_openat() at kern_openat+0x1f5/frame 0xffffff881de109a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de10ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de10ab0
--- syscall (5, FreeBSD ELF64, sys_open), rip = 0x800b50b1a, rsp = 0x7fffffffd988, rbp = 0x7fffffffdb80 ---
Mounting local file systems:.
Writing entropy file:.
Setting hostname: t2.osted.lan.
igb0: link state changed to UP
Starting Network: lo0 igb0 igb1.
lo0: flags=8049<UP,LOOPBACK,RUNNING,MULTICAST> metric 0 mtu 16384
	options=600003<RXCSUM,TXCSUM,RXCSUM_IPV6,TXCSUM_IPV6>
	inet6 ::1 prefixlen 128 
	inet6 fe80::1%lo0 prefixlen 64 scopeid 0x3 
	inet 127.0.0.1 netmask 0xff000000 
	nd6 options=21<PERFORMNUD,AUTO_LINKLOCAL>
igb0: flags=8843<UP,BROADCAST,RUNNING,SIMPLEX,MULTICAST> metric 0 mtu 1500
	options=401bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,TSO4,VLAN_HWTSO>
	ether 00:1e:67:56:b6:9b
	inet 192.168.1.109 netmask 0xffffff00 broadcast 192.168.1.255 
	inet6 fe80::21e:67ff:fe56:b69b%igb0 prefixlen 64 scopeid 0x1 
	nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
	media: Ethernet autoselect (100baseTX <full-duplex>)
	status: active
igb1: flags=8c02<BROADCAST,OACTIVE,SIMPLEX,MULTICAST> metric 0 mtu 1500
	options=401bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,TSO4,VLAN_HWTSO>
	ether 00:1e:67:56:b6:9c
	nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
	media: Ethernet autoselect
	status: no carrier
Starting devd.
Starting Network: igb1.
igb1: flags=8c02<BROADCAST,OACTIVE,SIMPLEX,MULTICAST> metric 0 mtu 1500
	options=401bb<RXCSUM,TXCSUM,VLAN_MTU,VLAN_HWTAGGING,JUMBO_MTU,VLAN_HWCSUM,TSO4,VLAN_HWTSO>
	ether 00:1e:67:56:b6:9c
	nd6 options=29<PERFORMNUD,IFDISABLED,AUTO_LINKLOCAL>
	media: Ethernet autoselect
	status: no carrier
Configuring keyboard: keymap.
ums0: <Logitech USB Receiver, class 0/0, rev 2.00/23.01, addr 3> on usbus0
ums1: <Mouse Interface> on usbus2
ums0: 18 buttons and [XYZT] coordinates ID=2
ums1: 3 buttons and [Z] coordinates ID=0
Starting ums0 moused.
Expensive timeout(9) function: 0xffffffff80716670(0xffffffff815a5dd0) 0.010141077 s
Starting ums1 moused.
add net default: gateway 192.168.1.1
add net fe80::: gateway ::1
add net ff02::: gateway ::1
add net ::ffff:0.0.0.0: gateway ::1
add net ::0.0.0.0: gateway ::1
ELF ldconfig path: /lib /usr/lib /usr/lib/compat /usr/local/lib
32-bit compatibility ldconfig path: /usr/lib32
Creating and/or trimming log files.
Starting syslogd.
No core dumps found.
Starting rpcbind.
NFS access cache time=60
lock order reversal:
 1st 0xffffff87a50dd148 bufwait (bufwait) @ kern/vfs_bio.c:3061
 2nd 0xfffffe0057d89800 dirhash (dirhash) @ ufs/ufs/ufs_dirhash.c:284
KDB: stack backtrace:
db_trace_self_wrapper() at db_trace_self_wrapper+0x2b/frame 0xffffff881df1a300
kdb_backtrace() at kdb_backtrace+0x39/frame 0xffffff881df1a3b0
witness_checkorder() at witness_checkorder+0xd4f/frame 0xffffff881df1a440
_sx_xlock() at _sx_xlock+0x75/frame 0xffffff881df1a480
ufsdirhash_add() at ufsdirhash_add+0x4c/frame 0xffffff881df1a4c0
ufs_direnter() at ufs_direnter+0x688/frame 0xffffff881df1a580
ufs_mkdir() at ufs_mkdir+0x863/frame 0xffffff881df1a780
VOP_MKDIR_APV() at VOP_MKDIR_APV+0x10e/frame 0xffffff881df1a7b0
kern_mkdirat() at kern_mkdirat+0x20e/frame 0xffffff881df1a9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df1aab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df1aab0
--- syscall (136, FreeBSD ELF64, sys_mkdir), rip = 0x800931dca, rsp = 0x7fffffffd788, rbp = 0x7fffffffdc70 ---
Clearing /tmp (X related).
Starting nfsuserd.
Starting mountd.
Starting nfsd.
Updating motd:.
Mounting late file systems:.
Starting ntpd.
Starting powerd.
Configuring syscons: keymap blanktime.
Performing sanity check on sshd configuration.
Starting sshd.
Starting cron.
Local package initialization: backup watchdogd.
Starting default mousedmoused: unable to open /dev/psm0: No such file or directory
.

Wed Jul 31 09:35:32 CEST 2013

FreeBSD/amd64 (t2.osted.lan) (console)

login: Jul 31 09:35:47 t2 su: pho to root on /dev/pts/0
20130731 09:36:00 all (1/224): fuse.sh
fuse-freebsd: version 0.4.4, FUSE ABI 7.8
20130731 09:36:01 all (2/224): nullfs14.sh
lock order reversal:
 1st 0xfffffe00847fc2d8 ufs (ufs) @ kern/vfs_mount.c:1237
 2nd 0xfffffe0084af1068 devfs (devfs) @ ufs/ffs/ffs_vfsops.c:1411
KDB: stack backtrace:
db_trace_self_wrapper() at db_trace_self_wrapper+0x2b/frame 0xffffff881e0723a0
kdb_backtrace() at kdb_backtrace+0x39/frame 0xffffff881e072450
witness_checkorder() at witness_checkorder+0xd4f/frame 0xffffff881e0724e0
__lockmgr_args() at __lockmgr_args+0x6f2/frame 0xffffff881e072610
vop_stdlock() at vop_stdlock+0x3c/frame 0xffffff881e072630
VOP_LOCK1_APV() at VOP_LOCK1_APV+0xf5/frame 0xffffff881e072660
_vn_lock() at _vn_lock+0xc6/frame 0xffffff881e0726d0
ffs_flushfiles() at ffs_flushfiles+0x123/frame 0xffffff881e072740
softdep_flushfiles() at softdep_flushfiles+0x17f/frame 0xffffff881e0727a0
ffs_unmount() at ffs_unmount+0x1a2/frame 0xffffff881e072810
dounmount() at dounmount+0x39e/frame 0xffffff881e072890
sys_unmount() at sys_unmount+0x376/frame 0xffffff881e0729a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e072ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e072ab0
--- syscall (22, FreeBSD ELF64, sys_unmount), rip = 0x800885d8a, rsp = 0x7fffffffceb8, rbp = 0x7fffffffcfd0 ---
panic: pmap_demote_pde: oldpde is missing PG_PS and/or PG_V 0x0
cpuid = 19
KDB: enter: panic
[ thread pid 2002 tid 100239 ]
Stopped at      kdb_enter+0x3e: movq    $0,kdb_why
db> bt
Tracing pid 2002 tid 100239 td 0xfffffe0084a84000
kdb_enter() at kdb_enter+0x3e/frame 0xffffff881e02c530
vpanic() at vpanic+0x146/frame 0xffffff881e02c570
kassert_panic() at kassert_panic+0x136/frame 0xffffff881e02c5e0
pmap_demote_pde_locked() at pmap_demote_pde_locked+0x89/frame 0xffffff881e02c670
pmap_remove_pde() at pmap_remove_pde+0x2ed/frame 0xffffff881e02c700
pmap_remove() at pmap_remove+0x2a0/frame 0xffffff881e02c790
kmem_unback() at kmem_unback+0x9b/frame 0xffffff881e02c7f0
kmem_free() at kmem_free+0x6c/frame 0xffffff881e02c830
uma_large_free() at uma_large_free+0x55/frame 0xffffff881e02c850
free() at free+0x6f/frame 0xffffff881e02c890
nullfs_uninit() at nullfs_uninit+0x2c/frame 0xffffff881e02c8a0
vfs_modevent() at vfs_modevent+0x9f/frame 0xffffff881e02c8e0
module_unload() at module_unload+0x32/frame 0xffffff881e02c900
linker_file_unload() at linker_file_unload+0x14b/frame 0xffffff881e02c950
kern_kldunload() at kern_kldunload+0x100/frame 0xffffff881e02c9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e02cab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e02cab0
--- syscall (444, FreeBSD ELF64, sys_kldunloadf), rip = 0x80088238a, rsp = 0x7fffffffce78, rbp = 0x7fffffffd6e0 ---
db> run pho
db:0:pho> bt
Tracing pid 2002 tid 100239 td 0xfffffe0084a84000
kdb_enter() at kdb_enter+0x3e/frame 0xffffff881e02c530
vpanic() at vpanic+0x146/frame 0xffffff881e02c570
kassert_panic() at kassert_panic+0x136/frame 0xffffff881e02c5e0
pmap_demote_pde_locked() at pmap_demote_pde_locked+0x89/frame 0xffffff881e02c670
pmap_remove_pde() at pmap_remove_pde+0x2ed/frame 0xffffff881e02c700
pmap_remove() at pmap_remove+0x2a0/frame 0xffffff881e02c790
kmem_unback() at kmem_unback+0x9b/frame 0xffffff881e02c7f0
kmem_free() at kmem_free+0x6c/frame 0xffffff881e02c830
uma_large_free() at uma_large_free+0x55/frame 0xffffff881e02c850
free() at free+0x6f/frame 0xffffff881e02c890
nullfs_uninit() at nullfs_uninit+0x2c/frame 0xffffff881e02c8a0
vfs_modevent() at vfs_modevent+0x9f/frame 0xffffff881e02c8e0
module_unload() at module_unload+0x32/frame 0xffffff881e02c900
linker_file_unload() at linker_file_unload+0x14b/frame 0xffffff881e02c950
kern_kldunload() at kern_kldunload+0x100/frame 0xffffff881e02c9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e02cab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e02cab0
--- syscall (444, FreeBSD ELF64, sys_kldunloadf), rip = 0x80088238a, rsp = 0x7fffffffce78, rbp = 0x7fffffffd6e0 ---
db:0:bt>  show allpcpu
Current CPU: 19

cpuid        = 0
dynamic pcpu = 0x5d4480
curthread    = 0xfffffe0050040920: pid 11 "idle: cpu0"
curpcb       = 0xffffff881b5ecb80
fpcurthread  = none
idlethread   = 0xfffffe0050040920: tid 100003 "idle: cpu0"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9010
commontssp   = 0xffffffff815f9010
rsp0         = 0xffffff881b5ecb80
gs32p        = 0xffffffff815faa68
ldt          = 0xffffffff815faaa8
tss          = 0xffffffff815faa98
spin locks held:

cpuid        = 1
dynamic pcpu = 0xffffff8823c97480
curthread    = 0xfffffe0050040490: pid 11 "idle: cpu1"
curpcb       = 0xffffff881b5f1b80
fpcurthread  = none
idlethread   = 0xfffffe0050040490: tid 100004 "idle: cpu1"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9078
commontssp   = 0xffffffff815f9078
rsp0         = 0xffffff881b5f1b80
gs32p        = 0xffffffff815faad0
ldt          = 0xffffffff815fab10
tss          = 0xffffffff815fab00
spin locks held:

cpuid        = 2
dynamic pcpu = 0xffffff8823c9e480
curthread    = 0xfffffe0050040000: pid 11 "idle: cpu2"
curpcb       = 0xffffff881b5f6b80
fpcurthread  = none
idlethread   = 0xfffffe0050040000: tid 100005 "idle: cpu2"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f90e0
commontssp   = 0xffffffff815f90e0
rsp0         = 0xffffff881b5f6b80
gs32p        = 0xffffffff815fab38
ldt          = 0xffffffff815fab78
tss          = 0xffffffff815fab68
spin locks held:

cpuid        = 3
dynamic pcpu = 0xffffff889a1f1480
curthread    = 0xfffffe0050056000: pid 11 "idle: cpu3"
curpcb       = 0xffffff881b5fbb80
fpcurthread  = none
idlethread   = 0xfffffe0050056000: tid 100006 "idle: cpu3"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9148
commontssp   = 0xffffffff815f9148
rsp0         = 0xffffff881b5fbb80
gs32p        = 0xffffffff815faba0
ldt          = 0xffffffff815fabe0
tss          = 0xffffffff815fabd0
spin locks held:

cpuid        = 4
dynamic pcpu = 0xffffff889a1f8480
curthread    = 0xfffffe0050055920: pid 11 "idle: cpu4"
curpcb       = 0xffffff87a9c2cb80
fpcurthread  = none
idlethread   = 0xfffffe0050055920: tid 100007 "idle: cpu4"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f91b0
commontssp   = 0xffffffff815f91b0
rsp0         = 0xffffff87a9c2cb80
gs32p        = 0xffffffff815fac08
ldt          = 0xffffffff815fac48
tss          = 0xffffffff815fac38
spin locks held:

cpuid        = 5
dynamic pcpu = 0xffffff889a1ff480
curthread    = 0xfffffe0050055490: pid 11 "idle: cpu5"
curpcb       = 0xffffff87a9c31b80
fpcurthread  = none
idlethread   = 0xfffffe0050055490: tid 100008 "idle: cpu5"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9218
commontssp   = 0xffffffff815f9218
rsp0         = 0xffffff87a9c31b80
gs32p        = 0xffffffff815fac70
ldt          = 0xffffffff815facb0
tss          = 0xffffffff815faca0
spin locks held:

cpuid        = 6
dynamic pcpu = 0xffffff889a206480
curthread    = 0xfffffe0050055000: pid 11 "idle: cpu6"
curpcb       = 0xffffff87a9c36b80
fpcurthread  = none
idlethread   = 0xfffffe0050055000: tid 100009 "idle: cpu6"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9280
commontssp   = 0xffffffff815f9280
rsp0         = 0xffffff87a9c36b80
gs32p        = 0xffffffff815facd8
ldt          = 0xffffffff815fad18
tss          = 0xffffffff815fad08
spin locks held:

cpuid        = 7
dynamic pcpu = 0xffffff889a20d480
curthread    = 0xfffffe0050046920: pid 11 "idle: cpu7"
curpcb       = 0xffffff87a9c3bb80
fpcurthread  = none
idlethread   = 0xfffffe0050046920: tid 100010 "idle: cpu7"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f92e8
commontssp   = 0xffffffff815f92e8
rsp0         = 0xffffff87a9c3bb80
gs32p        = 0xffffffff815fad40
ldt          = 0xffffffff815fad80
tss          = 0xffffffff815fad70
spin locks held:

cpuid        = 8
dynamic pcpu = 0xffffff889a214480
curthread    = 0xfffffe0050057920: pid 11 "idle: cpu8"
curpcb       = 0xffffff87a9c40b80
fpcurthread  = none
idlethread   = 0xfffffe0050057920: tid 100011 "idle: cpu8"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9350
commontssp   = 0xffffffff815f9350
rsp0         = 0xffffff87a9c40b80
gs32p        = 0xffffffff815fada8
ldt          = 0xffffffff815fade8
tss          = 0xffffffff815fadd8
spin locks held:

cpuid        = 9
dynamic pcpu = 0xffffff889a21b480
curthread    = 0xfffffe0050057490: pid 11 "idle: cpu9"
curpcb       = 0xffffff87a9c45b80
fpcurthread  = none
idlethread   = 0xfffffe0050057490: tid 100012 "idle: cpu9"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f93b8
commontssp   = 0xffffffff815f93b8
rsp0         = 0xffffff87a9c45b80
gs32p        = 0xffffffff815fae10
ldt          = 0xffffffff815fae50
tss          = 0xffffffff815fae40
spin locks held:

cpuid        = 10
dynamic pcpu = 0xffffff889a222480
curthread    = 0xfffffe0050057000: pid 11 "idle: cpu10"
curpcb       = 0xffffff87a9c4ab80
fpcurthread  = none
idlethread   = 0xfffffe0050057000: tid 100013 "idle: cpu10"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9420
commontssp   = 0xffffffff815f9420
rsp0         = 0xffffff87a9c4ab80
gs32p        = 0xffffffff815fae78
ldt          = 0xffffffff815faeb8
tss          = 0xffffffff815faea8
spin locks held:

cpuid        = 11
dynamic pcpu = 0xffffff889a229480
curthread    = 0xfffffe0050056920: pid 11 "idle: cpu11"
curpcb       = 0xffffff87a9c4fb80
fpcurthread  = none
idlethread   = 0xfffffe0050056920: tid 100014 "idle: cpu11"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9488
commontssp   = 0xffffffff815f9488
rsp0         = 0xffffff87a9c4fb80
gs32p        = 0xffffffff815faee0
ldt          = 0xffffffff815faf20
tss          = 0xffffffff815faf10
spin locks held:

cpuid        = 12
dynamic pcpu = 0xffffff889a230480
curthread    = 0xfffffe0050056490: pid 11 "idle: cpu12"
curpcb       = 0xffffff87a9c54b80
fpcurthread  = none
idlethread   = 0xfffffe0050056490: tid 100015 "idle: cpu12"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f94f0
commontssp   = 0xffffffff815f94f0
rsp0         = 0xffffff87a9c54b80
gs32p        = 0xffffffff815faf48
ldt          = 0xffffffff815faf88
tss          = 0xffffffff815faf78
spin locks held:

cpuid        = 13
dynamic pcpu = 0xffffff889a237480
curthread    = 0xfffffe0050059490: pid 11 "idle: cpu13"
curpcb       = 0xffffff87a9c59b80
fpcurthread  = none
idlethread   = 0xfffffe0050059490: tid 100016 "idle: cpu13"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9558
commontssp   = 0xffffffff815f9558
rsp0         = 0xffffff87a9c59b80
gs32p        = 0xffffffff815fafb0
ldt          = 0xffffffff815faff0
tss          = 0xffffffff815fafe0
spin locks held:

cpuid        = 14
dynamic pcpu = 0xffffff889a23e480
curthread    = 0xfffffe0050059000: pid 11 "idle: cpu14"
curpcb       = 0xffffff87a9c5eb80
fpcurthread  = none
idlethread   = 0xfffffe0050059000: tid 100017 "idle: cpu14"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f95c0
commontssp   = 0xffffffff815f95c0
rsp0         = 0xffffff87a9c5eb80
gs32p        = 0xffffffff815fb018
ldt          = 0xffffffff815fb058
tss          = 0xffffffff815fb048
spin locks held:

cpuid        = 15
dynamic pcpu = 0xffffff889a245480
curthread    = 0xfffffe0050058920: pid 11 "idle: cpu15"
curpcb       = 0xffffff87a9c63b80
fpcurthread  = none
idlethread   = 0xfffffe0050058920: tid 100018 "idle: cpu15"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9628
commontssp   = 0xffffffff815f9628
rsp0         = 0xffffff87a9c63b80
gs32p        = 0xffffffff815fb080
ldt          = 0xffffffff815fb0c0
tss          = 0xffffffff815fb0b0
spin locks held:

cpuid        = 16
dynamic pcpu = 0xffffff889a24c480
curthread    = 0xfffffe0050058490: pid 11 "idle: cpu16"
curpcb       = 0xffffff87a9c68b80
fpcurthread  = none
idlethread   = 0xfffffe0050058490: tid 100019 "idle: cpu16"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9690
commontssp   = 0xffffffff815f9690
rsp0         = 0xffffff87a9c68b80
gs32p        = 0xffffffff815fb0e8
ldt          = 0xffffffff815fb128
tss          = 0xffffffff815fb118
spin locks held:

cpuid        = 17
dynamic pcpu = 0xffffff889a253480
curthread    = 0xfffffe0050058000: pid 11 "idle: cpu17"
curpcb       = 0xffffff87a9c6db80
fpcurthread  = none
idlethread   = 0xfffffe0050058000: tid 100020 "idle: cpu17"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f96f8
commontssp   = 0xffffffff815f96f8
rsp0         = 0xffffff87a9c6db80
gs32p        = 0xffffffff815fb150
ldt          = 0xffffffff815fb190
tss          = 0xffffffff815fb180
spin locks held:

cpuid        = 18
dynamic pcpu = 0xffffff889a25a480
curthread    = 0xfffffe005005b000: pid 11 "idle: cpu18"
curpcb       = 0xffffff87a9c72b80
fpcurthread  = none
idlethread   = 0xfffffe005005b000: tid 100021 "idle: cpu18"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9760
commontssp   = 0xffffffff815f9760
rsp0         = 0xffffff87a9c72b80
gs32p        = 0xffffffff815fb1b8
ldt          = 0xffffffff815fb1f8
tss          = 0xffffffff815fb1e8
spin locks held:

cpuid        = 19
dynamic pcpu = 0xffffff889a261480
curthread    = 0xfffffe0084a84000: pid 2002 "kldunload"
curpcb       = 0xffffff881e02cb80
fpcurthread  = 0xfffffe0084a84000: pid 2002 "kldunload"
idlethread   = 0xfffffe005005a920: tid 100022 "idle: cpu19"
curpmap      = 0xfffffe0057cd3a98
tssp         = 0xffffffff815f97c8
commontssp   = 0xffffffff815f97c8
rsp0         = 0xffffff881e02cb80
gs32p        = 0xffffffff815fb220
ldt          = 0xffffffff815fb260
tss          = 0xffffffff815fb250
spin locks held:

cpuid        = 20
dynamic pcpu = 0xffffff889a268480
curthread    = 0xfffffe005005a490: pid 11 "idle: cpu20"
curpcb       = 0xffffff87a9c7cb80
fpcurthread  = none
idlethread   = 0xfffffe005005a490: tid 100023 "idle: cpu20"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9830
commontssp   = 0xffffffff815f9830
rsp0         = 0xffffff87a9c7cb80
gs32p        = 0xffffffff815fb288
ldt          = 0xffffffff815fb2c8
tss          = 0xffffffff815fb2b8
spin locks held:

cpuid        = 21
dynamic pcpu = 0xffffff889a26f480
curthread    = 0xfffffe005005a000: pid 11 "idle: cpu21"
curpcb       = 0xffffff87a9c81b80
fpcurthread  = none
idlethread   = 0xfffffe005005a000: tid 100024 "idle: cpu21"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9898
commontssp   = 0xffffffff815f9898
rsp0         = 0xffffff87a9c81b80
gs32p        = 0xffffffff815fb2f0
ldt          = 0xffffffff815fb330
tss          = 0xffffffff815fb320
spin locks held:

cpuid        = 22
dynamic pcpu = 0xffffff889a276480
curthread    = 0xfffffe0050059920: pid 11 "idle: cpu22"
curpcb       = 0xffffff87a9c86b80
fpcurthread  = none
idlethread   = 0xfffffe0050059920: tid 100025 "idle: cpu22"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9900
commontssp   = 0xffffffff815f9900
rsp0         = 0xffffff87a9c86b80
gs32p        = 0xffffffff815fb358
ldt          = 0xffffffff815fb398
tss          = 0xffffffff815fb388
spin locks held:

cpuid        = 23
dynamic pcpu = 0xffffff889a27d480
curthread    = 0xfffffe005005c920: pid 11 "idle: cpu23"
curpcb       = 0xffffff87a9c8bb80
fpcurthread  = none
idlethread   = 0xfffffe005005c920: tid 100026 "idle: cpu23"
curpmap      = 0xffffffff815e2298
tssp         = 0xffffffff815f9968
commontssp   = 0xffffffff815f9968
rsp0         = 0xffffff87a9c8bb80
gs32p        = 0xffffffff815fb3c0
ldt          = 0xffffffff815fb400
tss          = 0xffffffff815fb3f0
spin locks held:

db:0:allpcpu>  show alllocks
Process 2002 (kldunload) thread 0xfffffe0084a84000 (100239)
exclusive sleep mutex pmap (pmap) r = 0 (0xffffffff81612050) locked @ amd64/amd64/pmap.c:2942
shared rw pmap pv global (pmap pv global) r = 0 (0xffffffff81593400) locked @ amd64/amd64/pmap.c:2941
exclusive sleep mutex Giant (Giant) r = 0 (0xffffffff815e26a8) locked @ kern/kern_module.c:264
exclusive sx kernel linker (kernel linker) r = 0 (0xffffffff81393438) locked @ kern/kern_linker.c:1099
db:0:alllocks>  show lockedvnods
Locked vnodes
db:0:lockedvnods>  show mount
0xfffffe005745ab58 /dev/da0p2 on / (ufs)
0xfffffe005745b000 devfs on /dev (devfs)
0xfffffe0057df33c8 /dev/da0p3 on /tmp (ufs)
0xfffffe0057e01790 procfs on /proc (procfs)

More info: show mount <addr>
db:0:mount> ps
  pid  ppid  pgrp   uid   state   wmesg         wchan        cmd
 2002  2001  1086     0  R+      CPU 19                      kldunload
 2001  1914  1086     0  S+      wait     0xfffffe007604d970 xargs
 1914  1086  1086     0  S+      wait     0xfffffe005756c970 sh
 1086  1082  1086     0  S+      wait     0xfffffe00574ca4b8 sh
 1082  1080  1082     0  S+      wait     0xfffffe0057fd5000 bash
 1080  1079  1080     0  S+      pause    0xfffffe0084b5d560 csh
 1079  1070  1079  1001  S+      wait     0xfffffe005756c000 su
 1070  1069  1070  1001  Ss+     wait     0xfffffe0084b454b8 bash
 1069  1067  1067  1001  S       select   0xfffffe0057c76040 sshd
 1067   968  1067     0  Ss      select   0xfffffe0057d3d240 sshd
 1065     1  1065     0  Ss+     ttyin    0xfffffe0050138ca8 getty
 1064     1  1064     0  Ss+     ttyin    0xfffffe00501390a8 getty
 1063     1  1063     0  Ss+     ttyin    0xfffffe00501394a8 getty
 1062     1  1062     0  Ss+     ttyin    0xfffffe00501398a8 getty
 1061     1  1061     0  Ss+     ttyin    0xfffffe0050139ca8 getty
 1060     1  1060     0  Ss+     ttyin    0xfffffe005013a0a8 getty
 1059     1  1059     0  Ss+     ttyin    0xfffffe005013a4a8 getty
 1058     1  1058     0  Ss+     ttyin    0xfffffe005013a8a8 getty
 1057     1  1057     0  Ss+     ttyin    0xfffffe005013aca8 getty
  990     1   990     0  Ss      nanslp   0xffffffff81396955 watchdogd
  978     1   978     0  Ss      nanslp   0xffffffff81396953 cron
  974     1   974    25  Ss      pause    0xfffffe0084a83560 sendmail
  971     1   971     0  Ss      select   0xfffffe0057d7d0c0 sendmail
  968     1   968     0  Ss      select   0xfffffe0057a37bc0 sshd
  940     1   940     0  Ss      select   0xfffffe0057d632c0 powerd
  937     1   937     0  Ss      select   0xfffffe00571b8ac0 ntpd
  900   897   897     0  S       (threaded)                  nfsd
100198                   S       rpcsvc   0xfffffe0084471f20 nfsd: service
100197                   S       rpcsvc   0xfffffe0084488020 nfsd: service
100196                   S       rpcsvc   0xfffffe00848d1b20 nfsd: service
100195                   S       rpcsvc   0xfffffe0057d9f620 nfsd: master
  897     1   897     0  Ss      select   0xfffffe0057dad240 nfsd
  891     1   891     0  Ss      select   0xfffffe0057087bc0 mountd
  884   880   880     0  S       select   0xfffffe0057d7d240 nfsuserd
  883   880   880     0  S       select   0xfffffe0057c04040 nfsuserd
  882   880   880     0  S       select   0xfffffe0057dad3c0 nfsuserd
  881   880   880     0  S       select   0xfffffe00571d29c0 nfsuserd
  880     1   880     0  Ss      pause    0xfffffe0057f70560 nfsuserd
  851     1   851     0  Ss      select   0xfffffe0057c760c0 rpcbind
  838     1   838     0  Ss      select   0xfffffe00572d2c40 syslogd
  709     1   709     0  Ss      select   0xfffffe00572d2cc0 devd
  692     1   692     0  Ss      select   0xfffffe00844c2f40 moused
  671     1   671     0  Ss      select   0xfffffe0057087c40 moused
   17     0     0     0  DL      sdflush  0xffffffff8158b9fc [softdepflush]
   16     0     0     0  DL      vlruwt   0xfffffe005712f4b8 [vnlru]
    9     0     0     0  DL      syncer   0xffffffff81584d30 [syncer]
    8     0     0     0  DL      psleep   0xffffffff81584704 [bufdaemon]
    7     0     0     0  DL      pgzero   0xffffffff8158d4ec [pagezero]
    6     0     0     0  DL      psleep   0xffffffff8158c740 [vmdaemon]
    5     0     0     0  DL      psleep   0xffffffff815f8d84 [pagedaemon]
    4     0     0     0  DL      idle     0xfffffe005003f970 [enc_daemon0]
    3     0     0     0  DL      ccb_scan 0xffffffff813609b0 [xpt_thrd]
    2     0     0     0  DL      waiting_ 0xffffffff815ece08 [sctp_iterator]
   15     0     0     0  DL      (threaded)                  [usb]
100119                   D       -        0xffffff802024ae18 [usbus2]
100118                   D       -        0xffffff802024adc0 [usbus2]
100117                   D       -        0xffffff802024ad68 [usbus2]
100116                   D       -        0xffffff802024ad10 [usbus2]
100114                   D       -        0xffffff80203921b0 [usbus1]
100113                   D       -        0xffffff8020392158 [usbus1]
100112                   D       -        0xffffff8020392100 [usbus1]
100111                   D       -        0xffffff80203920a8 [usbus1]
100074                   D       -        0xffffff8020072e18 [usbus0]
100073                   D       -        0xffffff8020072dc0 [usbus0]
100072                   D       -        0xffffff8020072d68 [usbus0]
100071                   D       -        0xffffff8020072d10 [usbus0]
   14     0     0     0  DL      -        0xffffffff81379c08 [yarrow]
   13     0     0     0  DL      (threaded)                  [geom]
100055                   D       -        0xffffffff815e1730 [g_down]
100054                   D       -        0xffffffff815e1728 [g_up]
100053                   D       -        0xffffffff815e1720 [g_event]
   12     0     0     0  WL      (threaded)                  [intr]
100122                   I                                   [swi0: uart]
100121                   I                                   [irq287: hdac1]
100120                   I                                   [irq286: ahci0]
100115                   I                                   [irq20: ehci1]
100110                   I                                   [irq285: xhci0]
100109                   I                                   [irq284: igb1:link]
100107                   I                                   [irq283: igb1:que 7]
100105                   I                                   [irq282: igb1:que 6]
100103                   I                                   [irq281: igb1:que 5]
100101                   I                                   [irq280: igb1:que 4]
100099                   I                                   [irq279: igb1:que 3]
100097                   I                                   [irq278: igb1:que 2]
100095                   I                                   [irq277: igb1:que 1]
100093                   I                                   [irq276: igb1:que 0]
100092                   I                                   [irq275: igb0:link]
100090                   I                                   [irq274: igb0:que 7]
100088                   I                                   [irq273: igb0:que 6]
100086                   I                                   [irq272: igb0:que 5]
100084                   I                                   [irq271: igb0:que 4]
100082                   I                                   [irq270: igb0:que 3]
100080                   I                                   [irq269: igb0:que 2]
100078                   I                                   [irq268: igb0:que 1]
100076                   I                                   [irq267: igb0:que 0]
100075                   I                                   [irq266: hdac0]
100070                   I                                   [irq22: ehci0]
100069                   I                                   [irq265: isci0]
100068                   I                                   [irq264: isci0]
100067                   I                                   [swi5: fast taskq]
100064                   I                                   [swi6: Giant taskq]
100063                   I                                   [swi6: task queue]
100058                   I                                   [swi2: cambio]
100052                   I                                   [swi4: clock]
100051                   I                                   [swi4: clock]
100050                   I                                   [swi4: clock]
100049                   I                                   [swi4: clock]
100048                   I                                   [swi4: clock]
100047                   I                                   [swi4: clock]
100046                   I                                   [swi4: clock]
100045                   I                                   [swi4: clock]
100044                   I                                   [swi4: clock]
100043                   I                                   [swi4: clock]
100042                   I                                   [swi4: clock]
100041                   I                                   [swi4: clock]
100040                   I                                   [swi4: clock]
100039                   I                                   [swi4: clock]
100038                   I                                   [swi4: clock]
100037                   I                                   [swi4: clock]
100036                   I                                   [swi4: clock]
100035                   I                                   [swi4: clock]
100034                   I                                   [swi4: clock]
100033                   I                                   [swi4: clock]
100032                   I                                   [swi4: clock]
100031                   I                                   [swi4: clock]
100030                   I                                   [swi4: clock]
100029                   I                                   [swi4: clock]
100028                   I                                   [swi1: netisr 0]
100027                   I                                   [swi3: vm]
   11     0     0     0  RL      (threaded)                  [idle]
100026                   Run     CPU 23                      [idle: cpu23]
100025                   Run     CPU 22                      [idle: cpu22]
100024                   Run     CPU 21                      [idle: cpu21]
100023                   Run     CPU 20                      [idle: cpu20]
100022                   CanRun                              [idle: cpu19]
100021                   Run     CPU 18                      [idle: cpu18]
100020                   Run     CPU 17                      [idle: cpu17]
100019                   Run     CPU 16                      [idle: cpu16]
100018                   Run     CPU 15                      [idle: cpu15]
100017                   Run     CPU 14                      [idle: cpu14]
100016                   Run     CPU 13                      [idle: cpu13]
100015                   Run     CPU 12                      [idle: cpu12]
100014                   Run     CPU 11                      [idle: cpu11]
100013                   Run     CPU 10                      [idle: cpu10]
100012                   Run     CPU 9                       [idle: cpu9]
100011                   Run     CPU 8                       [idle: cpu8]
100010                   Run     CPU 7                       [idle: cpu7]
100009                   Run     CPU 6                       [idle: cpu6]
100008                   Run     CPU 5                       [idle: cpu5]
100007                   Run     CPU 4                       [idle: cpu4]
100006                   Run     CPU 3                       [idle: cpu3]
100005                   Run     CPU 2                       [idle: cpu2]
100004                   Run     CPU 1                       [idle: cpu1]
100003                   Run     CPU 0                       [idle: cpu0]
    1     0     1     0  SLs     wait     0xfffffe005003f000 [init]
   10     0     0     0  DL      audit_wo 0xffffffff815f0578 [audit]
    0     0     0     0  DLs     (threaded)                  [kernel]
100124                   D       -        0xffffffff813957a3 [deadlkres]
100123                   D       -        0xfffffe00516a0d00 [mca taskq]
100108                   D       -        0xfffffe00516a2600 [igb1 que]
100106                   D       -        0xfffffe00516a2900 [igb1 que]
100104                   D       -        0xfffffe00516a2c00 [igb1 que]
100102                   D       -        0xfffffe00516a3000 [igb1 que]
100100                   D       -        0xfffffe0050036100 [igb1 que]
100098                   D       -        0xfffffe0050036400 [igb1 que]
100096                   D       -        0xfffffe0050036700 [igb1 que]
100094                   D       -        0xfffffe0050036a00 [igb1 que]
100091                   D       -        0xfffffe0050036e00 [igb0 que]
100089                   D       -        0xfffffe005021a200 [igb0 que]
100087                   D       -        0xfffffe005021a500 [igb0 que]
100085                   D       -        0xfffffe005021a800 [igb0 que]
100083                   D       -        0xfffffe005021ab00 [igb0 que]
100081                   D       -        0xfffffe005021ae00 [igb0 que]
100079                   D       -        0xfffffe005021b200 [igb0 que]
100077                   D       -        0xfffffe005021b500 [igb0 que]
100066                   D       -        0xfffffe005021c400 [thread taskq]
100065                   D       -        0xfffffe005021c600 [ffs_trim taskq]
100062                   D       -        0xfffffe005021cc00 [kqueue taskq]
100061                   D       -        0xfffffe005021d100 [acpi_task_2]
100060                   D       -        0xfffffe005021d100 [acpi_task_1]
100059                   D       -        0xfffffe005021d100 [acpi_task_0]
100056                   D       -        0xfffffe0050032400 [firmware taskq]
100000                   D       swapin   0xffffffff815e1828 [swapper]
db:0:ps>  allt

Tracing command kldunload pid 2002 tid 100239 td 0xfffffe0084a84000
kdb_enter() at kdb_enter+0x3e/frame 0xffffff881e02c530
vpanic() at vpanic+0x146/frame 0xffffff881e02c570
kassert_panic() at kassert_panic+0x136/frame 0xffffff881e02c5e0
pmap_demote_pde_locked() at pmap_demote_pde_locked+0x89/frame 0xffffff881e02c670
pmap_remove_pde() at pmap_remove_pde+0x2ed/frame 0xffffff881e02c700
pmap_remove() at pmap_remove+0x2a0/frame 0xffffff881e02c790
kmem_unback() at kmem_unback+0x9b/frame 0xffffff881e02c7f0
kmem_free() at kmem_free+0x6c/frame 0xffffff881e02c830
uma_large_free() at uma_large_free+0x55/frame 0xffffff881e02c850
free() at free+0x6f/frame 0xffffff881e02c890
nullfs_uninit() at nullfs_uninit+0x2c/frame 0xffffff881e02c8a0
vfs_modevent() at vfs_modevent+0x9f/frame 0xffffff881e02c8e0
module_unload() at module_unload+0x32/frame 0xffffff881e02c900
linker_file_unload() at linker_file_unload+0x14b/frame 0xffffff881e02c950
kern_kldunload() at kern_kldunload+0x100/frame 0xffffff881e02c9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e02cab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e02cab0
--- syscall (444, FreeBSD ELF64, sys_kldunloadf), rip = 0x80088238a, rsp = 0x7fffffffce78, rbp = 0x7fffffffd6e0 ---

Tracing command xargs pid 2001 tid 100261 td 0xfffffe0076020000
sched_switch() at sched_switch+0x482/frame 0xffffff881e09a560
mi_switch() at mi_switch+0x179/frame 0xffffff881e09a5a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881e09a5e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881e09a650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881e09a680
_sleep() at _sleep+0x320/frame 0xffffff881e09a710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881e09a7b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881e09a9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e09aab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e09aab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x80089e20a, rsp = 0x7fffffffd5f8, rbp = 0x7fffffffd630 ---

Tracing command sh pid 1914 tid 100136 td 0xfffffe0057583000
sched_switch() at sched_switch+0x482/frame 0xffffff881de0b560
mi_switch() at mi_switch+0x179/frame 0xffffff881de0b5a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de0b5e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de0b650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881de0b680
_sleep() at _sleep+0x320/frame 0xffffff881de0b710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881de0b7b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881de0b9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de0bab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de0bab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x800d3320a, rsp = 0x7fffffffd748, rbp = 0x7fffffffd7f0 ---

Tracing command sh pid 1086 tid 100231 td 0xfffffe00574d3920
sched_switch() at sched_switch+0x482/frame 0xffffff881e004560
mi_switch() at mi_switch+0x179/frame 0xffffff881e0045a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881e0045e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881e004650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881e004680
_sleep() at _sleep+0x320/frame 0xffffff881e004710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881e0047b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881e0049a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881e004ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881e004ab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x800d3320a, rsp = 0x7fffffffd328, rbp = 0x7fffffffd3d0 ---

Tracing command bash pid 1082 tid 100210 td 0xfffffe0057fd6490
sched_switch() at sched_switch+0x482/frame 0xffffff881df97560
mi_switch() at mi_switch+0x179/frame 0xffffff881df975a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df975e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df97650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df97680
_sleep() at _sleep+0x320/frame 0xffffff881df97710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881df977b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881df979a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df97ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df97ab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x80109c20a, rsp = 0x7fffffffd268, rbp = 0x7fffffffd2b0 ---

Tracing command csh pid 1080 tid 100214 td 0xfffffe0084b5e920
sched_switch() at sched_switch+0x482/frame 0xffffff881dfab760
mi_switch() at mi_switch+0x179/frame 0xffffff881dfab7a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfab7e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfab850
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfab880
_sleep() at _sleep+0x320/frame 0xffffff881dfab910
kern_sigsuspend() at kern_sigsuspend+0xcd/frame 0xffffff881dfab970
sys_sigsuspend() at sys_sigsuspend+0x31/frame 0xffffff881dfab9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfabab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfabab0
--- syscall (4, FreeBSD ELF64, sys_write), rip = 0x800d44c2a, rsp = 0x7fffffffcdc8, rbp = 0x7fffffffce40 ---

Tracing command su pid 1079 tid 100171 td 0xfffffe0057577490
sched_switch() at sched_switch+0x482/frame 0xffffff881deba560
mi_switch() at mi_switch+0x179/frame 0xffffff881deba5a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881deba5e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881deba650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881deba680
_sleep() at _sleep+0x320/frame 0xffffff881deba710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881deba7b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881deba9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881debaab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881debaab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x800ed520a, rsp = 0x7fffffffd468, rbp = 0x7fffffffd9d0 ---

Tracing command bash pid 1070 tid 100213 td 0xfffffe0084b10920
sched_switch() at sched_switch+0x482/frame 0xffffff881dfa6560
mi_switch() at mi_switch+0x179/frame 0xffffff881dfa65a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfa65e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfa6650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfa6680
_sleep() at _sleep+0x320/frame 0xffffff881dfa6710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881dfa67b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881dfa69a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfa6ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfa6ab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x80109c20a, rsp = 0x7fffffffd4d8, rbp = 0x7fffffffd520 ---

Tracing command sshd pid 1069 tid 100227 td 0xfffffe0084c06920
sched_switch() at sched_switch+0x482/frame 0xffffff881dfec590
mi_switch() at mi_switch+0x179/frame 0xffffff881dfec5d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfec610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfec680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfec6b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfec720
seltdwait() at seltdwait+0x78/frame 0xffffff881dfec760
kern_select() at kern_select+0x892/frame 0xffffff881dfec960
sys_select() at sys_select+0x54/frame 0xffffff881dfec9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfecab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfecab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80257526a, rsp = 0x7fffffffd168, rbp = 0x7fffffffd1d0 ---

Tracing command sshd pid 1067 tid 100211 td 0xfffffe0084b5f000
sched_switch() at sched_switch+0x482/frame 0xffffff881df9c630
mi_switch() at mi_switch+0x179/frame 0xffffff881df9c670
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df9c6b0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df9c720
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df9c750
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881df9c7c0
seltdwait() at seltdwait+0x78/frame 0xffffff881df9c800
sys_poll() at sys_poll+0x38c/frame 0xffffff881df9c9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df9cab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df9cab0
--- syscall (209, FreeBSD ELF64, sys_poll), rip = 0x80250d6fa, rsp = 0x7fffffffd1f8, rbp = 0x7fffffffd250 ---

Tracing command getty pid 1065 tid 100226 td 0xfffffe0084c45000
sched_switch() at sched_switch+0x482/frame 0xffffff881dfe7620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfe7660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfe76a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfe7710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfe7740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfe77b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfe77e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfe7840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfe7870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfe78d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfe7910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfe7950
sys_read() at sys_read+0x63/frame 0xffffff881dfe79a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfe7ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfe7ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1064 tid 100225 td 0xfffffe0084c45490
sched_switch() at sched_switch+0x482/frame 0xffffff881dfe2620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfe2660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfe26a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfe2710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfe2740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfe27b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfe27e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfe2840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfe2870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfe28d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfe2910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfe2950
sys_read() at sys_read+0x63/frame 0xffffff881dfe29a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfe2ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfe2ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1063 tid 100224 td 0xfffffe0084c45920
sched_switch() at sched_switch+0x482/frame 0xffffff881dfdd620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfdd660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfdd6a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfdd710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfdd740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfdd7b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfdd7e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfdd840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfdd870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfdd8d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfdd910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfdd950
sys_read() at sys_read+0x63/frame 0xffffff881dfdd9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfddab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfddab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1062 tid 100223 td 0xfffffe0084c46000
sched_switch() at sched_switch+0x482/frame 0xffffff881dfd8620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfd8660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfd86a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfd8710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfd8740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfd87b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfd87e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfd8840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfd8870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfd88d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfd8910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfd8950
sys_read() at sys_read+0x63/frame 0xffffff881dfd89a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfd8ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfd8ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1061 tid 100222 td 0xfffffe0084b5f490
sched_switch() at sched_switch+0x482/frame 0xffffff881dfd3620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfd3660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfd36a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfd3710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfd3740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfd37b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfd37e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfd3840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfd3870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfd38d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfd3910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfd3950
sys_read() at sys_read+0x63/frame 0xffffff881dfd39a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfd3ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfd3ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1060 tid 100221 td 0xfffffe0084b5f920
sched_switch() at sched_switch+0x482/frame 0xffffff881dfce620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfce660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfce6a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfce710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfce740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfce7b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfce7e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfce840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfce870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfce8d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfce910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfce950
sys_read() at sys_read+0x63/frame 0xffffff881dfce9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfceab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfceab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1059 tid 100220 td 0xfffffe0084b10000
sched_switch() at sched_switch+0x482/frame 0xffffff881dfc9620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfc9660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfc96a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfc9710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfc9740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfc97b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfc97e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfc9840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfc9870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfc98d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfc9910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfc9950
sys_read() at sys_read+0x63/frame 0xffffff881dfc99a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfc9ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfc9ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1058 tid 100219 td 0xfffffe0084b10490
sched_switch() at sched_switch+0x482/frame 0xffffff881dfc4620
mi_switch() at mi_switch+0x179/frame 0xffffff881dfc4660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dfc46a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dfc4710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881dfc4740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881dfc47b0
tty_wait() at tty_wait+0x42/frame 0xffffff881dfc47e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881dfc4840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881dfc4870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881dfc48d0
dofileread() at dofileread+0x7b/frame 0xffffff881dfc4910
kern_readv() at kern_readv+0x48/frame 0xffffff881dfc4950
sys_read() at sys_read+0x63/frame 0xffffff881dfc49a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dfc4ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dfc4ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command getty pid 1057 tid 100135 td 0xfffffe00574d3490
sched_switch() at sched_switch+0x482/frame 0xffffff881de06620
mi_switch() at mi_switch+0x179/frame 0xffffff881de06660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de066a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de06710
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881de06740
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881de067b0
tty_wait() at tty_wait+0x42/frame 0xffffff881de067e0
ttydisc_read() at ttydisc_read+0x353/frame 0xffffff881de06840
ttydev_read() at ttydev_read+0x6d/frame 0xffffff881de06870
devfs_read_f() at devfs_read_f+0x7f/frame 0xffffff881de068d0
dofileread() at dofileread+0x7b/frame 0xffffff881de06910
kern_readv() at kern_readv+0x48/frame 0xffffff881de06950
sys_read() at sys_read+0x63/frame 0xffffff881de069a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de06ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de06ab0
--- syscall (3, FreeBSD ELF64, sys_read), rip = 0x800b582ea, rsp = 0x7fffffffdc98, rbp = 0x7fffffffdcd0 ---

Tracing command watchdogd pid 990 tid 100153 td 0xfffffe0057f53000
sched_switch() at sched_switch+0x482/frame 0xffffff881de60750
mi_switch() at mi_switch+0x179/frame 0xffffff881de60790
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de607d0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de60840
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881de60870
_sleep() at _sleep+0x300/frame 0xffffff881de60900
kern_nanosleep() at kern_nanosleep+0x10e/frame 0xffffff881de60960
sys_nanosleep() at sys_nanosleep+0x53/frame 0xffffff881de609a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de60ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de60ab0
--- syscall (240, FreeBSD ELF64, sys_nanosleep), rip = 0x800b353ca, rsp = 0x7fffffffdb18, rbp = 0x7fffffffdb70 ---

Tracing command cron pid 978 tid 100206 td 0xfffffe0084394920
sched_switch() at sched_switch+0x482/frame 0xffffff881df83750
mi_switch() at mi_switch+0x179/frame 0xffffff881df83790
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df837d0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df83840
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df83870
_sleep() at _sleep+0x300/frame 0xffffff881df83900
kern_nanosleep() at kern_nanosleep+0x10e/frame 0xffffff881df83960
sys_nanosleep() at sys_nanosleep+0x53/frame 0xffffff881df839a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df83ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df83ab0
--- syscall (240, FreeBSD ELF64, sys_nanosleep), rip = 0x800d473ca, rsp = 0x7fffffffdb28, rbp = 0x7fffffffdd00 ---

Tracing command sendmail pid 974 tid 100205 td 0xfffffe0084a84920
sched_switch() at sched_switch+0x482/frame 0xffffff881df7e760
mi_switch() at mi_switch+0x179/frame 0xffffff881df7e7a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df7e7e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df7e850
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df7e880
_sleep() at _sleep+0x320/frame 0xffffff881df7e910
kern_sigsuspend() at kern_sigsuspend+0xcd/frame 0xffffff881df7e970
sys_sigsuspend() at sys_sigsuspend+0x31/frame 0xffffff881df7e9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df7eab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df7eab0
--- syscall (4, FreeBSD ELF64, sys_write), rip = 0x801392c2a, rsp = 0x7fffffffc818, rbp = 0x7fffffffc830 ---

Tracing command sendmail pid 971 tid 100204 td 0xfffffe0057b20920
sched_switch() at sched_switch+0x482/frame 0xffffff881df79580
mi_switch() at mi_switch+0x179/frame 0xffffff881df795c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df79600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df79670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df796a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df79720
seltdwait() at seltdwait+0x8b/frame 0xffffff881df79760
kern_select() at kern_select+0x892/frame 0xffffff881df79960
sys_select() at sys_select+0x54/frame 0xffffff881df799a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df79ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df79ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80145226a, rsp = 0x7fffffffbd18, rbp = 0x7fffffffc810 ---

Tracing command sshd pid 968 tid 100203 td 0xfffffe00574cb490
sched_switch() at sched_switch+0x482/frame 0xffffff881df74590
mi_switch() at mi_switch+0x179/frame 0xffffff881df745d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df74610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df74680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df746b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881df74720
seltdwait() at seltdwait+0x78/frame 0xffffff881df74760
kern_select() at kern_select+0x892/frame 0xffffff881df74960
sys_select() at sys_select+0x54/frame 0xffffff881df749a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df74ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df74ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80257526a, rsp = 0x7fffffffd288, rbp = 0x7fffffffdd10 ---

Tracing command powerd pid 940 tid 100186 td 0xfffffe0057583490
sched_switch() at sched_switch+0x482/frame 0xffffff881df1f580
mi_switch() at mi_switch+0x179/frame 0xffffff881df1f5c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df1f600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df1f670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df1f6a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df1f720
seltdwait() at seltdwait+0x8b/frame 0xffffff881df1f760
kern_select() at kern_select+0x892/frame 0xffffff881df1f960
sys_select() at sys_select+0x54/frame 0xffffff881df1f9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df1fab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df1fab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x800b5626a, rsp = 0x7fffffffdb88, rbp = 0x7fffffffdd00 ---

Tracing command ntpd pid 937 tid 100202 td 0xfffffe0057be6000
sched_switch() at sched_switch+0x482/frame 0xffffff881df6f590
mi_switch() at mi_switch+0x179/frame 0xffffff881df6f5d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df6f610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df6f680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df6f6b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881df6f720
seltdwait() at seltdwait+0x78/frame 0xffffff881df6f760
kern_select() at kern_select+0x892/frame 0xffffff881df6f960
sys_select() at sys_select+0x54/frame 0xffffff881df6f9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df6fab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df6fab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x8013c126a, rsp = 0x7fffffffdbc8, rbp = 0x7fffffffdc90 ---

Tracing command nfsd pid 900 tid 100198 td 0xfffffe00846ef000
sched_switch() at sched_switch+0x482/frame 0xffffff881df5b730
mi_switch() at mi_switch+0x179/frame 0xffffff881df5b770
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df5b7b0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df5b820
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df5b850
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df5b8d0
svc_run_internal() at svc_run_internal+0x9c7/frame 0xffffff881df5ba60
svc_thread_start() at svc_thread_start+0xb/frame 0xffffff881df5ba70
fork_exit() at fork_exit+0x84/frame 0xffffff881df5bab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881df5bab0
--- trap 0xc, rip = 0x80088688a, rsp = 0x7fffffffd5d8, rbp = 0x7fffffffd880 ---

Tracing command nfsd pid 900 tid 100197 td 0xfffffe00846ef490
sched_switch() at sched_switch+0x482/frame 0xffffff881df56730
mi_switch() at mi_switch+0x179/frame 0xffffff881df56770
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df567b0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df56820
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df56850
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df568d0
svc_run_internal() at svc_run_internal+0x9c7/frame 0xffffff881df56a60
svc_thread_start() at svc_thread_start+0xb/frame 0xffffff881df56a70
fork_exit() at fork_exit+0x84/frame 0xffffff881df56ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881df56ab0
--- trap 0xc, rip = 0x80088688a, rsp = 0x7fffffffd5d8, rbp = 0x7fffffffd880 ---

Tracing command nfsd pid 900 tid 100196 td 0xfffffe00846ef920
sched_switch() at sched_switch+0x482/frame 0xffffff881df51730
mi_switch() at mi_switch+0x179/frame 0xffffff881df51770
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df517b0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df51820
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df51850
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df518d0
svc_run_internal() at svc_run_internal+0x9c7/frame 0xffffff881df51a60
svc_thread_start() at svc_thread_start+0xb/frame 0xffffff881df51a70
fork_exit() at fork_exit+0x84/frame 0xffffff881df51ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881df51ab0
--- trap 0xc, rip = 0x80088688a, rsp = 0x7fffffffd5d8, rbp = 0x7fffffffd880 ---

Tracing command nfsd pid 900 tid 100195 td 0xfffffe0057f53920
sched_switch() at sched_switch+0x482/frame 0xffffff881df4bea0
mi_switch() at mi_switch+0x179/frame 0xffffff881df4bee0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df4bf20
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df4bf90
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df4bfc0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df4c040
svc_run_internal() at svc_run_internal+0x9c7/frame 0xffffff881df4c1d0
svc_run() at svc_run+0xd4/frame 0xffffff881df4c210
nfsrvd_nfsd() at nfsrvd_nfsd+0x194/frame 0xffffff881df4c370
nfssvc_nfsd() at nfssvc_nfsd+0x103/frame 0xffffff881df4c970
sys_nfssvc() at sys_nfssvc+0xd2/frame 0xffffff881df4c9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df4cab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df4cab0
--- syscall (155, FreeBSD ELF64, sys_nfssvc), rip = 0x80088688a, rsp = 0x7fffffffd5d8, rbp = 0x7fffffffd880 ---

Tracing command nfsd pid 897 tid 100169 td 0xfffffe00843a0000
sched_switch() at sched_switch+0x482/frame 0xffffff881deb0590
mi_switch() at mi_switch+0x179/frame 0xffffff881deb05d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881deb0610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881deb0680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881deb06b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881deb0720
seltdwait() at seltdwait+0x78/frame 0xffffff881deb0760
kern_select() at kern_select+0x892/frame 0xffffff881deb0960
sys_select() at sys_select+0x54/frame 0xffffff881deb09a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881deb0ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881deb0ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80094526a, rsp = 0x7fffffffd888, rbp = 0x7fffffffdce0 ---

Tracing command mountd pid 891 tid 100176 td 0xfffffe0057f71000
sched_switch() at sched_switch+0x482/frame 0xffffff881ded3590
mi_switch() at mi_switch+0x179/frame 0xffffff881ded35d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881ded3610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881ded3680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881ded36b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881ded3720
seltdwait() at seltdwait+0x78/frame 0xffffff881ded3760
kern_select() at kern_select+0x892/frame 0xffffff881ded3960
sys_select() at sys_select+0x54/frame 0xffffff881ded39a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881ded3ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881ded3ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x800b5d26a, rsp = 0x7fffffffdb88, rbp = 0x7fffffffdd00 ---

Tracing command nfsuserd pid 884 tid 100193 td 0xfffffe0057bf6920
sched_switch() at sched_switch+0x482/frame 0xffffff881df42580
mi_switch() at mi_switch+0x179/frame 0xffffff881df425c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df42600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df42670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df426a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df42720
seltdwait() at seltdwait+0x8b/frame 0xffffff881df42760
kern_select() at kern_select+0x892/frame 0xffffff881df42960
sys_select() at sys_select+0x54/frame 0xffffff881df429a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df42ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df42ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80094426a, rsp = 0x7fffffffd9f8, rbp = 0x7fffffffdb30 ---

Tracing command nfsuserd pid 883 tid 100192 td 0xfffffe0057cae000
sched_switch() at sched_switch+0x482/frame 0xffffff881df3d580
mi_switch() at mi_switch+0x179/frame 0xffffff881df3d5c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df3d600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df3d670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881df3d6a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881df3d720
seltdwait() at seltdwait+0x8b/frame 0xffffff881df3d760
kern_select() at kern_select+0x892/frame 0xffffff881df3d960
sys_select() at sys_select+0x54/frame 0xffffff881df3d9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df3dab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df3dab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80094426a, rsp = 0x7fffffffd9f8, rbp = 0x7fffffffdb30 ---

Tracing command nfsuserd pid 882 tid 100177 td 0xfffffe0057cae490
sched_switch() at sched_switch+0x482/frame 0xffffff881ded8580
mi_switch() at mi_switch+0x179/frame 0xffffff881ded85c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881ded8600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881ded8670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881ded86a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881ded8720
seltdwait() at seltdwait+0x8b/frame 0xffffff881ded8760
kern_select() at kern_select+0x892/frame 0xffffff881ded8960
sys_select() at sys_select+0x54/frame 0xffffff881ded89a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881ded8ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881ded8ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80094426a, rsp = 0x7fffffffd9f8, rbp = 0x7fffffffdb30 ---

Tracing command nfsuserd pid 881 tid 100179 td 0xfffffe0057577000
sched_switch() at sched_switch+0x482/frame 0xffffff881dee2580
mi_switch() at mi_switch+0x179/frame 0xffffff881dee25c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dee2600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881dee2670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881dee26a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881dee2720
seltdwait() at seltdwait+0x8b/frame 0xffffff881dee2760
kern_select() at kern_select+0x892/frame 0xffffff881dee2960
sys_select() at sys_select+0x54/frame 0xffffff881dee29a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881dee2ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881dee2ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x80094426a, rsp = 0x7fffffffd9f8, rbp = 0x7fffffffdb30 ---

Tracing command nfsuserd pid 880 tid 100156 td 0xfffffe0057f71920
sched_switch() at sched_switch+0x482/frame 0xffffff881de6f760
mi_switch() at mi_switch+0x179/frame 0xffffff881de6f7a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de6f7e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de6f850
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881de6f880
_sleep() at _sleep+0x320/frame 0xffffff881de6f910
kern_sigsuspend() at kern_sigsuspend+0xcd/frame 0xffffff881de6f970
sys_sigsuspend() at sys_sigsuspend+0x31/frame 0xffffff881de6f9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de6fab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de6fab0
--- syscall (4, FreeBSD ELF64, sys_write), rip = 0x800884c2a, rsp = 0x7fffffffdb38, rbp = 0x7fffffffdd00 ---

Tracing command rpcbind pid 851 tid 100160 td 0xfffffe0057a6f490
sched_switch() at sched_switch+0x482/frame 0xffffff881de83620
mi_switch() at mi_switch+0x179/frame 0xffffff881de83660
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de836a0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de83710
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881de83740
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881de837c0
seltdwait() at seltdwait+0x8b/frame 0xffffff881de83800
sys_poll() at sys_poll+0x38c/frame 0xffffff881de839a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de83ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de83ab0
--- syscall (209, FreeBSD ELF64, sys_poll), rip = 0x800cfd6fa, rsp = 0x7fffffffba68, rbp = 0x7fffffffdc80 ---

Tracing command syslogd pid 838 tid 100189 td 0xfffffe00843be000
sched_switch() at sched_switch+0x482/frame 0xffffff881df2e590
mi_switch() at mi_switch+0x179/frame 0xffffff881df2e5d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881df2e610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881df2e680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881df2e6b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881df2e720
seltdwait() at seltdwait+0x78/frame 0xffffff881df2e760
kern_select() at kern_select+0x892/frame 0xffffff881df2e960
sys_select() at sys_select+0x54/frame 0xffffff881df2e9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881df2eab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881df2eab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x800b5b26a, rsp = 0x7fffffffcce8, rbp = 0x7fffffffdd00 ---

Tracing command devd pid 709 tid 100164 td 0xfffffe0076026490
sched_switch() at sched_switch+0x482/frame 0xffffff881de97580
mi_switch() at mi_switch+0x179/frame 0xffffff881de975c0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de97600
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de97670
sleepq_timedwait_sig() at sleepq_timedwait_sig+0x10/frame 0xffffff881de976a0
_cv_timedwait_sig_sbt() at _cv_timedwait_sig_sbt+0x1fe/frame 0xffffff881de97720
seltdwait() at seltdwait+0x8b/frame 0xffffff881de97760
kern_select() at kern_select+0x892/frame 0xffffff881de97960
sys_select() at sys_select+0x54/frame 0xffffff881de979a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de97ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de97ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x44cb4a, rsp = 0x7fffffffbbb8, rbp = 0x7fffffffdd20 ---

Tracing command moused pid 692 tid 100155 td 0xfffffe0057895000
sched_switch() at sched_switch+0x482/frame 0xffffff881de6a590
mi_switch() at mi_switch+0x179/frame 0xffffff881de6a5d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de6a610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de6a680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881de6a6b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881de6a720
seltdwait() at seltdwait+0x78/frame 0xffffff881de6a760
kern_select() at kern_select+0x892/frame 0xffffff881de6a960
sys_select() at sys_select+0x54/frame 0xffffff881de6a9a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de6aab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de6aab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x800d8126a, rsp = 0x7fffffffd6f8, rbp = 0x7fffffffdca0 ---

Tracing command moused pid 671 tid 100161 td 0xfffffe0057577920
sched_switch() at sched_switch+0x482/frame 0xffffff881de88590
mi_switch() at mi_switch+0x179/frame 0xffffff881de885d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881de88610
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881de88680
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881de886b0
_cv_wait_sig() at _cv_wait_sig+0x1e2/frame 0xffffff881de88720
seltdwait() at seltdwait+0x78/frame 0xffffff881de88760
kern_select() at kern_select+0x892/frame 0xffffff881de88960
sys_select() at sys_select+0x54/frame 0xffffff881de889a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881de88ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881de88ab0
--- syscall (93, FreeBSD ELF64, sys_select), rip = 0x800d8126a, rsp = 0x7fffffffd6f8, rbp = 0x7fffffffdca0 ---

Tracing command softdepflush pid 17 tid 100134 td 0xfffffe005707c920
sched_switch() at sched_switch+0x482/frame 0xffffff881dc098f0
mi_switch() at mi_switch+0x179/frame 0xffffff881dc09930
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dc09970
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dc099a0
_sleep() at _sleep+0x312/frame 0xffffff881dc09a30
softdep_flush() at softdep_flush+0x20c/frame 0xffffff881dc09a70
fork_exit() at fork_exit+0x84/frame 0xffffff881dc09ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dc09ab0
--- trap 0, rip = 0, rsp = 0xffffff881dc09b70, rbp = 0 ---

Tracing command vnlru pid 16 tid 100133 td 0xfffffe0057125000
sched_switch() at sched_switch+0x482/frame 0xffffff881dc048b0
mi_switch() at mi_switch+0x179/frame 0xffffff881dc048f0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dc04930
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dc04960
_sleep() at _sleep+0x312/frame 0xffffff881dc049f0
vnlru_proc() at vnlru_proc+0x48/frame 0xffffff881dc04a70
fork_exit() at fork_exit+0x84/frame 0xffffff881dc04ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dc04ab0
--- trap 0, rip = 0, rsp = 0xffffff881dc04b70, rbp = 0 ---

Tracing command syncer pid 9 tid 100132 td 0xfffffe0057125490
sched_switch() at sched_switch+0x482/frame 0xffffff881dbfe8a0
mi_switch() at mi_switch+0x179/frame 0xffffff881dbfe8e0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbfe920
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dbfe950
_cv_timedwait_sbt() at _cv_timedwait_sbt+0x1fe/frame 0xffffff881dbfe9d0
sched_sync() at sched_sync+0x5cb/frame 0xffffff881dbfea70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbfeab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbfeab0
--- trap 0, rip = 0, rsp = 0xffffff881dbfeb70, rbp = 0 ---

Tracing command bufdaemon pid 8 tid 100131 td 0xfffffe0057125920
sched_switch() at sched_switch+0x482/frame 0xffffff881dbf9900
mi_switch() at mi_switch+0x179/frame 0xffffff881dbf9940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbf9980
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dbf99b0
_sleep() at _sleep+0x312/frame 0xffffff881dbf9a40
buf_daemon() at buf_daemon+0x68/frame 0xffffff881dbf9a70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbf9ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbf9ab0
--- trap 0, rip = 0, rsp = 0xffffff881dbf9b70, rbp = 0 ---

Tracing command pagezero pid 7 tid 100130 td 0xfffffe0056002920
sched_switch() at sched_switch+0x482/frame 0xffffff881dbf4900
mi_switch() at mi_switch+0x179/frame 0xffffff881dbf4940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbf4980
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dbf49b0
_sleep() at _sleep+0x312/frame 0xffffff881dbf4a40
vm_pagezero() at vm_pagezero+0x88/frame 0xffffff881dbf4a70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbf4ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbf4ab0
--- trap 0, rip = 0, rsp = 0xffffff881dbf4b70, rbp = 0 ---

Tracing command vmdaemon pid 6 tid 100129 td 0xfffffe005707b000
sched_switch() at sched_switch+0x482/frame 0xffffff881dbef8c0
mi_switch() at mi_switch+0x179/frame 0xffffff881dbef900
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbef940
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881dbef970
_sleep() at _sleep+0x33d/frame 0xffffff881dbefa00
vm_daemon() at vm_daemon+0x7e/frame 0xffffff881dbefa70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbefab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbefab0
--- trap 0, rip = 0, rsp = 0xffffff881dbefb70, rbp = 0 ---

Tracing command pagedaemon pid 5 tid 100128 td 0xfffffe005707b490
sched_switch() at sched_switch+0x482/frame 0xffffff881dbea840
mi_switch() at mi_switch+0x179/frame 0xffffff881dbea880
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbea8c0
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881dbea8f0
_sleep() at _sleep+0x312/frame 0xffffff881dbea980
vm_pageout() at vm_pageout+0x1ef/frame 0xffffff881dbeaa70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbeaab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbeaab0
--- trap 0, rip = 0, rsp = 0xffffff881dbeab70, rbp = 0 ---

Tracing command enc_daemon0 pid 4 tid 100127 td 0xfffffe005707b920
sched_switch() at sched_switch+0x482/frame 0xffffff881dbe58c0
mi_switch() at mi_switch+0x179/frame 0xffffff881dbe5900
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881dbe5940
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881dbe5970
_sleep() at _sleep+0x33d/frame 0xffffff881dbe5a00
enc_daemon() at enc_daemon+0x109/frame 0xffffff881dbe5a70
fork_exit() at fork_exit+0x84/frame 0xffffff881dbe5ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881dbe5ab0
--- trap 0, rip = 0, rsp = 0xffffff881dbe5b70, rbp = 0 ---

Tracing command xpt_thrd pid 3 tid 100126 td 0xfffffe005707c000
sched_switch() at sched_switch+0x482/frame 0xffffff881da20900
mi_switch() at mi_switch+0x179/frame 0xffffff881da20940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881da20980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881da209b0
_sleep() at _sleep+0x33d/frame 0xffffff881da20a40
xpt_scanner_thread() at xpt_scanner_thread+0xdc/frame 0xffffff881da20a70
fork_exit() at fork_exit+0x84/frame 0xffffff881da20ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881da20ab0
--- trap 0, rip = 0, rsp = 0xffffff881da20b70, rbp = 0 ---

Tracing command sctp_iterator pid 2 tid 100125 td 0xfffffe00517fe000
sched_switch() at sched_switch+0x482/frame 0xffffff881da1b910
mi_switch() at mi_switch+0x179/frame 0xffffff881da1b950
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881da1b990
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881da1b9c0
_sleep() at _sleep+0x33d/frame 0xffffff881da1ba50
sctp_iterator_thread() at sctp_iterator_thread+0x59/frame 0xffffff881da1ba70
fork_exit() at fork_exit+0x84/frame 0xffffff881da1bab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881da1bab0
--- trap 0, rip = 0, rsp = 0xffffff881da1bb70, rbp = 0 ---

Tracing command usb pid 15 tid 100119 td 0xfffffe00516b1920
sched_switch() at sched_switch+0x482/frame 0xffffff881b978920
mi_switch() at mi_switch+0x179/frame 0xffffff881b978960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b9789a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b9789d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b978a40
usb_process() at usb_process+0xd4/frame 0xffffff881b978a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b978ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b978ab0
--- trap 0, rip = 0, rsp = 0xffffff881b978b70, rbp = 0 ---

Tracing command usb pid 15 tid 100118 td 0xfffffe00516bd000
sched_switch() at sched_switch+0x482/frame 0xffffff881b973920
mi_switch() at mi_switch+0x179/frame 0xffffff881b973960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b9739a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b9739d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b973a40
usb_process() at usb_process+0xd4/frame 0xffffff881b973a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b973ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b973ab0
--- trap 0, rip = 0, rsp = 0xffffff881b973b70, rbp = 0 ---

Tracing command usb pid 15 tid 100117 td 0xfffffe00516bd490
sched_switch() at sched_switch+0x482/frame 0xffffff881b96e920
mi_switch() at mi_switch+0x179/frame 0xffffff881b96e960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b96e9a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b96e9d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b96ea40
usb_process() at usb_process+0xd4/frame 0xffffff881b96ea70
fork_exit() at fork_exit+0x84/frame 0xffffff881b96eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b96eab0
--- trap 0, rip = 0, rsp = 0xffffff881b96eb70, rbp = 0 ---

Tracing command usb pid 15 tid 100116 td 0xfffffe00516bd920
sched_switch() at sched_switch+0x482/frame 0xffffff881b969920
mi_switch() at mi_switch+0x179/frame 0xffffff881b969960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b9699a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b9699d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b969a40
usb_process() at usb_process+0xd4/frame 0xffffff881b969a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b969ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b969ab0
--- trap 0, rip = 0, rsp = 0xffffff881b969b70, rbp = 0 ---

Tracing command usb pid 15 tid 100114 td 0xfffffe00516b0000
sched_switch() at sched_switch+0x482/frame 0xffffff881b7dc920
mi_switch() at mi_switch+0x179/frame 0xffffff881b7dc960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b7dc9a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7dc9d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b7dca40
usb_process() at usb_process+0xd4/frame 0xffffff881b7dca70
fork_exit() at fork_exit+0x84/frame 0xffffff881b7dcab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b7dcab0
--- trap 0, rip = 0, rsp = 0xffffff881b7dcb70, rbp = 0 ---

Tracing command usb pid 15 tid 100113 td 0xfffffe00516b0490
sched_switch() at sched_switch+0x482/frame 0xffffff881b7d7920
mi_switch() at mi_switch+0x179/frame 0xffffff881b7d7960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b7d79a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7d79d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b7d7a40
usb_process() at usb_process+0xd4/frame 0xffffff881b7d7a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b7d7ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b7d7ab0
--- trap 0, rip = 0, rsp = 0xffffff881b7d7b70, rbp = 0 ---

Tracing command usb pid 15 tid 100112 td 0xfffffe00516b0920
sched_switch() at sched_switch+0x482/frame 0xffffff881b7d2920
mi_switch() at mi_switch+0x179/frame 0xffffff881b7d2960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b7d29a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7d29d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b7d2a40
usb_process() at usb_process+0xd4/frame 0xffffff881b7d2a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b7d2ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b7d2ab0
--- trap 0, rip = 0, rsp = 0xffffff881b7d2b70, rbp = 0 ---

Tracing command usb pid 15 tid 100111 td 0xfffffe00516b1000
sched_switch() at sched_switch+0x482/frame 0xffffff881b7cd920
mi_switch() at mi_switch+0x179/frame 0xffffff881b7cd960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b7cd9a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7cd9d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b7cda40
usb_process() at usb_process+0xd4/frame 0xffffff881b7cda70
fork_exit() at fork_exit+0x84/frame 0xffffff881b7cdab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b7cdab0
--- trap 0, rip = 0, rsp = 0xffffff881b7cdb70, rbp = 0 ---

Tracing command usb pid 15 tid 100074 td 0xfffffe005022c920
sched_switch() at sched_switch+0x482/frame 0xffffff881b668920
mi_switch() at mi_switch+0x179/frame 0xffffff881b668960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6689a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6689d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b668a40
usb_process() at usb_process+0xd4/frame 0xffffff881b668a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b668ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b668ab0
--- trap 0, rip = 0, rsp = 0xffffff881b668b70, rbp = 0 ---

Tracing command usb pid 15 tid 100073 td 0xfffffe0051660000
sched_switch() at sched_switch+0x482/frame 0xffffff881b663920
mi_switch() at mi_switch+0x179/frame 0xffffff881b663960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6639a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6639d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b663a40
usb_process() at usb_process+0xd4/frame 0xffffff881b663a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b663ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b663ab0
--- trap 0, rip = 0, rsp = 0xffffff881b663b70, rbp = 0 ---

Tracing command usb pid 15 tid 100072 td 0xfffffe0051660490
sched_switch() at sched_switch+0x482/frame 0xffffff881b65e920
mi_switch() at mi_switch+0x179/frame 0xffffff881b65e960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b65e9a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b65e9d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b65ea40
usb_process() at usb_process+0xd4/frame 0xffffff881b65ea70
fork_exit() at fork_exit+0x84/frame 0xffffff881b65eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b65eab0
--- trap 0, rip = 0, rsp = 0xffffff881b65eb70, rbp = 0 ---

Tracing command usb pid 15 tid 100071 td 0xfffffe0051660920
sched_switch() at sched_switch+0x482/frame 0xffffff881b659920
mi_switch() at mi_switch+0x179/frame 0xffffff881b659960
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6599a0
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6599d0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b659a40
usb_process() at usb_process+0xd4/frame 0xffffff881b659a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b659ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b659ab0
--- trap 0, rip = 0, rsp = 0xffffff881b659b70, rbp = 0 ---

Tracing command yarrow pid 14 tid 100057 td 0xfffffe00500a4490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d268f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d26930
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d26970
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff87a9d269a0
msleep_spin_sbt() at msleep_spin_sbt+0x1f0/frame 0xffffff87a9d26a30
random_kthread() at random_kthread+0x68/frame 0xffffff87a9d26a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d26ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d26ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d26b70, rbp = 0 ---

Tracing command geom pid 13 tid 100055 td 0xfffffe005008e920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d1c8d0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d1c910
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d1c950
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d1c980
_sleep() at _sleep+0x33d/frame 0xffffff87a9d1ca10
g_io_schedule_down() at g_io_schedule_down+0x4c/frame 0xffffff87a9d1ca60
g_down_procbody() at g_down_procbody+0x7d/frame 0xffffff87a9d1ca70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d1cab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d1cab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d1cb70, rbp = 0 ---

Tracing command geom pid 13 tid 100054 td 0xfffffe005008f000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d178f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d17930
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d17970
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d179a0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d17a30
g_io_schedule_up() at g_io_schedule_up+0xbc/frame 0xffffff87a9d17a60
g_up_procbody() at g_up_procbody+0x7d/frame 0xffffff87a9d17a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d17ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d17ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d17b70, rbp = 0 ---

Tracing command geom pid 13 tid 100053 td 0xfffffe005008f490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d128f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d12930
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d12970
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d129a0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d12a30
g_run_events() at g_run_events+0x4f4/frame 0xffffff87a9d12a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d12ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d12ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d12b70, rbp = 0 ---

Tracing command intr pid 12 tid 100122 td 0xfffffe0056002000
sched_switch() at sched_switch+0x482/frame 0xffffff881da079f0
mi_switch() at mi_switch+0x179/frame 0xffffff881da07a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881da07a70
fork_exit() at fork_exit+0x84/frame 0xffffff881da07ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881da07ab0
--- trap 0, rip = 0, rsp = 0xffffff881da07b70, rbp = 0 ---

Tracing command intr pid 12 tid 100121 td 0xfffffe0056002490
sched_switch() at sched_switch+0x482/frame 0xffffff881d9ff9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881d9ffa30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881d9ffa70
fork_exit() at fork_exit+0x84/frame 0xffffff881d9ffab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881d9ffab0
--- trap 0, rip = 0, rsp = 0xffffff881d9ffb70, rbp = 0 ---

Tracing command intr pid 12 tid 100120 td 0xfffffe00516b1490
sched_switch() at sched_switch+0x482/frame 0xffffff881b97d9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b97da30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b97da70
fork_exit() at fork_exit+0x84/frame 0xffffff881b97dab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b97dab0
--- trap 0, rip = 0, rsp = 0xffffff881b97db70, rbp = 0 ---

Tracing command intr pid 12 tid 100115 td 0xfffffe00516a6920
sched_switch() at sched_switch+0x482/frame 0xffffff881b9649f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b964a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b964a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b964ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b964ab0
--- trap 0, rip = 0, rsp = 0xffffff881b964b70, rbp = 0 ---

Tracing command intr pid 12 tid 100110 td 0xfffffe00516a5000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100109 td 0xfffffe00516a5490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100107 td 0xfffffe00516a6000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100105 td 0xfffffe005169f490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100103 td 0xfffffe00516a4000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100101 td 0xfffffe00516a4920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100099 td 0xfffffe005169e000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100097 td 0xfffffe005169e920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100095 td 0xfffffe0051683000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100093 td 0xfffffe0051683920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100092 td 0xfffffe0051684000
sched_switch() at sched_switch+0x482/frame 0xffffff881b70c9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b70ca30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b70ca70
fork_exit() at fork_exit+0x84/frame 0xffffff881b70cab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b70cab0
--- trap 0, rip = 0, rsp = 0xffffff881b70cb70, rbp = 0 ---

Tracing command intr pid 12 tid 100090 td 0xfffffe0051681490
sched_switch() at sched_switch+0x482/frame 0xffffff881b7029f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b702a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b702a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b702ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b702ab0
--- trap 0, rip = 0, rsp = 0xffffff881b702b70, rbp = 0 ---

Tracing command intr pid 12 tid 100088 td 0xfffffe0051682000
sched_switch() at sched_switch+0x482/frame 0xffffff881b6f89f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6f8a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6f8a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6f8ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6f8ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6f8b70, rbp = 0 ---

Tracing command intr pid 12 tid 100086 td 0xfffffe0051682920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6ee9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6eea30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6eea70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6eeab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6eeab0
--- trap 0, rip = 0, rsp = 0xffffff881b6eeb70, rbp = 0 ---

Tracing command intr pid 12 tid 100084 td 0xfffffe0051680000
sched_switch() at sched_switch+0x482/frame 0xffffff881b6e49f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6e4a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6e4a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6e4ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6e4ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6e4b70, rbp = 0 ---

Tracing command intr pid 12 tid 100082 td 0xfffffe0051680920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6da9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6daa30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6daa70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6daab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6daab0
--- trap 0, rip = 0, rsp = 0xffffff881b6dab70, rbp = 0 ---

Tracing command intr pid 12 tid 100080 td 0xfffffe005167e000
sched_switch() at sched_switch+0x482/frame 0xffffff881b6d09f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6d0a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6d0a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6d0ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6d0ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6d0b70, rbp = 0 ---

Tracing command intr pid 12 tid 100078 td 0xfffffe005167e920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6c69f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6c6a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6c6a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6c6ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6c6ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6c6b70, rbp = 0 ---

Tracing command intr pid 12 tid 100076 td 0xfffffe005167f490
sched_switch() at sched_switch+0x482/frame 0xffffff881b6bc9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b6bca30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b6bca70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6bcab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6bcab0
--- trap 0, rip = 0, rsp = 0xffffff881b6bcb70, rbp = 0 ---

Tracing command intr pid 12 tid 100075 td 0xfffffe005022c490
sched_switch() at sched_switch+0x482/frame 0xffffff881b66d9f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b66da30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b66da70
fork_exit() at fork_exit+0x84/frame 0xffffff881b66dab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b66dab0
--- trap 0, rip = 0, rsp = 0xffffff881b66db70, rbp = 0 ---

Tracing command intr pid 12 tid 100070 td 0xfffffe0050226920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6549f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b654a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff881b654a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b654ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b654ab0
--- trap 0, rip = 0, rsp = 0xffffff881b654b70, rbp = 0 ---

Tracing command intr pid 12 tid 100069 td 0xfffffe005022b000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100068 td 0xfffffe005022b490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d9e9f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d9ea30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9d9ea70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d9eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d9eab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d9eb70, rbp = 0 ---

Tracing command intr pid 12 tid 100067 td 0xfffffe005022b920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100064 td 0xfffffe005021e490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d499f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d49a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9d49a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d49ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d49ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d49b70, rbp = 0 ---

Tracing command intr pid 12 tid 100063 td 0xfffffe005021e920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d449f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d44a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9d44a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d44ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d44ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d44b70, rbp = 0 ---

Tracing command intr pid 12 tid 100058 td 0xfffffe00500a4000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d2b9f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d2ba30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9d2ba70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d2bab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d2bab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d2bb70, rbp = 0 ---

Tracing command intr pid 12 tid 100052 td 0xfffffe005008f920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100051 td 0xfffffe0050090000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100050 td 0xfffffe005008d000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100049 td 0xfffffe005008d490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100048 td 0xfffffe005008d920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100047 td 0xfffffe005008e000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100046 td 0xfffffe005008e490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100045 td 0xfffffe005008b490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100044 td 0xfffffe005008b920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100043 td 0xfffffe005008c000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100042 td 0xfffffe005008c490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100041 td 0xfffffe005008c920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100040 td 0xfffffe0050088920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100039 td 0xfffffe005008a000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100038 td 0xfffffe005008a490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100037 td 0xfffffe005008a920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100036 td 0xfffffe005008b000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100035 td 0xfffffe0050087000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100034 td 0xfffffe0050087490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100033 td 0xfffffe0050087920
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100032 td 0xfffffe0050088000
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100031 td 0xfffffe0050088490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100030 td 0xfffffe005005b490
fork_trampoline() at fork_trampoline

Tracing command intr pid 12 tid 100029 td 0xfffffe005005b920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9c9a9f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9c9aa30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9c9aa70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c9aab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c9aab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c9ab70, rbp = 0 ---

Tracing command intr pid 12 tid 100028 td 0xfffffe005005c000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9c959f0
mi_switch() at mi_switch+0x179/frame 0xffffff87a9c95a30
ithread_loop() at ithread_loop+0x1d2/frame 0xffffff87a9c95a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c95ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c95ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c95b70, rbp = 0 ---

Tracing command intr pid 12 tid 100027 td 0xfffffe005005c490
fork_trampoline() at fork_trampoline

Tracing command idle pid 11 tid 100026 td 0xfffffe005005c920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5dbce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5dbd00
trap() at trap+0x42/frame 0xffffff881b5dbf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5dbf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5dbfe0, rbp = 0xffffff87a9c8b930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c8b930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c8b980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c8b9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c8b9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c8ba70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c8bab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c8bab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c8bb70, rbp = 0 ---

Tracing command idle pid 11 tid 100025 td 0xfffffe0050059920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5d4ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5d4d00
trap() at trap+0x42/frame 0xffffff881b5d4f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5d4f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5d4fe0, rbp = 0xffffff87a9c86930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c86930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c86980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c869a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c869c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c86a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c86ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c86ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c86b70, rbp = 0 ---

Tracing command idle pid 11 tid 100024 td 0xfffffe005005a000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5cdce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5cdd00
trap() at trap+0x42/frame 0xffffff881b5cdf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5cdf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5cdfe0, rbp = 0xffffff87a9c81930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c81930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c81980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c819a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c819c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c81a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c81ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c81ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c81b70, rbp = 0 ---

Tracing command idle pid 11 tid 100023 td 0xfffffe005005a490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5c6ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5c6d00
trap() at trap+0x42/frame 0xffffff881b5c6f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5c6f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5c6fe0, rbp = 0xffffff87a9c7c930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c7c930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c7c980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c7c9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c7c9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c7ca70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c7cab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c7cab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c7cb70, rbp = 0 ---

Tracing command idle pid 11 tid 100022 td 0xfffffe005005a920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9c77960
mi_switch() at mi_switch+0x179/frame 0xffffff87a9c779a0
critical_exit() at critical_exit+0x8b/frame 0xffffff87a9c779c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c77a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c77ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c77ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c77b70, rbp = 0 ---

Tracing command idle pid 11 tid 100021 td 0xfffffe005005b000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5b8ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5b8d00
trap() at trap+0x42/frame 0xffffff881b5b8f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5b8f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5b8fe0, rbp = 0xffffff87a9c72930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c72930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c72980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c729a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c729c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c72a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c72ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c72ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c72b70, rbp = 0 ---

Tracing command idle pid 11 tid 100020 td 0xfffffe0050058000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5b1ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5b1d00
trap() at trap+0x42/frame 0xffffff881b5b1f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5b1f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5b1fe0, rbp = 0xffffff87a9c6d930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c6d930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c6d980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c6d9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c6d9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c6da70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c6dab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c6dab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c6db70, rbp = 0 ---

Tracing command idle pid 11 tid 100019 td 0xfffffe0050058490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5aace0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5aad00
trap() at trap+0x42/frame 0xffffff881b5aaf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5aaf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5aafe0, rbp = 0xffffff87a9c68930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c68930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c68980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c689a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c689c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c68a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c68ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c68ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c68b70, rbp = 0 ---

Tracing command idle pid 11 tid 100018 td 0xfffffe0050058920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b5a3ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b5a3d00
trap() at trap+0x42/frame 0xffffff881b5a3f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b5a3f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b5a3fe0, rbp = 0xffffff87a9c63930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c63930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c63980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c639a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c639c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c63a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c63ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c63ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c63b70, rbp = 0 ---

Tracing command idle pid 11 tid 100017 td 0xfffffe0050059000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b59cce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b59cd00
trap() at trap+0x42/frame 0xffffff881b59cf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b59cf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b59cfe0, rbp = 0xffffff87a9c5e930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c5e930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c5e980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c5e9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c5e9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c5ea70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c5eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c5eab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c5eb70, rbp = 0 ---

Tracing command idle pid 11 tid 100016 td 0xfffffe0050059490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b595ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b595d00
trap() at trap+0x42/frame 0xffffff881b595f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b595f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b595fe0, rbp = 0xffffff87a9c59930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c59930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c59980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c599a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c599c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c59a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c59ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c59ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c59b70, rbp = 0 ---

Tracing command idle pid 11 tid 100015 td 0xfffffe0050056490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b58ece0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b58ed00
trap() at trap+0x42/frame 0xffffff881b58ef20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b58ef20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b58efe0, rbp = 0xffffff87a9c54930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c54930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c54980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c549a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c549c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c54a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c54ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c54ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c54b70, rbp = 0 ---

Tracing command idle pid 11 tid 100014 td 0xfffffe0050056920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b587ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b587d00
trap() at trap+0x42/frame 0xffffff881b587f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b587f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b587fe0, rbp = 0xffffff87a9c4f930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c4f930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c4f980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c4f9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c4f9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c4fa70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c4fab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c4fab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c4fb70, rbp = 0 ---

Tracing command idle pid 11 tid 100013 td 0xfffffe0050057000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b580ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b580d00
trap() at trap+0x42/frame 0xffffff881b580f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b580f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b580fe0, rbp = 0xffffff87a9c4a930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c4a930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c4a980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c4a9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c4a9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c4aa70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c4aab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c4aab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c4ab70, rbp = 0 ---

Tracing command idle pid 11 tid 100012 td 0xfffffe0050057490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b579ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b579d00
trap() at trap+0x42/frame 0xffffff881b579f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b579f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b579fe0, rbp = 0xffffff87a9c45930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c45930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c45980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c459a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c459c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c45a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c45ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c45ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c45b70, rbp = 0 ---

Tracing command idle pid 11 tid 100011 td 0xfffffe0050057920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b572ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b572d00
trap() at trap+0x42/frame 0xffffff881b572f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b572f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b572fe0, rbp = 0xffffff87a9c40930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c40930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c40980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c409a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c409c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c40a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c40ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c40ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c40b70, rbp = 0 ---

Tracing command idle pid 11 tid 100010 td 0xfffffe0050046920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b56bce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b56bd00
trap() at trap+0x42/frame 0xffffff881b56bf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b56bf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b56bfe0, rbp = 0xffffff87a9c3b930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c3b930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c3b980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c3b9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c3b9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c3ba70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c3bab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c3bab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c3bb70, rbp = 0 ---

Tracing command idle pid 11 tid 100009 td 0xfffffe0050055000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b564ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b564d00
trap() at trap+0x42/frame 0xffffff881b564f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b564f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b564fe0, rbp = 0xffffff87a9c36930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c36930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c36980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c369a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c369c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c36a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c36ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c36ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c36b70, rbp = 0 ---

Tracing command idle pid 11 tid 100008 td 0xfffffe0050055490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b55dce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b55dd00
trap() at trap+0x42/frame 0xffffff881b55df20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b55df20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b55dfe0, rbp = 0xffffff87a9c31930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c31930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c31980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c319a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c319c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c31a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c31ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c31ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c31b70, rbp = 0 ---

Tracing command idle pid 11 tid 100007 td 0xfffffe0050055920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff881b556ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff881b556d00
trap() at trap+0x42/frame 0xffffff881b556f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff881b556f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff881b556fe0, rbp = 0xffffff87a9c2c930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff87a9c2c930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff87a9c2c980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff87a9c2c9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff87a9c2c9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff87a9c2ca70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9c2cab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9c2cab0
--- trap 0, rip = 0, rsp = 0xffffff87a9c2cb70, rbp = 0 ---

Tracing command idle pid 11 tid 100006 td 0xfffffe0050056000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff87a4fffce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff87a4fffd00
trap() at trap+0x42/frame 0xffffff87a4ffff20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff87a4ffff20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff87a4ffffe0, rbp = 0xffffff881b5fb930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff881b5fb930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff881b5fb980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff881b5fb9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff881b5fb9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff881b5fba70
fork_exit() at fork_exit+0x84/frame 0xffffff881b5fbab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b5fbab0
--- trap 0, rip = 0, rsp = 0xffffff881b5fbb70, rbp = 0 ---

Tracing command idle pid 11 tid 100005 td 0xfffffe0050040000
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff87a4ffcce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff87a4ffcd00
trap() at trap+0x42/frame 0xffffff87a4ffcf20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff87a4ffcf20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff87a4ffcfe0, rbp = 0xffffff881b5f6930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff881b5f6930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff881b5f6980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff881b5f69a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff881b5f69c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff881b5f6a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b5f6ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b5f6ab0
--- trap 0, rip = 0, rsp = 0xffffff881b5f6b70, rbp = 0 ---

Tracing command idle pid 11 tid 100004 td 0xfffffe0050040490
cpustop_handler() at cpustop_handler+0x28/frame 0xffffff87a4ff5ce0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffff87a4ff5d00
trap() at trap+0x42/frame 0xffffff87a4ff5f20
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffff87a4ff5f20
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffff87a4ff5fe0, rbp = 0xffffff881b5f1930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff881b5f1930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff881b5f1980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff881b5f19a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff881b5f19c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff881b5f1a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b5f1ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b5f1ab0
--- trap 0, rip = 0, rsp = 0xffffff881b5f1b70, rbp = 0 ---

Tracing command idle pid 11 tid 100003 td 0xfffffe0050040920
cpustop_handler() at cpustop_handler+0x28/frame 0xffffffff815917c0
ipi_nmi_handler() at ipi_nmi_handler+0x3f/frame 0xffffffff815917e0
trap() at trap+0x42/frame 0xffffffff81591a00
nmi_calltrap() at nmi_calltrap+0x8/frame 0xffffffff81591a00
--- trap 0x13, rip = 0xffffffff80c91bd6, rsp = 0xffffffff81591ac0, rbp = 0xffffff881b5ec930 ---
acpi_cpu_c1() at acpi_cpu_c1+0x6/frame 0xffffff881b5ec930
acpi_cpu_idle() at acpi_cpu_idle+0x13b/frame 0xffffff881b5ec980
cpu_idle_acpi() at cpu_idle_acpi+0x3f/frame 0xffffff881b5ec9a0
cpu_idle() at cpu_idle+0x93/frame 0xffffff881b5ec9c0
sched_idletd() at sched_idletd+0x1e8/frame 0xffffff881b5eca70
fork_exit() at fork_exit+0x84/frame 0xffffff881b5ecab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b5ecab0
--- trap 0, rip = 0, rsp = 0xffffff881b5ecb70, rbp = 0 ---

Tracing command init pid 1 tid 100002 td 0xfffffe0050046000
sched_switch() at sched_switch+0x482/frame 0xffffff881b5e7560
mi_switch() at mi_switch+0x179/frame 0xffffff881b5e75a0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b5e75e0
sleepq_catch_signals() at sleepq_catch_signals+0x2f4/frame 0xffffff881b5e7650
sleepq_wait_sig() at sleepq_wait_sig+0xf/frame 0xffffff881b5e7680
_sleep() at _sleep+0x320/frame 0xffffff881b5e7710
kern_wait6() at kern_wait6+0x3e7/frame 0xffffff881b5e77b0
sys_wait4() at sys_wait4+0x76/frame 0xffffff881b5e79a0
amd64_syscall() at amd64_syscall+0x282/frame 0xffffff881b5e7ab0
Xfast_syscall() at Xfast_syscall+0xfb/frame 0xffffff881b5e7ab0
--- syscall (7, FreeBSD ELF64, sys_wait4), rip = 0x4131fa, rsp = 0x7fffffffd758, rbp = 0x7fffffffd7c0 ---

Tracing command audit pid 10 tid 100001 td 0xfffffe0050046490
sched_switch() at sched_switch+0x482/frame 0xffffff881b5e28f0
mi_switch() at mi_switch+0x179/frame 0xffffff881b5e2930
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b5e2970
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b5e29a0
_cv_wait() at _cv_wait+0x1df/frame 0xffffff881b5e2a10
audit_worker() at audit_worker+0xa3/frame 0xffffff881b5e2a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b5e2ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b5e2ab0
--- trap 0, rip = 0, rsp = 0xffffff881b5e2b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100124 td 0xfffffe00517fe490
sched_switch() at sched_switch+0x482/frame 0xffffff881da15890
mi_switch() at mi_switch+0x179/frame 0xffffff881da158d0
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881da15910
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffff881da15940
_sleep() at _sleep+0x312/frame 0xffffff881da159d0
pause_sbt() at pause_sbt+0x70/frame 0xffffff881da15a20
deadlkres() at deadlkres+0x66/frame 0xffffff881da15a70
fork_exit() at fork_exit+0x84/frame 0xffffff881da15ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881da15ab0
--- trap 0, rip = 0, rsp = 0xffffff881da15b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100123 td 0xfffffe00517fe920
sched_switch() at sched_switch+0x482/frame 0xffffff881da10900
mi_switch() at mi_switch+0x179/frame 0xffffff881da10940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881da10980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881da109b0
msleep_spin_sbt() at msleep_spin_sbt+0x200/frame 0xffffff881da10a40
taskqueue_thread_loop() at taskqueue_thread_loop+0x8d/frame 0xffffff881da10a70
fork_exit() at fork_exit+0x84/frame 0xffffff881da10ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881da10ab0
--- trap 0, rip = 0, rsp = 0xffffff881da10b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100108 td 0xfffffe00516a5920
sched_switch() at sched_switch+0x482/frame 0xffffff881b79c900
mi_switch() at mi_switch+0x179/frame 0xffffff881b79c940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b79c980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b79c9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b79ca40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b79ca70
fork_exit() at fork_exit+0x84/frame 0xffffff881b79cab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b79cab0
--- trap 0, rip = 0, rsp = 0xffffff881b79cb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100106 td 0xfffffe00516a6490
sched_switch() at sched_switch+0x482/frame 0xffffff881b792900
mi_switch() at mi_switch+0x179/frame 0xffffff881b792940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b792980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7929b0
_sleep() at _sleep+0x33d/frame 0xffffff881b792a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b792a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b792ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b792ab0
--- trap 0, rip = 0, rsp = 0xffffff881b792b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100104 td 0xfffffe005169f920
sched_switch() at sched_switch+0x482/frame 0xffffff881b788900
mi_switch() at mi_switch+0x179/frame 0xffffff881b788940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b788980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7889b0
_sleep() at _sleep+0x33d/frame 0xffffff881b788a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b788a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b788ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b788ab0
--- trap 0, rip = 0, rsp = 0xffffff881b788b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100102 td 0xfffffe00516a4490
sched_switch() at sched_switch+0x482/frame 0xffffff881b77e900
mi_switch() at mi_switch+0x179/frame 0xffffff881b77e940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b77e980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b77e9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b77ea40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b77ea70
fork_exit() at fork_exit+0x84/frame 0xffffff881b77eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b77eab0
--- trap 0, rip = 0, rsp = 0xffffff881b77eb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100100 td 0xfffffe0051684920
sched_switch() at sched_switch+0x482/frame 0xffffff881b774900
mi_switch() at mi_switch+0x179/frame 0xffffff881b774940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b774980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7749b0
_sleep() at _sleep+0x33d/frame 0xffffff881b774a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b774a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b774ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b774ab0
--- trap 0, rip = 0, rsp = 0xffffff881b774b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100098 td 0xfffffe005169e490
sched_switch() at sched_switch+0x482/frame 0xffffff881b76a900
mi_switch() at mi_switch+0x179/frame 0xffffff881b76a940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b76a980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b76a9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b76aa40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b76aa70
fork_exit() at fork_exit+0x84/frame 0xffffff881b76aab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b76aab0
--- trap 0, rip = 0, rsp = 0xffffff881b76ab70, rbp = 0 ---

Tracing command kernel pid 0 tid 100096 td 0xfffffe005169f000
sched_switch() at sched_switch+0x482/frame 0xffffff881b760900
mi_switch() at mi_switch+0x179/frame 0xffffff881b760940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b760980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7609b0
_sleep() at _sleep+0x33d/frame 0xffffff881b760a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b760a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b760ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b760ab0
--- trap 0, rip = 0, rsp = 0xffffff881b760b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100094 td 0xfffffe0051683490
sched_switch() at sched_switch+0x482/frame 0xffffff881b756900
mi_switch() at mi_switch+0x179/frame 0xffffff881b756940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b756980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7569b0
_sleep() at _sleep+0x33d/frame 0xffffff881b756a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b756a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b756ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b756ab0
--- trap 0, rip = 0, rsp = 0xffffff881b756b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100091 td 0xfffffe0051684490
sched_switch() at sched_switch+0x482/frame 0xffffff881b707900
mi_switch() at mi_switch+0x179/frame 0xffffff881b707940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b707980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b7079b0
_sleep() at _sleep+0x33d/frame 0xffffff881b707a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b707a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b707ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b707ab0
--- trap 0, rip = 0, rsp = 0xffffff881b707b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100089 td 0xfffffe0051681920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6fd900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6fd940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6fd980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6fd9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6fda40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6fda70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6fdab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6fdab0
--- trap 0, rip = 0, rsp = 0xffffff881b6fdb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100087 td 0xfffffe0051682490
sched_switch() at sched_switch+0x482/frame 0xffffff881b6f3900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6f3940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6f3980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6f39b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6f3a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6f3a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6f3ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6f3ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6f3b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100085 td 0xfffffe005167f920
sched_switch() at sched_switch+0x482/frame 0xffffff881b6e9900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6e9940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6e9980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6e99b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6e9a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6e9a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6e9ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6e9ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6e9b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100083 td 0xfffffe0051680490
sched_switch() at sched_switch+0x482/frame 0xffffff881b6df900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6df940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6df980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6df9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6dfa40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6dfa70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6dfab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6dfab0
--- trap 0, rip = 0, rsp = 0xffffff881b6dfb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100081 td 0xfffffe0051681000
sched_switch() at sched_switch+0x482/frame 0xffffff881b6d5900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6d5940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6d5980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6d59b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6d5a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6d5a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6d5ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6d5ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6d5b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100079 td 0xfffffe005167e490
sched_switch() at sched_switch+0x482/frame 0xffffff881b6cb900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6cb940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6cb980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6cb9b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6cba40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6cba70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6cbab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6cbab0
--- trap 0, rip = 0, rsp = 0xffffff881b6cbb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100077 td 0xfffffe005167f000
sched_switch() at sched_switch+0x482/frame 0xffffff881b6c1900
mi_switch() at mi_switch+0x179/frame 0xffffff881b6c1940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff881b6c1980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff881b6c19b0
_sleep() at _sleep+0x33d/frame 0xffffff881b6c1a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff881b6c1a70
fork_exit() at fork_exit+0x84/frame 0xffffff881b6c1ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff881b6c1ab0
--- trap 0, rip = 0, rsp = 0xffffff881b6c1b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100066 td 0xfffffe005022c000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d53900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d53940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d53980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d539b0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d53a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff87a9d53a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d53ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d53ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d53b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100065 td 0xfffffe005021e000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d4e900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d4e940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d4e980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d4e9b0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d4ea40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff87a9d4ea70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d4eab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d4eab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d4eb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100062 td 0xfffffe0050226000
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d3f900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d3f940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d3f980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d3f9b0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d3fa40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff87a9d3fa70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d3fab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d3fab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d3fb70, rbp = 0 ---

Tracing command kernel pid 0 tid 100061 td 0xfffffe0050226490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d3a900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d3a940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d3a980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d3a9b0
msleep_spin_sbt() at msleep_spin_sbt+0x200/frame 0xffffff87a9d3aa40
taskqueue_thread_loop() at taskqueue_thread_loop+0x8d/frame 0xffffff87a9d3aa70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d3aab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d3aab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d3ab70, rbp = 0 ---

Tracing command kernel pid 0 tid 100060 td 0xfffffe0050090490
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d35900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d35940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d35980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d359b0
msleep_spin_sbt() at msleep_spin_sbt+0x200/frame 0xffffff87a9d35a40
taskqueue_thread_loop() at taskqueue_thread_loop+0x8d/frame 0xffffff87a9d35a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d35ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d35ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d35b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100059 td 0xfffffe0050090920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d30900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d30940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d30980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d309b0
msleep_spin_sbt() at msleep_spin_sbt+0x200/frame 0xffffff87a9d30a40
taskqueue_thread_loop() at taskqueue_thread_loop+0x8d/frame 0xffffff87a9d30a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d30ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d30ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d30b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100056 td 0xfffffe00500a4920
sched_switch() at sched_switch+0x482/frame 0xffffff87a9d21900
mi_switch() at mi_switch+0x179/frame 0xffffff87a9d21940
sleepq_switch() at sleepq_switch+0x185/frame 0xffffff87a9d21980
sleepq_wait() at sleepq_wait+0x43/frame 0xffffff87a9d219b0
_sleep() at _sleep+0x33d/frame 0xffffff87a9d21a40
taskqueue_thread_loop() at taskqueue_thread_loop+0xc8/frame 0xffffff87a9d21a70
fork_exit() at fork_exit+0x84/frame 0xffffff87a9d21ab0
fork_trampoline() at fork_trampoline+0xe/frame 0xffffff87a9d21ab0
--- trap 0, rip = 0, rsp = 0xffffff87a9d21b70, rbp = 0 ---

Tracing command kernel pid 0 tid 100000 td 0xffffffff815e1cf0
sched_switch() at sched_switch+0x482/frame 0xffffffff819329e0
mi_switch() at mi_switch+0x179/frame 0xffffffff81932a20
sleepq_switch() at sleepq_switch+0x185/frame 0xffffffff81932a60
sleepq_timedwait() at sleepq_timedwait+0x43/frame 0xffffffff81932a90
_sleep() at _sleep+0x312/frame 0xffffffff81932b20
swapper() at swapper+0x211/frame 0xffffffff81932b70
btext() at btext+0x2c
db:0:allt>  call doadump
Dumping 2298 out of 31644 MB:..1%..11%..21%..31%..41%..51%..61%..71%..81%..91%
Dump complete
= 0
db:0:doadump>  reset
cpu_reset: Restarting BSP
cpu_reset_proxy: Stopped CPU 19

(kgdb) bt
#0  doadump (textdump=0xd) at pcpu.h:236
#1  0xffffffff8033bcf5 in db_fncall (dummy1=<value optimized out>, dummy2=<value optimized out>, dummy3=<value optimized out>, dummy4=<value optimized out>) at ../../../ddb/db_command.c:578
#2  0xffffffff8033b9dd in db_command (cmd_table=<value optimized out>) at ../../../ddb/db_command.c:449
#3  0xffffffff8033fc3f in db_script_exec (scriptname=0xffffffff815dd180 "doadump", warnifnotfound=<value optimized out>) at ../../../ddb/db_script.c:302
#4  0xffffffff8033b9dd in db_command (cmd_table=<value optimized out>) at ../../../ddb/db_command.c:449
#5  0xffffffff8033b754 in db_command_loop () at ../../../ddb/db_command.c:502
#6  0xffffffff8033e100 in db_trap (type=<value optimized out>, code=0x0) at ../../../ddb/db_main.c:231
#7  0xffffffff808f52f3 in kdb_trap (type=0x3, code=0x0, tf=<value optimized out>) at ../../../kern/subr_kdb.c:654
#8  0xffffffff80cb259b in trap (frame=0xffffff881e02c460) at ../../../amd64/amd64/trap.c:579
#9  0xffffffff80c96a62 in calltrap () at ../../../amd64/amd64/exception.S:232
#10 0xffffffff808f4ace in kdb_enter (why=0xffffffff80f7affb "panic", msg=<value optimized out>) at cpufunc.h:63
#11 0xffffffff808be7c6 in vpanic (fmt=<value optimized out>, ap=<value optimized out>) at ../../../kern/kern_shutdown.c:747
#12 0xffffffff808be676 in kassert_panic (fmt=<value optimized out>) at ../../../kern/kern_shutdown.c:642
#13 0xffffffff80ca4269 in pmap_demote_pde_locked (pmap=0xffffffff81612050, pde=0xfffffe00020028c0, va=0xffffff8023000000, lockp=0xffffff881e02c770) at ../../../amd64/amd64/pmap.c:2690
#14 0xffffffff80ca40dd in pmap_remove_pde (pmap=0xffffffff81612050, pdq=0xfffffe00020028c0, sva=0xffffff8023000000, free=0xffffff881e02c730, lockp=0xffffff881e02c770) at ../../../amd64/amd64/pmap.c:2842
#15 0xffffffff80ca3a20 in pmap_remove (pmap=0xffffffff81612050, sva=0xffffff8023000000, eva=0xffffff8023279000) at ../../../amd64/amd64/pmap.c:3010
#16 0xffffffff80b31fbb in kmem_unback (object=0xffffffff815f0b38, addr=0xffffff8022e79000, size=0x400000) at ../../../vm/vm_kern.c:403
#17 0xffffffff80b320dc in kmem_free (vmem=0xffffffff813e4b80, addr=0xffffff8022e79000, size=0x400000) at ../../../vm/vm_kern.c:426
#18 0xffffffff80b2abc5 in uma_large_free (slab=0xfffffe013c03d4d0) at ../../../vm/uma_core.c:1109
#19 0xffffffff808a5c9f in free (addr=<value optimized out>, mtp=0xffffffff81a183b0) at ../../../kern/kern_malloc.c:602
#20 0xffffffff81a1607c in nullfs_uninit (vfsp=<value optimized out>) at /usr/src/sys/modules/nullfs/../../fs/nullfs/null_subr.c:88
#21 0xffffffff8095769f in vfs_modevent (mod=<value optimized out>, type=<value optimized out>, data=<value optimized out>) at ../../../kern/vfs_init.c:304
#22 0xffffffff808a8a62 in module_unload (mod=0xfffffe0057dad000) at ../../../kern/kern_module.c:265
#23 0xffffffff8089d4bb in linker_file_unload (file=0xfffffe013c04dc00, flags=0x0) at ../../../kern/kern_linker.c:651
#24 0xffffffff8089e5e0 in kern_kldunload (td=0xfffffe0084a84000, fileid=<value optimized out>, flags=0x0) at ../../../kern/kern_linker.c:1123
#25 0xffffffff80cb3202 in amd64_syscall (td=0xfffffe0084a84000, traced=0x0) at subr_syscall.c:134
#26 0xffffffff80c96d4b in Xfast_syscall () at ../../../amd64/amd64/exception.S:391
#27 0x000000080088238a in ?? ()
Previous frame inner to this frame (corrupt stack?)
Current language:  auto; currently minimal
(kgdb) f 13
#13 0xffffffff80ca4269 in pmap_demote_pde_locked (pmap=0xffffffff81612050, pde=0xfffffe00020028c0, va=0xffffff8023000000, lockp=0xffffff881e02c770) at ../../../amd64/amd64/pmap.c:2690
2690            KASSERT((oldpde & (PG_PS | PG_V)) == (PG_PS | PG_V),
(kgdb) l
2685            vm_paddr_t mptepa;
2686            vm_page_t free, mpte;
2687
2688            PMAP_LOCK_ASSERT(pmap, MA_OWNED);
2689            oldpde = *pde;
2690            KASSERT((oldpde & (PG_PS | PG_V)) == (PG_PS | PG_V),
2691                ("pmap_demote_pde: oldpde is missing PG_PS and/or PG_V 0x%jx", 
2692                oldpde));
2693            mpte = pmap_lookup_pt_page(pmap, va);
2694            if (mpte != NULL)
(kgdb) info loc
newpde = 0x0
oldpde = 0x0
firstpte = (pt_entry_t *) 0xffffff881e02c650
newpte = 0x0
mptepa = 0x0
free = 0xffffffff80ca1dda
mpte = 0xffffff881e02c670
(kgdb) p *pmap
$1 = {pm_mtx = {lock_object = {lo_name = 0xffffffff80f8452e "pmap", lo_flags = 0x1430000, lo_data = 0x0, lo_witness = 0xffffff801f8bf900}, mtx_lock = 0xfffffe0084a84000}, pm_pml4 = 0xfffffe0001936000, 
  pm_pvchunk = {tqh_first = 0xfffffe0084483000, tqh_last = 0xfffffe0084483008}, pm_active = {__bits = {0xffffffffffffffff}}, pm_stats = {resident_count = 0xade0, wired_count = 0xaddf}, pm_root = {
    rt_root = 0xfffffe004abe9000}}
(kgdb)

$ svn diff -x -p /usr/src/sys
Index: /usr/src/sys/amd64/amd64/mp_machdep.c
===================================================================
--- /usr/src/sys/amd64/amd64/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/amd64/amd64/mp_machdep.c	(working copy)
@@ -938,10 +938,14 @@ start_all_aps(void)
 		apic_id = cpu_apic_ids[cpu];
 
 		/* allocate and set up an idle stack data page */
-		bootstacks[cpu] = (void *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE);
-		doublefault_stack = (char *)kmem_alloc(kernel_map, PAGE_SIZE);
-		nmi_stack = (char *)kmem_alloc(kernel_map, PAGE_SIZE);
-		dpcpu = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+		bootstacks[cpu] = (void *)kmem_malloc(kernel_arena,
+		    KSTACK_PAGES * PAGE_SIZE, M_WAITOK | M_ZERO);
+		doublefault_stack = (char *)kmem_malloc(kernel_arena,
+		    PAGE_SIZE, M_WAITOK | M_ZERO);
+		nmi_stack = (char *)kmem_malloc(kernel_arena, PAGE_SIZE,
+		    M_WAITOK | M_ZERO);
+		dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
+		    M_WAITOK | M_ZERO);
 
 		bootSTK = (char *)bootstacks[cpu] + KSTACK_PAGES * PAGE_SIZE - 8;
 		bootAP = cpu;
Index: /usr/src/sys/amd64/amd64/pmap.c
===================================================================
--- /usr/src/sys/amd64/amd64/pmap.c	(revision 253832)
+++ /usr/src/sys/amd64/amd64/pmap.c	(working copy)
@@ -860,7 +860,8 @@ pmap_init(void)
 	 */
 	s = (vm_size_t)(pv_npg * sizeof(struct md_page));
 	s = round_page(s);
-	pv_table = (struct md_page *)kmem_alloc(kernel_map, s);
+	pv_table = (struct md_page *)kmem_malloc(kernel_arena, s,
+	    M_WAITOK | M_ZERO);
 	for (i = 0; i < pv_npg; i++)
 		TAILQ_INIT(&pv_table[i].pv_list);
 }
@@ -2687,7 +2688,8 @@ pmap_demote_pde_locked(pmap_t pmap, pd_entry_t *pd
 	PMAP_LOCK_ASSERT(pmap, MA_OWNED);
 	oldpde = *pde;
 	KASSERT((oldpde & (PG_PS | PG_V)) == (PG_PS | PG_V),
-	    ("pmap_demote_pde: oldpde is missing PG_PS and/or PG_V"));
+	    ("pmap_demote_pde: oldpde is missing PG_PS and/or PG_V 0x%jx", 
+	    oldpde));
 	mpte = pmap_lookup_pt_page(pmap, va);
 	if (mpte != NULL)
 		pmap_remove_pt_page(pmap, mpte);
@@ -5023,7 +5025,7 @@ pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, in
 	}
 	offset = pa & PAGE_MASK;
 	size = round_page(offset + size);
-	va = kmem_alloc_nofault(kernel_map, size);
+	va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 	pa = trunc_page(pa);
@@ -5059,7 +5061,7 @@ pmap_unmapdev(vm_offset_t va, vm_size_t size)
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
 	size = round_page(offset + size);
-	kmem_free(kernel_map, base, size);
+	kva_free(kernel_arena, base, size);
 }
 
 /*
Index: /usr/src/sys/amd64/amd64/sys_machdep.c
===================================================================
--- /usr/src/sys/amd64/amd64/sys_machdep.c	(revision 253832)
+++ /usr/src/sys/amd64/amd64/sys_machdep.c	(working copy)
@@ -356,7 +356,7 @@ amd64_set_ioperm(td, uap)
 	 */
 	pcb = td->td_pcb;
 	if (pcb->pcb_tssp == NULL) {
-		tssp = (struct amd64tss *)kmem_malloc(kernel_map,
+		tssp = (struct amd64tss *)kmem_malloc(kernel_arena,
 		    ctob(IOPAGES+1), M_WAITOK);
 		if (tssp == NULL)
 			return (ENOMEM);
@@ -463,7 +463,7 @@ user_ldt_alloc(struct proc *p, int force)
 		return (mdp->md_ldt);
 	mtx_unlock(&dt_lock);
 	new_ldt = malloc(sizeof(struct proc_ldt), M_SUBPROC, M_WAITOK);
-	new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_map,
+	new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_arena,
 	     max_ldt_segment * sizeof(struct user_segment_descriptor),
 	     M_WAITOK);
 	if (new_ldt->ldt_base == NULL) {
@@ -484,7 +484,7 @@ user_ldt_alloc(struct proc *p, int force)
 	mtx_lock(&dt_lock);
 	pldt = mdp->md_ldt;
 	if (pldt != NULL && !force) {
-		kmem_free(kernel_map, (vm_offset_t)new_ldt->ldt_base,
+		kmem_free(kernel_arena, (vm_offset_t)new_ldt->ldt_base,
 		    max_ldt_segment * sizeof(struct user_segment_descriptor));
 		free(new_ldt, M_SUBPROC);
 		return (pldt);
@@ -529,7 +529,7 @@ user_ldt_derefl(struct proc_ldt *pldt)
 {
 
 	if (--pldt->ldt_refcnt == 0) {
-		kmem_free(kernel_map, (vm_offset_t)pldt->ldt_base,
+		kmem_free(kernel_arena, (vm_offset_t)pldt->ldt_base,
 		    max_ldt_segment * sizeof(struct user_segment_descriptor));
 		free(pldt, M_SUBPROC);
 	}
Index: /usr/src/sys/amd64/amd64/vm_machdep.c
===================================================================
--- /usr/src/sys/amd64/amd64/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/amd64/amd64/vm_machdep.c	(working copy)
@@ -342,7 +342,7 @@ cpu_thread_clean(struct thread *td)
 	 * Clean TSS/iomap
 	 */
 	if (pcb->pcb_tssp != NULL) {
-		kmem_free(kernel_map, (vm_offset_t)pcb->pcb_tssp,
+		kva_free(kernel_arena, (vm_offset_t)pcb->pcb_tssp,
 		    ctob(IOPAGES + 1));
 		pcb->pcb_tssp = NULL;
 	}
Index: /usr/src/sys/arm/arm/bus_space_generic.c
===================================================================
--- /usr/src/sys/arm/arm/bus_space_generic.c	(revision 253832)
+++ /usr/src/sys/arm/arm/bus_space_generic.c	(working copy)
@@ -73,7 +73,7 @@ generic_bs_map(void *t, bus_addr_t bpa, bus_size_t
 	offset = bpa & PAGE_MASK;
 	startpa = trunc_page(bpa);
 
-	va = kmem_alloc_nofault(kernel_map, endpa - startpa);
+	va = kva_alloc(kernel_arena, endpa - startpa);
 	if (va == 0)
 		return (ENOMEM);
 
@@ -118,7 +118,7 @@ generic_bs_unmap(void *t, bus_space_handle_t h, bu
 		pmap_kremove(va);
 		va += PAGE_SIZE;
 	}
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 }
 
 void
Index: /usr/src/sys/arm/arm/busdma_machdep-v6.c
===================================================================
--- /usr/src/sys/arm/arm/busdma_machdep-v6.c	(revision 253832)
+++ /usr/src/sys/arm/arm/busdma_machdep-v6.c	(working copy)
@@ -696,10 +696,10 @@ bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr,
 		*vaddr = uma_zalloc(bufzone->umazone, mflags);
 	} else if (dmat->nsegments >= btoc(dmat->maxsize) &&
 	    dmat->alignment <= PAGE_SIZE && dmat->boundary == 0) {
-		*vaddr = (void *)kmem_alloc_attr(kernel_map, dmat->maxsize,
+		*vaddr = (void *)kmem_alloc_attr(kernel_arena, dmat->maxsize,
 		    mflags, 0, dmat->lowaddr, memattr);
 	} else {
-		*vaddr = (void *)kmem_alloc_contig(kernel_map, dmat->maxsize,
+		*vaddr = (void *)kmem_alloc_contig(kernel_arena, dmat->maxsize,
 		    mflags, 0, dmat->lowaddr, dmat->alignment, dmat->boundary,
 		    memattr);
 	}
@@ -744,7 +744,7 @@ bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, b
 	    !_bus_dma_can_bounce(dmat->lowaddr, dmat->highaddr))
 		uma_zfree(bufzone->umazone, vaddr);
 	else
-		kmem_free(kernel_map, (vm_offset_t)vaddr, dmat->maxsize);
+		kmem_free(kernel_arena, (vm_offset_t)vaddr, dmat->maxsize);
 
 	dmat->map_count--;
 	free(map, M_DEVBUF);
Index: /usr/src/sys/arm/arm/busdma_machdep.c
===================================================================
--- /usr/src/sys/arm/arm/busdma_machdep.c	(revision 253832)
+++ /usr/src/sys/arm/arm/busdma_machdep.c	(working copy)
@@ -752,10 +752,10 @@ bus_dmamem_alloc(bus_dma_tag_t dmat, void **vaddrp
 		vaddr = uma_zalloc(bufzone->umazone, mflags);
 	} else if (dmat->nsegments >= btoc(dmat->maxsize) &&
 	    dmat->alignment <= PAGE_SIZE && dmat->boundary == 0) {
-		vaddr = (void *)kmem_alloc_attr(kernel_map, dmat->maxsize,
+		vaddr = (void *)kmem_alloc_attr(kernel_arena, dmat->maxsize,
 		    mflags, 0, dmat->lowaddr, memattr);
 	} else {
-		vaddr = (void *)kmem_alloc_contig(kernel_map, dmat->maxsize,
+		vaddr = (void *)kmem_alloc_contig(kernel_arena, dmat->maxsize,
 		    mflags, 0, dmat->lowaddr, dmat->alignment, dmat->boundary,
 		    memattr);
 	}
@@ -798,7 +798,7 @@ bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, b
 	    !_bus_dma_can_bounce(dmat->lowaddr, dmat->highaddr))
 		uma_zfree(bufzone->umazone, vaddr);
 	else
-		kmem_free(kernel_map, (vm_offset_t)vaddr, dmat->maxsize);
+		kmem_free(kernel_arena, (vm_offset_t)vaddr, dmat->maxsize);
 }
 
 static void
Index: /usr/src/sys/arm/arm/mp_machdep.c
===================================================================
--- /usr/src/sys/arm/arm/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/arm/arm/mp_machdep.c	(working copy)
@@ -112,7 +112,8 @@ cpu_mp_start(void)
 
 	/* Reserve memory for application processors */
 	for(i = 0; i < (mp_ncpus - 1); i++)
-		dpcpu[i] = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+		dpcpu[i] = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
+		    M_WAITOK | M_ZERO);
 	temp_pagetable_va = (vm_offset_t)contigmalloc(L1_TABLE_SIZE,
 	    M_TEMP, 0, 0x0, 0xffffffff, L1_TABLE_SIZE, 0);
 	addr = KERNPHYSADDR;
Index: /usr/src/sys/arm/arm/pmap-v6.c
===================================================================
--- /usr/src/sys/arm/arm/pmap-v6.c	(revision 253832)
+++ /usr/src/sys/arm/arm/pmap-v6.c	(working copy)
@@ -1255,7 +1255,7 @@ pmap_init(void)
 	pv_entry_high_water = 9 * (pv_entry_max / 10);
 
 	pv_maxchunks = MAX(pv_entry_max / _NPCPV, maxproc);
-	pv_chunkbase = (struct pv_chunk *)kmem_alloc_nofault(kernel_map,
+	pv_chunkbase = (struct pv_chunk *)kva_alloc(kernel_arena,
 	    PAGE_SIZE * pv_maxchunks);
 
 	if (pv_chunkbase == NULL)
@@ -4103,7 +4103,7 @@ pmap_mapdev(vm_offset_t pa, vm_size_t size)
 
 	GIANT_REQUIRED;
 
-	va = kmem_alloc_nofault(kernel_map, size);
+	va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 	for (tmpva = va; size > 0;) {
Index: /usr/src/sys/arm/arm/pmap.c
===================================================================
--- /usr/src/sys/arm/arm/pmap.c	(revision 253832)
+++ /usr/src/sys/arm/arm/pmap.c	(working copy)
@@ -4718,7 +4718,7 @@ pmap_mapdev(vm_offset_t pa, vm_size_t size)
 	
 	GIANT_REQUIRED;
 	
-	va = kmem_alloc_nofault(kernel_map, size);
+	va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 	for (tmpva = va; size > 0;) {
Index: /usr/src/sys/arm/arm/vm_machdep.c
===================================================================
--- /usr/src/sys/arm/arm/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/arm/arm/vm_machdep.c	(working copy)
@@ -209,7 +209,7 @@ sf_buf_init(void *arg)
 		
 	sf_buf_active = hashinit(nsfbufs, M_TEMP, &sf_buf_hashmask);
 	TAILQ_INIT(&sf_buf_freelist);
-	sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+	sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP,
 	    M_NOWAIT | M_ZERO);
 	for (i = 0; i < nsfbufs; i++) {
@@ -666,7 +666,8 @@ uma_small_alloc(uma_zone_t zone, int bytes, u_int8
 		if (zone == l2zone &&
 		    pte_l1_s_cache_mode != pte_l1_s_cache_mode_pt) {
 			*flags = UMA_SLAB_KMEM;
-			ret = ((void *)kmem_malloc(kmem_map, bytes, M_NOWAIT));
+			ret = ((void *)kmem_malloc(kmem_arena, bytes,
+			    M_NOWAIT));
 			return (ret);
 		}
 		pflags = malloc2vm_flags(wait) | VM_ALLOC_WIRED;
@@ -700,7 +701,7 @@ uma_small_free(void *mem, int size, u_int8_t flags
 	pt_entry_t *pt;
 
 	if (flags & UMA_SLAB_KMEM)
-		kmem_free(kmem_map, (vm_offset_t)mem, size);
+		kmem_free(kmem_arena, (vm_offset_t)mem, size);
 	else {
 		struct arm_small_page *sp;
 
Index: /usr/src/sys/arm/at91/at91.c
===================================================================
--- /usr/src/sys/arm/at91/at91.c	(revision 253832)
+++ /usr/src/sys/arm/at91/at91.c	(working copy)
@@ -85,7 +85,7 @@ at91_bs_unmap(void *t, bus_space_handle_t h, bus_s
 	endva = va + round_page(size);
 
 	/* Free the kernel virtual mapping. */
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 }
 
 static int
Index: /usr/src/sys/arm/mv/armadaxp/armadaxp_mp.c
===================================================================
--- /usr/src/sys/arm/mv/armadaxp/armadaxp_mp.c	(revision 253832)
+++ /usr/src/sys/arm/mv/armadaxp/armadaxp_mp.c	(working copy)
@@ -113,7 +113,7 @@ platform_mp_start_ap(void)
 	cputype = cpufunc_id();
 	cputype &= CPU_ID_CPU_MASK;
 
-	smp_boot = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
+	smp_boot = kva_alloc(kernel_arena, PAGE_SIZE);
 	pmap_kenter_nocache(smp_boot, 0xffff0000);
 	dst = (uint32_t *) smp_boot;
 
@@ -121,7 +121,7 @@ platform_mp_start_ap(void)
 	    src++, dst++) {
 		*dst = *src;
 	}
-	kmem_free(kernel_map, smp_boot, PAGE_SIZE);
+	kva_free(kernel_arena, smp_boot, PAGE_SIZE);
 
 	if (cputype == CPU_ID_MV88SV584X_V7) {
 		/* Core rev A0 */
Index: /usr/src/sys/arm/s3c2xx0/s3c2xx0_space.c
===================================================================
--- /usr/src/sys/arm/s3c2xx0/s3c2xx0_space.c	(revision 253832)
+++ /usr/src/sys/arm/s3c2xx0/s3c2xx0_space.c	(working copy)
@@ -182,7 +182,7 @@ s3c2xx0_bs_map(void *t, bus_addr_t bpa, bus_size_t
 	startpa = trunc_page(bpa);
 	endpa = round_page(bpa + size);
 
-	va = kmem_alloc_nofault(kernel_map, endpa - startpa);
+	va = kva_alloc(kernel_arena, endpa - startpa);
 	if (!va)
 		return (ENOMEM);
 
@@ -214,7 +214,7 @@ s3c2xx0_bs_unmap(void *t, bus_space_handle_t h, bu
 		pmap_kremove(va);
 		va += PAGE_SIZE;
 	}
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 }
 
 int
Index: /usr/src/sys/arm/xscale/i80321/i80321_space.c
===================================================================
--- /usr/src/sys/arm/xscale/i80321/i80321_space.c	(revision 253832)
+++ /usr/src/sys/arm/xscale/i80321/i80321_space.c	(working copy)
@@ -312,7 +312,7 @@ i80321_mem_bs_unmap(void *t, bus_space_handle_t h,
 	endva = va + round_page(size);
 
 	/* Free the kernel virtual mapping. */
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 }
 
 int
Index: /usr/src/sys/arm/xscale/i8134x/i81342_space.c
===================================================================
--- /usr/src/sys/arm/xscale/i8134x/i81342_space.c	(revision 253832)
+++ /usr/src/sys/arm/xscale/i8134x/i81342_space.c	(working copy)
@@ -324,7 +324,7 @@ i81342_mem_bs_unmap(void *t, bus_space_handle_t h,
 	endva = va + round_page(size);
 
 	/* Free the kernel virtual mapping. */
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 #endif
 }
 
Index: /usr/src/sys/arm/xscale/ixp425/ixp425_pci_space.c
===================================================================
--- /usr/src/sys/arm/xscale/ixp425/ixp425_pci_space.c	(revision 253832)
+++ /usr/src/sys/arm/xscale/ixp425/ixp425_pci_space.c	(working copy)
@@ -432,7 +432,7 @@ ixp425_pci_mem_bs_unmap(void *t, bus_space_handle_
 	endva = va + round_page(size);
 
 	/* Free the kernel virtual mapping. */
-	kmem_free(kernel_map, va, endva - va);
+	kva_free(kernel_arena, va, endva - va);
 }
 
 int
Index: /usr/src/sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c
===================================================================
--- /usr/src/sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c	(revision 253832)
+++ /usr/src/sys/cddl/compat/opensolaris/kern/opensolaris_kmem.c	(working copy)
@@ -62,6 +62,8 @@ static struct mtx kmem_items_mtx;
 MTX_SYSINIT(kmem_items_mtx, &kmem_items_mtx, "kmem_items", MTX_DEF);
 #endif	/* KMEM_DEBUG */
 
+#include <sys/vmem.h>
+
 void *
 zfs_kmem_alloc(size_t size, int kmflags)
 {
@@ -135,7 +137,7 @@ uint64_t
 kmem_used(void)
 {
 
-	return (kmem_map->size);
+	return (vmem_size(kmem_arena, VMEM_ALLOC));
 }
 
 static int
Index: /usr/src/sys/cddl/compat/opensolaris/sys/kmem.h
===================================================================
--- /usr/src/sys/cddl/compat/opensolaris/sys/kmem.h	(revision 253832)
+++ /usr/src/sys/cddl/compat/opensolaris/sys/kmem.h	(working copy)
@@ -32,6 +32,7 @@
 #include <sys/param.h>
 #include <sys/proc.h>
 #include <sys/malloc.h>
+#include <sys/vmem.h>
 
 #include <vm/uma.h>
 #include <vm/vm.h>
@@ -61,8 +62,6 @@ typedef struct kmem_cache {
 	void		*kc_private;
 } kmem_cache_t;
 
-#define vmem_t	void
-
 void *zfs_kmem_alloc(size_t size, int kmflags);
 void zfs_kmem_free(void *buf, size_t size);
 uint64_t kmem_size(void);
Index: /usr/src/sys/compat/ndis/subr_ntoskrnl.c
===================================================================
--- /usr/src/sys/compat/ndis/subr_ntoskrnl.c	(revision 253832)
+++ /usr/src/sys/compat/ndis/subr_ntoskrnl.c	(working copy)
@@ -2489,7 +2489,7 @@ MmAllocateContiguousMemorySpecifyCache(size, lowes
 		break;
 	}
 
-	ret = (void *)kmem_alloc_contig(kernel_map, size, M_ZERO | M_NOWAIT,
+	ret = (void *)kmem_alloc_contig(kernel_arena, size, M_ZERO | M_NOWAIT,
 	    lowest, highest, PAGE_SIZE, boundary, memattr);
 	if (ret != NULL)
 		malloc_type_allocated(M_DEVBUF, round_page(size));
Index: /usr/src/sys/dev/bktr/bktr_core.c
===================================================================
--- /usr/src/sys/dev/bktr/bktr_core.c	(revision 253832)
+++ /usr/src/sys/dev/bktr/bktr_core.c	(working copy)
@@ -109,6 +109,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/kernel.h>
 #include <sys/fcntl.h>
 #include <sys/lock.h>
+#include <sys/malloc.h>
 #include <sys/mutex.h>
 #include <sys/proc.h>
 #include <sys/signalvar.h>
@@ -1801,8 +1802,10 @@ video_ioctl( bktr_ptr_t bktr, int unit, ioctl_cmd_
 #else
                                 buf = get_bktr_mem(unit, temp*PAGE_SIZE);
                                 if (buf != 0) {
-                                        kmem_free(kernel_map, bktr->bigbuf,
-                                          (bktr->alloc_pages * PAGE_SIZE));
+					contigfree(
+					  (void *)(uintptr_t)bktr->bigbuf,
+                                          (bktr->alloc_pages * PAGE_SIZE),
+					  M_DEVBUF);
 #endif                                          
 
 					bktr->bigbuf = buf;
Index: /usr/src/sys/dev/drm/drm_scatter.c
===================================================================
--- /usr/src/sys/dev/drm/drm_scatter.c	(revision 253832)
+++ /usr/src/sys/dev/drm/drm_scatter.c	(working copy)
@@ -52,7 +52,7 @@ drm_sg_alloc(struct drm_device *dev, struct drm_sc
 	entry->busaddr = malloc(entry->pages * sizeof(*entry->busaddr),
 	    DRM_MEM_SGLISTS, M_WAITOK | M_ZERO);
 
-	entry->vaddr = kmem_alloc_attr(kernel_map, size, M_WAITOK | M_ZERO,
+	entry->vaddr = kmem_alloc_attr(kernel_arena, size, M_WAITOK | M_ZERO,
 	    0, BUS_SPACE_MAXADDR_32BIT, VM_MEMATTR_WRITE_COMBINING);
 	if (entry->vaddr == 0) {
 		drm_sg_cleanup(entry);
@@ -99,7 +99,7 @@ drm_sg_cleanup(struct drm_sg_mem *entry)
 		return;
 
 	if (entry->vaddr != 0)
-		kmem_free(kernel_map, entry->vaddr, IDX_TO_OFF(entry->pages));
+		kmem_free(kernel_arena, entry->vaddr, IDX_TO_OFF(entry->pages));
 
 	free(entry->busaddr, DRM_MEM_SGLISTS);
 	free(entry, DRM_MEM_DRIVER);
Index: /usr/src/sys/dev/drm2/drm_scatter.c
===================================================================
--- /usr/src/sys/dev/drm2/drm_scatter.c	(revision 253832)
+++ /usr/src/sys/dev/drm2/drm_scatter.c	(working copy)
@@ -52,7 +52,7 @@ drm_sg_alloc(struct drm_device *dev, struct drm_sc
 	entry->busaddr = malloc(entry->pages * sizeof(*entry->busaddr),
 	    DRM_MEM_SGLISTS, M_WAITOK | M_ZERO);
 
-	entry->vaddr = kmem_alloc_attr(kernel_map, size, M_WAITOK | M_ZERO,
+	entry->vaddr = kmem_alloc_attr(kernel_arena, size, M_WAITOK | M_ZERO,
 	    0, BUS_SPACE_MAXADDR_32BIT, VM_MEMATTR_WRITE_COMBINING);
 	if (entry->vaddr == 0) {
 		drm_sg_cleanup(entry);
@@ -99,7 +99,7 @@ drm_sg_cleanup(struct drm_sg_mem *entry)
 		return;
 
 	if (entry->vaddr != 0)
-		kmem_free(kernel_map, entry->vaddr, IDX_TO_OFF(entry->pages));
+		kmem_free(kernel_arena, entry->vaddr, IDX_TO_OFF(entry->pages));
 
 	free(entry->busaddr, DRM_MEM_SGLISTS);
 	free(entry, DRM_MEM_DRIVER);
Index: /usr/src/sys/dev/drm2/i915/intel_ringbuffer.c
===================================================================
--- /usr/src/sys/dev/drm2/i915/intel_ringbuffer.c	(revision 253832)
+++ /usr/src/sys/dev/drm2/i915/intel_ringbuffer.c	(working copy)
@@ -361,7 +361,7 @@ init_pipe_control(struct intel_ring_buffer *ring)
 		goto err_unref;
 
 	pc->gtt_offset = obj->gtt_offset;
-	pc->cpu_page = (uint32_t *)kmem_alloc_nofault(kernel_map, PAGE_SIZE);
+	pc->cpu_page = (uint32_t *)kva_alloc(kernel_arena, PAGE_SIZE);
 	if (pc->cpu_page == NULL)
 		goto err_unpin;
 	pmap_qenter((uintptr_t)pc->cpu_page, &obj->pages[0], 1);
@@ -392,7 +392,7 @@ cleanup_pipe_control(struct intel_ring_buffer *rin
 
 	obj = pc->obj;
 	pmap_qremove((vm_offset_t)pc->cpu_page, 1);
-	kmem_free(kernel_map, (uintptr_t)pc->cpu_page, PAGE_SIZE);
+	kva_free(kernel_arena, (uintptr_t)pc->cpu_page, PAGE_SIZE);
 	i915_gem_object_unpin(obj);
 	drm_gem_object_unreference(&obj->base);
 
@@ -968,7 +968,7 @@ static void cleanup_status_page(struct intel_ring_
 		return;
 
 	pmap_qremove((vm_offset_t)ring->status_page.page_addr, 1);
-	kmem_free(kernel_map, (vm_offset_t)ring->status_page.page_addr,
+	kva_free(kernel_arena, (vm_offset_t)ring->status_page.page_addr,
 	    PAGE_SIZE);
 	i915_gem_object_unpin(obj);
 	drm_gem_object_unreference(&obj->base);
@@ -999,7 +999,7 @@ static int init_status_page(struct intel_ring_buff
 	}
 
 	ring->status_page.gfx_addr = obj->gtt_offset;
-	ring->status_page.page_addr = (void *)kmem_alloc_nofault(kernel_map,
+	ring->status_page.page_addr = (void *)kva_alloc(kernel_arena,
 	    PAGE_SIZE);
 	if (ring->status_page.page_addr == NULL) {
 		memset(&dev_priv->hws_map, 0, sizeof(dev_priv->hws_map));
Index: /usr/src/sys/dev/drm2/ttm/ttm_bo_util.c
===================================================================
--- /usr/src/sys/dev/drm2/ttm/ttm_bo_util.c	(revision 253832)
+++ /usr/src/sys/dev/drm2/ttm/ttm_bo_util.c	(working copy)
@@ -498,7 +498,7 @@ static int ttm_bo_kmap_ttm(struct ttm_buffer_objec
 			ttm_io_prot(mem->placement);
 		map->bo_kmap_type = ttm_bo_map_vmap;
 		map->num_pages = num_pages;
-		map->virtual = (void *)kmem_alloc_nofault(kernel_map,
+		map->virtual = (void *)kva_alloc(kernel_arena,
 		    num_pages * PAGE_SIZE);
 		if (map->virtual != NULL) {
 			for (i = 0; i < num_pages; i++) {
@@ -561,7 +561,7 @@ void ttm_bo_kunmap(struct ttm_bo_kmap_obj *map)
 		break;
 	case ttm_bo_map_vmap:
 		pmap_qremove((vm_offset_t)(map->virtual), map->num_pages);
-		kmem_free(kernel_map, (vm_offset_t)map->virtual,
+		kva_free(kernel_arena, (vm_offset_t)map->virtual,
 		    map->num_pages * PAGE_SIZE);
 		break;
 	case ttm_bo_map_kmap:
Index: /usr/src/sys/dev/xen/blkback/blkback.c
===================================================================
--- /usr/src/sys/dev/xen/blkback/blkback.c	(revision 253832)
+++ /usr/src/sys/dev/xen/blkback/blkback.c	(working copy)
@@ -2775,7 +2775,7 @@ xbb_free_communication_mem(struct xbb_softc *xbb)
 {
 	if (xbb->kva != 0) {
 #ifndef XENHVM
-		kmem_free(kernel_map, xbb->kva, xbb->kva_size);
+		kva_free(kernel_arena, xbb->kva, xbb->kva_size);
 #else
 		if (xbb->pseudo_phys_res != NULL) {
 			bus_release_resource(xbb->dev, SYS_RES_MEMORY,
@@ -3014,7 +3014,7 @@ xbb_alloc_communication_mem(struct xbb_softc *xbb)
 		device_get_nameunit(xbb->dev), xbb->kva_size,
 		xbb->reqlist_kva_size);
 #ifndef XENHVM
-	xbb->kva = kmem_alloc_nofault(kernel_map, xbb->kva_size);
+	xbb->kva = kva_alloc(kernel_arena, xbb->kva_size);
 	if (xbb->kva == 0)
 		return (ENOMEM);
 	xbb->gnt_base_addr = xbb->kva;
Index: /usr/src/sys/dev/xen/netback/netback.c
===================================================================
--- /usr/src/sys/dev/xen/netback/netback.c	(revision 253832)
+++ /usr/src/sys/dev/xen/netback/netback.c	(working copy)
@@ -621,7 +621,7 @@ xnb_free_communication_mem(struct xnb_softc *xnb)
 {
 	if (xnb->kva != 0) {
 #ifndef XENHVM
-		kmem_free(kernel_map, xnb->kva, xnb->kva_size);
+		kva_free(kernel_arena, xnb->kva, xnb->kva_size);
 #else
 		if (xnb->pseudo_phys_res != NULL) {
 			bus_release_resource(xnb->dev, SYS_RES_MEMORY,
@@ -811,7 +811,7 @@ xnb_alloc_communication_mem(struct xnb_softc *xnb)
 		xnb->kva_size += xnb->ring_configs[i].ring_pages * PAGE_SIZE;
 	}
 #ifndef XENHVM
-	xnb->kva = kmem_alloc_nofault(kernel_map, xnb->kva_size);
+	xnb->kva = kva_alloc(kernel_arena, xnb->kva_size);
 	if (xnb->kva == 0)
 		return (ENOMEM);
 	xnb->gnt_base_addr = xnb->kva;
Index: /usr/src/sys/dev/xen/xenpci/xenpci.c
===================================================================
--- /usr/src/sys/dev/xen/xenpci/xenpci.c	(revision 253832)
+++ /usr/src/sys/dev/xen/xenpci/xenpci.c	(working copy)
@@ -383,7 +383,7 @@ xenpci_attach(device_t dev)
 	if (HYPERVISOR_memory_op(XENMEM_add_to_physmap, &xatp))
 		panic("HYPERVISOR_memory_op failed");
 
-	shared_va = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
+	shared_va = kva_alloc(kernel_arena, PAGE_SIZE);
 	pmap_kenter(shared_va, shared_info_pa);
 	HYPERVISOR_shared_info = (void *) shared_va;
 
Index: /usr/src/sys/i386/i386/machdep.c
===================================================================
--- /usr/src/sys/i386/i386/machdep.c	(revision 253832)
+++ /usr/src/sys/i386/i386/machdep.c	(working copy)
@@ -3178,9 +3178,9 @@ f00f_hack(void *unused)
 
 	printf("Intel Pentium detected, installing workaround for F00F bug\n");
 
-	tmp = kmem_alloc(kernel_map, PAGE_SIZE * 2);
+	tmp = kmem_malloc(kernel_arena, PAGE_SIZE * 2, M_WAITOK | M_ZERO);
 	if (tmp == 0)
-		panic("kmem_alloc returned 0");
+		panic("kmap_alloc returned 0");
 
 	/* Put the problematic entry (#6) at the end of the lower page. */
 	new_idt = (struct gate_descriptor*)
@@ -3189,9 +3189,7 @@ f00f_hack(void *unused)
 	r_idt.rd_base = (u_int)new_idt;
 	lidt(&r_idt);
 	idt = new_idt;
-	if (vm_map_protect(kernel_map, tmp, tmp + PAGE_SIZE,
-			   VM_PROT_READ, FALSE) != KERN_SUCCESS)
-		panic("vm_map_protect failed");
+	pmap_protect(kernel_pmap, tmp, tmp + PAGE_SIZE, VM_PROT_READ);
 }
 #endif /* defined(I586_CPU) && !NO_F00F_HACK */
 
Index: /usr/src/sys/i386/i386/mp_machdep.c
===================================================================
--- /usr/src/sys/i386/i386/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/i386/i386/mp_machdep.c	(working copy)
@@ -959,8 +959,10 @@ start_all_aps(void)
 
 		/* allocate and set up a boot stack data page */
 		bootstacks[cpu] =
-		    (char *)kmem_alloc(kernel_map, KSTACK_PAGES * PAGE_SIZE);
-		dpcpu = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+		    (char *)kmem_malloc(kernel_arena, KSTACK_PAGES * PAGE_SIZE,
+		    M_WAITOK | M_ZERO);
+		dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
+		    M_WAITOK | M_ZERO);
 		/* setup a vector to our boot code */
 		*((volatile u_short *) WARMBOOT_OFF) = WARMBOOT_TARGET;
 		*((volatile u_short *) WARMBOOT_SEG) = (boot_address >> 4);
Index: /usr/src/sys/i386/i386/pmap.c
===================================================================
--- /usr/src/sys/i386/i386/pmap.c	(revision 253832)
+++ /usr/src/sys/i386/i386/pmap.c	(working copy)
@@ -655,7 +655,7 @@ pmap_pdpt_allocf(uma_zone_t zone, int bytes, u_int
 
 	/* Inform UMA that this allocator uses kernel_map/object. */
 	*flags = UMA_SLAB_KERNEL;
-	return ((void *)kmem_alloc_contig(kernel_map, bytes, wait, 0x0ULL,
+	return ((void *)kmem_alloc_contig(kernel_arena, bytes, wait, 0x0ULL,
 	    0xffffffffULL, 1, 0, VM_MEMATTR_DEFAULT));
 }
 #endif
@@ -783,12 +783,13 @@ pmap_init(void)
 	 */
 	s = (vm_size_t)(pv_npg * sizeof(struct md_page));
 	s = round_page(s);
-	pv_table = (struct md_page *)kmem_alloc(kernel_map, s);
+	pv_table = (struct md_page *)kmem_malloc(kernel_arena, s,
+	    M_WAITOK | M_ZERO);
 	for (i = 0; i < pv_npg; i++)
 		TAILQ_INIT(&pv_table[i].pv_list);
 
 	pv_maxchunks = MAX(pv_entry_max / _NPCPV, maxproc);
-	pv_chunkbase = (struct pv_chunk *)kmem_alloc_nofault(kernel_map,
+	pv_chunkbase = (struct pv_chunk *)kva_alloc(kernel_arena,
 	    PAGE_SIZE * pv_maxchunks);
 	if (pv_chunkbase == NULL)
 		panic("pmap_init: not enough kvm for pv chunks");
@@ -1747,7 +1748,7 @@ pmap_pinit(pmap_t pmap)
 	 * page directory table.
 	 */
 	if (pmap->pm_pdir == NULL) {
-		pmap->pm_pdir = (pd_entry_t *)kmem_alloc_nofault(kernel_map,
+		pmap->pm_pdir = (pd_entry_t *)kva_alloc(kernel_arena,
 		    NBPTD);
 		if (pmap->pm_pdir == NULL) {
 			PMAP_LOCK_DESTROY(pmap);
@@ -5007,7 +5008,7 @@ pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, in
 	if (pa < KERNLOAD && pa + size <= KERNLOAD)
 		va = KERNBASE + pa;
 	else
-		va = kmem_alloc_nofault(kernel_map, size);
+		va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 
@@ -5042,7 +5043,7 @@ pmap_unmapdev(vm_offset_t va, vm_size_t size)
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
 	size = round_page(offset + size);
-	kmem_free(kernel_map, base, size);
+	kva_free(kernel_arena, base, size);
 }
 
 /*
Index: /usr/src/sys/i386/i386/sys_machdep.c
===================================================================
--- /usr/src/sys/i386/i386/sys_machdep.c	(revision 253832)
+++ /usr/src/sys/i386/i386/sys_machdep.c	(working copy)
@@ -164,7 +164,7 @@ sysarch(td, uap)
 		break;
 	case I386_SET_LDT:
 		if (kargs.largs.descs != NULL) {
-			lp = (union descriptor *)kmem_malloc(kernel_map,
+			lp = (union descriptor *)kmem_malloc(kernel_arena,
 			    kargs.largs.num * sizeof(union descriptor),
 			    M_WAITOK);
 			if (lp == NULL) {
@@ -175,7 +175,7 @@ sysarch(td, uap)
 			    kargs.largs.num * sizeof(union descriptor));
 			if (error == 0)
 				error = i386_set_ldt(td, &kargs.largs, lp);
-			kmem_free(kernel_map, (vm_offset_t)lp,
+			kmem_free(kernel_arena, (vm_offset_t)lp,
 			    kargs.largs.num * sizeof(union descriptor));
 		} else {
 			error = i386_set_ldt(td, &kargs.largs, NULL);
@@ -299,7 +299,7 @@ i386_extend_pcb(struct thread *td)
 		0			/* granularity */
 	};
 
-	ext = (struct pcb_ext *)kmem_malloc(kernel_map, ctob(IOPAGES+1),
+	ext = (struct pcb_ext *)kmem_malloc(kernel_arena, ctob(IOPAGES+1),
 	    M_WAITOK);
 	if (ext == 0)
 		return (ENOMEM);
@@ -473,7 +473,7 @@ user_ldt_alloc(struct mdproc *mdp, int len)
                 M_SUBPROC, M_WAITOK); 
  
         new_ldt->ldt_len = len = NEW_MAX_LD(len); 
-        new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_map, 
+        new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_arena, 
                 round_page(len * sizeof(union descriptor)), M_WAITOK);
         if (new_ldt->ldt_base == NULL) { 
                 free(new_ldt, M_SUBPROC);
@@ -513,7 +513,7 @@ user_ldt_alloc(struct mdproc *mdp, int len)
 		M_SUBPROC, M_WAITOK);
 
 	new_ldt->ldt_len = len = NEW_MAX_LD(len);
-	new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_map,
+	new_ldt->ldt_base = (caddr_t)kmem_malloc(kernel_arena,
 		len * sizeof(union descriptor), M_WAITOK);
 	if (new_ldt->ldt_base == NULL) {
 		free(new_ldt, M_SUBPROC);
@@ -576,7 +576,7 @@ user_ldt_deref(struct proc_ldt *pldt)
 	mtx_assert(&dt_lock, MA_OWNED);
 	if (--pldt->ldt_refcnt == 0) {
 		mtx_unlock_spin(&dt_lock);
-		kmem_free(kernel_map, (vm_offset_t)pldt->ldt_base,
+		kmem_free(kernel_arena, (vm_offset_t)pldt->ldt_base,
 			pldt->ldt_len * sizeof(union descriptor));
 		free(pldt, M_SUBPROC);
 	} else
@@ -855,7 +855,7 @@ i386_ldt_grow(struct thread *td, int len)
 				 * free the new object and return.
 				 */
 				mtx_unlock_spin(&dt_lock);
-				kmem_free(kernel_map,
+				kmem_free(kernel_arena,
 				   (vm_offset_t)new_ldt->ldt_base,
 				   new_ldt->ldt_len * sizeof(union descriptor));
 				free(new_ldt, M_SUBPROC);
@@ -889,7 +889,7 @@ i386_ldt_grow(struct thread *td, int len)
 		mtx_unlock_spin(&dt_lock);
 #endif
 		if (old_ldt_base != NULL_LDT_BASE) {
-			kmem_free(kernel_map, (vm_offset_t)old_ldt_base,
+			kmem_free(kernel_arena, (vm_offset_t)old_ldt_base,
 			    old_ldt_len * sizeof(union descriptor));
 			free(new_ldt, M_SUBPROC);
 		}
Index: /usr/src/sys/i386/i386/vm_machdep.c
===================================================================
--- /usr/src/sys/i386/i386/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/i386/i386/vm_machdep.c	(working copy)
@@ -355,7 +355,7 @@ cpu_thread_clean(struct thread *td)
 		 * XXX do we need to move the TSS off the allocated pages
 		 * before freeing them?  (not done here)
 		 */
-		kmem_free(kernel_map, (vm_offset_t)pcb->pcb_ext,
+		kva_free(kernel_arena, (vm_offset_t)pcb->pcb_ext,
 		    ctob(IOPAGES + 1));
 		pcb->pcb_ext = NULL;
 	}
@@ -751,7 +751,7 @@ sf_buf_init(void *arg)
 
 	sf_buf_active = hashinit(nsfbufs, M_TEMP, &sf_buf_hashmask);
 	TAILQ_INIT(&sf_buf_freelist);
-	sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+	sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP,
 	    M_NOWAIT | M_ZERO);
 	for (i = 0; i < nsfbufs; i++) {
Index: /usr/src/sys/i386/pci/pci_cfgreg.c
===================================================================
--- /usr/src/sys/i386/pci/pci_cfgreg.c	(revision 253832)
+++ /usr/src/sys/i386/pci/pci_cfgreg.c	(working copy)
@@ -562,7 +562,7 @@ pcie_cfgregopen(uint64_t base, uint8_t minbus, uin
 		if (pcie_array == NULL)
 			return (0);
 
-		va = kmem_alloc_nofault(kernel_map, PCIE_CACHE * PAGE_SIZE);
+		va = kva_alloc(kernel_arena, PCIE_CACHE * PAGE_SIZE);
 		if (va == 0) {
 			free(pcie_array, M_DEVBUF);
 			return (0);
Index: /usr/src/sys/i386/xen/mp_machdep.c
===================================================================
--- /usr/src/sys/i386/xen/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/i386/xen/mp_machdep.c	(working copy)
@@ -746,7 +746,8 @@ start_all_aps(void)
 		/* Get per-cpu data */
 		pc = &__pcpu[bootAP];
 		pcpu_init(pc, bootAP, sizeof(struct pcpu));
-		dpcpu_init((void *)kmem_alloc(kernel_map, DPCPU_SIZE), bootAP);
+		dpcpu_init((void *)kmem_malloc(kernel_arena, DPCPU_SIZE),
+		    bootAP, M_WAITOK | M_ZERO);
 		pc->pc_apic_id = cpu_apic_ids[bootAP];
 		pc->pc_prvspace = pc;
 		pc->pc_curthread = 0;
@@ -833,8 +834,8 @@ cpu_initialize_context(unsigned int cpu)
 		pmap_zero_page(m[i]);
 
 	}
-	boot_stack = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
-	newPTD = kmem_alloc_nofault(kernel_map, NPGPTD * PAGE_SIZE);
+	boot_stack = kva_alloc(kernel_arena, PAGE_SIZE);
+	newPTD = kva_alloc(kernel_arena, NPGPTD * PAGE_SIZE);
 	ma[0] = VM_PAGE_TO_MACH(m[0])|PG_V;
 
 #ifdef PAE	
@@ -856,7 +857,7 @@ cpu_initialize_context(unsigned int cpu)
 	    nkpt*sizeof(vm_paddr_t));
 
 	pmap_qremove(newPTD, 4);
-	kmem_free(kernel_map, newPTD, 4 * PAGE_SIZE);
+	kva_free(kernel_arena, newPTD, 4 * PAGE_SIZE);
 	/*
 	 * map actual idle stack to boot_stack
 	 */
Index: /usr/src/sys/i386/xen/pmap.c
===================================================================
--- /usr/src/sys/i386/xen/pmap.c	(revision 253832)
+++ /usr/src/sys/i386/xen/pmap.c	(working copy)
@@ -620,7 +620,7 @@ pmap_init(void)
 	pv_entry_high_water = 9 * (pv_entry_max / 10);
 
 	pv_maxchunks = MAX(pv_entry_max / _NPCPV, maxproc);
-	pv_chunkbase = (struct pv_chunk *)kmem_alloc_nofault(kernel_map,
+	pv_chunkbase = (struct pv_chunk *)kva_alloc(kernel_arena,
 	    PAGE_SIZE * pv_maxchunks);
 	if (pv_chunkbase == NULL)
 		panic("pmap_init: not enough kvm for pv chunks");
@@ -1460,7 +1460,7 @@ pmap_pinit(pmap_t pmap)
 	 * page directory table.
 	 */
 	if (pmap->pm_pdir == NULL) {
-		pmap->pm_pdir = (pd_entry_t *)kmem_alloc_nofault(kernel_map,
+		pmap->pm_pdir = (pd_entry_t *)kva_alloc(kernel_arena,
 		    NBPTD);
 		if (pmap->pm_pdir == NULL) {
 			PMAP_LOCK_DESTROY(pmap);
@@ -1470,7 +1470,7 @@ pmap_pinit(pmap_t pmap)
 			return (0);
 		}
 #ifdef PAE
-		pmap->pm_pdpt = (pd_entry_t *)kmem_alloc_nofault(kernel_map, 1);
+		pmap->pm_pdpt = (pd_entry_t *)kva_alloc(kernel_arena, 1);
 #endif
 	}
 
@@ -4022,7 +4022,7 @@ pmap_mapdev_attr(vm_paddr_t pa, vm_size_t size, in
 	if (pa < KERNLOAD && pa + size <= KERNLOAD)
 		va = KERNBASE + pa;
 	else
-		va = kmem_alloc_nofault(kernel_map, size);
+		va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 
@@ -4057,7 +4057,7 @@ pmap_unmapdev(vm_offset_t va, vm_size_t size)
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
 	size = round_page(offset + size);
-	kmem_free(kernel_map, base, size);
+	kva_free(kernel_arena, base, size);
 }
 
 /*
Index: /usr/src/sys/ia64/ia64/mp_machdep.c
===================================================================
--- /usr/src/sys/ia64/ia64/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/ia64/ia64/mp_machdep.c	(working copy)
@@ -304,7 +304,8 @@ cpu_mp_add(u_int acpi_id, u_int id, u_int eid)
 	if (cpuid != 0) {
 		pc = (struct pcpu *)malloc(sizeof(*pc), M_SMP, M_WAITOK);
 		pcpu_init(pc, cpuid, sizeof(*pc));
-		dpcpu = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+		dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
+		    M_WAITOK | M_ZERO);
 		dpcpu_init(dpcpu, cpuid);
 	} else
 		pc = pcpup;
Index: /usr/src/sys/kern/imgact_gzip.c
===================================================================
--- /usr/src/sys/kern/imgact_gzip.c	(revision 253832)
+++ /usr/src/sys/kern/imgact_gzip.c	(working copy)
@@ -137,7 +137,7 @@ exec_gzip_imgact(imgp)
 	}
 
 	if (igz.inbuf)
-		kmem_free_wakeup(exec_map, (vm_offset_t)igz.inbuf, PAGE_SIZE);
+		kmap_free_wakeup(exec_map, (vm_offset_t)igz.inbuf, PAGE_SIZE);
 	if (igz.error || error) {
 		printf("Output=%lu ", igz.output);
 		printf("Inflate_error=%d igz.error=%d where=%d\n",
@@ -310,7 +310,7 @@ NextByte(void *vp)
 		return igz->inbuf[(igz->idx++) - igz->offset];
 	}
 	if (igz->inbuf)
-		kmem_free_wakeup(exec_map, (vm_offset_t)igz->inbuf, PAGE_SIZE);
+		kmap_free_wakeup(exec_map, (vm_offset_t)igz->inbuf, PAGE_SIZE);
 	igz->offset = igz->idx & ~PAGE_MASK;
 
 	error = vm_mmap(exec_map,	/* map */
Index: /usr/src/sys/kern/init_main.c
===================================================================
--- /usr/src/sys/kern/init_main.c	(revision 253832)
+++ /usr/src/sys/kern/init_main.c	(working copy)
@@ -461,11 +461,6 @@ proc0_init(void *dummy __unused)
 	sleepinit();
 
 	/*
-	 * additional VM structures
-	 */
-	vm_init2();
-
-	/*
 	 * Create process 0 (the swapper).
 	 */
 	LIST_INSERT_HEAD(&allproc, p, p_list);
Index: /usr/src/sys/kern/kern_exec.c
===================================================================
--- /usr/src/sys/kern/kern_exec.c	(revision 253832)
+++ /usr/src/sys/kern/kern_exec.c	(working copy)
@@ -1192,7 +1192,7 @@ int
 exec_alloc_args(struct image_args *args)
 {
 
-	args->buf = (char *)kmem_alloc_wait(exec_map, PATH_MAX + ARG_MAX);
+	args->buf = (char *)kmap_alloc_wait(exec_map, PATH_MAX + ARG_MAX);
 	return (args->buf != NULL ? 0 : ENOMEM);
 }
 
@@ -1201,7 +1201,7 @@ exec_free_args(struct image_args *args)
 {
 
 	if (args->buf != NULL) {
-		kmem_free_wakeup(exec_map, (vm_offset_t)args->buf,
+		kmap_free_wakeup(exec_map, (vm_offset_t)args->buf,
 		    PATH_MAX + ARG_MAX);
 		args->buf = NULL;
 	}
Index: /usr/src/sys/kern/kern_malloc.c
===================================================================
--- /usr/src/sys/kern/kern_malloc.c	(revision 253832)
+++ /usr/src/sys/kern/kern_malloc.c	(working copy)
@@ -62,9 +62,11 @@ __FBSDID("$FreeBSD$");
 #include <sys/sbuf.h>
 #include <sys/sysctl.h>
 #include <sys/time.h>
+#include <sys/vmem.h>
 
 #include <vm/vm.h>
 #include <vm/pmap.h>
+#include <vm/vm_pageout.h>
 #include <vm/vm_param.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_extern.h>
@@ -113,14 +115,9 @@ MALLOC_DEFINE(M_TEMP, "temp", "misc temporary data
 MALLOC_DEFINE(M_IP6OPT, "ip6opt", "IPv6 options");
 MALLOC_DEFINE(M_IP6NDP, "ip6ndp", "IPv6 Neighbor Discovery");
 
-static void kmeminit(void *);
-SYSINIT(kmem, SI_SUB_KMEM, SI_ORDER_FIRST, kmeminit, NULL);
-
 static MALLOC_DEFINE(M_FREE, "free", "should be on free list");
 
 static struct malloc_type *kmemstatistics;
-static vm_offset_t kmembase;
-static vm_offset_t kmemlimit;
 static int kmemcount;
 
 #define KMEM_ZSHIFT	4
@@ -205,12 +202,12 @@ SYSCTL_UINT(_vm, OID_AUTO, kmem_size_scale, CTLFLA
 static int sysctl_kmem_map_size(SYSCTL_HANDLER_ARGS);
 SYSCTL_PROC(_vm, OID_AUTO, kmem_map_size,
     CTLFLAG_RD | CTLTYPE_ULONG | CTLFLAG_MPSAFE, NULL, 0,
-    sysctl_kmem_map_size, "LU", "Current kmem_map allocation size");
+    sysctl_kmem_map_size, "LU", "Current kmem allocation size");
 
 static int sysctl_kmem_map_free(SYSCTL_HANDLER_ARGS);
 SYSCTL_PROC(_vm, OID_AUTO, kmem_map_free,
     CTLFLAG_RD | CTLTYPE_ULONG | CTLFLAG_MPSAFE, NULL, 0,
-    sysctl_kmem_map_free, "LU", "Largest contiguous free range in kmem_map");
+    sysctl_kmem_map_free, "LU", "Free space in kmem");
 
 /*
  * The malloc_mtx protects the kmemstatistics linked list.
@@ -255,7 +252,7 @@ sysctl_kmem_map_size(SYSCTL_HANDLER_ARGS)
 {
 	u_long size;
 
-	size = kmem_map->size;
+	size = vmem_size(kmem_arena, VMEM_ALLOC);
 	return (sysctl_handle_long(oidp, &size, 0, req));
 }
 
@@ -264,10 +261,7 @@ sysctl_kmem_map_free(SYSCTL_HANDLER_ARGS)
 {
 	u_long size;
 
-	vm_map_lock_read(kmem_map);
-	size = kmem_map->root != NULL ? kmem_map->root->max_free :
-	    kmem_map->max_offset - kmem_map->min_offset;
-	vm_map_unlock_read(kmem_map);
+	size = vmem_size(kmem_arena, VMEM_FREE);
 	return (sysctl_handle_long(oidp, &size, 0, req));
 }
 
@@ -422,7 +416,7 @@ contigmalloc(unsigned long size, struct malloc_typ
 {
 	void *ret;
 
-	ret = (void *)kmem_alloc_contig(kernel_map, size, flags, low, high,
+	ret = (void *)kmem_alloc_contig(kernel_arena, size, flags, low, high,
 	    alignment, boundary, VM_MEMATTR_DEFAULT);
 	if (ret != NULL)
 		malloc_type_allocated(type, round_page(size));
@@ -440,7 +434,7 @@ void
 contigfree(void *addr, unsigned long size, struct malloc_type *type)
 {
 
-	kmem_free(kernel_map, (vm_offset_t)addr, size);
+	kmem_free(kernel_arena, (vm_offset_t)addr, size);
 	malloc_type_freed(type, round_page(size));
 }
 
@@ -683,18 +677,24 @@ reallocf(void *addr, unsigned long size, struct ma
 }
 
 /*
- * Initialize the kernel memory allocator
+ * Wake the page daemon when we exhaust KVA.  It will call the lowmem handler
+ * and uma_reclaim() callbacks in a context that is safe.
  */
-/* ARGSUSED*/
 static void
-kmeminit(void *dummy)
+kmem_reclaim(vmem_t *vm, int flags)
 {
-	uint8_t indx;
+
+	pagedaemon_wakeup();
+}
+
+/*
+ * Initialize the kernel memory arena.
+ */
+void
+kmeminit(void)
+{
 	u_long mem_size, tmp;
-	int i;
  
-	mtx_init(&malloc_mtx, "malloc", NULL, MTX_DEF);
-
 	/*
 	 * Try to auto-tune the kernel memory size, so that it is
 	 * more applicable for a wider range of machine sizes.  The
@@ -747,9 +747,10 @@ static void
 #else
 	tmp = vm_kmem_size;
 #endif
-	kmem_map = kmem_suballoc(kernel_map, &kmembase, &kmemlimit,
-	    tmp, TRUE);
-	kmem_map->system_map = 1;
+	vmem_init(kmem_arena, "kmem arena",
+	    kva_alloc(kernel_arena, tmp),
+	    tmp, PAGE_SIZE, PAGE_SIZE * 16, 0);
+	vmem_set_reclaim(kmem_arena, kmem_reclaim);
 
 #ifdef DEBUG_MEMGUARD
 	/*
@@ -757,9 +758,24 @@ static void
 	 * replacement allocator used for detecting tamper-after-free
 	 * scenarios as they occur.  It is only used for debugging.
 	 */
-	memguard_init(kmem_map);
+	memguard_init(kmem_arena);
 #endif
+}
 
+/*
+ * Initialize the kernel memory allocator
+ */
+/* ARGSUSED*/
+static void
+mallocinit(void *dummy)
+{
+	int i;
+	uint8_t indx;
+
+	mtx_init(&malloc_mtx, "malloc", NULL, MTX_DEF);
+
+	kmeminit();
+
 	uma_startup2();
 
 	mt_zone = uma_zcreate("mt_zone", sizeof(struct malloc_type_internal),
@@ -789,6 +805,7 @@ static void
 		
 	}
 }
+SYSINIT(kmem, SI_SUB_KMEM, SI_ORDER_FIRST, mallocinit, NULL);
 
 void
 malloc_init(void *data)
Index: /usr/src/sys/kern/kern_mbuf.c
===================================================================
--- /usr/src/sys/kern/kern_mbuf.c	(revision 253832)
+++ /usr/src/sys/kern/kern_mbuf.c	(working copy)
@@ -121,8 +121,7 @@ tunable_mbinit(void *dummy)
 	 * available kernel memory (physical or kmem).
 	 * At most it can be 3/4 of available kernel memory.
 	 */
-	realmem = qmin((quad_t)physmem * PAGE_SIZE,
-	    vm_map_max(kmem_map) - vm_map_min(kmem_map));
+	realmem = qmin((quad_t)physmem * PAGE_SIZE, vm_kmem_size);
 	maxmbufmem = realmem / 2;
 	TUNABLE_QUAD_FETCH("kern.ipc.maxmbufmem", &maxmbufmem);
 	if (maxmbufmem > realmem / 4 * 3)
@@ -395,7 +394,7 @@ mbuf_jumbo_alloc(uma_zone_t zone, int bytes, uint8
 
 	/* Inform UMA that this allocator uses kernel_map/object. */
 	*flags = UMA_SLAB_KERNEL;
-	return ((void *)kmem_alloc_contig(kernel_map, bytes, wait,
+	return ((void *)kmem_alloc_contig(kernel_arena, bytes, wait,
 	    (vm_paddr_t)0, ~(vm_paddr_t)0, 1, 0, VM_MEMATTR_DEFAULT));
 }
 
Index: /usr/src/sys/kern/kern_sharedpage.c
===================================================================
--- /usr/src/sys/kern/kern_sharedpage.c	(revision 253832)
+++ /usr/src/sys/kern/kern_sharedpage.c	(working copy)
@@ -112,7 +112,7 @@ shared_page_init(void *dummy __unused)
 	    VM_ALLOC_ZERO);
 	m->valid = VM_PAGE_BITS_ALL;
 	VM_OBJECT_WUNLOCK(shared_page_obj);
-	addr = kmem_alloc_nofault(kernel_map, PAGE_SIZE);
+	addr = kva_alloc(kernel_arena, PAGE_SIZE);
 	pmap_qenter(addr, &m, 1);
 	shared_page_mapping = (char *)addr;
 }
Index: /usr/src/sys/kern/subr_blist.c
===================================================================
--- /usr/src/sys/kern/subr_blist.c	(revision 253832)
+++ /usr/src/sys/kern/subr_blist.c	(working copy)
@@ -181,6 +181,8 @@ blist_create(daddr_t blocks, int flags)
 	    blst_radix_init(NULL, bl->bl_radix, bl->bl_skip, blocks);
 	bl->bl_root = malloc(sizeof(blmeta_t) * bl->bl_rootblks, M_SWAP, flags);
 
+	printf("blist: Allocated %p, %p\n", bl->bl_root, bl);
+
 #if defined(BLIST_DEBUG)
 	printf(
 		"BLIST representing %lld blocks (%lld MB of swap)"
@@ -200,6 +202,7 @@ blist_create(daddr_t blocks, int flags)
 void 
 blist_destroy(blist_t bl)
 {
+	printf("blist: Freeing %p, %p\n", bl->bl_root, bl);
 	free(bl->bl_root, M_SWAP);
 	free(bl, M_SWAP);
 }
Index: /usr/src/sys/kern/subr_busdma_bufalloc.c
===================================================================
--- /usr/src/sys/kern/subr_busdma_bufalloc.c	(revision 253832)
+++ /usr/src/sys/kern/subr_busdma_bufalloc.c	(working copy)
@@ -155,7 +155,7 @@ busdma_bufalloc_alloc_uncacheable(uma_zone_t zone,
 	/* Inform UMA that this allocator uses kernel_map/object. */
 	*pflag = UMA_SLAB_KERNEL;
 
-	return ((void *)kmem_alloc_attr(kernel_map, size, wait, 0,
+	return ((void *)kmem_alloc_attr(kernel_arena, size, wait, 0,
 	    BUS_SPACE_MAXADDR, VM_MEMATTR_UNCACHEABLE));
 
 #else
Index: /usr/src/sys/kern/subr_vmem.c
===================================================================
--- /usr/src/sys/kern/subr_vmem.c	(revision 253832)
+++ /usr/src/sys/kern/subr_vmem.c	(working copy)
@@ -54,6 +54,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/mutex.h>
 #include <sys/smp.h>
 #include <sys/condvar.h>
+#include <sys/sysctl.h>
 #include <sys/taskqueue.h>
 #include <sys/vmem.h>
 
@@ -61,6 +62,7 @@ __FBSDID("$FreeBSD$");
 #include <vm/vm.h>
 #include <vm/pmap.h>
 #include <vm/vm_map.h>
+#include <vm/vm_object.h>
 #include <vm/vm_kern.h>
 #include <vm/vm_extern.h>
 #include <vm/vm_param.h>
@@ -164,6 +166,9 @@ struct vmem_btag {
 #define	BT_END(bt)	((bt)->bt_start + (bt)->bt_size - 1)
 
 #if defined(DIAGNOSTIC)
+static int do_vmem_check = 1;
+SYSCTL_INT(_debug, OID_AUTO, do_vmem_check, CTLFLAG_RW,
+    &do_vmem_check, 0, "Enable vmem check");
 static void vmem_check(vmem_t *);
 #endif
 
@@ -213,8 +218,12 @@ static LIST_HEAD(, vmem) vmem_list = LIST_HEAD_INI
 static uma_zone_t vmem_bt_zone;
 
 /* boot time arena storage. */
+static struct vmem kernel_arena_storage;
+static struct vmem kmem_arena_storage;
 static struct vmem buffer_arena_storage;
 static struct vmem transient_arena_storage;
+vmem_t *kernel_arena = &kernel_arena_storage;
+vmem_t *kmem_arena = &kmem_arena_storage;
 vmem_t *buffer_arena = &buffer_arena_storage;
 vmem_t *transient_arena = &transient_arena_storage;
 
@@ -231,6 +240,14 @@ bt_fill(vmem_t *vm, int flags)
 	VMEM_ASSERT_LOCKED(vm);
 
 	/*
+	 * Only allow the kernel arena to dip into reserve tags.  It is the
+	 * vmem where new tags come from.
+	 */
+	flags &= BT_FLAGS;
+	if (vm != kmem_arena)
+		flags &= ~M_USE_RESERVE;
+
+	/*
 	 * Loop until we meet the reserve.  To minimize the lock shuffle
 	 * and prevent simultaneous fills we first try a NOWAIT regardless
 	 * of the caller's flags.  Specify M_NOVM so we don't recurse while
@@ -545,6 +562,78 @@ qc_drain(vmem_t *vm)
 		zone_drain(vm->vm_qcache[i].qc_cache);
 }
 
+#ifndef UMA_MD_SMALL_ALLOC
+
+static struct mtx_padalign vmem_bt_lock;
+
+/*
+ * vmem_bt_alloc:  Allocate a new page of boundary tags.
+ *
+ * On architectures with uma_small_alloc there is no recursion; no address
+ * space need be allocated to allocate boundary tags.  For the others, we
+ * must handle recursion.  Boundary tags are necessary to allocate new
+ * boundary tags.
+ *
+ * UMA guarantees that enough tags are held in reserve to allocate a new
+ * page of kva.  We dip into this reserve by specifying M_USE_RESERVE only
+ * when allocating the page to hold new boundary tags.  In this way the
+ * reserve is automatically filled by the allocation that uses the reserve.
+ * 
+ * We still have to guarantee that the new tags are allocated atomically since
+ * many threads may try concurrently.  The bt_lock provides this guarantee.
+ * We convert WAITOK allocations to NOWAIT and then handle the blocking here
+ * on failure.  It's ok to return NULL for a WAITOK allocation as UMA will
+ * loop again after checking to see if we lost the race to allocate.
+ *
+ * There is a small race between vmem_bt_alloc() returning the page and the
+ * zone lock being acquired to add the page to the zone.  For WAITOK
+ * allocations we just pause briefly.  NOWAIT may experience a transient
+ * failure.  To alleviate this we permit a small number of simultaneous
+ * fills to proceed concurrently so NOWAIT is less likely to fail unless
+ * we are really out of KVA.
+ */
+static void *
+vmem_bt_alloc(uma_zone_t zone, int bytes, uint8_t *pflag, int wait)
+{
+	vmem_addr_t addr;
+
+	*pflag = UMA_SLAB_KMEM;
+
+	/*
+	 * Single thread boundary tag allocation so that the address space
+	 * and memory are added in one atomic operation.
+	 */
+	mtx_lock(&vmem_bt_lock);
+	if (vmem_xalloc(kmem_arena, bytes, 0, 0, 0, VMEM_ADDR_MIN,
+	    VMEM_ADDR_MAX, M_NOWAIT | M_NOVM | M_USE_RESERVE | M_BESTFIT,
+	    &addr) == 0) {
+//		if (kmem_back(addr, kernel_object, bytes,
+		if (kmem_back(kernel_object, addr, bytes,
+		    M_NOWAIT | M_USE_RESERVE) == 0) {
+			mtx_unlock(&vmem_bt_lock);
+			return ((void *)addr);
+		}
+		vmem_xfree(kmem_arena, addr, bytes);
+		mtx_unlock(&vmem_bt_lock);
+		/*
+		 * Out of memory, not address space.  This may not even be
+		 * possible due to M_USE_RESERVE page allocation.
+		 */
+		if (wait & M_WAITOK)
+			VM_WAIT;
+		return (NULL);
+	}
+	mtx_unlock(&vmem_bt_lock);
+	/*
+	 * We're either out of address space or lost a fill race.
+	 */
+	if (wait & M_WAITOK)
+		pause("btalloc", 1);
+
+	return (NULL);
+}
+#endif
+
 void
 vmem_startup(void)
 {
@@ -553,6 +642,17 @@ vmem_startup(void)
 	vmem_bt_zone = uma_zcreate("vmem btag",
 	    sizeof(struct vmem_btag), NULL, NULL, NULL, NULL,
 	    UMA_ALIGN_PTR, UMA_ZONE_VM);
+#ifndef UMA_MD_SMALL_ALLOC
+	mtx_init(&vmem_bt_lock, "btag lock", NULL, MTX_DEF);
+	uma_prealloc(vmem_bt_zone, BT_MAXALLOC);
+	/*
+	 * Reserve enough tags to allocate new tags.  We allow multiple
+	 * CPUs to attempt to allocate new tags concurrently to limit
+	 * false restarts in UMA.
+	 */
+	uma_zone_reserve(vmem_bt_zone, BT_MAXALLOC * (mp_ncpus + 1) / 2);
+	uma_zone_set_allocf(vmem_bt_zone, vmem_bt_alloc);
+#endif
 }
 
 /* ---- rehash */
@@ -618,9 +718,11 @@ vmem_periodic(void *unused, int pending)
 	LIST_FOREACH(vm, &vmem_list, vm_alllist) {
 #ifdef DIAGNOSTIC
 		/* Convenient time to verify vmem state. */
-		VMEM_LOCK(vm);
-		vmem_check(vm);
-		VMEM_UNLOCK(vm);
+		if (do_vmem_check == 1) {
+			VMEM_LOCK(vm);
+			vmem_check(vm);
+			VMEM_UNLOCK(vm);
+		}
 #endif
 		desired = 1 << flsl(vm->vm_nbusytag);
 		desired = MIN(MAX(desired, VMEM_HASHSIZE_MIN),
@@ -661,15 +763,15 @@ vmem_add1(vmem_t *vm, vmem_addr_t addr, vmem_size_
 	btspan->bt_type = type;
 	btspan->bt_start = addr;
 	btspan->bt_size = size;
+	bt_insseg_tail(vm, btspan);
 
 	btfree = bt_alloc(vm);
 	btfree->bt_type = BT_TYPE_FREE;
 	btfree->bt_start = addr;
 	btfree->bt_size = size;
-
-	bt_insseg_tail(vm, btspan);
 	bt_insseg(vm, btfree, btspan);
 	bt_insfree(vm, btfree);
+
 	vm->vm_size += size;
 }
 
Index: /usr/src/sys/kern/vfs_bio.c
===================================================================
--- /usr/src/sys/kern/vfs_bio.c	(revision 253832)
+++ /usr/src/sys/kern/vfs_bio.c	(working copy)
@@ -856,7 +856,7 @@ bufinit(void)
 
 	bogus_page = vm_page_alloc(NULL, 0, VM_ALLOC_NOOBJ |
 	    VM_ALLOC_NORMAL | VM_ALLOC_WIRED);
-	unmapped_buf = (caddr_t)kmem_alloc_nofault(kernel_map, MAXPHYS);
+	unmapped_buf = (caddr_t)kva_alloc(kernel_arena, MAXPHYS);
 }
 
 #ifdef INVARIANTS
Index: /usr/src/sys/mips/mips/mp_machdep.c
===================================================================
--- /usr/src/sys/mips/mips/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/mips/mips/mp_machdep.c	(working copy)
@@ -182,7 +182,7 @@ start_ap(int cpuid)
 	int cpus, ms;
 
 	cpus = mp_naps;
-	dpcpu = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+	dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE, M_WAITOK | M_ZERO);
 
 	mips_sync();
 
Index: /usr/src/sys/mips/mips/pmap.c
===================================================================
--- /usr/src/sys/mips/mips/pmap.c	(revision 253832)
+++ /usr/src/sys/mips/mips/pmap.c	(working copy)
@@ -3015,7 +3015,7 @@ pmap_mapdev(vm_paddr_t pa, vm_size_t size)
 		offset = pa & PAGE_MASK;
 		size = roundup(size + offset, PAGE_SIZE);
         
-		va = kmem_alloc_nofault(kernel_map, size);
+		va = kva_alloc(kernel_arena, size);
 		if (!va)
 			panic("pmap_mapdev: Couldn't alloc kernel virtual memory");
 		pa = trunc_page(pa);
@@ -3043,7 +3043,7 @@ pmap_unmapdev(vm_offset_t va, vm_size_t size)
 	base = trunc_page(va);
 	offset = va & PAGE_MASK;
 	size = roundup(size + offset, PAGE_SIZE);
-	kmem_free(kernel_map, base, size);
+	kva_free(kernel_arena, base, size);
 #endif
 }
 
@@ -3149,21 +3149,6 @@ pmap_align_superpage(vm_object_t object, vm_ooffse
 		*addr = ((*addr + SEGMASK) & ~SEGMASK) + superpage_offset;
 }
 
-/*
- * 	Increase the starting virtual address of the given mapping so
- * 	that it is aligned to not be the second page in a TLB entry.
- * 	This routine assumes that the length is appropriately-sized so
- * 	that the allocation does not share a TLB entry at all if required.
- */
-void
-pmap_align_tlb(vm_offset_t *addr)
-{
-	if ((*addr & PAGE_SIZE) == 0)
-		return;
-	*addr += PAGE_SIZE;
-	return;
-}
-
 #ifdef DDB
 DB_SHOW_COMMAND(ptable, ddb_pid_dump)
 {
Index: /usr/src/sys/mips/mips/vm_machdep.c
===================================================================
--- /usr/src/sys/mips/mips/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/mips/mips/vm_machdep.c	(working copy)
@@ -514,7 +514,7 @@ sf_buf_init(void *arg)
 
 	mtx_init(&sf_freelist.sf_lock, "sf_bufs list lock", NULL, MTX_DEF);
 	SLIST_INIT(&sf_freelist.sf_head);
-	sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+	sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP,
 	    M_NOWAIT | M_ZERO);
 	for (i = 0; i < nsfbufs; i++) {
Index: /usr/src/sys/mips/sibyte/sb_zbpci.c
===================================================================
--- /usr/src/sys/mips/sibyte/sb_zbpci.c	(revision 253832)
+++ /usr/src/sys/mips/sibyte/sb_zbpci.c	(working copy)
@@ -137,7 +137,7 @@ zbpci_attach(device_t dev)
 	/*
 	 * Allocate KVA for accessing PCI config space.
 	 */
-	va = kmem_alloc_nofault(kernel_map, PAGE_SIZE * mp_ncpus);
+	va = kva_alloc(kernel_arena, PAGE_SIZE * mp_ncpus);
 	if (va == 0) {
 		device_printf(dev, "Cannot allocate virtual addresses for "
 				   "config space access.\n");
Index: /usr/src/sys/ofed/include/linux/dma-mapping.h
===================================================================
--- /usr/src/sys/ofed/include/linux/dma-mapping.h	(revision 253832)
+++ /usr/src/sys/ofed/include/linux/dma-mapping.h	(working copy)
@@ -130,7 +130,7 @@ dma_alloc_coherent(struct device *dev, size_t size
 	else
 		high = BUS_SPACE_MAXADDR_32BIT;
 	align = PAGE_SIZE << get_order(size);
-	mem = (void *)kmem_alloc_contig(kmem_map, size, flag, 0, high, align,
+	mem = (void *)kmem_alloc_contig(kmem_arena, size, flag, 0, high, align,
 	    0, VM_MEMATTR_DEFAULT);
 	if (mem)
 		*dma_handle = vtophys(mem);
@@ -144,7 +144,7 @@ dma_free_coherent(struct device *dev, size_t size,
     dma_addr_t dma_handle)
 {
 
-	kmem_free(kmem_map, (vm_offset_t)cpu_addr, size);
+	kmem_free(kmem_arena, (vm_offset_t)cpu_addr, size);
 }
 
 /* XXX This only works with no iommu. */
Index: /usr/src/sys/ofed/include/linux/gfp.h
===================================================================
--- /usr/src/sys/ofed/include/linux/gfp.h	(revision 253832)
+++ /usr/src/sys/ofed/include/linux/gfp.h	(working copy)
@@ -65,7 +65,7 @@ static inline unsigned long
 _get_page(gfp_t mask)
 {
 
-	return kmem_malloc(kmem_map, PAGE_SIZE, mask);
+	return kmem_malloc(kmem_arena, PAGE_SIZE, mask);
 }
 
 #define	get_zeroed_page(mask)	_get_page((mask) | M_ZERO)
@@ -78,7 +78,7 @@ free_page(unsigned long page)
 
 	if (page == 0)
 		return;
-	kmem_free(kmem_map, page, PAGE_SIZE);
+	kmem_free(kmem_arena, page, PAGE_SIZE);
 }
 
 static inline void
@@ -88,7 +88,7 @@ __free_page(struct page *m)
 	if (m->object != kmem_object)
 		panic("__free_page:  Freed page %p not allocated via wrappers.",
 		    m);
-	kmem_free(kmem_map, (vm_offset_t)page_address(m), PAGE_SIZE);
+	kmem_free(kmem_arena, (vm_offset_t)page_address(m), PAGE_SIZE);
 }
 
 static inline void
@@ -99,7 +99,7 @@ __free_pages(void *p, unsigned int order)
 	if (p == 0)
 		return;
 	size = PAGE_SIZE << order;
-	kmem_free(kmem_map, (vm_offset_t)p, size);
+	kmem_free(kmem_arena, (vm_offset_t)p, size);
 }
 
 /*
@@ -114,7 +114,7 @@ alloc_pages(gfp_t gfp_mask, unsigned int order)
 	size_t size;
 
 	size = PAGE_SIZE << order;
-	page = kmem_alloc_contig(kmem_map, size, gfp_mask, 0, -1,
+	page = kmem_alloc_contig(kmem_arena, size, gfp_mask, 0, -1,
 	    size, 0, VM_MEMATTR_DEFAULT);
 	if (page == 0)
 		return (NULL);
Index: /usr/src/sys/ofed/include/linux/linux_compat.c
===================================================================
--- /usr/src/sys/ofed/include/linux/linux_compat.c	(revision 253832)
+++ /usr/src/sys/ofed/include/linux/linux_compat.c	(working copy)
@@ -647,7 +647,7 @@ vmap(struct page **pages, unsigned int count, unsi
 	size_t size;
 
 	size = count * PAGE_SIZE;
-	off = kmem_alloc_nofault(kernel_map, size);
+	off = kva_alloc(kernel_arena, size);
 	if (off == 0)
 		return (NULL);
 	vmmap_add((void *)off, size);
@@ -665,7 +665,7 @@ vunmap(void *addr)
 	if (vmmap == NULL)
 		return;
 	pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);
-	kmem_free(kernel_map, (vm_offset_t)addr, vmmap->vm_size);
+	kva_free(kernel_arena, (vm_offset_t)addr, vmmap->vm_size);
 	kfree(vmmap);
 }
 
Index: /usr/src/sys/pc98/pc98/machdep.c
===================================================================
--- /usr/src/sys/pc98/pc98/machdep.c	(revision 253832)
+++ /usr/src/sys/pc98/pc98/machdep.c	(working copy)
@@ -2479,7 +2479,7 @@ f00f_hack(void *unused)
 
 	printf("Intel Pentium detected, installing workaround for F00F bug\n");
 
-	tmp = kmem_alloc(kernel_map, PAGE_SIZE * 2);
+	tmp = kmem_malloc(kernel_arena, PAGE_SIZE * 2, M_WAITOK | M_ZERO);
 	if (tmp == 0)
 		panic("kmem_alloc returned 0");
 
@@ -2490,9 +2490,7 @@ f00f_hack(void *unused)
 	r_idt.rd_base = (u_int)new_idt;
 	lidt(&r_idt);
 	idt = new_idt;
-	if (vm_map_protect(kernel_map, tmp, tmp + PAGE_SIZE,
-			   VM_PROT_READ, FALSE) != KERN_SUCCESS)
-		panic("vm_map_protect failed");
+	pmap_protect(kernel_pmap, tmp, tmp + PAGE_SIZE, VM_PROT_READ);
 }
 #endif /* defined(I586_CPU) && !NO_F00F_HACK */
 
Index: /usr/src/sys/powerpc/aim/mmu_oea.c
===================================================================
--- /usr/src/sys/powerpc/aim/mmu_oea.c	(revision 253832)
+++ /usr/src/sys/powerpc/aim/mmu_oea.c	(working copy)
@@ -2524,7 +2524,7 @@ moea_mapdev_attr(mmu_t mmu, vm_offset_t pa, vm_siz
 			return ((void *) pa);
 	}
 
-	va = kmem_alloc_nofault(kernel_map, size);
+	va = kva_alloc(kernel_arena, size);
 	if (!va)
 		panic("moea_mapdev: Couldn't alloc kernel virtual memory");
 
@@ -2552,7 +2552,7 @@ moea_unmapdev(mmu_t mmu, vm_offset_t va, vm_size_t
 		base = trunc_page(va);
 		offset = va & PAGE_MASK;
 		size = roundup(offset + size, PAGE_SIZE);
-		kmem_free(kernel_map, base, size);
+		kva_free(kernel_arena, base, size);
 	}
 }
 
Index: /usr/src/sys/powerpc/aim/mmu_oea64.c
===================================================================
--- /usr/src/sys/powerpc/aim/mmu_oea64.c	(revision 253832)
+++ /usr/src/sys/powerpc/aim/mmu_oea64.c	(working copy)
@@ -2544,7 +2544,7 @@ moea64_mapdev_attr(mmu_t mmu, vm_offset_t pa, vm_s
 	offset = pa & PAGE_MASK;
 	size = roundup2(offset + size, PAGE_SIZE);
 
-	va = kmem_alloc_nofault(kernel_map, size);
+	va = kva_alloc(kernel_arena, size);
 
 	if (!va)
 		panic("moea64_mapdev: Couldn't alloc kernel virtual memory");
@@ -2575,7 +2575,7 @@ moea64_unmapdev(mmu_t mmu, vm_offset_t va, vm_size
 	offset = va & PAGE_MASK;
 	size = roundup2(offset + size, PAGE_SIZE);
 
-	kmem_free(kernel_map, base, size);
+	kva_free(kernel_arena, base, size);
 }
 
 void
Index: /usr/src/sys/powerpc/aim/vm_machdep.c
===================================================================
--- /usr/src/sys/powerpc/aim/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/powerpc/aim/vm_machdep.c	(working copy)
@@ -253,7 +253,7 @@ sf_buf_init(void *arg)
 
         sf_buf_active = hashinit(nsfbufs, M_TEMP, &sf_buf_hashmask);
         TAILQ_INIT(&sf_buf_freelist);
-        sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+        sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
         sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP, M_NOWAIT | M_ZERO);
 
         for (i = 0; i < nsfbufs; i++) {
Index: /usr/src/sys/powerpc/booke/pmap.c
===================================================================
--- /usr/src/sys/powerpc/booke/pmap.c	(revision 253832)
+++ /usr/src/sys/powerpc/booke/pmap.c	(working copy)
@@ -2681,7 +2681,7 @@ mmu_booke_unmapdev(mmu_t mmu, vm_offset_t va, vm_s
 		base = trunc_page(va);
 		offset = va & PAGE_MASK;
 		size = roundup(offset + size, PAGE_SIZE);
-		kmem_free(kernel_map, base, size);
+		kva_free(kernel_arena, base, size);
 	}
 }
 
Index: /usr/src/sys/powerpc/booke/vm_machdep.c
===================================================================
--- /usr/src/sys/powerpc/booke/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/powerpc/booke/vm_machdep.c	(working copy)
@@ -260,7 +260,7 @@ sf_buf_init(void *arg)
 
 	sf_buf_active = hashinit(nsfbufs, M_TEMP, &sf_buf_hashmask);
 	TAILQ_INIT(&sf_buf_freelist);
-	sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+	sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP, M_NOWAIT | M_ZERO);
 
 	for (i = 0; i < nsfbufs; i++) {
Index: /usr/src/sys/powerpc/powerpc/busdma_machdep.c
===================================================================
--- /usr/src/sys/powerpc/powerpc/busdma_machdep.c	(revision 253832)
+++ /usr/src/sys/powerpc/powerpc/busdma_machdep.c	(working copy)
@@ -532,7 +532,7 @@ bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr,
 		 *     multi-seg allocations yet though.
 		 * XXX Certain AGP hardware does.
 		 */
-		*vaddr = (void *)kmem_alloc_contig(kernel_map, dmat->maxsize,
+		*vaddr = (void *)kmem_alloc_contig(kmem_arena, dmat->maxsize,
 		    mflags, 0ul, dmat->lowaddr, dmat->alignment ?
 		    dmat->alignment : 1ul, dmat->boundary, attr);
 		(*mapp)->contigalloc = 1;
@@ -560,7 +560,7 @@ bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, b
 	if (!map->contigalloc)
 		free(vaddr, M_DEVBUF);
 	else
-		kmem_free(kernel_map, (vm_offset_t)vaddr, dmat->maxsize);
+		kmem_free(kmem_arena, (vm_offset_t)vaddr, dmat->maxsize);
 	bus_dmamap_destroy(dmat, map);
 	CTR3(KTR_BUSDMA, "%s: tag %p flags 0x%x", __func__, dmat, dmat->flags);
 }
Index: /usr/src/sys/powerpc/powerpc/mp_machdep.c
===================================================================
--- /usr/src/sys/powerpc/powerpc/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/powerpc/powerpc/mp_machdep.c	(working copy)
@@ -163,7 +163,8 @@ cpu_mp_start(void)
 			void *dpcpu;
 
 			pc = &__pcpu[cpu.cr_cpuid];
-			dpcpu = (void *)kmem_alloc(kernel_map, DPCPU_SIZE);
+			dpcpu = (void *)kmem_malloc(kernel_arena, DPCPU_SIZE,
+			    M_WAITOK | M_ZERO);
 			pcpu_init(pc, cpu.cr_cpuid, sizeof(*pc));
 			dpcpu_init(dpcpu, cpu.cr_cpuid);
 		} else {
Index: /usr/src/sys/sparc64/sparc64/bus_machdep.c
===================================================================
--- /usr/src/sys/sparc64/sparc64/bus_machdep.c	(revision 253832)
+++ /usr/src/sys/sparc64/sparc64/bus_machdep.c	(working copy)
@@ -655,7 +655,7 @@ sparc64_bus_mem_map(bus_space_tag_t tag, bus_addr_
 	if (vaddr != 0L)
 		sva = trunc_page(vaddr);
 	else {
-		if ((sva = kmem_alloc_nofault(kernel_map, size)) == 0)
+		if ((sva = kva_alloc(kernel_arena, size)) == 0)
 			panic("%s: cannot allocate virtual memory", __func__);
 	}
 
@@ -701,7 +701,7 @@ sparc64_bus_mem_unmap(bus_space_tag_t tag, bus_spa
 	for (va = sva; va < endva; va += PAGE_SIZE)
 		pmap_kremove_flags(va);
 	tlb_range_demap(kernel_pmap, sva, sva + size - 1);
-	kmem_free(kernel_map, sva, size);
+	kva_free(kernel_arena, sva, size);
 	return (0);
 }
 
Index: /usr/src/sys/sparc64/sparc64/mem.c
===================================================================
--- /usr/src/sys/sparc64/sparc64/mem.c	(revision 253832)
+++ /usr/src/sys/sparc64/sparc64/mem.c	(working copy)
@@ -137,7 +137,7 @@ memrw(struct cdev *dev, struct uio *uio, int flags
 				if (ova == 0) {
 					if (dcache_color_ignore == 0)
 						colors = DCACHE_COLORS;
-					ova = kmem_alloc_wait(kernel_map,
+					ova = kmap_alloc_wait(kernel_map,
 					    PAGE_SIZE * colors);
 				}
 				if (colors != 1 && m->md.color != -1)
Index: /usr/src/sys/sparc64/sparc64/mp_machdep.c
===================================================================
--- /usr/src/sys/sparc64/sparc64/mp_machdep.c	(revision 253832)
+++ /usr/src/sys/sparc64/sparc64/mp_machdep.c	(working copy)
@@ -336,10 +336,12 @@ ap_start(phandle_t node, u_int mid, u_int cpu_impl
 	cpuid_to_mid[cpuid] = mid;
 	cpu_identify(csa->csa_ver, clock, cpuid);
 
-	va = kmem_alloc(kernel_map, PCPU_PAGES * PAGE_SIZE);
+	va = kmem_malloc(kernel_arena, PCPU_PAGES * PAGE_SIZE,
+	    M_WAITOK | M_ZERO);
 	pc = (struct pcpu *)(va + (PCPU_PAGES * PAGE_SIZE)) - 1;
 	pcpu_init(pc, cpuid, sizeof(*pc));
-	dpcpu_init((void *)kmem_alloc(kernel_map, DPCPU_SIZE), cpuid);
+	dpcpu_init((void *)kmem_malloc(kernel_arena, DPCPU_SIZE), cpuid,
+	    M_WAITOK | M_ZERO);
 	pc->pc_addr = va;
 	pc->pc_clock = clock;
 	pc->pc_impl = cpu_impl;
Index: /usr/src/sys/sparc64/sparc64/pmap.c
===================================================================
--- /usr/src/sys/sparc64/sparc64/pmap.c	(revision 253832)
+++ /usr/src/sys/sparc64/sparc64/pmap.c	(working copy)
@@ -1211,8 +1211,7 @@ pmap_pinit(pmap_t pm)
 	 * Allocate KVA space for the TSB.
 	 */
 	if (pm->pm_tsb == NULL) {
-		pm->pm_tsb = (struct tte *)kmem_alloc_nofault(kernel_map,
-		    TSB_BSIZE);
+		pm->pm_tsb = (struct tte *)kva_alloc(kernel_arena, TSB_BSIZE);
 		if (pm->pm_tsb == NULL) {
 			PMAP_LOCK_DESTROY(pm);
 			return (0);
Index: /usr/src/sys/sparc64/sparc64/vm_machdep.c
===================================================================
--- /usr/src/sys/sparc64/sparc64/vm_machdep.c	(revision 253832)
+++ /usr/src/sys/sparc64/sparc64/vm_machdep.c	(working copy)
@@ -421,7 +421,7 @@ sf_buf_init(void *arg)
 
 	mtx_init(&sf_freelist.sf_lock, "sf_bufs list lock", NULL, MTX_DEF);
 	SLIST_INIT(&sf_freelist.sf_head);
-	sf_base = kmem_alloc_nofault(kernel_map, nsfbufs * PAGE_SIZE);
+	sf_base = kva_alloc(kernel_arena, nsfbufs * PAGE_SIZE);
 	sf_bufs = malloc(nsfbufs * sizeof(struct sf_buf), M_TEMP,
 	    M_NOWAIT | M_ZERO);
 	for (i = 0; i < nsfbufs; i++) {
Index: /usr/src/sys/sys/vmmeter.h
===================================================================
--- /usr/src/sys/sys/vmmeter.h	(revision 253832)
+++ /usr/src/sys/sys/vmmeter.h	(working copy)
@@ -98,7 +98,7 @@ struct vmmeter {
 	u_int v_inactive_count;	/* (q) pages inactive */
 	u_int v_cache_count;	/* (f) pages on cache queue */
 	u_int v_cache_min;	/* (c) min pages desired on cache queue */
-	u_int v_cache_max;	/* (c) max pages in cached obj */
+	u_int v_cache_max;	/* (c) max pages in cached obj (unused) */
 	u_int v_pageout_free_min;   /* (c) min pages reserved for kernel */
 	u_int v_interrupt_free_min; /* (c) reserved pages for int code */
 	u_int v_free_severe;	/* (c) severe page depletion point */
@@ -118,6 +118,8 @@ struct vmmeter {
 
 extern struct vmmeter cnt;
 
+extern int vm_pageout_wakeup_thresh;
+
 /*
  * Return TRUE if we are under our severe low-free-pages threshold
  *
@@ -184,10 +186,7 @@ static __inline
 int
 vm_paging_needed(void)
 {
-    return (
-	(cnt.v_free_reserved + cnt.v_cache_min) >
-	(cnt.v_free_count + cnt.v_cache_count)
-    );
+    return (cnt.v_free_count + cnt.v_cache_count < vm_pageout_wakeup_thresh);
 }
 
 #endif
Index: /usr/src/sys/vm/memguard.c
===================================================================
--- /usr/src/sys/vm/memguard.c	(revision 253832)
+++ /usr/src/sys/vm/memguard.c	(working copy)
@@ -48,6 +48,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/mutex.h>
 #include <sys/malloc.h>
 #include <sys/sysctl.h>
+#include <sys/vmem.h>
 
 #include <vm/vm.h>
 #include <vm/uma.h>
@@ -99,8 +100,9 @@ SYSCTL_PROC(_vm_memguard, OID_AUTO, desc,
     CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 0,
     memguard_sysctl_desc, "A", "Short description of memory type to monitor");
 
-static vm_map_t memguard_map = NULL;
+static vmem_t *memguard_map = NULL;
 static vm_offset_t memguard_cursor;
+static vm_offset_t memguard_base;
 static vm_size_t memguard_mapsize;
 static vm_size_t memguard_physlimit;
 static u_long memguard_wasted;
@@ -112,7 +114,7 @@ static u_long memguard_fail_pgs;
 SYSCTL_ULONG(_vm_memguard, OID_AUTO, cursor, CTLFLAG_RD,
     &memguard_cursor, 0, "MemGuard cursor");
 SYSCTL_ULONG(_vm_memguard, OID_AUTO, mapsize, CTLFLAG_RD,
-    &memguard_mapsize, 0, "MemGuard private vm_map size");
+    &memguard_mapsize, 0, "MemGuard private arena size");
 SYSCTL_ULONG(_vm_memguard, OID_AUTO, phys_limit, CTLFLAG_RD,
     &memguard_physlimit, 0, "Limit on MemGuard memory consumption");
 SYSCTL_ULONG(_vm_memguard, OID_AUTO, wasted, CTLFLAG_RD,
@@ -200,21 +202,18 @@ memguard_fudge(unsigned long km_size, const struct
  * out of a single VM map (contiguous chunk of address space).
  */
 void
-memguard_init(vm_map_t parent_map)
+memguard_init(vmem_t *parent)
 {
-	vm_offset_t base, limit;
+	vm_offset_t base;
 
-	memguard_map = kmem_suballoc(parent_map, &base, &limit,
-	    memguard_mapsize, FALSE);
-	memguard_map->system_map = 1;
-	KASSERT(memguard_mapsize == limit - base,
-	    ("Expected %lu, got %lu", (u_long)memguard_mapsize,
-	     (u_long)(limit - base)));
+	vmem_alloc(parent, memguard_mapsize, M_WAITOK, &base);
+	memguard_map = vmem_create("memguard arena", base, memguard_mapsize,
+	    PAGE_SIZE, 0, M_WAITOK);
 	memguard_cursor = base;
+	memguard_base = base;
 
 	printf("MEMGUARD DEBUGGING ALLOCATOR INITIALIZED:\n");
 	printf("\tMEMGUARD map base: 0x%lx\n", (u_long)base);
-	printf("\tMEMGUARD map limit: 0x%lx\n", (u_long)limit);
 	printf("\tMEMGUARD map size: %jd KBytes\n",
 	    (uintmax_t)memguard_mapsize >> 10);
 }
@@ -230,11 +229,13 @@ memguard_sysinit(void)
 	parent = SYSCTL_STATIC_CHILDREN(_vm_memguard);
 
 	SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "mapstart", CTLFLAG_RD,
-	    &memguard_map->min_offset, "MemGuard KVA base");
+	    &memguard_base, "MemGuard KVA base");
 	SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "maplimit", CTLFLAG_RD,
-	    &memguard_map->max_offset, "MemGuard KVA end");
+	    &memguard_mapsize, "MemGuard KVA size");
+#if 0
 	SYSCTL_ADD_ULONG(NULL, parent, OID_AUTO, "mapused", CTLFLAG_RD,
 	    &memguard_map->size, "MemGuard KVA used");
+#endif
 }
 SYSINIT(memguard, SI_SUB_KLD, SI_ORDER_ANY, memguard_sysinit, NULL);
 
@@ -263,6 +264,21 @@ v2sizep(vm_offset_t va)
 	return ((u_long *)&p->pageq.tqe_next);
 }
 
+static u_long *
+v2sizev(vm_offset_t va)
+{
+	vm_paddr_t pa;
+	struct vm_page *p;
+
+	pa = pmap_kextract(va);
+	if (pa == 0)
+		panic("MemGuard detected double-free of %p", (void *)va);
+	p = PHYS_TO_VM_PAGE(pa);
+	KASSERT(p->wire_count != 0 && p->queue == PQ_NONE,
+	    ("MEMGUARD: Expected wired page %p in vtomgfifo!", p));
+	return ((u_long *)&p->pageq.tqe_prev);
+}
+
 /*
  * Allocate a single object of specified size with specified flags
  * (either M_WAITOK or M_NOWAIT).
@@ -289,7 +305,6 @@ memguard_alloc(unsigned long req_size, int flags)
 	if (do_guard)
 		size_v += 2 * PAGE_SIZE;
 
-	vm_map_lock(memguard_map);
 	/*
 	 * When we pass our memory limit, reject sub-page allocations.
 	 * Page-size and larger allocations will use the same amount
@@ -296,7 +311,7 @@ memguard_alloc(unsigned long req_size, int flags)
 	 * of physical memory whether we allocate or hand off to
 	 * uma_large_alloc(), so keep those.
 	 */
-	if (memguard_map->size >= memguard_physlimit &&
+	if (vmem_size(memguard_map, VMEM_ALLOC) >= memguard_physlimit &&
 	    req_size < PAGE_SIZE) {
 		addr = (vm_offset_t)NULL;
 		memguard_fail_pgs++;
@@ -313,9 +328,8 @@ memguard_alloc(unsigned long req_size, int flags)
 	 * map, unless vm_map_findspace() is tweaked.
 	 */
 	for (;;) {
-		rv = vm_map_findspace(memguard_map, memguard_cursor,
-		    size_v, &addr);
-		if (rv == KERN_SUCCESS)
+		if (vmem_xalloc(memguard_map, size_v, 0, 0, 0, memguard_cursor,
+		    VMEM_ADDR_MAX, M_BESTFIT | M_NOWAIT, &addr) == 0)
 			break;
 		/*
 		 * The map has no space.  This may be due to
@@ -322,24 +336,26 @@ memguard_alloc(unsigned long req_size, int flags)
 		 * fragmentation, or because the cursor is near the
 		 * end of the map.
 		 */
-		if (memguard_cursor == vm_map_min(memguard_map)) {
+		if (memguard_cursor == memguard_base) {
 			memguard_fail_kva++;
 			addr = (vm_offset_t)NULL;
 			goto out;
 		}
 		memguard_wrap++;
-		memguard_cursor = vm_map_min(memguard_map);
+		memguard_cursor = memguard_base;
 	}
 	if (do_guard)
 		addr += PAGE_SIZE;
-	rv = kmem_back(memguard_map, addr, size_p, flags);
+	rv = kmem_back(addr, size_p, flags);
 	if (rv != KERN_SUCCESS) {
+		vmem_xfree(memguard_map, addr, size_v);
 		memguard_fail_pgs++;
 		addr = (vm_offset_t)NULL;
 		goto out;
 	}
-	memguard_cursor = addr + size_p;
+	memguard_cursor = addr + size_v;
 	*v2sizep(trunc_page(addr)) = req_size;
+	*v2sizev(trunc_page(addr)) = size_v;
 	memguard_succ++;
 	if (req_size < PAGE_SIZE) {
 		memguard_wasted += (PAGE_SIZE - req_size);
@@ -354,7 +370,6 @@ memguard_alloc(unsigned long req_size, int flags)
 		}
 	}
 out:
-	vm_map_unlock(memguard_map);
 	return ((void *)addr);
 }
 
@@ -363,7 +378,7 @@ is_memguard_addr(void *addr)
 {
 	vm_offset_t a = (vm_offset_t)(uintptr_t)addr;
 
-	return (a >= memguard_map->min_offset && a < memguard_map->max_offset);
+	return (a >= memguard_base && a < memguard_base + memguard_mapsize);
 }
 
 /*
@@ -373,12 +388,13 @@ void
 memguard_free(void *ptr)
 {
 	vm_offset_t addr;
-	u_long req_size, size;
+	u_long req_size, size, sizev;
 	char *temp;
 	int i;
 
 	addr = trunc_page((uintptr_t)ptr);
 	req_size = *v2sizep(addr);
+	sizev = *v2sizev(addr);
 	size = round_page(req_size);
 
 	/*
@@ -400,11 +416,12 @@ memguard_free(void *ptr)
 	 * vm_map lock to serialize updates to memguard_wasted, since
 	 * we had the lock at increment.
 	 */
-	vm_map_lock(memguard_map);
+	kmem_unback(addr, size);
+	if (sizev > size)
+		addr -= PAGE_SIZE;
+	vmem_xfree(memguard_map, addr, sizev);
 	if (req_size < PAGE_SIZE)
 		memguard_wasted -= (PAGE_SIZE - req_size);
-	(void)vm_map_delete(memguard_map, addr, addr + size);
-	vm_map_unlock(memguard_map);
 }
 
 /*
Index: /usr/src/sys/vm/memguard.h
===================================================================
--- /usr/src/sys/vm/memguard.h	(revision 253832)
+++ /usr/src/sys/vm/memguard.h	(working copy)
@@ -33,10 +33,11 @@
 
 struct malloc_type;
 struct vm_map;
+struct vmem;
 
 #ifdef DEBUG_MEMGUARD
 unsigned long	memguard_fudge(unsigned long, const struct vm_map *);
-void	memguard_init(struct vm_map *);
+void	memguard_init(struct vmem *);
 void 	*memguard_alloc(unsigned long, int);
 void	*memguard_realloc(void *, unsigned long, struct malloc_type *, int);
 void	memguard_free(void *);
Index: /usr/src/sys/vm/pmap.h
===================================================================
--- /usr/src/sys/vm/pmap.h	(revision 253832)
+++ /usr/src/sys/vm/pmap.h	(working copy)
@@ -100,9 +100,6 @@ extern vm_offset_t kernel_vm_end;
 void		 pmap_activate(struct thread *td);
 void		 pmap_align_superpage(vm_object_t, vm_ooffset_t, vm_offset_t *,
 		    vm_size_t);
-#if defined(__mips__)
-void		 pmap_align_tlb(vm_offset_t *);
-#endif
 void		 pmap_change_wiring(pmap_t, vm_offset_t, boolean_t);
 void		 pmap_clear_modify(vm_page_t m);
 void		 pmap_clear_reference(vm_page_t m);
Index: /usr/src/sys/vm/uma_core.c
===================================================================
--- /usr/src/sys/vm/uma_core.c	(revision 253832)
+++ /usr/src/sys/vm/uma_core.c	(working copy)
@@ -1015,7 +1015,7 @@ page_alloc(uma_zone_t zone, int bytes, uint8_t *pf
 	void *p;	/* Returned page */
 
 	*pflag = UMA_SLAB_KMEM;
-	p = (void *) kmem_malloc(kmem_map, bytes, wait);
+	p = (void *) kmem_malloc(kmem_arena, bytes, wait);
 
 	return (p);
 }
@@ -1097,16 +1097,16 @@ noobj_alloc(uma_zone_t zone, int bytes, uint8_t *f
 static void
 page_free(void *mem, int size, uint8_t flags)
 {
-	vm_map_t map;
+	struct vmem *vmem;
 
 	if (flags & UMA_SLAB_KMEM)
-		map = kmem_map;
+		vmem = kmem_arena;
 	else if (flags & UMA_SLAB_KERNEL)
-		map = kernel_map;
+		vmem = kernel_arena;
 	else
 		panic("UMA: page_free used with invalid flags %d", flags);
 
-	kmem_free(map, (vm_offset_t)mem, size);
+	kmem_free(vmem, (vm_offset_t)mem, size);
 }
 
 /*
@@ -2983,7 +2983,7 @@ uma_zone_reserve_kva(uma_zone_t zone, int count)
 #else
 	if (1) {
 #endif
-		kva = kmem_alloc_nofault(kernel_map, pages * UMA_SLAB_SIZE);
+		kva = kva_alloc(kernel_arena, pages * UMA_SLAB_SIZE);
 		if (kva == 0)
 			return (0);
 	} else
Index: /usr/src/sys/vm/vm_extern.h
===================================================================
--- /usr/src/sys/vm/vm_extern.h	(revision 253832)
+++ /usr/src/sys/vm/vm_extern.h	(working copy)
@@ -36,27 +36,38 @@
 struct proc;
 struct vmspace;
 struct vnode;
+struct vmem;
 
 #ifdef _KERNEL
 
-int kernacc(void *, int, int);
-vm_offset_t kmem_alloc(vm_map_t, vm_size_t);
-vm_offset_t kmem_alloc_attr(vm_map_t map, vm_size_t size, int flags,
+/* These operate on virtual addresses only. */
+vm_offset_t kva_alloc(struct vmem *, vm_size_t);
+void kva_free(struct vmem *, vm_offset_t, vm_size_t);
+
+/* These operate on pageable virtual addresses. */
+vm_offset_t kmap_alloc_wait(vm_map_t, vm_size_t);
+void kmap_free_wakeup(vm_map_t, vm_offset_t, vm_size_t);
+
+/* These operate on virtual addresses backed by memory. */
+vm_offset_t kmem_alloc_attr(struct vmem *, vm_size_t size, int flags,
     vm_paddr_t low, vm_paddr_t high, vm_memattr_t memattr);
-vm_offset_t kmem_alloc_contig(vm_map_t map, vm_size_t size, int flags,
+vm_offset_t kmem_alloc_contig(struct vmem *, vm_size_t size, int flags,
     vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary,
     vm_memattr_t memattr);
-vm_offset_t kmem_alloc_nofault(vm_map_t, vm_size_t);
-vm_offset_t kmem_alloc_nofault_space(vm_map_t, vm_size_t, int);
-vm_offset_t kmem_alloc_wait(vm_map_t, vm_size_t);
-void kmem_free(vm_map_t, vm_offset_t, vm_size_t);
-void kmem_free_wakeup(vm_map_t, vm_offset_t, vm_size_t);
-void kmem_init(vm_offset_t, vm_offset_t);
-vm_offset_t kmem_malloc(vm_map_t map, vm_size_t size, int flags);
-int kmem_back(vm_map_t, vm_offset_t, vm_size_t, int);
+vm_offset_t kmem_malloc(struct vmem *, vm_size_t size, int flags);
+void kmem_free(struct vmem *, vm_offset_t, vm_size_t);
+int kmem_back(vm_object_t, vm_offset_t, vm_size_t, int);
+void kmem_unback(vm_object_t, vm_offset_t, vm_size_t);
+
+/* Bootstrapping. */
 vm_map_t kmem_suballoc(vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t,
     boolean_t);
+void kmem_init(vm_offset_t, vm_offset_t);
+void kmem_init_zero_region(void);
+void kmeminit(void);
+
 void swapout_procs(int);
+int kernacc(void *, int, int);
 int useracc(void *, int, int);
 int vm_fault(vm_map_t, vm_offset_t, vm_prot_t, int);
 void vm_fault_copy_entry(vm_map_t, vm_map_t, vm_map_entry_t, vm_map_entry_t,
Index: /usr/src/sys/vm/vm_glue.c
===================================================================
--- /usr/src/sys/vm/vm_glue.c	(revision 253832)
+++ /usr/src/sys/vm/vm_glue.c	(working copy)
@@ -359,11 +359,13 @@ vm_thread_new(struct thread *td, int pages)
 	 * We need to align the kstack's mapped address to fit within
 	 * a single TLB entry.
 	 */
-	ks = kmem_alloc_nofault_space(kernel_map,
-	    (pages + KSTACK_GUARD_PAGES) * PAGE_SIZE, VMFS_TLB_ALIGNED_SPACE);
+	if (vmem_xalloc(kernel_arena, (pages + KSTACK_GUARD_PAGES) * PAGE_SIZE,
+	    PAGE_SIZE * 2, 0, 0, VMEM_ADDR_MIN, VMEM_ADDR_MAX,
+	    M_BESTFIT | M_NOWAIT, &ks)) {
+		ks = 0;
+	}
 #else
-	ks = kmem_alloc_nofault(kernel_map,
-	   (pages + KSTACK_GUARD_PAGES) * PAGE_SIZE);
+	ks = kva_alloc(kernel_arena, (pages + KSTACK_GUARD_PAGES) * PAGE_SIZE);
 #endif
 	if (ks == 0) {
 		printf("vm_thread_new: kstack allocation failed\n");
@@ -422,7 +424,7 @@ vm_thread_stack_dispose(vm_object_t ksobj, vm_offs
 	}
 	VM_OBJECT_WUNLOCK(ksobj);
 	vm_object_deallocate(ksobj);
-	kmem_free(kernel_map, ks - (KSTACK_GUARD_PAGES * PAGE_SIZE),
+	kva_free(kernel_arena, ks - (KSTACK_GUARD_PAGES * PAGE_SIZE),
 	    (pages + KSTACK_GUARD_PAGES) * PAGE_SIZE);
 }
 
Index: /usr/src/sys/vm/vm_init.c
===================================================================
--- /usr/src/sys/vm/vm_init.c	(revision 253832)
+++ /usr/src/sys/vm/vm_init.c	(working copy)
@@ -70,6 +70,7 @@ __FBSDID("$FreeBSD$");
 #include <sys/lock.h>
 #include <sys/proc.h>
 #include <sys/rwlock.h>
+#include <sys/malloc.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/selinfo.h>
@@ -101,6 +102,26 @@ static void vm_mem_init(void *);
 SYSINIT(vm_mem, SI_SUB_VM, SI_ORDER_FIRST, vm_mem_init, NULL);
 
 /*
+ * Import kva into the kernel arena.
+ */
+static int
+kva_import(void *unused, vmem_size_t size, int flags, vmem_addr_t *addrp)
+{
+	vm_offset_t addr;
+	int result;
+ 
+	addr = vm_map_min(kernel_map);
+	result = vm_map_find(kernel_map, NULL, 0, &addr, size,
+	    VMFS_ALIGNED_SPACE, VM_PROT_ALL, VM_PROT_ALL, MAP_NOFAULT);
+	if (result != KERN_SUCCESS)
+                return (ENOMEM);
+
+	*addrp = addr;
+
+	return (0);
+}
+
+/*
  *	vm_init initializes the virtual memory system.
  *	This is done only by the first cpu up.
  *
@@ -111,6 +132,9 @@ static void
 vm_mem_init(dummy)
 	void *dummy;
 {
+	vm_offset_t minaddr;
+	vm_offset_t maxaddr;
+
 	/*
 	 * Initializes resident memory structures. From here on, all physical
 	 * memory is accounted for, and we use only virtual addresses.
@@ -125,6 +149,26 @@ vm_mem_init(dummy)
 	vm_object_init();
 	vm_map_startup();
 	kmem_init(virtual_avail, virtual_end);
+
+	/*
+ 	 * Allocate the pageable submaps.
+	 */
+	exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
+	    exec_map_entries * round_page(PATH_MAX + ARG_MAX), FALSE);
+	pipe_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
+	    maxpipekva, FALSE);
+
+	/*
+	 * Initialize the kernel_arena.  This can grow on demand.
+	 */
+	vmem_init(kernel_arena, "kernel arena", 0, 0, PAGE_SIZE, 0, 0);
+	vmem_set_import(kernel_arena, kva_import, NULL, NULL,
+#if VM_NRESERVLEVEL > 0
+	    1 << (VM_LEVEL_0_ORDER + PAGE_SHIFT));
+#else
+	    PAGE_SIZE);
+#endif
+
 	pmap_init();
 	vm_pager_init();
 }
@@ -136,9 +180,6 @@ vm_ksubmap_init(struct kva_md_info *kmi)
 	caddr_t v;
 	vm_size_t size = 0;
 	long physmem_est;
-	vm_offset_t minaddr;
-	vm_offset_t maxaddr;
-	vm_map_t clean_map;
 
 	/*
 	 * Allocate space for system data structures.
@@ -146,8 +187,6 @@ vm_ksubmap_init(struct kva_md_info *kmi)
 	 * As pages of kernel virtual memory are allocated, "v" is incremented.
 	 * As pages of memory are allocated and cleared,
 	 * "firstaddr" is incremented.
-	 * An index into the kernel page table corresponding to the
-	 * virtual memory address maintained in "v" is kept in "mapaddr".
 	 */
 
 	/*
@@ -173,7 +212,8 @@ again:
 	 */
 	if (firstaddr == 0) {
 		size = (vm_size_t)v;
-		firstaddr = kmem_alloc(kernel_map, round_page(size));
+		firstaddr = kmem_malloc(kernel_arena, round_page(size),
+		    M_ZERO | M_WAITOK);
 		if (firstaddr == 0)
 			panic("startup: no room for tables");
 		goto again;
@@ -185,31 +225,43 @@ again:
 	if ((vm_size_t)((char *)v - firstaddr) != size)
 		panic("startup: table size inconsistency");
 
+	/*
+	 * Allocate the clean map to hold all of the paging and I/O virtual
+	 * memory.
+	 */
 	size = (long)nbuf * BKVASIZE + (long)nswbuf * MAXPHYS +
 	    (long)bio_transient_maxcnt * MAXPHYS;
-	clean_map = kmem_suballoc(kernel_map, &kmi->clean_sva, &kmi->clean_eva,
-	    size, TRUE);
+	kmi->clean_sva = firstaddr = kva_alloc(kernel_arena, size);
+	kmi->clean_eva = firstaddr + size;
 
+	/*
+	 * Allocate the buffer arena.
+	 */
 	size = (long)nbuf * BKVASIZE;
-	kmi->buffer_sva = kmem_alloc_nofault(clean_map, size);
+	kmi->buffer_sva = firstaddr;
 	kmi->buffer_eva = kmi->buffer_sva + size;
 	vmem_init(buffer_arena, "buffer arena", kmi->buffer_sva, size,
 	    PAGE_SIZE, 0, 0);
+	firstaddr += size;
 
+	/*
+	 * Now swap kva.
+	 */
+	swapbkva = firstaddr;
 	size = (long)nswbuf * MAXPHYS;
-	swapbkva = kmem_alloc_nofault(clean_map, size);
-	if (!swapbkva)
-		panic("Not enough clean_map VM space for pager buffers");
+	firstaddr += size;
 
+	/*
+	 * And optionally transient bio space.
+	 */
 	if (bio_transient_maxcnt != 0) {
 		size = (long)bio_transient_maxcnt * MAXPHYS;
 		vmem_init(transient_arena, "transient arena",
-		    kmem_alloc_nofault(clean_map, size),
-		    size, PAGE_SIZE, 0, 0);
+		    firstaddr, size, PAGE_SIZE, 0, 0);
+		firstaddr += size;
 	}
-	exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
-	    exec_map_entries * round_page(PATH_MAX + ARG_MAX), FALSE);
-	pipe_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr, maxpipekva,
-	    FALSE);
+	if (firstaddr != kmi->clean_eva)
+		panic("Clean map calculation incorrect. 0x%jx != 0x%jx",
+		    firstaddr, kmi->clean_eva);
 }
 
Index: /usr/src/sys/vm/vm_kern.c
===================================================================
--- /usr/src/sys/vm/vm_kern.c	(revision 253832)
+++ /usr/src/sys/vm/vm_kern.c	(working copy)
@@ -74,9 +74,11 @@ __FBSDID("$FreeBSD$");
 #include <sys/malloc.h>
 #include <sys/rwlock.h>
 #include <sys/sysctl.h>
+#include <sys/vmem.h>
 
 #include <vm/vm.h>
 #include <vm/vm_param.h>
+#include <vm/vm_kern.h>
 #include <vm/pmap.h>
 #include <vm/vm_map.h>
 #include <vm/vm_object.h>
@@ -86,7 +88,6 @@ __FBSDID("$FreeBSD$");
 #include <vm/uma.h>
 
 vm_map_t kernel_map;
-vm_map_t kmem_map;
 vm_map_t exec_map;
 vm_map_t pipe_map;
 
@@ -105,7 +106,7 @@ SYSCTL_ULONG(_vm, OID_AUTO, max_kernel_address, CT
     "Max kernel address");
 
 /*
- *	kmem_alloc_nofault:
+ *	kva_alloc:
  *
  *	Allocate a virtual address range with no underlying object and
  *	no initial mapping to physical memory.  Any mapping from this
@@ -114,94 +115,37 @@ SYSCTL_ULONG(_vm, OID_AUTO, max_kernel_address, CT
  *	a mapping on demand through vm_fault() will result in a panic. 
  */
 vm_offset_t
-kmem_alloc_nofault(map, size)
-	vm_map_t map;
+kva_alloc(vmem, size)
+	struct vmem *vmem;
 	vm_size_t size;
 {
 	vm_offset_t addr;
-	int result;
 
 	size = round_page(size);
-	addr = vm_map_min(map);
-	result = vm_map_find(map, NULL, 0, &addr, size, VMFS_ANY_SPACE,
-	    VM_PROT_ALL, VM_PROT_ALL, MAP_NOFAULT);
-	if (result != KERN_SUCCESS) {
+	if (vmem_alloc(vmem, size, M_BESTFIT | M_NOWAIT, &addr))
 		return (0);
-	}
+
 	return (addr);
 }
 
 /*
- *	kmem_alloc_nofault_space:
+ *	kva_free:
  *
- *	Allocate a virtual address range with no underlying object and
- *	no initial mapping to physical memory within the specified
- *	address space.  Any mapping from this range to physical memory
- *	must be explicitly created prior to its use, typically with
- *	pmap_qenter().  Any attempt to create a mapping on demand
- *	through vm_fault() will result in a panic. 
+ *	Release a region of kernel virtual memory allocated
+ *	with kva_alloc, and return the physical pages
+ *	associated with that region.
+ *
+ *	This routine may not block on kernel maps.
  */
-vm_offset_t
-kmem_alloc_nofault_space(map, size, find_space)
-	vm_map_t map;
-	vm_size_t size;
-	int find_space;
-{
+void
+kva_free(vmem, addr, size)
+	struct vmem *vmem;
 	vm_offset_t addr;
-	int result;
-
-	size = round_page(size);
-	addr = vm_map_min(map);
-	result = vm_map_find(map, NULL, 0, &addr, size, find_space,
-	    VM_PROT_ALL, VM_PROT_ALL, MAP_NOFAULT);
-	if (result != KERN_SUCCESS) {
-		return (0);
-	}
-	return (addr);
-}
-
-/*
- *	Allocate wired-down memory in the kernel's address map
- *	or a submap.
- */
-vm_offset_t
-kmem_alloc(map, size)
-	vm_map_t map;
 	vm_size_t size;
 {
-	vm_offset_t addr;
-	vm_offset_t offset;
 
 	size = round_page(size);
-
-	/*
-	 * Use the kernel object for wired-down kernel pages. Assume that no
-	 * region of the kernel object is referenced more than once.
-	 */
-
-	/*
-	 * Locate sufficient space in the map.  This will give us the final
-	 * virtual address for the new memory, and thus will tell us the
-	 * offset within the kernel map.
-	 */
-	vm_map_lock(map);
-	if (vm_map_findspace(map, vm_map_min(map), size, &addr)) {
-		vm_map_unlock(map);
-		return (0);
-	}
-	offset = addr - VM_MIN_KERNEL_ADDRESS;
-	vm_object_reference(kernel_object);
-	vm_map_insert(map, kernel_object, offset, addr, addr + size,
-		VM_PROT_ALL, VM_PROT_ALL, 0);
-	vm_map_unlock(map);
-
-	/*
-	 * And finally, mark the data as non-pageable.
-	 */
-	(void) vm_map_wire(map, addr, addr + size,
-	    VM_MAP_WIRE_SYSTEM|VM_MAP_WIRE_NOHOLES);
-
-	return (addr);
+	vmem_free(vmem, addr, size);
 }
 
 /*
@@ -213,62 +157,57 @@ vm_offset_t
  *	given flags, then the pages are zeroed before they are mapped.
  */
 vm_offset_t
-kmem_alloc_attr(vm_map_t map, vm_size_t size, int flags, vm_paddr_t low,
+kmem_alloc_attr(vmem_t *vmem, vm_size_t size, int flags, vm_paddr_t low,
     vm_paddr_t high, vm_memattr_t memattr)
 {
-	vm_object_t object = kernel_object;
+	vm_object_t object = vmem == kmem_arena ? kmem_object : kernel_object;
 	vm_offset_t addr;
-	vm_ooffset_t end_offset, offset;
+	vm_ooffset_t offset;
 	vm_page_t m;
 	int pflags, tries;
+	int i;
 
 	size = round_page(size);
-	vm_map_lock(map);
-	if (vm_map_findspace(map, vm_map_min(map), size, &addr)) {
-		vm_map_unlock(map);
+	if (vmem_alloc(vmem, size, M_BESTFIT | flags, &addr))
 		return (0);
-	}
 	offset = addr - VM_MIN_KERNEL_ADDRESS;
-	vm_object_reference(object);
-	vm_map_insert(map, object, offset, addr, addr + size, VM_PROT_ALL,
-	    VM_PROT_ALL, 0);
-	pflags = malloc2vm_flags(flags) | VM_ALLOC_NOBUSY;
+	pflags = malloc2vm_flags(flags) | VM_ALLOC_NOBUSY | VM_ALLOC_WIRED;
 	VM_OBJECT_WLOCK(object);
-	end_offset = offset + size;
-	for (; offset < end_offset; offset += PAGE_SIZE) {
+	for (i = 0; i < size; i += PAGE_SIZE) {
 		tries = 0;
 retry:
-		m = vm_page_alloc_contig(object, OFF_TO_IDX(offset), pflags, 1,
-		    low, high, PAGE_SIZE, 0, memattr);
+		m = vm_page_alloc_contig(object, OFF_TO_IDX(offset + i),
+		    pflags, 1, low, high, PAGE_SIZE, 0, memattr);
 		if (m == NULL) {
 			VM_OBJECT_WUNLOCK(object);
 			if (tries < ((flags & M_NOWAIT) != 0 ? 1 : 3)) {
-				vm_map_unlock(map);
 				vm_pageout_grow_cache(tries, low, high);
-				vm_map_lock(map);
 				VM_OBJECT_WLOCK(object);
 				tries++;
 				goto retry;
 			}
-
-			/*
-			 * Since the pages that were allocated by any previous
-			 * iterations of this loop are not busy, they can be
-			 * freed by vm_object_page_remove(), which is called
-			 * by vm_map_delete().
+			/* 
+			 * Unmap and free the pages.
 			 */
-			vm_map_delete(map, addr, addr + size);
-			vm_map_unlock(map);
+			if (i != 0)
+				pmap_remove(kernel_pmap, addr, addr + i);
+			while (i != 0) {
+				m = vm_page_lookup(object,
+				    OFF_TO_IDX(offset + i));
+				vm_page_unwire(m, 0);
+				vm_page_free(m);
+			}
+			vmem_free(vmem, addr, size);
 			return (0);
 		}
 		if ((flags & M_ZERO) && (m->flags & PG_ZERO) == 0)
 			pmap_zero_page(m);
+		/* XXX Could pmap_enter_object? */
+		pmap_enter(kernel_pmap, addr + i, VM_PROT_ALL, m, VM_PROT_ALL,
+		    TRUE);
 		m->valid = VM_PAGE_BITS_ALL;
 	}
 	VM_OBJECT_WUNLOCK(object);
-	vm_map_unlock(map);
-	vm_map_wire(map, addr, addr + size, VM_MAP_WIRE_SYSTEM |
-	    VM_MAP_WIRE_NOHOLES);
 	return (addr);
 }
 
@@ -281,27 +220,21 @@ retry:
  *	mapped.
  */
 vm_offset_t
-kmem_alloc_contig(vm_map_t map, vm_size_t size, int flags, vm_paddr_t low,
+kmem_alloc_contig(struct vmem *vmem, vm_size_t size, int flags, vm_paddr_t low,
     vm_paddr_t high, u_long alignment, vm_paddr_t boundary,
     vm_memattr_t memattr)
 {
-	vm_object_t object = kernel_object;
-	vm_offset_t addr;
+	vm_object_t object = vmem == kmem_arena ? kmem_object : kernel_object;
+	vm_offset_t addr, tmp;
 	vm_ooffset_t offset;
 	vm_page_t end_m, m;
 	int pflags, tries;
  
 	size = round_page(size);
-	vm_map_lock(map);
-	if (vm_map_findspace(map, vm_map_min(map), size, &addr)) {
-		vm_map_unlock(map);
+	if (vmem_alloc(vmem, size, flags | M_BESTFIT, &addr))
 		return (0);
-	}
 	offset = addr - VM_MIN_KERNEL_ADDRESS;
-	vm_object_reference(object);
-	vm_map_insert(map, object, offset, addr, addr + size, VM_PROT_ALL,
-	    VM_PROT_ALL, 0);
-	pflags = malloc2vm_flags(flags) | VM_ALLOC_NOBUSY;
+	pflags = malloc2vm_flags(flags) | VM_ALLOC_NOBUSY | VM_ALLOC_WIRED;
 	VM_OBJECT_WLOCK(object);
 	tries = 0;
 retry:
@@ -310,50 +243,29 @@ retry:
 	if (m == NULL) {
 		VM_OBJECT_WUNLOCK(object);
 		if (tries < ((flags & M_NOWAIT) != 0 ? 1 : 3)) {
-			vm_map_unlock(map);
 			vm_pageout_grow_cache(tries, low, high);
-			vm_map_lock(map);
 			VM_OBJECT_WLOCK(object);
 			tries++;
 			goto retry;
 		}
-		vm_map_delete(map, addr, addr + size);
-		vm_map_unlock(map);
+		vmem_free(vmem, addr, size);
 		return (0);
 	}
 	end_m = m + atop(size);
+	tmp = addr;
 	for (; m < end_m; m++) {
 		if ((flags & M_ZERO) && (m->flags & PG_ZERO) == 0)
 			pmap_zero_page(m);
 		m->valid = VM_PAGE_BITS_ALL;
+		/* XXX Could pmap_enter_object? */
+		pmap_enter(kernel_pmap, tmp, VM_PROT_ALL, m, VM_PROT_ALL, true);
+		tmp += PAGE_SIZE;
 	}
 	VM_OBJECT_WUNLOCK(object);
-	vm_map_unlock(map);
-	vm_map_wire(map, addr, addr + size, VM_MAP_WIRE_SYSTEM |
-	    VM_MAP_WIRE_NOHOLES);
 	return (addr);
 }
 
 /*
- *	kmem_free:
- *
- *	Release a region of kernel virtual memory allocated
- *	with kmem_alloc, and return the physical pages
- *	associated with that region.
- *
- *	This routine may not block on kernel maps.
- */
-void
-kmem_free(map, addr, size)
-	vm_map_t map;
-	vm_offset_t addr;
-	vm_size_t size;
-{
-
-	(void) vm_map_remove(map, trunc_page(addr), round_page(addr + size));
-}
-
-/*
  *	kmem_suballoc:
  *
  *	Allocates a map to manage a subrange
@@ -393,65 +305,25 @@ kmem_suballoc(vm_map_t parent, vm_offset_t *min, v
 /*
  *	kmem_malloc:
  *
- * 	Allocate wired-down memory in the kernel's address map for the higher
- * 	level kernel memory allocator (kern/kern_malloc.c).  We cannot use
- * 	kmem_alloc() because we may need to allocate memory at interrupt
- * 	level where we cannot block (canwait == FALSE).
- *
- * 	This routine has its own private kernel submap (kmem_map) and object
- * 	(kmem_object).  This, combined with the fact that only malloc uses
- * 	this routine, ensures that we will never block in map or object waits.
- *
- * 	We don't worry about expanding the map (adding entries) since entries
- * 	for wired maps are statically allocated.
- *
- *	`map' is ONLY allowed to be kmem_map or one of the mbuf submaps to
- *	which we never free.
+ *	Allocate wired-down pages in the kernel's address space.
  */
 vm_offset_t
-kmem_malloc(map, size, flags)
-	vm_map_t map;
-	vm_size_t size;
-	int flags;
+kmem_malloc(struct vmem *vmem, vm_size_t size, int flags)
 {
 	vm_offset_t addr;
-	int i, rv;
+	int rv;
 
 	size = round_page(size);
-	addr = vm_map_min(map);
+	if (vmem_alloc(vmem, size, flags | M_BESTFIT, &addr))
+		return (0);
 
-	/*
-	 * Locate sufficient space in the map.  This will give us the final
-	 * virtual address for the new memory, and thus will tell us the
-	 * offset within the kernel map.
-	 */
-	vm_map_lock(map);
-	if (vm_map_findspace(map, vm_map_min(map), size, &addr)) {
-		vm_map_unlock(map);
-                if ((flags & M_NOWAIT) == 0) {
-			for (i = 0; i < 8; i++) {
-				EVENTHANDLER_INVOKE(vm_lowmem, 0);
-				uma_reclaim();
-				vm_map_lock(map);
-				if (vm_map_findspace(map, vm_map_min(map),
-				    size, &addr) == 0) {
-					break;
-				}
-				vm_map_unlock(map);
-				tsleep(&i, 0, "nokva", (hz / 4) * (i + 1));
-			}
-			if (i == 8) {
-				panic("kmem_malloc(%ld): kmem_map too small: %ld total allocated",
-				    (long)size, (long)map->size);
-			}
-		} else {
-			return (0);
-		}
+	rv = kmem_back((vmem == kmem_arena) ? kmem_object : kernel_object,
+	    addr, size, flags);
+	if (rv != KERN_SUCCESS) {
+		vmem_free(kmem_arena, addr, size);
+		return (0);
 	}
-
-	rv = kmem_back(map, addr, size, flags);
-	vm_map_unlock(map);
-	return (rv == KERN_SUCCESS ? addr : 0);
+	return (addr);
 }
 
 /*
@@ -460,37 +332,22 @@ vm_offset_t
  *	Allocate physical pages for the specified virtual address range.
  */
 int
-kmem_back(vm_map_t map, vm_offset_t addr, vm_size_t size, int flags)
+kmem_back(vm_object_t object, vm_offset_t addr, vm_size_t size, int flags)
 {
 	vm_offset_t offset, i;
-	vm_map_entry_t entry;
 	vm_page_t m;
 	int pflags;
-	boolean_t found;
 
-	KASSERT(vm_map_locked(map), ("kmem_back: map %p is not locked", map));
+	KASSERT(object == kmem_object || object == kernel_object,
+	    ("kmem_back: only supports kernel objects."));
+
 	offset = addr - VM_MIN_KERNEL_ADDRESS;
-	vm_object_reference(kmem_object);
-	vm_map_insert(map, kmem_object, offset, addr, addr + size,
-	    VM_PROT_ALL, VM_PROT_ALL, 0);
+	pflags = malloc2vm_flags(flags) | VM_ALLOC_NOBUSY | VM_ALLOC_WIRED;
 
-	/*
-	 * Assert: vm_map_insert() will never be able to extend the
-	 * previous entry so vm_map_lookup_entry() will find a new
-	 * entry exactly corresponding to this address range and it
-	 * will have wired_count == 0.
-	 */
-	found = vm_map_lookup_entry(map, addr, &entry);
-	KASSERT(found && entry->start == addr && entry->end == addr + size &&
-	    entry->wired_count == 0 && (entry->eflags & MAP_ENTRY_IN_TRANSITION)
-	    == 0, ("kmem_back: entry not found or misaligned"));
-
-	pflags = malloc2vm_flags(flags) | VM_ALLOC_WIRED;
-
-	VM_OBJECT_WLOCK(kmem_object);
+	VM_OBJECT_WLOCK(object);
 	for (i = 0; i < size; i += PAGE_SIZE) {
 retry:
-		m = vm_page_alloc(kmem_object, OFF_TO_IDX(offset + i), pflags);
+		m = vm_page_alloc(object, OFF_TO_IDX(offset + i), pflags);
 
 		/*
 		 * Ran out of space, free everything up and return. Don't need
@@ -499,34 +356,24 @@ retry:
 		 */
 		if (m == NULL) {
 			if ((flags & M_NOWAIT) == 0) {
-				VM_OBJECT_WUNLOCK(kmem_object);
-				entry->eflags |= MAP_ENTRY_IN_TRANSITION;
-				vm_map_unlock(map);
+				VM_OBJECT_WUNLOCK(object);
 				VM_WAIT;
-				vm_map_lock(map);
-				KASSERT(
-(entry->eflags & (MAP_ENTRY_IN_TRANSITION | MAP_ENTRY_NEEDS_WAKEUP)) ==
-				    MAP_ENTRY_IN_TRANSITION,
-				    ("kmem_back: volatile entry"));
-				entry->eflags &= ~MAP_ENTRY_IN_TRANSITION;
-				VM_OBJECT_WLOCK(kmem_object);
+				VM_OBJECT_WLOCK(object);
 				goto retry;
 			}
 			/* 
-			 * Free the pages before removing the map entry.
-			 * They are already marked busy.  Calling
-			 * vm_map_delete before the pages has been freed or
-			 * unbusied will cause a deadlock.
+			 * Unmap and free the pages.
 			 */
+			if (i != 0)
+				pmap_remove(kernel_pmap, addr, addr + i);
 			while (i != 0) {
 				i -= PAGE_SIZE;
-				m = vm_page_lookup(kmem_object,
+				m = vm_page_lookup(object,
 						   OFF_TO_IDX(offset + i));
 				vm_page_unwire(m, 0);
 				vm_page_free(m);
 			}
-			VM_OBJECT_WUNLOCK(kmem_object);
-			vm_map_delete(map, addr, addr + size);
+			VM_OBJECT_WUNLOCK(object);
 			return (KERN_NO_SPACE);
 		}
 		if (flags & M_ZERO && (m->flags & PG_ZERO) == 0)
@@ -534,40 +381,51 @@ retry:
 		m->valid = VM_PAGE_BITS_ALL;
 		KASSERT((m->oflags & VPO_UNMANAGED) != 0,
 		    ("kmem_malloc: page %p is managed", m));
+		/* XXX pmap_enter_object ? */
+		pmap_enter(kernel_pmap, addr + i, VM_PROT_ALL, m, VM_PROT_ALL,
+		    TRUE);
 	}
-	VM_OBJECT_WUNLOCK(kmem_object);
+	VM_OBJECT_WUNLOCK(object);
 
-	/*
-	 * Mark map entry as non-pageable.  Repeat the assert.
-	 */
-	KASSERT(entry->start == addr && entry->end == addr + size &&
-	    entry->wired_count == 0,
-	    ("kmem_back: entry not found or misaligned after allocation"));
-	entry->wired_count = 1;
+	return (KERN_SUCCESS);
+}
 
-	/*
-	 * At this point, the kmem_object must be unlocked because
-	 * vm_map_simplify_entry() calls vm_object_deallocate(), which
-	 * locks the kmem_object.
-	 */
-	vm_map_simplify_entry(map, entry);
+void
+kmem_unback(vm_object_t object, vm_offset_t addr, vm_size_t size)
+{
+	vm_page_t m;
+	vm_offset_t offset;
+	int i;
 
-	/*
-	 * Loop thru pages, entering them in the pmap.
-	 */
-	VM_OBJECT_WLOCK(kmem_object);
+	KASSERT(object == kmem_object || object == kernel_object,
+	    ("kmem_unback: only supports kernel objects."));
+
+	pmap_remove(kernel_pmap, addr, addr + size);
+	offset = addr - VM_MIN_KERNEL_ADDRESS;
+	VM_OBJECT_WLOCK(object);
 	for (i = 0; i < size; i += PAGE_SIZE) {
-		m = vm_page_lookup(kmem_object, OFF_TO_IDX(offset + i));
-		/*
-		 * Because this is kernel_pmap, this call will not block.
-		 */
-		pmap_enter(kernel_pmap, addr + i, VM_PROT_ALL, m, VM_PROT_ALL,
-		    TRUE);
-		vm_page_wakeup(m);
+		/* XXX Could use page next. */
+		m = vm_page_lookup(object, OFF_TO_IDX(offset + i));
+		vm_page_unwire(m, 0);
+		vm_page_free(m);
 	}
-	VM_OBJECT_WUNLOCK(kmem_object);
+	VM_OBJECT_WUNLOCK(object);
+}
 
-	return (KERN_SUCCESS);
+/*
+ *	kmem_free:
+ *
+ *	Free memory allocated with kmem_malloc.  The size must match the
+ *	original allocation.
+ */
+void
+kmem_free(struct vmem *vmem, vm_offset_t addr, vm_size_t size)
+{
+
+	size = round_page(size);
+	kmem_unback((vmem == kmem_arena) ? kmem_object : kernel_object,
+	    addr, size);
+	vmem_free(vmem, addr, size);
 }
 
 /*
@@ -579,7 +437,7 @@ retry:
  *	This routine may block.
  */
 vm_offset_t
-kmem_alloc_wait(map, size)
+kmap_alloc_wait(map, size)
 	vm_map_t map;
 	vm_size_t size;
 {
@@ -613,13 +471,13 @@ vm_offset_t
 }
 
 /*
- *	kmem_free_wakeup:
+ *	kmap_free_wakeup:
  *
  *	Returns memory to a submap of the kernel, and wakes up any processes
  *	waiting for memory in that map.
  */
 void
-kmem_free_wakeup(map, addr, size)
+kmap_free_wakeup(map, addr, size)
 	vm_map_t map;
 	vm_offset_t addr;
 	vm_size_t size;
@@ -634,12 +492,11 @@ void
 	vm_map_unlock(map);
 }
 
-static void
+void
 kmem_init_zero_region(void)
 {
 	vm_offset_t addr, i;
 	vm_page_t m;
-	int error;
 
 	/*
 	 * Map a single physical page of zeros to a larger virtual range.
@@ -646,7 +503,7 @@ kmem_init_zero_region(void)
 	 * This requires less looping in places that want large amounts of
 	 * zeros, while not using much more physical resources.
 	 */
-	addr = kmem_alloc_nofault(kernel_map, ZERO_REGION_SIZE);
+	addr = kva_alloc(kernel_arena, ZERO_REGION_SIZE);
 	m = vm_page_alloc(NULL, 0, VM_ALLOC_NORMAL |
 	    VM_ALLOC_NOOBJ | VM_ALLOC_WIRED | VM_ALLOC_ZERO);
 	if ((m->flags & PG_ZERO) == 0)
@@ -653,9 +510,7 @@ kmem_init_zero_region(void)
 		pmap_zero_page(m);
 	for (i = 0; i < ZERO_REGION_SIZE; i += PAGE_SIZE)
 		pmap_qenter(addr + i, &m, 1);
-	error = vm_map_protect(kernel_map, addr, addr + ZERO_REGION_SIZE,
-	    VM_PROT_READ, TRUE);
-	KASSERT(error == 0, ("error=%d", error));
+	pmap_protect(kernel_pmap, addr, addr + ZERO_REGION_SIZE, VM_PROT_READ);
 
 	zero_region = (const void *)addr;
 }
@@ -688,8 +543,6 @@ kmem_init(start, end)
 	    start, VM_PROT_ALL, VM_PROT_ALL, MAP_NOFAULT);
 	/* ... and ending with the completion of the above `insert' */
 	vm_map_unlock(m);
-
-	kmem_init_zero_region();
 }
 
 #ifdef DIAGNOSTIC
Index: /usr/src/sys/vm/vm_kern.h
===================================================================
--- /usr/src/sys/vm/vm_kern.h	(revision 253832)
+++ /usr/src/sys/vm/vm_kern.h	(working copy)
@@ -65,9 +65,10 @@
 
 /* Kernel memory management definitions. */
 extern vm_map_t kernel_map;
-extern vm_map_t kmem_map;
 extern vm_map_t exec_map;
 extern vm_map_t pipe_map;
+extern struct vmem *kernel_arena;
+extern struct vmem *kmem_arena;
 extern struct vmem *buffer_arena;
 extern struct vmem *transient_arena;
 extern vm_offset_t swapbkva;
Index: /usr/src/sys/vm/vm_map.c
===================================================================
--- /usr/src/sys/vm/vm_map.c	(revision 253832)
+++ /usr/src/sys/vm/vm_map.c	(working copy)
@@ -197,9 +197,15 @@ vm_map_startup(void)
 	kmapentzone = uma_zcreate("KMAP ENTRY", sizeof(struct vm_map_entry),
 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR,
 	    UMA_ZONE_MTXCLASS | UMA_ZONE_VM);
-	uma_prealloc(kmapentzone, MAX_KMAPENT);
 	mapentzone = uma_zcreate("MAP ENTRY", sizeof(struct vm_map_entry),
 	    NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, 0);
+	vmspace_zone = uma_zcreate("VMSPACE", sizeof(struct vmspace), NULL,
+#ifdef INVARIANTS
+	    vmspace_zdtor,
+#else
+	    NULL,
+#endif
+	    vmspace_zinit, vmspace_zfini, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
 }
 
 static void
@@ -299,21 +305,6 @@ vmspace_alloc(min, max)
 	return (vm);
 }
 
-void
-vm_init2(void)
-{
-	uma_zone_reserve_kva(kmapentzone, lmin(cnt.v_page_count,
-	    (VM_MAX_KERNEL_ADDRESS - VM_MIN_KERNEL_ADDRESS) / PAGE_SIZE) / 8 +
-	     maxproc * 2 + maxfiles);
-	vmspace_zone = uma_zcreate("VMSPACE", sizeof(struct vmspace), NULL,
-#ifdef INVARIANTS
-	    vmspace_zdtor,
-#else
-	    NULL,
-#endif
-	    vmspace_zinit, vmspace_zfini, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
-}
-
 static void
 vmspace_container_reset(struct proc *p)
 {
@@ -1469,11 +1460,6 @@ again:
 				pmap_align_superpage(object, offset, addr,
 				    length);
 				break;
-#ifdef VMFS_TLB_ALIGNED_SPACE
-			case VMFS_TLB_ALIGNED_SPACE:
-				pmap_align_tlb(addr);
-				break;
-#endif
 			default:
 				break;
 			}
@@ -1483,9 +1469,6 @@ again:
 		result = vm_map_insert(map, object, offset, start, start +
 		    length, prot, max, cow);
 	} while (result == KERN_NO_SPACE && (find_space == VMFS_ALIGNED_SPACE ||
-#ifdef VMFS_TLB_ALIGNED_SPACE
-	    find_space == VMFS_TLB_ALIGNED_SPACE ||
-#endif
 	    find_space == VMFS_OPTIMAL_SPACE));
 	vm_map_unlock(map);
 	return (result);
Index: /usr/src/sys/vm/vm_map.h
===================================================================
--- /usr/src/sys/vm/vm_map.h	(revision 253832)
+++ /usr/src/sys/vm/vm_map.h	(working copy)
@@ -345,9 +345,6 @@ long vmspace_resident_count(struct vmspace *vmspac
 #define	VMFS_ANY_SPACE		1	/* find a range with any alignment */
 #define	VMFS_OPTIMAL_SPACE	2	/* find a range with optimal alignment*/
 #define	VMFS_ALIGNED_SPACE	3	/* find a superpage-aligned range */
-#if defined(__mips__)
-#define	VMFS_TLB_ALIGNED_SPACE	4	/* find a TLB entry aligned range */
-#endif
 
 /*
  * vm_map_wire and vm_map_unwire option flags
@@ -387,7 +384,6 @@ int vm_map_submap (vm_map_t, vm_offset_t, vm_offse
 int vm_map_sync(vm_map_t, vm_offset_t, vm_offset_t, boolean_t, boolean_t);
 int vm_map_madvise (vm_map_t, vm_offset_t, vm_offset_t, int);
 void vm_map_simplify_entry (vm_map_t, vm_map_entry_t);
-void vm_init2 (void);
 int vm_map_stack (vm_map_t, vm_offset_t, vm_size_t, vm_prot_t, vm_prot_t, int);
 int vm_map_growstack (struct proc *p, vm_offset_t addr);
 int vm_map_unwire(vm_map_t map, vm_offset_t start, vm_offset_t end,
Index: /usr/src/sys/vm/vm_object.c
===================================================================
--- /usr/src/sys/vm/vm_object.c	(revision 253832)
+++ /usr/src/sys/vm/vm_object.c	(working copy)
@@ -295,7 +295,7 @@ vm_object_init(void)
 #else
 	    NULL,
 #endif
-	    vm_object_zinit, NULL, UMA_ALIGN_PTR, UMA_ZONE_VM|UMA_ZONE_NOFREE);
+	    vm_object_zinit, NULL, UMA_ALIGN_PTR, UMA_ZONE_NOFREE);
 
 	vm_radix_init();
 }
Index: /usr/src/sys/vm/vm_pageout.c
===================================================================
--- /usr/src/sys/vm/vm_pageout.c	(revision 253832)
+++ /usr/src/sys/vm/vm_pageout.c	(working copy)
@@ -143,6 +143,7 @@ SYSINIT(vmdaemon, SI_SUB_KTHREAD_VM, SI_ORDER_FIRS
 int vm_pages_needed;		/* Event on which pageout daemon sleeps */
 int vm_pageout_deficit;		/* Estimated number of pages deficit */
 int vm_pageout_pages_needed;	/* flag saying that the pageout daemon needs pages */
+int vm_pageout_wakeup_thresh;
 
 #if !defined(NO_SWAPPING)
 static int vm_pageout_req_swapout;	/* XXX */
@@ -152,11 +153,7 @@ static struct mtx vm_daemon_mtx;
 MTX_SYSINIT(vm_daemon, &vm_daemon_mtx, "vm daemon", MTX_DEF);
 #endif
 static int vm_max_launder = 32;
-static int vm_pageout_stats_max;
-static int vm_pageout_stats;
-static int vm_pageout_stats_interval;
-static int vm_pageout_full_stats;
-static int vm_pageout_full_stats_interval;
+static int vm_pageout_update_period;
 static int defer_swap_pageouts;
 static int disable_swap_pageouts;
 
@@ -168,24 +165,17 @@ static int vm_swap_enabled = 1;
 static int vm_swap_idle_enabled = 0;
 #endif
 
+SYSCTL_INT(_vm, OID_AUTO, pageout_wakeup_thresh,
+	CTLFLAG_RW, &vm_pageout_wakeup_thresh, 0,
+	"free page threshold for waking up the pageout daemon");
+
 SYSCTL_INT(_vm, OID_AUTO, max_launder,
 	CTLFLAG_RW, &vm_max_launder, 0, "Limit dirty flushes in pageout");
 
-SYSCTL_INT(_vm, OID_AUTO, pageout_stats_max,
-	CTLFLAG_RW, &vm_pageout_stats_max, 0, "Max pageout stats scan length");
-
-SYSCTL_INT(_vm, OID_AUTO, pageout_stats,
-	CTLFLAG_RD, &vm_pageout_stats, 0, "Number of partial stats scans");
-
-SYSCTL_INT(_vm, OID_AUTO, pageout_stats_interval,
-	CTLFLAG_RW, &vm_pageout_stats_interval, 0, "Interval for partial stats scan");
-
-SYSCTL_INT(_vm, OID_AUTO, pageout_full_stats,
-	CTLFLAG_RD, &vm_pageout_full_stats, 0, "Number of full stats scans");
-
-SYSCTL_INT(_vm, OID_AUTO, pageout_full_stats_interval,
-	CTLFLAG_RW, &vm_pageout_full_stats_interval, 0, "Interval for full stats scan");
-
+SYSCTL_INT(_vm, OID_AUTO, pageout_update_period,
+	CTLFLAG_RW, &vm_pageout_update_period, 0,
+	"Maximum active LRU update period");
+  
 #if defined(NO_SWAPPING)
 SYSCTL_INT(_vm, VM_SWAPPING_ENABLED, swap_enabled,
 	CTLFLAG_RD, &vm_swap_enabled, 0, "Enable entire process swapout");
@@ -223,7 +213,6 @@ static void vm_pageout_object_deactivate_pages(pma
 static void vm_req_vmdaemon(int req);
 #endif
 static boolean_t vm_pageout_page_lock(vm_page_t, vm_page_t *);
-static void vm_pageout_page_stats(void);
 
 /*
  * Initialize a dummy page for marking the caller's place in the specified
@@ -859,6 +848,10 @@ vm_pageout_map_deactivate_pages(map, desired)
 
 /*
  *	vm_pageout_scan does the dirty work for the pageout daemon.
+ *
+ *	pass 0 - Update active LRU/deactivate pages
+ *	pass 1 - Move inactive to cache or free
+ *	pass 2 - Launder dirty pages
  */
 static void
 vm_pageout_scan(int pass)
@@ -877,13 +870,20 @@ vm_pageout_scan(int pass)
 	vm_pageout_init_marker(&marker, PQ_INACTIVE);
 
 	/*
-	 * Decrease registered cache sizes.
+	 * If we need to reclaim memory ask kernel caches to return
+	 * some.
 	 */
-	EVENTHANDLER_INVOKE(vm_lowmem, 0);
-	/*
-	 * We do this explicitly after the caches have been drained above.
-	 */
-	uma_reclaim();
+	if (pass > 0) {
+		/*
+		 * Decrease registered cache sizes.
+		 */
+		EVENTHANDLER_INVOKE(vm_lowmem, 0);
+		/*
+		 * We do this explicitly after the caches have been
+		 * drained above.
+		 */
+		uma_reclaim();
+	}
 
 	/*
 	 * The addl_page_shortage is the number of temporarily
@@ -911,7 +911,7 @@ vm_pageout_scan(int pass)
 	 */
 	if ((maxlaunder = vm_max_launder) <= 1)
 		maxlaunder = 1;
-	if (pass)
+	if (pass > 1)
 		maxlaunder = 10000;
 
 	maxscan = cnt.v_inactive_count;
@@ -1068,7 +1068,7 @@ vm_pageout_scan(int pass)
 			 */
 			vm_page_cache(m);
 			--page_shortage;
-		} else if ((m->flags & PG_WINATCFLS) == 0 && pass == 0) {
+		} else if ((m->flags & PG_WINATCFLS) == 0 && pass < 2) {
 			/*
 			 * Dirty pages need to be paged out, but flushing
 			 * a page is extremely expensive verses freeing
@@ -1257,9 +1257,18 @@ relock_queues:
 	 * Compute the number of pages we want to try to move from the
 	 * active queue to the inactive queue.
 	 */
+	pcount = cnt.v_active_count;
 	page_shortage = vm_paging_target() +
 		cnt.v_inactive_target - cnt.v_inactive_count;
 	page_shortage += addl_page_shortage;
+	/*
+	 * If we're just idle polling attempt to visit every
+	 * active page within 'update_period' seconds.
+	 */
+	if (pass == 0 && vm_pageout_update_period != 0) {
+		pcount /= vm_pageout_update_period;
+		page_shortage = pcount;
+	}
 
 	/*
 	 * Scan the active queue for things we can deactivate. We nominally
@@ -1266,7 +1275,6 @@ relock_queues:
 	 * track the per-page activity counter and use it to locate
 	 * deactivation candidates.
 	 */
-	pcount = cnt.v_active_count;
 	pq = &vm_pagequeues[PQ_ACTIVE];
 	vm_pagequeue_lock(pq);
 	m = TAILQ_FIRST(&pq->pq_pl);
@@ -1393,7 +1401,7 @@ relock_queues:
 	 * chance to flush out dirty vnode-backed pages and to allow
 	 * active pages to be moved to the inactive queue and reclaimed.
 	 */
-	if (pass != 0 &&
+	if (pass > 1 &&
 	    ((swap_pager_avail < 64 && vm_page_count_min()) ||
 	     (swap_pager_full && vm_paging_target() > 0)))
 		vm_pageout_oom(VM_OOM_MEM);
@@ -1495,129 +1503,12 @@ vm_pageout_oom(int shortage)
 }
 
 /*
- * This routine tries to maintain the pseudo LRU active queue,
- * so that during long periods of time where there is no paging,
- * that some statistic accumulation still occurs.  This code
- * helps the situation where paging just starts to occur.
- */
-static void
-vm_pageout_page_stats(void)
-{
-	struct vm_pagequeue *pq;
-	vm_object_t object;
-	vm_page_t m, next;
-	int pcount, tpcount;		/* Number of pages to check */
-	static int fullintervalcount = 0;
-	int page_shortage;
-
-	page_shortage = 
-	    (cnt.v_inactive_target + cnt.v_cache_max + cnt.v_free_min) -
-	    (cnt.v_free_count + cnt.v_inactive_count + cnt.v_cache_count);
-
-	if (page_shortage <= 0)
-		return;
-
-	pcount = cnt.v_active_count;
-	fullintervalcount += vm_pageout_stats_interval;
-	if (fullintervalcount < vm_pageout_full_stats_interval) {
-		vm_pageout_stats++;
-		tpcount = (int64_t)vm_pageout_stats_max * cnt.v_active_count /
-		    cnt.v_page_count;
-		if (pcount > tpcount)
-			pcount = tpcount;
-	} else {
-		vm_pageout_full_stats++;
-		fullintervalcount = 0;
-	}
-
-	pq = &vm_pagequeues[PQ_ACTIVE];
-	vm_pagequeue_lock(pq);
-	m = TAILQ_FIRST(&pq->pq_pl);
-	while ((m != NULL) && (pcount-- > 0)) {
-		int actcount;
-
-		KASSERT(m->queue == PQ_ACTIVE,
-		    ("vm_pageout_page_stats: page %p isn't active", m));
-
-		next = TAILQ_NEXT(m, pageq);
-		if ((m->flags & PG_MARKER) != 0) {
-			m = next;
-			continue;
-		}
-		vm_page_lock_assert(m, MA_NOTOWNED);
-		if (!vm_pageout_page_lock(m, &next)) {
-			vm_page_unlock(m);
-			m = next;
-			continue;
-		}
-		object = m->object;
-		if (!VM_OBJECT_TRYWLOCK(object) &&
-		    !vm_pageout_fallback_object_lock(m, &next)) {
-			VM_OBJECT_WUNLOCK(object);
-			vm_page_unlock(m);
-			m = next;
-			continue;
-		}
-
-		/*
-		 * Don't deactivate pages that are busy.
-		 */
-		if ((m->busy != 0) ||
-		    (m->oflags & VPO_BUSY) ||
-		    (m->hold_count != 0)) {
-			vm_page_unlock(m);
-			VM_OBJECT_WUNLOCK(object);
-			vm_page_requeue_locked(m);
-			m = next;
-			continue;
-		}
-
-		actcount = 0;
-		if (m->aflags & PGA_REFERENCED) {
-			vm_page_aflag_clear(m, PGA_REFERENCED);
-			actcount += 1;
-		}
-
-		actcount += pmap_ts_referenced(m);
-		if (actcount) {
-			m->act_count += ACT_ADVANCE + actcount;
-			if (m->act_count > ACT_MAX)
-				m->act_count = ACT_MAX;
-			vm_page_requeue_locked(m);
-		} else {
-			if (m->act_count == 0) {
-				/*
-				 * We turn off page access, so that we have
-				 * more accurate RSS stats.  We don't do this
-				 * in the normal page deactivation when the
-				 * system is loaded VM wise, because the
-				 * cost of the large number of page protect
-				 * operations would be higher than the value
-				 * of doing the operation.
-				 */
-				pmap_remove_all(m);
-				/* Dequeue to avoid later lock recursion. */
-				vm_page_dequeue_locked(m);
-				vm_page_deactivate(m);
-			} else {
-				m->act_count -= min(m->act_count, ACT_DECLINE);
-				vm_page_requeue_locked(m);
-			}
-		}
-		vm_page_unlock(m);
-		VM_OBJECT_WUNLOCK(object);
-		m = next;
-	}
-	vm_pagequeue_unlock(pq);
-}
-
-/*
  *	vm_pageout is the high level pageout daemon.
  */
 static void
 vm_pageout(void)
 {
-	int error, pass;
+	int pass;
 
 	/*
 	 * Initialize some paging parameters.
@@ -1654,38 +1545,36 @@ vm_pageout(void)
 	 * be big enough to handle memory needs while the pageout daemon
 	 * is signalled and run to free more pages.
 	 */
-	if (cnt.v_free_count > 6144)
-		cnt.v_free_target = 4 * cnt.v_free_min + cnt.v_free_reserved;
-	else
-		cnt.v_free_target = 2 * cnt.v_free_min + cnt.v_free_reserved;
+	cnt.v_free_target = 2 * cnt.v_free_min + cnt.v_free_reserved;
 
 	if (cnt.v_free_count > 2048) {
 		cnt.v_cache_min = cnt.v_free_target;
-		cnt.v_cache_max = 2 * cnt.v_cache_min;
-		cnt.v_inactive_target = (3 * cnt.v_free_target) / 2;
+		cnt.v_inactive_target = 3 * cnt.v_free_target;
 	} else {
 		cnt.v_cache_min = 0;
-		cnt.v_cache_max = 0;
 		cnt.v_inactive_target = cnt.v_free_count / 4;
 	}
 	if (cnt.v_inactive_target > cnt.v_free_count / 3)
 		cnt.v_inactive_target = cnt.v_free_count / 3;
 
+	/*
+	 * Set the wakeup at 25% of the difference between target and
+	 * reserved.  This ensures that the page daemon wakes up well
+	 * before we run out of pages.
+	 */
+	vm_pageout_wakeup_thresh =
+	    ((cnt.v_cache_min + cnt.v_free_target) / 4) + cnt.v_free_reserved;
+
+	/*
+	 * Set interval in seconds for active scan.
+	 */
+	if (vm_pageout_update_period == 0)
+		vm_pageout_update_period = 60;
+
 	/* XXX does not really belong here */
 	if (vm_page_max_wired == 0)
 		vm_page_max_wired = cnt.v_free_count / 3;
 
-	if (vm_pageout_stats_max == 0)
-		vm_pageout_stats_max = cnt.v_free_target;
-
-	/*
-	 * Set interval in seconds for stats scan.
-	 */
-	if (vm_pageout_stats_interval == 0)
-		vm_pageout_stats_interval = 5;
-	if (vm_pageout_full_stats_interval == 0)
-		vm_pageout_full_stats_interval = vm_pageout_stats_interval * 4;
-
 	swap_pager_swap_init();
 	pass = 0;
 	/*
@@ -1710,7 +1599,6 @@ vm_pageout(void)
 			 * (unlimited dirty cleaning), otherwise sleep a bit
 			 * and try again.
 			 */
-			++pass;
 			if (pass > 1)
 				msleep(&vm_pages_needed,
 				    &vm_page_queue_free_mtx, PVM, "psleep",
@@ -1717,25 +1605,17 @@ vm_pageout(void)
 				    hz / 2);
 		} else {
 			/*
-			 * Good enough, sleep & handle stats.  Prime the pass
-			 * for the next run.
+			 * Good enough, sleep until required to refresh
+			 * stats.
 			 */
-			if (pass > 1)
-				pass = 1;
-			else
-				pass = 0;
-			error = msleep(&vm_pages_needed,
-			    &vm_page_queue_free_mtx, PVM, "psleep",
-			    vm_pageout_stats_interval * hz);
-			if (error && !vm_pages_needed) {
-				mtx_unlock(&vm_page_queue_free_mtx);
-				pass = 0;
-				vm_pageout_page_stats();
-				continue;
-			}
+			pass = 0;
+			msleep(&vm_pages_needed, &vm_page_queue_free_mtx,
+			    PVM, "psleep", hz);
 		}
-		if (vm_pages_needed)
+		if (vm_pages_needed) {
 			cnt.v_pdwakeups++;
+			pass++;
+		}
 		mtx_unlock(&vm_page_queue_free_mtx);
 		vm_pageout_scan(pass);
 	}
Index: /usr/src/sys/x86/x86/busdma_machdep.c
===================================================================
--- /usr/src/sys/x86/x86/busdma_machdep.c	(revision 253832)
+++ /usr/src/sys/x86/x86/busdma_machdep.c	(working copy)
@@ -544,11 +544,11 @@ bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr,
 	    dmat->alignment <= PAGE_SIZE &&
 	    (dmat->boundary == 0 || dmat->boundary >= dmat->lowaddr)) {
 		/* Page-based multi-segment allocations allowed */
-		*vaddr = (void *)kmem_alloc_attr(kernel_map, dmat->maxsize,
+		*vaddr = (void *)kmem_alloc_attr(kernel_arena, dmat->maxsize,
 		    mflags, 0ul, dmat->lowaddr, attr);
 		*mapp = &contig_dmamap;
 	} else {
-		*vaddr = (void *)kmem_alloc_contig(kernel_map, dmat->maxsize,
+		*vaddr = (void *)kmem_alloc_contig(kernel_arena, dmat->maxsize,
 		    mflags, 0ul, dmat->lowaddr, dmat->alignment ?
 		    dmat->alignment : 1ul, dmat->boundary, attr);
 		*mapp = &contig_dmamap;
@@ -582,7 +582,7 @@ bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, b
 	if (map == NULL)
 		free(vaddr, M_DEVBUF);
 	else
-		kmem_free(kernel_map, (vm_offset_t)vaddr, dmat->maxsize);
+		kmem_free(kernel_arena, (vm_offset_t)vaddr, dmat->maxsize);
 	CTR3(KTR_BUSDMA, "%s: tag %p flags 0x%x", __func__, dmat, dmat->flags);
 }
 
Index: /usr/src/sys/xen/gnttab.c
===================================================================
--- /usr/src/sys/xen/gnttab.c	(revision 253832)
+++ /usr/src/sys/xen/gnttab.c	(working copy)
@@ -527,7 +527,7 @@ gnttab_map(unsigned int start_idx, unsigned int en
 	if (shared == NULL) {
 		vm_offset_t area;
 
-		area = kmem_alloc_nofault(kernel_map,
+		area = kva_alloc(kernel_arena,
 		    PAGE_SIZE * max_nr_grant_frames());
 		KASSERT(area, ("can't allocate VM space for grant table"));
 		shared = (grant_entry_t *)area;
@@ -590,7 +590,7 @@ gnttab_map(unsigned int start_idx, unsigned int en
 	if (shared == NULL) {
 		vm_offset_t area;
 
-		area = kmem_alloc_nofault(kernel_map,
+		area = kva_alloc(kernel_arena,
 		    PAGE_SIZE * max_nr_grant_frames());
 		KASSERT(area, ("can't allocate VM space for grant table"));
 		shared = (grant_entry_t *)area;
--
Test scenario: nullfs14.sh (or more likely cleanup.sh)