bsd/sys/kern_memorystatus.h

   1 /*
   2  * Copyright (c) 2006 Apple Computer, 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 #ifndef SYS_MEMORYSTATUS_H
  30 #define SYS_MEMORYSTATUS_H
  31
  32 #include <stdint.h>
  33 #include <sys/time.h>
  34 #include <sys/proc.h>
  35 #include <sys/param.h>
  36
  37 #define JETSAM_PRIORITY_REVISION                  2
  38
  39 #define JETSAM_PRIORITY_IDLE_HEAD                -2
  40 /* The value -1 is an alias to JETSAM_PRIORITY_DEFAULT */
  41 #define JETSAM_PRIORITY_IDLE                      0
  42 #define JETSAM_PRIORITY_IDLE_DEFERRED             1
  43 #define JETSAM_PRIORITY_BACKGROUND_OPPORTUNISTIC  2
  44 #define JETSAM_PRIORITY_BACKGROUND                3
  45 #define JETSAM_PRIORITY_MAIL                      4
  46 #define JETSAM_PRIORITY_PHONE                     5
  47 #define JETSAM_PRIORITY_UI_SUPPORT                8
  48 #define JETSAM_PRIORITY_FOREGROUND_SUPPORT        9
  49 #define JETSAM_PRIORITY_FOREGROUND               10
  50 #define JETSAM_PRIORITY_AUDIO_AND_ACCESSORY      12
  51 #define JETSAM_PRIORITY_CONDUCTOR                13
  52 #define JETSAM_PRIORITY_HOME                     16
  53 #define JETSAM_PRIORITY_EXECUTIVE                17
  54 #define JETSAM_PRIORITY_IMPORTANT                18
  55 #define JETSAM_PRIORITY_CRITICAL                 19
  56
  57 #define JETSAM_PRIORITY_MAX                      21
  58
  59 /* TODO - tune. This should probably be lower priority */
  60 #define JETSAM_PRIORITY_DEFAULT                  18
  61 #define JETSAM_PRIORITY_TELEPHONY                19
  62
  63 /* Compatibility */
  64 #define DEFAULT_JETSAM_PRIORITY                  18
  65
  66 #define DEFERRED_IDLE_EXIT_TIME_SECS             10
  67
  68 #define KEV_MEMORYSTATUS_SUBCLASS                 3
  69
  70 enum {
  71         kMemorystatusLevelNote = 1,
  72         kMemorystatusSnapshotNote = 2,
  73         kMemorystatusFreezeNote = 3,
  74         kMemorystatusPressureNote = 4
  75 };
  76
  77 enum {
  78         kMemorystatusLevelAny = -1,
  79         kMemorystatusLevelNormal = 0,
  80         kMemorystatusLevelWarning = 1,
  81         kMemorystatusLevelUrgent = 2,
  82         kMemorystatusLevelCritical = 3
  83 };
  84
  85 typedef struct memorystatus_priority_entry {
  86         pid_t pid;
  87         int32_t priority;
  88         uint64_t user_data;
  89         int32_t limit;
  90         uint32_t state;
  91 } memorystatus_priority_entry_t;
  92
  93 typedef struct memorystatus_kernel_stats {
  94         uint32_t free_pages;
  95         uint32_t active_pages;
  96         uint32_t inactive_pages;
  97         uint32_t throttled_pages;
  98         uint32_t purgeable_pages;
  99         uint32_t wired_pages;
 100         uint32_t speculative_pages;
 101         uint32_t filebacked_pages;
 102         uint32_t anonymous_pages;
 103         uint32_t compressor_pages;
 104         uint64_t compressions;
 105         uint64_t decompressions;
 106         uint64_t total_uncompressed_pages_in_compressor;
 107 } memorystatus_kernel_stats_t;
 108
 109 /*
 110 ** This is a variable-length struct.
 111 ** Allocate a buffer of the size returned by the sysctl, cast to a memorystatus_snapshot_t *
 112 */
 113
 114 typedef struct jetsam_snapshot_entry {
 115         pid_t    pid;
 116         char     name[MAXCOMLEN+1];
 117         int32_t  priority;
 118         uint32_t pages;
 119         uint32_t max_pages;
 120         uint32_t state;
 121         uint32_t killed;
 122         uint64_t user_data;
 123         uint8_t  uuid[16];
 124         uint32_t fds;
 125         uint32_t max_pages_lifetime;
 126         uint32_t purgeable_pages;
 127         struct timeval cpu_time;
 128 } memorystatus_jetsam_snapshot_entry_t;
 129
 130 typedef struct jetsam_snapshot {
 131         uint64_t snapshot_time;
 132         uint64_t notification_time;
 133         memorystatus_kernel_stats_t stats;
 134         size_t entry_count;
 135         memorystatus_jetsam_snapshot_entry_t entries[];
 136 } memorystatus_jetsam_snapshot_t;
 137
 138 typedef struct memorystatus_freeze_entry {
 139         int32_t pid;
 140         uint32_t flags;
 141         uint32_t pages;
 142 } memorystatus_freeze_entry_t;
 143
 144 /* TODO - deprecate; see <rdar://problem/12969599> */
 145 #define kMaxSnapshotEntries 192
 146
 147 /* State */
 148 #define kMemorystatusSuspended        0x01
 149 #define kMemorystatusFrozen           0x02
 150 #define kMemorystatusWasThawed        0x04
 151 #define kMemorystatusTracked          0x08
 152 #define kMemorystatusSupportsIdleExit 0x10
 153 #define kMemorystatusDirty            0x20
 154
 155 /* Cause */
 156 enum {
 157         kMemorystatusKilled = 1,
 158         kMemorystatusKilledHiwat,
 159         kMemorystatusKilledVnodes,
 160         kMemorystatusKilledVMPageShortage,
 161         kMemorystatusKilledVMThrashing,
 162         kMemorystatusKilledFCThrashing,
 163         kMemorystatusKilledPerProcessLimit,
 164         kMemorystatusKilledDiagnostic,
 165         kMemorystatusKilledIdleExit
 166 };
 167
 168 /* Temporary, to prevent the need for a linked submission of ReportCrash */
 169 /* Remove when <rdar://problem/13210532> has been integrated */
 170 enum {
 171         kMemorystatusKilledVM = kMemorystatusKilledVMPageShortage
 172 };
 173
 174 /* Memorystatus control */
 175 #define MEMORYSTATUS_BUFFERSIZE_MAX 65536
 176
 177 #ifndef KERNEL
 178 int memorystatus_get_level(user_addr_t level);
 179 int memorystatus_control(uint32_t command, int32_t pid, uint32_t flags, void *buffer, size_t buffersize);
 180 #endif
 181
 182 /* Commands */
 183 #define MEMORYSTATUS_CMD_GET_PRIORITY_LIST            1
 184 #define MEMORYSTATUS_CMD_SET_PRIORITY_PROPERTIES      2
 185 #define MEMORYSTATUS_CMD_GET_JETSAM_SNAPSHOT          3
 186 #define MEMORYSTATUS_CMD_GET_PRESSURE_STATUS          4
 187 #define MEMORYSTATUS_CMD_SET_JETSAM_HIGH_WATER_MARK   5    /* Set active memory limit = inactive memory limit, both non-fatal   */
 188 #define MEMORYSTATUS_CMD_SET_JETSAM_TASK_LIMIT        6    /* Set active memory limit = inactive memory limit, both fatal       */
 189 #define MEMORYSTATUS_CMD_SET_MEMLIMIT_PROPERTIES      7    /* Set memory limits plus attributes independently                   */
 190 #define MEMORYSTATUS_CMD_GET_MEMLIMIT_PROPERTIES      8    /* Get memory limits plus attributes                                 */
 191 #define MEMORYSTATUS_CMD_PRIVILEGED_LISTENER_ENABLE   9    /* Set the task's status as a privileged listener w.r.t memory notifications  */
 192 #define MEMORYSTATUS_CMD_PRIVILEGED_LISTENER_DISABLE  10   /* Reset the task's status as a privileged listener w.r.t memory notifications  */
 193 /* Commands that act on a group of processes */
 194 #define MEMORYSTATUS_CMD_GRP_SET_PROPERTIES           100
 195
 196 #if PRIVATE
 197 /* Test commands */
 198
 199 /* Trigger forced jetsam */
 200 #define MEMORYSTATUS_CMD_TEST_JETSAM            1000
 201 #define MEMORYSTATUS_CMD_TEST_JETSAM_SORT       1001
 202
 203 /* Panic on jetsam options */
 204 typedef struct memorystatus_jetsam_panic_options {
 205         uint32_t data;
 206         uint32_t mask;
 207 } memorystatus_jetsam_panic_options_t;
 208
 209 #define MEMORYSTATUS_CMD_SET_JETSAM_PANIC_BITS        1002
 210
 211 /* Select priority band sort order */
 212 #define JETSAM_SORT_NOSORT      0
 213 #define JETSAM_SORT_DEFAULT     1
 214
 215 #endif /* PRIVATE */
 216
 217 /*
 218  * For use with memorystatus_control:
 219  * MEMORYSTATUS_CMD_GET_JETSAM_SNAPSHOT
 220  *
 221  * A jetsam snapshot is initialized when a non-idle
 222  * jetsam event occurs.  The data is held in the
 223  * buffer until it is reaped. This is the default
 224  * behavior.
 225  *
 226  * Flags change the default behavior:
 227  *      Demand mode - this is an on_demand snapshot,
 228  *      meaning data is populated upon request.
 229  *
 230  *      Boot mode - this is a snapshot of
 231  *      memstats collected before loading the
 232  *      init program.  Once collected, these
 233  *      stats do not change.  In this mode,
 234  *      the snapshot entry_count is always 0.
 235  *
 236  * Snapshots are inherently racey between request
 237  * for buffer size and actual data compilation.
 238 */
 239
 240 /* Flags */
 241 #define MEMORYSTATUS_SNAPSHOT_ON_DEMAND         0x1     /* A populated snapshot buffer is returned on demand */
 242 #define MEMORYSTATUS_SNAPSHOT_AT_BOOT           0x2     /* Returns a snapshot with memstats collected at boot */
 243
 244
 245 /*
 246  * For use with memorystatus_control:
 247  * MEMORYSTATUS_CMD_SET_PRIORITY_PROPERTIES
 248  */
 249 typedef struct memorystatus_priority_properties {
 250         int32_t  priority;
 251         uint64_t user_data;
 252 } memorystatus_priority_properties_t;
 253
 254 /*
 255  * For use with memorystatus_control:
 256  * MEMORYSTATUS_CMD_SET_MEMLIMIT_PROPERTIES
 257  * MEMORYSTATUS_CMD_GET_MEMLIMIT_PROPERTIES
 258  */
 259 typedef struct memorystatus_memlimit_properties {
 260         int32_t memlimit_active;                /* jetsam memory limit (in MB) when process is active */
 261         uint32_t memlimit_active_attr;
 262         int32_t memlimit_inactive;              /* jetsam memory limit (in MB) when process is inactive */
 263         uint32_t memlimit_inactive_attr;
 264 } memorystatus_memlimit_properties_t;
 265
 266 #define MEMORYSTATUS_MEMLIMIT_ATTR_FATAL        0x1     /* if set, exceeding the memlimit is fatal */
 267
 268
 269 #ifdef XNU_KERNEL_PRIVATE
 270
 271 /*
 272  * A process will be killed immediately if it crosses a memory limit marked as fatal.
 273  * Fatal limit types are the
 274  *      - default system-wide task limit
 275  *      - per-task custom memory limit
 276  *
 277  * A process with a non-fatal memory limit can exceed that limit, but becomes an early
 278  * candidate for jetsam when the device is under memory pressure.
 279  * Non-fatal limit types are the
 280  *      - high-water-mark limit
 281  *
 282  * P_MEMSTAT_MEMLIMIT_BACKGROUND is translated in posix_spawn as
 283  *      the fatal system_wide task limit when active
 284  *      non-fatal inactive limit based on limit provided.
 285  *      This is necessary for backward compatibility until the
 286  *      the flag can be considered obsolete.
 287  *
 288  * Processes that opt into dirty tracking are evaluated
 289  * based on clean vs dirty state.
 290  *      dirty ==> active
 291  *      clean ==> inactive
 292  *
 293  * Processes that do not opt into dirty tracking are
 294  * evalulated based on priority level.
 295  *      Foreground or above ==> active
 296  *      Below Foreground    ==> inactive
 297  */
 298
 299 /*
 300  * p_memstat_state flag holds
 301  *      - in kernel process state and memlimit state
 302  */
 303
 304 #define P_MEMSTAT_SUSPENDED            0x00000001
 305 #define P_MEMSTAT_FROZEN               0x00000002
 306 #define P_MEMSTAT_NORECLAIM            0x00000004
 307 #define P_MEMSTAT_ERROR                0x00000008
 308 #define P_MEMSTAT_LOCKED               0x00000010
 309 #define P_MEMSTAT_TERMINATED           0x00000020
 310 #define P_MEMSTAT_NOTFIED              0x00000040
 311 #define P_MEMSTAT_PRIORITYUPDATED      0x00000080
 312 #define P_MEMSTAT_FOREGROUND           0x00000100
 313 #define P_MEMSTAT_DIAG_SUSPENDED       0x00000200
 314 #define P_MEMSTAT_PRIOR_THAW           0x00000400
 315 #define P_MEMSTAT_MEMLIMIT_BACKGROUND  0x00000800 /* Task has a memory limit for when it's in the background. Used for a process' "high water mark".*/
 316 #define P_MEMSTAT_INTERNAL             0x00001000
 317 #define P_MEMSTAT_FATAL_MEMLIMIT                  0x00002000   /* current fatal state of the process's memlimit */
 318 #define P_MEMSTAT_MEMLIMIT_ACTIVE_FATAL           0x00004000   /* if set, exceeding limit is fatal when the process is active   */
 319 #define P_MEMSTAT_MEMLIMIT_ACTIVE_EXC_TRIGGERED   0x00008000   /* if set, supresses high-water-mark EXC_RESOURCE, allows one hit per active limit */
 320 #define P_MEMSTAT_MEMLIMIT_INACTIVE_FATAL         0x00010000   /* if set, exceeding limit is fatal when the process is inactive */
 321 #define P_MEMSTAT_MEMLIMIT_INACTIVE_EXC_TRIGGERED 0x00020000   /* if set, supresses high-water-mark EXC_RESOURCE, allows one hit per inactive limit */
 322
 323 extern void memorystatus_init(void) __attribute__((section("__TEXT, initcode")));
 324
 325 extern void memorystatus_init_at_boot_snapshot(void);
 326
 327 extern int memorystatus_add(proc_t p, boolean_t locked);
 328 extern int memorystatus_update(proc_t p, int priority, uint64_t user_data, boolean_t effective,
 329                                boolean_t update_memlimit, int32_t memlimit_active, boolean_t memlimit_active_is_fatal,
 330                                int32_t memlimit_inactive, boolean_t memlimit_inactive_is_fatal, boolean_t memlimit_background);
 331
 332 extern int memorystatus_remove(proc_t p, boolean_t locked);
 333
 334 extern int memorystatus_dirty_track(proc_t p, uint32_t pcontrol);
 335 extern int memorystatus_dirty_set(proc_t p, boolean_t self, uint32_t pcontrol);
 336 extern int memorystatus_dirty_get(proc_t p);
 337 extern int memorystatus_dirty_clear(proc_t p, uint32_t pcontrol);
 338
 339 extern int memorystatus_on_terminate(proc_t p);
 340
 341 extern void memorystatus_on_suspend(proc_t p);
 342 extern void memorystatus_on_resume(proc_t p);
 343 extern void memorystatus_on_inactivity(proc_t p);
 344
 345 extern void memorystatus_on_pageout_scan_end(void);
 346
 347 /* Memorystatus kevent */
 348
 349 void memorystatus_kevent_init(lck_grp_t *grp, lck_attr_t *attr);
 350
 351 int memorystatus_knote_register(struct knote *kn);
 352 void memorystatus_knote_unregister(struct knote *kn);
 353
 354 #if CONFIG_JETSAM
 355
 356 int memorystatus_get_pressure_status_kdp(void);
 357
 358 typedef enum memorystatus_policy {
 359         kPolicyDefault        = 0x0,
 360         kPolicyMoreFree       = 0x1,
 361         kPolicyDiagnoseAll    = 0x2,
 362         kPolicyDiagnoseFirst  = 0x4,
 363         kPolicyDiagnoseActive = (kPolicyDiagnoseAll | kPolicyDiagnoseFirst),
 364 } memorystatus_policy_t;
 365
 366 extern int memorystatus_jetsam_wakeup;
 367 extern unsigned int memorystatus_jetsam_running;
 368
 369 boolean_t memorystatus_kill_on_VM_page_shortage(boolean_t async);
 370 boolean_t memorystatus_kill_on_VM_thrashing(boolean_t async);
 371 boolean_t memorystatus_kill_on_FC_thrashing(boolean_t async);
 372 boolean_t memorystatus_kill_on_vnode_limit(void);
 373
 374 void memorystatus_on_ledger_footprint_exceeded(int warning, const int max_footprint_mb);
 375 void proc_memstat_terminated(proc_t p, boolean_t set);
 376 void jetsam_on_ledger_cpulimit_exceeded(void);
 377
 378 void memorystatus_pages_update(unsigned int pages_avail);
 379
 380 #else /* CONFIG_JETSAM */
 381
 382 boolean_t memorystatus_idle_exit_from_VM(void);
 383
 384 #endif /* !CONFIG_JETSAM */
 385
 386 #ifdef CONFIG_FREEZE
 387
 388 #define FREEZE_PAGES_MIN   ( 1 * 1024 * 1024 / PAGE_SIZE)
 389 #define FREEZE_PAGES_MAX   (16 * 1024 * 1024 / PAGE_SIZE)
 390
 391 #define FREEZE_SUSPENDED_THRESHOLD_LOW     2
 392 #define FREEZE_SUSPENDED_THRESHOLD_DEFAULT 4
 393
 394 #define FREEZE_DAILY_MB_MAX_DEFAULT       1024
 395
 396 typedef struct throttle_interval_t {
 397         uint32_t mins;
 398         uint32_t burst_multiple;
 399         uint32_t pageouts;
 400         uint32_t max_pageouts;
 401         mach_timespec_t ts;
 402         boolean_t throttle;
 403 } throttle_interval_t;
 404
 405 extern boolean_t memorystatus_freeze_enabled;
 406 extern int memorystatus_freeze_wakeup;
 407
 408 extern void memorystatus_freeze_init(void) __attribute__((section("__TEXT, initcode")));
 409 extern int  memorystatus_freeze_process_sync(proc_t p);
 410 #endif /* CONFIG_FREEZE */
 411
 412 #if VM_PRESSURE_EVENTS
 413
 414 extern kern_return_t memorystatus_update_vm_pressure(boolean_t);
 415
 416 #if CONFIG_MEMORYSTATUS
 417 /* Flags */
 418 extern int memorystatus_low_mem_privileged_listener(uint32_t op_flags);
 419 extern int memorystatus_send_pressure_note(int pid);
 420 extern boolean_t memorystatus_is_foreground_locked(proc_t p);
 421 extern boolean_t memorystatus_bg_pressure_eligible(proc_t p);
 422 #endif /* CONFIG_MEMORYSTATUS */
 423
 424 #endif /* VM_PRESSURE_EVENTS */
 425
 426 #endif /* XNU_KERNEL_PRIVATE */
 427
 428 #endif /* SYS_MEMORYSTATUS_H */