sys/ia64/ia64/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$
  42  */
  43 /*-
  44  * Copyright (c) 1994, 1995, 1996 Carnegie-Mellon University.
  45  * All rights reserved.
  46  *
  47  * Author: Chris G. Demetriou
  48  *
  49  * Permission to use, copy, modify and distribute this software and
  50  * its documentation is hereby granted, provided that both the copyright
  51  * notice and this permission notice appear in all copies of the
  52  * software, derivative works or modified versions, and any portions
  53  * thereof, and that both notices appear in supporting documentation.
  54  *
  55  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
  56  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
  57  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
  58  *
  59  * Carnegie Mellon requests users of this software to return to
  60  *
  61  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
  62  *  School of Computer Science
  63  *  Carnegie Mellon University
  64  *  Pittsburgh PA 15213-3890
  65  *
  66  * any improvements or extensions that they make and grant Carnegie the
  67  * rights to redistribute these changes.
  68  */
  69
  70 #include <sys/param.h>
  71 #include <sys/systm.h>
  72 #include <sys/proc.h>
  73 #include <sys/lock.h>
  74 #include <sys/malloc.h>
  75 #include <sys/bio.h>
  76 #include <sys/buf.h>
  77 #include <sys/sysent.h>
  78 #include <sys/vnode.h>
  79 #include <sys/vmmeter.h>
  80 #include <sys/kernel.h>
  81 #include <sys/mbuf.h>
  82 #include <sys/sf_buf.h>
  83 #include <sys/sysctl.h>
  84 #include <sys/unistd.h>
  85
  86 #include <machine/cpu.h>
  87 #include <machine/fpu.h>
  88 #include <machine/md_var.h>
  89 #include <machine/pcb.h>
  90
  91 #include <vm/vm.h>
  92 #include <vm/vm_param.h>
  93 #include <vm/vm_kern.h>
  94 #include <vm/vm_page.h>
  95 #include <vm/vm_map.h>
  96 #include <vm/vm_extern.h>
  97
  98 void
  99 cpu_thread_exit(struct thread *td)
 100 {
 101
 102         /* Throw away the high FP registers. */
 103         ia64_highfp_drop(td);
 104 }
 105
 106 void
 107 cpu_thread_clean(struct thread *td)
 108 {
 109 }
 110
 111 void
 112 cpu_thread_alloc(struct thread *td)
 113 {
 114         intptr_t sp;
 115
 116         sp = td->td_kstack + td->td_kstack_pages * PAGE_SIZE;
 117         sp -= sizeof(struct pcb);
 118         td->td_pcb = (struct pcb *)sp;
 119         sp -= sizeof(struct trapframe);
 120         td->td_frame = (struct trapframe *)sp;
 121         td->td_frame->tf_length = sizeof(struct trapframe);
 122 }
 123
 124 void
 125 cpu_thread_free(struct thread *td)
 126 {
 127 }
 128
 129 void
 130 cpu_thread_swapin(struct thread *td)
 131 {
 132 }
 133
 134 void
 135 cpu_thread_swapout(struct thread *td)
 136 {
 137
 138         ia64_highfp_save(td);
 139 }
 140
 141 void
 142 cpu_set_syscall_retval(struct thread *td, int error)
 143 {
 144         struct proc *p;
 145         struct trapframe *tf;
 146
 147         if (error == EJUSTRETURN)
 148                 return;
 149
 150         tf = td->td_frame;
 151
 152         /*
 153          * Save the "raw" error code in r10. We use this to handle
 154          * syscall restarts (see do_ast()).
 155          */
 156         tf->tf_scratch.gr10 = error;
 157         if (error == 0) {
 158                 tf->tf_scratch.gr8 = td->td_retval[0];
 159                 tf->tf_scratch.gr9 = td->td_retval[1];
 160         } else if (error != ERESTART) {
 161                 p = td->td_proc;
 162                 if (error < p->p_sysent->sv_errsize)
 163                         error = p->p_sysent->sv_errtbl[error];
 164                 /*
 165                  * Translated error codes are returned in r8. User
 166                  */
 167                 tf->tf_scratch.gr8 = error;
 168         }
 169 }
 170
 171 void
 172 cpu_set_upcall(struct thread *td, struct thread *td0)
 173 {
 174         struct pcb *pcb;
 175         struct trapframe *tf;
 176
 177         ia64_highfp_save(td0);
 178
 179         tf = td->td_frame;
 180         KASSERT(tf != NULL, ("foo"));
 181         bcopy(td0->td_frame, tf, sizeof(*tf));
 182         tf->tf_length = sizeof(struct trapframe);
 183         tf->tf_flags = FRAME_SYSCALL;
 184         tf->tf_special.ndirty = 0;
 185         tf->tf_special.bspstore &= ~0x1ffUL;
 186         tf->tf_scratch.gr8 = 0;
 187         tf->tf_scratch.gr9 = 1;
 188         tf->tf_scratch.gr10 = 0;
 189
 190         pcb = td->td_pcb;
 191         KASSERT(pcb != NULL, ("foo"));
 192         bcopy(td0->td_pcb, pcb, sizeof(*pcb));
 193         pcb->pcb_special.bspstore = td->td_kstack;
 194         pcb->pcb_special.pfs = 0;
 195         pcb->pcb_current_pmap = vmspace_pmap(td0->td_proc->p_vmspace);
 196         pcb->pcb_special.sp = (uintptr_t)tf - 16;
 197         pcb->pcb_special.rp = FDESC_FUNC(fork_trampoline);
 198         cpu_set_fork_handler(td, (void (*)(void*))fork_return, td);
 199
 200         /* Setup to release the spin count in fork_exit(). */
 201         td->td_md.md_spinlock_count = 1;
 202         td->td_md.md_saved_intr = 1;
 203 }
 204
 205 void
 206 cpu_set_upcall_kse(struct thread *td, void (*entry)(void *), void *arg,
 207         stack_t *stack)
 208 {
 209         struct ia64_fdesc *fd;
 210         struct trapframe *tf;
 211         uint64_t ndirty, sp;
 212
 213         tf = td->td_frame;
 214         ndirty = tf->tf_special.ndirty + (tf->tf_special.bspstore & 0x1ffUL);
 215
 216         KASSERT((ndirty & ~PAGE_MASK) == 0,
 217             ("Whoa there! We have more than 8KB of dirty registers!"));
 218
 219         fd = (struct ia64_fdesc *)entry;
 220         sp = (uint64_t)stack->ss_sp;
 221
 222         bzero(&tf->tf_special, sizeof(tf->tf_special));
 223         tf->tf_special.iip = fuword(&fd->func);
 224         tf->tf_special.gp = fuword(&fd->gp);
 225         tf->tf_special.sp = (sp + stack->ss_size - 16) & ~15;
 226         tf->tf_special.rsc = 0xf;
 227         tf->tf_special.fpsr = IA64_FPSR_DEFAULT;
 228         tf->tf_special.psr = IA64_PSR_IC | IA64_PSR_I | IA64_PSR_IT |
 229             IA64_PSR_DT | IA64_PSR_RT | IA64_PSR_DFH | IA64_PSR_BN |
 230             IA64_PSR_CPL_USER;
 231
 232         if (tf->tf_flags & FRAME_SYSCALL) {
 233                 tf->tf_special.cfm = (3UL<<62) | (1UL<<7) | 1UL;
 234                 tf->tf_special.bspstore = sp + 8;
 235                 suword((caddr_t)sp, (uint64_t)arg);
 236         } else {
 237                 tf->tf_special.cfm = (1UL<<63) | (1UL<<7) | 1UL;
 238                 tf->tf_special.bspstore = sp;
 239                 tf->tf_special.ndirty = 8;
 240                 sp = td->td_kstack + ndirty - 8;
 241                 if ((sp & 0x1ff) == 0x1f8) {
 242                         *(uint64_t*)sp = 0;
 243                         tf->tf_special.ndirty += 8;
 244                         sp -= 8;
 245                 }
 246                 *(uint64_t*)sp = (uint64_t)arg;
 247         }
 248 }
 249
 250 int
 251 cpu_set_user_tls(struct thread *td, void *tls_base)
 252 {
 253         td->td_frame->tf_special.tp = (unsigned long)tls_base;
 254         return (0);
 255 }
 256
 257 /*
 258  * Finish a fork operation, with process p2 nearly set up.
 259  * Copy and update the pcb, set up the stack so that the child
 260  * ready to run and return to user mode.
 261  */
 262 void
 263 cpu_fork(struct thread *td1, struct proc *p2 __unused, struct thread *td2,
 264     int flags)
 265 {
 266         char *stackp;
 267         uint64_t ndirty;
 268
 269         KASSERT(td1 == curthread || td1 == &thread0,
 270             ("cpu_fork: td1 not curthread and not thread0"));
 271
 272         if ((flags & RFPROC) == 0)
 273                 return;
 274
 275         /*
 276          * Save the preserved registers and the high FP registers in the
 277          * PCB if we're the parent (ie td1 == curthread) so that we have
 278          * a valid PCB. This also causes a RSE flush. We don't have to
 279          * do that otherwise, because there wouldn't be anything important
 280          * to save.
 281          */
 282         if (td1 == curthread) {
 283                 if (savectx(td1->td_pcb) != 0)
 284                         panic("unexpected return from savectx()");
 285                 ia64_highfp_save(td1);
 286         }
 287
 288         /*
 289          * create the child's kernel stack and backing store. We basicly
 290          * create an image of the parent's stack and backing store and
 291          * adjust where necessary.
 292          */
 293         stackp = (char *)(td2->td_kstack + td2->td_kstack_pages * PAGE_SIZE);
 294
 295         stackp -= sizeof(struct pcb);
 296         td2->td_pcb = (struct pcb *)stackp;
 297         bcopy(td1->td_pcb, td2->td_pcb, sizeof(struct pcb));
 298
 299         stackp -= sizeof(struct trapframe);
 300         td2->td_frame = (struct trapframe *)stackp;
 301         bcopy(td1->td_frame, td2->td_frame, sizeof(struct trapframe));
 302         td2->td_frame->tf_length = sizeof(struct trapframe);
 303         ndirty = td2->td_frame->tf_special.ndirty +
 304             (td2->td_frame->tf_special.bspstore & 0x1ffUL);
 305         bcopy((void*)td1->td_kstack, (void*)td2->td_kstack, ndirty);
 306
 307         /* Set-up the return values as expected by the fork() libc stub. */
 308         if (td2->td_frame->tf_special.psr & IA64_PSR_IS) {
 309                 td2->td_frame->tf_scratch.gr8 = 0;
 310                 td2->td_frame->tf_scratch.gr10 = 1;
 311         } else {
 312                 td2->td_frame->tf_scratch.gr8 = 0;
 313                 td2->td_frame->tf_scratch.gr9 = 1;
 314                 td2->td_frame->tf_scratch.gr10 = 0;
 315         }
 316
 317         td2->td_pcb->pcb_special.bspstore = td2->td_kstack + ndirty;
 318         td2->td_pcb->pcb_special.pfs = 0;
 319         td2->td_pcb->pcb_current_pmap = vmspace_pmap(td2->td_proc->p_vmspace);
 320
 321         td2->td_pcb->pcb_special.sp = (uintptr_t)stackp - 16;
 322         td2->td_pcb->pcb_special.rp = FDESC_FUNC(fork_trampoline);
 323         cpu_set_fork_handler(td2, (void (*)(void*))fork_return, td2);
 324
 325         /* Setup to release the spin count in fork_exit(). */
 326         td2->td_md.md_spinlock_count = 1;
 327         td2->td_md.md_saved_intr = 1;
 328 }
 329
 330 /*
 331  * Intercept the return address from a freshly forked process that has NOT
 332  * been scheduled yet.
 333  *
 334  * This is needed to make kernel threads stay in kernel mode.
 335  */
 336 void
 337 cpu_set_fork_handler(td, func, arg)
 338         struct thread *td;
 339         void (*func)(void *);
 340         void *arg;
 341 {
 342         td->td_frame->tf_scratch.gr2 = (u_int64_t)func;
 343         td->td_frame->tf_scratch.gr3 = (u_int64_t)arg;
 344 }
 345
 346 /*
 347  * cpu_exit is called as the last action during exit.
 348  * We drop the fp state (if we have it) and switch to a live one.
 349  */
 350 void
 351 cpu_exit(struct thread *td)
 352 {
 353 }
 354
 355 /*
 356  * Allocate an sf_buf for the given vm_page.  On this machine, however, there
 357  * is no sf_buf object.  Instead, an opaque pointer to the given vm_page is
 358  * returned.
 359  */
 360 struct sf_buf *
 361 sf_buf_alloc(struct vm_page *m, int pri)
 362 {
 363
 364         return ((struct sf_buf *)m);
 365 }
 366
 367 /*
 368  * Free the sf_buf.  In fact, do nothing because there are no resources
 369  * associated with the sf_buf.
 370  */
 371 void
 372 sf_buf_free(struct sf_buf *sf)
 373 {
 374 }
 375
 376 /*
 377  * Software interrupt handler for queued VM system processing.
 378  */
 379 void
 380 swi_vm(void *dummy)
 381 {
 382
 383         if (busdma_swi_pending != 0)
 384                 busdma_swi();
 385 }