MP Implementation 2/4: Implement a poor-man's IPI messaging subsystem,
[dragonfly.git] / sys / i386 / i386 / vm_machdep.c
1 /*-
2  * Copyright (c) 1982, 1986 The Regents of the University of California.
3  * Copyright (c) 1989, 1990 William Jolitz
4  * Copyright (c) 1994 John Dyson
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to Berkeley by
8  * the Systems Programming Group of the University of Utah Computer
9  * Science Department, and William Jolitz.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *      This product includes software developed by the University of
22  *      California, Berkeley and its contributors.
23  * 4. Neither the name of the University nor the names of its contributors
24  *    may be used to endorse or promote products derived from this software
25  *    without specific prior written permission.
26  *
27  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
28  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
29  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
31  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
33  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
34  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
36  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37  * SUCH DAMAGE.
38  *
39  *      from: @(#)vm_machdep.c  7.3 (Berkeley) 5/13/91
40  *      Utah $Hdr: vm_machdep.c 1.16.1.1 89/06/23$
41  * $FreeBSD: src/sys/i386/i386/vm_machdep.c,v 1.132.2.9 2003/01/25 19:02:23 dillon Exp $
42  * $DragonFly: src/sys/i386/i386/Attic/vm_machdep.c,v 1.18 2003/07/08 06:27:26 dillon Exp $
43  */
44
45 #include "npx.h"
46 #include "opt_user_ldt.h"
47 #ifdef PC98
48 #include "opt_pc98.h"
49 #endif
50 #include "opt_reset.h"
51
52 #include <sys/param.h>
53 #include <sys/systm.h>
54 #include <sys/malloc.h>
55 #include <sys/proc.h>
56 #include <sys/buf.h>
57 #include <sys/interrupt.h>
58 #include <sys/vnode.h>
59 #include <sys/vmmeter.h>
60 #include <sys/kernel.h>
61 #include <sys/sysctl.h>
62 #include <sys/unistd.h>
63
64 #include <machine/clock.h>
65 #include <machine/cpu.h>
66 #include <machine/md_var.h>
67 #ifdef SMP
68 #include <machine/smp.h>
69 #endif
70 #include <machine/pcb.h>
71 #include <machine/pcb_ext.h>
72 #include <machine/vm86.h>
73 #include <machine/globaldata.h> /* npxthread */
74 #include <machine/ipl.h>        /* SWI_ */
75
76 #include <vm/vm.h>
77 #include <vm/vm_param.h>
78 #include <sys/lock.h>
79 #include <vm/vm_kern.h>
80 #include <vm/vm_page.h>
81 #include <vm/vm_map.h>
82 #include <vm/vm_extern.h>
83
84 #include <sys/user.h>
85 #include <sys/thread2.h>
86
87 #ifdef PC98
88 #include <pc98/pc98/pc98.h>
89 #else
90 #include <i386/isa/isa.h>
91 #endif
92
93 static void     cpu_reset_real __P((void));
94 #ifdef SMP
95 static void     cpu_reset_proxy __P((void));
96 static u_int    cpu_reset_proxyid;
97 static volatile u_int   cpu_reset_proxy_active;
98 #endif
99 extern int      _ucodesel, _udatasel;
100
101 /*
102  * quick version of vm_fault
103  */
104 int
105 vm_fault_quick(v, prot)
106         caddr_t v;
107         int prot;
108 {
109         int r;
110
111         if (prot & VM_PROT_WRITE)
112                 r = subyte(v, fubyte(v));
113         else
114                 r = fubyte(v);
115         return(r);
116 }
117
118 /*
119  * Finish a fork operation, with process p2 nearly set up.
120  * Copy and update the pcb, set up the stack so that the child
121  * ready to run and return to user mode.
122  */
123 void
124 cpu_fork(p1, p2, flags)
125         register struct proc *p1, *p2;
126         int flags;
127 {
128         struct pcb *pcb2;
129
130         if ((flags & RFPROC) == 0) {
131 #ifdef USER_LDT
132                 if ((flags & RFMEM) == 0) {
133                         /* unshare user LDT */
134                         struct pcb *pcb1 = p1->p_thread->td_pcb;
135                         struct pcb_ldt *pcb_ldt = pcb1->pcb_ldt;
136                         if (pcb_ldt && pcb_ldt->ldt_refcnt > 1) {
137                                 pcb_ldt = user_ldt_alloc(pcb1,pcb_ldt->ldt_len);
138                                 user_ldt_free(pcb1);
139                                 pcb1->pcb_ldt = pcb_ldt;
140                                 set_user_ldt(pcb1);
141                         }
142                 }
143 #endif
144                 return;
145         }
146
147 #if NNPX > 0
148         /* Ensure that p1's pcb is up to date. */
149         if (npxthread == p1->p_thread)
150                 npxsave(&p1->p_thread->td_pcb->pcb_save);
151 #endif
152
153         /* Copy p1's pcb. */
154         pcb2 = p2->p_thread->td_pcb;
155         *pcb2 = *p1->p_thread->td_pcb;
156
157         /*
158          * Create a new fresh stack for the new process.
159          * Copy the trap frame for the return to user mode as if from a
160          * syscall.  This copies the user mode register values.  The
161          * 16 byte offset saves space for vm86, and must match 
162          * common_tss.esp0 (kernel stack pointer on entry from user mode)
163          *
164          * pcb_esp must allocate an additional call-return pointer below
165          * the trap frame which will be restored by cpu_restore, and the
166          * thread's td_sp pointer must allocate an additonal call-return
167          * pointer below the pcb_esp call-return pointer to hold the LWKT
168          * restore function pointer.
169          *
170          * The LWKT restore function pointer must be set to cpu_restore,
171          * which is our standard heavy weight process switch-in function.
172          * YYY eventually we should shortcut fork_return and fork_trampoline
173          * to use the LWKT restore function directly so we can get rid of
174          * all the extra crap we are setting up.
175          */
176         p2->p_md.md_regs = (struct trapframe *)((char *)pcb2 - 16) - 1;
177         bcopy(p1->p_md.md_regs, p2->p_md.md_regs, sizeof(*p2->p_md.md_regs));
178
179         /*
180          * Set registers for trampoline to user mode.  Leave space for the
181          * return address on stack.  These are the kernel mode register values.
182          */
183         pcb2->pcb_cr3 = vtophys(vmspace_pmap(p2->p_vmspace)->pm_pdir);
184         pcb2->pcb_edi = 0;
185         pcb2->pcb_esi = (int)fork_return;       /* fork_trampoline argument */
186         pcb2->pcb_ebp = 0;
187         pcb2->pcb_esp = (int)p2->p_md.md_regs - sizeof(void *);
188         pcb2->pcb_ebx = (int)p2;                /* fork_trampoline argument */
189         pcb2->pcb_eip = (int)fork_trampoline;
190         p2->p_thread->td_sp = (char *)(pcb2->pcb_esp - sizeof(void *));
191         *(void **)p2->p_thread->td_sp = (void *)cpu_heavy_restore;
192         /*
193          * pcb2->pcb_ldt:       duplicated below, if necessary.
194          * pcb2->pcb_savefpu:   cloned above.
195          * pcb2->pcb_flags:     cloned above (always 0 here?).
196          * pcb2->pcb_onfault:   cloned above (always NULL here?).
197          */
198
199         /*
200          * XXX don't copy the i/o pages.  this should probably be fixed.
201          */
202         pcb2->pcb_ext = 0;
203
204 #ifdef USER_LDT
205         /* Copy the LDT, if necessary. */
206         if (pcb2->pcb_ldt != 0) {
207                 if (flags & RFMEM) {
208                         pcb2->pcb_ldt->ldt_refcnt++;
209                 } else {
210                         pcb2->pcb_ldt = user_ldt_alloc(pcb2,
211                                 pcb2->pcb_ldt->ldt_len);
212                 }
213         }
214 #endif
215
216         /*
217          * Now, cpu_switch() can schedule the new process.
218          * pcb_esp is loaded pointing to the cpu_switch() stack frame
219          * containing the return address when exiting cpu_switch.
220          * This will normally be to fork_trampoline(), which will have
221          * %ebx loaded with the new proc's pointer.  fork_trampoline()
222          * will set up a stack to call fork_return(p, frame); to complete
223          * the return to user-mode.
224          */
225 }
226
227 /*
228  * Intercept the return address from a freshly forked process that has NOT
229  * been scheduled yet.
230  *
231  * This is needed to make kernel threads stay in kernel mode.
232  */
233 void
234 cpu_set_fork_handler(p, func, arg)
235         struct proc *p;
236         void (*func) __P((void *));
237         void *arg;
238 {
239         /*
240          * Note that the trap frame follows the args, so the function
241          * is really called like this:  func(arg, frame);
242          */
243         p->p_thread->td_pcb->pcb_esi = (int) func;      /* function */
244         p->p_thread->td_pcb->pcb_ebx = (int) arg;       /* first arg */
245 }
246
247 void
248 cpu_set_thread_handler(thread_t td, void (*rfunc)(void), void *func, void *arg)
249 {
250         td->td_pcb->pcb_esi = (int)func;
251         td->td_pcb->pcb_ebx = (int) arg;
252         td->td_switch = cpu_lwkt_switch;
253         td->td_sp -= sizeof(void *);
254         *(void **)td->td_sp = rfunc;    /* exit function on return */
255         td->td_sp -= sizeof(void *);
256         *(void **)td->td_sp = cpu_kthread_restore;
257 }
258
259 void
260 cpu_proc_exit(void)
261 {
262         struct thread *td = curthread;
263         struct pcb *pcb;
264
265
266 #if NNPX > 0
267         KKASSERT(td->td_proc);
268         npxexit(td->td_proc);
269 #endif  /* NNPX */
270
271         /*
272          * Cleanup the PCB
273          */
274         pcb = td->td_pcb;
275         if (pcb->pcb_ext != 0) {
276                 /* 
277                  * XXX do we need to move the TSS off the allocated pages 
278                  * before freeing them?  (not done here)
279                  */
280                 kmem_free(kernel_map, (vm_offset_t)pcb->pcb_ext,
281                     ctob(IOPAGES + 1));
282                 pcb->pcb_ext = 0;
283         }
284 #ifdef USER_LDT
285         user_ldt_free(pcb);
286 #endif
287         if (pcb->pcb_flags & PCB_DBREGS) {
288                 /*
289                  * disable all hardware breakpoints
290                  */
291                 reset_dbregs();
292                 pcb->pcb_flags &= ~PCB_DBREGS;
293         }
294         mycpu->gd_cnt.v_swtch++;
295
296         crit_enter();
297         lwkt_deschedule_self();
298         cpu_thread_exit();
299 }
300
301 /*
302  * Terminate the current thread.  The caller must have already acquired
303  * the thread's rwlock and placed it on a reap list or otherwise notified
304  * a reaper of its existance.  We set a special assembly switch function which
305  * releases td_rwlock after it has cleaned up the MMU state and switched
306  * out the stack.
307  *
308  * Must be caller from a critical section and with the thread descheduled.
309  */
310 void
311 cpu_thread_exit(void)
312 {
313         curthread->td_switch = cpu_exit_switch;
314         lwkt_switch();
315         panic("cpu_exit");
316 }
317
318 /*
319  * Process Reaper.  Called after the caller has acquired the thread's
320  * rwlock and removed it from the reap list.
321  */
322 void
323 cpu_proc_wait(struct proc *p)
324 {
325         struct thread *td;
326
327         /* drop per-process resources */
328         td = pmap_dispose_proc(p);
329         if (td)
330                 lwkt_free_thread(td);
331 }
332
333 /*
334  * Dump the machine specific header information at the start of a core dump.
335  */
336 int
337 cpu_coredump(struct thread *td, struct vnode *vp, struct ucred *cred)
338 {
339         struct proc *p = td->td_proc;
340         int error;
341         caddr_t tempuser;
342
343         KKASSERT(p);
344         tempuser = malloc(ctob(UPAGES), M_TEMP, M_WAITOK);
345         if (!tempuser)
346                 return EINVAL;
347         
348         bzero(tempuser, ctob(UPAGES));
349         bcopy(p->p_addr, tempuser, sizeof(struct user));
350         bcopy(p->p_md.md_regs,
351               tempuser + ((caddr_t) p->p_md.md_regs - (caddr_t) p->p_addr),
352               sizeof(struct trapframe));
353         bcopy(p->p_thread->td_pcb, tempuser + ((char *)p->p_thread->td_pcb - (char *)p->p_addr), sizeof(struct pcb));
354
355         error = vn_rdwr(UIO_WRITE, vp, (caddr_t) tempuser, ctob(UPAGES),
356                         (off_t)0, UIO_SYSSPACE, IO_UNIT, cred, (int *)NULL, td);
357
358         free(tempuser, M_TEMP);
359         
360         return error;
361 }
362
363 #ifdef notyet
364 static void
365 setredzone(pte, vaddr)
366         u_short *pte;
367         caddr_t vaddr;
368 {
369 /* eventually do this by setting up an expand-down stack segment
370    for ss0: selector, allowing stack access down to top of u.
371    this means though that protection violations need to be handled
372    thru a double fault exception that must do an integral task
373    switch to a known good context, within which a dump can be
374    taken. a sensible scheme might be to save the initial context
375    used by sched (that has physical memory mapped 1:1 at bottom)
376    and take the dump while still in mapped mode */
377 }
378 #endif
379
380 /*
381  * Convert kernel VA to physical address
382  */
383 u_long
384 kvtop(void *addr)
385 {
386         vm_offset_t va;
387
388         va = pmap_kextract((vm_offset_t)addr);
389         if (va == 0)
390                 panic("kvtop: zero page frame");
391         return((int)va);
392 }
393
394 /*
395  * Force reset the processor by invalidating the entire address space!
396  */
397
398 #ifdef SMP
399 static void
400 cpu_reset_proxy()
401 {
402         u_int saved_mp_lock;
403
404         cpu_reset_proxy_active = 1;
405         while (cpu_reset_proxy_active == 1)
406                 ;        /* Wait for other cpu to disable interupts */
407         saved_mp_lock = mp_lock;
408         mp_lock = 0;    /* BSP */
409         printf("cpu_reset_proxy: Grabbed mp lock for BSP\n");
410         cpu_reset_proxy_active = 3;
411         while (cpu_reset_proxy_active == 3)
412                 ;       /* Wait for other cpu to enable interrupts */
413         stop_cpus((1<<cpu_reset_proxyid));
414         printf("cpu_reset_proxy: Stopped CPU %d\n", cpu_reset_proxyid);
415         DELAY(1000000);
416         cpu_reset_real();
417 }
418 #endif
419
420 void
421 cpu_reset()
422 {
423 #ifdef SMP
424         if (smp_active == 0) {
425                 cpu_reset_real();
426                 /* NOTREACHED */
427         } else {
428
429                 u_int map;
430                 int cnt;
431                 printf("cpu_reset called on cpu#%d\n",mycpu->gd_cpuid);
432
433                 map = mycpu->gd_other_cpus & ~ stopped_cpus;
434
435                 if (map != 0) {
436                         printf("cpu_reset: Stopping other CPUs\n");
437                         stop_cpus(map);         /* Stop all other CPUs */
438                 }
439
440                 if (mycpu->gd_cpuid == 0) {
441                         DELAY(1000000);
442                         cpu_reset_real();
443                         /* NOTREACHED */
444                 } else {
445                         /* We are not BSP (CPU #0) */
446
447                         cpu_reset_proxyid = mycpu->gd_cpuid;
448                         cpustop_restartfunc = cpu_reset_proxy;
449                         printf("cpu_reset: Restarting BSP\n");
450                         started_cpus = (1<<0);          /* Restart CPU #0 */
451
452                         cnt = 0;
453                         while (cpu_reset_proxy_active == 0 && cnt < 10000000)
454                                 cnt++;  /* Wait for BSP to announce restart */
455                         if (cpu_reset_proxy_active == 0)
456                                 printf("cpu_reset: Failed to restart BSP\n");
457                         __asm __volatile("cli" : : : "memory");
458                         cpu_reset_proxy_active = 2;
459                         cnt = 0;
460                         while (cpu_reset_proxy_active == 2 && cnt < 10000000)
461                                 cnt++;  /* Do nothing */
462                         if (cpu_reset_proxy_active == 2) {
463                                 printf("cpu_reset: BSP did not grab mp lock\n");
464                                 cpu_reset_real();       /* XXX: Bogus ? */
465                         }
466                         cpu_reset_proxy_active = 4;
467                         __asm __volatile("sti" : : : "memory");
468                         while (1);
469                         /* NOTREACHED */
470                 }
471         }
472 #else
473         cpu_reset_real();
474 #endif
475 }
476
477 static void
478 cpu_reset_real()
479 {
480
481 #ifdef PC98
482         /*
483          * Attempt to do a CPU reset via CPU reset port.
484          */
485         disable_intr();
486         if ((inb(0x35) & 0xa0) != 0xa0) {
487                 outb(0x37, 0x0f);               /* SHUT0 = 0. */
488                 outb(0x37, 0x0b);               /* SHUT1 = 0. */
489         }
490         outb(0xf0, 0x00);               /* Reset. */
491 #else
492         /*
493          * Attempt to do a CPU reset via the keyboard controller,
494          * do not turn of the GateA20, as any machine that fails
495          * to do the reset here would then end up in no man's land.
496          */
497
498 #if !defined(BROKEN_KEYBOARD_RESET)
499         outb(IO_KBD + 4, 0xFE);
500         DELAY(500000);  /* wait 0.5 sec to see if that did it */
501         printf("Keyboard reset did not work, attempting CPU shutdown\n");
502         DELAY(1000000); /* wait 1 sec for printf to complete */
503 #endif
504 #endif /* PC98 */
505         /* force a shutdown by unmapping entire address space ! */
506         bzero((caddr_t) PTD, PAGE_SIZE);
507
508         /* "good night, sweet prince .... <THUNK!>" */
509         invltlb();
510         /* NOTREACHED */
511         while(1);
512 }
513
514 int
515 grow_stack(p, sp)
516         struct proc *p;
517         u_int sp;
518 {
519         int rv;
520
521         rv = vm_map_growstack (p, sp);
522         if (rv != KERN_SUCCESS)
523                 return (0);
524
525         return (1);
526 }
527
528 SYSCTL_DECL(_vm_stats_misc);
529
530 static int cnt_prezero;
531
532 SYSCTL_INT(_vm_stats_misc, OID_AUTO,
533         cnt_prezero, CTLFLAG_RD, &cnt_prezero, 0, "");
534
535 /*
536  * Implement the pre-zeroed page mechanism.
537  * This routine is called from the idle loop.
538  */
539
540 #define ZIDLE_LO(v)     ((v) * 2 / 3)
541 #define ZIDLE_HI(v)     ((v) * 4 / 5)
542
543 int
544 vm_page_zero_idle()
545 {
546         static int free_rover;
547         static int zero_state;
548         vm_page_t m;
549         int s;
550
551         /*
552          * Attempt to maintain approximately 1/2 of our free pages in a
553          * PG_ZERO'd state.   Add some hysteresis to (attempt to) avoid
554          * generally zeroing a page when the system is near steady-state.
555          * Otherwise we might get 'flutter' during disk I/O / IPC or 
556          * fast sleeps.  We also do not want to be continuously zeroing
557          * pages because doing so may flush our L1 and L2 caches too much.
558          */
559
560         if (zero_state && vm_page_zero_count >= ZIDLE_LO(vmstats.v_free_count))
561                 return(0);
562         if (vm_page_zero_count >= ZIDLE_HI(vmstats.v_free_count))
563                 return(0);
564
565 #ifdef SMP
566         if (try_mplock()) {
567 #endif
568                 s = splvm();
569                 __asm __volatile("sti" : : : "memory");
570                 zero_state = 0;
571                 m = vm_page_list_find(PQ_FREE, free_rover, FALSE);
572                 if (m != NULL && (m->flags & PG_ZERO) == 0) {
573                         vm_page_queues[m->queue].lcnt--;
574                         TAILQ_REMOVE(&vm_page_queues[m->queue].pl, m, pageq);
575                         m->queue = PQ_NONE;
576                         splx(s);
577                         pmap_zero_page(VM_PAGE_TO_PHYS(m));
578                         (void)splvm();
579                         vm_page_flag_set(m, PG_ZERO);
580                         m->queue = PQ_FREE + m->pc;
581                         vm_page_queues[m->queue].lcnt++;
582                         TAILQ_INSERT_TAIL(&vm_page_queues[m->queue].pl, m,
583                             pageq);
584                         ++vm_page_zero_count;
585                         ++cnt_prezero;
586                         if (vm_page_zero_count >= ZIDLE_HI(vmstats.v_free_count))
587                                 zero_state = 1;
588                 }
589                 free_rover = (free_rover + PQ_PRIME2) & PQ_L2_MASK;
590                 splx(s);
591                 __asm __volatile("cli" : : : "memory");
592 #ifdef SMP
593                 rel_mplock();
594 #endif
595                 return (1);
596 #ifdef SMP
597         }
598 #endif
599         /*
600          * We have to enable interrupts for a moment if the try_mplock fails
601          * in order to potentially take an IPI.   XXX this should be in 
602          * swtch.s
603          */
604         __asm __volatile("sti; nop; cli" : : : "memory");
605         return (0);
606 }
607
608 static void
609 swi_vm(void *arg)
610 {
611         if (busdma_swi_pending != 0)
612                 busdma_swi();
613 }
614
615 static void
616 swi_vm_setup(void *arg)
617 {
618         register_swi(SWI_VM, swi_vm, NULL, "swi_vm");
619 }
620
621 SYSINIT(vm_setup, SI_SUB_CPU, SI_ORDER_ANY, swi_vm_setup, NULL);
622
623
624 /*
625  * Tell whether this address is in some physical memory region.
626  * Currently used by the kernel coredump code in order to avoid
627  * dumping the ``ISA memory hole'' which could cause indefinite hangs,
628  * or other unpredictable behaviour.
629  */
630
631 #include "isa.h"
632
633 int
634 is_physical_memory(addr)
635         vm_offset_t addr;
636 {
637
638 #if NISA > 0
639         /* The ISA ``memory hole''. */
640         if (addr >= 0xa0000 && addr < 0x100000)
641                 return 0;
642 #endif
643
644         /*
645          * stuff other tests for known memory-mapped devices (PCI?)
646          * here
647          */
648
649         return 1;
650 }