xnu-3247.10.11.tar.gz

[apple/xnu.git] / bsd / kern / vm_pressure.c

/*
 * Copyright (c) 2009-2010 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#include <libkern/libkern.h>
#include <mach/mach_types.h>
#include <mach/task.h>
#include <sys/proc_internal.h>
#include <sys/event.h>
#include <sys/eventvar.h>
#include <kern/locks.h>
#include <sys/queue.h>
#include <kern/vm_pressure.h>
#include <sys/malloc.h>
#include <sys/errno.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/sysctl.h>
#include <kern/assert.h>
#include <kern/task.h>
#include <vm/vm_pageout.h>

#include <kern/task.h>

#if CONFIG_MEMORYSTATUS
#include <sys/kern_memorystatus.h>
#endif

/* 
 * This value is the threshold that a process must meet to be considered for scavenging.
 */
#define VM_PRESSURE_MINIMUM_RSIZE		10	/* MB */

#define VM_PRESSURE_NOTIFY_WAIT_PERIOD		10000	/* milliseconds */

void vm_pressure_klist_lock(void);
void vm_pressure_klist_unlock(void);

static void vm_dispatch_memory_pressure(void);
void vm_reset_active_list(void);

#if CONFIG_MEMORYSTATUS
static kern_return_t vm_try_pressure_candidates(boolean_t target_foreground_process);
#endif

static lck_mtx_t vm_pressure_klist_mutex;

struct klist vm_pressure_klist;
struct klist vm_pressure_klist_dormant;

#if DEBUG
#define VM_PRESSURE_DEBUG(cond, format, ...)      \
do {                                              \
	if (cond) { printf(format, ##__VA_ARGS__); } \
} while(0)
#else
#define VM_PRESSURE_DEBUG(cond, format, ...)
#endif

void vm_pressure_init(lck_grp_t *grp, lck_attr_t *attr) {
	lck_mtx_init(&vm_pressure_klist_mutex, grp, attr);
}

void vm_pressure_klist_lock(void) {
	lck_mtx_lock(&vm_pressure_klist_mutex);
}

void vm_pressure_klist_unlock(void) {
	lck_mtx_unlock(&vm_pressure_klist_mutex);
}

int vm_knote_register(struct knote *kn) {
	int rv = 0;
	
	vm_pressure_klist_lock();
	
	if ((kn->kn_sfflags) & (NOTE_VM_PRESSURE)) {
		KNOTE_ATTACH(&vm_pressure_klist, kn);
	} else {	  
		rv = ENOTSUP;
	}
	
	vm_pressure_klist_unlock();
	
	return rv;
}

void vm_knote_unregister(struct knote *kn) {
	struct knote *kn_temp;
	
	vm_pressure_klist_lock();
	
	VM_PRESSURE_DEBUG(0, "[vm_pressure] process %d cancelling pressure notification\n", kn->kn_kq->kq_p->p_pid);
	
	SLIST_FOREACH(kn_temp, &vm_pressure_klist, kn_selnext) {
		if (kn_temp == kn) {
			KNOTE_DETACH(&vm_pressure_klist, kn);
			vm_pressure_klist_unlock();
			return;
		}
	}

	SLIST_FOREACH(kn_temp, &vm_pressure_klist_dormant, kn_selnext) {
		if (kn_temp == kn) {
			KNOTE_DETACH(&vm_pressure_klist_dormant, kn);
			vm_pressure_klist_unlock();
			return;
		}
	}
	
	vm_pressure_klist_unlock();
}

void vm_pressure_proc_cleanup(proc_t p)
{
	struct knote *kn = NULL;

	vm_pressure_klist_lock();
	
	VM_PRESSURE_DEBUG(0, "[vm_pressure] process %d exiting pressure notification\n", p->p_pid);
	
	SLIST_FOREACH(kn, &vm_pressure_klist, kn_selnext) {
		if (kn->kn_kq->kq_p == p) {
			KNOTE_DETACH(&vm_pressure_klist, kn);
			vm_pressure_klist_unlock();
			return;
		}
	}
	
	SLIST_FOREACH(kn, &vm_pressure_klist_dormant, kn_selnext) {
		if (kn->kn_kq->kq_p == p) {
			KNOTE_DETACH(&vm_pressure_klist_dormant, kn);
			vm_pressure_klist_unlock();
			return;
		}
	}
	
	vm_pressure_klist_unlock();
}

/*
 * Used by the vm_pressure_thread which is
 * signalled from within vm_pageout_scan().
 */
void consider_vm_pressure_events(void)
{
	vm_dispatch_memory_pressure();
}

#if CONFIG_MEMORYSTATUS

/* Jetsam aware version. Called with lock held */

struct knote *vm_find_knote_from_pid(pid_t, struct klist *);

struct knote *vm_find_knote_from_pid(pid_t pid, struct klist *list) {
	struct knote *kn = NULL;
    
	SLIST_FOREACH(kn, list, kn_selnext) {
		struct proc *p;
		pid_t current_pid;

		p = kn->kn_kq->kq_p;
		current_pid = p->p_pid;

		if (current_pid == pid) {
			break;
		}
	}
    
	return kn;
}

int vm_dispatch_pressure_note_to_pid(pid_t pid, boolean_t locked) {
	int ret = EINVAL;
	struct knote *kn;
    
	VM_PRESSURE_DEBUG(1, "vm_dispatch_pressure_note_to_pid(): pid %d\n", pid);
	
	if (!locked) {
		vm_pressure_klist_lock();	    
	}
    
	/* 
	 * Because we're specifically targeting a process here, we don't care
	 * if a warning has already been sent and it's moved to the dormant
	 * list; check that too.
	 */
	kn = vm_find_knote_from_pid(pid, &vm_pressure_klist);
	if (kn) {
    		KNOTE(&vm_pressure_klist, pid);
    		ret = 0;
	} else {	
	        kn = vm_find_knote_from_pid(pid, &vm_pressure_klist_dormant);
	        if (kn) {
        		KNOTE(&vm_pressure_klist_dormant, pid);
			ret = 0;
	        }
	}

	if (!locked) {
		vm_pressure_klist_unlock();	    
	}

	return ret;
}

void vm_find_pressure_foreground_candidates(void)
{
	struct knote *kn, *kn_tmp;
	struct klist dispatch_klist = { NULL };

	vm_pressure_klist_lock();
	proc_list_lock();
	
	/* Find the foreground processes. */
	SLIST_FOREACH_SAFE(kn, &vm_pressure_klist, kn_selnext, kn_tmp) {
		proc_t p = kn->kn_kq->kq_p;

		if (memorystatus_is_foreground_locked(p)) {
			KNOTE_DETACH(&vm_pressure_klist, kn);  
			KNOTE_ATTACH(&dispatch_klist, kn);          
		}
	}

	SLIST_FOREACH_SAFE(kn, &vm_pressure_klist_dormant, kn_selnext, kn_tmp) {
		proc_t p = kn->kn_kq->kq_p;

		if (memorystatus_is_foreground_locked(p)) {
			KNOTE_DETACH(&vm_pressure_klist_dormant, kn);  
			KNOTE_ATTACH(&dispatch_klist, kn);          
		}
	}

	proc_list_unlock();

	/* Dispatch pressure notifications accordingly */
	SLIST_FOREACH_SAFE(kn, &dispatch_klist, kn_selnext, kn_tmp) {
		proc_t p = kn->kn_kq->kq_p;

		proc_list_lock();
		if (p != proc_ref_locked(p)) {
			proc_list_unlock();
			KNOTE_DETACH(&dispatch_klist, kn);
			KNOTE_ATTACH(&vm_pressure_klist_dormant, kn);
			continue;
		}
		proc_list_unlock();
  
		VM_PRESSURE_DEBUG(1, "[vm_pressure] sending event to pid %d\n", kn->kn_kq->kq_p->p_pid);
		KNOTE(&dispatch_klist, p->p_pid);
		KNOTE_DETACH(&dispatch_klist, kn);
		KNOTE_ATTACH(&vm_pressure_klist_dormant, kn);
		microuptime(&p->vm_pressure_last_notify_tstamp);
		memorystatus_send_pressure_note(p->p_pid);
		proc_rele(p);
	}

	vm_pressure_klist_unlock();
}

void vm_find_pressure_candidate(void)
{
	struct knote *kn = NULL, *kn_max = NULL;
	unsigned int resident_max = 0;
	pid_t target_pid = -1;
	struct klist dispatch_klist = { NULL };
	struct timeval curr_tstamp = {0, 0};
	int elapsed_msecs = 0;
	proc_t target_proc = PROC_NULL;
	kern_return_t kr = KERN_SUCCESS;

	microuptime(&curr_tstamp);
	
	vm_pressure_klist_lock();
	
	SLIST_FOREACH(kn, &vm_pressure_klist, kn_selnext) {\
	    struct mach_task_basic_info basic_info;
	    mach_msg_type_number_t  size = MACH_TASK_BASIC_INFO_COUNT;
		unsigned int		resident_size = 0;
		proc_t			p = PROC_NULL;
		struct task*		t = TASK_NULL;

		p = kn->kn_kq->kq_p;
		proc_list_lock();
		if (p != proc_ref_locked(p)) {
			p = PROC_NULL;
			proc_list_unlock();
			continue;
		}
		proc_list_unlock();

		t = (struct task *)(p->task);
		
		timevalsub(&curr_tstamp, &p->vm_pressure_last_notify_tstamp);
		elapsed_msecs = curr_tstamp.tv_sec * 1000 + curr_tstamp.tv_usec / 1000;
							
		if (elapsed_msecs < VM_PRESSURE_NOTIFY_WAIT_PERIOD) {
			proc_rele(p);
			continue;
		}
		
		if (!memorystatus_bg_pressure_eligible(p)) {
			VM_PRESSURE_DEBUG(1, "[vm_pressure] skipping process %d\n", p->p_pid);
			proc_rele(p);
			continue;			
		}

		if( ( kr = task_info(t, MACH_TASK_BASIC_INFO, (task_info_t)(&basic_info), &size)) != KERN_SUCCESS ) {
			VM_PRESSURE_DEBUG(1, "[vm_pressure] task_info for pid %d failed\n", p->p_pid);
			proc_rele(p);
			continue;
		}

		/* 
		 * We don't want a small process to block large processes from 
		 * being notified again. <rdar://problem/7955532>
		 */
		resident_size = (basic_info.resident_size)/(1024 * 1024);
		if (resident_size >= VM_PRESSURE_MINIMUM_RSIZE) {
			if (resident_size > resident_max) {
				resident_max = resident_size;
				kn_max = kn;
				target_pid = p->p_pid;
				target_proc = p;
			}
		} else {
			/* There was no candidate with enough resident memory to scavenge */
			VM_PRESSURE_DEBUG(1, "[vm_pressure] threshold failed for pid %d with %u resident...\n", p->p_pid, resident_size);
		}
		proc_rele(p);
	}

	if (kn_max == NULL || target_pid == -1) {
		VM_PRESSURE_DEBUG(1, "[vm_pressure] - no target found!\n");
		goto exit;
	}

	VM_DEBUG_CONSTANT_EVENT(vm_pressure_event, VM_PRESSURE_EVENT, DBG_FUNC_NONE, target_pid, resident_max, 0, 0);
	VM_PRESSURE_DEBUG(1, "[vm_pressure] sending event to pid %d with %u resident\n", kn_max->kn_kq->kq_p->p_pid, resident_max);

	KNOTE_DETACH(&vm_pressure_klist, kn_max);

	target_proc = proc_find(target_pid);
	if (target_proc != PROC_NULL) {
		KNOTE_ATTACH(&dispatch_klist, kn_max);
		KNOTE(&dispatch_klist, target_pid);
		KNOTE_ATTACH(&vm_pressure_klist_dormant, kn_max);
		memorystatus_send_pressure_note(target_pid);
		microuptime(&target_proc->vm_pressure_last_notify_tstamp);
		proc_rele(target_proc);
	}

exit:
	vm_pressure_klist_unlock();
}
#endif /* CONFIG_MEMORYSTATUS */


struct knote *
vm_pressure_select_optimal_candidate_to_notify(struct klist *candidate_list, int level, boolean_t target_foreground_process);

kern_return_t vm_pressure_notification_without_levels(boolean_t target_foreground_process);
kern_return_t vm_pressure_notify_dispatch_vm_clients(boolean_t target_foreground_process);

kern_return_t
vm_pressure_notify_dispatch_vm_clients(boolean_t target_foreground_process)
{
	vm_pressure_klist_lock();
	
	if (SLIST_EMPTY(&vm_pressure_klist)) {
		vm_reset_active_list();
	}
	
	if (!SLIST_EMPTY(&vm_pressure_klist)) {
		
		VM_PRESSURE_DEBUG(1, "[vm_pressure] vm_dispatch_memory_pressure\n");
		
		if (KERN_SUCCESS == vm_try_pressure_candidates(target_foreground_process)) {
			vm_pressure_klist_unlock();
			return KERN_SUCCESS;
		}
	}
	
	VM_PRESSURE_DEBUG(1, "[vm_pressure] could not find suitable event candidate\n");
	
	vm_pressure_klist_unlock();

	return KERN_FAILURE;
}

static void vm_dispatch_memory_pressure(void)
{
	memorystatus_update_vm_pressure(FALSE);
}

extern vm_pressure_level_t
convert_internal_pressure_level_to_dispatch_level(vm_pressure_level_t);

struct knote *
vm_pressure_select_optimal_candidate_to_notify(struct klist *candidate_list, int level, boolean_t target_foreground_process)
{
	struct knote	*kn = NULL, *kn_max = NULL;
        unsigned int	resident_max = 0;
	struct timeval	curr_tstamp = {0, 0};
	int		elapsed_msecs = 0;
	int		selected_task_importance = 0;
	static int	pressure_snapshot = -1;
	boolean_t	pressure_increase = FALSE;

	if (level != -1) {
	
		if (pressure_snapshot == -1) {
			/*
			 * Initial snapshot.
		 	*/
			pressure_snapshot = level;
			pressure_increase = TRUE;
		} else {
			
			if (level >= pressure_snapshot) {
				pressure_increase = TRUE;
			} else {
				pressure_increase = FALSE;
			}

			pressure_snapshot = level;
		}
	}

	if ((level > 0) && (pressure_increase) == TRUE) {
		/*
		 * We'll start by considering the largest
		 * unimportant task in our list.
		 */
		selected_task_importance = INT_MAX;
	} else {
		/*
		 * We'll start by considering the largest
		 * important task in our list.
		 */
		selected_task_importance = 0;
	}

	microuptime(&curr_tstamp);

        SLIST_FOREACH(kn, candidate_list, kn_selnext) {

                unsigned int		resident_size = 0;
		proc_t			p = PROC_NULL;
		struct task*		t = TASK_NULL;
		int			curr_task_importance = 0;
		boolean_t		consider_knote = FALSE;
		boolean_t		privileged_listener = FALSE;

		p = kn->kn_kq->kq_p;
		proc_list_lock();
		if (p != proc_ref_locked(p)) {
			p = PROC_NULL;
			proc_list_unlock();
			continue;
		}
		proc_list_unlock();

#if CONFIG_MEMORYSTATUS		
		if (target_foreground_process == TRUE && !memorystatus_is_foreground_locked(p)) {
			/*
			 * Skip process not marked foreground.
			 */
			proc_rele(p);
			continue;
		}
#endif /* CONFIG_MEMORYSTATUS */

		t = (struct task *)(p->task);
		
		timevalsub(&curr_tstamp, &p->vm_pressure_last_notify_tstamp);
		elapsed_msecs = curr_tstamp.tv_sec * 1000 + curr_tstamp.tv_usec / 1000;
		
		if ((level == -1) && (elapsed_msecs < VM_PRESSURE_NOTIFY_WAIT_PERIOD)) { 
			proc_rele(p);
			continue;
		}

		if (level != -1) {
			/*
			 * For the level based notifications, check and see if this knote is
			 * registered for the current level.
			 */
			vm_pressure_level_t dispatch_level = convert_internal_pressure_level_to_dispatch_level(level);
			
			if ((kn->kn_sfflags & dispatch_level) == 0) {
				proc_rele(p);
				continue;
			}
		}

#if CONFIG_MEMORYSTATUS
		if (target_foreground_process == FALSE && !memorystatus_bg_pressure_eligible(p)) {
			VM_PRESSURE_DEBUG(1, "[vm_pressure] skipping process %d\n", p->p_pid);
			proc_rele(p);
			continue;			
		}
#endif /* CONFIG_MEMORYSTATUS */

		curr_task_importance = task_importance_estimate(t);

		/*
		 * Privileged listeners are only considered in the multi-level pressure scheme
		 * AND only if the pressure is increasing.
		 */
		if (level > 0) {

			if (task_has_been_notified(t, level) == FALSE) {

				/*
				 * Is this a privileged listener?
				 */
				if (task_low_mem_privileged_listener(t, FALSE, &privileged_listener) == 0) {

					if (privileged_listener) {
						kn_max = kn;
						proc_rele(p);
						goto done_scanning;
					}
				}
			} else {
				proc_rele(p);
				continue;
			}
		} else if (level == 0) {

			/*
			 * Task wasn't notified when the pressure was increasing and so
			 * no need to notify it that the pressure is decreasing.
			 */
			if ((task_has_been_notified(t, kVMPressureWarning) == FALSE) && (task_has_been_notified(t, kVMPressureCritical) == FALSE)) {
				proc_rele(p);
				continue;
			}
		}

		/*
                 * We don't want a small process to block large processes from 
                 * being notified again. <rdar://problem/7955532>
                 */
                resident_size = (get_task_phys_footprint(t))/(1024*1024ULL); //(MB);

                if (resident_size >= VM_PRESSURE_MINIMUM_RSIZE) {

			if (level > 0) {
				/*
				 * Warning or Critical Pressure.
				 */
                        	if (pressure_increase) {
					if ((curr_task_importance < selected_task_importance) || 
					    ((curr_task_importance == selected_task_importance) && (resident_size > resident_max))) {

						/*
 						 * We have found a candidate process which is:
						 * a) at a lower importance than the current selected process
						 * OR
						 * b) has importance equal to that of the current selected process but is larger
						 */

						consider_knote = TRUE;
					}
				} else {
					if ((curr_task_importance > selected_task_importance) ||
					    ((curr_task_importance == selected_task_importance) && (resident_size > resident_max))) {
						
						/*
 						 * We have found a candidate process which is:
						 * a) at a higher importance than the current selected process
						 * OR
						 * b) has importance equal to that of the current selected process but is larger
						 */

						consider_knote = TRUE;
					}
				}
			} else if (level == 0) {
                        	/*
				 * Pressure back to normal.
				 */
				if ((curr_task_importance > selected_task_importance) ||
				    ((curr_task_importance == selected_task_importance) && (resident_size > resident_max))) {

					consider_knote = TRUE;
				}
			} else if (level == -1) {

				/*
				 * Simple (importance and level)-free behavior based solely on RSIZE.
				 */
				if (resident_size > resident_max) {
					consider_knote = TRUE;
				}
			}

				
			if (consider_knote) {
				resident_max = resident_size;
				kn_max = kn;
				selected_task_importance = curr_task_importance;
				consider_knote = FALSE; /* reset for the next candidate */
			}
                } else {
                        /* There was no candidate with enough resident memory to scavenge */
                        VM_PRESSURE_DEBUG(0, "[vm_pressure] threshold failed for pid %d with %u resident...\n", p->p_pid, resident_size);
                }
		proc_rele(p);
        }

done_scanning:
	if (kn_max) {
		VM_DEBUG_CONSTANT_EVENT(vm_pressure_event, VM_PRESSURE_EVENT, DBG_FUNC_NONE, kn_max->kn_kq->kq_p->p_pid, resident_max, 0, 0);
		VM_PRESSURE_DEBUG(1, "[vm_pressure] sending event to pid %d with %u resident\n", kn_max->kn_kq->kq_p->p_pid, resident_max);
	}

	return kn_max;
}

/*
 * vm_pressure_klist_lock is held for this routine.
 */
kern_return_t vm_pressure_notification_without_levels(boolean_t target_foreground_process)
{
	struct knote *kn_max = NULL;
        pid_t target_pid = -1;
        struct klist dispatch_klist = { NULL };
	proc_t	target_proc = PROC_NULL;
	struct klist *candidate_list = NULL;

	candidate_list = &vm_pressure_klist;
	
	kn_max = vm_pressure_select_optimal_candidate_to_notify(candidate_list, -1, target_foreground_process);

        if (kn_max == NULL) {
		if (target_foreground_process) {
			/*
			 * Doesn't matter if the process had been notified earlier on.
			 * This is a very specific request. Deliver it.
			 */
			candidate_list = &vm_pressure_klist_dormant;
			kn_max = vm_pressure_select_optimal_candidate_to_notify(candidate_list, -1, target_foreground_process);
		}

		if (kn_max == NULL) {
			return KERN_FAILURE;
		}
	}
		
	target_proc = kn_max->kn_kq->kq_p;
	
        KNOTE_DETACH(candidate_list, kn_max);

	if (target_proc != PROC_NULL) {
	
		target_pid = target_proc->p_pid;

		memoryshot(VM_PRESSURE_EVENT, DBG_FUNC_NONE);

        	KNOTE_ATTACH(&dispatch_klist, kn_max);
        	KNOTE(&dispatch_klist, target_pid);
        	KNOTE_ATTACH(&vm_pressure_klist_dormant, kn_max);

#if CONFIG_MEMORYSTATUS
		memorystatus_send_pressure_note(target_pid);
#endif /* CONFIG_MEMORYSTATUS */

		microuptime(&target_proc->vm_pressure_last_notify_tstamp);
	}

        return KERN_SUCCESS;
}

static kern_return_t vm_try_pressure_candidates(boolean_t target_foreground_process)
{
	/*
	 * This takes care of candidates that use NOTE_VM_PRESSURE.
	 * It's a notification without indication of the level
	 * of memory pressure.
	 */
	return (vm_pressure_notification_without_levels(target_foreground_process));
}

/*
 * Remove all elements from the dormant list and place them on the active list.
 * Called with klist lock held.
 */
void vm_reset_active_list(void) {
	/* Re-charge the main list from the dormant list if possible */
	if (!SLIST_EMPTY(&vm_pressure_klist_dormant)) {
		struct knote *kn;

		VM_PRESSURE_DEBUG(1, "[vm_pressure] recharging main list from dormant list\n");
        
		while (!SLIST_EMPTY(&vm_pressure_klist_dormant)) {
			kn = SLIST_FIRST(&vm_pressure_klist_dormant);
			SLIST_REMOVE_HEAD(&vm_pressure_klist_dormant, kn_selnext);
			SLIST_INSERT_HEAD(&vm_pressure_klist, kn, kn_selnext);
		}
	}
}