sys/powerpc/aim/machdep.c

   1 /*-
   2  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
   3  * Copyright (C) 1995, 1996 TooLs GmbH.
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by TooLs GmbH.
  17  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  25  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  26  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  27  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  28  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  29  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*-
  32  * Copyright (C) 2001 Benno Rice
  33  * All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  *
  44  * THIS SOFTWARE IS PROVIDED BY Benno Rice ``AS IS'' AND ANY EXPRESS OR
  45  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  46  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  47  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  48  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  49  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  50  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  51  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  52  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  53  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  54  *      $NetBSD: machdep.c,v 1.74.2.1 2000/11/01 16:13:48 tv Exp $
  55  */
  56
  57 #include <sys/cdefs.h>
  58 __FBSDID("$FreeBSD$");
  59
  60 #include "opt_compat.h"
  61 #include "opt_ddb.h"
  62 #include "opt_kstack_pages.h"
  63 #include "opt_msgbuf.h"
  64
  65 #include <sys/param.h>
  66 #include <sys/proc.h>
  67 #include <sys/systm.h>
  68 #include <sys/bio.h>
  69 #include <sys/buf.h>
  70 #include <sys/bus.h>
  71 #include <sys/cons.h>
  72 #include <sys/cpu.h>
  73 #include <sys/eventhandler.h>
  74 #include <sys/exec.h>
  75 #include <sys/imgact.h>
  76 #include <sys/kdb.h>
  77 #include <sys/kernel.h>
  78 #include <sys/ktr.h>
  79 #include <sys/linker.h>
  80 #include <sys/lock.h>
  81 #include <sys/malloc.h>
  82 #include <sys/mbuf.h>
  83 #include <sys/msgbuf.h>
  84 #include <sys/mutex.h>
  85 #include <sys/ptrace.h>
  86 #include <sys/reboot.h>
  87 #include <sys/signalvar.h>
  88 #include <sys/sysctl.h>
  89 #include <sys/sysent.h>
  90 #include <sys/sysproto.h>
  91 #include <sys/ucontext.h>
  92 #include <sys/uio.h>
  93 #include <sys/vmmeter.h>
  94 #include <sys/vnode.h>
  95
  96 #include <net/netisr.h>
  97
  98 #include <vm/vm.h>
  99 #include <vm/vm_extern.h>
 100 #include <vm/vm_kern.h>
 101 #include <vm/vm_page.h>
 102 #include <vm/vm_map.h>
 103 #include <vm/vm_object.h>
 104 #include <vm/vm_pager.h>
 105
 106 #include <machine/bat.h>
 107 #include <machine/cpu.h>
 108 #include <machine/elf.h>
 109 #include <machine/fpu.h>
 110 #include <machine/md_var.h>
 111 #include <machine/metadata.h>
 112 #include <machine/mmuvar.h>
 113 #include <machine/pcb.h>
 114 #include <machine/powerpc.h>
 115 #include <machine/reg.h>
 116 #include <machine/sigframe.h>
 117 #include <machine/trap.h>
 118 #include <machine/vmparam.h>
 119
 120 #include <ddb/ddb.h>
 121
 122 #include <dev/ofw/openfirm.h>
 123
 124 #ifdef DDB
 125 extern vm_offset_t ksym_start, ksym_end;
 126 #endif
 127
 128 int cold = 1;
 129
 130 struct          pcpu __pcpu[MAXCPU];
 131 struct          trapframe frame0;
 132
 133 vm_offset_t     kstack0;
 134 vm_offset_t     kstack0_phys;
 135
 136 char            machine[] = "powerpc";
 137 SYSCTL_STRING(_hw, HW_MACHINE, machine, CTLFLAG_RD, machine, 0, "");
 138
 139 static char     model[128];
 140 SYSCTL_STRING(_hw, HW_MODEL, model, CTLFLAG_RD, model, 0, "");
 141
 142 static int cacheline_size = CACHELINESIZE;
 143 SYSCTL_INT(_machdep, CPU_CACHELINE, cacheline_size,
 144            CTLFLAG_RD, &cacheline_size, 0, "");
 145
 146 static void     cpu_startup(void *);
 147 SYSINIT(cpu, SI_SUB_CPU, SI_ORDER_FIRST, cpu_startup, NULL)
 148
 149 void            powerpc_init(u_int, u_int, u_int, void *);
 150
 151 int             save_ofw_mapping(void);
 152 int             restore_ofw_mapping(void);
 153
 154 void            install_extint(void (*)(void));
 155
 156 int             setfault(faultbuf);             /* defined in locore.S */
 157
 158 static int      grab_mcontext(struct thread *, mcontext_t *, int);
 159
 160 void            asm_panic(char *);
 161
 162 long            Maxmem = 0;
 163 long            realmem = 0;
 164
 165 struct pmap     ofw_pmap;
 166 extern int      ofmsr;
 167
 168 struct bat      battable[16];
 169
 170 struct kva_md_info kmi;
 171
 172 void setPQL2(int *const size, int *const ways);
 173
 174 void
 175 setPQL2(int *const size, int *const ways)
 176 {
 177         return;
 178 }
 179
 180 static void
 181 powerpc_ofw_shutdown(void *junk, int howto)
 182 {
 183         if (howto & RB_HALT) {
 184                 OF_halt();
 185         }
 186         OF_reboot();
 187 }
 188
 189 static void
 190 cpu_startup(void *dummy)
 191 {
 192
 193         /*
 194          * Initialise the decrementer-based clock.
 195          */
 196         decr_init();
 197
 198         /*
 199          * Good {morning,afternoon,evening,night}.
 200          */
 201         cpu_setup(PCPU_GET(cpuid));
 202
 203         /* startrtclock(); */
 204 #ifdef PERFMON
 205         perfmon_init();
 206 #endif
 207         printf("real memory  = %ld (%ld MB)\n", ptoa(physmem),
 208             ptoa(physmem) / 1048576);
 209         realmem = physmem;
 210
 211         /*
 212          * Display any holes after the first chunk of extended memory.
 213          */
 214         if (bootverbose) {
 215                 int indx;
 216
 217                 printf("Physical memory chunk(s):\n");
 218                 for (indx = 0; phys_avail[indx + 1] != 0; indx += 2) {
 219                         int size1 = phys_avail[indx + 1] - phys_avail[indx];
 220
 221                         printf("0x%08x - 0x%08x, %d bytes (%d pages)\n",
 222                             phys_avail[indx], phys_avail[indx + 1] - 1, size1,
 223                             size1 / PAGE_SIZE);
 224                 }
 225         }
 226
 227         vm_ksubmap_init(&kmi);
 228
 229         printf("avail memory = %ld (%ld MB)\n", ptoa(cnt.v_free_count),
 230             ptoa(cnt.v_free_count) / 1048576);
 231
 232         /*
 233          * Set up buffers, so they can be used to read disk labels.
 234          */
 235         bufinit();
 236         vm_pager_bufferinit();
 237
 238         EVENTHANDLER_REGISTER(shutdown_final, powerpc_ofw_shutdown, 0,
 239             SHUTDOWN_PRI_LAST);
 240
 241 #ifdef SMP
 242         /*
 243          * OK, enough kmem_alloc/malloc state should be up, lets get on with it!
 244          */
 245         mp_start();                     /* fire up the secondaries */
 246         mp_announce();
 247 #endif  /* SMP */
 248 }
 249
 250 extern char     kernel_text[], _end[];
 251
 252 extern void     *trapcode, *trapsize;
 253 extern void     *alitrap, *alisize;
 254 extern void     *dsitrap, *dsisize;
 255 extern void     *decrint, *decrsize;
 256 extern void     *extint, *extsize;
 257 extern void     *dblow, *dbsize;
 258 extern void     *vectrap, *vectrapsize;
 259
 260 void
 261 powerpc_init(u_int startkernel, u_int endkernel, u_int basekernel, void *mdp)
 262 {
 263         struct          pcpu *pc;
 264         vm_offset_t     end, off;
 265         void            *kmdp;
 266         char            *env;
 267
 268         end = 0;
 269         kmdp = NULL;
 270
 271         /*
 272          * Parse metadata if present and fetch parameters.  Must be done
 273          * before console is inited so cninit gets the right value of
 274          * boothowto.
 275          */
 276         if (mdp != NULL) {
 277                 preload_metadata = mdp;
 278                 kmdp = preload_search_by_type("elf kernel");
 279                 if (kmdp != NULL) {
 280                         boothowto = MD_FETCH(kmdp, MODINFOMD_HOWTO, int);
 281                         kern_envp = MD_FETCH(kmdp, MODINFOMD_ENVP, char *);
 282                         end = MD_FETCH(kmdp, MODINFOMD_KERNEND, vm_offset_t);
 283 #ifdef DDB
 284                         ksym_start = MD_FETCH(kmdp, MODINFOMD_SSYM, uintptr_t);
 285                         ksym_end = MD_FETCH(kmdp, MODINFOMD_ESYM, uintptr_t);
 286 #endif
 287                 }
 288         }
 289
 290         /*
 291          * Init params/tunables that can be overridden by the loader
 292          */
 293         init_param1();
 294
 295         /*
 296          * Start initializing proc0 and thread0.
 297          */
 298 #ifdef KSE
 299         proc_linkup(&proc0, &ksegrp0, &thread0);
 300 #else
 301         proc_linkup(&proc0, &thread0);
 302 #endif
 303         thread0.td_frame = &frame0;
 304
 305         /*
 306          * Set up per-cpu data.
 307          */
 308         pc = &__pcpu[0];
 309         pcpu_init(pc, 0, sizeof(struct pcpu));
 310         pc->pc_curthread = &thread0;
 311         pc->pc_curpcb = thread0.td_pcb;
 312         pc->pc_cpuid = 0;
 313
 314         __asm __volatile("mtsprg 0, %0" :: "r"(pc));
 315
 316         mutex_init();
 317
 318         /*
 319          * Initialize the console before printing anything.
 320          */
 321         cninit();
 322
 323         /*
 324          * Complain if there is no metadata.
 325          */
 326         if (mdp == NULL || kmdp == NULL) {
 327                 printf("powerpc_init: no loader metadata.\n");
 328         }
 329
 330         kdb_init();
 331
 332         kobj_machdep_init();
 333
 334         /*
 335          * XXX: Initialize the interrupt tables.
 336          *      Disable translation in case the vector area
 337          *      hasn't been mapped (G5)
 338          */
 339         mtmsr(mfmsr() & ~(PSL_IR | PSL_DR));
 340         isync();
 341         bcopy(&trapcode, (void *)EXC_RST,  (size_t)&trapsize);
 342         bcopy(&trapcode, (void *)EXC_MCHK, (size_t)&trapsize);
 343         bcopy(&dsitrap,  (void *)EXC_DSI,  (size_t)&dsisize);
 344         bcopy(&trapcode, (void *)EXC_ISI,  (size_t)&trapsize);
 345         bcopy(&trapcode, (void *)EXC_EXI,  (size_t)&trapsize);
 346         bcopy(&alitrap,  (void *)EXC_ALI,  (size_t)&alisize);
 347         bcopy(&trapcode, (void *)EXC_PGM,  (size_t)&trapsize);
 348         bcopy(&trapcode, (void *)EXC_FPU,  (size_t)&trapsize);
 349         bcopy(&trapcode, (void *)EXC_DECR, (size_t)&trapsize);
 350         bcopy(&trapcode, (void *)EXC_SC,   (size_t)&trapsize);
 351         bcopy(&trapcode, (void *)EXC_TRC,  (size_t)&trapsize);
 352         bcopy(&trapcode, (void *)EXC_FPA,  (size_t)&trapsize);
 353         bcopy(&vectrap,  (void *)EXC_VEC,  (size_t)&vectrapsize);
 354         bcopy(&trapcode, (void *)EXC_VECAST, (size_t)&trapsize);
 355         bcopy(&trapcode, (void *)EXC_THRM, (size_t)&trapsize);
 356         bcopy(&trapcode, (void *)EXC_BPT,  (size_t)&trapsize);
 357 #ifdef KDB
 358         bcopy(&dblow,    (void *)EXC_RST,  (size_t)&dbsize);
 359         bcopy(&dblow,    (void *)EXC_MCHK, (size_t)&dbsize);
 360         bcopy(&dblow,   (void *)EXC_PGM,  (size_t)&dbsize);
 361         bcopy(&dblow,   (void *)EXC_TRC,  (size_t)&dbsize);
 362         bcopy(&dblow,   (void *)EXC_BPT,  (size_t)&dbsize);
 363 #endif
 364         __syncicache(EXC_RSVD, EXC_LAST - EXC_RSVD);
 365
 366         /*
 367          * Make sure translation has been enabled
 368          */
 369         mtmsr(mfmsr() | PSL_IR|PSL_DR|PSL_ME|PSL_RI);
 370         isync();
 371
 372         /*
 373          * Initialise virtual memory.
 374          */
 375         pmap_mmu_install(MMU_TYPE_OEA, 0);              /* XXX temporary */
 376         pmap_bootstrap(startkernel, endkernel);
 377
 378         /*
 379          * Initialize params/tunables that are derived from memsize
 380          */
 381         init_param2(physmem);
 382
 383         /*
 384          * Grab booted kernel's name
 385          */
 386         env = getenv("kernelname");
 387         if (env != NULL) {
 388                 strlcpy(kernelname, env, sizeof(kernelname));
 389                 freeenv(env);
 390         }
 391
 392         /*
 393          * Finish setting up thread0.
 394          */
 395         thread0.td_kstack = kstack0;
 396         thread0.td_pcb = (struct pcb *)
 397             (thread0.td_kstack + KSTACK_PAGES * PAGE_SIZE) - 1;
 398
 399         /*
 400          * Map and initialise the message buffer.
 401          */
 402         for (off = 0; off < round_page(MSGBUF_SIZE); off += PAGE_SIZE)
 403                 pmap_kenter((vm_offset_t)msgbufp + off, msgbuf_phys + off);
 404         msgbufinit(msgbufp, MSGBUF_SIZE);
 405
 406 #ifdef KDB
 407         if (boothowto & RB_KDB)
 408                 kdb_enter("Boot flags requested debugger");
 409 #endif
 410 }
 411
 412 void
 413 bzero(void *buf, size_t len)
 414 {
 415         caddr_t p;
 416
 417         p = buf;
 418
 419         while (((vm_offset_t) p & (sizeof(u_long) - 1)) && len) {
 420                 *p++ = 0;
 421                 len--;
 422         }
 423
 424         while (len >= sizeof(u_long) * 8) {
 425                 *(u_long*) p = 0;
 426                 *((u_long*) p + 1) = 0;
 427                 *((u_long*) p + 2) = 0;
 428                 *((u_long*) p + 3) = 0;
 429                 len -= sizeof(u_long) * 8;
 430                 *((u_long*) p + 4) = 0;
 431                 *((u_long*) p + 5) = 0;
 432                 *((u_long*) p + 6) = 0;
 433                 *((u_long*) p + 7) = 0;
 434                 p += sizeof(u_long) * 8;
 435         }
 436
 437         while (len >= sizeof(u_long)) {
 438                 *(u_long*) p = 0;
 439                 len -= sizeof(u_long);
 440                 p += sizeof(u_long);
 441         }
 442
 443         while (len) {
 444                 *p++ = 0;
 445                 len--;
 446         }
 447 }
 448
 449 void
 450 sendsig(sig_t catcher, ksiginfo_t *ksi, sigset_t *mask)
 451 {
 452         struct trapframe *tf;
 453         struct sigframe *sfp;
 454         struct sigacts *psp;
 455         struct sigframe sf;
 456         struct thread *td;
 457         struct proc *p;
 458         int oonstack, rndfsize;
 459         int sig;
 460         int code;
 461
 462         td = curthread;
 463         p = td->td_proc;
 464         PROC_LOCK_ASSERT(p, MA_OWNED);
 465         sig = ksi->ksi_signo;
 466         code = ksi->ksi_code;
 467         psp = p->p_sigacts;
 468         mtx_assert(&psp->ps_mtx, MA_OWNED);
 469         tf = td->td_frame;
 470         oonstack = sigonstack(tf->fixreg[1]);
 471
 472         rndfsize = ((sizeof(sf) + 15) / 16) * 16;
 473
 474         CTR4(KTR_SIG, "sendsig: td=%p (%s) catcher=%p sig=%d", td, p->p_comm,
 475              catcher, sig);
 476
 477         /*
 478          * Save user context
 479          */
 480         memset(&sf, 0, sizeof(sf));
 481         grab_mcontext(td, &sf.sf_uc.uc_mcontext, 0);
 482         sf.sf_uc.uc_sigmask = *mask;
 483         sf.sf_uc.uc_stack = td->td_sigstk;
 484         sf.sf_uc.uc_stack.ss_flags = (td->td_pflags & TDP_ALTSTACK)
 485             ? ((oonstack) ? SS_ONSTACK : 0) : SS_DISABLE;
 486
 487         sf.sf_uc.uc_mcontext.mc_onstack = (oonstack) ? 1 : 0;
 488
 489         /*
 490          * Allocate and validate space for the signal handler context.
 491          */
 492         if ((td->td_pflags & TDP_ALTSTACK) != 0 && !oonstack &&
 493             SIGISMEMBER(psp->ps_sigonstack, sig)) {
 494                 sfp = (struct sigframe *)((caddr_t)td->td_sigstk.ss_sp +
 495                    td->td_sigstk.ss_size - rndfsize);
 496         } else {
 497                 sfp = (struct sigframe *)(tf->fixreg[1] - rndfsize);
 498         }
 499
 500         /*
 501          * Translate the signal if appropriate (Linux emu ?)
 502          */
 503         if (p->p_sysent->sv_sigtbl && sig <= p->p_sysent->sv_sigsize)
 504                 sig = p->p_sysent->sv_sigtbl[_SIG_IDX(sig)];
 505
 506         /*
 507          * Save the floating-point state, if necessary, then copy it.
 508          */
 509         /* XXX */
 510
 511         /*
 512          * Set up the registers to return to sigcode.
 513          *
 514          *   r1/sp - sigframe ptr
 515          *   lr    - sig function, dispatched to by blrl in trampoline
 516          *   r3    - sig number
 517          *   r4    - SIGINFO ? &siginfo : exception code
 518          *   r5    - user context
 519          *   srr0  - trampoline function addr
 520          */
 521         tf->lr = (register_t)catcher;
 522         tf->fixreg[1] = (register_t)sfp;
 523         tf->fixreg[FIRSTARG] = sig;
 524         tf->fixreg[FIRSTARG+2] = (register_t)&sfp->sf_uc;
 525         if (SIGISMEMBER(psp->ps_siginfo, sig)) {
 526                 /*
 527                  * Signal handler installed with SA_SIGINFO.
 528                  */
 529                 tf->fixreg[FIRSTARG+1] = (register_t)&sfp->sf_si;
 530
 531                 /*
 532                  * Fill siginfo structure.
 533                  */
 534                 sf.sf_si = ksi->ksi_info;
 535                 sf.sf_si.si_signo = sig;
 536                 sf.sf_si.si_addr = (void *) ((tf->exc == EXC_DSI) ?
 537                                              tf->dar : tf->srr0);
 538         } else {
 539                 /* Old FreeBSD-style arguments. */
 540                 tf->fixreg[FIRSTARG+1] = code;
 541                 tf->fixreg[FIRSTARG+3] = (tf->exc == EXC_DSI) ?
 542                                              tf->dar : tf->srr0;
 543         }
 544         mtx_unlock(&psp->ps_mtx);
 545         PROC_UNLOCK(p);
 546
 547         tf->srr0 = (register_t)(PS_STRINGS - *(p->p_sysent->sv_szsigcode));
 548
 549         /*
 550          * copy the frame out to userland.
 551          */
 552         if (copyout((caddr_t)&sf, (caddr_t)sfp, sizeof(sf)) != 0) {
 553                 /*
 554                  * Process has trashed its stack. Kill it.
 555                  */
 556                 CTR2(KTR_SIG, "sendsig: sigexit td=%p sfp=%p", td, sfp);
 557                 PROC_LOCK(p);
 558                 sigexit(td, SIGILL);
 559         }
 560
 561         CTR3(KTR_SIG, "sendsig: return td=%p pc=%#x sp=%#x", td,
 562              tf->srr0, tf->fixreg[1]);
 563
 564         PROC_LOCK(p);
 565         mtx_lock(&psp->ps_mtx);
 566 }
 567
 568 int
 569 sigreturn(struct thread *td, struct sigreturn_args *uap)
 570 {
 571         struct proc *p;
 572         ucontext_t uc;
 573         int error;
 574
 575         CTR2(KTR_SIG, "sigreturn: td=%p ucp=%p", td, uap->sigcntxp);
 576
 577         if (copyin(uap->sigcntxp, &uc, sizeof(uc)) != 0) {
 578                 CTR1(KTR_SIG, "sigreturn: efault td=%p", td);
 579                 return (EFAULT);
 580         }
 581
 582         error = set_mcontext(td, &uc.uc_mcontext);
 583         if (error != 0)
 584                 return (error);
 585
 586         p = td->td_proc;
 587         PROC_LOCK(p);
 588         td->td_sigmask = uc.uc_sigmask;
 589         SIG_CANTMASK(td->td_sigmask);
 590         signotify(td);
 591         PROC_UNLOCK(p);
 592
 593         CTR3(KTR_SIG, "sigreturn: return td=%p pc=%#x sp=%#x",
 594              td, uc.uc_mcontext.mc_srr0, uc.uc_mcontext.mc_gpr[1]);
 595
 596         return (EJUSTRETURN);
 597 }
 598
 599 #ifdef COMPAT_FREEBSD4
 600 int
 601 freebsd4_sigreturn(struct thread *td, struct freebsd4_sigreturn_args *uap)
 602 {
 603
 604         return sigreturn(td, (struct sigreturn_args *)uap);
 605 }
 606 #endif
 607
 608 /*
 609  * Construct a PCB from a trapframe. This is called from kdb_trap() where
 610  * we want to start a backtrace from the function that caused us to enter
 611  * the debugger. We have the context in the trapframe, but base the trace
 612  * on the PCB. The PCB doesn't have to be perfect, as long as it contains
 613  * enough for a backtrace.
 614  */
 615 void
 616 makectx(struct trapframe *tf, struct pcb *pcb)
 617 {
 618
 619         pcb->pcb_lr = tf->srr0;
 620         pcb->pcb_sp = tf->fixreg[1];
 621 }
 622
 623 /*
 624  * get_mcontext/sendsig helper routine that doesn't touch the
 625  * proc lock
 626  */
 627 static int
 628 grab_mcontext(struct thread *td, mcontext_t *mcp, int flags)
 629 {
 630         struct pcb *pcb;
 631
 632         pcb = td->td_pcb;
 633
 634         memset(mcp, 0, sizeof(mcontext_t));
 635
 636         mcp->mc_vers = _MC_VERSION;
 637         mcp->mc_flags = 0;
 638         memcpy(&mcp->mc_frame, td->td_frame, sizeof(struct trapframe));
 639         if (flags & GET_MC_CLEAR_RET) {
 640                 mcp->mc_gpr[3] = 0;
 641                 mcp->mc_gpr[4] = 0;
 642         }
 643
 644         /*
 645          * This assumes that floating-point context is *not* lazy,
 646          * so if the thread has used FP there would have been a
 647          * FP-unavailable exception that would have set things up
 648          * correctly.
 649          */
 650         if (pcb->pcb_flags & PCB_FPU) {
 651                 KASSERT(td == curthread,
 652                         ("get_mcontext: fp save not curthread"));
 653                 critical_enter();
 654                 save_fpu(td);
 655                 critical_exit();
 656                 mcp->mc_flags |= _MC_FP_VALID;
 657                 memcpy(&mcp->mc_fpscr, &pcb->pcb_fpu.fpscr, sizeof(double));
 658                 memcpy(mcp->mc_fpreg, pcb->pcb_fpu.fpr, 32*sizeof(double));
 659         }
 660
 661         /* XXX Altivec context ? */
 662
 663         mcp->mc_len = sizeof(*mcp);
 664
 665         return (0);
 666 }
 667
 668 int
 669 get_mcontext(struct thread *td, mcontext_t *mcp, int flags)
 670 {
 671         int error;
 672
 673         error = grab_mcontext(td, mcp, flags);
 674         if (error == 0) {
 675                 PROC_LOCK(curthread->td_proc);
 676                 mcp->mc_onstack = sigonstack(td->td_frame->fixreg[1]);
 677                 PROC_UNLOCK(curthread->td_proc);
 678         }
 679
 680         return (error);
 681 }
 682
 683 int
 684 set_mcontext(struct thread *td, const mcontext_t *mcp)
 685 {
 686         struct pcb *pcb;
 687         struct trapframe *tf;
 688
 689         pcb = td->td_pcb;
 690         tf = td->td_frame;
 691
 692         if (mcp->mc_vers != _MC_VERSION ||
 693             mcp->mc_len != sizeof(*mcp))
 694                 return (EINVAL);
 695
 696         /*
 697          * Don't let the user set privileged MSR bits
 698          */
 699         if ((mcp->mc_srr1 & PSL_USERSTATIC) != (tf->srr1 & PSL_USERSTATIC)) {
 700                 return (EINVAL);
 701         }
 702
 703         memcpy(tf, mcp->mc_frame, sizeof(mcp->mc_frame));
 704
 705         if (mcp->mc_flags & _MC_FP_VALID) {
 706                 if ((pcb->pcb_flags & PCB_FPU) != PCB_FPU) {
 707                         critical_enter();
 708                         enable_fpu(td);
 709                         critical_exit();
 710                 }
 711                 memcpy(&pcb->pcb_fpu.fpscr, &mcp->mc_fpscr, sizeof(double));
 712                 memcpy(pcb->pcb_fpu.fpr, mcp->mc_fpreg, 32*sizeof(double));
 713         }
 714
 715         /* XXX Altivec context? */
 716
 717         return (0);
 718 }
 719
 720 void
 721 cpu_boot(int howto)
 722 {
 723 }
 724
 725 /* Get current clock frequency for the given cpu id. */
 726 int
 727 cpu_est_clockrate(int cpu_id, uint64_t *rate)
 728 {
 729
 730         return (ENXIO);
 731 }
 732
 733 /*
 734  * Shutdown the CPU as much as possible.
 735  */
 736 void
 737 cpu_halt(void)
 738 {
 739
 740         OF_exit();
 741 }
 742
 743 void
 744 cpu_idle(void)
 745 {
 746         /* TODO: Insert code to halt (until next interrupt) */
 747
 748 #ifdef INVARIANTS
 749         if ((mfmsr() & PSL_EE) != PSL_EE) {
 750                 struct thread *td = curthread;
 751                 printf("td msr %x\n", td->td_md.md_saved_msr);
 752                 panic("ints disabled in idleproc!");
 753         }
 754 #endif
 755 }
 756
 757 /*
 758  * Set set up registers on exec.
 759  */
 760 void
 761 exec_setregs(struct thread *td, u_long entry, u_long stack, u_long ps_strings)
 762 {
 763         struct trapframe        *tf;
 764         struct ps_strings       arginfo;
 765
 766         tf = trapframe(td);
 767         bzero(tf, sizeof *tf);
 768         tf->fixreg[1] = -roundup(-stack + 8, 16);
 769
 770         /*
 771          * XXX Machine-independent code has already copied arguments and
 772          * XXX environment to userland.  Get them back here.
 773          */
 774         (void)copyin((char *)PS_STRINGS, &arginfo, sizeof(arginfo));
 775
 776         /*
 777          * Set up arguments for _start():
 778          *      _start(argc, argv, envp, obj, cleanup, ps_strings);
 779          *
 780          * Notes:
 781          *      - obj and cleanup are the auxilliary and termination
 782          *        vectors.  They are fixed up by ld.elf_so.
 783          *      - ps_strings is a NetBSD extention, and will be
 784          *        ignored by executables which are strictly
 785          *        compliant with the SVR4 ABI.
 786          *
 787          * XXX We have to set both regs and retval here due to different
 788          * XXX calling convention in trap.c and init_main.c.
 789          */
 790         /*
 791          * XXX PG: these get overwritten in the syscall return code.
 792          * execve() should return EJUSTRETURN, like it does on NetBSD.
 793          * Emulate by setting the syscall return value cells. The
 794          * registers still have to be set for init's fork trampoline.
 795          */
 796         td->td_retval[0] = arginfo.ps_nargvstr;
 797         td->td_retval[1] = (register_t)arginfo.ps_argvstr;
 798         tf->fixreg[3] = arginfo.ps_nargvstr;
 799         tf->fixreg[4] = (register_t)arginfo.ps_argvstr;
 800         tf->fixreg[5] = (register_t)arginfo.ps_envstr;
 801         tf->fixreg[6] = 0;                      /* auxillary vector */
 802         tf->fixreg[7] = 0;                      /* termination vector */
 803         tf->fixreg[8] = (register_t)PS_STRINGS; /* NetBSD extension */
 804
 805         tf->srr0 = entry;
 806         tf->srr1 = PSL_MBO | PSL_USERSET | PSL_FE_DFLT;
 807         td->td_pcb->pcb_flags = 0;
 808 }
 809
 810 int
 811 fill_regs(struct thread *td, struct reg *regs)
 812 {
 813         struct trapframe *tf;
 814
 815         tf = td->td_frame;
 816         memcpy(regs, tf, sizeof(struct reg));
 817
 818         return (0);
 819 }
 820
 821 int
 822 fill_dbregs(struct thread *td, struct dbreg *dbregs)
 823 {
 824         /* No debug registers on PowerPC */
 825         return (ENOSYS);
 826 }
 827
 828 int
 829 fill_fpregs(struct thread *td, struct fpreg *fpregs)
 830 {
 831         struct pcb *pcb;
 832
 833         pcb = td->td_pcb;
 834
 835         if ((pcb->pcb_flags & PCB_FPU) == 0)
 836                 memset(fpregs, 0, sizeof(struct fpreg));
 837         else
 838                 memcpy(fpregs, &pcb->pcb_fpu, sizeof(struct fpreg));
 839
 840         return (0);
 841 }
 842
 843 int
 844 set_regs(struct thread *td, struct reg *regs)
 845 {
 846         struct trapframe *tf;
 847
 848         tf = td->td_frame;
 849         memcpy(tf, regs, sizeof(struct reg));
 850
 851         return (0);
 852 }
 853
 854 int
 855 set_dbregs(struct thread *td, struct dbreg *dbregs)
 856 {
 857         /* No debug registers on PowerPC */
 858         return (ENOSYS);
 859 }
 860
 861 int
 862 set_fpregs(struct thread *td, struct fpreg *fpregs)
 863 {
 864         struct pcb *pcb;
 865
 866         pcb = td->td_pcb;
 867         if ((pcb->pcb_flags & PCB_FPU) == 0)
 868                 enable_fpu(td);
 869         memcpy(&pcb->pcb_fpu, fpregs, sizeof(struct fpreg));
 870
 871         return (0);
 872 }
 873
 874 int
 875 ptrace_set_pc(struct thread *td, unsigned long addr)
 876 {
 877         struct trapframe *tf;
 878
 879         tf = td->td_frame;
 880         tf->srr0 = (register_t)addr;
 881
 882         return (0);
 883 }
 884
 885 int
 886 ptrace_single_step(struct thread *td)
 887 {
 888         struct trapframe *tf;
 889
 890         tf = td->td_frame;
 891         tf->srr1 |= PSL_SE;
 892
 893         return (0);
 894 }
 895
 896 int
 897 ptrace_clear_single_step(struct thread *td)
 898 {
 899         struct trapframe *tf;
 900
 901         tf = td->td_frame;
 902         tf->srr1 &= ~PSL_SE;
 903
 904         return (0);
 905 }
 906
 907 /*
 908  * Initialise a struct pcpu.
 909  */
 910 void
 911 cpu_pcpu_init(struct pcpu *pcpu, int cpuid, size_t sz)
 912 {
 913
 914 }
 915
 916 void
 917 spinlock_enter(void)
 918 {
 919         struct thread *td;
 920
 921         td = curthread;
 922         if (td->td_md.md_spinlock_count == 0)
 923                 td->td_md.md_saved_msr = intr_disable();
 924         td->td_md.md_spinlock_count++;
 925         critical_enter();
 926 }
 927
 928 void
 929 spinlock_exit(void)
 930 {
 931         struct thread *td;
 932
 933         td = curthread;
 934         critical_exit();
 935         td->td_md.md_spinlock_count--;
 936         if (td->td_md.md_spinlock_count == 0)
 937                 intr_restore(td->td_md.md_saved_msr);
 938 }
 939
 940 /*
 941  * kcopy(const void *src, void *dst, size_t len);
 942  *
 943  * Copy len bytes from src to dst, aborting if we encounter a fatal
 944  * page fault.
 945  *
 946  * kcopy() _must_ save and restore the old fault handler since it is
 947  * called by uiomove(), which may be in the path of servicing a non-fatal
 948  * page fault.
 949  */
 950 int
 951 kcopy(const void *src, void *dst, size_t len)
 952 {
 953         struct thread   *td;
 954         faultbuf        env, *oldfault;
 955         int             rv;
 956
 957         td = PCPU_GET(curthread);
 958         oldfault = td->td_pcb->pcb_onfault;
 959         if ((rv = setfault(env)) != 0) {
 960                 td->td_pcb->pcb_onfault = oldfault;
 961                 return rv;
 962         }
 963
 964         memcpy(dst, src, len);
 965
 966         td->td_pcb->pcb_onfault = oldfault;
 967         return (0);
 968 }
 969
 970 void
 971 asm_panic(char *pstr)
 972 {
 973         panic(pstr);
 974 }
 975
 976 int db_trap_glue(struct trapframe *);           /* Called from trap_subr.S */
 977
 978 int
 979 db_trap_glue(struct trapframe *frame)
 980 {
 981         if (!(frame->srr1 & PSL_PR)
 982             && (frame->exc == EXC_TRC || frame->exc == EXC_RUNMODETRC
 983                 || (frame->exc == EXC_PGM
 984                     && (frame->srr1 & 0x20000))
 985                 || frame->exc == EXC_BPT
 986                 || frame->exc == EXC_DSI)) {
 987                 int type = frame->exc;
 988                 if (type == EXC_PGM && (frame->srr1 & 0x20000)) {
 989                         type = T_BREAKPOINT;
 990                 }
 991                 return (kdb_trap(type, 0, frame));
 992         }
 993
 994         return (0);
 995 }