2005-01-07 02:29:27 +00:00
|
|
|
/*-
|
2017-11-20 19:43:44 +00:00
|
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
|
|
|
*
|
1994-05-24 10:09:53 +00:00
|
|
|
* Copyright (c) 1982, 1986, 1989, 1993
|
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
2017-02-28 23:42:47 +00:00
|
|
|
* 3. Neither the name of the University nor the names of its contributors
|
1994-05-24 10:09:53 +00:00
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
|
* without specific prior written permission.
|
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
|
*
|
|
|
|
|
* @(#)vm_meter.c 8.4 (Berkeley) 1/4/94
|
|
|
|
|
*/
|
|
|
|
|
|
2003-06-11 23:50:51 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
#include <sys/kernel.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/lock.h>
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
#include <sys/malloc.h>
|
2001-05-01 08:13:21 +00:00
|
|
|
#include <sys/mutex.h>
|
|
|
|
|
#include <sys/proc.h>
|
1998-03-28 10:33:27 +00:00
|
|
|
#include <sys/resource.h>
|
2013-03-09 02:32:23 +00:00
|
|
|
#include <sys/rwlock.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
#include <sys/sx.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <sys/vmmeter.h>
|
2002-04-04 21:38:47 +00:00
|
|
|
#include <sys/smp.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <vm/vm.h>
|
1998-10-31 17:21:31 +00:00
|
|
|
#include <vm/vm_page.h>
|
1995-12-10 14:52:10 +00:00
|
|
|
#include <vm/vm_extern.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/vm_param.h>
|
2018-02-06 22:10:07 +00:00
|
|
|
#include <vm/vm_phys.h>
|
|
|
|
|
#include <vm/vm_pagequeue.h>
|
1995-12-07 12:48:31 +00:00
|
|
|
#include <vm/pmap.h>
|
|
|
|
|
#include <vm/vm_map.h>
|
|
|
|
|
#include <vm/vm_object.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/sysctl.h>
|
|
|
|
|
|
2018-04-27 05:36:02 +00:00
|
|
|
struct vmmeter __read_mostly vm_cnt = {
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
.v_swtch = EARLY_COUNTER,
|
|
|
|
|
.v_trap = EARLY_COUNTER,
|
|
|
|
|
.v_syscall = EARLY_COUNTER,
|
|
|
|
|
.v_intr = EARLY_COUNTER,
|
|
|
|
|
.v_soft = EARLY_COUNTER,
|
|
|
|
|
.v_vm_faults = EARLY_COUNTER,
|
|
|
|
|
.v_io_faults = EARLY_COUNTER,
|
|
|
|
|
.v_cow_faults = EARLY_COUNTER,
|
|
|
|
|
.v_cow_optim = EARLY_COUNTER,
|
|
|
|
|
.v_zfod = EARLY_COUNTER,
|
|
|
|
|
.v_ozfod = EARLY_COUNTER,
|
|
|
|
|
.v_swapin = EARLY_COUNTER,
|
|
|
|
|
.v_swapout = EARLY_COUNTER,
|
|
|
|
|
.v_swappgsin = EARLY_COUNTER,
|
|
|
|
|
.v_swappgsout = EARLY_COUNTER,
|
|
|
|
|
.v_vnodein = EARLY_COUNTER,
|
|
|
|
|
.v_vnodeout = EARLY_COUNTER,
|
|
|
|
|
.v_vnodepgsin = EARLY_COUNTER,
|
|
|
|
|
.v_vnodepgsout = EARLY_COUNTER,
|
|
|
|
|
.v_intrans = EARLY_COUNTER,
|
|
|
|
|
.v_reactivated = EARLY_COUNTER,
|
|
|
|
|
.v_pdwakeups = EARLY_COUNTER,
|
|
|
|
|
.v_pdpages = EARLY_COUNTER,
|
|
|
|
|
.v_pdshortfalls = EARLY_COUNTER,
|
|
|
|
|
.v_dfree = EARLY_COUNTER,
|
|
|
|
|
.v_pfree = EARLY_COUNTER,
|
|
|
|
|
.v_tfree = EARLY_COUNTER,
|
|
|
|
|
.v_forks = EARLY_COUNTER,
|
|
|
|
|
.v_vforks = EARLY_COUNTER,
|
|
|
|
|
.v_rforks = EARLY_COUNTER,
|
|
|
|
|
.v_kthreads = EARLY_COUNTER,
|
|
|
|
|
.v_forkpages = EARLY_COUNTER,
|
|
|
|
|
.v_vforkpages = EARLY_COUNTER,
|
|
|
|
|
.v_rforkpages = EARLY_COUNTER,
|
|
|
|
|
.v_kthreadpages = EARLY_COUNTER,
|
2018-02-12 22:53:00 +00:00
|
|
|
.v_wire_count = EARLY_COUNTER,
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
};
|
|
|
|
|
|
Provide separate accounting for user-wired pages.
Historically we have not distinguished between kernel wirings and user
wirings for accounting purposes. User wirings (via mlock(2)) were
subject to a global limit on the number of wired pages, so if large
swaths of physical memory were wired by the kernel, as happens with
the ZFS ARC among other things, the limit could be exceeded, causing
user wirings to fail.
The change adds a new counter, v_user_wire_count, which counts the
number of virtual pages wired by user processes via mlock(2) and
mlockall(2). Only user-wired pages are subject to the system-wide
limit which helps provide some safety against deadlocks. In
particular, while sources of kernel wirings typically support some
backpressure mechanism, there is no way to reclaim user-wired pages
shorting of killing the wiring process. The limit is exported as
vm.max_user_wired, renamed from vm.max_wired, and changed from u_int
to u_long.
The choice to count virtual user-wired pages rather than physical
pages was done for simplicity. There are mechanisms that can cause
user-wired mappings to be destroyed while maintaining a wiring of
the backing physical page; these make it difficult to accurately
track user wirings at the physical page layer.
The change also closes some holes which allowed user wirings to succeed
even when they would cause the system limit to be exceeded. For
instance, mmap() may now fail with ENOMEM in a process that has called
mlockall(MCL_FUTURE) if the new mapping would cause the user wiring
limit to be exceeded.
Note that bhyve -S is subject to the user wiring limit, which defaults
to 1/3 of physical RAM. Users that wish to exceed the limit must tune
vm.max_user_wired.
Reviewed by: kib, ngie (mlock() test changes)
Tested by: pho (earlier version)
MFC after: 45 days
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D19908
2019-05-13 16:38:48 +00:00
|
|
|
u_long __exclusive_cache_line vm_user_wire_count;
|
|
|
|
|
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
static void
|
|
|
|
|
vmcounter_startup(void)
|
|
|
|
|
{
|
|
|
|
|
counter_u64_t *cnt = (counter_u64_t *)&vm_cnt;
|
|
|
|
|
|
|
|
|
|
COUNTER_ARRAY_ALLOC(cnt, VM_METER_NCOUNTERS, M_WAITOK);
|
|
|
|
|
}
|
2018-02-12 22:53:00 +00:00
|
|
|
SYSINIT(counter, SI_SUB_KMEM, SI_ORDER_FIRST, vmcounter_startup, NULL);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, VM_V_FREE_MIN, v_free_min,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_free_min, 0, "Minimum low-free-pages threshold");
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, VM_V_FREE_TARGET, v_free_target,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_free_target, 0, "Desired free pages");
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, VM_V_FREE_RESERVED, v_free_reserved,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_free_reserved, 0, "Pages reserved for deadlock");
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, VM_V_INACTIVE_TARGET, v_inactive_target,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_inactive_target, 0, "Pages desired inactive");
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, VM_V_PAGEOUT_FREE_MIN, v_pageout_free_min,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_pageout_free_min, 0, "Min pages reserved for kernel");
|
2000-07-05 07:46:41 +00:00
|
|
|
SYSCTL_UINT(_vm, OID_AUTO, v_free_severe,
|
2014-03-22 10:26:09 +00:00
|
|
|
CTLFLAG_RW, &vm_cnt.v_free_severe, 0, "Severe page depletion point");
|
1995-11-14 09:29:34 +00:00
|
|
|
|
2004-10-11 22:04:16 +00:00
|
|
|
static int
|
|
|
|
|
sysctl_vm_loadavg(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
2020-09-01 21:20:45 +00:00
|
|
|
|
2004-10-11 22:04:16 +00:00
|
|
|
#ifdef SCTL_MASK32
|
|
|
|
|
u_int32_t la[4];
|
|
|
|
|
|
|
|
|
|
if (req->flags & SCTL_MASK32) {
|
|
|
|
|
la[0] = averunnable.ldavg[0];
|
|
|
|
|
la[1] = averunnable.ldavg[1];
|
|
|
|
|
la[2] = averunnable.ldavg[2];
|
|
|
|
|
la[3] = averunnable.fscale;
|
|
|
|
|
return SYSCTL_OUT(req, la, sizeof(la));
|
|
|
|
|
} else
|
|
|
|
|
#endif
|
|
|
|
|
return SYSCTL_OUT(req, &averunnable, sizeof(averunnable));
|
|
|
|
|
}
|
2009-01-23 22:49:23 +00:00
|
|
|
SYSCTL_PROC(_vm, VM_LOADAVG, loadavg, CTLTYPE_STRUCT | CTLFLAG_RD |
|
|
|
|
|
CTLFLAG_MPSAFE, NULL, 0, sysctl_vm_loadavg, "S,loadavg",
|
|
|
|
|
"Machine loadaverage history");
|
1995-11-14 09:29:34 +00:00
|
|
|
|
2016-06-21 17:49:33 +00:00
|
|
|
/*
|
|
|
|
|
* This function aims to determine if the object is mapped,
|
|
|
|
|
* specifically, if it is referenced by a vm_map_entry. Because
|
|
|
|
|
* objects occasionally acquire transient references that do not
|
|
|
|
|
* represent a mapping, the method used here is inexact. However, it
|
|
|
|
|
* has very low overhead and is good enough for the advisory
|
|
|
|
|
* vm.vmtotal sysctl.
|
|
|
|
|
*/
|
|
|
|
|
static bool
|
|
|
|
|
is_object_active(vm_object_t obj)
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
return (obj->ref_count > obj->shadow_count);
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-15 13:41:03 +00:00
|
|
|
#if defined(COMPAT_FREEBSD11)
|
|
|
|
|
struct vmtotal11 {
|
|
|
|
|
int16_t t_rq;
|
|
|
|
|
int16_t t_dw;
|
|
|
|
|
int16_t t_pw;
|
|
|
|
|
int16_t t_sl;
|
|
|
|
|
int16_t t_sw;
|
|
|
|
|
int32_t t_vm;
|
|
|
|
|
int32_t t_avm;
|
|
|
|
|
int32_t t_rm;
|
|
|
|
|
int32_t t_arm;
|
|
|
|
|
int32_t t_vmshr;
|
|
|
|
|
int32_t t_avmshr;
|
|
|
|
|
int32_t t_rmshr;
|
|
|
|
|
int32_t t_armshr;
|
|
|
|
|
int32_t t_free;
|
|
|
|
|
};
|
|
|
|
|
#endif
|
|
|
|
|
|
1995-11-14 09:29:34 +00:00
|
|
|
static int
|
2000-07-04 11:25:35 +00:00
|
|
|
vmtotal(SYSCTL_HANDLER_ARGS)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2006-11-20 08:33:55 +00:00
|
|
|
struct vmtotal total;
|
2017-11-15 13:41:03 +00:00
|
|
|
#if defined(COMPAT_FREEBSD11)
|
|
|
|
|
struct vmtotal11 total11;
|
|
|
|
|
#endif
|
1995-11-14 09:29:34 +00:00
|
|
|
vm_object_t object;
|
2016-06-21 17:49:33 +00:00
|
|
|
struct proc *p;
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
struct thread *td;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2017-11-15 13:41:03 +00:00
|
|
|
if (req->oldptr == NULL) {
|
|
|
|
|
#if defined(COMPAT_FREEBSD11)
|
|
|
|
|
if (curproc->p_osrel < P_OSREL_VMTOTAL64)
|
|
|
|
|
return (SYSCTL_OUT(req, NULL, sizeof(total11)));
|
|
|
|
|
#endif
|
|
|
|
|
return (SYSCTL_OUT(req, NULL, sizeof(total)));
|
|
|
|
|
}
|
2006-11-20 08:33:55 +00:00
|
|
|
bzero(&total, sizeof(total));
|
2016-06-21 17:49:33 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Calculate process statistics.
|
|
|
|
|
*/
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_slock(&allproc_lock);
|
2001-09-12 08:38:13 +00:00
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
2016-12-26 19:29:04 +00:00
|
|
|
if ((p->p_flag & P_SYSTEM) != 0)
|
1994-05-24 10:09:53 +00:00
|
|
|
continue;
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_LOCK(p);
|
2016-12-26 19:29:04 +00:00
|
|
|
if (p->p_state != PRS_NEW) {
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
FOREACH_THREAD_IN_PROC(p, td) {
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_lock(td);
|
2021-02-18 10:25:10 +00:00
|
|
|
switch (TD_GET_STATE(td)) {
|
2002-09-11 08:13:56 +00:00
|
|
|
case TDS_INHIBITED:
|
2008-03-12 06:31:06 +00:00
|
|
|
if (TD_IS_SWAPPED(td))
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_sw++;
|
2016-06-21 17:49:33 +00:00
|
|
|
else if (TD_IS_SLEEPING(td)) {
|
|
|
|
|
if (td->td_priority <= PZERO)
|
|
|
|
|
total.t_dw++;
|
|
|
|
|
else
|
|
|
|
|
total.t_sl++;
|
|
|
|
|
}
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
break;
|
2002-09-11 08:13:56 +00:00
|
|
|
case TDS_CAN_RUN:
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_sw++;
|
2002-09-11 08:13:56 +00:00
|
|
|
break;
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
case TDS_RUNQ:
|
|
|
|
|
case TDS_RUNNING:
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_rq++;
|
2016-12-26 19:29:04 +00:00
|
|
|
break;
|
Part 1 of KSE-III
The ability to schedule multiple threads per process
(one one cpu) by making ALL system calls optionally asynchronous.
to come: ia64 and power-pc patches, patches for gdb, test program (in tools)
Reviewed by: Almost everyone who counts
(at various times, peter, jhb, matt, alfred, mini, bernd,
and a cast of thousands)
NOTE: this is still Beta code, and contains lots of debugging stuff.
expect slight instability in signals..
2002-06-29 17:26:22 +00:00
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
Commit 14/14 of sched_lock decomposition.
- Use thread_lock() rather than sched_lock for per-thread scheduling
sychronization.
- Use the per-process spinlock rather than the sched_lock for per-process
scheduling synchronization.
Tested by: kris, current@
Tested on: i386, amd64, ULE, 4BSD, libthr, libkse, PREEMPTION, etc.
Discussed with: kris, attilio, kmacy, jhb, julian, bde (small parts each)
2007-06-05 00:00:57 +00:00
|
|
|
thread_unlock(td);
|
2001-01-24 11:28:36 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2008-03-19 06:19:01 +00:00
|
|
|
PROC_UNLOCK(p);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2001-03-28 11:52:56 +00:00
|
|
|
sx_sunlock(&allproc_lock);
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
|
* Calculate object memory usage statistics.
|
|
|
|
|
*/
|
2002-04-20 07:23:22 +00:00
|
|
|
mtx_lock(&vm_object_list_mtx);
|
2001-04-15 10:22:04 +00:00
|
|
|
TAILQ_FOREACH(object, &vm_object_list, object_list) {
|
1999-01-21 08:29:12 +00:00
|
|
|
/*
|
2015-05-08 19:43:37 +00:00
|
|
|
* Perform unsynchronized reads on the object. In
|
|
|
|
|
* this case, the lack of synchronization should not
|
|
|
|
|
* impair the accuracy of the reported statistics.
|
1999-01-21 08:29:12 +00:00
|
|
|
*/
|
In the past four years, we've added two new vm object types. Each time,
similar changes had to be made in various places throughout the machine-
independent virtual memory layer to support the new vm object type.
However, in most of these places, it's actually not the type of the vm
object that matters to us but instead certain attributes of its pages.
For example, OBJT_DEVICE, OBJT_MGTDEVICE, and OBJT_SG objects contain
fictitious pages. In other words, in most of these places, we were
testing the vm object's type to determine if it contained fictitious (or
unmanaged) pages.
To both simplify the code in these places and make the addition of future
vm object types easier, this change introduces two new vm object flags
that describe attributes of the vm object's pages, specifically, whether
they are fictitious or unmanaged.
Reviewed and tested by: kib
2012-12-09 00:32:38 +00:00
|
|
|
if ((object->flags & OBJ_FICTITIOUS) != 0) {
|
2004-01-02 19:38:25 +00:00
|
|
|
/*
|
|
|
|
|
* Devices, like /dev/mem, will badly skew our totals.
|
|
|
|
|
*/
|
1999-01-21 08:29:12 +00:00
|
|
|
continue;
|
2003-01-03 05:52:02 +00:00
|
|
|
}
|
2006-11-20 00:16:00 +00:00
|
|
|
if (object->ref_count == 0) {
|
|
|
|
|
/*
|
|
|
|
|
* Also skip unreferenced objects, including
|
|
|
|
|
* vnodes representing mounted file systems.
|
|
|
|
|
*/
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2016-06-21 17:49:33 +00:00
|
|
|
if (object->ref_count == 1 &&
|
2019-11-19 23:19:43 +00:00
|
|
|
(object->flags & OBJ_ANON) == 0) {
|
2016-06-21 17:49:33 +00:00
|
|
|
/*
|
|
|
|
|
* Also skip otherwise unreferenced swap
|
|
|
|
|
* objects backing tmpfs vnodes, and POSIX or
|
|
|
|
|
* SysV shared memory.
|
|
|
|
|
*/
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_vm += object->size;
|
|
|
|
|
total.t_rm += object->resident_page_count;
|
2016-06-21 17:49:33 +00:00
|
|
|
if (is_object_active(object)) {
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_avm += object->size;
|
|
|
|
|
total.t_arm += object->resident_page_count;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1996-09-08 20:44:49 +00:00
|
|
|
if (object->shadow_count > 1) {
|
1994-05-24 10:09:53 +00:00
|
|
|
/* shared object */
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_vmshr += object->size;
|
|
|
|
|
total.t_rmshr += object->resident_page_count;
|
2016-06-21 17:49:33 +00:00
|
|
|
if (is_object_active(object)) {
|
2006-11-20 08:33:55 +00:00
|
|
|
total.t_avmshr += object->size;
|
|
|
|
|
total.t_armshr += object->resident_page_count;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2002-04-20 07:23:22 +00:00
|
|
|
mtx_unlock(&vm_object_list_mtx);
|
2018-02-06 22:10:07 +00:00
|
|
|
total.t_pw = vm_wait_count();
|
|
|
|
|
total.t_free = vm_free_count();
|
2017-11-15 13:41:03 +00:00
|
|
|
#if defined(COMPAT_FREEBSD11)
|
|
|
|
|
/* sysctl(8) allocates twice as much memory as reported by sysctl(3) */
|
|
|
|
|
if (curproc->p_osrel < P_OSREL_VMTOTAL64 && (req->oldlen ==
|
|
|
|
|
sizeof(total11) || req->oldlen == 2 * sizeof(total11))) {
|
|
|
|
|
bzero(&total11, sizeof(total11));
|
|
|
|
|
total11.t_rq = total.t_rq;
|
|
|
|
|
total11.t_dw = total.t_dw;
|
|
|
|
|
total11.t_pw = total.t_pw;
|
|
|
|
|
total11.t_sl = total.t_sl;
|
|
|
|
|
total11.t_sw = total.t_sw;
|
|
|
|
|
total11.t_vm = total.t_vm; /* truncate */
|
|
|
|
|
total11.t_avm = total.t_avm; /* truncate */
|
|
|
|
|
total11.t_rm = total.t_rm; /* truncate */
|
|
|
|
|
total11.t_arm = total.t_arm; /* truncate */
|
|
|
|
|
total11.t_vmshr = total.t_vmshr; /* truncate */
|
|
|
|
|
total11.t_avmshr = total.t_avmshr; /* truncate */
|
|
|
|
|
total11.t_rmshr = total.t_rmshr; /* truncate */
|
|
|
|
|
total11.t_armshr = total.t_armshr; /* truncate */
|
|
|
|
|
total11.t_free = total.t_free; /* truncate */
|
|
|
|
|
return (SYSCTL_OUT(req, &total11, sizeof(total11)));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return (SYSCTL_OUT(req, &total, sizeof(total)));
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
1995-11-14 09:29:34 +00:00
|
|
|
|
2017-11-15 13:41:03 +00:00
|
|
|
SYSCTL_PROC(_vm, VM_TOTAL, vmtotal, CTLTYPE_OPAQUE | CTLFLAG_RD |
|
|
|
|
|
CTLFLAG_MPSAFE, NULL, 0, vmtotal, "S,vmtotal",
|
1999-05-03 23:57:32 +00:00
|
|
|
"System virtual memory statistics");
|
2020-02-26 14:26:36 +00:00
|
|
|
SYSCTL_NODE(_vm, OID_AUTO, stats, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
|
|
|
|
|
"VM meter stats");
|
|
|
|
|
static SYSCTL_NODE(_vm_stats, OID_AUTO, sys, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
|
|
|
|
|
"VM meter sys stats");
|
|
|
|
|
static SYSCTL_NODE(_vm_stats, OID_AUTO, vm, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
|
|
|
|
|
"VM meter vm stats");
|
|
|
|
|
SYSCTL_NODE(_vm_stats, OID_AUTO, misc, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
|
|
|
|
|
"VM meter misc stats");
|
2002-04-04 21:38:47 +00:00
|
|
|
|
2017-05-02 18:40:41 +00:00
|
|
|
static int
|
|
|
|
|
sysctl_handle_vmstat(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
|
|
|
|
uint64_t val;
|
|
|
|
|
#ifdef COMPAT_FREEBSD11
|
|
|
|
|
uint32_t val32;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
val = counter_u64_fetch(*(counter_u64_t *)arg1);
|
|
|
|
|
#ifdef COMPAT_FREEBSD11
|
|
|
|
|
if (req->oldlen == sizeof(val32)) {
|
|
|
|
|
val32 = val; /* truncate */
|
|
|
|
|
return (SYSCTL_OUT(req, &val32, sizeof(val32)));
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return (SYSCTL_OUT(req, &val, sizeof(val)));
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-14 13:25:00 +00:00
|
|
|
#define VM_STATS(parent, var, descr) \
|
2017-05-02 18:40:41 +00:00
|
|
|
SYSCTL_OID(parent, OID_AUTO, var, CTLTYPE_U64 | CTLFLAG_MPSAFE | \
|
2018-02-06 22:10:07 +00:00
|
|
|
CTLFLAG_RD, &vm_cnt.var, 0, sysctl_handle_vmstat, "QU", descr)
|
2011-12-14 13:25:00 +00:00
|
|
|
#define VM_STATS_VM(var, descr) VM_STATS(_vm_stats_vm, var, descr)
|
|
|
|
|
#define VM_STATS_SYS(var, descr) VM_STATS(_vm_stats_sys, var, descr)
|
2002-04-04 21:38:47 +00:00
|
|
|
|
2011-12-13 00:38:50 +00:00
|
|
|
VM_STATS_SYS(v_swtch, "Context switches");
|
|
|
|
|
VM_STATS_SYS(v_trap, "Traps");
|
|
|
|
|
VM_STATS_SYS(v_syscall, "System calls");
|
|
|
|
|
VM_STATS_SYS(v_intr, "Device interrupts");
|
|
|
|
|
VM_STATS_SYS(v_soft, "Software interrupts");
|
2011-12-14 13:25:00 +00:00
|
|
|
VM_STATS_VM(v_vm_faults, "Address memory faults");
|
2013-01-28 12:54:53 +00:00
|
|
|
VM_STATS_VM(v_io_faults, "Page faults requiring I/O");
|
2011-12-14 13:25:00 +00:00
|
|
|
VM_STATS_VM(v_cow_faults, "Copy-on-write faults");
|
|
|
|
|
VM_STATS_VM(v_cow_optim, "Optimized COW faults");
|
|
|
|
|
VM_STATS_VM(v_zfod, "Pages zero-filled on demand");
|
|
|
|
|
VM_STATS_VM(v_ozfod, "Optimized zero fill pages");
|
|
|
|
|
VM_STATS_VM(v_swapin, "Swap pager pageins");
|
|
|
|
|
VM_STATS_VM(v_swapout, "Swap pager pageouts");
|
|
|
|
|
VM_STATS_VM(v_swappgsin, "Swap pages swapped in");
|
|
|
|
|
VM_STATS_VM(v_swappgsout, "Swap pages swapped out");
|
|
|
|
|
VM_STATS_VM(v_vnodein, "Vnode pager pageins");
|
|
|
|
|
VM_STATS_VM(v_vnodeout, "Vnode pager pageouts");
|
|
|
|
|
VM_STATS_VM(v_vnodepgsin, "Vnode pages paged in");
|
|
|
|
|
VM_STATS_VM(v_vnodepgsout, "Vnode pages paged out");
|
|
|
|
|
VM_STATS_VM(v_intrans, "In transit page faults");
|
Introduce a new page queue, PQ_LAUNDRY, for storing unreferenced, dirty
pages, specificially, dirty pages that have passed once through the inactive
queue. A new, dedicated thread is responsible for both deciding when to
launder pages and actually laundering them. The new policy uses the
relative sizes of the inactive and laundry queues to determine whether to
launder pages at a given point in time. In general, this leads to more
intelligent swapping behavior, since the laundry thread will avoid pageouts
when the marginal benefit of doing so is low. Previously, without a
dedicated queue for dirty pages, the page daemon didn't have the information
to determine whether pageout provides any benefit to the system. Thus, the
previous policy often resulted in small but steadily increasing amounts of
swap usage when the system is under memory pressure, even when the inactive
queue consisted mostly of clean pages. This change addresses that issue,
and also paves the way for some future virtual memory system improvements by
removing the last source of object-cached clean pages, i.e., PG_CACHE pages.
The new laundry thread sleeps while waiting for a request from the page
daemon thread(s). A request is raised by setting the variable
vm_laundry_request and waking the laundry thread. We request launderings
for two reasons: to try and balance the inactive and laundry queue sizes
("background laundering"), and to quickly make up for a shortage of free
pages and clean inactive pages ("shortfall laundering"). When background
laundering is requested, the laundry thread computes the number of page
daemon wakeups that have taken place since the last laundering. If this
number is large enough relative to the ratio of the laundry and (global)
inactive queue sizes, we will launder vm_background_launder_target pages at
vm_background_launder_rate KB/s. Otherwise, the laundry thread goes back
to sleep without doing any work. When scanning the laundry queue during
background laundering, reactivated pages are counted towards the laundry
thread's target.
In contrast, shortfall laundering is requested when an inactive queue scan
fails to meet its target. In this case, the laundry thread attempts to
launder enough pages to meet v_free_target within 0.5s, which is the
inactive queue scan period.
A laundry request can be latched while another is currently being
serviced. In particular, a shortfall request will immediately preempt a
background laundering.
This change also redefines the meaning of vm_cnt.v_reactivated and removes
the functions vm_page_cache() and vm_page_try_to_cache(). The new meaning
of vm_cnt.v_reactivated now better reflects its name. It represents the
number of inactive or laundry pages that are returned to the active queue
on account of a reference.
In collaboration with: markj
Reviewed by: kib
Tested by: pho
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D8302
2016-11-09 18:48:37 +00:00
|
|
|
VM_STATS_VM(v_reactivated, "Pages reactivated by pagedaemon");
|
2011-12-14 13:25:00 +00:00
|
|
|
VM_STATS_VM(v_pdwakeups, "Pagedaemon wakeups");
|
Introduce a new page queue, PQ_LAUNDRY, for storing unreferenced, dirty
pages, specificially, dirty pages that have passed once through the inactive
queue. A new, dedicated thread is responsible for both deciding when to
launder pages and actually laundering them. The new policy uses the
relative sizes of the inactive and laundry queues to determine whether to
launder pages at a given point in time. In general, this leads to more
intelligent swapping behavior, since the laundry thread will avoid pageouts
when the marginal benefit of doing so is low. Previously, without a
dedicated queue for dirty pages, the page daemon didn't have the information
to determine whether pageout provides any benefit to the system. Thus, the
previous policy often resulted in small but steadily increasing amounts of
swap usage when the system is under memory pressure, even when the inactive
queue consisted mostly of clean pages. This change addresses that issue,
and also paves the way for some future virtual memory system improvements by
removing the last source of object-cached clean pages, i.e., PG_CACHE pages.
The new laundry thread sleeps while waiting for a request from the page
daemon thread(s). A request is raised by setting the variable
vm_laundry_request and waking the laundry thread. We request launderings
for two reasons: to try and balance the inactive and laundry queue sizes
("background laundering"), and to quickly make up for a shortage of free
pages and clean inactive pages ("shortfall laundering"). When background
laundering is requested, the laundry thread computes the number of page
daemon wakeups that have taken place since the last laundering. If this
number is large enough relative to the ratio of the laundry and (global)
inactive queue sizes, we will launder vm_background_launder_target pages at
vm_background_launder_rate KB/s. Otherwise, the laundry thread goes back
to sleep without doing any work. When scanning the laundry queue during
background laundering, reactivated pages are counted towards the laundry
thread's target.
In contrast, shortfall laundering is requested when an inactive queue scan
fails to meet its target. In this case, the laundry thread attempts to
launder enough pages to meet v_free_target within 0.5s, which is the
inactive queue scan period.
A laundry request can be latched while another is currently being
serviced. In particular, a shortfall request will immediately preempt a
background laundering.
This change also redefines the meaning of vm_cnt.v_reactivated and removes
the functions vm_page_cache() and vm_page_try_to_cache(). The new meaning
of vm_cnt.v_reactivated now better reflects its name. It represents the
number of inactive or laundry pages that are returned to the active queue
on account of a reference.
In collaboration with: markj
Reviewed by: kib
Tested by: pho
Sponsored by: Dell EMC Isilon
Differential Revision: https://reviews.freebsd.org/D8302
2016-11-09 18:48:37 +00:00
|
|
|
VM_STATS_VM(v_pdshortfalls, "Page reclamation shortfalls");
|
2011-12-14 13:25:00 +00:00
|
|
|
VM_STATS_VM(v_dfree, "Pages freed by pagedaemon");
|
|
|
|
|
VM_STATS_VM(v_pfree, "Pages freed by exiting processes");
|
|
|
|
|
VM_STATS_VM(v_tfree, "Total pages freed");
|
|
|
|
|
VM_STATS_VM(v_forks, "Number of fork() calls");
|
|
|
|
|
VM_STATS_VM(v_vforks, "Number of vfork() calls");
|
|
|
|
|
VM_STATS_VM(v_rforks, "Number of rfork() calls");
|
|
|
|
|
VM_STATS_VM(v_kthreads, "Number of fork() calls by kernel");
|
|
|
|
|
VM_STATS_VM(v_forkpages, "VM pages affected by fork()");
|
|
|
|
|
VM_STATS_VM(v_vforkpages, "VM pages affected by vfork()");
|
|
|
|
|
VM_STATS_VM(v_rforkpages, "VM pages affected by rfork()");
|
|
|
|
|
VM_STATS_VM(v_kthreadpages, "VM pages affected by fork() by kernel");
|
2016-12-06 22:52:45 +00:00
|
|
|
|
2018-02-06 22:10:07 +00:00
|
|
|
static int
|
|
|
|
|
sysctl_handle_vmstat_proc(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
|
|
|
|
u_int (*fn)(void);
|
|
|
|
|
uint32_t val;
|
|
|
|
|
|
|
|
|
|
fn = arg1;
|
|
|
|
|
val = fn();
|
|
|
|
|
return (SYSCTL_OUT(req, &val, sizeof(val)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define VM_STATS_PROC(var, descr, fn) \
|
|
|
|
|
SYSCTL_OID(_vm_stats_vm, OID_AUTO, var, CTLTYPE_U32 | CTLFLAG_MPSAFE | \
|
|
|
|
|
CTLFLAG_RD, fn, 0, sysctl_handle_vmstat_proc, "IU", descr)
|
|
|
|
|
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
#define VM_STATS_UINT(var, descr) \
|
|
|
|
|
SYSCTL_UINT(_vm_stats_vm, OID_AUTO, var, CTLFLAG_RD, &vm_cnt.var, 0, descr)
|
Provide separate accounting for user-wired pages.
Historically we have not distinguished between kernel wirings and user
wirings for accounting purposes. User wirings (via mlock(2)) were
subject to a global limit on the number of wired pages, so if large
swaths of physical memory were wired by the kernel, as happens with
the ZFS ARC among other things, the limit could be exceeded, causing
user wirings to fail.
The change adds a new counter, v_user_wire_count, which counts the
number of virtual pages wired by user processes via mlock(2) and
mlockall(2). Only user-wired pages are subject to the system-wide
limit which helps provide some safety against deadlocks. In
particular, while sources of kernel wirings typically support some
backpressure mechanism, there is no way to reclaim user-wired pages
shorting of killing the wiring process. The limit is exported as
vm.max_user_wired, renamed from vm.max_wired, and changed from u_int
to u_long.
The choice to count virtual user-wired pages rather than physical
pages was done for simplicity. There are mechanisms that can cause
user-wired mappings to be destroyed while maintaining a wiring of
the backing physical page; these make it difficult to accurately
track user wirings at the physical page layer.
The change also closes some holes which allowed user wirings to succeed
even when they would cause the system limit to be exceeded. For
instance, mmap() may now fail with ENOMEM in a process that has called
mlockall(MCL_FUTURE) if the new mapping would cause the user wiring
limit to be exceeded.
Note that bhyve -S is subject to the user wiring limit, which defaults
to 1/3 of physical RAM. Users that wish to exceed the limit must tune
vm.max_user_wired.
Reviewed by: kib, ngie (mlock() test changes)
Tested by: pho (earlier version)
MFC after: 45 days
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D19908
2019-05-13 16:38:48 +00:00
|
|
|
#define VM_STATS_ULONG(var, descr) \
|
|
|
|
|
SYSCTL_ULONG(_vm_stats_vm, OID_AUTO, var, CTLFLAG_RD, &vm_cnt.var, 0, descr)
|
2018-02-06 22:10:07 +00:00
|
|
|
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
VM_STATS_UINT(v_page_size, "Page size in bytes");
|
|
|
|
|
VM_STATS_UINT(v_page_count, "Total number of pages in system");
|
|
|
|
|
VM_STATS_UINT(v_free_reserved, "Pages reserved for deadlock");
|
|
|
|
|
VM_STATS_UINT(v_free_target, "Pages desired free");
|
|
|
|
|
VM_STATS_UINT(v_free_min, "Minimum low-free-pages threshold");
|
2018-02-06 22:10:07 +00:00
|
|
|
VM_STATS_PROC(v_free_count, "Free pages", vm_free_count);
|
2018-02-12 22:53:00 +00:00
|
|
|
VM_STATS_PROC(v_wire_count, "Wired pages", vm_wire_count);
|
2018-02-06 22:10:07 +00:00
|
|
|
VM_STATS_PROC(v_active_count, "Active pages", vm_active_count);
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
VM_STATS_UINT(v_inactive_target, "Desired inactive pages");
|
2018-02-06 22:10:07 +00:00
|
|
|
VM_STATS_PROC(v_inactive_count, "Inactive pages", vm_inactive_count);
|
|
|
|
|
VM_STATS_PROC(v_laundry_count, "Pages eligible for laundering",
|
|
|
|
|
vm_laundry_count);
|
- Remove 'struct vmmeter' from 'struct pcpu', leaving only global vmmeter
in place. To do per-cpu stats, convert all fields that previously were
maintained in the vmmeters that sit in pcpus to counter(9).
- Since some vmmeter stats may be touched at very early stages of boot,
before we have set up UMA and we can do counter_u64_alloc(), provide an
early counter mechanism:
o Leave one spare uint64_t in struct pcpu, named pc_early_dummy_counter.
o Point counter(9) fields of vmmeter to pcpu[0].pc_early_dummy_counter,
so that at early stages of boot, before counters are allocated we already
point to a counter that can be safely written to.
o For sparc64 that required a whole dummy pcpu[MAXCPU] array.
Further related changes:
- Don't include vmmeter.h into pcpu.h.
- vm.stats.vm.v_swappgsout and vm.stats.vm.v_swappgsin changed to 64-bit,
to match kernel representation.
- struct vmmeter hidden under _KERNEL, and only vmstat(1) is an exclusion.
This is based on benno@'s 4-year old patch:
https://lists.freebsd.org/pipermail/freebsd-arch/2013-July/014471.html
Reviewed by: kib, gallatin, marius, lidl
Differential Revision: https://reviews.freebsd.org/D10156
2017-04-17 17:34:47 +00:00
|
|
|
VM_STATS_UINT(v_pageout_free_min, "Min pages reserved for kernel");
|
|
|
|
|
VM_STATS_UINT(v_interrupt_free_min, "Reserved pages for interrupt code");
|
|
|
|
|
VM_STATS_UINT(v_free_severe, "Severe page depletion point");
|
|
|
|
|
|
Provide separate accounting for user-wired pages.
Historically we have not distinguished between kernel wirings and user
wirings for accounting purposes. User wirings (via mlock(2)) were
subject to a global limit on the number of wired pages, so if large
swaths of physical memory were wired by the kernel, as happens with
the ZFS ARC among other things, the limit could be exceeded, causing
user wirings to fail.
The change adds a new counter, v_user_wire_count, which counts the
number of virtual pages wired by user processes via mlock(2) and
mlockall(2). Only user-wired pages are subject to the system-wide
limit which helps provide some safety against deadlocks. In
particular, while sources of kernel wirings typically support some
backpressure mechanism, there is no way to reclaim user-wired pages
shorting of killing the wiring process. The limit is exported as
vm.max_user_wired, renamed from vm.max_wired, and changed from u_int
to u_long.
The choice to count virtual user-wired pages rather than physical
pages was done for simplicity. There are mechanisms that can cause
user-wired mappings to be destroyed while maintaining a wiring of
the backing physical page; these make it difficult to accurately
track user wirings at the physical page layer.
The change also closes some holes which allowed user wirings to succeed
even when they would cause the system limit to be exceeded. For
instance, mmap() may now fail with ENOMEM in a process that has called
mlockall(MCL_FUTURE) if the new mapping would cause the user wiring
limit to be exceeded.
Note that bhyve -S is subject to the user wiring limit, which defaults
to 1/3 of physical RAM. Users that wish to exceed the limit must tune
vm.max_user_wired.
Reviewed by: kib, ngie (mlock() test changes)
Tested by: pho (earlier version)
MFC after: 45 days
Sponsored by: Netflix
Differential Revision: https://reviews.freebsd.org/D19908
2019-05-13 16:38:48 +00:00
|
|
|
SYSCTL_ULONG(_vm_stats_vm, OID_AUTO, v_user_wire_count, CTLFLAG_RD,
|
|
|
|
|
&vm_user_wire_count, 0, "User-wired virtual memory");
|
|
|
|
|
|
2016-12-09 18:55:27 +00:00
|
|
|
#ifdef COMPAT_FREEBSD11
|
2016-12-06 22:52:45 +00:00
|
|
|
/*
|
|
|
|
|
* Provide compatibility sysctls for the benefit of old utilities which exit
|
|
|
|
|
* with an error if they cannot be found.
|
|
|
|
|
*/
|
|
|
|
|
SYSCTL_UINT(_vm_stats_vm, OID_AUTO, v_cache_count, CTLFLAG_RD,
|
2016-12-07 01:15:10 +00:00
|
|
|
SYSCTL_NULL_UINT_PTR, 0, "Dummy for compatibility");
|
2016-12-06 22:52:45 +00:00
|
|
|
SYSCTL_UINT(_vm_stats_vm, OID_AUTO, v_tcached, CTLFLAG_RD,
|
2016-12-07 01:15:10 +00:00
|
|
|
SYSCTL_NULL_UINT_PTR, 0, "Dummy for compatibility");
|
2016-12-06 22:52:45 +00:00
|
|
|
#endif
|
2018-02-06 22:10:07 +00:00
|
|
|
|
|
|
|
|
u_int
|
|
|
|
|
vm_free_count(void)
|
|
|
|
|
{
|
|
|
|
|
u_int v;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
v = 0;
|
|
|
|
|
for (i = 0; i < vm_ndomains; i++)
|
|
|
|
|
v += vm_dom[i].vmd_free_count;
|
|
|
|
|
|
|
|
|
|
return (v);
|
|
|
|
|
}
|
|
|
|
|
|
2018-08-23 21:03:45 +00:00
|
|
|
static u_int
|
2018-02-06 22:10:07 +00:00
|
|
|
vm_pagequeue_count(int pq)
|
|
|
|
|
{
|
|
|
|
|
u_int v;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
v = 0;
|
|
|
|
|
for (i = 0; i < vm_ndomains; i++)
|
|
|
|
|
v += vm_dom[i].vmd_pagequeues[pq].pq_cnt;
|
|
|
|
|
|
|
|
|
|
return (v);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u_int
|
|
|
|
|
vm_active_count(void)
|
|
|
|
|
{
|
|
|
|
|
|
2018-08-23 21:03:45 +00:00
|
|
|
return (vm_pagequeue_count(PQ_ACTIVE));
|
2018-02-06 22:10:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u_int
|
|
|
|
|
vm_inactive_count(void)
|
|
|
|
|
{
|
|
|
|
|
|
2018-08-23 21:03:45 +00:00
|
|
|
return (vm_pagequeue_count(PQ_INACTIVE));
|
2018-02-06 22:10:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
u_int
|
|
|
|
|
vm_laundry_count(void)
|
|
|
|
|
{
|
|
|
|
|
|
2018-08-23 21:03:45 +00:00
|
|
|
return (vm_pagequeue_count(PQ_LAUNDRY));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
sysctl_vm_pdpages(SYSCTL_HANDLER_ARGS)
|
|
|
|
|
{
|
|
|
|
|
struct vm_pagequeue *pq;
|
|
|
|
|
uint64_t ret;
|
|
|
|
|
int dom, i;
|
|
|
|
|
|
|
|
|
|
ret = counter_u64_fetch(vm_cnt.v_pdpages);
|
|
|
|
|
for (dom = 0; dom < vm_ndomains; dom++)
|
|
|
|
|
for (i = 0; i < PQ_COUNT; i++) {
|
|
|
|
|
pq = &VM_DOMAIN(dom)->vmd_pagequeues[i];
|
|
|
|
|
ret += pq->pq_pdpages;
|
|
|
|
|
}
|
|
|
|
|
return (SYSCTL_OUT(req, &ret, sizeof(ret)));
|
2018-02-06 22:10:07 +00:00
|
|
|
}
|
2018-08-23 21:03:45 +00:00
|
|
|
SYSCTL_PROC(_vm_stats_vm, OID_AUTO, v_pdpages,
|
|
|
|
|
CTLTYPE_U64 | CTLFLAG_MPSAFE | CTLFLAG_RD, NULL, 0, sysctl_vm_pdpages, "QU",
|
|
|
|
|
"Pages analyzed by pagedaemon");
|
2018-02-06 22:10:07 +00:00
|
|
|
|
2018-02-23 22:51:51 +00:00
|
|
|
static void
|
|
|
|
|
vm_domain_stats_init(struct vm_domain *vmd, struct sysctl_oid *parent)
|
|
|
|
|
{
|
|
|
|
|
struct sysctl_oid *oid;
|
|
|
|
|
|
|
|
|
|
vmd->vmd_oid = SYSCTL_ADD_NODE(NULL, SYSCTL_CHILDREN(parent), OID_AUTO,
|
2020-02-26 14:26:36 +00:00
|
|
|
vmd->vmd_name, CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
|
2018-02-23 22:51:51 +00:00
|
|
|
oid = SYSCTL_ADD_NODE(NULL, SYSCTL_CHILDREN(vmd->vmd_oid), OID_AUTO,
|
2020-02-26 14:26:36 +00:00
|
|
|
"stats", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
|
2018-02-23 22:51:51 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"free_count", CTLFLAG_RD, &vmd->vmd_free_count, 0,
|
|
|
|
|
"Free pages");
|
|
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"active", CTLFLAG_RD, &vmd->vmd_pagequeues[PQ_ACTIVE].pq_cnt, 0,
|
|
|
|
|
"Active pages");
|
2018-08-23 21:03:45 +00:00
|
|
|
SYSCTL_ADD_U64(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"actpdpgs", CTLFLAG_RD,
|
|
|
|
|
&vmd->vmd_pagequeues[PQ_ACTIVE].pq_pdpages, 0,
|
|
|
|
|
"Active pages scanned by the page daemon");
|
2018-02-23 22:51:51 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"inactive", CTLFLAG_RD, &vmd->vmd_pagequeues[PQ_INACTIVE].pq_cnt, 0,
|
|
|
|
|
"Inactive pages");
|
2018-08-23 21:03:45 +00:00
|
|
|
SYSCTL_ADD_U64(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"inactpdpgs", CTLFLAG_RD,
|
|
|
|
|
&vmd->vmd_pagequeues[PQ_INACTIVE].pq_pdpages, 0,
|
|
|
|
|
"Inactive pages scanned by the page daemon");
|
2018-02-23 22:51:51 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"laundry", CTLFLAG_RD, &vmd->vmd_pagequeues[PQ_LAUNDRY].pq_cnt, 0,
|
|
|
|
|
"laundry pages");
|
2018-08-23 21:03:45 +00:00
|
|
|
SYSCTL_ADD_U64(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"laundpdpgs", CTLFLAG_RD,
|
|
|
|
|
&vmd->vmd_pagequeues[PQ_LAUNDRY].pq_pdpages, 0,
|
|
|
|
|
"Laundry pages scanned by the page daemon");
|
2018-02-23 22:51:51 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO, "unswappable",
|
|
|
|
|
CTLFLAG_RD, &vmd->vmd_pagequeues[PQ_UNSWAPPABLE].pq_cnt, 0,
|
|
|
|
|
"Unswappable pages");
|
2018-08-23 21:03:45 +00:00
|
|
|
SYSCTL_ADD_U64(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"unswppdpgs", CTLFLAG_RD,
|
|
|
|
|
&vmd->vmd_pagequeues[PQ_UNSWAPPABLE].pq_pdpages, 0,
|
|
|
|
|
"Unswappable pages scanned by the page daemon");
|
2018-02-23 22:51:51 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"inactive_target", CTLFLAG_RD, &vmd->vmd_inactive_target, 0,
|
|
|
|
|
"Target inactive pages");
|
|
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"free_target", CTLFLAG_RD, &vmd->vmd_free_target, 0,
|
|
|
|
|
"Target free pages");
|
|
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"free_reserved", CTLFLAG_RD, &vmd->vmd_free_reserved, 0,
|
|
|
|
|
"Reserved free pages");
|
|
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"free_min", CTLFLAG_RD, &vmd->vmd_free_min, 0,
|
|
|
|
|
"Minimum free pages");
|
|
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"free_severe", CTLFLAG_RD, &vmd->vmd_free_severe, 0,
|
|
|
|
|
"Severe free pages");
|
2020-08-11 20:37:45 +00:00
|
|
|
SYSCTL_ADD_UINT(NULL, SYSCTL_CHILDREN(oid), OID_AUTO,
|
|
|
|
|
"inactive_pps", CTLFLAG_RD, &vmd->vmd_inactive_pps, 0,
|
|
|
|
|
"inactive pages freed/second");
|
2018-02-23 22:51:51 +00:00
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
vm_stats_init(void *arg __unused)
|
|
|
|
|
{
|
|
|
|
|
struct sysctl_oid *oid;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
oid = SYSCTL_ADD_NODE(NULL, SYSCTL_STATIC_CHILDREN(_vm), OID_AUTO,
|
2020-02-26 14:26:36 +00:00
|
|
|
"domain", CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
|
2018-02-23 22:51:51 +00:00
|
|
|
for (i = 0; i < vm_ndomains; i++)
|
|
|
|
|
vm_domain_stats_init(VM_DOMAIN(i), oid);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
SYSINIT(vmstats_init, SI_SUB_VM_CONF, SI_ORDER_FIRST, vm_stats_init, NULL);
|
