Make tsleep/wakeup() MP SAFE for kernel threads and get us closer to
[dragonfly.git] / sys / vm / vm_glue.c
1 /*
2  * Copyright (c) 1991, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * The Mach Operating System project at Carnegie-Mellon University.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
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.
23  *
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
34  * SUCH DAMAGE.
35  *
36  *      from: @(#)vm_glue.c     8.6 (Berkeley) 1/5/94
37  *
38  *
39  * Copyright (c) 1987, 1990 Carnegie-Mellon University.
40  * All rights reserved.
41  *
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.
47  *
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.
51  *
52  * Carnegie Mellon requests users of this software to return to
53  *
54  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
55  *  School of Computer Science
56  *  Carnegie Mellon University
57  *  Pittsburgh PA 15213-3890
58  *
59  * any improvements or extensions that they make and grant Carnegie the
60  * rights to redistribute these changes.
61  *
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.36 2005/11/14 18:50:15 dillon Exp $
64  */
65
66 #include "opt_vm.h"
67
68 #include <sys/param.h>
69 #include <sys/systm.h>
70 #include <sys/proc.h>
71 #include <sys/resourcevar.h>
72 #include <sys/buf.h>
73 #include <sys/shm.h>
74 #include <sys/vmmeter.h>
75 #include <sys/sysctl.h>
76
77 #include <sys/kernel.h>
78 #include <sys/unistd.h>
79
80 #include <machine/limits.h>
81
82 #include <vm/vm.h>
83 #include <vm/vm_param.h>
84 #include <sys/lock.h>
85 #include <vm/pmap.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>
91
92 #include <sys/user.h>
93 #include <vm/vm_page2.h>
94 #include <sys/thread2.h>
95
96 /*
97  * System initialization
98  *
99  * Note: proc0 from proc.h
100  */
101
102 static void vm_init_limits (void *);
103 SYSINIT(vm_limits, SI_SUB_VM_CONF, SI_ORDER_FIRST, vm_init_limits, &proc0)
104
105 /*
106  * THIS MUST BE THE LAST INITIALIZATION ITEM!!!
107  *
108  * Note: run scheduling should be divorced from the vm system.
109  */
110 static void scheduler (void *);
111 SYSINIT(scheduler, SI_SUB_RUN_SCHEDULER, SI_ORDER_FIRST, scheduler, NULL)
112
113 #ifdef INVARIANTS
114
115 static int swap_debug = 0;
116 SYSCTL_INT(_vm, OID_AUTO, swap_debug,
117         CTLFLAG_RW, &swap_debug, 0, "");
118
119 #endif
120
121 static int scheduler_notify;
122
123 static void swapout (struct proc *);
124
125 int
126 kernacc(c_caddr_t addr, int len, int rw)
127 {
128         boolean_t rv;
129         vm_offset_t saddr, eaddr;
130         vm_prot_t prot;
131
132         KASSERT((rw & (~VM_PROT_ALL)) == 0,
133             ("illegal ``rw'' argument to kernacc (%x)\n", rw));
134         prot = rw;
135         saddr = trunc_page((vm_offset_t)addr);
136         eaddr = round_page((vm_offset_t)addr + len);
137         vm_map_lock_read(kernel_map);
138         rv = vm_map_check_protection(kernel_map, saddr, eaddr, prot);
139         vm_map_unlock_read(kernel_map);
140         if (rv == FALSE && is_globaldata_space(saddr, eaddr))
141                 rv = TRUE;
142         return (rv == TRUE);
143 }
144
145 int
146 useracc(c_caddr_t addr, int len, int rw)
147 {
148         boolean_t rv;
149         vm_prot_t prot;
150         vm_map_t map;
151         vm_map_entry_t save_hint;
152
153         KASSERT((rw & (~VM_PROT_ALL)) == 0,
154             ("illegal ``rw'' argument to useracc (%x)\n", rw));
155         prot = rw;
156         /*
157          * XXX - check separately to disallow access to user area and user
158          * page tables - they are in the map.
159          *
160          * XXX - VM_MAXUSER_ADDRESS is an end address, not a max.  It was once
161          * only used (as an end address) in trap.c.  Use it as an end address
162          * here too.  This bogusness has spread.  I just fixed where it was
163          * used as a max in vm_mmap.c.
164          */
165         if ((vm_offset_t) addr + len > /* XXX */ VM_MAXUSER_ADDRESS
166             || (vm_offset_t) addr + len < (vm_offset_t) addr) {
167                 return (FALSE);
168         }
169         map = &curproc->p_vmspace->vm_map;
170         vm_map_lock_read(map);
171         /*
172          * We save the map hint, and restore it.  Useracc appears to distort
173          * the map hint unnecessarily.
174          */
175         save_hint = map->hint;
176         rv = vm_map_check_protection(map,
177             trunc_page((vm_offset_t)addr), round_page((vm_offset_t)addr + len), prot);
178         map->hint = save_hint;
179         vm_map_unlock_read(map);
180         
181         return (rv == TRUE);
182 }
183
184 void
185 vslock(caddr_t addr, u_int len)
186 {
187         vm_map_wire(&curproc->p_vmspace->vm_map, trunc_page((vm_offset_t)addr),
188             round_page((vm_offset_t)addr + len), 0);
189 }
190
191 void
192 vsunlock(caddr_t addr, u_int len)
193 {
194         vm_map_wire(&curproc->p_vmspace->vm_map, trunc_page((vm_offset_t)addr),
195             round_page((vm_offset_t)addr + len), KM_PAGEABLE);
196 }
197
198 /*
199  * Implement fork's actions on an address space.
200  * Here we arrange for the address space to be copied or referenced,
201  * allocate a user struct (pcb and kernel stack), then call the
202  * machine-dependent layer to fill those in and make the new process
203  * ready to run.  The new process is set up so that it returns directly
204  * to user mode to avoid stack copying and relocation problems.
205  */
206 void
207 vm_fork(struct proc *p1, struct proc *p2, int flags)
208 {
209         struct user *up;
210         struct thread *td2;
211
212         if ((flags & RFPROC) == 0) {
213                 /*
214                  * Divorce the memory, if it is shared, essentially
215                  * this changes shared memory amongst threads, into
216                  * COW locally.
217                  */
218                 if ((flags & RFMEM) == 0) {
219                         if (p1->p_vmspace->vm_refcnt > 1) {
220                                 vmspace_unshare(p1);
221                         }
222                 }
223                 cpu_fork(p1, p2, flags);
224                 return;
225         }
226
227         if (flags & RFMEM) {
228                 p2->p_vmspace = p1->p_vmspace;
229                 p1->p_vmspace->vm_refcnt++;
230         }
231
232         while (vm_page_count_severe()) {
233                 vm_wait();
234         }
235
236         if ((flags & RFMEM) == 0) {
237                 p2->p_vmspace = vmspace_fork(p1->p_vmspace);
238
239                 pmap_pinit2(vmspace_pmap(p2->p_vmspace));
240
241                 if (p1->p_vmspace->vm_shm)
242                         shmfork(p1, p2);
243         }
244
245         td2 = lwkt_alloc_thread(NULL, LWKT_THREAD_STACK, -1);
246         pmap_init_proc(p2, td2);
247         lwkt_setpri(td2, TDPRI_KERN_USER);
248         lwkt_set_comm(td2, "%s", p1->p_comm);
249
250         up = p2->p_addr;
251
252         /*
253          * p_stats currently points at fields in the user struct
254          * but not at &u, instead at p_addr. Copy parts of
255          * p_stats; zero the rest of p_stats (statistics).
256          *
257          * If procsig->ps_refcnt is 1 and p2->p_sigacts is NULL we dont' need
258          * to share sigacts, so we use the up->u_sigacts.
259          */
260         p2->p_stats = &up->u_stats;
261         if (p2->p_sigacts == NULL) {
262                 if (p2->p_procsig->ps_refcnt != 1)
263                         printf ("PID:%d NULL sigacts with refcnt not 1!\n",p2->p_pid);
264                 p2->p_sigacts = &up->u_sigacts;
265                 up->u_sigacts = *p1->p_sigacts;
266         }
267
268         bzero(&up->u_stats, sizeof(struct pstats));
269
270         /*
271          * cpu_fork will copy and update the pcb, set up the kernel stack,
272          * and make the child ready to run.
273          */
274         cpu_fork(p1, p2, flags);
275 }
276
277 /*
278  * Called after process has been wait(2)'ed apon and is being reaped.
279  * The idea is to reclaim resources that we could not reclaim while  
280  * the process was still executing.
281  */
282 void
283 vm_waitproc(struct proc *p)
284 {
285         p->p_stats = NULL;
286         cpu_proc_wait(p);
287         vmspace_exitfree(p);    /* and clean-out the vmspace */
288 }
289
290 /*
291  * Set default limits for VM system.
292  * Called for proc 0, and then inherited by all others.
293  *
294  * XXX should probably act directly on proc0.
295  */
296 static void
297 vm_init_limits(void *udata)
298 {
299         struct proc *p = udata;
300         int rss_limit;
301
302         /*
303          * Set up the initial limits on process VM. Set the maximum resident
304          * set size to be half of (reasonably) available memory.  Since this
305          * is a soft limit, it comes into effect only when the system is out
306          * of memory - half of main memory helps to favor smaller processes,
307          * and reduces thrashing of the object cache.
308          */
309         p->p_rlimit[RLIMIT_STACK].rlim_cur = dflssiz;
310         p->p_rlimit[RLIMIT_STACK].rlim_max = maxssiz;
311         p->p_rlimit[RLIMIT_DATA].rlim_cur = dfldsiz;
312         p->p_rlimit[RLIMIT_DATA].rlim_max = maxdsiz;
313         /* limit the limit to no less than 2MB */
314         rss_limit = max(vmstats.v_free_count, 512);
315         p->p_rlimit[RLIMIT_RSS].rlim_cur = ptoa(rss_limit);
316         p->p_rlimit[RLIMIT_RSS].rlim_max = RLIM_INFINITY;
317 }
318
319 /*
320  * Faultin the specified process.  Note that the process can be in any
321  * state.  Just clear P_SWAPPEDOUT and call wakeup in case the process is
322  * sleeping.
323  */
324 void
325 faultin(struct proc *p)
326 {
327         if (p->p_flag & P_SWAPPEDOUT) {
328                 PHOLD(p);
329                 /*
330                  * The process is waiting in the kernel to return to user
331                  * mode but cannot until P_SWAPPEDOUT gets cleared.
332                  */
333                 crit_enter();
334                 p->p_flag &= ~(P_SWAPPEDOUT | P_SWAPWAIT);
335 #ifdef INVARIANTS
336                 if (swap_debug)
337                         printf("swapping in %d (%s)\n", p->p_pid, p->p_comm);
338 #endif
339                 wakeup(p);
340
341                 /* undo the effect of setting SLOCK above */
342                 PRELE(p);
343                 crit_exit();
344         }
345 }
346
347 /*
348  * Kernel initialization eventually falls through to this function,
349  * which is process 0.
350  *
351  * This swapin algorithm attempts to swap-in processes only if there
352  * is enough space for them.  Of course, if a process waits for a long
353  * time, it will be swapped in anyway.
354  */
355
356 /* ARGSUSED*/
357 static void
358 scheduler(void *dummy)
359 {
360         struct proc *p;
361         struct proc *pp;
362         int pri;
363         int ppri;
364         segsz_t pgs;
365
366         KKASSERT(!IN_CRITICAL_SECT(curthread));
367 loop:
368         scheduler_notify = 0;
369         /*
370          * Don't try to swap anything in if we are low on memory.
371          */
372         if (vm_page_count_min()) {
373                 vm_wait();
374                 goto loop;
375         }
376
377         /*
378          * Look for a good candidate to wake up
379          */
380         pp = NULL;
381         ppri = INT_MIN;
382         for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
383                 if (p->p_flag & P_SWAPWAIT) {
384                         pri = p->p_swtime + p->p_slptime - p->p_nice * 8;
385
386                         /*
387                          * The more pages paged out while we were swapped,
388                          * the more work we have to do to get up and running
389                          * again and the lower our wakeup priority.
390                          *
391                          * Each second of sleep time is worth ~1MB
392                          */
393                         pgs = vmspace_resident_count(p->p_vmspace);
394                         if (pgs < p->p_vmspace->vm_swrss) {
395                                 pri -= (p->p_vmspace->vm_swrss - pgs) /
396                                         (1024 * 1024 / PAGE_SIZE);
397                         }
398
399                         /*
400                          * if this process is higher priority and there is
401                          * enough space, then select this process instead of
402                          * the previous selection.
403                          */
404                         if (pri > ppri) {
405                                 pp = p;
406                                 ppri = pri;
407                         }
408                 }
409         }
410
411         /*
412          * Nothing to do, back to sleep for at least 1/10 of a second.  If
413          * we are woken up, immediately process the next request.  If
414          * multiple requests have built up the first is processed 
415          * immediately and the rest are staggered.
416          */
417         if ((p = pp) == NULL) {
418                 tsleep(&proc0, 0, "nowork", hz / 10);
419                 if (scheduler_notify == 0)
420                         tsleep(&scheduler_notify, 0, "nowork", 0);
421                 goto loop;
422         }
423
424         /*
425          * Fault the selected process in, then wait for a short period of
426          * time and loop up.
427          *
428          * XXX we need a heuristic to get a measure of system stress and
429          * then adjust our stagger wakeup delay accordingly.
430          */
431         faultin(p);
432         p->p_swtime = 0;
433         tsleep(&proc0, 0, "swapin", hz / 10);
434         goto loop;
435 }
436
437 void
438 swapin_request(void)
439 {
440         if (scheduler_notify == 0) {
441                 scheduler_notify = 1;
442                 wakeup(&scheduler_notify);
443         }
444 }
445
446 #ifndef NO_SWAPPING
447
448 #define swappable(p) \
449         (((p)->p_lock == 0) && \
450         ((p)->p_flag & (P_TRACED|P_SYSTEM|P_SWAPPEDOUT|P_WEXIT)) == 0)
451
452
453 /*
454  * Swap_idle_threshold1 is the guaranteed swapped in time for a process
455  */
456 static int swap_idle_threshold1 = 2;
457 SYSCTL_INT(_vm, OID_AUTO, swap_idle_threshold1,
458         CTLFLAG_RW, &swap_idle_threshold1, 0, "");
459
460 /*
461  * Swap_idle_threshold2 is the time that a process can be idle before
462  * it will be swapped out, if idle swapping is enabled.  Default is
463  * one minute.
464  */
465 static int swap_idle_threshold2 = 60;
466 SYSCTL_INT(_vm, OID_AUTO, swap_idle_threshold2,
467         CTLFLAG_RW, &swap_idle_threshold2, 0, "");
468
469 /*
470  * Swapout is driven by the pageout daemon.  Very simple, we find eligible
471  * procs and mark them as being swapped out.  This will cause the kernel
472  * to prefer to pageout those proc's pages first and the procs in question 
473  * will not return to user mode until the swapper tells them they can.
474  *
475  * If any procs have been sleeping/stopped for at least maxslp seconds,
476  * they are swapped.  Else, we swap the longest-sleeping or stopped process,
477  * if any, otherwise the longest-resident process.
478  */
479 void
480 swapout_procs(int action)
481 {
482         struct proc *p;
483         struct proc *outp, *outp2;
484         int outpri, outpri2;
485
486         outp = outp2 = NULL;
487         outpri = outpri2 = INT_MIN;
488 retry:
489         for (p = allproc.lh_first; p != 0; p = p->p_list.le_next) {
490                 struct vmspace *vm;
491                 if (!swappable(p))
492                         continue;
493
494                 vm = p->p_vmspace;
495
496                 if (p->p_stat == SSLEEP || p->p_stat == SRUN) {
497                         /*
498                          * do not swap out a realtime process
499                          */
500                         if (RTP_PRIO_IS_REALTIME(p->p_lwp.lwp_rtprio.type))
501                                 continue;
502
503                         /*
504                          * Guarentee swap_idle_threshold time in memory
505                          */
506                         if (p->p_slptime < swap_idle_threshold1)
507                                 continue;
508
509                         /*
510                          * If the system is under memory stress, or if we
511                          * are swapping idle processes >= swap_idle_threshold2,
512                          * then swap the process out.
513                          */
514                         if (((action & VM_SWAP_NORMAL) == 0) &&
515                             (((action & VM_SWAP_IDLE) == 0) ||
516                              (p->p_slptime < swap_idle_threshold2))) {
517                                 continue;
518                         }
519
520                         ++vm->vm_refcnt;
521
522                         /*
523                          * If the process has been asleep for awhile, swap
524                          * it out.
525                          */
526                         if ((action & VM_SWAP_NORMAL) ||
527                             ((action & VM_SWAP_IDLE) &&
528                              (p->p_slptime > swap_idle_threshold2))) {
529                                 swapout(p);
530                                 vmspace_free(vm);
531                                 goto retry;
532                         }
533
534                         /*
535                          * cleanup our reference
536                          */
537                         vmspace_free(vm);
538                 }
539         }
540 }
541
542 static void
543 swapout(struct proc *p)
544 {
545 #ifdef INVARIANTS
546         if (swap_debug)
547                 printf("swapping out %d (%s)\n", p->p_pid, p->p_comm);
548 #endif
549         ++p->p_stats->p_ru.ru_nswap;
550         /*
551          * remember the process resident count
552          */
553         p->p_vmspace->vm_swrss = vmspace_resident_count(p->p_vmspace);
554         p->p_flag |= P_SWAPPEDOUT;
555         p->p_swtime = 0;
556 }
557
558 #endif /* !NO_SWAPPING */
559