vm_meter.c revision 171633
1130803Smarcel/*- 2130803Smarcel * Copyright (c) 1982, 1986, 1989, 1993 3130803Smarcel * The Regents of the University of California. All rights reserved. 4130803Smarcel * 5130803Smarcel * Redistribution and use in source and binary forms, with or without 6130803Smarcel * modification, are permitted provided that the following conditions 7130803Smarcel * are met: 8130803Smarcel * 1. Redistributions of source code must retain the above copyright 9130803Smarcel * notice, this list of conditions and the following disclaimer. 10130803Smarcel * 2. Redistributions in binary form must reproduce the above copyright 11130803Smarcel * notice, this list of conditions and the following disclaimer in the 12130803Smarcel * documentation and/or other materials provided with the distribution. 13130803Smarcel * 4. Neither the name of the University nor the names of its contributors 14130803Smarcel * may be used to endorse or promote products derived from this software 15130803Smarcel * without specific prior written permission. 16130803Smarcel * 17130803Smarcel * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 18130803Smarcel * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19130803Smarcel * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20130803Smarcel * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 21130803Smarcel * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22130803Smarcel * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23130803Smarcel * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24130803Smarcel * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25130803Smarcel * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26130803Smarcel * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27130803Smarcel * SUCH DAMAGE. 28130803Smarcel * 29130803Smarcel * @(#)vm_meter.c 8.4 (Berkeley) 1/4/94 30130803Smarcel */ 31130803Smarcel 32130803Smarcel#include <sys/cdefs.h> 33130803Smarcel__FBSDID("$FreeBSD: head/sys/vm/vm_meter.c 171633 2007-07-27 20:01:22Z alc $"); 34130803Smarcel 35130803Smarcel#include <sys/param.h> 36130803Smarcel#include <sys/systm.h> 37130803Smarcel#include <sys/kernel.h> 38130803Smarcel#include <sys/lock.h> 39130803Smarcel#include <sys/mutex.h> 40130803Smarcel#include <sys/proc.h> 41130803Smarcel#include <sys/resource.h> 42130803Smarcel#include <sys/sx.h> 43130803Smarcel#include <sys/vmmeter.h> 44130803Smarcel#include <sys/smp.h> 45130803Smarcel 46130803Smarcel#include <vm/vm.h> 47130803Smarcel#include <vm/vm_page.h> 48130803Smarcel#include <vm/vm_extern.h> 49130803Smarcel#include <vm/vm_param.h> 50130803Smarcel#include <vm/pmap.h> 51130803Smarcel#include <vm/vm_map.h> 52130803Smarcel#include <vm/vm_object.h> 53130803Smarcel#include <sys/sysctl.h> 54130803Smarcel 55130803Smarcelstruct vmmeter cnt; 56130803Smarcel 57130803Smarcelint maxslp = MAXSLP; 58130803Smarcel 59130803SmarcelSYSCTL_UINT(_vm, VM_V_FREE_MIN, v_free_min, 60130803Smarcel CTLFLAG_RW, &cnt.v_free_min, 0, ""); 61130803SmarcelSYSCTL_UINT(_vm, VM_V_FREE_TARGET, v_free_target, 62130803Smarcel CTLFLAG_RW, &cnt.v_free_target, 0, ""); 63130803SmarcelSYSCTL_UINT(_vm, VM_V_FREE_RESERVED, v_free_reserved, 64130803Smarcel CTLFLAG_RW, &cnt.v_free_reserved, 0, ""); 65130803SmarcelSYSCTL_UINT(_vm, VM_V_INACTIVE_TARGET, v_inactive_target, 66130803Smarcel CTLFLAG_RW, &cnt.v_inactive_target, 0, ""); 67130803SmarcelSYSCTL_UINT(_vm, VM_V_CACHE_MIN, v_cache_min, 68130803Smarcel CTLFLAG_RW, &cnt.v_cache_min, 0, ""); 69130803SmarcelSYSCTL_UINT(_vm, VM_V_CACHE_MAX, v_cache_max, 70130803Smarcel CTLFLAG_RW, &cnt.v_cache_max, 0, ""); 71130803SmarcelSYSCTL_UINT(_vm, VM_V_PAGEOUT_FREE_MIN, v_pageout_free_min, 72130803Smarcel CTLFLAG_RW, &cnt.v_pageout_free_min, 0, ""); 73130803SmarcelSYSCTL_UINT(_vm, OID_AUTO, v_free_severe, 74130803Smarcel CTLFLAG_RW, &cnt.v_free_severe, 0, ""); 75130803Smarcel 76130803Smarcelstatic int 77130803Smarcelsysctl_vm_loadavg(SYSCTL_HANDLER_ARGS) 78130803Smarcel{ 79130803Smarcel#ifdef SCTL_MASK32 80130803Smarcel u_int32_t la[4]; 81130803Smarcel 82130803Smarcel if (req->flags & SCTL_MASK32) { 83130803Smarcel la[0] = averunnable.ldavg[0]; 84130803Smarcel la[1] = averunnable.ldavg[1]; 85130803Smarcel la[2] = averunnable.ldavg[2]; 86130803Smarcel la[3] = averunnable.fscale; 87130803Smarcel return SYSCTL_OUT(req, la, sizeof(la)); 88130803Smarcel } else 89130803Smarcel#endif 90130803Smarcel return SYSCTL_OUT(req, &averunnable, sizeof(averunnable)); 91130803Smarcel} 92130803SmarcelSYSCTL_PROC(_vm, VM_LOADAVG, loadavg, CTLTYPE_STRUCT|CTLFLAG_RD, 93130803Smarcel NULL, 0, sysctl_vm_loadavg, "S,loadavg", "Machine loadaverage history"); 94130803Smarcel 95130803Smarcelstatic int 96130803Smarcelvmtotal(SYSCTL_HANDLER_ARGS) 97130803Smarcel{ 98130803Smarcel/* XXXKSE almost completely broken */ 99130803Smarcel struct proc *p; 100130803Smarcel struct vmtotal total; 101130803Smarcel vm_map_entry_t entry; 102130803Smarcel vm_object_t object; 103130803Smarcel vm_map_t map; 104130803Smarcel int paging; 105130803Smarcel struct thread *td; 106130803Smarcel struct vmspace *vm; 107130803Smarcel 108130803Smarcel bzero(&total, sizeof(total)); 109130803Smarcel /* 110130803Smarcel * Mark all objects as inactive. 111130803Smarcel */ 112130803Smarcel GIANT_REQUIRED; 113130803Smarcel mtx_lock(&vm_object_list_mtx); 114130803Smarcel TAILQ_FOREACH(object, &vm_object_list, object_list) { 115130803Smarcel if (!VM_OBJECT_TRYLOCK(object)) { 116130803Smarcel /* 117130803Smarcel * Avoid a lock-order reversal. Consequently, 118130803Smarcel * the reported number of active pages may be 119130803Smarcel * greater than the actual number. 120130803Smarcel */ 121130803Smarcel continue; 122130803Smarcel } 123130803Smarcel vm_object_clear_flag(object, OBJ_ACTIVE); 124130803Smarcel VM_OBJECT_UNLOCK(object); 125130803Smarcel } 126130803Smarcel mtx_unlock(&vm_object_list_mtx); 127130803Smarcel /* 128130803Smarcel * Calculate process statistics. 129130803Smarcel */ 130130803Smarcel sx_slock(&allproc_lock); 131130803Smarcel FOREACH_PROC_IN_SYSTEM(p) { 132130803Smarcel if (p->p_flag & P_SYSTEM) 133130803Smarcel continue; 134130803Smarcel PROC_SLOCK(p); 135130803Smarcel switch (p->p_state) { 136130803Smarcel case PRS_NEW: 137130803Smarcel PROC_SUNLOCK(p); 138130803Smarcel continue; 139130803Smarcel break; 140130803Smarcel default: 141130803Smarcel FOREACH_THREAD_IN_PROC(p, td) { 142130803Smarcel /* Need new statistics XXX */ 143130803Smarcel thread_lock(td); 144130803Smarcel switch (td->td_state) { 145130803Smarcel case TDS_INHIBITED: 146130803Smarcel /* 147130803Smarcel * XXX stats no longer synchronized. 148130803Smarcel */ 149130803Smarcel if (TD_ON_LOCK(td) || 150130803Smarcel (td->td_inhibitors == 151130803Smarcel TDI_SWAPPED)) { 152130803Smarcel total.t_sw++; 153130803Smarcel } else if (TD_IS_SLEEPING(td) || 154130803Smarcel TD_AWAITING_INTR(td) || 155130803Smarcel TD_IS_SUSPENDED(td)) { 156130803Smarcel if (td->td_priority <= PZERO) 157130803Smarcel total.t_dw++; 158130803Smarcel else 159130803Smarcel total.t_sl++; 160130803Smarcel } 161130803Smarcel break; 162130803Smarcel 163130803Smarcel case TDS_CAN_RUN: 164130803Smarcel total.t_sw++; 165130803Smarcel break; 166130803Smarcel case TDS_RUNQ: 167130803Smarcel case TDS_RUNNING: 168130803Smarcel total.t_rq++; 169130803Smarcel thread_unlock(td); 170130803Smarcel continue; 171130803Smarcel default: 172130803Smarcel break; 173130803Smarcel } 174130803Smarcel thread_unlock(td); 175130803Smarcel } 176130803Smarcel } 177130803Smarcel PROC_SUNLOCK(p); 178130803Smarcel /* 179130803Smarcel * Note active objects. 180130803Smarcel */ 181130803Smarcel paging = 0; 182130803Smarcel vm = vmspace_acquire_ref(p); 183130803Smarcel if (vm == NULL) 184130803Smarcel continue; 185130803Smarcel map = &vm->vm_map; 186130803Smarcel vm_map_lock_read(map); 187130803Smarcel for (entry = map->header.next; 188130803Smarcel entry != &map->header; entry = entry->next) { 189130803Smarcel if ((entry->eflags & MAP_ENTRY_IS_SUB_MAP) || 190130803Smarcel (object = entry->object.vm_object) == NULL) 191130803Smarcel continue; 192130803Smarcel VM_OBJECT_LOCK(object); 193130803Smarcel vm_object_set_flag(object, OBJ_ACTIVE); 194130803Smarcel paging |= object->paging_in_progress; 195130803Smarcel VM_OBJECT_UNLOCK(object); 196130803Smarcel } 197130803Smarcel vm_map_unlock_read(map); 198130803Smarcel vmspace_free(vm); 199130803Smarcel if (paging) 200130803Smarcel total.t_pw++; 201130803Smarcel } 202130803Smarcel sx_sunlock(&allproc_lock); 203130803Smarcel /* 204130803Smarcel * Calculate object memory usage statistics. 205130803Smarcel */ 206130803Smarcel mtx_lock(&vm_object_list_mtx); 207130803Smarcel TAILQ_FOREACH(object, &vm_object_list, object_list) { 208130803Smarcel /* 209130803Smarcel * Perform unsynchronized reads on the object to avoid 210130803Smarcel * a lock-order reversal. In this case, the lack of 211130803Smarcel * synchronization should not impair the accuracy of 212130803Smarcel * the reported statistics. 213130803Smarcel */ 214130803Smarcel if (object->type == OBJT_DEVICE) { 215130803Smarcel /* 216130803Smarcel * Devices, like /dev/mem, will badly skew our totals. 217130803Smarcel */ 218130803Smarcel continue; 219130803Smarcel } 220130803Smarcel if (object->ref_count == 0) { 221130803Smarcel /* 222130803Smarcel * Also skip unreferenced objects, including 223130803Smarcel * vnodes representing mounted file systems. 224130803Smarcel */ 225130803Smarcel continue; 226130803Smarcel } 227130803Smarcel total.t_vm += object->size; 228130803Smarcel total.t_rm += object->resident_page_count; 229130803Smarcel if (object->flags & OBJ_ACTIVE) { 230130803Smarcel total.t_avm += object->size; 231130803Smarcel total.t_arm += object->resident_page_count; 232130803Smarcel } 233130803Smarcel if (object->shadow_count > 1) { 234130803Smarcel /* shared object */ 235130803Smarcel total.t_vmshr += object->size; 236130803Smarcel total.t_rmshr += object->resident_page_count; 237130803Smarcel if (object->flags & OBJ_ACTIVE) { 238130803Smarcel total.t_avmshr += object->size; 239130803Smarcel total.t_armshr += object->resident_page_count; 240130803Smarcel } 241130803Smarcel } 242130803Smarcel } 243130803Smarcel mtx_unlock(&vm_object_list_mtx); 244130803Smarcel total.t_free = cnt.v_free_count + cnt.v_cache_count; 245130803Smarcel return (sysctl_handle_opaque(oidp, &total, sizeof(total), req)); 246130803Smarcel} 247130803Smarcel 248130803Smarcel/* 249130803Smarcel * vcnt() - accumulate statistics from all cpus and the global cnt 250130803Smarcel * structure. 251130803Smarcel * 252130803Smarcel * The vmmeter structure is now per-cpu as well as global. Those 253130803Smarcel * statistics which can be kept on a per-cpu basis (to avoid cache 254130803Smarcel * stalls between cpus) can be moved to the per-cpu vmmeter. Remaining 255130803Smarcel * statistics, such as v_free_reserved, are left in the global 256130803Smarcel * structure. 257130803Smarcel * 258130803Smarcel * (sysctl_oid *oidp, void *arg1, int arg2, struct sysctl_req *req) 259130803Smarcel */ 260130803Smarcelstatic int 261130803Smarcelvcnt(SYSCTL_HANDLER_ARGS) 262130803Smarcel{ 263130803Smarcel int count = *(int *)arg1; 264130803Smarcel int offset = (char *)arg1 - (char *)&cnt; 265130803Smarcel#ifdef SMP 266130803Smarcel int i; 267130803Smarcel 268130803Smarcel for (i = 0; i < mp_ncpus; ++i) { 269130803Smarcel struct pcpu *pcpu = pcpu_find(i); 270130803Smarcel count += *(int *)((char *)&pcpu->pc_cnt + offset); 271130803Smarcel } 272130803Smarcel#else 273130803Smarcel count += *(int *)((char *)PCPU_PTR(cnt) + offset); 274130803Smarcel#endif 275130803Smarcel return (SYSCTL_OUT(req, &count, sizeof(int))); 276130803Smarcel} 277130803Smarcel 278130803SmarcelSYSCTL_PROC(_vm, VM_TOTAL, vmtotal, CTLTYPE_OPAQUE|CTLFLAG_RD, 279130803Smarcel 0, sizeof(struct vmtotal), vmtotal, "S,vmtotal", 280130803Smarcel "System virtual memory statistics"); 281130803SmarcelSYSCTL_NODE(_vm, OID_AUTO, stats, CTLFLAG_RW, 0, "VM meter stats"); 282130803Smarcelstatic SYSCTL_NODE(_vm_stats, OID_AUTO, sys, CTLFLAG_RW, 0, 283130803Smarcel "VM meter sys stats"); 284130803Smarcelstatic SYSCTL_NODE(_vm_stats, OID_AUTO, vm, CTLFLAG_RW, 0, 285130803Smarcel "VM meter vm stats"); 286130803SmarcelSYSCTL_NODE(_vm_stats, OID_AUTO, misc, CTLFLAG_RW, 0, "VM meter misc stats"); 287130803Smarcel 288130803SmarcelSYSCTL_PROC(_vm_stats_sys, OID_AUTO, v_swtch, CTLTYPE_UINT|CTLFLAG_RD, 289130803Smarcel &cnt.v_swtch, 0, vcnt, "IU", "Context switches"); 290130803SmarcelSYSCTL_PROC(_vm_stats_sys, OID_AUTO, v_trap, CTLTYPE_UINT|CTLFLAG_RD, 291130803Smarcel &cnt.v_trap, 0, vcnt, "IU", "Traps"); 292130803SmarcelSYSCTL_PROC(_vm_stats_sys, OID_AUTO, v_syscall, CTLTYPE_UINT|CTLFLAG_RD, 293130803Smarcel &cnt.v_syscall, 0, vcnt, "IU", "Syscalls"); 294130803SmarcelSYSCTL_PROC(_vm_stats_sys, OID_AUTO, v_intr, CTLTYPE_UINT|CTLFLAG_RD, 295130803Smarcel &cnt.v_intr, 0, vcnt, "IU", "Hardware interrupts"); 296130803SmarcelSYSCTL_PROC(_vm_stats_sys, OID_AUTO, v_soft, CTLTYPE_UINT|CTLFLAG_RD, 297130803Smarcel &cnt.v_soft, 0, vcnt, "IU", "Software interrupts"); 298130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vm_faults, CTLTYPE_UINT|CTLFLAG_RD, 299130803Smarcel &cnt.v_vm_faults, 0, vcnt, "IU", "VM faults"); 300130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_cow_faults, CTLTYPE_UINT|CTLFLAG_RD, 301130803Smarcel &cnt.v_cow_faults, 0, vcnt, "IU", "COW faults"); 302130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_cow_optim, CTLTYPE_UINT|CTLFLAG_RD, 303130803Smarcel &cnt.v_cow_optim, 0, vcnt, "IU", "Optimized COW faults"); 304130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_zfod, CTLTYPE_UINT|CTLFLAG_RD, 305130803Smarcel &cnt.v_zfod, 0, vcnt, "IU", "Zero fill"); 306130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_ozfod, CTLTYPE_UINT|CTLFLAG_RD, 307130803Smarcel &cnt.v_ozfod, 0, vcnt, "IU", "Optimized zero fill"); 308130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_swapin, CTLTYPE_UINT|CTLFLAG_RD, 309130803Smarcel &cnt.v_swapin, 0, vcnt, "IU", "Swapin operations"); 310130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_swapout, CTLTYPE_UINT|CTLFLAG_RD, 311130803Smarcel &cnt.v_swapout, 0, vcnt, "IU", "Swapout operations"); 312130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_swappgsin, CTLTYPE_UINT|CTLFLAG_RD, 313130803Smarcel &cnt.v_swappgsin, 0, vcnt, "IU", "Swapin pages"); 314130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_swappgsout, CTLTYPE_UINT|CTLFLAG_RD, 315130803Smarcel &cnt.v_swappgsout, 0, vcnt, "IU", "Swapout pages"); 316130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vnodein, CTLTYPE_UINT|CTLFLAG_RD, 317130803Smarcel &cnt.v_vnodein, 0, vcnt, "IU", "Vnodein operations"); 318130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vnodeout, CTLTYPE_UINT|CTLFLAG_RD, 319130803Smarcel &cnt.v_vnodeout, 0, vcnt, "IU", "Vnodeout operations"); 320130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vnodepgsin, CTLTYPE_UINT|CTLFLAG_RD, 321130803Smarcel &cnt.v_vnodepgsin, 0, vcnt, "IU", "Vnodein pages"); 322130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vnodepgsout, CTLTYPE_UINT|CTLFLAG_RD, 323130803Smarcel &cnt.v_vnodepgsout, 0, vcnt, "IU", "Vnodeout pages"); 324130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_intrans, CTLTYPE_UINT|CTLFLAG_RD, 325130803Smarcel &cnt.v_intrans, 0, vcnt, "IU", "In transit page blocking"); 326130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_reactivated, CTLTYPE_UINT|CTLFLAG_RD, 327130803Smarcel &cnt.v_reactivated, 0, vcnt, "IU", "Reactivated pages"); 328130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_pdwakeups, CTLTYPE_UINT|CTLFLAG_RD, 329130803Smarcel &cnt.v_pdwakeups, 0, vcnt, "IU", "Pagedaemon wakeups"); 330130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_pdpages, CTLTYPE_UINT|CTLFLAG_RD, 331130803Smarcel &cnt.v_pdpages, 0, vcnt, "IU", "Pagedaemon page scans"); 332130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_tcached, CTLTYPE_UINT|CTLFLAG_RD, 333130803Smarcel &cnt.v_tcached, 0, vcnt, "IU", "Total pages cached"); 334130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_dfree, CTLTYPE_UINT|CTLFLAG_RD, 335130803Smarcel &cnt.v_dfree, 0, vcnt, "IU", ""); 336130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_pfree, CTLTYPE_UINT|CTLFLAG_RD, 337130803Smarcel &cnt.v_pfree, 0, vcnt, "IU", ""); 338130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_tfree, CTLTYPE_UINT|CTLFLAG_RD, 339130803Smarcel &cnt.v_tfree, 0, vcnt, "IU", ""); 340130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_page_size, CTLTYPE_UINT|CTLFLAG_RD, 341130803Smarcel &cnt.v_page_size, 0, vcnt, "IU", ""); 342130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_page_count, CTLTYPE_UINT|CTLFLAG_RD, 343130803Smarcel &cnt.v_page_count, 0, vcnt, "IU", ""); 344130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_free_reserved, CTLTYPE_UINT|CTLFLAG_RD, 345130803Smarcel &cnt.v_free_reserved, 0, vcnt, "IU", ""); 346130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_free_target, CTLTYPE_UINT|CTLFLAG_RD, 347130803Smarcel &cnt.v_free_target, 0, vcnt, "IU", ""); 348130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_free_min, CTLTYPE_UINT|CTLFLAG_RD, 349130803Smarcel &cnt.v_free_min, 0, vcnt, "IU", ""); 350130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_free_count, CTLTYPE_UINT|CTLFLAG_RD, 351130803Smarcel &cnt.v_free_count, 0, vcnt, "IU", ""); 352130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_wire_count, CTLTYPE_UINT|CTLFLAG_RD, 353130803Smarcel &cnt.v_wire_count, 0, vcnt, "IU", ""); 354130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_active_count, CTLTYPE_UINT|CTLFLAG_RD, 355130803Smarcel &cnt.v_active_count, 0, vcnt, "IU", ""); 356130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_inactive_target, CTLTYPE_UINT|CTLFLAG_RD, 357130803Smarcel &cnt.v_inactive_target, 0, vcnt, "IU", ""); 358130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_inactive_count, CTLTYPE_UINT|CTLFLAG_RD, 359130803Smarcel &cnt.v_inactive_count, 0, vcnt, "IU", ""); 360130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_cache_count, CTLTYPE_UINT|CTLFLAG_RD, 361130803Smarcel &cnt.v_cache_count, 0, vcnt, "IU", ""); 362130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_cache_min, CTLTYPE_UINT|CTLFLAG_RD, 363130803Smarcel &cnt.v_cache_min, 0, vcnt, "IU", ""); 364130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_cache_max, CTLTYPE_UINT|CTLFLAG_RD, 365130803Smarcel &cnt.v_cache_max, 0, vcnt, "IU", ""); 366130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_pageout_free_min, CTLTYPE_UINT|CTLFLAG_RD, 367130803Smarcel &cnt.v_pageout_free_min, 0, vcnt, "IU", ""); 368130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_interrupt_free_min, CTLTYPE_UINT|CTLFLAG_RD, 369130803Smarcel &cnt.v_interrupt_free_min, 0, vcnt, "IU", ""); 370130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_forks, CTLTYPE_UINT|CTLFLAG_RD, 371130803Smarcel &cnt.v_forks, 0, vcnt, "IU", "Number of fork() calls"); 372130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vforks, CTLTYPE_UINT|CTLFLAG_RD, 373130803Smarcel &cnt.v_vforks, 0, vcnt, "IU", "Number of vfork() calls"); 374130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_rforks, CTLTYPE_UINT|CTLFLAG_RD, 375130803Smarcel &cnt.v_rforks, 0, vcnt, "IU", "Number of rfork() calls"); 376130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_kthreads, CTLTYPE_UINT|CTLFLAG_RD, 377130803Smarcel &cnt.v_kthreads, 0, vcnt, "IU", "Number of fork() calls by kernel"); 378130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_forkpages, CTLTYPE_UINT|CTLFLAG_RD, 379130803Smarcel &cnt.v_forkpages, 0, vcnt, "IU", "VM pages affected by fork()"); 380130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_vforkpages, CTLTYPE_UINT|CTLFLAG_RD, 381130803Smarcel &cnt.v_vforkpages, 0, vcnt, "IU", "VM pages affected by vfork()"); 382130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_rforkpages, CTLTYPE_UINT|CTLFLAG_RD, 383130803Smarcel &cnt.v_rforkpages, 0, vcnt, "IU", "VM pages affected by rfork()"); 384130803SmarcelSYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_kthreadpages, CTLTYPE_UINT|CTLFLAG_RD, 385130803Smarcel &cnt.v_kthreadpages, 0, vcnt, "IU", "VM pages affected by fork() by kernel"); 386130803Smarcel 387130803SmarcelSYSCTL_INT(_vm_stats_misc, OID_AUTO, 388130803Smarcel zero_page_count, CTLFLAG_RD, &vm_page_zero_count, 0, ""); 389130803Smarcel