| vm_pageout.c (283310) | vm_pageout.c (284665) |
|---|---|
| 1/*- 2 * Copyright (c) 1991 Regents of the University of California. 3 * All rights reserved. 4 * Copyright (c) 1994 John S. Dyson 5 * All rights reserved. 6 * Copyright (c) 1994 David Greenman 7 * All rights reserved. 8 * Copyright (c) 2005 Yahoo! Technologies Norway AS --- 59 unchanged lines hidden (view full) --- 68 * rights to redistribute these changes. 69 */ 70 71/* 72 * The proverbial page-out daemon. 73 */ 74 75#include <sys/cdefs.h> | 1/*- 2 * Copyright (c) 1991 Regents of the University of California. 3 * All rights reserved. 4 * Copyright (c) 1994 John S. Dyson 5 * All rights reserved. 6 * Copyright (c) 1994 David Greenman 7 * All rights reserved. 8 * Copyright (c) 2005 Yahoo! Technologies Norway AS --- 59 unchanged lines hidden (view full) --- 68 * rights to redistribute these changes. 69 */ 70 71/* 72 * The proverbial page-out daemon. 73 */ 74 75#include <sys/cdefs.h> |
| 76__FBSDID("$FreeBSD: stable/10/sys/vm/vm_pageout.c 283310 2015-05-23 09:14:29Z kib $"); | 76__FBSDID("$FreeBSD: stable/10/sys/vm/vm_pageout.c 284665 2015-06-21 06:28:26Z trasz $"); |
| 77 78#include "opt_vm.h" 79#include "opt_kdtrace.h" 80#include <sys/param.h> 81#include <sys/systm.h> 82#include <sys/kernel.h> 83#include <sys/eventhandler.h> 84#include <sys/lock.h> --- 1704 unchanged lines hidden (view full) --- 1789 struct vmspace *vm; 1790 int breakout, swapout_flags, tryagain, attempts; 1791#ifdef RACCT 1792 uint64_t rsize, ravailable; 1793#endif 1794 1795 while (TRUE) { 1796 mtx_lock(&vm_daemon_mtx); | 77 78#include "opt_vm.h" 79#include "opt_kdtrace.h" 80#include <sys/param.h> 81#include <sys/systm.h> 82#include <sys/kernel.h> 83#include <sys/eventhandler.h> 84#include <sys/lock.h> --- 1704 unchanged lines hidden (view full) --- 1789 struct vmspace *vm; 1790 int breakout, swapout_flags, tryagain, attempts; 1791#ifdef RACCT 1792 uint64_t rsize, ravailable; 1793#endif 1794 1795 while (TRUE) { 1796 mtx_lock(&vm_daemon_mtx); |
| 1797 msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep", |
|
| 1797#ifdef RACCT | 1798#ifdef RACCT |
| 1798 msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep", hz); | 1799 racct_enable ? hz : 0 |
| 1799#else | 1800#else |
| 1800 msleep(&vm_daemon_needed, &vm_daemon_mtx, PPAUSE, "psleep", 0); | 1801 0 |
| 1801#endif | 1802#endif |
| 1803 ); |
|
| 1802 swapout_flags = vm_pageout_req_swapout; 1803 vm_pageout_req_swapout = 0; 1804 mtx_unlock(&vm_daemon_mtx); 1805 if (swapout_flags) 1806 swapout_procs(swapout_flags); 1807 1808 /* 1809 * scan the processes for exceeding their rlimits or if --- 58 unchanged lines hidden (view full) --- 1868 continue; 1869 1870 size = vmspace_resident_count(vm); 1871 if (size >= limit) { 1872 vm_pageout_map_deactivate_pages( 1873 &vm->vm_map, limit); 1874 } 1875#ifdef RACCT | 1804 swapout_flags = vm_pageout_req_swapout; 1805 vm_pageout_req_swapout = 0; 1806 mtx_unlock(&vm_daemon_mtx); 1807 if (swapout_flags) 1808 swapout_procs(swapout_flags); 1809 1810 /* 1811 * scan the processes for exceeding their rlimits or if --- 58 unchanged lines hidden (view full) --- 1870 continue; 1871 1872 size = vmspace_resident_count(vm); 1873 if (size >= limit) { 1874 vm_pageout_map_deactivate_pages( 1875 &vm->vm_map, limit); 1876 } 1877#ifdef RACCT |
| 1876 rsize = IDX_TO_OFF(size); 1877 PROC_LOCK(p); 1878 racct_set(p, RACCT_RSS, rsize); 1879 ravailable = racct_get_available(p, RACCT_RSS); 1880 PROC_UNLOCK(p); 1881 if (rsize > ravailable) { 1882 /* 1883 * Don't be overly aggressive; this might be 1884 * an innocent process, and the limit could've 1885 * been exceeded by some memory hog. Don't 1886 * try to deactivate more than 1/4th of process' 1887 * resident set size. 1888 */ 1889 if (attempts <= 8) { 1890 if (ravailable < rsize - (rsize / 4)) 1891 ravailable = rsize - (rsize / 4); 1892 } 1893 vm_pageout_map_deactivate_pages( 1894 &vm->vm_map, OFF_TO_IDX(ravailable)); 1895 /* Update RSS usage after paging out. */ 1896 size = vmspace_resident_count(vm); | 1878 if (racct_enable) { |
| 1897 rsize = IDX_TO_OFF(size); 1898 PROC_LOCK(p); 1899 racct_set(p, RACCT_RSS, rsize); | 1879 rsize = IDX_TO_OFF(size); 1880 PROC_LOCK(p); 1881 racct_set(p, RACCT_RSS, rsize); |
| 1882 ravailable = racct_get_available(p, RACCT_RSS); |
|
| 1900 PROC_UNLOCK(p); | 1883 PROC_UNLOCK(p); |
| 1901 if (rsize > ravailable) 1902 tryagain = 1; | 1884 if (rsize > ravailable) { 1885 /* 1886 * Don't be overly aggressive; this 1887 * might be an innocent process, 1888 * and the limit could've been exceeded 1889 * by some memory hog. Don't try 1890 * to deactivate more than 1/4th 1891 * of process' resident set size. 1892 */ 1893 if (attempts <= 8) { 1894 if (ravailable < rsize - 1895 (rsize / 4)) { 1896 ravailable = rsize - 1897 (rsize / 4); 1898 } 1899 } 1900 vm_pageout_map_deactivate_pages( 1901 &vm->vm_map, 1902 OFF_TO_IDX(ravailable)); 1903 /* Update RSS usage after paging out. */ 1904 size = vmspace_resident_count(vm); 1905 rsize = IDX_TO_OFF(size); 1906 PROC_LOCK(p); 1907 racct_set(p, RACCT_RSS, rsize); 1908 PROC_UNLOCK(p); 1909 if (rsize > ravailable) 1910 tryagain = 1; 1911 } |
| 1903 } 1904#endif 1905 vmspace_free(vm); 1906 } 1907 sx_sunlock(&allproc_lock); 1908 if (tryagain != 0 && attempts <= 10) 1909 goto again; 1910 } 1911} 1912#endif /* !defined(NO_SWAPPING) */ | 1912 } 1913#endif 1914 vmspace_free(vm); 1915 } 1916 sx_sunlock(&allproc_lock); 1917 if (tryagain != 0 && attempts <= 10) 1918 goto again; 1919 } 1920} 1921#endif /* !defined(NO_SWAPPING) */ |