osfmk/vm/vm_pageout.h

   1 /*
   2  * Copyright (c) 2000-2009 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. The rights granted to you under the License
  10  * may not be used to create, or enable the creation or redistribution of,
  11  * unlawful or unlicensed copies of an Apple operating system, or to
  12  * circumvent, violate, or enable the circumvention or violation of, any
  13  * terms of an Apple operating system software license agreement.
  14  *
  15  * Please obtain a copy of the License at
  16  * http://www.opensource.apple.com/apsl/ and read it before using this file.
  17  *
  18  * The Original Code and all software distributed under the License are
  19  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  20  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  21  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  23  * Please see the License for the specific language governing rights and
  24  * limitations under the License.
  25  *
  26  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  27  */
  28 /*
  29  * @OSF_COPYRIGHT@
  30  */
  31 /*
  32  * Mach Operating System
  33  * Copyright (c) 1991,1990,1989,1988,1987 Carnegie Mellon University
  34  * All Rights Reserved.
  35  *
  36  * Permission to use, copy, modify and distribute this software and its
  37  * documentation is hereby granted, provided that both the copyright
  38  * notice and this permission notice appear in all copies of the
  39  * software, derivative works or modified versions, and any portions
  40  * thereof, and that both notices appear in supporting documentation.
  41  *
  42  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  43  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
  44  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  45  *
  46  * Carnegie Mellon requests users of this software to return to
  47  *
  48  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  49  *  School of Computer Science
  50  *  Carnegie Mellon University
  51  *  Pittsburgh PA 15213-3890
  52  *
  53  * any improvements or extensions that they make and grant Carnegie Mellon
  54  * the rights to redistribute these changes.
  55  */
  56 /*
  57  */
  58 /*
  59  *      File:   vm/vm_pageout.h
  60  *      Author: Avadis Tevanian, Jr.
  61  *      Date:   1986
  62  *
  63  *      Declarations for the pageout daemon interface.
  64  */
  65
  66 #ifndef _VM_VM_PAGEOUT_H_
  67 #define _VM_VM_PAGEOUT_H_
  68
  69 #ifdef  KERNEL_PRIVATE
  70
  71 #include <mach/mach_types.h>
  72 #include <mach/boolean.h>
  73 #include <mach/machine/vm_types.h>
  74 #include <mach/memory_object_types.h>
  75
  76 #include <kern/kern_types.h>
  77 #include <kern/locks.h>
  78
  79 #include <libkern/OSAtomic.h>
  80
  81
  82 #include <vm/vm_options.h>
  83
  84 #ifdef  MACH_KERNEL_PRIVATE
  85 #include <vm/vm_page.h>
  86 #endif
  87
  88 #include <sys/kdebug.h>
  89
  90 #define VM_PAGE_AVAILABLE_COUNT()               ((unsigned int)(vm_page_cleaned_count))
  91
  92 /* externally manipulated counters */
  93 extern unsigned int vm_pageout_cleaned_reactivated, vm_pageout_cleaned_fault_reactivated, vm_pageout_cleaned_commit_reactivated;
  94
  95 #if CONFIG_FREEZE
  96 extern boolean_t memorystatus_freeze_enabled;
  97 #endif
  98
  99 #define VM_DYNAMIC_PAGING_ENABLED() (VM_CONFIG_COMPRESSOR_IS_ACTIVE)
 100
 101 #if VM_PRESSURE_EVENTS
 102 extern boolean_t vm_pressure_events_enabled;
 103 #endif /* VM_PRESSURE_EVENTS */
 104
 105
 106 /*
 107  * the following codes are used in the DBG_MACH_WORKINGSET subclass
 108  * of the DBG_MACH class
 109  */
 110 #define VM_DISCONNECT_ALL_PAGE_MAPPINGS         0x00
 111 #define VM_DISCONNECT_TASK_PAGE_MAPPINGS        0x01
 112 #define VM_REAL_FAULT_ADDR_INTERNAL             0x02
 113 #define VM_REAL_FAULT_ADDR_PURGABLE             0x03
 114 #define VM_REAL_FAULT_ADDR_EXTERNAL             0x04
 115 #define VM_REAL_FAULT_ADDR_SHAREDCACHE          0x05
 116
 117
 118
 119 extern int      vm_debug_events;
 120
 121 #define VMF_CHECK_ZFDELAY               0x100
 122 #define VMF_COWDELAY                    0x101
 123 #define VMF_ZFDELAY                     0x102
 124 #define VMF_COMPRESSORDELAY             0x103
 125
 126 #define VM_PAGEOUT_SCAN                 0x104
 127 #define VM_PAGEOUT_BALANCE              0x105
 128 #define VM_PAGEOUT_FREELIST             0x106
 129 #define VM_PAGEOUT_PURGEONE             0x107
 130 #define VM_PAGEOUT_CACHE_EVICT          0x108
 131 #define VM_PAGEOUT_THREAD_BLOCK         0x109
 132 #define VM_PAGEOUT_JETSAM               0x10A
 133 #define VM_INFO1                        0x10B
 134 #define VM_INFO2                        0x10C
 135 #define VM_INFO3                        0x10D
 136 #define VM_INFO4                        0x10E
 137 #define VM_INFO5                        0x10F
 138 #define VM_INFO6                        0x110
 139 #define VM_INFO7                        0x111
 140
 141 #define VM_UPL_PAGE_WAIT                0x120
 142 #define VM_IOPL_PAGE_WAIT               0x121
 143 #define VM_PAGE_WAIT_BLOCK              0x122
 144
 145 #if CONFIG_IOSCHED
 146 #define VM_PAGE_SLEEP                   0x123
 147 #define VM_PAGE_EXPEDITE                0x124
 148 #define VM_PAGE_EXPEDITE_NO_MEMORY      0x125
 149 #endif
 150
 151 #define VM_PRESSURE_EVENT               0x130
 152 #define VM_EXECVE                       0x131
 153 #define VM_WAKEUP_COMPACTOR_SWAPPER     0x132
 154
 155 #define VM_DATA_WRITE                   0x140
 156
 157 #define VM_DEBUG_EVENT(name, event, control, arg1, arg2, arg3, arg4)    \
 158         MACRO_BEGIN                                             \
 159         if (vm_debug_events) {                                  \
 160                 KERNEL_DEBUG_CONSTANT((MACHDBG_CODE(DBG_MACH_VM, event)) | control, arg1, arg2, arg3, arg4, 0); \
 161         }                                                       \
 162         MACRO_END
 163
 164 #define VM_DEBUG_CONSTANT_EVENT(name, event, control, arg1, arg2, arg3, arg4)   \
 165         MACRO_BEGIN                                             \
 166                 KERNEL_DEBUG_CONSTANT((MACHDBG_CODE(DBG_MACH_VM, event)) | control, arg1, arg2, arg3, arg4, 0); \
 167         MACRO_END
 168
 169 extern void memoryshot(unsigned int event, unsigned int control);
 170
 171 extern void update_vm_info(void);
 172
 173 #if CONFIG_IOSCHED
 174 extern int upl_get_cached_tier(
 175        upl_t                   upl);
 176 #endif
 177
 178 extern ppnum_t upl_get_highest_page(
 179         upl_t                   upl);
 180
 181 extern upl_size_t upl_get_size(
 182         upl_t                   upl);
 183
 184 extern upl_t upl_associated_upl(upl_t upl);
 185 extern void upl_set_associated_upl(upl_t upl, upl_t associated_upl);
 186
 187 #ifdef  XNU_KERNEL_PRIVATE
 188
 189 extern kern_return_t vm_map_create_upl(
 190         vm_map_t                map,
 191         vm_map_address_t        offset,
 192         upl_size_t              *upl_size,
 193         upl_t                   *upl,
 194         upl_page_info_array_t   page_list,
 195         unsigned int            *count,
 196         upl_control_flags_t     *flags,
 197         vm_tag_t            tag);
 198
 199 extern void iopl_valid_data(
 200         upl_t                   upl_ptr,
 201         vm_tag_t        tag);
 202
 203 #endif  /* XNU_KERNEL_PRIVATE */
 204
 205 extern struct vnode * upl_lookup_vnode(upl_t upl);
 206
 207 #ifndef MACH_KERNEL_PRIVATE
 208 typedef struct vm_page  *vm_page_t;
 209 #endif
 210
 211 extern void                vm_page_free_list(
 212                             vm_page_t   mem,
 213                             boolean_t   prepare_object);
 214
 215 extern kern_return_t      vm_page_alloc_list(
 216                             int         page_count,
 217                             int                 flags,
 218                             vm_page_t * list);
 219
 220 extern void               vm_page_set_offset(vm_page_t page, vm_object_offset_t offset);
 221 extern vm_object_offset_t vm_page_get_offset(vm_page_t page);
 222 extern ppnum_t            vm_page_get_phys_page(vm_page_t page);
 223 extern vm_page_t          vm_page_get_next(vm_page_t page);
 224
 225 extern kern_return_t    mach_vm_pressure_level_monitor(boolean_t wait_for_pressure, unsigned int *pressure_level);
 226
 227 #if !CONFIG_EMBEDDED
 228 extern kern_return_t    vm_pageout_wait(uint64_t deadline);
 229 #endif
 230
 231 #ifdef  MACH_KERNEL_PRIVATE
 232
 233 #include <vm/vm_page.h>
 234
 235 extern unsigned int     vm_pageout_scan_event_counter;
 236 extern unsigned int     vm_page_anonymous_count;
 237
 238
 239 /*
 240  * must hold the page queues lock to
 241  * manipulate this structure
 242  */
 243 struct vm_pageout_queue {
 244         vm_page_queue_head_t    pgo_pending;    /* laundry pages to be processed by pager's iothread */
 245         unsigned int    pgo_laundry;    /* current count of laundry pages on queue or in flight */
 246         unsigned int    pgo_maxlaundry;
 247         uint64_t        pgo_tid;        /* thread ID of I/O thread that services this queue */
 248         uint8_t         pgo_lowpriority; /* iothread is set to use low priority I/O */
 249
 250         unsigned int    pgo_idle:1,     /* iothread is blocked waiting for work to do */
 251                         pgo_busy:1,     /* iothread is currently processing request from pgo_pending */
 252                         pgo_throttled:1,/* vm_pageout_scan thread needs a wakeup when pgo_laundry drops */
 253                         pgo_draining:1,
 254                         pgo_inited:1,
 255                         :0;
 256 };
 257
 258 #define VM_PAGE_Q_THROTTLED(q)          \
 259         ((q)->pgo_laundry >= (q)->pgo_maxlaundry)
 260
 261 extern struct   vm_pageout_queue        vm_pageout_queue_internal;
 262 extern struct   vm_pageout_queue        vm_pageout_queue_external;
 263
 264
 265 /*
 266  *      Routines exported to Mach.
 267  */
 268 extern void             vm_pageout(void);
 269
 270 extern kern_return_t    vm_pageout_internal_start(void);
 271
 272 extern void             vm_pageout_object_terminate(
 273                                         vm_object_t     object);
 274
 275 extern void             vm_pageout_cluster(
 276                                         vm_page_t       m);
 277
 278 extern void             vm_pageout_initialize_page(
 279                                         vm_page_t       m);
 280
 281 /* UPL exported routines and structures */
 282
 283 #define upl_lock_init(object)   lck_mtx_init(&(object)->Lock, &vm_object_lck_grp, &vm_object_lck_attr)
 284 #define upl_lock_destroy(object)        lck_mtx_destroy(&(object)->Lock, &vm_object_lck_grp)
 285 #define upl_lock(object)        lck_mtx_lock(&(object)->Lock)
 286 #define upl_unlock(object)      lck_mtx_unlock(&(object)->Lock)
 287 #define upl_try_lock(object)    lck_mtx_try_lock(&(object)->Lock)
 288
 289 #define MAX_VECTOR_UPL_ELEMENTS 8
 290
 291 struct _vector_upl_iostates{
 292         upl_offset_t offset;
 293         upl_size_t   size;
 294 };
 295
 296 typedef struct _vector_upl_iostates vector_upl_iostates_t;
 297
 298 struct _vector_upl {
 299         upl_size_t              size;
 300         uint32_t                num_upls;
 301         uint32_t                invalid_upls;
 302         uint32_t                _reserved;
 303         vm_map_t                submap;
 304         vm_offset_t             submap_dst_addr;
 305         vm_object_offset_t      offset;
 306         upl_t                   upl_elems[MAX_VECTOR_UPL_ELEMENTS];
 307         upl_page_info_array_t   pagelist;
 308         vector_upl_iostates_t   upl_iostates[MAX_VECTOR_UPL_ELEMENTS];
 309 };
 310
 311 typedef struct _vector_upl* vector_upl_t;
 312
 313 /* universal page list structure */
 314
 315 #if UPL_DEBUG
 316 #define UPL_DEBUG_STACK_FRAMES  16
 317 #define UPL_DEBUG_COMMIT_RECORDS 4
 318
 319 struct ucd {
 320         upl_offset_t    c_beg;
 321         upl_offset_t    c_end;
 322         int             c_aborted;
 323         void *          c_retaddr[UPL_DEBUG_STACK_FRAMES];
 324 };
 325 #endif
 326
 327
 328 struct upl {
 329         decl_lck_mtx_data(,     Lock)   /* Synchronization */
 330         int             ref_count;
 331         int             ext_ref_count;
 332         int             flags;
 333         vm_object_offset_t offset;
 334         upl_size_t      size;       /* size in bytes of the address space */
 335         vm_offset_t     kaddr;      /* secondary mapping in kernel */
 336         vm_object_t     map_object;
 337         ppnum_t         highest_page;
 338         void*           vector_upl;
 339         upl_t           associated_upl;
 340 #if CONFIG_IOSCHED
 341         int             upl_priority;
 342         uint64_t        *upl_reprio_info;
 343         void            *decmp_io_upl;
 344 #endif
 345 #if CONFIG_IOSCHED || UPL_DEBUG
 346         thread_t        upl_creator;
 347         queue_chain_t   uplq;       /* List of outstanding upls on an obj */
 348 #endif
 349 #if     UPL_DEBUG
 350         uintptr_t       ubc_alias1;
 351         uintptr_t       ubc_alias2;
 352
 353         uint32_t        upl_state;
 354         uint32_t        upl_commit_index;
 355         void    *upl_create_retaddr[UPL_DEBUG_STACK_FRAMES];
 356
 357         struct  ucd     upl_commit_records[UPL_DEBUG_COMMIT_RECORDS];
 358 #endif  /* UPL_DEBUG */
 359 };
 360
 361 /* upl struct flags */
 362 #define UPL_PAGE_LIST_MAPPED    0x1
 363 #define UPL_KERNEL_MAPPED       0x2
 364 #define UPL_CLEAR_DIRTY         0x4
 365 #define UPL_COMPOSITE_LIST      0x8
 366 #define UPL_INTERNAL            0x10
 367 #define UPL_PAGE_SYNC_DONE      0x20
 368 #define UPL_DEVICE_MEMORY       0x40
 369 #define UPL_PAGEOUT             0x80
 370 #define UPL_LITE                0x100
 371 #define UPL_IO_WIRE             0x200
 372 #define UPL_ACCESS_BLOCKED      0x400
 373 #define UPL_SHADOWED            0x1000
 374 #define UPL_KERNEL_OBJECT       0x2000
 375 #define UPL_VECTOR              0x4000
 376 #define UPL_SET_DIRTY           0x8000
 377 #define UPL_HAS_BUSY            0x10000
 378 #define UPL_TRACKED_BY_OBJECT   0x20000
 379 #define UPL_EXPEDITE_SUPPORTED  0x40000
 380 #define UPL_DECMP_REQ           0x80000
 381 #define UPL_DECMP_REAL_IO       0x100000
 382
 383 /* flags for upl_create flags parameter */
 384 #define UPL_CREATE_EXTERNAL     0
 385 #define UPL_CREATE_INTERNAL     0x1
 386 #define UPL_CREATE_LITE         0x2
 387 #define UPL_CREATE_IO_TRACKING  0x4
 388 #define UPL_CREATE_EXPEDITE_SUP 0x8
 389
 390 extern upl_t vector_upl_create(vm_offset_t);
 391 extern void vector_upl_deallocate(upl_t);
 392 extern boolean_t vector_upl_is_valid(upl_t);
 393 extern boolean_t vector_upl_set_subupl(upl_t, upl_t, u_int32_t);
 394 extern void vector_upl_set_pagelist(upl_t);
 395 extern void vector_upl_set_submap(upl_t, vm_map_t, vm_offset_t);
 396 extern void vector_upl_get_submap(upl_t, vm_map_t*, vm_offset_t*);
 397 extern void vector_upl_set_iostate(upl_t, upl_t, upl_offset_t, upl_size_t);
 398 extern void vector_upl_get_iostate(upl_t, upl_t, upl_offset_t*, upl_size_t*);
 399 extern void vector_upl_get_iostate_byindex(upl_t, uint32_t, upl_offset_t*, upl_size_t*);
 400 extern upl_t vector_upl_subupl_byindex(upl_t , uint32_t);
 401 extern upl_t vector_upl_subupl_byoffset(upl_t , upl_offset_t*, upl_size_t*);
 402
 403 extern void vm_object_set_pmap_cache_attr(
 404                 vm_object_t             object,
 405                 upl_page_info_array_t   user_page_list,
 406                 unsigned int            num_pages,
 407                 boolean_t               batch_pmap_op);
 408
 409 extern kern_return_t vm_object_iopl_request(
 410         vm_object_t             object,
 411         vm_object_offset_t      offset,
 412         upl_size_t              size,
 413         upl_t                   *upl_ptr,
 414         upl_page_info_array_t   user_page_list,
 415         unsigned int            *page_list_count,
 416         upl_control_flags_t     cntrl_flags,
 417         vm_tag_t            tag);
 418
 419 extern kern_return_t vm_object_super_upl_request(
 420         vm_object_t             object,
 421         vm_object_offset_t      offset,
 422         upl_size_t              size,
 423         upl_size_t              super_cluster,
 424         upl_t                   *upl,
 425         upl_page_info_t         *user_page_list,
 426         unsigned int            *page_list_count,
 427         upl_control_flags_t     cntrl_flags,
 428         vm_tag_t            tag);
 429
 430 /* should be just a regular vm_map_enter() */
 431 extern kern_return_t vm_map_enter_upl(
 432         vm_map_t                map,
 433         upl_t                   upl,
 434         vm_map_offset_t         *dst_addr);
 435
 436 /* should be just a regular vm_map_remove() */
 437 extern kern_return_t vm_map_remove_upl(
 438         vm_map_t                map,
 439         upl_t                   upl);
 440
 441 /* wired  page list structure */
 442 typedef uint32_t *wpl_array_t;
 443
 444 extern void vm_page_free_reserve(int pages);
 445
 446 extern void vm_pageout_throttle_down(vm_page_t page);
 447 extern void vm_pageout_throttle_up(vm_page_t page);
 448
 449 extern kern_return_t vm_paging_map_object(
 450         vm_page_t               page,
 451         vm_object_t             object,
 452         vm_object_offset_t      offset,
 453         vm_prot_t               protection,
 454         boolean_t               can_unlock_object,
 455         vm_map_size_t           *size,          /* IN/OUT */
 456         vm_map_offset_t         *address,       /* OUT */
 457         boolean_t               *need_unmap);   /* OUT */
 458 extern void vm_paging_unmap_object(
 459         vm_object_t             object,
 460         vm_map_offset_t         start,
 461         vm_map_offset_t         end);
 462 decl_simple_lock_data(extern, vm_paging_lock)
 463
 464 /*
 465  * Backing store throttle when BS is exhausted
 466  */
 467 extern unsigned int    vm_backing_store_low;
 468
 469 extern void vm_pageout_steal_laundry(
 470         vm_page_t page,
 471         boolean_t queues_locked);
 472
 473 extern boolean_t vm_page_is_slideable(vm_page_t m);
 474
 475 extern kern_return_t vm_page_slide(vm_page_t page, vm_map_offset_t kernel_mapping_offset);
 476 #endif  /* MACH_KERNEL_PRIVATE */
 477
 478 #if UPL_DEBUG
 479 extern kern_return_t  upl_ubc_alias_set(
 480         upl_t upl,
 481         uintptr_t alias1,
 482         uintptr_t alias2);
 483 extern int  upl_ubc_alias_get(
 484         upl_t upl,
 485         uintptr_t * al,
 486         uintptr_t * al2);
 487 #endif /* UPL_DEBUG */
 488
 489 extern void vm_countdirtypages(void);
 490
 491 extern void vm_backing_store_disable(
 492                         boolean_t       suspend);
 493
 494 extern kern_return_t upl_transpose(
 495         upl_t   upl1,
 496         upl_t   upl2);
 497
 498 extern kern_return_t mach_vm_pressure_monitor(
 499         boolean_t       wait_for_pressure,
 500         unsigned int    nsecs_monitored,
 501         unsigned int    *pages_reclaimed_p,
 502         unsigned int    *pages_wanted_p);
 503
 504 extern kern_return_t
 505 vm_set_buffer_cleanup_callout(
 506         boolean_t       (*func)(int));
 507
 508 struct vm_page_stats_reusable {
 509         SInt32          reusable_count;
 510         uint64_t        reusable;
 511         uint64_t        reused;
 512         uint64_t        reused_wire;
 513         uint64_t        reused_remove;
 514         uint64_t        all_reusable_calls;
 515         uint64_t        partial_reusable_calls;
 516         uint64_t        all_reuse_calls;
 517         uint64_t        partial_reuse_calls;
 518         uint64_t        reusable_pages_success;
 519         uint64_t        reusable_pages_failure;
 520         uint64_t        reusable_pages_shared;
 521         uint64_t        reuse_pages_success;
 522         uint64_t        reuse_pages_failure;
 523         uint64_t        can_reuse_success;
 524         uint64_t        can_reuse_failure;
 525         uint64_t        reusable_reclaimed;
 526         uint64_t        reusable_nonwritable;
 527         uint64_t        reusable_shared;
 528         uint64_t        free_shared;
 529 };
 530 extern struct vm_page_stats_reusable vm_page_stats_reusable;
 531
 532 extern int hibernate_flush_memory(void);
 533 extern void hibernate_reset_stats(void);
 534 extern void hibernate_create_paddr_map(void);
 535
 536 extern void vm_set_restrictions(void);
 537
 538 extern int vm_compressor_mode;
 539 extern int vm_compressor_thread_count;
 540 extern boolean_t vm_restricted_to_single_processor;
 541 extern kern_return_t vm_pageout_compress_page(void **, char *, vm_page_t, boolean_t);
 542 extern void vm_pageout_anonymous_pages(void);
 543 extern void vm_pageout_disconnect_all_pages(void);
 544
 545
 546 struct  vm_config {
 547         boolean_t       compressor_is_present;          /* compressor is initialized and can be used by the freezer, the sweep or the pager */
 548         boolean_t       compressor_is_active;           /* pager can actively compress pages...  'compressor_is_present' must be set */
 549         boolean_t       swap_is_present;                /* swap is initialized and can be used by the freezer, the sweep or the pager */
 550         boolean_t       swap_is_active;                 /* pager can actively swap out compressed segments... 'swap_is_present' must be set */
 551         boolean_t       freezer_swap_is_active;         /* freezer can swap out frozen tasks... "compressor_is_present + swap_is_present" must be set */
 552 };
 553
 554 extern  struct vm_config        vm_config;
 555
 556
 557 #define VM_PAGER_NOT_CONFIGURED                         0x0     /* no compresser or swap configured */
 558 #define VM_PAGER_DEFAULT                                0x1     /* Use default pager... DEPRECATED */
 559 #define VM_PAGER_COMPRESSOR_NO_SWAP                     0x2     /* Active in-core compressor only. */
 560 #define VM_PAGER_COMPRESSOR_WITH_SWAP                   0x4     /* Active in-core compressor + swap backend. */
 561 #define VM_PAGER_FREEZER_DEFAULT                        0x8     /* Freezer backed by default pager... DEPRECATED */
 562 #define VM_PAGER_FREEZER_COMPRESSOR_NO_SWAP             0x10    /* Freezer backed by in-core compressor only i.e. frozen data remain in-core compressed.*/
 563 #define VM_PAGER_COMPRESSOR_NO_SWAP_PLUS_FREEZER_COMPRESSOR_WITH_SWAP   0x20    /* Active in-core compressor + Freezer backed by in-core compressor with swap support too.*/
 564
 565 #define VM_PAGER_MAX_MODES                              6       /* Total number of vm compressor modes supported */
 566
 567
 568 #define VM_CONFIG_COMPRESSOR_IS_PRESENT         (vm_config.compressor_is_present == TRUE)
 569 #define VM_CONFIG_COMPRESSOR_IS_ACTIVE          (vm_config.compressor_is_active == TRUE)
 570 #define VM_CONFIG_SWAP_IS_PRESENT               (vm_config.swap_is_present == TRUE)
 571 #define VM_CONFIG_SWAP_IS_ACTIVE                (vm_config.swap_is_active == TRUE)
 572 #define VM_CONFIG_FREEZER_SWAP_IS_ACTIVE        (vm_config.freezer_swap_is_active == TRUE)
 573
 574 #endif  /* KERNEL_PRIVATE */
 575
 576 #ifdef XNU_KERNEL_PRIVATE
 577 #define MAX_COMPRESSOR_THREAD_COUNT      8
 578
 579 #if DEVELOPMENT || DEBUG
 580 typedef struct vmct_stats_s {
 581         uint64_t vmct_runtimes[MAX_COMPRESSOR_THREAD_COUNT];
 582         uint64_t vmct_pages[MAX_COMPRESSOR_THREAD_COUNT];
 583         uint64_t vmct_iterations[MAX_COMPRESSOR_THREAD_COUNT];
 584         uint64_t vmct_cthreads_total;
 585         int32_t vmct_minpages[MAX_COMPRESSOR_THREAD_COUNT];
 586         int32_t vmct_maxpages[MAX_COMPRESSOR_THREAD_COUNT];
 587 } vmct_stats_t;
 588 #endif
 589 #endif
 590 #endif  /* _VM_VM_PAGEOUT_H_ */