Go to the source code of this file.
Data Structures | |
| union | vm_page_astate |
| struct | vm_page |
Macros | |
| #define | VPRC_BLOCKED 0x40000000u /* mappings are being removed */ |
| #define | VPRC_OBJREF 0x80000000u /* object reference, cleared with (O) */ |
| #define | VPRC_WIRE_COUNT(c) ((c) & ~(VPRC_BLOCKED | VPRC_OBJREF)) |
| #define | VPRC_WIRE_COUNT_MAX (~(VPRC_BLOCKED | VPRC_OBJREF)) |
| #define | VPO_KMEM_EXEC 0x01 /* kmem mapping allows execution */ |
| #define | VPO_SWAPSLEEP 0x02 /* waiting for swap to finish */ |
| #define | VPO_UNMANAGED 0x04 /* no PV management for page */ |
| #define | VPO_SWAPINPROG 0x08 /* swap I/O in progress on page */ |
| #define | VPB_BIT_SHARED 0x01 |
| #define | VPB_BIT_EXCLUSIVE 0x02 |
| #define | VPB_BIT_WAITERS 0x04 |
| #define | VPB_BIT_FLAGMASK (VPB_BIT_SHARED | VPB_BIT_EXCLUSIVE | VPB_BIT_WAITERS) |
| #define | VPB_SHARERS_SHIFT 3 |
| #define | VPB_SHARERS(x) (((x) & ~VPB_BIT_FLAGMASK) >> VPB_SHARERS_SHIFT) |
| #define | VPB_SHARERS_WORD(x) ((x) << VPB_SHARERS_SHIFT | VPB_BIT_SHARED) |
| #define | VPB_ONE_SHARER (1 << VPB_SHARERS_SHIFT) |
| #define | VPB_SINGLE_EXCLUSIVE VPB_BIT_EXCLUSIVE |
| #define | VPB_CURTHREAD_EXCLUSIVE VPB_SINGLE_EXCLUSIVE |
| #define | VPB_UNBUSIED VPB_SHARERS_WORD(0) |
| #define | VPB_FREED (0xffffffff - VPB_BIT_SHARED) |
| #define | PQ_NONE 255 |
| #define | PQ_INACTIVE 0 |
| #define | PQ_ACTIVE 1 |
| #define | PQ_LAUNDRY 2 |
| #define | PQ_UNSWAPPABLE 3 |
| #define | PQ_COUNT 4 |
| #define | VM_PAGE_HAVE_PGLIST |
| #define | PDRSHIFT 21 |
| #define | pa_index(pa) ((pa) >> PDRSHIFT) |
| #define | PA_LOCKPTR(pa) ((struct mtx *)(&pa_lock[pa_index(pa) % PA_LOCK_COUNT])) |
| #define | PA_LOCKOBJPTR(pa) ((struct lock_object *)PA_LOCKPTR((pa))) |
| #define | PA_LOCK(pa) mtx_lock(PA_LOCKPTR(pa)) |
| #define | PA_TRYLOCK(pa) mtx_trylock(PA_LOCKPTR(pa)) |
| #define | PA_UNLOCK(pa) mtx_unlock(PA_LOCKPTR(pa)) |
| #define | PA_UNLOCK_COND(pa) |
| #define | PA_LOCK_ASSERT(pa, a) mtx_assert(PA_LOCKPTR(pa), (a)) |
| #define | vm_page_lockptr(m) (PA_LOCKPTR(VM_PAGE_TO_PHYS((m)))) |
| #define | vm_page_lock(m) mtx_lock(vm_page_lockptr((m))) |
| #define | vm_page_unlock(m) mtx_unlock(vm_page_lockptr((m))) |
| #define | vm_page_trylock(m) mtx_trylock(vm_page_lockptr((m))) |
| #define | vm_page_assert_locked(m) |
| #define | vm_page_lock_assert(m, a) |
| #define | PGA_WRITEABLE 0x0001 /* page may be mapped writeable */ |
| #define | PGA_REFERENCED 0x0002 /* page has been referenced */ |
| #define | PGA_EXECUTABLE 0x0004 /* page may be mapped executable */ |
| #define | PGA_ENQUEUED 0x0008 /* page is enqueued in a page queue */ |
| #define | PGA_DEQUEUE 0x0010 /* page is due to be dequeued */ |
| #define | PGA_REQUEUE 0x0020 /* page is due to be requeued */ |
| #define | PGA_REQUEUE_HEAD 0x0040 /* page requeue should bypass LRU */ |
| #define | PGA_NOSYNC 0x0080 /* do not collect for syncer */ |
| #define | PGA_SWAP_FREE 0x0100 /* page with swap space was dirtied */ |
| #define | PGA_SWAP_SPACE 0x0200 /* page has allocated swap space */ |
| #define | PGA_QUEUE_OP_MASK (PGA_DEQUEUE | PGA_REQUEUE | PGA_REQUEUE_HEAD) |
| #define | PGA_QUEUE_STATE_MASK (PGA_ENQUEUED | PGA_QUEUE_OP_MASK) |
| #define | PG_PCPU_CACHE 0x01 /* was allocated from per-CPU caches */ |
| #define | PG_FICTITIOUS 0x02 /* physical page doesn't exist */ |
| #define | PG_ZERO 0x04 /* page is zeroed */ |
| #define | PG_MARKER 0x08 /* special queue marker page */ |
| #define | PG_NODUMP 0x10 /* don't include this page in a dump */ |
| #define | ACT_DECLINE 1 |
| #define | ACT_ADVANCE 3 |
| #define | ACT_INIT 5 |
| #define | ACT_MAX 64 |
| #define | VM_PAGE_TO_PHYS(entry) ((entry)->phys_addr) |
| #define | VM_ALLOC_NORMAL 0 |
| #define | VM_ALLOC_INTERRUPT 1 |
| #define | VM_ALLOC_SYSTEM 2 |
| #define | VM_ALLOC_CLASS_MASK 3 |
| #define | VM_ALLOC_WAITOK 0x0008 /* (acn) Sleep and retry */ |
| #define | VM_ALLOC_WAITFAIL 0x0010 /* (acn) Sleep and return error */ |
| #define | VM_ALLOC_WIRED 0x0020 /* (acgnp) Allocate a wired page */ |
| #define | VM_ALLOC_ZERO 0x0040 /* (acgnp) Allocate a zeroed page */ |
| #define | VM_ALLOC_NORECLAIM 0x0080 /* (c) Do not reclaim after failure */ |
| #define | VM_ALLOC_AVAIL0 0x0100 |
| #define | VM_ALLOC_NOBUSY 0x0200 /* (acgp) Do not excl busy the page */ |
| #define | VM_ALLOC_NOCREAT 0x0400 /* (gp) Don't create a page */ |
| #define | VM_ALLOC_AVAIL1 0x0800 |
| #define | VM_ALLOC_IGN_SBUSY 0x1000 /* (gp) Ignore shared busy flag */ |
| #define | VM_ALLOC_NODUMP 0x2000 /* (ag) don't include in dump */ |
| #define | VM_ALLOC_SBUSY 0x4000 /* (acgp) Shared busy the page */ |
| #define | VM_ALLOC_NOWAIT 0x8000 /* (acgnp) Do not sleep */ |
| #define | VM_ALLOC_COUNT_MAX 0xffff |
| #define | VM_ALLOC_COUNT_SHIFT 16 |
| #define | VM_ALLOC_COUNT_MASK (VM_ALLOC_COUNT(VM_ALLOC_COUNT_MAX)) |
| #define | VM_ALLOC_COUNT(count) |
| #define | PS_ALL_DIRTY 0x1 |
| #define | PS_ALL_VALID 0x2 |
| #define | PS_NONE_BUSY 0x4 |
| #define | VPR_TRYFREE 0x01 |
| #define | VPR_NOREUSE 0x02 |
| #define | vm_page_busy_fetch(m) atomic_load_int(&(m)->busy_lock) |
| #define | vm_page_assert_busied(m) |
| #define | vm_page_assert_sbusied(m) |
| #define | vm_page_assert_unbusied(m) |
| #define | vm_page_assert_xbusied_unchecked(m) |
| #define | vm_page_assert_xbusied(m) |
| #define | vm_page_busied(m) (vm_page_busy_fetch(m) != VPB_UNBUSIED) |
| #define | vm_page_xbusied(m) ((vm_page_busy_fetch(m) & VPB_SINGLE_EXCLUSIVE) != 0) |
| #define | vm_page_busy_freed(m) (vm_page_busy_fetch(m) == VPB_FREED) |
| #define | vm_page_xunbusy(m) |
| #define | vm_page_xunbusy_unchecked(m) |
| #define | VM_PAGE_OBJECT_BUSY_ASSERT(m) (void)0 |
| #define | VM_PAGE_ASSERT_PGA_WRITEABLE(m, bits) (void)0 |
| #define | vm_page_xbusy_claim(m) |
| #define | VM_PAGE_AFLAG_SHIFT 16 |
Typedefs | |
| typedef union vm_page_astate | vm_page_astate_t |
Functions | |
| TAILQ_HEAD (pglist, vm_page) | |
| SLIST_HEAD (spglist, vm_page) | |
| vm_page_t | PHYS_TO_VM_PAGE (vm_paddr_t pa) |
| bool | vm_page_busy_acquire (vm_page_t m, int allocflags) |
| void | vm_page_busy_downgrade (vm_page_t m) |
| int | vm_page_busy_tryupgrade (vm_page_t m) |
| bool | vm_page_busy_sleep (vm_page_t m, const char *msg, int allocflags) |
| void | vm_page_busy_sleep_unlocked (vm_object_t obj, vm_page_t m, vm_pindex_t pindex, const char *wmesg, int allocflags) |
| void | vm_page_free (vm_page_t m) |
| void | vm_page_free_zero (vm_page_t m) |
| void | vm_page_activate (vm_page_t) |
| void | vm_page_advise (vm_page_t m, int advice) |
| vm_page_t | vm_page_alloc (vm_object_t, vm_pindex_t, int) |
| vm_page_t | vm_page_alloc_domain (vm_object_t, vm_pindex_t, int, int) |
| vm_page_t | vm_page_alloc_after (vm_object_t, vm_pindex_t, int, vm_page_t) |
| vm_page_t | vm_page_alloc_domain_after (vm_object_t, vm_pindex_t, int, int, vm_page_t) |
| vm_page_t | vm_page_alloc_contig (vm_object_t object, vm_pindex_t pindex, int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary, vm_memattr_t memattr) |
| vm_page_t | vm_page_alloc_contig_domain (vm_object_t object, vm_pindex_t pindex, int domain, int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary, vm_memattr_t memattr) |
| vm_page_t | vm_page_alloc_freelist (int, int) |
| vm_page_t | vm_page_alloc_freelist_domain (int, int, int) |
| vm_page_t | vm_page_alloc_noobj (int) |
| vm_page_t | vm_page_alloc_noobj_domain (int, int) |
| vm_page_t | vm_page_alloc_noobj_contig (int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary, vm_memattr_t memattr) |
| vm_page_t | vm_page_alloc_noobj_contig_domain (int domain, int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary, vm_memattr_t memattr) |
| void | vm_page_bits_set (vm_page_t m, vm_page_bits_t *bits, vm_page_bits_t set) |
| bool | vm_page_blacklist_add (vm_paddr_t pa, bool verbose) |
| vm_page_t | vm_page_grab (vm_object_t, vm_pindex_t, int) |
| vm_page_t | vm_page_grab_unlocked (vm_object_t, vm_pindex_t, int) |
| int | vm_page_grab_pages (vm_object_t object, vm_pindex_t pindex, int allocflags, vm_page_t *ma, int count) |
| int | vm_page_grab_pages_unlocked (vm_object_t object, vm_pindex_t pindex, int allocflags, vm_page_t *ma, int count) |
| int | vm_page_grab_valid (vm_page_t *mp, vm_object_t object, vm_pindex_t pindex, int allocflags) |
| int | vm_page_grab_valid_unlocked (vm_page_t *mp, vm_object_t object, vm_pindex_t pindex, int allocflags) |
| void | vm_page_deactivate (vm_page_t) |
| void | vm_page_deactivate_noreuse (vm_page_t) |
| void | vm_page_dequeue (vm_page_t m) |
| void | vm_page_dequeue_deferred (vm_page_t m) |
| vm_page_t | vm_page_find_least (vm_object_t, vm_pindex_t) |
| void | vm_page_free_invalid (vm_page_t) |
| vm_page_t | vm_page_getfake (vm_paddr_t paddr, vm_memattr_t memattr) |
| void | vm_page_initfake (vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr) |
| void | vm_page_init_marker (vm_page_t marker, int queue, uint16_t aflags) |
| void | vm_page_init_page (vm_page_t m, vm_paddr_t pa, int segind) |
| int | vm_page_insert (vm_page_t, vm_object_t, vm_pindex_t) |
| void | vm_page_invalid (vm_page_t m) |
| void | vm_page_launder (vm_page_t m) |
| vm_page_t | vm_page_lookup (vm_object_t, vm_pindex_t) |
| vm_page_t | vm_page_lookup_unlocked (vm_object_t, vm_pindex_t) |
| vm_page_t | vm_page_next (vm_page_t m) |
| void | vm_page_pqbatch_drain (void) |
| void | vm_page_pqbatch_submit (vm_page_t m, uint8_t queue) |
| bool | vm_page_pqstate_commit (vm_page_t m, vm_page_astate_t *old, vm_page_astate_t new) |
| vm_page_t | vm_page_prev (vm_page_t m) |
| bool | vm_page_ps_test (vm_page_t m, int flags, vm_page_t skip_m) |
| void | vm_page_putfake (vm_page_t m) |
| void | vm_page_readahead_finish (vm_page_t m) |
| bool | vm_page_reclaim_contig (int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) |
| bool | vm_page_reclaim_contig_domain (int domain, int req, u_long npages, vm_paddr_t low, vm_paddr_t high, u_long alignment, vm_paddr_t boundary) |
| void | vm_page_reference (vm_page_t m) |
| void | vm_page_release (vm_page_t m, int flags) |
| void | vm_page_release_locked (vm_page_t m, int flags) |
| vm_page_t | vm_page_relookup (vm_object_t, vm_pindex_t) |
| bool | vm_page_remove (vm_page_t) |
| bool | vm_page_remove_xbusy (vm_page_t) |
| int | vm_page_rename (vm_page_t, vm_object_t, vm_pindex_t) |
| void | vm_page_replace (vm_page_t mnew, vm_object_t object, vm_pindex_t pindex, vm_page_t mold) |
| int | vm_page_sbusied (vm_page_t m) |
| vm_page_t | vm_page_scan_contig (u_long npages, vm_page_t m_start, vm_page_t m_end, u_long alignment, vm_paddr_t boundary, int options) |
| vm_page_bits_t | vm_page_set_dirty (vm_page_t m) |
| void | vm_page_set_valid_range (vm_page_t m, int base, int size) |
| vm_offset_t | vm_page_startup (vm_offset_t vaddr) |
| void | vm_page_sunbusy (vm_page_t m) |
| bool | vm_page_try_remove_all (vm_page_t m) |
| bool | vm_page_try_remove_write (vm_page_t m) |
| int | vm_page_trysbusy (vm_page_t m) |
| int | vm_page_tryxbusy (vm_page_t m) |
| void | vm_page_unhold_pages (vm_page_t *ma, int count) |
| void | vm_page_unswappable (vm_page_t m) |
| void | vm_page_unwire (vm_page_t m, uint8_t queue) |
| bool | vm_page_unwire_noq (vm_page_t m) |
| void | vm_page_updatefake (vm_page_t m, vm_paddr_t paddr, vm_memattr_t memattr) |
| void | vm_page_wire (vm_page_t) |
| bool | vm_page_wire_mapped (vm_page_t m) |
| void | vm_page_xunbusy_hard (vm_page_t m) |
| void | vm_page_xunbusy_hard_unchecked (vm_page_t m) |
| void | vm_page_set_validclean (vm_page_t, int, int) |
| void | vm_page_clear_dirty (vm_page_t, int, int) |
| void | vm_page_set_invalid (vm_page_t, int, int) |
| void | vm_page_valid (vm_page_t m) |
| int | vm_page_is_valid (vm_page_t, int, int) |
| void | vm_page_test_dirty (vm_page_t) |
| vm_page_bits_t | vm_page_bits (int base, int size) |
| void | vm_page_zero_invalid (vm_page_t m, boolean_t setvalid) |
| void | vm_page_free_pages_toq (struct spglist *free, bool update_wire_count) |
| void | vm_page_dirty_KBI (vm_page_t m) |
| void | vm_page_lock_KBI (vm_page_t m, const char *file, int line) |
| void | vm_page_unlock_KBI (vm_page_t m, const char *file, int line) |
| int | vm_page_trylock_KBI (vm_page_t m, const char *file, int line) |
| static vm_page_astate_t | vm_page_astate_load (vm_page_t m) |
| static bool | vm_page_astate_fcmpset (vm_page_t m, vm_page_astate_t *old, vm_page_astate_t new) |
| static void | vm_page_aflag_clear (vm_page_t m, uint16_t bits) |
| static void | vm_page_aflag_set (vm_page_t m, uint16_t bits) |
| static __inline void | vm_page_dirty (vm_page_t m) |
| static __inline void | vm_page_undirty (vm_page_t m) |
| static uint8_t | _vm_page_queue (vm_page_astate_t as) |
| static uint8_t | vm_page_queue (vm_page_t m) |
| static bool | vm_page_active (vm_page_t m) |
| static bool | vm_page_inactive (vm_page_t m) |
| static bool | vm_page_in_laundry (vm_page_t m) |
| static u_int | vm_page_drop (vm_page_t m, u_int val) |
| static bool | vm_page_wired (vm_page_t m) |
| static bool | vm_page_all_valid (vm_page_t m) |
| static bool | vm_page_none_valid (vm_page_t m) |
| static int | vm_page_domain (vm_page_t m) |
Variables | |
| vm_page_t | bogus_page |
| struct mtx_padalign | pa_lock [] |
| vm_page_t | vm_page_array |
| long | vm_page_array_size |
| long | first_page |
Macro Definition Documentation
◆ ACT_ADVANCE
◆ ACT_DECLINE
◆ ACT_INIT
◆ ACT_MAX
◆ pa_index
◆ PA_LOCK
| #define PA_LOCK | ( | pa | ) | mtx_lock(PA_LOCKPTR(pa)) |
◆ PA_LOCK_ASSERT
| #define PA_LOCK_ASSERT | ( | pa, | |
| a | |||
| ) | mtx_assert(PA_LOCKPTR(pa), (a)) |
◆ PA_LOCKOBJPTR
| #define PA_LOCKOBJPTR | ( | pa | ) | ((struct lock_object *)PA_LOCKPTR((pa))) |
◆ PA_LOCKPTR
| #define PA_LOCKPTR | ( | pa | ) | ((struct mtx *)(&pa_lock[pa_index(pa) % PA_LOCK_COUNT])) |
◆ PA_TRYLOCK
| #define PA_TRYLOCK | ( | pa | ) | mtx_trylock(PA_LOCKPTR(pa)) |
◆ PA_UNLOCK
| #define PA_UNLOCK | ( | pa | ) | mtx_unlock(PA_LOCKPTR(pa)) |
◆ PA_UNLOCK_COND
| #define PA_UNLOCK_COND | ( | pa | ) |
◆ PDRSHIFT
◆ PG_FICTITIOUS
| #define PG_FICTITIOUS 0x02 /* physical page doesn't exist */ |
◆ PG_MARKER
◆ PG_NODUMP
| #define PG_NODUMP 0x10 /* don't include this page in a dump */ |
◆ PG_PCPU_CACHE
| #define PG_PCPU_CACHE 0x01 /* was allocated from per-CPU caches */ |
◆ PG_ZERO
◆ PGA_DEQUEUE
| #define PGA_DEQUEUE 0x0010 /* page is due to be dequeued */ |
◆ PGA_ENQUEUED
| #define PGA_ENQUEUED 0x0008 /* page is enqueued in a page queue */ |
◆ PGA_EXECUTABLE
| #define PGA_EXECUTABLE 0x0004 /* page may be mapped executable */ |
◆ PGA_NOSYNC
◆ PGA_QUEUE_OP_MASK
| #define PGA_QUEUE_OP_MASK (PGA_DEQUEUE | PGA_REQUEUE | PGA_REQUEUE_HEAD) |
◆ PGA_QUEUE_STATE_MASK
| #define PGA_QUEUE_STATE_MASK (PGA_ENQUEUED | PGA_QUEUE_OP_MASK) |
◆ PGA_REFERENCED
| #define PGA_REFERENCED 0x0002 /* page has been referenced */ |
◆ PGA_REQUEUE
| #define PGA_REQUEUE 0x0020 /* page is due to be requeued */ |
◆ PGA_REQUEUE_HEAD
| #define PGA_REQUEUE_HEAD 0x0040 /* page requeue should bypass LRU */ |
◆ PGA_SWAP_FREE
| #define PGA_SWAP_FREE 0x0100 /* page with swap space was dirtied */ |
◆ PGA_SWAP_SPACE
| #define PGA_SWAP_SPACE 0x0200 /* page has allocated swap space */ |
◆ PGA_WRITEABLE
| #define PGA_WRITEABLE 0x0001 /* page may be mapped writeable */ |
◆ PQ_ACTIVE
◆ PQ_COUNT
◆ PQ_INACTIVE
◆ PQ_LAUNDRY
◆ PQ_NONE
◆ PQ_UNSWAPPABLE
◆ PS_ALL_DIRTY
◆ PS_ALL_VALID
◆ PS_NONE_BUSY
◆ VM_ALLOC_AVAIL0
◆ VM_ALLOC_AVAIL1
◆ VM_ALLOC_CLASS_MASK
◆ VM_ALLOC_COUNT
| #define VM_ALLOC_COUNT | ( | count | ) |
◆ VM_ALLOC_COUNT_MASK
| #define VM_ALLOC_COUNT_MASK (VM_ALLOC_COUNT(VM_ALLOC_COUNT_MAX)) |
◆ VM_ALLOC_COUNT_MAX
◆ VM_ALLOC_COUNT_SHIFT
◆ VM_ALLOC_IGN_SBUSY
| #define VM_ALLOC_IGN_SBUSY 0x1000 /* (gp) Ignore shared busy flag */ |
◆ VM_ALLOC_INTERRUPT
◆ VM_ALLOC_NOBUSY
| #define VM_ALLOC_NOBUSY 0x0200 /* (acgp) Do not excl busy the page */ |
◆ VM_ALLOC_NOCREAT
| #define VM_ALLOC_NOCREAT 0x0400 /* (gp) Don't create a page */ |
◆ VM_ALLOC_NODUMP
| #define VM_ALLOC_NODUMP 0x2000 /* (ag) don't include in dump */ |
◆ VM_ALLOC_NORECLAIM
| #define VM_ALLOC_NORECLAIM 0x0080 /* (c) Do not reclaim after failure */ |
◆ VM_ALLOC_NORMAL
◆ VM_ALLOC_NOWAIT
◆ VM_ALLOC_SBUSY
| #define VM_ALLOC_SBUSY 0x4000 /* (acgp) Shared busy the page */ |
◆ VM_ALLOC_SYSTEM
◆ VM_ALLOC_WAITFAIL
| #define VM_ALLOC_WAITFAIL 0x0010 /* (acn) Sleep and return error */ |
◆ VM_ALLOC_WAITOK
| #define VM_ALLOC_WAITOK 0x0008 /* (acn) Sleep and retry */ |
◆ VM_ALLOC_WIRED
| #define VM_ALLOC_WIRED 0x0020 /* (acgnp) Allocate a wired page */ |
◆ VM_ALLOC_ZERO
| #define VM_ALLOC_ZERO 0x0040 /* (acgnp) Allocate a zeroed page */ |
◆ VM_PAGE_AFLAG_SHIFT
◆ vm_page_assert_busied
| #define vm_page_assert_busied | ( | m | ) |
◆ vm_page_assert_locked
◆ VM_PAGE_ASSERT_PGA_WRITEABLE
◆ vm_page_assert_sbusied
| #define vm_page_assert_sbusied | ( | m | ) |
◆ vm_page_assert_unbusied
| #define vm_page_assert_unbusied | ( | m | ) |
◆ vm_page_assert_xbusied
| #define vm_page_assert_xbusied | ( | m | ) |
◆ vm_page_assert_xbusied_unchecked
| #define vm_page_assert_xbusied_unchecked | ( | m | ) |
◆ vm_page_busied
| #define vm_page_busied | ( | m | ) | (vm_page_busy_fetch(m) != VPB_UNBUSIED) |
◆ vm_page_busy_fetch
| #define vm_page_busy_fetch | ( | m | ) | atomic_load_int(&(m)->busy_lock) |
◆ vm_page_busy_freed
| #define vm_page_busy_freed | ( | m | ) | (vm_page_busy_fetch(m) == VPB_FREED) |
◆ VM_PAGE_HAVE_PGLIST
◆ vm_page_lock
| #define vm_page_lock | ( | m | ) | mtx_lock(vm_page_lockptr((m))) |
◆ vm_page_lock_assert
◆ vm_page_lockptr
| #define vm_page_lockptr | ( | m | ) | (PA_LOCKPTR(VM_PAGE_TO_PHYS((m)))) |
◆ VM_PAGE_OBJECT_BUSY_ASSERT
◆ VM_PAGE_TO_PHYS
◆ vm_page_trylock
| #define vm_page_trylock | ( | m | ) | mtx_trylock(vm_page_lockptr((m))) |
◆ vm_page_unlock
| #define vm_page_unlock | ( | m | ) | mtx_unlock(vm_page_lockptr((m))) |
◆ vm_page_xbusied
| #define vm_page_xbusied | ( | m | ) | ((vm_page_busy_fetch(m) & VPB_SINGLE_EXCLUSIVE) != 0) |
◆ vm_page_xbusy_claim
◆ vm_page_xunbusy
| #define vm_page_xunbusy | ( | m | ) |
◆ vm_page_xunbusy_unchecked
| #define vm_page_xunbusy_unchecked | ( | m | ) |
◆ VPB_BIT_EXCLUSIVE
◆ VPB_BIT_FLAGMASK
| #define VPB_BIT_FLAGMASK (VPB_BIT_SHARED | VPB_BIT_EXCLUSIVE | VPB_BIT_WAITERS) |
◆ VPB_BIT_SHARED
◆ VPB_BIT_WAITERS
◆ VPB_CURTHREAD_EXCLUSIVE
| #define VPB_CURTHREAD_EXCLUSIVE VPB_SINGLE_EXCLUSIVE |
◆ VPB_FREED
| #define VPB_FREED (0xffffffff - VPB_BIT_SHARED) |
◆ VPB_ONE_SHARER
| #define VPB_ONE_SHARER (1 << VPB_SHARERS_SHIFT) |
◆ VPB_SHARERS
| #define VPB_SHARERS | ( | x | ) | (((x) & ~VPB_BIT_FLAGMASK) >> VPB_SHARERS_SHIFT) |
◆ VPB_SHARERS_SHIFT
◆ VPB_SHARERS_WORD
| #define VPB_SHARERS_WORD | ( | x | ) | ((x) << VPB_SHARERS_SHIFT | VPB_BIT_SHARED) |
◆ VPB_SINGLE_EXCLUSIVE
| #define VPB_SINGLE_EXCLUSIVE VPB_BIT_EXCLUSIVE |
◆ VPB_UNBUSIED
| #define VPB_UNBUSIED VPB_SHARERS_WORD(0) |
◆ VPO_KMEM_EXEC
| #define VPO_KMEM_EXEC 0x01 /* kmem mapping allows execution */ |
◆ VPO_SWAPINPROG
| #define VPO_SWAPINPROG 0x08 /* swap I/O in progress on page */ |
◆ VPO_SWAPSLEEP
| #define VPO_SWAPSLEEP 0x02 /* waiting for swap to finish */ |
◆ VPO_UNMANAGED
| #define VPO_UNMANAGED 0x04 /* no PV management for page */ |
◆ VPR_NOREUSE
◆ VPR_TRYFREE
◆ VPRC_BLOCKED
| #define VPRC_BLOCKED 0x40000000u /* mappings are being removed */ |
◆ VPRC_OBJREF
| #define VPRC_OBJREF 0x80000000u /* object reference, cleared with (O) */ |
◆ VPRC_WIRE_COUNT
| #define VPRC_WIRE_COUNT | ( | c | ) | ((c) & ~(VPRC_BLOCKED | VPRC_OBJREF)) |
◆ VPRC_WIRE_COUNT_MAX
| #define VPRC_WIRE_COUNT_MAX (~(VPRC_BLOCKED | VPRC_OBJREF)) |
Typedef Documentation
◆ vm_page_astate_t
| typedef union vm_page_astate vm_page_astate_t |
Function Documentation
◆ _vm_page_queue()
|
inlinestatic |
Definition at line 910 of file vm_page.h.
References vm_page_astate::flags, PGA_DEQUEUE, PQ_NONE, and vm_page_astate::queue.
Referenced by vm_page_queue(), vm_pageout_launder(), vm_pageout_scan_active(), and vm_pageout_scan_inactive().
◆ PHYS_TO_VM_PAGE()
| vm_page_t PHYS_TO_VM_PAGE | ( | vm_paddr_t | pa | ) |
Definition at line 1221 of file vm_page.c.
References first_page, vm_page_array, vm_page_array_size, vm_phys_fictitious_to_vm_page(), and vm_phys_paddr_to_vm_page().
Referenced by kern_mincore(), kmem_bootstrap_free(), pcpu_page_free(), startup_free(), v2sizep(), v2sizev(), vm_phys_init(), vsetzoneslab(), and vtozoneslab().
◆ SLIST_HEAD()
| SLIST_HEAD | ( | spglist | , |
| vm_page | |||
| ) |
◆ TAILQ_HEAD()
| TAILQ_HEAD | ( | pglist | , |
| vm_page | |||
| ) |
◆ vm_page_activate()
| void vm_page_activate | ( | vm_page_t | m | ) |
Definition at line 4159 of file vm_page.c.
References PGA_REQUEUE, PQ_ACTIVE, and vm_page_mvqueue().
Referenced by swp_pager_async_iodone(), vm_fault(), vm_fault_copy_entry(), vm_fault_populate(), vm_page_advise(), vm_page_readahead_finish(), and vm_pageout_flush().
◆ vm_page_active()
|
inlinestatic |
Definition at line 931 of file vm_page.h.
References PQ_ACTIVE, and vm_page_queue().
Referenced by vm_swapout_object_deactivate_page().
◆ vm_page_advise()
| void vm_page_advise | ( | vm_page_t | m, |
| int | advice | ||
| ) |
Definition at line 4370 of file vm_page.c.
References PGA_REFERENCED, pmap_is_modified(), VM_OBJECT_ASSERT_WLOCKED, vm_page_activate(), vm_page_aflag_clear(), vm_page_assert_xbusied, vm_page_deactivate_noreuse(), vm_page_dirty(), vm_page_in_laundry(), vm_page_launder(), and vm_page_undirty().
Referenced by vm_object_madvise().
◆ vm_page_aflag_clear()
|
inlinestatic |
Definition at line 840 of file vm_page.h.
References VM_PAGE_AFLAG_SHIFT.
Referenced by swap_pager_putpages(), swap_pager_unswapped(), vm_fault_dirty(), vm_page_advise(), vm_page_set_validclean(), vm_page_unwire_managed(), vm_page_unwire_noq(), vm_pageout_collect_batch(), and vm_pageout_end_scan().
◆ vm_page_aflag_set()
|
inlinestatic |
Definition at line 858 of file vm_page.h.
References VM_PAGE_AFLAG_SHIFT, and VM_PAGE_ASSERT_PGA_WRITEABLE.
Referenced by swap_pager_unswapped(), swp_pager_async_iodone(), vm_fault_busy_sleep(), vm_fault_dirty(), vm_object_madvise(), vm_page_enqueue(), vm_page_reference(), vm_page_unwire_managed(), vm_page_wire(), vm_page_wire_mapped(), vm_pageout_init_scan(), and vm_pageout_reinsert_inactive_page().
◆ vm_page_all_valid()
|
inlinestatic |
Definition at line 990 of file vm_page.h.
Referenced by default_phys_pager_getpages(), default_phys_pager_populate(), kern_mincore(), swap_pager_swapoff_object(), vm_fault(), vm_fault_copy_entry(), vm_fault_dontneed(), vm_fault_object(), vm_fault_populate_check_page(), vm_fault_prefault(), vm_fault_soft_fast(), vm_map_pmap_enter(), vm_object_collapse_scan(), vm_object_madvise(), vm_object_scan_all_shadowed(), vm_page_dirty_KBI(), vm_page_grab_valid(), vm_page_grab_valid_unlocked(), vm_page_set_invalid(), vm_pageout_flush(), and vm_thread_swapin().
◆ vm_page_alloc()
| vm_page_t vm_page_alloc | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | req | ||
| ) |
Definition at line 1908 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, vm_page_alloc_after(), and vm_radix_lookup_le().
Referenced by swap_pager_getpages_locked(), swap_pager_swapoff_object(), vm_fault_allocate(), vm_fault_copy_entry(), vm_page_grab(), vm_page_grab_valid(), and vnode_pager_generic_getpages().
◆ vm_page_alloc_after()
| vm_page_t vm_page_alloc_after | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | req, | ||
| vm_page_t | mpred | ||
| ) |
Definition at line 1931 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_alloc_domain_after().
Referenced by vm_page_alloc(), and vm_page_grab_pages().
◆ vm_page_alloc_contig()
| vm_page_t vm_page_alloc_contig | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | req, | ||
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 2162 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_alloc_contig_domain().
◆ vm_page_alloc_contig_domain()
| vm_page_t vm_page_alloc_contig_domain | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | domain, | ||
| int | req, | ||
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 2220 of file vm_page.c.
References vm_object::flags, vm_object::memattr, OBJ_FICTITIOUS, OBJ_UNMANAGED, PG_NODUMP, PG_ZERO, vm_object::rtree, VM_ALLOC_NOBUSY, VM_ALLOC_NODUMP, VM_ALLOC_NORECLAIM, VM_ALLOC_SBUSY, VM_ALLOC_WAITFAIL, VM_ALLOC_WAITOK, VM_ALLOC_WIRED, VM_DOMAIN, vm_domain_alloc_fail(), VM_OBJECT_ASSERT_WLOCKED, vm_object_reserv(), VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_alloc_check(), vm_page_dequeue(), vm_page_find_contig_domain(), vm_page_free_toq(), vm_page_insert_after(), vm_radix_lookup_le(), vm_radix_wait(), VPAC_FLAGS, VPB_CURTHREAD_EXCLUSIVE, VPB_SHARERS_WORD, VPB_UNBUSIED, and VPO_UNMANAGED.
Referenced by kmem_alloc_contig_pages(), and vm_page_alloc_contig().
◆ vm_page_alloc_domain()
| vm_page_t vm_page_alloc_domain | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | domain, | ||
| int | req | ||
| ) |
Definition at line 1916 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, vm_page_alloc_domain_after(), and vm_radix_lookup_le().
◆ vm_page_alloc_domain_after()
| vm_page_t vm_page_alloc_domain_after | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | domain, | ||
| int | req, | ||
| vm_page_t | mpred | ||
| ) |
Definition at line 2003 of file vm_page.c.
References vm_object::flags, vm_object::memattr, OBJ_FICTITIOUS, OBJ_UNMANAGED, PG_NODUMP, PG_PCPU_CACHE, PG_ZERO, uma_zalloc(), VM_ALLOC_NOBUSY, VM_ALLOC_NODUMP, VM_ALLOC_SBUSY, VM_ALLOC_WAITFAIL, VM_ALLOC_WIRED, VM_DOMAIN, vm_domain_alloc_fail(), vm_domain_allocate(), vm_domain_free_lock, vm_domain_free_unlock, vm_domain_freecnt_inc(), VM_OBJECT_ASSERT_WLOCKED, vm_object_reserv(), VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_alloc_check(), vm_page_dequeue(), vm_page_free_toq(), vm_page_insert_after(), vm_phys_alloc_pages(), vm_radix_wait(), vm_domain::vmd_pgcache, VPA_FLAGS, VPB_CURTHREAD_EXCLUSIVE, VPB_SHARERS_WORD, VPB_UNBUSIED, VPO_UNMANAGED, and vm_domain::vm_pgcache::zone.
Referenced by kmem_back_domain(), vm_page_alloc_after(), and vm_page_alloc_domain().
◆ vm_page_alloc_freelist()
| vm_page_t vm_page_alloc_freelist | ( | int | freelist, |
| int | req | ||
| ) |
Definition at line 2402 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_alloc_freelist_domain().
◆ vm_page_alloc_freelist_domain()
| vm_page_t vm_page_alloc_freelist_domain | ( | int | domain, |
| int | freelist, | ||
| int | req | ||
| ) |
Definition at line 2419 of file vm_page.c.
References _vm_page_alloc_noobj_domain().
Referenced by vm_page_alloc_freelist().
◆ vm_page_alloc_noobj()
| vm_page_t vm_page_alloc_noobj | ( | int | req | ) |
Definition at line 2428 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_alloc_noobj_domain().
Referenced by kmem_init_zero_region(), and pcpu_page_alloc().
◆ vm_page_alloc_noobj_contig()
| vm_page_t vm_page_alloc_noobj_contig | ( | int | req, |
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 2451 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_alloc_noobj_contig_domain().
Referenced by vm_page_reclaim_run().
◆ vm_page_alloc_noobj_contig_domain()
| vm_page_t vm_page_alloc_noobj_contig_domain | ( | int | domain, |
| int | req, | ||
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 2471 of file vm_page.c.
References PG_NODUMP, PG_ZERO, pmap_zero_page(), VM_ALLOC_NOBUSY, VM_ALLOC_NODUMP, VM_ALLOC_NORECLAIM, VM_ALLOC_SBUSY, VM_ALLOC_WAITOK, VM_ALLOC_WIRED, VM_ALLOC_ZERO, VM_DOMAIN, vm_domain_alloc_fail(), vm_page_alloc_check(), vm_page_dequeue(), vm_page_find_contig_domain(), VPANC_FLAGS, VPB_UNBUSIED, and VPO_UNMANAGED.
Referenced by startup_alloc(), and vm_page_alloc_noobj_contig().
◆ vm_page_alloc_noobj_domain()
| vm_page_t vm_page_alloc_noobj_domain | ( | int | domain, |
| int | req | ||
| ) |
Definition at line 2445 of file vm_page.c.
References _vm_page_alloc_noobj_domain().
Referenced by noobj_alloc(), pcpu_page_alloc(), and vm_page_alloc_noobj().
◆ vm_page_astate_fcmpset()
|
inlinestatic |
Definition at line 823 of file vm_page.h.
References vm_page_astate::_bits, PGA_ENQUEUED, PGA_REQUEUE_HEAD, PQ_INACTIVE, and PQ_NONE.
Referenced by vm_page_pqstate_fcmpset().
◆ vm_page_astate_load()
|
inlinestatic |
Definition at line 811 of file vm_page.h.
References vm_page_astate::_bits.
Referenced by vm_page_dequeue(), vm_page_dequeue_deferred(), vm_page_mvqueue(), vm_page_pqstate_commit_dequeue(), vm_page_queue(), vm_page_release_toq(), vm_page_unwire_managed(), vm_pageout_defer(), vm_pageout_launder(), vm_pageout_reinsert_inactive_page(), vm_pageout_scan_active(), vm_pageout_scan_inactive(), and vm_pqbatch_process_page().
◆ vm_page_bits()
| vm_page_bits_t vm_page_bits | ( | int | base, |
| int | size | ||
| ) |
Definition at line 4929 of file vm_page.c.
Referenced by vm_page_clear_dirty(), vm_page_is_valid(), vm_page_set_invalid(), vm_page_set_valid_range(), vm_page_set_validclean(), vnode_pager_generic_getpages_done(), and vnode_pager_input_smlfs().
◆ vm_page_bits_set()
| void vm_page_bits_set | ( | vm_page_t | m, |
| vm_page_bits_t * | bits, | ||
| vm_page_bits_t | set | ||
| ) |
Definition at line 4950 of file vm_page.c.
Referenced by vm_page_set_valid_range(), vm_page_set_validclean(), vm_page_valid(), and vnode_pager_input_smlfs().
◆ vm_page_blacklist_add()
| bool vm_page_blacklist_add | ( | vm_paddr_t | pa, |
| bool | verbose | ||
| ) |
Definition at line 326 of file vm_page.c.
References vm_domain_free_lock, vm_domain_free_unlock, vm_domain_freecnt_inc(), vm_pagequeue_domain(), vm_phys_paddr_to_vm_page(), and vm_phys_unfree_page().
Referenced by vm_page_blacklist_check().
◆ vm_page_busy_acquire()
| bool vm_page_busy_acquire | ( | vm_page_t | m, |
| int | allocflags | ||
| ) |
Definition at line 869 of file vm_page.c.
References _vm_page_busy_sleep(), VM_ALLOC_NOWAIT, VM_ALLOC_WAITFAIL, VM_OBJECT_WLOCK, VM_OBJECT_WOWNED, vm_page_tryacquire(), and vm_page_wired().
Referenced by dev_pager_dealloc(), sg_pager_dealloc(), swap_pager_swapoff_object(), vm_fault_copy_entry(), and vm_object_page_clean().
◆ vm_page_busy_downgrade()
| void vm_page_busy_downgrade | ( | vm_page_t | m | ) |
Definition at line 909 of file vm_page.c.
References vm_page_assert_xbusied, vm_page_busy_fetch, VPB_BIT_WAITERS, and VPB_SHARERS_WORD.
Referenced by vm_page_grab_valid(), and vm_pageout_flush().
◆ vm_page_busy_sleep()
| bool vm_page_busy_sleep | ( | vm_page_t | m, |
| const char * | msg, | ||
| int | allocflags | ||
| ) |
Definition at line 1014 of file vm_page.c.
References _vm_page_busy_sleep(), and VM_OBJECT_ASSERT_LOCKED.
Referenced by vm_fault_busy_sleep(), vm_object_collapse_scan_wait(), vm_object_madvise(), vm_object_page_remove(), vm_object_split(), and vm_object_unwire().
◆ vm_page_busy_sleep_unlocked()
| void vm_page_busy_sleep_unlocked | ( | vm_object_t | obj, |
| vm_page_t | m, | ||
| vm_pindex_t | pindex, | ||
| const char * | wmesg, | ||
| int | allocflags | ||
| ) |
Definition at line 1038 of file vm_page.c.
References _vm_page_busy_sleep(), vm_page::pindex, and VM_OBJECT_ASSERT_UNLOCKED.
◆ vm_page_busy_tryupgrade()
| int vm_page_busy_tryupgrade | ( | vm_page_t | m | ) |
Definition at line 932 of file vm_page.c.
References vm_page_assert_sbusied, vm_page_busy_fetch, VPB_BIT_WAITERS, VPB_CURTHREAD_EXCLUSIVE, VPB_SHARERS, and VPB_SHARERS_WORD.
◆ vm_page_clear_dirty()
| void vm_page_clear_dirty | ( | vm_page_t | m, |
| int | base, | ||
| int | size | ||
| ) |
Definition at line 5264 of file vm_page.c.
References vm_page_bits(), and vm_page_clear_dirty_mask().
Referenced by vnode_pager_generic_putpages(), vnode_pager_subpage_purge(), and vnode_pager_undirty_pages().
◆ vm_page_deactivate()
| void vm_page_deactivate | ( | vm_page_t | m | ) |
Definition at line 4170 of file vm_page.c.
References PGA_REQUEUE, PQ_INACTIVE, and vm_page_mvqueue().
Referenced by fault_page_release(), vm_fault_dontneed(), vm_fault_populate_cleanup(), vm_page_readahead_finish(), vm_page_reclaim_run(), and vm_swapout_object_deactivate_page().
◆ vm_page_deactivate_noreuse()
| void vm_page_deactivate_noreuse | ( | vm_page_t | m | ) |
Definition at line 4177 of file vm_page.c.
References PGA_REQUEUE_HEAD, PQ_INACTIVE, and vm_page_mvqueue().
Referenced by swp_pager_async_iodone(), vm_object_page_noreuse(), vm_page_advise(), and vm_pageout_flush().
◆ vm_page_dequeue()
| void vm_page_dequeue | ( | vm_page_t | m | ) |
Definition at line 3755 of file vm_page.c.
References vm_page_astate::flags, PGA_QUEUE_STATE_MASK, PQ_NONE, vm_page_astate::queue, vm_page_astate_load(), and vm_page_pqstate_commit_dequeue().
Referenced by _vm_page_alloc_noobj_domain(), vm_page_alloc_contig_domain(), vm_page_alloc_domain_after(), vm_page_alloc_noobj_contig_domain(), vm_page_reclaim_run(), and vm_page_unswappable().
◆ vm_page_dequeue_deferred()
| void vm_page_dequeue_deferred | ( | vm_page_t | m | ) |
Definition at line 3731 of file vm_page.c.
References vm_page_astate::flags, PGA_DEQUEUE, PGA_QUEUE_STATE_MASK, PQ_NONE, vm_page_astate::queue, vm_page_astate_load(), and vm_page_pqstate_commit_request().
Referenced by vm_page_free_prep().
◆ vm_page_dirty()
|
static |
Definition at line 885 of file vm_page.h.
References vm_page_dirty_KBI().
Referenced by kern_mincore(), swp_pager_force_dirty(), vm_fault_cow(), vm_fault_quick_hold_pages(), vm_page_advise(), vm_page_rename(), vm_page_test_dirty(), and vm_thread_swapout().
◆ vm_page_dirty_KBI()
| void vm_page_dirty_KBI | ( | vm_page_t | m | ) |
Definition at line 1413 of file vm_page.c.
References vm_page_all_valid().
Referenced by vm_page_dirty().
◆ vm_page_domain()
|
inlinestatic |
Definition at line 1004 of file vm_page.h.
References vm_phys_seg::domain, vm_ndomains, vm_phys_nsegs, and vm_phys_segs.
Referenced by _kmem_unback(), kmem_alloc_attr_domain(), kmem_alloc_contig_domain(), kmem_back_domain(), vm_page_pqbatch_submit(), vm_page_reclaim_run(), and vm_pagequeue_domain().
◆ vm_page_drop()
|
inlinestatic |
Definition at line 959 of file vm_page.h.
References VPRC_BLOCKED.
Referenced by vm_object_terminate_pages(), vm_page_remove_xbusy(), vm_page_replace_hold(), vm_page_try_blocked_op(), and vm_page_unwire_noq().
◆ vm_page_find_least()
| vm_page_t vm_page_find_least | ( | vm_object_t | object, |
| vm_pindex_t | pindex | ||
| ) |
Definition at line 1708 of file vm_page.c.
References vm_object::memq, vm_page::object, vm_page::pindex, vm_object::rtree, VM_OBJECT_ASSERT_LOCKED, and vm_radix_lookup_ge().
Referenced by vm_fault_dontneed(), vm_map_pmap_enter(), vm_object_madvise(), vm_object_page_clean(), vm_object_page_noreuse(), vm_object_page_remove(), vm_object_scan_all_shadowed(), vm_object_split(), and vm_object_unwire().
◆ vm_page_free()
| void vm_page_free | ( | vm_page_t | m | ) |
Definition at line 1326 of file vm_page.c.
References vm_page_free_toq().
Referenced by _kmem_unback(), fault_page_free(), noobj_alloc(), pcpu_page_alloc(), pcpu_page_free(), startup_free(), vm_object_collapse_scan(), vm_object_page_remove(), vm_object_split(), vm_object_terminate_pages(), vm_page_free_invalid(), vm_page_grab_valid(), vm_page_reclaim_run(), vm_page_release_locked(), vm_page_replace(), vm_page_unwire(), vm_page_unwire_managed(), vm_pageout_launder(), vm_pageout_scan_inactive(), and vm_thread_stack_dispose().
◆ vm_page_free_invalid()
| void vm_page_free_invalid | ( | vm_page_t | m | ) |
Definition at line 1375 of file vm_page.c.
References VM_OBJECT_ASSERT_WLOCKED, vm_page_free(), vm_page_none_valid(), vm_page_remove(), and vm_page_xbusy_claim.
Referenced by vnode_pager_generic_getpages_done().
◆ vm_page_free_pages_toq()
| void vm_page_free_pages_toq | ( | struct spglist * | free, |
| bool | update_wire_count | ||
| ) |
Definition at line 3941 of file vm_page.c.
References vm_page_free_toq().
◆ vm_page_free_zero()
| void vm_page_free_zero | ( | vm_page_t | m | ) |
Definition at line 1339 of file vm_page.c.
References PG_ZERO, and vm_page_free_toq().
◆ vm_page_getfake()
| vm_page_t vm_page_getfake | ( | vm_paddr_t | paddr, |
| vm_memattr_t | memattr | ||
| ) |
Definition at line 1252 of file vm_page.c.
References uma_zalloc(), and vm_page_initfake().
Referenced by old_dev_pager_fault(), and sg_pager_getpages().
◆ vm_page_grab()
| vm_page_t vm_page_grab | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | allocflags | ||
| ) |
Definition at line 4509 of file vm_page.c.
References PG_ZERO, pmap_zero_page(), VM_ALLOC_NOCREAT, VM_ALLOC_NOWAIT, VM_ALLOC_WAITFAIL, VM_ALLOC_ZERO, VM_OBJECT_ASSERT_WLOCKED, vm_page_alloc(), vm_page_grab_check(), vm_page_grab_pflags(), vm_page_grab_release(), vm_page_grab_sleep(), vm_page_lookup(), and vm_page_tryacquire().
Referenced by default_phys_pager_populate(), vm_page_grab_unlocked(), vnode_pager_purge_range(), and vnode_pager_setsize().
◆ vm_page_grab_pages()
| int vm_page_grab_pages | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | allocflags, | ||
| vm_page_t * | ma, | ||
| int | count | ||
| ) |
Definition at line 4821 of file vm_page.c.
References PG_ZERO, pmap_zero_page(), vm_object::rtree, VM_ALLOC_COUNT, VM_ALLOC_COUNT_SHIFT, VM_ALLOC_NOCREAT, VM_ALLOC_NOWAIT, VM_ALLOC_WAITFAIL, VM_ALLOC_ZERO, VM_OBJECT_ASSERT_WLOCKED, vm_page_alloc_after(), vm_page_grab_check(), vm_page_grab_pflags(), vm_page_grab_release(), vm_page_grab_sleep(), vm_page_next(), vm_page_none_valid(), vm_page_tryacquire(), vm_page_valid(), and vm_radix_lookup_le().
Referenced by vm_page_grab_pages_unlocked(), and vm_thread_stack_back().
◆ vm_page_grab_pages_unlocked()
| int vm_page_grab_pages_unlocked | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | allocflags, | ||
| vm_page_t * | ma, | ||
| int | count | ||
| ) |
Definition at line 4882 of file vm_page.c.
References PG_ZERO, pmap_zero_page(), VM_ALLOC_NOCREAT, VM_ALLOC_ZERO, VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_acquire_unlocked(), vm_page_grab_check(), vm_page_grab_pages(), vm_page_grab_release(), vm_page_none_valid(), and vm_page_valid().
◆ vm_page_grab_unlocked()
| vm_page_t vm_page_grab_unlocked | ( | vm_object_t | object, |
| vm_pindex_t | pindex, | ||
| int | allocflags | ||
| ) |
Definition at line 4612 of file vm_page.c.
References VM_ALLOC_NOCREAT, VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_acquire_unlocked(), vm_page_grab(), and vm_page_grab_check().
◆ vm_page_grab_valid()
| int vm_page_grab_valid | ( | vm_page_t * | mp, |
| vm_object_t | object, | ||
| vm_pindex_t | pindex, | ||
| int | allocflags | ||
| ) |
Definition at line 4647 of file vm_page.c.
References VM_ALLOC_COUNT_SHIFT, VM_ALLOC_IGN_SBUSY, VM_ALLOC_NOBUSY, VM_ALLOC_NOCREAT, VM_ALLOC_NORMAL, VM_ALLOC_NOWAIT, VM_ALLOC_SBUSY, VM_ALLOC_WAITFAIL, VM_ALLOC_WIRED, VM_ALLOC_ZERO, VM_OBJECT_ASSERT_WLOCKED, vm_object_pip_add(), vm_object_pip_wakeupn(), VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_all_valid(), vm_page_alloc(), vm_page_assert_xbusied, vm_page_busy_downgrade(), vm_page_busy_release(), vm_page_free(), vm_page_grab_sleep(), vm_page_lookup(), vm_page_next(), vm_page_readahead_finish(), vm_page_trybusy(), vm_page_tryxbusy(), vm_page_wire(), vm_page_wired(), vm_page_xbusied, vm_page_xunbusy, vm_page_zero_invalid(), VM_PAGER_FAIL, vm_pager_get_pages(), vm_pager_has_page(), and VM_PAGER_OK.
Referenced by vm_object_populate(), and vm_page_grab_valid_unlocked().
◆ vm_page_grab_valid_unlocked()
| int vm_page_grab_valid_unlocked | ( | vm_page_t * | mp, |
| vm_object_t | object, | ||
| vm_pindex_t | pindex, | ||
| int | allocflags | ||
| ) |
Definition at line 4752 of file vm_page.c.
References VM_ALLOC_IGN_SBUSY, VM_ALLOC_NOBUSY, VM_ALLOC_NOCREAT, VM_ALLOC_NOWAIT, VM_ALLOC_SBUSY, VM_ALLOC_WAITFAIL, VM_ALLOC_WIRED, VM_ALLOC_ZERO, VM_OBJECT_WLOCK, VM_OBJECT_WUNLOCK, vm_page_acquire_unlocked(), vm_page_all_valid(), vm_page_busy_release(), vm_page_grab_release(), vm_page_grab_valid(), vm_page_wire(), VM_PAGER_FAIL, and VM_PAGER_OK.
Referenced by vm_imgact_hold_page().
◆ vm_page_in_laundry()
|
inlinestatic |
Definition at line 945 of file vm_page.h.
References PQ_LAUNDRY, PQ_UNSWAPPABLE, and vm_page_queue().
Referenced by vm_page_advise(), vm_pageout_clean(), vm_pageout_cluster(), and vm_pageout_flush().
◆ vm_page_inactive()
|
inlinestatic |
Definition at line 938 of file vm_page.h.
References PQ_INACTIVE, and vm_page_queue().
Referenced by vm_fault_dontneed().
◆ vm_page_init_marker()
| void vm_page_init_marker | ( | vm_page_t | marker, |
| int | queue, | ||
| uint16_t | aflags | ||
| ) |
Definition at line 428 of file vm_page.c.
References PG_MARKER, and VPB_CURTHREAD_EXCLUSIVE.
Referenced by vm_page_domain_init(), and vm_pageout_scan_inactive().
◆ vm_page_init_page()
| void vm_page_init_page | ( | vm_page_t | m, |
| vm_paddr_t | pa, | ||
| int | segind | ||
| ) |
Definition at line 500 of file vm_page.c.
References pmap_page_init(), PQ_NONE, and VPB_FREED.
Referenced by vm_page_startup().
◆ vm_page_initfake()
| void vm_page_initfake | ( | vm_page_t | m, |
| vm_paddr_t | paddr, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 1262 of file vm_page.c.
References PG_FICTITIOUS, pmap_page_init(), PQ_NONE, VPB_CURTHREAD_EXCLUSIVE, and VPO_UNMANAGED.
Referenced by vm_page_getfake(), and vm_phys_fictitious_init_range().
◆ vm_page_insert()
| int vm_page_insert | ( | vm_page_t | m, |
| vm_object_t | object, | ||
| vm_pindex_t | pindex | ||
| ) |
Definition at line 1429 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, VM_OBJECT_ASSERT_WLOCKED, vm_page_insert_after(), and vm_radix_lookup_le().
◆ vm_page_invalid()
| void vm_page_invalid | ( | vm_page_t | m | ) |
Definition at line 5318 of file vm_page.c.
References VM_OBJECT_ASSERT_WLOCKED, vm_page_assert_busied, vm_page_bits_clear(), and vm_page_xbusied.
Referenced by swp_pager_async_iodone(), and vm_object_page_remove().
◆ vm_page_is_valid()
| int vm_page_is_valid | ( | vm_page_t | m, |
| int | base, | ||
| int | size | ||
| ) |
Definition at line 5386 of file vm_page.c.
References vm_page_bits().
◆ vm_page_launder()
| void vm_page_launder | ( | vm_page_t | m | ) |
Definition at line 4187 of file vm_page.c.
References PGA_REQUEUE, PQ_LAUNDRY, and vm_page_mvqueue().
Referenced by swp_pager_force_dirty(), vm_page_advise(), vm_pageout_launder(), and vm_pageout_scan_inactive().
◆ vm_page_lock_KBI()
| void vm_page_lock_KBI | ( | vm_page_t | m, |
| const char * | file, | ||
| int | line | ||
| ) |
Definition at line 5464 of file vm_page.c.
References vm_page_lockptr.
◆ vm_page_lookup()
| vm_page_t vm_page_lookup | ( | vm_object_t | object, |
| vm_pindex_t | pindex | ||
| ) |
Definition at line 1627 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, VM_OBJECT_ASSERT_LOCKED, and vm_radix_lookup().
Referenced by _kmem_unback(), kern_mincore(), swap_pager_swapoff_object(), vm_fault_busy_sleep(), vm_fault_copy_entry(), vm_fault_object(), vm_fault_populate(), vm_fault_populate_cleanup(), vm_fault_prefault(), vm_fault_soft_fast(), vm_object_collapse_scan(), vm_object_madvise(), vm_object_populate(), vm_object_scan_all_shadowed(), vm_object_unwire(), vm_page_grab(), vm_page_grab_valid(), vm_thread_stack_dispose(), and vm_thread_swapout().
◆ vm_page_lookup_unlocked()
| vm_page_t vm_page_lookup_unlocked | ( | vm_object_t | object, |
| vm_pindex_t | pindex | ||
| ) |
Definition at line 1643 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, and vm_radix_lookup_unlocked().
◆ vm_page_next()
| vm_page_t vm_page_next | ( | vm_page_t | m | ) |
Definition at line 1725 of file vm_page.c.
References VM_OBJECT_ASSERT_LOCKED.
Referenced by _kmem_unback(), swap_pager_swapoff_object(), vm_fault_populate(), vm_fault_populate_cleanup(), vm_object_page_collect_flush(), vm_page_grab_pages(), vm_page_grab_valid(), and vm_pageout_cluster().
◆ vm_page_none_valid()
|
inlinestatic |
Definition at line 997 of file vm_page.h.
Referenced by default_phys_pager_getpages(), kern_mincore(), vm_object_collapse_scan(), vm_object_page_clean(), vm_object_page_remove(), vm_object_scan_all_shadowed(), vm_object_split(), vm_page_free_invalid(), vm_page_grab_pages(), vm_page_grab_pages_unlocked(), vm_page_readahead_finish(), vm_page_reclaim_run(), vm_pageout_launder(), vm_pageout_scan_inactive(), vnode_pager_generic_getpages(), vnode_pager_purge_range(), and vnode_pager_setsize().
◆ vm_page_pqbatch_drain()
| void vm_page_pqbatch_drain | ( | void | ) |
Definition at line 3692 of file vm_page.c.
References PQ_COUNT, VM_DOMAIN, vm_ndomains, vm_pagequeue_lock, vm_pagequeue_unlock, vm_pqbatch_process(), and vm_domain::vmd_pagequeues.
Referenced by vm_daemon().
◆ vm_page_pqbatch_submit()
| void vm_page_pqbatch_submit | ( | vm_page_t | m, |
| uint8_t | queue | ||
| ) |
Definition at line 3657 of file vm_page.c.
References PQ_COUNT, vm_batchqueue_insert(), VM_DOMAIN, vm_page_domain(), vm_pagequeue_lock, vm_pagequeue_unlock, vm_pqbatch_process(), and vm_pqbatch_process_page().
Referenced by vm_page_enqueue(), vm_page_pqstate_commit(), vm_page_pqstate_commit_request(), and vm_pageout_defer().
◆ vm_page_pqstate_commit()
| bool vm_page_pqstate_commit | ( | vm_page_t | m, |
| vm_page_astate_t * | old, | ||
| vm_page_astate_t | new | ||
| ) |
Definition at line 3573 of file vm_page.c.
References vm_page_astate::_bits, vm_page_astate::flags, PGA_QUEUE_OP_MASK, PQ_NONE, vm_page_astate::queue, vm_page_pqbatch_submit(), vm_page_pqstate_commit_dequeue(), and vm_page_pqstate_fcmpset().
Referenced by vm_page_mvqueue(), vm_page_release_toq(), vm_pageout_launder(), vm_pageout_scan_active(), and vm_pageout_scan_inactive().
◆ vm_page_prev()
| vm_page_t vm_page_prev | ( | vm_page_t | m | ) |
Definition at line 1745 of file vm_page.c.
References VM_OBJECT_ASSERT_LOCKED.
Referenced by vm_object_page_collect_flush(), and vm_pageout_cluster().
◆ vm_page_ps_test()
| bool vm_page_ps_test | ( | vm_page_t | m, |
| int | flags, | ||
| vm_page_t | skip_m | ||
| ) |
Definition at line 5399 of file vm_page.c.
References PS_ALL_DIRTY, PS_ALL_VALID, PS_NONE_BUSY, VM_OBJECT_ASSERT_LOCKED, and vm_page_busied.
Referenced by vm_fault_soft_fast(), and vm_map_pmap_enter().
◆ vm_page_putfake()
| void vm_page_putfake | ( | vm_page_t | m | ) |
Definition at line 1293 of file vm_page.c.
References PG_FICTITIOUS, uma_zfree(), vm_page_assert_xbusied, vm_page_busy_free(), and VPO_UNMANAGED.
Referenced by dev_pager_free_page(), and sg_pager_dealloc().
◆ vm_page_queue()
|
inlinestatic |
Definition at line 924 of file vm_page.h.
References _vm_page_queue(), and vm_page_astate_load().
Referenced by vm_page_active(), vm_page_in_laundry(), vm_page_inactive(), vm_page_reclaim_run(), and vm_page_scan_contig().
◆ vm_page_readahead_finish()
| void vm_page_readahead_finish | ( | vm_page_t | m | ) |
Definition at line 1351 of file vm_page.c.
References vm_page_activate(), vm_page_busy_fetch, vm_page_deactivate(), vm_page_none_valid(), vm_page_xunbusy_unchecked, and VPB_BIT_WAITERS.
Referenced by swp_pager_async_iodone(), vm_page_grab_valid(), and vnode_pager_generic_getpages_done().
◆ vm_page_reclaim_contig()
| bool vm_page_reclaim_contig | ( | int | req, |
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary | ||
| ) |
Definition at line 3122 of file vm_page.c.
References vm_domainset_iter_page(), vm_domainset_iter_page_init(), and vm_page_reclaim_contig_domain().
◆ vm_page_reclaim_contig_domain()
| bool vm_page_reclaim_contig_domain | ( | int | domain, |
| int | req, | ||
| u_long | npages, | ||
| vm_paddr_t | low, | ||
| vm_paddr_t | high, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary | ||
| ) |
Definition at line 3024 of file vm_page.c.
References MIN_RECLAIM, NRUNS, pageproc, RUN_INDEX, VM_ALLOC_CLASS_MASK, VM_ALLOC_INTERRUPT, VM_ALLOC_SYSTEM, VM_DOMAIN, vm_page_reclaim_run(), VM_PAGE_TO_PHYS, vm_phys_scan_contig(), vmd_free_reserved, vm_domain::vmd_interrupt_free_min, VPSC_ANY, VPSC_NORESERV, and VPSC_NOSUPER.
Referenced by kmem_alloc_contig_pages(), and vm_page_reclaim_contig().
◆ vm_page_reference()
| void vm_page_reference | ( | vm_page_t | m | ) |
Definition at line 821 of file vm_page.c.
References PGA_REFERENCED, and vm_page_aflag_set().
Referenced by vm_page_grab_sleep().
◆ vm_page_release()
| void vm_page_release | ( | vm_page_t | m, |
| int | flags | ||
| ) |
Definition at line 4256 of file vm_page.c.
References PQ_INACTIVE, VM_OBJECT_TRYWLOCK, VM_OBJECT_WUNLOCK, vm_page_busied, vm_page_release_locked(), vm_page_unwire_managed(), VPO_UNMANAGED, and VPR_TRYFREE.
◆ vm_page_release_locked()
| void vm_page_release_locked | ( | vm_page_t | m, |
| int | flags | ||
| ) |
Definition at line 4284 of file vm_page.c.
References PQ_INACTIVE, VM_OBJECT_ASSERT_WLOCKED, vm_page_free(), vm_page_release_toq(), vm_page_tryxbusy(), vm_page_unwire_noq(), vm_page_wired(), vm_page_xunbusy, VPO_UNMANAGED, and VPR_TRYFREE.
Referenced by vm_page_release().
◆ vm_page_relookup()
| vm_page_t vm_page_relookup | ( | vm_object_t | object, |
| vm_pindex_t | pindex | ||
| ) |
Definition at line 1656 of file vm_page.c.
References vm_page::object, vm_page::pindex, vm_object::rtree, vm_page_busied, vm_page_wired(), and vm_radix_lookup_unlocked().
Referenced by vm_pager_get_pages().
◆ vm_page_remove()
| bool vm_page_remove | ( | vm_page_t | m | ) |
Definition at line 1594 of file vm_page.c.
References vm_page_remove_xbusy(), and vm_page_xunbusy.
Referenced by cdev_pager_free_page(), vm_object_collapse_scan(), vm_object_split(), and vm_page_free_invalid().
◆ vm_page_remove_xbusy()
| bool vm_page_remove_xbusy | ( | vm_page_t | m | ) |
Definition at line 1611 of file vm_page.c.
References vm_page_drop(), vm_page_object_remove(), and VPRC_OBJREF.
Referenced by vm_fault_cow(), and vm_page_remove().
◆ vm_page_rename()
| int vm_page_rename | ( | vm_page_t | m, |
| vm_object_t | new_object, | ||
| vm_pindex_t | new_pindex | ||
| ) |
Definition at line 1845 of file vm_page.c.
References vm_object::rtree, VM_OBJECT_ASSERT_WLOCKED, vm_page_dirty(), vm_page_insert_radixdone(), vm_page_object_remove(), vm_radix_insert(), and vm_radix_lookup_le().
Referenced by vm_object_collapse_scan(), and vm_object_split().
◆ vm_page_replace()
| void vm_page_replace | ( | vm_page_t | mnew, |
| vm_object_t | object, | ||
| vm_pindex_t | pindex, | ||
| vm_page_t | mold | ||
| ) |
Definition at line 1816 of file vm_page.c.
References vm_page::pindex, vm_page_assert_xbusied, vm_page_free(), and vm_page_replace_hold().
Referenced by old_dev_pager_fault(), sg_pager_getpages(), and vm_fault_cow().
◆ vm_page_sbusied()
| int vm_page_sbusied | ( | vm_page_t | m | ) |
Definition at line 958 of file vm_page.c.
References vm_page_busy_fetch, VPB_BIT_SHARED, and VPB_UNBUSIED.
◆ vm_page_scan_contig()
| vm_page_t vm_page_scan_contig | ( | u_long | npages, |
| vm_page_t | m_start, | ||
| vm_page_t | m_end, | ||
| u_long | alignment, | ||
| vm_paddr_t | boundary, | ||
| int | options | ||
| ) |
Definition at line 2625 of file vm_page.c.
References vm_object::flags, vm_object::memattr, OBJ_SWAP, OBJT_DEFAULT, OBJT_VNODE, PG_FICTITIOUS, PG_MARKER, PQ_NONE, vm_object::type, vm_addr_align_ok(), vm_addr_bound_ok(), VM_OBJECT_RLOCK, VM_OBJECT_RUNLOCK, vm_page_busied, vm_page_queue(), VM_PAGE_TO_PHYS, vm_page_wired(), VPO_SWAPINPROG, VPO_SWAPSLEEP, VPO_UNMANAGED, VPSC_NORESERV, and VPSC_NOSUPER.
Referenced by vm_phys_scan_contig().
◆ vm_page_set_dirty()
| vm_page_bits_t vm_page_set_dirty | ( | vm_page_t | m | ) |
Definition at line 5133 of file vm_page.c.
References PGA_SWAP_SPACE, vm_page_bits_swap(), VM_PAGE_OBJECT_BUSY_ASSERT, vm_page_xbusied, and vm_pager_page_unswapped().
Referenced by vm_fault_dirty().
◆ vm_page_set_invalid()
| void vm_page_set_invalid | ( | vm_page_t | m, |
| int | base, | ||
| int | size | ||
| ) |
Definition at line 5277 of file vm_page.c.
References IDX_TO_OFF, OBJT_VNODE, pmap_remove_all(), vm_object::ref_count, vm_object::type, vm_object::un_pager, VM_OBJECT_ASSERT_WLOCKED, vm_page_all_valid(), vm_page_assert_busied, vm_page_bits(), vm_page_bits_clear(), vm_page_xbusied, vm_object::vnp, and vm_object::vnp_size.
◆ vm_page_set_valid_range()
| void vm_page_set_valid_range | ( | vm_page_t | m, |
| int | base, | ||
| int | size | ||
| ) |
Definition at line 5082 of file vm_page.c.
References pmap_zero_page_area(), vm_page_assert_busied, vm_page_bits(), vm_page_bits_set(), and vm_page_xbusied.
Referenced by vnode_pager_generic_getpages_done(), and vnode_pager_subpage_purge().
◆ vm_page_set_validclean()
| void vm_page_set_validclean | ( | vm_page_t | m, |
| int | base, | ||
| int | size | ||
| ) |
Definition at line 5183 of file vm_page.c.
References PGA_NOSYNC, pmap_clear_modify(), pmap_zero_page_area(), vm_page_aflag_clear(), vm_page_assert_busied, vm_page_bits(), vm_page_bits_set(), vm_page_clear_dirty_mask(), and vm_page_xbusied.
◆ vm_page_startup()
| vm_offset_t vm_page_startup | ( | vm_offset_t | vaddr | ) |
Definition at line 551 of file vm_page.c.
References vm_phys_seg::domain, dump_add_page, dump_avail, vm_phys_seg::end, vm_phys_seg::first_page, first_page, pa_lock, PA_LOCK_COUNT, PG_FICTITIOUS, phys_avail, pmap_map(), vm_page::segind, vm_phys_seg::start, vm_cnt, VM_DOMAIN, vm_domain_free_lock, vm_domain_free_unlock, vm_domain_freecnt_inc(), vm_domainset_lock, vm_ndomains, vm_page_array, vm_page_array_alloc(), vm_page_array_size, vm_page_blacklist_check(), vm_page_blacklist_load(), vm_page_domain_init(), vm_page_dump, vm_page_dump_pages, vm_page_init_page(), vm_phys_add_seg(), vm_phys_avail_largest(), vm_phys_avail_size(), vm_phys_early_startup(), vm_phys_enqueue_contig(), vm_phys_init(), vm_phys_nsegs, vm_phys_segs, VM_PROT_READ, VM_PROT_WRITE, vm_domain::vmd_page_count, and vm_domain::vmd_segs.
Referenced by vm_mem_init().
◆ vm_page_sunbusy()
| void vm_page_sunbusy | ( | vm_page_t | m | ) |
Definition at line 972 of file vm_page.c.
References vm_page_assert_sbusied, vm_page_busy_fetch, VPB_BIT_WAITERS, VPB_FREED, VPB_ONE_SHARER, VPB_SHARERS, VPB_SHARERS_WORD, and VPB_UNBUSIED.
Referenced by swp_pager_async_iodone(), vm_object_unwire(), vm_page_grab_release(), vm_page_trysbusy(), and vm_pageout_flush().
◆ vm_page_test_dirty()
| void vm_page_test_dirty | ( | vm_page_t | m | ) |
Definition at line 5444 of file vm_page.c.
References pmap_is_modified(), vm_page_assert_busied, and vm_page_dirty().
Referenced by vm_pageout_cluster(), vm_pageout_launder(), and vm_pageout_scan_inactive().
◆ vm_page_try_remove_all()
| bool vm_page_try_remove_all | ( | vm_page_t | m | ) |
Definition at line 4348 of file vm_page.c.
References pmap_remove_all(), and vm_page_try_blocked_op().
Referenced by vm_object_page_remove(), vm_page_reclaim_run(), vm_pageout_launder(), vm_pageout_scan_inactive(), and vm_swapout_object_deactivate_page().
◆ vm_page_try_remove_write()
| bool vm_page_try_remove_write | ( | vm_page_t | m | ) |
Definition at line 4358 of file vm_page.c.
References pmap_remove_write(), and vm_page_try_blocked_op().
Referenced by vm_object_page_remove(), vm_pageout_clean(), and vm_pageout_cluster().
◆ vm_page_trylock_KBI()
| int vm_page_trylock_KBI | ( | vm_page_t | m, |
| const char * | file, | ||
| int | line | ||
| ) |
Definition at line 5478 of file vm_page.c.
References vm_page_lockptr.
◆ vm_page_trysbusy()
| int vm_page_trysbusy | ( | vm_page_t | m | ) |
Definition at line 1113 of file vm_page.c.
References vm_object_busied(), vm_page_busy_fetch, vm_page_sunbusy(), VPB_BIT_SHARED, and VPB_ONE_SHARER.
Referenced by vm_object_unwire(), and vm_page_trybusy().
◆ vm_page_tryxbusy()
| int vm_page_tryxbusy | ( | vm_page_t | m | ) |
Definition at line 1151 of file vm_page.c.
References vm_object_busied(), vm_page_xunbusy, VPB_CURTHREAD_EXCLUSIVE, and VPB_UNBUSIED.
Referenced by vm_fault_object(), vm_object_collapse_scan(), vm_object_madvise(), vm_object_page_collect_flush(), vm_object_page_remove(), vm_object_scan_all_shadowed(), vm_object_split(), vm_page_grab_valid(), vm_page_reclaim_run(), vm_page_release_locked(), vm_page_trybusy(), vm_pageout_clean(), vm_pageout_cluster(), vm_pageout_launder(), vm_pageout_scan_inactive(), and vm_swapout_object_deactivate_page().
◆ vm_page_undirty()
|
static |
Definition at line 902 of file vm_page.h.
References VM_PAGE_OBJECT_BUSY_ASSERT.
Referenced by swp_pager_async_iodone(), vm_object_page_remove(), vm_page_advise(), vm_page_free_prep(), vm_pageout_flush(), and vnode_pager_undirty_pages().
◆ vm_page_unhold_pages()
| void vm_page_unhold_pages | ( | vm_page_t * | ma, |
| int | count | ||
| ) |
Definition at line 1211 of file vm_page.c.
References PQ_ACTIVE, and vm_page_unwire().
◆ vm_page_unlock_KBI()
| void vm_page_unlock_KBI | ( | vm_page_t | m, |
| const char * | file, | ||
| int | line | ||
| ) |
Definition at line 5471 of file vm_page.c.
References vm_page_lockptr.
◆ vm_page_unswappable()
| void vm_page_unswappable | ( | vm_page_t | m | ) |
Definition at line 4197 of file vm_page.c.
References PQ_UNSWAPPABLE, vm_page_dequeue(), vm_page_enqueue(), vm_page_wired(), and VPO_UNMANAGED.
Referenced by vm_pageout_flush().
◆ vm_page_unwire()
| void vm_page_unwire | ( | vm_page_t | m, |
| uint8_t | queue | ||
| ) |
Definition at line 4079 of file vm_page.c.
References PQ_COUNT, vm_page_free(), vm_page_unwire_managed(), vm_page_unwire_noq(), and VPO_UNMANAGED.
Referenced by vm_fault_copy_entry(), vm_fault_cow(), vm_fault_quick_hold_pages(), vm_imgact_unmap_page(), vm_object_unwire(), vm_page_unhold_pages(), and vm_thread_swapout().
◆ vm_page_unwire_noq()
| bool vm_page_unwire_noq | ( | vm_page_t | m | ) |
Definition at line 4101 of file vm_page.c.
References PG_FICTITIOUS, PGA_DEQUEUE, vm_page_aflag_clear(), vm_page_drop(), VPO_UNMANAGED, and VPRC_WIRE_COUNT.
Referenced by _kmem_unback(), noobj_alloc(), pcpu_page_alloc(), pcpu_page_free(), startup_free(), vm_page_release_locked(), vm_page_unwire(), and vm_thread_stack_dispose().
◆ vm_page_updatefake()
| void vm_page_updatefake | ( | vm_page_t | m, |
| vm_paddr_t | paddr, | ||
| vm_memattr_t | memattr | ||
| ) |
Definition at line 1311 of file vm_page.c.
References PG_FICTITIOUS.
Referenced by old_dev_pager_fault().
◆ vm_page_valid()
| void vm_page_valid | ( | vm_page_t | m | ) |
Definition at line 5453 of file vm_page.c.
References vm_page_assert_busied, vm_page_bits_set(), and vm_page_xbusied.
Referenced by default_phys_pager_getpages(), kmem_alloc_attr_domain(), kmem_alloc_contig_domain(), kmem_back_domain(), old_dev_pager_fault(), sg_pager_getpages(), swp_pager_async_iodone(), vm_fault_cow(), vm_fault_zerofill(), vm_page_grab_pages(), vm_page_grab_pages_unlocked(), vm_page_zero_invalid(), vm_thread_stack_create(), vnode_pager_generic_getpages(), vnode_pager_generic_getpages_done(), and vnode_pager_input_old().
◆ vm_page_wire()
| void vm_page_wire | ( | vm_page_t | m | ) |
Definition at line 3965 of file vm_page.c.
References PG_FICTITIOUS, PGA_DEQUEUE, VM_OBJECT_ASSERT_LOCKED, vm_object_busied(), vm_page_aflag_set(), vm_page_busied, VPO_UNMANAGED, VPRC_WIRE_COUNT, and VPRC_WIRE_COUNT_MAX.
Referenced by vm_fault(), vm_fault_copy_entry(), vm_fault_cow(), vm_fault_populate(), vm_fault_soft_fast(), vm_page_acquire_unlocked(), vm_page_grab_valid(), vm_page_grab_valid_unlocked(), and vm_page_tryacquire().
◆ vm_page_wire_mapped()
| bool vm_page_wire_mapped | ( | vm_page_t | m | ) |
Definition at line 3996 of file vm_page.c.
References PGA_DEQUEUE, vm_page_aflag_set(), VPO_UNMANAGED, VPRC_BLOCKED, and VPRC_WIRE_COUNT.
◆ vm_page_wired()
|
inlinestatic |
Definition at line 983 of file vm_page.h.
References VPRC_WIRE_COUNT.
Referenced by fault_page_free(), v2sizep(), v2sizev(), vm_fault_copy_entry(), vm_object_madvise(), vm_object_page_remove(), vm_page_acquire_unlocked(), vm_page_busy_acquire(), vm_page_grab_valid(), vm_page_mvqueue(), vm_page_reclaim_run(), vm_page_release_locked(), vm_page_relookup(), vm_page_scan_contig(), vm_page_unswappable(), vm_pageout_cluster(), vm_pageout_launder(), vm_pageout_scan_inactive(), and vm_swapout_object_deactivate_page().
◆ vm_page_xunbusy_hard()
| void vm_page_xunbusy_hard | ( | vm_page_t | m | ) |
Definition at line 1181 of file vm_page.c.
References vm_page_assert_xbusied, and vm_page_xunbusy_hard_tail().
◆ vm_page_xunbusy_hard_unchecked()
| void vm_page_xunbusy_hard_unchecked | ( | vm_page_t | m | ) |
Definition at line 1188 of file vm_page.c.
References vm_page_assert_xbusied_unchecked, and vm_page_xunbusy_hard_tail().
◆ vm_page_zero_invalid()
| void vm_page_zero_invalid | ( | vm_page_t | m, |
| boolean_t | setvalid | ||
| ) |
Definition at line 5343 of file vm_page.c.
References pmap_zero_page_area(), and vm_page_valid().
Referenced by default_phys_pager_populate(), vm_page_grab_valid(), and vm_pager_get_pages().
Variable Documentation
◆ bogus_page
|
extern |
Definition at line 153 of file vm_page.c.
Referenced by vm_pager_assert_in(), vnode_pager_generic_getpages(), and vnode_pager_generic_getpages_done().
◆ first_page
|
extern |
Definition at line 157 of file vm_page.c.
Referenced by PHYS_TO_VM_PAGE(), vm_page_startup(), vm_phys_fictitious_reg_range(), and vm_phys_fictitious_unreg_range().
◆ pa_lock
|
extern |
Definition at line 121 of file vm_page.c.
Referenced by vm_page_startup().
◆ vm_page_array
|
extern |
Definition at line 155 of file vm_page.c.
Referenced by kmem_init(), PHYS_TO_VM_PAGE(), vm_page_array_alloc(), vm_page_startup(), vm_phys_fictitious_reg_range(), and vm_phys_init().
◆ vm_page_array_size
|
extern |
Definition at line 156 of file vm_page.c.
Referenced by kmem_init(), PHYS_TO_VM_PAGE(), vm_page_array_alloc(), vm_page_startup(), vm_phys_fictitious_reg_range(), and vm_phys_fictitious_unreg_range().
