2 * Copyright (c) 1991, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
6 * The Mach Operating System project at Carnegie-Mellon University.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36 * from: @(#)vm_glue.c 8.6 (Berkeley) 1/5/94
39 * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40 * All rights reserved.
42 * Permission to use, copy, modify and distribute this software and
43 * its documentation is hereby granted, provided that both the copyright
44 * notice and this permission notice appear in all copies of the
45 * software, derivative works or modified versions, and any portions
46 * thereof, and that both notices appear in supporting documentation.
48 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
49 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
50 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
52 * Carnegie Mellon requests users of this software to return to
54 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
55 * School of Computer Science
56 * Carnegie Mellon University
57 * Pittsburgh PA 15213-3890
59 * any improvements or extensions that they make and grant Carnegie the
60 * rights to redistribute these changes.
62 * $FreeBSD: src/sys/vm/vm_glue.c,v 1.94.2.4 2003/01/13 22:51:17 dillon Exp $
63 * $DragonFly: src/sys/vm/vm_glue.c,v 1.42 2006/06/27 16:38:42 dillon Exp $
68 #include <sys/param.h>
69 #include <sys/systm.h>
71 #include <sys/resourcevar.h>
74 #include <sys/vmmeter.h>
75 #include <sys/sysctl.h>
77 #include <sys/kernel.h>
78 #include <sys/unistd.h>
80 #include <machine/limits.h>
83 #include <vm/vm_param.h>
86 #include <vm/vm_map.h>
87 #include <vm/vm_page.h>
88 #include <vm/vm_pageout.h>
89 #include <vm/vm_kern.h>
90 #include <vm/vm_extern.h>
93 #include <vm/vm_page2.h>
94 #include <sys/thread2.h>
97 * System initialization
99 * Note: proc0 from proc.h
102 static void vm_init_limits (void *);
103 SYSINIT(vm_limits
, SI_SUB_VM_CONF
, SI_ORDER_FIRST
, vm_init_limits
, &proc0
)
106 * THIS MUST BE THE LAST INITIALIZATION ITEM!!!
108 * Note: run scheduling should be divorced from the vm system.
110 static void scheduler (void *);
111 SYSINIT(scheduler
, SI_SUB_RUN_SCHEDULER
, SI_ORDER_FIRST
, scheduler
, NULL
)
115 static int swap_debug
= 0;
116 SYSCTL_INT(_vm
, OID_AUTO
, swap_debug
,
117 CTLFLAG_RW
, &swap_debug
, 0, "");
121 static int scheduler_notify
;
123 static void swapout (struct proc
*);
126 kernacc(c_caddr_t addr
, int len
, int rw
)
129 vm_offset_t saddr
, eaddr
;
132 KASSERT((rw
& (~VM_PROT_ALL
)) == 0,
133 ("illegal ``rw'' argument to kernacc (%x)\n", rw
));
136 * The globaldata space is not part of the kernel_map proper,
137 * check access separately.
139 if (is_globaldata_space((vm_offset_t
)addr
, (vm_offset_t
)(addr
+ len
)))
143 * Nominal kernel memory access - check access via kernel_map.
145 if ((vm_offset_t
)addr
+ len
> kernel_map
->max_offset
||
146 (vm_offset_t
)addr
+ len
< (vm_offset_t
)addr
) {
150 saddr
= trunc_page((vm_offset_t
)addr
);
151 eaddr
= round_page((vm_offset_t
)addr
+ len
);
152 vm_map_lock_read(kernel_map
);
153 rv
= vm_map_check_protection(kernel_map
, saddr
, eaddr
, prot
);
154 vm_map_unlock_read(kernel_map
);
159 useracc(c_caddr_t addr
, int len
, int rw
)
164 vm_map_entry_t save_hint
;
166 KASSERT((rw
& (~VM_PROT_ALL
)) == 0,
167 ("illegal ``rw'' argument to useracc (%x)\n", rw
));
170 * XXX - check separately to disallow access to user area and user
171 * page tables - they are in the map.
173 * XXX - VM_MAXUSER_ADDRESS is an end address, not a max. It was once
174 * only used (as an end address) in trap.c. Use it as an end address
175 * here too. This bogusness has spread. I just fixed where it was
176 * used as a max in vm_mmap.c.
178 if ((vm_offset_t
) addr
+ len
> /* XXX */ VM_MAXUSER_ADDRESS
179 || (vm_offset_t
) addr
+ len
< (vm_offset_t
) addr
) {
182 map
= &curproc
->p_vmspace
->vm_map
;
183 vm_map_lock_read(map
);
185 * We save the map hint, and restore it. Useracc appears to distort
186 * the map hint unnecessarily.
188 save_hint
= map
->hint
;
189 rv
= vm_map_check_protection(map
,
190 trunc_page((vm_offset_t
)addr
), round_page((vm_offset_t
)addr
+ len
), prot
);
191 map
->hint
= save_hint
;
192 vm_map_unlock_read(map
);
198 vslock(caddr_t addr
, u_int len
)
200 vm_map_wire(&curproc
->p_vmspace
->vm_map
, trunc_page((vm_offset_t
)addr
),
201 round_page((vm_offset_t
)addr
+ len
), 0);
205 vsunlock(caddr_t addr
, u_int len
)
207 vm_map_wire(&curproc
->p_vmspace
->vm_map
, trunc_page((vm_offset_t
)addr
),
208 round_page((vm_offset_t
)addr
+ len
), KM_PAGEABLE
);
212 * Implement fork's actions on an address space.
213 * Here we arrange for the address space to be copied or referenced,
214 * allocate a user struct (pcb and kernel stack), then call the
215 * machine-dependent layer to fill those in and make the new process
216 * ready to run. The new process is set up so that it returns directly
217 * to user mode to avoid stack copying and relocation problems.
220 vm_fork(struct proc
*p1
, struct proc
*p2
, int flags
)
225 if ((flags
& RFPROC
) == 0) {
227 * Divorce the memory, if it is shared, essentially
228 * this changes shared memory amongst threads, into
231 if ((flags
& RFMEM
) == 0) {
232 if (p1
->p_vmspace
->vm_refcnt
> 1) {
236 cpu_fork(p1
, p2
, flags
);
241 p2
->p_vmspace
= p1
->p_vmspace
;
242 p1
->p_vmspace
->vm_refcnt
++;
245 while (vm_page_count_severe()) {
249 if ((flags
& RFMEM
) == 0) {
250 p2
->p_vmspace
= vmspace_fork(p1
->p_vmspace
);
252 pmap_pinit2(vmspace_pmap(p2
->p_vmspace
));
254 if (p1
->p_vmspace
->vm_shm
)
258 td2
= lwkt_alloc_thread(NULL
, LWKT_THREAD_STACK
, -1, 0);
259 pmap_init_proc(p2
, td2
);
260 lwkt_setpri(td2
, TDPRI_KERN_USER
);
261 lwkt_set_comm(td2
, "%s", p1
->p_comm
);
266 * p_stats currently points at fields in the user struct
267 * but not at &u, instead at p_addr. Copy parts of
268 * p_stats; zero the rest of p_stats (statistics).
270 * If procsig->ps_refcnt is 1 and p2->p_sigacts is NULL we dont' need
271 * to share sigacts, so we use the up->u_sigacts.
273 p2
->p_stats
= &up
->u_stats
;
274 if (p2
->p_sigacts
== NULL
) {
275 if (p2
->p_procsig
->ps_refcnt
!= 1)
276 printf ("PID:%d NULL sigacts with refcnt not 1!\n",p2
->p_pid
);
277 p2
->p_sigacts
= &up
->u_sigacts
;
278 up
->u_sigacts
= *p1
->p_sigacts
;
281 bzero(&up
->u_stats
, sizeof(struct pstats
));
284 * cpu_fork will copy and update the pcb, set up the kernel stack,
285 * and make the child ready to run.
287 cpu_fork(p1
, p2
, flags
);
291 * Called after process has been wait(2)'ed apon and is being reaped.
292 * The idea is to reclaim resources that we could not reclaim while
293 * the process was still executing.
296 vm_waitproc(struct proc
*p
)
300 vmspace_exitfree(p
); /* and clean-out the vmspace */
304 * Set default limits for VM system.
305 * Called for proc 0, and then inherited by all others.
307 * XXX should probably act directly on proc0.
310 vm_init_limits(void *udata
)
312 struct proc
*p
= udata
;
316 * Set up the initial limits on process VM. Set the maximum resident
317 * set size to be half of (reasonably) available memory. Since this
318 * is a soft limit, it comes into effect only when the system is out
319 * of memory - half of main memory helps to favor smaller processes,
320 * and reduces thrashing of the object cache.
322 p
->p_rlimit
[RLIMIT_STACK
].rlim_cur
= dflssiz
;
323 p
->p_rlimit
[RLIMIT_STACK
].rlim_max
= maxssiz
;
324 p
->p_rlimit
[RLIMIT_DATA
].rlim_cur
= dfldsiz
;
325 p
->p_rlimit
[RLIMIT_DATA
].rlim_max
= maxdsiz
;
326 /* limit the limit to no less than 2MB */
327 rss_limit
= max(vmstats
.v_free_count
, 512);
328 p
->p_rlimit
[RLIMIT_RSS
].rlim_cur
= ptoa(rss_limit
);
329 p
->p_rlimit
[RLIMIT_RSS
].rlim_max
= RLIM_INFINITY
;
333 * Faultin the specified process. Note that the process can be in any
334 * state. Just clear P_SWAPPEDOUT and call wakeup in case the process is
338 faultin(struct proc
*p
)
340 if (p
->p_flag
& P_SWAPPEDOUT
) {
342 * The process is waiting in the kernel to return to user
343 * mode but cannot until P_SWAPPEDOUT gets cleared.
346 p
->p_flag
&= ~(P_SWAPPEDOUT
| P_SWAPWAIT
);
349 printf("swapping in %d (%s)\n", p
->p_pid
, p
->p_comm
);
358 * Kernel initialization eventually falls through to this function,
359 * which is process 0.
361 * This swapin algorithm attempts to swap-in processes only if there
362 * is enough space for them. Of course, if a process waits for a long
363 * time, it will be swapped in anyway.
366 struct scheduler_info
{
371 static int scheduler_callback(struct proc
*p
, void *data
);
374 scheduler(void *dummy
)
376 struct scheduler_info info
;
379 KKASSERT(!IN_CRITICAL_SECT(curthread
));
381 scheduler_notify
= 0;
383 * Don't try to swap anything in if we are low on memory.
385 if (vm_page_count_min()) {
391 * Look for a good candidate to wake up
395 allproc_scan(scheduler_callback
, &info
);
398 * Nothing to do, back to sleep for at least 1/10 of a second. If
399 * we are woken up, immediately process the next request. If
400 * multiple requests have built up the first is processed
401 * immediately and the rest are staggered.
403 if ((p
= info
.pp
) == NULL
) {
404 tsleep(&proc0
, 0, "nowork", hz
/ 10);
405 if (scheduler_notify
== 0)
406 tsleep(&scheduler_notify
, 0, "nowork", 0);
411 * Fault the selected process in, then wait for a short period of
414 * XXX we need a heuristic to get a measure of system stress and
415 * then adjust our stagger wakeup delay accordingly.
420 tsleep(&proc0
, 0, "swapin", hz
/ 10);
425 scheduler_callback(struct proc
*p
, void *data
)
427 struct scheduler_info
*info
= data
;
431 if (p
->p_flag
& P_SWAPWAIT
) {
432 pri
= p
->p_swtime
+ p
->p_slptime
- p
->p_nice
* 8;
435 * The more pages paged out while we were swapped,
436 * the more work we have to do to get up and running
437 * again and the lower our wakeup priority.
439 * Each second of sleep time is worth ~1MB
441 pgs
= vmspace_resident_count(p
->p_vmspace
);
442 if (pgs
< p
->p_vmspace
->vm_swrss
) {
443 pri
-= (p
->p_vmspace
->vm_swrss
- pgs
) /
444 (1024 * 1024 / PAGE_SIZE
);
448 * If this process is higher priority and there is
449 * enough space, then select this process instead of
450 * the previous selection.
452 if (pri
> info
->ppri
) {
466 if (scheduler_notify
== 0) {
467 scheduler_notify
= 1;
468 wakeup(&scheduler_notify
);
474 #define swappable(p) \
475 (((p)->p_lock == 0) && \
476 ((p)->p_flag & (P_TRACED|P_SYSTEM|P_SWAPPEDOUT|P_WEXIT)) == 0)
480 * Swap_idle_threshold1 is the guaranteed swapped in time for a process
482 static int swap_idle_threshold1
= 15;
483 SYSCTL_INT(_vm
, OID_AUTO
, swap_idle_threshold1
,
484 CTLFLAG_RW
, &swap_idle_threshold1
, 0, "");
487 * Swap_idle_threshold2 is the time that a process can be idle before
488 * it will be swapped out, if idle swapping is enabled. Default is
491 static int swap_idle_threshold2
= 60;
492 SYSCTL_INT(_vm
, OID_AUTO
, swap_idle_threshold2
,
493 CTLFLAG_RW
, &swap_idle_threshold2
, 0, "");
496 * Swapout is driven by the pageout daemon. Very simple, we find eligible
497 * procs and mark them as being swapped out. This will cause the kernel
498 * to prefer to pageout those proc's pages first and the procs in question
499 * will not return to user mode until the swapper tells them they can.
501 * If any procs have been sleeping/stopped for at least maxslp seconds,
502 * they are swapped. Else, we swap the longest-sleeping or stopped process,
503 * if any, otherwise the longest-resident process.
506 static int swapout_procs_callback(struct proc
*p
, void *data
);
509 swapout_procs(int action
)
511 allproc_scan(swapout_procs_callback
, &action
);
515 swapout_procs_callback(struct proc
*p
, void *data
)
518 int action
= *(int *)data
;
525 if (p
->p_stat
== SSLEEP
|| p
->p_stat
== SRUN
) {
527 * do not swap out a realtime process
529 if (RTP_PRIO_IS_REALTIME(p
->p_lwp
.lwp_rtprio
.type
))
533 * Guarentee swap_idle_threshold time in memory
535 if (p
->p_slptime
< swap_idle_threshold1
)
539 * If the system is under memory stress, or if we
540 * are swapping idle processes >= swap_idle_threshold2,
541 * then swap the process out.
543 if (((action
& VM_SWAP_NORMAL
) == 0) &&
544 (((action
& VM_SWAP_IDLE
) == 0) ||
545 (p
->p_slptime
< swap_idle_threshold2
))) {
552 * If the process has been asleep for awhile, swap
555 if ((action
& VM_SWAP_NORMAL
) ||
556 ((action
& VM_SWAP_IDLE
) &&
557 (p
->p_slptime
> swap_idle_threshold2
))) {
562 * cleanup our reference
570 swapout(struct proc
*p
)
574 printf("swapping out %d (%s)\n", p
->p_pid
, p
->p_comm
);
576 ++p
->p_stats
->p_ru
.ru_nswap
;
578 * remember the process resident count
580 p
->p_vmspace
->vm_swrss
= vmspace_resident_count(p
->p_vmspace
);
581 p
->p_flag
|= P_SWAPPEDOUT
;
585 #endif /* !NO_SWAPPING */