Home | History | Annotate | Line # | Download | only in alpha
machdep.c revision 1.73
      1  1.73       cgd /* $NetBSD: machdep.c,v 1.73 1997/04/07 06:09:06 cgd Exp $ */
      2   1.1       cgd 
      3   1.1       cgd /*
      4  1.16       cgd  * Copyright (c) 1994, 1995, 1996 Carnegie-Mellon University.
      5   1.1       cgd  * All rights reserved.
      6   1.1       cgd  *
      7   1.1       cgd  * Author: Chris G. Demetriou
      8   1.1       cgd  *
      9   1.1       cgd  * Permission to use, copy, modify and distribute this software and
     10   1.1       cgd  * its documentation is hereby granted, provided that both the copyright
     11   1.1       cgd  * notice and this permission notice appear in all copies of the
     12   1.1       cgd  * software, derivative works or modified versions, and any portions
     13   1.1       cgd  * thereof, and that both notices appear in supporting documentation.
     14   1.1       cgd  *
     15   1.1       cgd  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
     16   1.1       cgd  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
     17   1.1       cgd  * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     18   1.1       cgd  *
     19   1.1       cgd  * Carnegie Mellon requests users of this software to return to
     20   1.1       cgd  *
     21   1.1       cgd  *  Software Distribution Coordinator  or  Software.Distribution (at) CS.CMU.EDU
     22   1.1       cgd  *  School of Computer Science
     23   1.1       cgd  *  Carnegie Mellon University
     24   1.1       cgd  *  Pittsburgh PA 15213-3890
     25   1.1       cgd  *
     26   1.1       cgd  * any improvements or extensions that they make and grant Carnegie the
     27   1.1       cgd  * rights to redistribute these changes.
     28   1.1       cgd  */
     29   1.1       cgd 
     30   1.1       cgd #include <sys/param.h>
     31   1.1       cgd #include <sys/systm.h>
     32   1.1       cgd #include <sys/signalvar.h>
     33   1.1       cgd #include <sys/kernel.h>
     34   1.1       cgd #include <sys/map.h>
     35   1.1       cgd #include <sys/proc.h>
     36   1.1       cgd #include <sys/buf.h>
     37   1.1       cgd #include <sys/reboot.h>
     38  1.28       cgd #include <sys/device.h>
     39   1.1       cgd #include <sys/file.h>
     40   1.1       cgd #ifdef REAL_CLISTS
     41   1.1       cgd #include <sys/clist.h>
     42   1.1       cgd #endif
     43   1.1       cgd #include <sys/callout.h>
     44   1.1       cgd #include <sys/malloc.h>
     45   1.1       cgd #include <sys/mbuf.h>
     46   1.1       cgd #include <sys/msgbuf.h>
     47   1.1       cgd #include <sys/ioctl.h>
     48   1.1       cgd #include <sys/tty.h>
     49   1.1       cgd #include <sys/user.h>
     50   1.1       cgd #include <sys/exec.h>
     51   1.1       cgd #include <sys/exec_ecoff.h>
     52   1.1       cgd #include <sys/sysctl.h>
     53  1.43       cgd #include <sys/core.h>
     54  1.43       cgd #include <sys/kcore.h>
     55  1.43       cgd #include <machine/kcore.h>
     56   1.1       cgd #ifdef SYSVMSG
     57   1.1       cgd #include <sys/msg.h>
     58   1.1       cgd #endif
     59   1.1       cgd #ifdef SYSVSEM
     60   1.1       cgd #include <sys/sem.h>
     61   1.1       cgd #endif
     62   1.1       cgd #ifdef SYSVSHM
     63   1.1       cgd #include <sys/shm.h>
     64   1.1       cgd #endif
     65   1.1       cgd 
     66   1.1       cgd #include <sys/mount.h>
     67   1.1       cgd #include <sys/syscallargs.h>
     68   1.1       cgd 
     69   1.1       cgd #include <vm/vm_kern.h>
     70   1.1       cgd 
     71   1.1       cgd #include <dev/cons.h>
     72   1.1       cgd 
     73   1.1       cgd #include <machine/cpu.h>
     74   1.1       cgd #include <machine/reg.h>
     75   1.1       cgd #include <machine/rpb.h>
     76   1.1       cgd #include <machine/prom.h>
     77  1.73       cgd #include <machine/conf.h>
     78   1.8       cgd 
     79  1.49       cgd #include <net/netisr.h>
     80  1.33       cgd #include <net/if.h>
     81  1.49       cgd 
     82  1.49       cgd #ifdef INET
     83  1.33       cgd #include <netinet/in.h>
     84  1.72       cgd #include <netinet/ip_var.h>
     85  1.72       cgd #include "arp.h"
     86  1.72       cgd #if NARP > 0
     87  1.67        is #include <netinet/if_inarp.h>
     88  1.72       cgd #endif
     89  1.49       cgd #endif
     90  1.49       cgd #ifdef NS
     91  1.49       cgd #include <netns/ns_var.h>
     92  1.49       cgd #endif
     93  1.49       cgd #ifdef ISO
     94  1.49       cgd #include <netiso/iso.h>
     95  1.49       cgd #include <netiso/clnp.h>
     96  1.49       cgd #endif
     97  1.55       cgd #ifdef CCITT
     98  1.55       cgd #include <netccitt/x25.h>
     99  1.55       cgd #include <netccitt/pk.h>
    100  1.55       cgd #include <netccitt/pk_extern.h>
    101  1.55       cgd #endif
    102  1.55       cgd #ifdef NATM
    103  1.55       cgd #include <netnatm/natm.h>
    104  1.55       cgd #endif
    105  1.70  christos #ifdef NETATALK
    106  1.70  christos #include <netatalk/at_extern.h>
    107  1.70  christos #endif
    108  1.49       cgd #include "ppp.h"
    109  1.49       cgd #if NPPP > 0
    110  1.49       cgd #include <net/ppp_defs.h>
    111  1.49       cgd #include <net/if_ppp.h>
    112  1.49       cgd #endif
    113   1.1       cgd 
    114  1.17       cgd #include "le_ioasic.h"			/* for le_iomem creation */
    115   1.1       cgd 
    116   1.1       cgd vm_map_t buffer_map;
    117   1.1       cgd 
    118   1.1       cgd /*
    119   1.1       cgd  * Declare these as initialized data so we can patch them.
    120   1.1       cgd  */
    121   1.1       cgd int	nswbuf = 0;
    122   1.1       cgd #ifdef	NBUF
    123   1.1       cgd int	nbuf = NBUF;
    124   1.1       cgd #else
    125   1.1       cgd int	nbuf = 0;
    126   1.1       cgd #endif
    127   1.1       cgd #ifdef	BUFPAGES
    128   1.1       cgd int	bufpages = BUFPAGES;
    129   1.1       cgd #else
    130   1.1       cgd int	bufpages = 0;
    131   1.1       cgd #endif
    132   1.1       cgd int	msgbufmapped = 0;	/* set when safe to use msgbuf */
    133   1.1       cgd int	maxmem;			/* max memory per process */
    134   1.7       cgd 
    135   1.7       cgd int	totalphysmem;		/* total amount of physical memory in system */
    136   1.7       cgd int	physmem;		/* physical memory used by NetBSD + some rsvd */
    137   1.7       cgd int	firstusablepage;	/* first usable memory page */
    138   1.7       cgd int	lastusablepage;		/* last usable memory page */
    139   1.1       cgd int	resvmem;		/* amount of memory reserved for PROM */
    140   1.7       cgd int	unusedmem;		/* amount of memory for OS that we don't use */
    141   1.7       cgd int	unknownmem;		/* amount of memory with an unknown use */
    142   1.1       cgd 
    143   1.1       cgd int	cputype;		/* system type, from the RPB */
    144   1.1       cgd 
    145   1.1       cgd /*
    146   1.1       cgd  * XXX We need an address to which we can assign things so that they
    147   1.1       cgd  * won't be optimized away because we didn't use the value.
    148   1.1       cgd  */
    149   1.1       cgd u_int32_t no_optimize;
    150   1.1       cgd 
    151   1.1       cgd /* the following is used externally (sysctl_hw) */
    152   1.1       cgd char	machine[] = "alpha";
    153  1.29       cgd char	cpu_model[128];
    154  1.54       cgd const struct cpusw *cpu_fn_switch;		/* function switch */
    155   1.1       cgd 
    156   1.1       cgd struct	user *proc0paddr;
    157   1.1       cgd 
    158   1.1       cgd /* Number of machine cycles per microsecond */
    159   1.1       cgd u_int64_t	cycles_per_usec;
    160   1.1       cgd 
    161   1.1       cgd /* some memory areas for device DMA.  "ick." */
    162   1.1       cgd caddr_t		le_iomem;		/* XXX iomem for LANCE DMA */
    163   1.1       cgd 
    164   1.7       cgd /* number of cpus in the box.  really! */
    165   1.7       cgd int		ncpus;
    166   1.7       cgd 
    167  1.25       cgd char boot_flags[64];
    168  1.61       cgd char booted_kernel[64];
    169   1.8       cgd 
    170  1.30       cgd /* for cpu_sysctl() */
    171  1.36       cgd int	alpha_unaligned_print = 1;	/* warn about unaligned accesses */
    172  1.36       cgd int	alpha_unaligned_fix = 1;	/* fix up unaligned accesses */
    173  1.36       cgd int	alpha_unaligned_sigbus = 0;	/* don't SIGBUS on fixed-up accesses */
    174  1.30       cgd 
    175  1.55       cgd int	cpu_dump __P((void));
    176  1.55       cgd int	cpu_dumpsize __P((void));
    177  1.55       cgd void	dumpsys __P((void));
    178  1.55       cgd void	identifycpu __P((void));
    179  1.55       cgd void	netintr __P((void));
    180  1.55       cgd void	printregs __P((struct reg *));
    181  1.33       cgd 
    182  1.55       cgd void
    183  1.25       cgd alpha_init(pfn, ptb)
    184   1.1       cgd 	u_long pfn;		/* first free PFN number */
    185   1.1       cgd 	u_long ptb;		/* PFN of current level 1 page table */
    186   1.1       cgd {
    187   1.2       cgd 	extern char _end[];
    188   1.1       cgd 	caddr_t start, v;
    189   1.1       cgd 	struct mddt *mddtp;
    190   1.7       cgd 	int i, mddtweird;
    191   1.1       cgd 	char *p;
    192   1.1       cgd 
    193   1.1       cgd 	/*
    194   1.1       cgd 	 * Turn off interrupts and floating point.
    195   1.1       cgd 	 * Make sure the instruction and data streams are consistent.
    196   1.1       cgd 	 */
    197   1.1       cgd 	(void)splhigh();
    198  1.32       cgd 	alpha_pal_wrfen(0);
    199  1.37       cgd 	ALPHA_TBIA();
    200  1.32       cgd 	alpha_pal_imb();
    201   1.1       cgd 
    202   1.1       cgd 	/*
    203   1.1       cgd 	 * get address of the restart block, while we the bootstrap
    204   1.1       cgd 	 * mapping is still around.
    205   1.1       cgd 	 */
    206  1.32       cgd 	hwrpb = (struct rpb *)ALPHA_PHYS_TO_K0SEG(
    207  1.32       cgd 	    (vm_offset_t)(*(struct rpb **)HWRPB_ADDR));
    208   1.1       cgd 
    209   1.1       cgd 	/*
    210   1.1       cgd 	 * Remember how many cycles there are per microsecond,
    211   1.7       cgd 	 * so that we can use delay().  Round up, for safety.
    212   1.1       cgd 	 */
    213   1.7       cgd 	cycles_per_usec = (hwrpb->rpb_cc_freq + 999999) / 1000000;
    214   1.1       cgd 
    215   1.1       cgd 	/*
    216   1.1       cgd 	 * Init the PROM interface, so we can use printf
    217   1.1       cgd 	 * until PROM mappings go away in consinit.
    218   1.1       cgd 	 */
    219   1.1       cgd 	init_prom_interface();
    220   1.1       cgd 
    221   1.1       cgd 	/*
    222   1.1       cgd 	 * Point interrupt/exception vectors to our own.
    223   1.1       cgd 	 */
    224  1.36       cgd 	alpha_pal_wrent(XentInt, ALPHA_KENTRY_INT);
    225  1.36       cgd 	alpha_pal_wrent(XentArith, ALPHA_KENTRY_ARITH);
    226  1.36       cgd 	alpha_pal_wrent(XentMM, ALPHA_KENTRY_MM);
    227  1.36       cgd 	alpha_pal_wrent(XentIF, ALPHA_KENTRY_IF);
    228  1.36       cgd 	alpha_pal_wrent(XentUna, ALPHA_KENTRY_UNA);
    229  1.36       cgd 	alpha_pal_wrent(XentSys, ALPHA_KENTRY_SYS);
    230  1.36       cgd 
    231  1.36       cgd 	/*
    232  1.36       cgd 	 * Disable System and Processor Correctable Error reporting.
    233  1.36       cgd 	 * Clear pending machine checks and error reports, etc.
    234  1.36       cgd 	 */
    235  1.40       cgd 	alpha_pal_wrmces(alpha_pal_rdmces() | ALPHA_MCES_DSC | ALPHA_MCES_DPC);
    236   1.1       cgd 
    237   1.1       cgd 	/*
    238   1.1       cgd 	 * Find out how much memory is available, by looking at
    239   1.7       cgd 	 * the memory cluster descriptors.  This also tries to do
    240   1.7       cgd 	 * its best to detect things things that have never been seen
    241   1.7       cgd 	 * before...
    242   1.7       cgd 	 *
    243   1.1       cgd 	 * XXX Assumes that the first "system" cluster is the
    244   1.7       cgd 	 * only one we can use. Is the second (etc.) system cluster
    245   1.7       cgd 	 * (if one happens to exist) guaranteed to be contiguous?  or...?
    246   1.1       cgd 	 */
    247   1.1       cgd 	mddtp = (struct mddt *)(((caddr_t)hwrpb) + hwrpb->rpb_memdat_off);
    248   1.7       cgd 
    249   1.7       cgd 	/*
    250   1.7       cgd 	 * BEGIN MDDT WEIRDNESS CHECKING
    251   1.7       cgd 	 */
    252   1.7       cgd 	mddtweird = 0;
    253   1.7       cgd 
    254   1.7       cgd #define cnt	 mddtp->mddt_cluster_cnt
    255   1.7       cgd #define	usage(n) mddtp->mddt_clusters[(n)].mddt_usage
    256   1.7       cgd 	if (cnt != 2 && cnt != 3) {
    257  1.46  christos 		printf("WARNING: weird number (%ld) of mem clusters\n", cnt);
    258   1.7       cgd 		mddtweird = 1;
    259   1.7       cgd 	} else if (usage(0) != MDDT_PALCODE ||
    260   1.7       cgd 		   usage(1) != MDDT_SYSTEM ||
    261   1.7       cgd 	           (cnt == 3 && usage(2) != MDDT_PALCODE)) {
    262   1.7       cgd 		mddtweird = 1;
    263  1.46  christos 		printf("WARNING: %ld mem clusters, but weird config\n", cnt);
    264   1.7       cgd 	}
    265   1.7       cgd 
    266   1.7       cgd 	for (i = 0; i < cnt; i++) {
    267   1.7       cgd 		if ((usage(i) & MDDT_mbz) != 0) {
    268  1.46  christos 			printf("WARNING: mem cluster %d has weird usage %lx\n",
    269   1.7       cgd 			    i, usage(i));
    270   1.7       cgd 			mddtweird = 1;
    271   1.7       cgd 		}
    272   1.7       cgd 		if (mddtp->mddt_clusters[i].mddt_pg_cnt == 0) {
    273  1.46  christos 			printf("WARNING: mem cluster %d has pg cnt == 0\n", i);
    274   1.7       cgd 			mddtweird = 1;
    275   1.7       cgd 		}
    276   1.7       cgd 		/* XXX other things to check? */
    277   1.7       cgd 	}
    278   1.7       cgd #undef cnt
    279   1.7       cgd #undef usage
    280   1.7       cgd 
    281   1.7       cgd 	if (mddtweird) {
    282  1.46  christos 		printf("\n");
    283  1.46  christos 		printf("complete memory cluster information:\n");
    284   1.2       cgd 		for (i = 0; i < mddtp->mddt_cluster_cnt; i++) {
    285  1.46  christos 			printf("mddt %d:\n", i);
    286  1.46  christos 			printf("\tpfn %lx\n",
    287   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_pfn);
    288  1.46  christos 			printf("\tcnt %lx\n",
    289   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_pg_cnt);
    290  1.46  christos 			printf("\ttest %lx\n",
    291   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_pg_test);
    292  1.46  christos 			printf("\tbva %lx\n",
    293   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_v_bitaddr);
    294  1.46  christos 			printf("\tbpa %lx\n",
    295   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_p_bitaddr);
    296  1.46  christos 			printf("\tbcksum %lx\n",
    297   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_bit_cksum);
    298  1.46  christos 			printf("\tusage %lx\n",
    299   1.2       cgd 			    mddtp->mddt_clusters[i].mddt_usage);
    300   1.2       cgd 		}
    301  1.46  christos 		printf("\n");
    302   1.2       cgd 	}
    303   1.7       cgd 	/*
    304   1.7       cgd 	 * END MDDT WEIRDNESS CHECKING
    305   1.7       cgd 	 */
    306   1.2       cgd 
    307   1.1       cgd 	for (i = 0; i < mddtp->mddt_cluster_cnt; i++) {
    308   1.7       cgd 		totalphysmem += mddtp->mddt_clusters[i].mddt_pg_cnt;
    309   1.7       cgd #define	usage(n) mddtp->mddt_clusters[(n)].mddt_usage
    310   1.7       cgd #define	pgcnt(n) mddtp->mddt_clusters[(n)].mddt_pg_cnt
    311   1.7       cgd 		if ((usage(i) & MDDT_mbz) != 0)
    312   1.7       cgd 			unknownmem += pgcnt(i);
    313   1.7       cgd 		else if ((usage(i) & ~MDDT_mbz) == MDDT_PALCODE)
    314   1.7       cgd 			resvmem += pgcnt(i);
    315   1.7       cgd 		else if ((usage(i) & ~MDDT_mbz) == MDDT_SYSTEM) {
    316   1.7       cgd 			/*
    317   1.7       cgd 			 * assumes that the system cluster listed is
    318   1.7       cgd 			 * one we're in...
    319   1.7       cgd 			 */
    320   1.7       cgd 			if (physmem != resvmem) {
    321   1.7       cgd 				physmem += pgcnt(i);
    322   1.7       cgd 				firstusablepage =
    323   1.7       cgd 				    mddtp->mddt_clusters[i].mddt_pfn;
    324   1.7       cgd 				lastusablepage = firstusablepage + pgcnt(i) - 1;
    325   1.7       cgd 			} else
    326   1.7       cgd 				unusedmem += pgcnt(i);
    327   1.7       cgd 		}
    328   1.7       cgd #undef usage
    329   1.7       cgd #undef pgcnt
    330   1.1       cgd 	}
    331   1.7       cgd 	if (totalphysmem == 0)
    332   1.1       cgd 		panic("can't happen: system seems to have no memory!");
    333   1.1       cgd 	maxmem = physmem;
    334   1.1       cgd 
    335   1.7       cgd #if 0
    336  1.46  christos 	printf("totalphysmem = %d\n", totalphysmem);
    337  1.46  christos 	printf("physmem = %d\n", physmem);
    338  1.46  christos 	printf("firstusablepage = %d\n", firstusablepage);
    339  1.46  christos 	printf("lastusablepage = %d\n", lastusablepage);
    340  1.46  christos 	printf("resvmem = %d\n", resvmem);
    341  1.46  christos 	printf("unusedmem = %d\n", unusedmem);
    342  1.46  christos 	printf("unknownmem = %d\n", unknownmem);
    343   1.7       cgd #endif
    344   1.7       cgd 
    345   1.1       cgd 	/*
    346   1.1       cgd 	 * find out this CPU's page size
    347   1.1       cgd 	 */
    348   1.1       cgd 	PAGE_SIZE = hwrpb->rpb_page_size;
    349  1.12       cgd 	if (PAGE_SIZE != 8192)
    350  1.12       cgd 		panic("page size %d != 8192?!", PAGE_SIZE);
    351   1.1       cgd 
    352   1.2       cgd 	v = (caddr_t)alpha_round_page(_end);
    353   1.1       cgd 	/*
    354   1.1       cgd 	 * Init mapping for u page(s) for proc 0
    355   1.1       cgd 	 */
    356   1.1       cgd 	start = v;
    357   1.1       cgd 	curproc->p_addr = proc0paddr = (struct user *)v;
    358   1.1       cgd 	v += UPAGES * NBPG;
    359   1.1       cgd 
    360   1.1       cgd 	/*
    361   1.1       cgd 	 * Find out what hardware we're on, and remember its type name.
    362   1.1       cgd 	 */
    363   1.1       cgd 	cputype = hwrpb->rpb_type;
    364  1.54       cgd 	if (cputype < 0 || cputype > ncpusw) {
    365  1.54       cgd unknown_cputype:
    366  1.54       cgd 		printf("\n");
    367  1.54       cgd 		printf("Unknown system type %d.\n", cputype);
    368  1.54       cgd 		printf("\n");
    369  1.54       cgd 		panic("unknown system type");
    370  1.54       cgd 	}
    371  1.54       cgd 	cpu_fn_switch = &cpusw[cputype];
    372  1.54       cgd 	if (cpu_fn_switch->family == NULL)
    373  1.54       cgd 		goto unknown_cputype;
    374  1.54       cgd 	if (cpu_fn_switch->option == NULL) {
    375  1.54       cgd 		printf("\n");
    376  1.54       cgd 		printf("NetBSD does not currently support system type %d\n",
    377  1.54       cgd 		    cputype);
    378  1.54       cgd 		printf("(%s family).\n", cpu_fn_switch->family);
    379  1.54       cgd 		printf("\n");
    380  1.54       cgd 		panic("unsupported system type");
    381  1.54       cgd 	}
    382  1.54       cgd 	if (!cpu_fn_switch->present) {
    383  1.54       cgd 		printf("\n");
    384  1.54       cgd 		printf("Support for system type %d (%s family) is\n", cputype,
    385  1.54       cgd 		    cpu_fn_switch->family);
    386  1.57       cgd 		printf("not present in this kernel.  Build a kernel with \"options %s\"\n",
    387  1.54       cgd 		    cpu_fn_switch->option);
    388  1.57       cgd 		printf("to include support for this system type.\n");
    389  1.54       cgd 		printf("\n");
    390  1.54       cgd 		panic("support for system not present");
    391  1.54       cgd 	}
    392  1.54       cgd 
    393  1.54       cgd 	if ((*cpu_fn_switch->model_name)() != NULL)
    394  1.54       cgd 		strncpy(cpu_model, (*cpu_fn_switch->model_name)(),
    395  1.54       cgd 		    sizeof cpu_model - 1);
    396  1.54       cgd 	else {
    397  1.54       cgd 		strncpy(cpu_model, cpu_fn_switch->family, sizeof cpu_model - 1);
    398  1.54       cgd 		strcat(cpu_model, " family");		/* XXX */
    399  1.54       cgd 	}
    400  1.29       cgd 	cpu_model[sizeof cpu_model - 1] = '\0';
    401  1.66       cgd 
    402  1.66       cgd 	/* XXX SANITY CHECKING.  SHOULD GO AWAY */
    403  1.66       cgd 	/* XXX We should always be running on the the primary. */
    404  1.66       cgd 	assert(hwrpb->rpb_primary_cpu_id == alpha_pal_whami());		/*XXX*/
    405  1.66       cgd 	/* XXX On single-CPU boxes, the primary should always be CPU 0. */
    406  1.66       cgd 	if (cputype != ST_DEC_21000)					/*XXX*/
    407  1.66       cgd 		assert(hwrpb->rpb_primary_cpu_id == 0);			/*XXX*/
    408   1.1       cgd 
    409  1.17       cgd #if NLE_IOASIC > 0
    410   1.1       cgd 	/*
    411   1.1       cgd 	 * Grab 128K at the top of physical memory for the lance chip
    412   1.1       cgd 	 * on machines where it does dma through the I/O ASIC.
    413   1.1       cgd 	 * It must be physically contiguous and aligned on a 128K boundary.
    414  1.17       cgd 	 *
    415  1.17       cgd 	 * Note that since this is conditional on the presence of
    416  1.17       cgd 	 * IOASIC-attached 'le' units in the kernel config, the
    417  1.17       cgd 	 * message buffer may move on these systems.  This shouldn't
    418  1.17       cgd 	 * be a problem, because once people have a kernel config that
    419  1.17       cgd 	 * they use, they're going to stick with it.
    420   1.1       cgd 	 */
    421   1.1       cgd 	if (cputype == ST_DEC_3000_500 ||
    422   1.1       cgd 	    cputype == ST_DEC_3000_300) {	/* XXX possibly others? */
    423   1.7       cgd 		lastusablepage -= btoc(128 * 1024);
    424  1.32       cgd 		le_iomem =
    425  1.32       cgd 		    (caddr_t)ALPHA_PHYS_TO_K0SEG(ctob(lastusablepage + 1));
    426   1.1       cgd 	}
    427  1.17       cgd #endif /* NLE_IOASIC */
    428   1.1       cgd 
    429   1.1       cgd 	/*
    430   1.1       cgd 	 * Initialize error message buffer (at end of core).
    431   1.1       cgd 	 */
    432   1.7       cgd 	lastusablepage -= btoc(sizeof (struct msgbuf));
    433  1.32       cgd 	msgbufp =
    434  1.32       cgd 	    (struct msgbuf *)ALPHA_PHYS_TO_K0SEG(ctob(lastusablepage + 1));
    435   1.1       cgd 	msgbufmapped = 1;
    436   1.1       cgd 
    437   1.1       cgd 	/*
    438   1.1       cgd 	 * Allocate space for system data structures.
    439   1.1       cgd 	 * The first available kernel virtual address is in "v".
    440   1.1       cgd 	 * As pages of kernel virtual memory are allocated, "v" is incremented.
    441   1.1       cgd 	 *
    442   1.1       cgd 	 * These data structures are allocated here instead of cpu_startup()
    443   1.1       cgd 	 * because physical memory is directly addressable. We don't have
    444   1.1       cgd 	 * to map these into virtual address space.
    445   1.1       cgd 	 */
    446   1.1       cgd #define valloc(name, type, num) \
    447  1.12       cgd 	    (name) = (type *)v; v = (caddr_t)ALIGN((name)+(num))
    448   1.1       cgd #define valloclim(name, type, num, lim) \
    449  1.12       cgd 	    (name) = (type *)v; v = (caddr_t)ALIGN((lim) = ((name)+(num)))
    450   1.1       cgd #ifdef REAL_CLISTS
    451   1.1       cgd 	valloc(cfree, struct cblock, nclist);
    452   1.1       cgd #endif
    453   1.1       cgd 	valloc(callout, struct callout, ncallout);
    454   1.1       cgd 	valloc(swapmap, struct map, nswapmap = maxproc * 2);
    455   1.1       cgd #ifdef SYSVSHM
    456   1.1       cgd 	valloc(shmsegs, struct shmid_ds, shminfo.shmmni);
    457   1.1       cgd #endif
    458   1.1       cgd #ifdef SYSVSEM
    459   1.1       cgd 	valloc(sema, struct semid_ds, seminfo.semmni);
    460   1.1       cgd 	valloc(sem, struct sem, seminfo.semmns);
    461   1.1       cgd 	/* This is pretty disgusting! */
    462   1.1       cgd 	valloc(semu, int, (seminfo.semmnu * seminfo.semusz) / sizeof(int));
    463   1.1       cgd #endif
    464   1.1       cgd #ifdef SYSVMSG
    465   1.1       cgd 	valloc(msgpool, char, msginfo.msgmax);
    466   1.1       cgd 	valloc(msgmaps, struct msgmap, msginfo.msgseg);
    467   1.1       cgd 	valloc(msghdrs, struct msg, msginfo.msgtql);
    468   1.1       cgd 	valloc(msqids, struct msqid_ds, msginfo.msgmni);
    469   1.1       cgd #endif
    470   1.1       cgd 
    471   1.1       cgd 	/*
    472   1.1       cgd 	 * Determine how many buffers to allocate.
    473  1.31       cgd 	 * We allocate 10% of memory for buffer space.  Insure a
    474   1.1       cgd 	 * minimum of 16 buffers.  We allocate 1/2 as many swap buffer
    475   1.1       cgd 	 * headers as file i/o buffers.
    476   1.1       cgd 	 */
    477   1.1       cgd 	if (bufpages == 0)
    478  1.31       cgd 		bufpages = (physmem * 10) / (CLSIZE * 100);
    479   1.1       cgd 	if (nbuf == 0) {
    480   1.1       cgd 		nbuf = bufpages;
    481   1.1       cgd 		if (nbuf < 16)
    482   1.1       cgd 			nbuf = 16;
    483   1.1       cgd 	}
    484   1.1       cgd 	if (nswbuf == 0) {
    485   1.1       cgd 		nswbuf = (nbuf / 2) &~ 1;	/* force even */
    486   1.1       cgd 		if (nswbuf > 256)
    487   1.1       cgd 			nswbuf = 256;		/* sanity */
    488   1.1       cgd 	}
    489   1.1       cgd 	valloc(swbuf, struct buf, nswbuf);
    490   1.1       cgd 	valloc(buf, struct buf, nbuf);
    491   1.1       cgd 
    492   1.1       cgd 	/*
    493   1.1       cgd 	 * Clear allocated memory.
    494   1.1       cgd 	 */
    495   1.1       cgd 	bzero(start, v - start);
    496   1.1       cgd 
    497   1.1       cgd 	/*
    498   1.1       cgd 	 * Initialize the virtual memory system, and set the
    499   1.1       cgd 	 * page table base register in proc 0's PCB.
    500   1.1       cgd 	 */
    501  1.40       cgd #ifndef NEW_PMAP
    502  1.32       cgd 	pmap_bootstrap((vm_offset_t)v, ALPHA_PHYS_TO_K0SEG(ptb << PGSHIFT));
    503  1.40       cgd #else
    504  1.40       cgd 	pmap_bootstrap((vm_offset_t)v, ALPHA_PHYS_TO_K0SEG(ptb << PGSHIFT),
    505  1.40       cgd 	    hwrpb->rpb_max_asn);
    506  1.40       cgd #endif
    507   1.1       cgd 
    508   1.1       cgd 	/*
    509   1.3       cgd 	 * Initialize the rest of proc 0's PCB, and cache its physical
    510   1.3       cgd 	 * address.
    511   1.3       cgd 	 */
    512   1.3       cgd 	proc0.p_md.md_pcbpaddr =
    513  1.32       cgd 	    (struct pcb *)ALPHA_K0SEG_TO_PHYS((vm_offset_t)&proc0paddr->u_pcb);
    514   1.3       cgd 
    515   1.3       cgd 	/*
    516   1.3       cgd 	 * Set the kernel sp, reserving space for an (empty) trapframe,
    517   1.3       cgd 	 * and make proc0's trapframe pointer point to it for sanity.
    518   1.3       cgd 	 */
    519  1.33       cgd 	proc0paddr->u_pcb.pcb_hw.apcb_ksp =
    520   1.3       cgd 	    (u_int64_t)proc0paddr + USPACE - sizeof(struct trapframe);
    521  1.33       cgd 	proc0.p_md.md_tf = (struct trapframe *)proc0paddr->u_pcb.pcb_hw.apcb_ksp;
    522  1.38       cgd 
    523  1.40       cgd #ifdef NEW_PMAP
    524  1.40       cgd 	pmap_activate(kernel_pmap, &proc0paddr->u_pcb.pcb_hw, 0);
    525  1.38       cgd #endif
    526   1.1       cgd 
    527   1.1       cgd 	/*
    528  1.25       cgd 	 * Look at arguments passed to us and compute boothowto.
    529  1.61       cgd 	 * Also, get kernel name so it can be used in user-land.
    530   1.8       cgd 	 */
    531  1.25       cgd 	prom_getenv(PROM_E_BOOTED_OSFLAGS, boot_flags, sizeof(boot_flags));
    532  1.25       cgd #if 0
    533  1.46  christos 	printf("boot flags = \"%s\"\n", boot_flags);
    534  1.25       cgd #endif
    535  1.61       cgd 	prom_getenv(PROM_E_BOOTED_FILE, booted_kernel,
    536  1.61       cgd 	    sizeof(booted_kernel));
    537  1.61       cgd #if 0
    538  1.61       cgd 	printf("booted kernel = \"%s\"\n", booted_kernel);
    539  1.61       cgd #endif
    540   1.1       cgd 
    541   1.8       cgd 	boothowto = RB_SINGLE;
    542   1.1       cgd #ifdef KADB
    543   1.1       cgd 	boothowto |= RB_KDB;
    544   1.1       cgd #endif
    545   1.8       cgd 	for (p = boot_flags; p && *p != '\0'; p++) {
    546  1.26       cgd 		/*
    547  1.26       cgd 		 * Note that we'd really like to differentiate case here,
    548  1.26       cgd 		 * but the Alpha AXP Architecture Reference Manual
    549  1.26       cgd 		 * says that we shouldn't.
    550  1.26       cgd 		 */
    551   1.8       cgd 		switch (*p) {
    552  1.26       cgd 		case 'a': /* autoboot */
    553  1.26       cgd 		case 'A':
    554  1.26       cgd 			boothowto &= ~RB_SINGLE;
    555  1.21       cgd 			break;
    556  1.21       cgd 
    557  1.43       cgd #ifdef DEBUG
    558  1.43       cgd 		case 'c': /* crash dump immediately after autoconfig */
    559  1.43       cgd 		case 'C':
    560  1.43       cgd 			boothowto |= RB_DUMP;
    561  1.43       cgd 			break;
    562  1.43       cgd #endif
    563  1.43       cgd 
    564  1.36       cgd 		case 'h': /* always halt, never reboot */
    565  1.36       cgd 		case 'H':
    566  1.36       cgd 			boothowto |= RB_HALT;
    567   1.8       cgd 			break;
    568   1.8       cgd 
    569  1.21       cgd #if 0
    570   1.8       cgd 		case 'm': /* mini root present in memory */
    571  1.26       cgd 		case 'M':
    572   1.8       cgd 			boothowto |= RB_MINIROOT;
    573   1.8       cgd 			break;
    574  1.21       cgd #endif
    575  1.36       cgd 
    576  1.36       cgd 		case 'n': /* askname */
    577  1.36       cgd 		case 'N':
    578  1.36       cgd 			boothowto |= RB_ASKNAME;
    579  1.65       cgd 			break;
    580  1.65       cgd 
    581  1.65       cgd 		case 's': /* single-user (default, supported for sanity) */
    582  1.65       cgd 		case 'S':
    583  1.65       cgd 			boothowto |= RB_SINGLE;
    584  1.65       cgd 			break;
    585  1.65       cgd 
    586  1.65       cgd 		default:
    587  1.65       cgd 			printf("Unrecognized boot flag '%c'.\n", *p);
    588  1.36       cgd 			break;
    589   1.1       cgd 		}
    590   1.1       cgd 	}
    591   1.1       cgd 
    592   1.7       cgd 	/*
    593   1.7       cgd 	 * Figure out the number of cpus in the box, from RPB fields.
    594   1.7       cgd 	 * Really.  We mean it.
    595   1.7       cgd 	 */
    596   1.7       cgd 	for (i = 0; i < hwrpb->rpb_pcs_cnt; i++) {
    597   1.7       cgd 		struct pcs *pcsp;
    598   1.7       cgd 
    599   1.7       cgd 		pcsp = (struct pcs *)((char *)hwrpb + hwrpb->rpb_pcs_off +
    600   1.7       cgd 		    (i * hwrpb->rpb_pcs_size));
    601   1.7       cgd 		if ((pcsp->pcs_flags & PCS_PP) != 0)
    602   1.7       cgd 			ncpus++;
    603   1.7       cgd 	}
    604   1.1       cgd }
    605   1.1       cgd 
    606  1.18       cgd void
    607   1.1       cgd consinit()
    608   1.1       cgd {
    609   1.1       cgd 
    610  1.54       cgd 	(*cpu_fn_switch->cons_init)();
    611   1.1       cgd 	pmap_unmap_prom();
    612   1.1       cgd }
    613   1.1       cgd 
    614  1.18       cgd void
    615   1.1       cgd cpu_startup()
    616   1.1       cgd {
    617   1.1       cgd 	register unsigned i;
    618   1.1       cgd 	int base, residual;
    619   1.1       cgd 	vm_offset_t minaddr, maxaddr;
    620   1.1       cgd 	vm_size_t size;
    621  1.40       cgd #if defined(DEBUG)
    622   1.1       cgd 	extern int pmapdebug;
    623   1.1       cgd 	int opmapdebug = pmapdebug;
    624   1.1       cgd 
    625   1.1       cgd 	pmapdebug = 0;
    626   1.1       cgd #endif
    627   1.1       cgd 
    628   1.1       cgd 	/*
    629   1.1       cgd 	 * Good {morning,afternoon,evening,night}.
    630   1.1       cgd 	 */
    631  1.46  christos 	printf(version);
    632   1.1       cgd 	identifycpu();
    633  1.46  christos 	printf("real mem = %d (%d reserved for PROM, %d used by NetBSD)\n",
    634   1.7       cgd 	    ctob(totalphysmem), ctob(resvmem), ctob(physmem));
    635   1.7       cgd 	if (unusedmem)
    636  1.46  christos 		printf("WARNING: unused memory = %d bytes\n", ctob(unusedmem));
    637   1.7       cgd 	if (unknownmem)
    638  1.46  christos 		printf("WARNING: %d bytes of memory with unknown purpose\n",
    639   1.7       cgd 		    ctob(unknownmem));
    640   1.1       cgd 
    641   1.1       cgd 	/*
    642   1.1       cgd 	 * Allocate virtual address space for file I/O buffers.
    643   1.1       cgd 	 * Note they are different than the array of headers, 'buf',
    644   1.1       cgd 	 * and usually occupy more virtual memory than physical.
    645   1.1       cgd 	 */
    646   1.1       cgd 	size = MAXBSIZE * nbuf;
    647   1.1       cgd 	buffer_map = kmem_suballoc(kernel_map, (vm_offset_t *)&buffers,
    648   1.1       cgd 	    &maxaddr, size, TRUE);
    649   1.1       cgd 	minaddr = (vm_offset_t)buffers;
    650   1.1       cgd 	if (vm_map_find(buffer_map, vm_object_allocate(size), (vm_offset_t)0,
    651   1.1       cgd 			&minaddr, size, FALSE) != KERN_SUCCESS)
    652   1.1       cgd 		panic("startup: cannot allocate buffers");
    653   1.1       cgd 	base = bufpages / nbuf;
    654   1.1       cgd 	residual = bufpages % nbuf;
    655   1.1       cgd 	for (i = 0; i < nbuf; i++) {
    656   1.1       cgd 		vm_size_t curbufsize;
    657   1.1       cgd 		vm_offset_t curbuf;
    658   1.1       cgd 
    659   1.1       cgd 		/*
    660   1.1       cgd 		 * First <residual> buffers get (base+1) physical pages
    661   1.1       cgd 		 * allocated for them.  The rest get (base) physical pages.
    662   1.1       cgd 		 *
    663   1.1       cgd 		 * The rest of each buffer occupies virtual space,
    664   1.1       cgd 		 * but has no physical memory allocated for it.
    665   1.1       cgd 		 */
    666   1.1       cgd 		curbuf = (vm_offset_t)buffers + i * MAXBSIZE;
    667   1.1       cgd 		curbufsize = CLBYTES * (i < residual ? base+1 : base);
    668   1.1       cgd 		vm_map_pageable(buffer_map, curbuf, curbuf+curbufsize, FALSE);
    669   1.1       cgd 		vm_map_simplify(buffer_map, curbuf);
    670   1.1       cgd 	}
    671   1.1       cgd 	/*
    672   1.1       cgd 	 * Allocate a submap for exec arguments.  This map effectively
    673   1.1       cgd 	 * limits the number of processes exec'ing at any time.
    674   1.1       cgd 	 */
    675   1.1       cgd 	exec_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
    676   1.1       cgd 				 16 * NCARGS, TRUE);
    677   1.1       cgd 
    678   1.1       cgd 	/*
    679   1.1       cgd 	 * Allocate a submap for physio
    680   1.1       cgd 	 */
    681   1.1       cgd 	phys_map = kmem_suballoc(kernel_map, &minaddr, &maxaddr,
    682   1.1       cgd 				 VM_PHYS_SIZE, TRUE);
    683   1.1       cgd 
    684   1.1       cgd 	/*
    685  1.69   thorpej 	 * Finally, allocate mbuf cluster submap.
    686   1.1       cgd 	 */
    687   1.1       cgd 	mb_map = kmem_suballoc(kernel_map, (vm_offset_t *)&mbutl, &maxaddr,
    688   1.1       cgd 	    VM_MBUF_SIZE, FALSE);
    689   1.1       cgd 	/*
    690   1.1       cgd 	 * Initialize callouts
    691   1.1       cgd 	 */
    692   1.1       cgd 	callfree = callout;
    693   1.1       cgd 	for (i = 1; i < ncallout; i++)
    694   1.1       cgd 		callout[i-1].c_next = &callout[i];
    695   1.1       cgd 	callout[i-1].c_next = NULL;
    696   1.1       cgd 
    697  1.40       cgd #if defined(DEBUG)
    698   1.1       cgd 	pmapdebug = opmapdebug;
    699   1.1       cgd #endif
    700  1.46  christos 	printf("avail mem = %ld\n", (long)ptoa(cnt.v_free_count));
    701  1.46  christos 	printf("using %ld buffers containing %ld bytes of memory\n",
    702   1.1       cgd 		(long)nbuf, (long)(bufpages * CLBYTES));
    703   1.1       cgd 
    704   1.1       cgd 	/*
    705   1.1       cgd 	 * Set up buffers, so they can be used to read disk labels.
    706   1.1       cgd 	 */
    707   1.1       cgd 	bufinit();
    708   1.1       cgd 
    709   1.1       cgd 	/*
    710   1.1       cgd 	 * Configure the system.
    711   1.1       cgd 	 */
    712   1.1       cgd 	configure();
    713  1.48       cgd 
    714  1.48       cgd 	/*
    715  1.48       cgd 	 * Note that bootstrapping is finished, and set the HWRPB up
    716  1.48       cgd 	 * to do restarts.
    717  1.48       cgd 	 */
    718  1.55       cgd 	hwrpb_restart_setup();
    719   1.1       cgd }
    720   1.1       cgd 
    721  1.33       cgd void
    722   1.1       cgd identifycpu()
    723   1.1       cgd {
    724   1.1       cgd 
    725   1.7       cgd 	/*
    726   1.7       cgd 	 * print out CPU identification information.
    727   1.7       cgd 	 */
    728  1.46  christos 	printf("%s, %ldMHz\n", cpu_model,
    729   1.7       cgd 	    hwrpb->rpb_cc_freq / 1000000);	/* XXX true for 21164? */
    730  1.46  christos 	printf("%ld byte page size, %d processor%s.\n",
    731   1.7       cgd 	    hwrpb->rpb_page_size, ncpus, ncpus == 1 ? "" : "s");
    732   1.7       cgd #if 0
    733   1.7       cgd 	/* this isn't defined for any systems that we run on? */
    734  1.46  christos 	printf("serial number 0x%lx 0x%lx\n",
    735   1.1       cgd 	    ((long *)hwrpb->rpb_ssn)[0], ((long *)hwrpb->rpb_ssn)[1]);
    736   1.7       cgd 
    737   1.7       cgd 	/* and these aren't particularly useful! */
    738  1.46  christos 	printf("variation: 0x%lx, revision 0x%lx\n",
    739   1.1       cgd 	    hwrpb->rpb_variation, *(long *)hwrpb->rpb_revision);
    740   1.7       cgd #endif
    741   1.1       cgd }
    742   1.1       cgd 
    743   1.1       cgd int	waittime = -1;
    744   1.7       cgd struct pcb dumppcb;
    745   1.1       cgd 
    746  1.18       cgd void
    747  1.68       gwr cpu_reboot(howto, bootstr)
    748   1.1       cgd 	int howto;
    749  1.39       mrg 	char *bootstr;
    750   1.1       cgd {
    751   1.1       cgd 	extern int cold;
    752   1.1       cgd 
    753   1.1       cgd 	/* If system is cold, just halt. */
    754   1.1       cgd 	if (cold) {
    755   1.1       cgd 		howto |= RB_HALT;
    756   1.1       cgd 		goto haltsys;
    757   1.1       cgd 	}
    758   1.1       cgd 
    759  1.36       cgd 	/* If "always halt" was specified as a boot flag, obey. */
    760  1.36       cgd 	if ((boothowto & RB_HALT) != 0)
    761  1.36       cgd 		howto |= RB_HALT;
    762  1.36       cgd 
    763   1.7       cgd 	boothowto = howto;
    764   1.7       cgd 	if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
    765   1.1       cgd 		waittime = 0;
    766   1.7       cgd 		vfs_shutdown();
    767   1.1       cgd 		/*
    768   1.1       cgd 		 * If we've been adjusting the clock, the todr
    769   1.1       cgd 		 * will be out of synch; adjust it now.
    770   1.1       cgd 		 */
    771   1.1       cgd 		resettodr();
    772   1.1       cgd 	}
    773   1.1       cgd 
    774   1.1       cgd 	/* Disable interrupts. */
    775   1.1       cgd 	splhigh();
    776   1.1       cgd 
    777   1.7       cgd 	/* If rebooting and a dump is requested do it. */
    778  1.42       cgd #if 0
    779  1.42       cgd 	if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
    780  1.42       cgd #else
    781  1.42       cgd 	if (howto & RB_DUMP)
    782  1.42       cgd #endif
    783   1.1       cgd 		dumpsys();
    784   1.6       cgd 
    785  1.12       cgd haltsys:
    786  1.12       cgd 
    787   1.6       cgd 	/* run any shutdown hooks */
    788   1.6       cgd 	doshutdownhooks();
    789   1.1       cgd 
    790   1.7       cgd #ifdef BOOTKEY
    791  1.46  christos 	printf("hit any key to %s...\n", howto & RB_HALT ? "halt" : "reboot");
    792   1.7       cgd 	cngetc();
    793  1.46  christos 	printf("\n");
    794   1.7       cgd #endif
    795   1.7       cgd 
    796   1.1       cgd 	/* Finally, halt/reboot the system. */
    797  1.46  christos 	printf("%s\n\n", howto & RB_HALT ? "halted." : "rebooting...");
    798   1.1       cgd 	prom_halt(howto & RB_HALT);
    799   1.1       cgd 	/*NOTREACHED*/
    800   1.1       cgd }
    801   1.1       cgd 
    802   1.7       cgd /*
    803   1.7       cgd  * These variables are needed by /sbin/savecore
    804   1.7       cgd  */
    805   1.7       cgd u_long	dumpmag = 0x8fca0101;	/* magic number */
    806   1.7       cgd int 	dumpsize = 0;		/* pages */
    807   1.7       cgd long	dumplo = 0; 		/* blocks */
    808   1.7       cgd 
    809   1.7       cgd /*
    810  1.43       cgd  * cpu_dumpsize: calculate size of machine-dependent kernel core dump headers.
    811  1.43       cgd  */
    812  1.43       cgd int
    813  1.43       cgd cpu_dumpsize()
    814  1.43       cgd {
    815  1.43       cgd 	int size;
    816  1.43       cgd 
    817  1.43       cgd 	size = ALIGN(sizeof(kcore_seg_t)) + ALIGN(sizeof(cpu_kcore_hdr_t));
    818  1.43       cgd 	if (roundup(size, dbtob(1)) != dbtob(1))
    819  1.43       cgd 		return -1;
    820  1.43       cgd 
    821  1.43       cgd 	return (1);
    822  1.43       cgd }
    823  1.43       cgd 
    824  1.43       cgd /*
    825  1.43       cgd  * cpu_dump: dump machine-dependent kernel core dump headers.
    826  1.43       cgd  */
    827  1.43       cgd int
    828  1.43       cgd cpu_dump()
    829  1.43       cgd {
    830  1.43       cgd 	int (*dump) __P((dev_t, daddr_t, caddr_t, size_t));
    831  1.43       cgd 	long buf[dbtob(1) / sizeof (long)];
    832  1.43       cgd 	kcore_seg_t	*segp;
    833  1.43       cgd 	cpu_kcore_hdr_t	*cpuhdrp;
    834  1.43       cgd 
    835  1.43       cgd         dump = bdevsw[major(dumpdev)].d_dump;
    836  1.43       cgd 
    837  1.43       cgd 	segp = (kcore_seg_t *)buf;
    838  1.43       cgd 	cpuhdrp =
    839  1.43       cgd 	    (cpu_kcore_hdr_t *)&buf[ALIGN(sizeof(*segp)) / sizeof (long)];
    840  1.43       cgd 
    841  1.43       cgd 	/*
    842  1.43       cgd 	 * Generate a segment header.
    843  1.43       cgd 	 */
    844  1.43       cgd 	CORE_SETMAGIC(*segp, KCORE_MAGIC, MID_MACHINE, CORE_CPU);
    845  1.43       cgd 	segp->c_size = dbtob(1) - ALIGN(sizeof(*segp));
    846  1.43       cgd 
    847  1.43       cgd 	/*
    848  1.43       cgd 	 * Add the machine-dependent header info
    849  1.43       cgd 	 */
    850  1.44       cgd 	cpuhdrp->lev1map_pa = ALPHA_K0SEG_TO_PHYS((vm_offset_t)Lev1map);
    851  1.43       cgd 	cpuhdrp->page_size = PAGE_SIZE;
    852  1.43       cgd 	cpuhdrp->core_seg.start = ctob(firstusablepage);
    853  1.43       cgd 	cpuhdrp->core_seg.size = ctob(physmem);
    854  1.43       cgd 
    855  1.43       cgd 	return (dump(dumpdev, dumplo, (caddr_t)buf, dbtob(1)));
    856  1.43       cgd }
    857  1.43       cgd 
    858  1.43       cgd /*
    859  1.68       gwr  * This is called by main to set dumplo and dumpsize.
    860   1.7       cgd  * Dumps always skip the first CLBYTES of disk space
    861   1.7       cgd  * in case there might be a disk label stored there.
    862   1.7       cgd  * If there is extra space, put dump at the end to
    863   1.7       cgd  * reduce the chance that swapping trashes it.
    864   1.7       cgd  */
    865   1.7       cgd void
    866  1.68       gwr cpu_dumpconf()
    867   1.7       cgd {
    868  1.43       cgd 	int nblks, dumpblks;	/* size of dump area */
    869   1.7       cgd 	int maj;
    870   1.7       cgd 
    871   1.7       cgd 	if (dumpdev == NODEV)
    872  1.43       cgd 		goto bad;
    873   1.7       cgd 	maj = major(dumpdev);
    874   1.7       cgd 	if (maj < 0 || maj >= nblkdev)
    875   1.7       cgd 		panic("dumpconf: bad dumpdev=0x%x", dumpdev);
    876   1.7       cgd 	if (bdevsw[maj].d_psize == NULL)
    877  1.43       cgd 		goto bad;
    878   1.7       cgd 	nblks = (*bdevsw[maj].d_psize)(dumpdev);
    879   1.7       cgd 	if (nblks <= ctod(1))
    880  1.43       cgd 		goto bad;
    881  1.43       cgd 
    882  1.43       cgd 	dumpblks = cpu_dumpsize();
    883  1.43       cgd 	if (dumpblks < 0)
    884  1.43       cgd 		goto bad;
    885  1.43       cgd 	dumpblks += ctod(physmem);
    886  1.43       cgd 
    887  1.43       cgd 	/* If dump won't fit (incl. room for possible label), punt. */
    888  1.43       cgd 	if (dumpblks > (nblks - ctod(1)))
    889  1.43       cgd 		goto bad;
    890  1.43       cgd 
    891  1.43       cgd 	/* Put dump at end of partition */
    892  1.43       cgd 	dumplo = nblks - dumpblks;
    893   1.7       cgd 
    894  1.43       cgd 	/* dumpsize is in page units, and doesn't include headers. */
    895   1.7       cgd 	dumpsize = physmem;
    896  1.43       cgd 	return;
    897   1.7       cgd 
    898  1.43       cgd bad:
    899  1.43       cgd 	dumpsize = 0;
    900  1.43       cgd 	return;
    901   1.7       cgd }
    902   1.7       cgd 
    903   1.7       cgd /*
    904  1.42       cgd  * Dump the kernel's image to the swap partition.
    905   1.7       cgd  */
    906  1.42       cgd #define	BYTES_PER_DUMP	NBPG
    907  1.42       cgd 
    908   1.7       cgd void
    909   1.7       cgd dumpsys()
    910   1.7       cgd {
    911  1.42       cgd 	unsigned bytes, i, n;
    912  1.42       cgd 	int maddr, psize;
    913  1.42       cgd 	daddr_t blkno;
    914  1.42       cgd 	int (*dump) __P((dev_t, daddr_t, caddr_t, size_t));
    915  1.42       cgd 	int error;
    916  1.42       cgd 
    917  1.42       cgd 	/* Save registers. */
    918  1.42       cgd 	savectx(&dumppcb);
    919   1.7       cgd 
    920  1.42       cgd 	msgbufmapped = 0;	/* don't record dump msgs in msgbuf */
    921   1.7       cgd 	if (dumpdev == NODEV)
    922   1.7       cgd 		return;
    923  1.42       cgd 
    924  1.42       cgd 	/*
    925  1.42       cgd 	 * For dumps during autoconfiguration,
    926  1.42       cgd 	 * if dump device has already configured...
    927  1.42       cgd 	 */
    928  1.42       cgd 	if (dumpsize == 0)
    929  1.68       gwr 		cpu_dumpconf();
    930  1.47       cgd 	if (dumplo <= 0) {
    931  1.46  christos 		printf("\ndump to dev %x not possible\n", dumpdev);
    932  1.42       cgd 		return;
    933  1.43       cgd 	}
    934  1.46  christos 	printf("\ndumping to dev %x, offset %ld\n", dumpdev, dumplo);
    935   1.7       cgd 
    936  1.42       cgd 	psize = (*bdevsw[major(dumpdev)].d_psize)(dumpdev);
    937  1.46  christos 	printf("dump ");
    938  1.42       cgd 	if (psize == -1) {
    939  1.46  christos 		printf("area unavailable\n");
    940  1.42       cgd 		return;
    941  1.42       cgd 	}
    942  1.42       cgd 
    943  1.42       cgd 	/* XXX should purge all outstanding keystrokes. */
    944  1.42       cgd 
    945  1.43       cgd 	if ((error = cpu_dump()) != 0)
    946  1.43       cgd 		goto err;
    947  1.43       cgd 
    948  1.43       cgd 	bytes = ctob(physmem);
    949  1.42       cgd 	maddr = ctob(firstusablepage);
    950  1.43       cgd 	blkno = dumplo + cpu_dumpsize();
    951  1.42       cgd 	dump = bdevsw[major(dumpdev)].d_dump;
    952  1.42       cgd 	error = 0;
    953  1.42       cgd 	for (i = 0; i < bytes; i += n) {
    954  1.42       cgd 
    955  1.42       cgd 		/* Print out how many MBs we to go. */
    956  1.42       cgd 		n = bytes - i;
    957  1.42       cgd 		if (n && (n % (1024*1024)) == 0)
    958  1.46  christos 			printf("%d ", n / (1024 * 1024));
    959  1.42       cgd 
    960  1.42       cgd 		/* Limit size for next transfer. */
    961  1.42       cgd 		if (n > BYTES_PER_DUMP)
    962  1.42       cgd 			n =  BYTES_PER_DUMP;
    963  1.42       cgd 
    964  1.42       cgd 		error = (*dump)(dumpdev, blkno,
    965  1.42       cgd 		    (caddr_t)ALPHA_PHYS_TO_K0SEG(maddr), n);
    966  1.42       cgd 		if (error)
    967  1.42       cgd 			break;
    968  1.42       cgd 		maddr += n;
    969  1.42       cgd 		blkno += btodb(n);			/* XXX? */
    970  1.42       cgd 
    971  1.42       cgd 		/* XXX should look for keystrokes, to cancel. */
    972  1.42       cgd 	}
    973  1.42       cgd 
    974  1.43       cgd err:
    975  1.42       cgd 	switch (error) {
    976   1.7       cgd 
    977   1.7       cgd 	case ENXIO:
    978  1.46  christos 		printf("device bad\n");
    979   1.7       cgd 		break;
    980   1.7       cgd 
    981   1.7       cgd 	case EFAULT:
    982  1.46  christos 		printf("device not ready\n");
    983   1.7       cgd 		break;
    984   1.7       cgd 
    985   1.7       cgd 	case EINVAL:
    986  1.46  christos 		printf("area improper\n");
    987   1.7       cgd 		break;
    988   1.7       cgd 
    989   1.7       cgd 	case EIO:
    990  1.46  christos 		printf("i/o error\n");
    991   1.7       cgd 		break;
    992   1.7       cgd 
    993   1.7       cgd 	case EINTR:
    994  1.46  christos 		printf("aborted from console\n");
    995   1.7       cgd 		break;
    996   1.7       cgd 
    997  1.42       cgd 	case 0:
    998  1.46  christos 		printf("succeeded\n");
    999  1.42       cgd 		break;
   1000  1.42       cgd 
   1001   1.7       cgd 	default:
   1002  1.46  christos 		printf("error %d\n", error);
   1003   1.7       cgd 		break;
   1004   1.7       cgd 	}
   1005  1.46  christos 	printf("\n\n");
   1006   1.7       cgd 	delay(1000);
   1007   1.7       cgd }
   1008   1.7       cgd 
   1009   1.1       cgd void
   1010   1.1       cgd frametoreg(framep, regp)
   1011   1.1       cgd 	struct trapframe *framep;
   1012   1.1       cgd 	struct reg *regp;
   1013   1.1       cgd {
   1014   1.1       cgd 
   1015   1.1       cgd 	regp->r_regs[R_V0] = framep->tf_regs[FRAME_V0];
   1016   1.1       cgd 	regp->r_regs[R_T0] = framep->tf_regs[FRAME_T0];
   1017   1.1       cgd 	regp->r_regs[R_T1] = framep->tf_regs[FRAME_T1];
   1018   1.1       cgd 	regp->r_regs[R_T2] = framep->tf_regs[FRAME_T2];
   1019   1.1       cgd 	regp->r_regs[R_T3] = framep->tf_regs[FRAME_T3];
   1020   1.1       cgd 	regp->r_regs[R_T4] = framep->tf_regs[FRAME_T4];
   1021   1.1       cgd 	regp->r_regs[R_T5] = framep->tf_regs[FRAME_T5];
   1022   1.1       cgd 	regp->r_regs[R_T6] = framep->tf_regs[FRAME_T6];
   1023   1.1       cgd 	regp->r_regs[R_T7] = framep->tf_regs[FRAME_T7];
   1024   1.1       cgd 	regp->r_regs[R_S0] = framep->tf_regs[FRAME_S0];
   1025   1.1       cgd 	regp->r_regs[R_S1] = framep->tf_regs[FRAME_S1];
   1026   1.1       cgd 	regp->r_regs[R_S2] = framep->tf_regs[FRAME_S2];
   1027   1.1       cgd 	regp->r_regs[R_S3] = framep->tf_regs[FRAME_S3];
   1028   1.1       cgd 	regp->r_regs[R_S4] = framep->tf_regs[FRAME_S4];
   1029   1.1       cgd 	regp->r_regs[R_S5] = framep->tf_regs[FRAME_S5];
   1030   1.1       cgd 	regp->r_regs[R_S6] = framep->tf_regs[FRAME_S6];
   1031  1.34       cgd 	regp->r_regs[R_A0] = framep->tf_regs[FRAME_A0];
   1032  1.34       cgd 	regp->r_regs[R_A1] = framep->tf_regs[FRAME_A1];
   1033  1.34       cgd 	regp->r_regs[R_A2] = framep->tf_regs[FRAME_A2];
   1034   1.1       cgd 	regp->r_regs[R_A3] = framep->tf_regs[FRAME_A3];
   1035   1.1       cgd 	regp->r_regs[R_A4] = framep->tf_regs[FRAME_A4];
   1036   1.1       cgd 	regp->r_regs[R_A5] = framep->tf_regs[FRAME_A5];
   1037   1.1       cgd 	regp->r_regs[R_T8] = framep->tf_regs[FRAME_T8];
   1038   1.1       cgd 	regp->r_regs[R_T9] = framep->tf_regs[FRAME_T9];
   1039   1.1       cgd 	regp->r_regs[R_T10] = framep->tf_regs[FRAME_T10];
   1040   1.1       cgd 	regp->r_regs[R_T11] = framep->tf_regs[FRAME_T11];
   1041   1.1       cgd 	regp->r_regs[R_RA] = framep->tf_regs[FRAME_RA];
   1042   1.1       cgd 	regp->r_regs[R_T12] = framep->tf_regs[FRAME_T12];
   1043   1.1       cgd 	regp->r_regs[R_AT] = framep->tf_regs[FRAME_AT];
   1044  1.34       cgd 	regp->r_regs[R_GP] = framep->tf_regs[FRAME_GP];
   1045  1.35       cgd 	/* regp->r_regs[R_SP] = framep->tf_regs[FRAME_SP]; XXX */
   1046   1.1       cgd 	regp->r_regs[R_ZERO] = 0;
   1047   1.1       cgd }
   1048   1.1       cgd 
   1049   1.1       cgd void
   1050   1.1       cgd regtoframe(regp, framep)
   1051   1.1       cgd 	struct reg *regp;
   1052   1.1       cgd 	struct trapframe *framep;
   1053   1.1       cgd {
   1054   1.1       cgd 
   1055   1.1       cgd 	framep->tf_regs[FRAME_V0] = regp->r_regs[R_V0];
   1056   1.1       cgd 	framep->tf_regs[FRAME_T0] = regp->r_regs[R_T0];
   1057   1.1       cgd 	framep->tf_regs[FRAME_T1] = regp->r_regs[R_T1];
   1058   1.1       cgd 	framep->tf_regs[FRAME_T2] = regp->r_regs[R_T2];
   1059   1.1       cgd 	framep->tf_regs[FRAME_T3] = regp->r_regs[R_T3];
   1060   1.1       cgd 	framep->tf_regs[FRAME_T4] = regp->r_regs[R_T4];
   1061   1.1       cgd 	framep->tf_regs[FRAME_T5] = regp->r_regs[R_T5];
   1062   1.1       cgd 	framep->tf_regs[FRAME_T6] = regp->r_regs[R_T6];
   1063   1.1       cgd 	framep->tf_regs[FRAME_T7] = regp->r_regs[R_T7];
   1064   1.1       cgd 	framep->tf_regs[FRAME_S0] = regp->r_regs[R_S0];
   1065   1.1       cgd 	framep->tf_regs[FRAME_S1] = regp->r_regs[R_S1];
   1066   1.1       cgd 	framep->tf_regs[FRAME_S2] = regp->r_regs[R_S2];
   1067   1.1       cgd 	framep->tf_regs[FRAME_S3] = regp->r_regs[R_S3];
   1068   1.1       cgd 	framep->tf_regs[FRAME_S4] = regp->r_regs[R_S4];
   1069   1.1       cgd 	framep->tf_regs[FRAME_S5] = regp->r_regs[R_S5];
   1070   1.1       cgd 	framep->tf_regs[FRAME_S6] = regp->r_regs[R_S6];
   1071  1.34       cgd 	framep->tf_regs[FRAME_A0] = regp->r_regs[R_A0];
   1072  1.34       cgd 	framep->tf_regs[FRAME_A1] = regp->r_regs[R_A1];
   1073  1.34       cgd 	framep->tf_regs[FRAME_A2] = regp->r_regs[R_A2];
   1074   1.1       cgd 	framep->tf_regs[FRAME_A3] = regp->r_regs[R_A3];
   1075   1.1       cgd 	framep->tf_regs[FRAME_A4] = regp->r_regs[R_A4];
   1076   1.1       cgd 	framep->tf_regs[FRAME_A5] = regp->r_regs[R_A5];
   1077   1.1       cgd 	framep->tf_regs[FRAME_T8] = regp->r_regs[R_T8];
   1078   1.1       cgd 	framep->tf_regs[FRAME_T9] = regp->r_regs[R_T9];
   1079   1.1       cgd 	framep->tf_regs[FRAME_T10] = regp->r_regs[R_T10];
   1080   1.1       cgd 	framep->tf_regs[FRAME_T11] = regp->r_regs[R_T11];
   1081   1.1       cgd 	framep->tf_regs[FRAME_RA] = regp->r_regs[R_RA];
   1082   1.1       cgd 	framep->tf_regs[FRAME_T12] = regp->r_regs[R_T12];
   1083   1.1       cgd 	framep->tf_regs[FRAME_AT] = regp->r_regs[R_AT];
   1084  1.34       cgd 	framep->tf_regs[FRAME_GP] = regp->r_regs[R_GP];
   1085  1.35       cgd 	/* framep->tf_regs[FRAME_SP] = regp->r_regs[R_SP]; XXX */
   1086   1.1       cgd 	/* ??? = regp->r_regs[R_ZERO]; */
   1087   1.1       cgd }
   1088   1.1       cgd 
   1089   1.1       cgd void
   1090   1.1       cgd printregs(regp)
   1091   1.1       cgd 	struct reg *regp;
   1092   1.1       cgd {
   1093   1.1       cgd 	int i;
   1094   1.1       cgd 
   1095   1.1       cgd 	for (i = 0; i < 32; i++)
   1096  1.46  christos 		printf("R%d:\t0x%016lx%s", i, regp->r_regs[i],
   1097   1.1       cgd 		   i & 1 ? "\n" : "\t");
   1098   1.1       cgd }
   1099   1.1       cgd 
   1100   1.1       cgd void
   1101   1.1       cgd regdump(framep)
   1102   1.1       cgd 	struct trapframe *framep;
   1103   1.1       cgd {
   1104   1.1       cgd 	struct reg reg;
   1105   1.1       cgd 
   1106   1.1       cgd 	frametoreg(framep, &reg);
   1107  1.35       cgd 	reg.r_regs[R_SP] = alpha_pal_rdusp();
   1108  1.35       cgd 
   1109  1.46  christos 	printf("REGISTERS:\n");
   1110   1.1       cgd 	printregs(&reg);
   1111   1.1       cgd }
   1112   1.1       cgd 
   1113   1.1       cgd #ifdef DEBUG
   1114   1.1       cgd int sigdebug = 0;
   1115   1.1       cgd int sigpid = 0;
   1116   1.1       cgd #define	SDB_FOLLOW	0x01
   1117   1.1       cgd #define	SDB_KSTACK	0x02
   1118   1.1       cgd #endif
   1119   1.1       cgd 
   1120   1.1       cgd /*
   1121   1.1       cgd  * Send an interrupt to process.
   1122   1.1       cgd  */
   1123   1.1       cgd void
   1124   1.1       cgd sendsig(catcher, sig, mask, code)
   1125   1.1       cgd 	sig_t catcher;
   1126   1.1       cgd 	int sig, mask;
   1127   1.1       cgd 	u_long code;
   1128   1.1       cgd {
   1129   1.1       cgd 	struct proc *p = curproc;
   1130   1.1       cgd 	struct sigcontext *scp, ksc;
   1131   1.1       cgd 	struct trapframe *frame;
   1132   1.1       cgd 	struct sigacts *psp = p->p_sigacts;
   1133   1.1       cgd 	int oonstack, fsize, rndfsize;
   1134   1.1       cgd 	extern char sigcode[], esigcode[];
   1135   1.1       cgd 	extern struct proc *fpcurproc;
   1136   1.1       cgd 
   1137   1.1       cgd 	frame = p->p_md.md_tf;
   1138   1.9   mycroft 	oonstack = psp->ps_sigstk.ss_flags & SS_ONSTACK;
   1139   1.1       cgd 	fsize = sizeof ksc;
   1140   1.1       cgd 	rndfsize = ((fsize + 15) / 16) * 16;
   1141   1.1       cgd 	/*
   1142   1.1       cgd 	 * Allocate and validate space for the signal handler
   1143   1.1       cgd 	 * context. Note that if the stack is in P0 space, the
   1144   1.1       cgd 	 * call to grow() is a nop, and the useracc() check
   1145   1.1       cgd 	 * will fail if the process has not already allocated
   1146   1.1       cgd 	 * the space with a `brk'.
   1147   1.1       cgd 	 */
   1148   1.1       cgd 	if ((psp->ps_flags & SAS_ALTSTACK) && !oonstack &&
   1149   1.1       cgd 	    (psp->ps_sigonstack & sigmask(sig))) {
   1150  1.14       jtc 		scp = (struct sigcontext *)(psp->ps_sigstk.ss_sp +
   1151   1.1       cgd 		    psp->ps_sigstk.ss_size - rndfsize);
   1152   1.9   mycroft 		psp->ps_sigstk.ss_flags |= SS_ONSTACK;
   1153   1.1       cgd 	} else
   1154  1.35       cgd 		scp = (struct sigcontext *)(alpha_pal_rdusp() - rndfsize);
   1155   1.1       cgd 	if ((u_long)scp <= USRSTACK - ctob(p->p_vmspace->vm_ssize))
   1156   1.1       cgd 		(void)grow(p, (u_long)scp);
   1157   1.1       cgd #ifdef DEBUG
   1158   1.1       cgd 	if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
   1159  1.46  christos 		printf("sendsig(%d): sig %d ssp %p usp %p\n", p->p_pid,
   1160   1.1       cgd 		    sig, &oonstack, scp);
   1161   1.1       cgd #endif
   1162   1.1       cgd 	if (useracc((caddr_t)scp, fsize, B_WRITE) == 0) {
   1163   1.1       cgd #ifdef DEBUG
   1164   1.1       cgd 		if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
   1165  1.46  christos 			printf("sendsig(%d): useracc failed on sig %d\n",
   1166   1.1       cgd 			    p->p_pid, sig);
   1167   1.1       cgd #endif
   1168   1.1       cgd 		/*
   1169   1.1       cgd 		 * Process has trashed its stack; give it an illegal
   1170   1.1       cgd 		 * instruction to halt it in its tracks.
   1171   1.1       cgd 		 */
   1172   1.1       cgd 		SIGACTION(p, SIGILL) = SIG_DFL;
   1173   1.1       cgd 		sig = sigmask(SIGILL);
   1174   1.1       cgd 		p->p_sigignore &= ~sig;
   1175   1.1       cgd 		p->p_sigcatch &= ~sig;
   1176   1.1       cgd 		p->p_sigmask &= ~sig;
   1177   1.1       cgd 		psignal(p, SIGILL);
   1178   1.1       cgd 		return;
   1179   1.1       cgd 	}
   1180   1.1       cgd 
   1181   1.1       cgd 	/*
   1182   1.1       cgd 	 * Build the signal context to be used by sigreturn.
   1183   1.1       cgd 	 */
   1184   1.1       cgd 	ksc.sc_onstack = oonstack;
   1185   1.1       cgd 	ksc.sc_mask = mask;
   1186  1.34       cgd 	ksc.sc_pc = frame->tf_regs[FRAME_PC];
   1187  1.34       cgd 	ksc.sc_ps = frame->tf_regs[FRAME_PS];
   1188   1.1       cgd 
   1189   1.1       cgd 	/* copy the registers. */
   1190   1.1       cgd 	frametoreg(frame, (struct reg *)ksc.sc_regs);
   1191   1.1       cgd 	ksc.sc_regs[R_ZERO] = 0xACEDBADE;		/* magic number */
   1192  1.35       cgd 	ksc.sc_regs[R_SP] = alpha_pal_rdusp();
   1193   1.1       cgd 
   1194   1.1       cgd 	/* save the floating-point state, if necessary, then copy it. */
   1195   1.1       cgd 	if (p == fpcurproc) {
   1196  1.32       cgd 		alpha_pal_wrfen(1);
   1197   1.1       cgd 		savefpstate(&p->p_addr->u_pcb.pcb_fp);
   1198  1.32       cgd 		alpha_pal_wrfen(0);
   1199   1.1       cgd 		fpcurproc = NULL;
   1200   1.1       cgd 	}
   1201   1.1       cgd 	ksc.sc_ownedfp = p->p_md.md_flags & MDP_FPUSED;
   1202   1.1       cgd 	bcopy(&p->p_addr->u_pcb.pcb_fp, (struct fpreg *)ksc.sc_fpregs,
   1203   1.1       cgd 	    sizeof(struct fpreg));
   1204   1.1       cgd 	ksc.sc_fp_control = 0;					/* XXX ? */
   1205   1.1       cgd 	bzero(ksc.sc_reserved, sizeof ksc.sc_reserved);		/* XXX */
   1206   1.1       cgd 	bzero(ksc.sc_xxx, sizeof ksc.sc_xxx);			/* XXX */
   1207   1.1       cgd 
   1208   1.1       cgd 
   1209   1.1       cgd #ifdef COMPAT_OSF1
   1210   1.1       cgd 	/*
   1211   1.1       cgd 	 * XXX Create an OSF/1-style sigcontext and associated goo.
   1212   1.1       cgd 	 */
   1213   1.1       cgd #endif
   1214   1.1       cgd 
   1215   1.1       cgd 	/*
   1216   1.1       cgd 	 * copy the frame out to userland.
   1217   1.1       cgd 	 */
   1218   1.1       cgd 	(void) copyout((caddr_t)&ksc, (caddr_t)scp, fsize);
   1219   1.1       cgd #ifdef DEBUG
   1220   1.1       cgd 	if (sigdebug & SDB_FOLLOW)
   1221  1.46  christos 		printf("sendsig(%d): sig %d scp %p code %lx\n", p->p_pid, sig,
   1222   1.1       cgd 		    scp, code);
   1223   1.1       cgd #endif
   1224   1.1       cgd 
   1225   1.1       cgd 	/*
   1226   1.1       cgd 	 * Set up the registers to return to sigcode.
   1227   1.1       cgd 	 */
   1228  1.34       cgd 	frame->tf_regs[FRAME_PC] =
   1229  1.34       cgd 	    (u_int64_t)PS_STRINGS - (esigcode - sigcode);
   1230  1.34       cgd 	frame->tf_regs[FRAME_A0] = sig;
   1231  1.34       cgd 	frame->tf_regs[FRAME_A1] = code;
   1232  1.34       cgd 	frame->tf_regs[FRAME_A2] = (u_int64_t)scp;
   1233   1.1       cgd 	frame->tf_regs[FRAME_T12] = (u_int64_t)catcher;		/* t12 is pv */
   1234  1.35       cgd 	alpha_pal_wrusp((unsigned long)scp);
   1235   1.1       cgd 
   1236   1.1       cgd #ifdef DEBUG
   1237   1.1       cgd 	if (sigdebug & SDB_FOLLOW)
   1238  1.46  christos 		printf("sendsig(%d): pc %lx, catcher %lx\n", p->p_pid,
   1239  1.34       cgd 		    frame->tf_regs[FRAME_PC], frame->tf_regs[FRAME_A3]);
   1240   1.1       cgd 	if ((sigdebug & SDB_KSTACK) && p->p_pid == sigpid)
   1241  1.46  christos 		printf("sendsig(%d): sig %d returns\n",
   1242   1.1       cgd 		    p->p_pid, sig);
   1243   1.1       cgd #endif
   1244   1.1       cgd }
   1245   1.1       cgd 
   1246   1.1       cgd /*
   1247   1.1       cgd  * System call to cleanup state after a signal
   1248   1.1       cgd  * has been taken.  Reset signal mask and
   1249   1.1       cgd  * stack state from context left by sendsig (above).
   1250   1.1       cgd  * Return to previous pc and psl as specified by
   1251   1.1       cgd  * context left by sendsig. Check carefully to
   1252   1.1       cgd  * make sure that the user has not modified the
   1253   1.1       cgd  * psl to gain improper priviledges or to cause
   1254   1.1       cgd  * a machine fault.
   1255   1.1       cgd  */
   1256   1.1       cgd /* ARGSUSED */
   1257  1.11   mycroft int
   1258  1.11   mycroft sys_sigreturn(p, v, retval)
   1259   1.1       cgd 	struct proc *p;
   1260  1.10   thorpej 	void *v;
   1261  1.10   thorpej 	register_t *retval;
   1262  1.10   thorpej {
   1263  1.11   mycroft 	struct sys_sigreturn_args /* {
   1264   1.1       cgd 		syscallarg(struct sigcontext *) sigcntxp;
   1265  1.10   thorpej 	} */ *uap = v;
   1266   1.1       cgd 	struct sigcontext *scp, ksc;
   1267   1.1       cgd 	extern struct proc *fpcurproc;
   1268   1.1       cgd 
   1269   1.1       cgd 	scp = SCARG(uap, sigcntxp);
   1270   1.1       cgd #ifdef DEBUG
   1271   1.1       cgd 	if (sigdebug & SDB_FOLLOW)
   1272  1.46  christos 	    printf("sigreturn: pid %d, scp %p\n", p->p_pid, scp);
   1273   1.1       cgd #endif
   1274   1.1       cgd 
   1275   1.1       cgd 	if (ALIGN(scp) != (u_int64_t)scp)
   1276   1.1       cgd 		return (EINVAL);
   1277   1.1       cgd 
   1278   1.1       cgd 	/*
   1279   1.1       cgd 	 * Test and fetch the context structure.
   1280   1.1       cgd 	 * We grab it all at once for speed.
   1281   1.1       cgd 	 */
   1282   1.1       cgd 	if (useracc((caddr_t)scp, sizeof (*scp), B_WRITE) == 0 ||
   1283   1.1       cgd 	    copyin((caddr_t)scp, (caddr_t)&ksc, sizeof ksc))
   1284   1.1       cgd 		return (EINVAL);
   1285   1.1       cgd 
   1286   1.1       cgd 	if (ksc.sc_regs[R_ZERO] != 0xACEDBADE)		/* magic number */
   1287   1.1       cgd 		return (EINVAL);
   1288   1.1       cgd 	/*
   1289   1.1       cgd 	 * Restore the user-supplied information
   1290   1.1       cgd 	 */
   1291   1.1       cgd 	if (ksc.sc_onstack)
   1292   1.9   mycroft 		p->p_sigacts->ps_sigstk.ss_flags |= SS_ONSTACK;
   1293   1.1       cgd 	else
   1294   1.9   mycroft 		p->p_sigacts->ps_sigstk.ss_flags &= ~SS_ONSTACK;
   1295   1.1       cgd 	p->p_sigmask = ksc.sc_mask &~ sigcantmask;
   1296   1.1       cgd 
   1297  1.34       cgd 	p->p_md.md_tf->tf_regs[FRAME_PC] = ksc.sc_pc;
   1298  1.34       cgd 	p->p_md.md_tf->tf_regs[FRAME_PS] =
   1299  1.32       cgd 	    (ksc.sc_ps | ALPHA_PSL_USERSET) & ~ALPHA_PSL_USERCLR;
   1300   1.1       cgd 
   1301   1.1       cgd 	regtoframe((struct reg *)ksc.sc_regs, p->p_md.md_tf);
   1302  1.35       cgd 	alpha_pal_wrusp(ksc.sc_regs[R_SP]);
   1303   1.1       cgd 
   1304   1.1       cgd 	/* XXX ksc.sc_ownedfp ? */
   1305   1.1       cgd 	if (p == fpcurproc)
   1306   1.1       cgd 		fpcurproc = NULL;
   1307   1.1       cgd 	bcopy((struct fpreg *)ksc.sc_fpregs, &p->p_addr->u_pcb.pcb_fp,
   1308   1.1       cgd 	    sizeof(struct fpreg));
   1309   1.1       cgd 	/* XXX ksc.sc_fp_control ? */
   1310   1.1       cgd 
   1311   1.1       cgd #ifdef DEBUG
   1312   1.1       cgd 	if (sigdebug & SDB_FOLLOW)
   1313  1.46  christos 		printf("sigreturn(%d): returns\n", p->p_pid);
   1314   1.1       cgd #endif
   1315   1.1       cgd 	return (EJUSTRETURN);
   1316   1.1       cgd }
   1317   1.1       cgd 
   1318   1.1       cgd /*
   1319   1.1       cgd  * machine dependent system variables.
   1320   1.1       cgd  */
   1321  1.33       cgd int
   1322   1.1       cgd cpu_sysctl(name, namelen, oldp, oldlenp, newp, newlen, p)
   1323   1.1       cgd 	int *name;
   1324   1.1       cgd 	u_int namelen;
   1325   1.1       cgd 	void *oldp;
   1326   1.1       cgd 	size_t *oldlenp;
   1327   1.1       cgd 	void *newp;
   1328   1.1       cgd 	size_t newlen;
   1329   1.1       cgd 	struct proc *p;
   1330   1.1       cgd {
   1331   1.1       cgd 	dev_t consdev;
   1332   1.1       cgd 
   1333   1.1       cgd 	/* all sysctl names at this level are terminal */
   1334   1.1       cgd 	if (namelen != 1)
   1335   1.1       cgd 		return (ENOTDIR);		/* overloaded */
   1336   1.1       cgd 
   1337   1.1       cgd 	switch (name[0]) {
   1338   1.1       cgd 	case CPU_CONSDEV:
   1339   1.1       cgd 		if (cn_tab != NULL)
   1340   1.1       cgd 			consdev = cn_tab->cn_dev;
   1341   1.1       cgd 		else
   1342   1.1       cgd 			consdev = NODEV;
   1343   1.1       cgd 		return (sysctl_rdstruct(oldp, oldlenp, newp, &consdev,
   1344   1.1       cgd 			sizeof consdev));
   1345  1.30       cgd 
   1346  1.30       cgd 	case CPU_ROOT_DEVICE:
   1347  1.64   thorpej 		return (sysctl_rdstring(oldp, oldlenp, newp,
   1348  1.64   thorpej 		    root_device->dv_xname));
   1349  1.36       cgd 
   1350  1.36       cgd 	case CPU_UNALIGNED_PRINT:
   1351  1.36       cgd 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1352  1.36       cgd 		    &alpha_unaligned_print));
   1353  1.36       cgd 
   1354  1.36       cgd 	case CPU_UNALIGNED_FIX:
   1355  1.36       cgd 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1356  1.36       cgd 		    &alpha_unaligned_fix));
   1357  1.36       cgd 
   1358  1.36       cgd 	case CPU_UNALIGNED_SIGBUS:
   1359  1.36       cgd 		return (sysctl_int(oldp, oldlenp, newp, newlen,
   1360  1.36       cgd 		    &alpha_unaligned_sigbus));
   1361  1.61       cgd 
   1362  1.61       cgd 	case CPU_BOOTED_KERNEL:
   1363  1.61       cgd 		return (sysctl_rdstring(oldp, oldlenp, newp, booted_kernel));
   1364  1.30       cgd 
   1365   1.1       cgd 	default:
   1366   1.1       cgd 		return (EOPNOTSUPP);
   1367   1.1       cgd 	}
   1368   1.1       cgd 	/* NOTREACHED */
   1369   1.1       cgd }
   1370   1.1       cgd 
   1371   1.1       cgd /*
   1372   1.1       cgd  * Set registers on exec.
   1373   1.1       cgd  */
   1374   1.1       cgd void
   1375   1.5  christos setregs(p, pack, stack, retval)
   1376   1.1       cgd 	register struct proc *p;
   1377   1.5  christos 	struct exec_package *pack;
   1378   1.1       cgd 	u_long stack;
   1379   1.1       cgd 	register_t *retval;
   1380   1.1       cgd {
   1381   1.1       cgd 	struct trapframe *tfp = p->p_md.md_tf;
   1382  1.56       cgd 	extern struct proc *fpcurproc;
   1383  1.56       cgd #ifdef DEBUG
   1384   1.1       cgd 	int i;
   1385  1.56       cgd #endif
   1386  1.43       cgd 
   1387  1.43       cgd #ifdef DEBUG
   1388  1.43       cgd 	/*
   1389  1.43       cgd 	 * Crash and dump, if the user requested it.
   1390  1.43       cgd 	 */
   1391  1.43       cgd 	if (boothowto & RB_DUMP)
   1392  1.43       cgd 		panic("crash requested by boot flags");
   1393  1.43       cgd #endif
   1394   1.1       cgd 
   1395   1.1       cgd #ifdef DEBUG
   1396  1.34       cgd 	for (i = 0; i < FRAME_SIZE; i++)
   1397   1.1       cgd 		tfp->tf_regs[i] = 0xbabefacedeadbeef;
   1398   1.1       cgd #else
   1399  1.34       cgd 	bzero(tfp->tf_regs, FRAME_SIZE * sizeof tfp->tf_regs[0]);
   1400   1.1       cgd #endif
   1401   1.1       cgd 	bzero(&p->p_addr->u_pcb.pcb_fp, sizeof p->p_addr->u_pcb.pcb_fp);
   1402   1.7       cgd #define FP_RN 2 /* XXX */
   1403   1.7       cgd 	p->p_addr->u_pcb.pcb_fp.fpr_cr = (long)FP_RN << 58;
   1404  1.35       cgd 	alpha_pal_wrusp(stack);
   1405  1.34       cgd 	tfp->tf_regs[FRAME_PS] = ALPHA_PSL_USERSET;
   1406  1.34       cgd 	tfp->tf_regs[FRAME_PC] = pack->ep_entry & ~3;
   1407  1.41       cgd 
   1408  1.62       cgd 	tfp->tf_regs[FRAME_A0] = stack;			/* a0 = sp */
   1409  1.62       cgd 	tfp->tf_regs[FRAME_A1] = 0;			/* a1 = rtld cleanup */
   1410  1.62       cgd 	tfp->tf_regs[FRAME_A2] = 0;			/* a2 = rtld object */
   1411  1.63       cgd 	tfp->tf_regs[FRAME_A3] = (u_int64_t)PS_STRINGS;	/* a3 = ps_strings */
   1412  1.41       cgd 	tfp->tf_regs[FRAME_T12] = tfp->tf_regs[FRAME_PC];	/* a.k.a. PV */
   1413   1.1       cgd 
   1414  1.33       cgd 	p->p_md.md_flags &= ~MDP_FPUSED;
   1415   1.1       cgd 	if (fpcurproc == p)
   1416   1.1       cgd 		fpcurproc = NULL;
   1417   1.1       cgd 
   1418   1.1       cgd 	retval[0] = retval[1] = 0;
   1419   1.1       cgd }
   1420   1.1       cgd 
   1421   1.1       cgd void
   1422   1.1       cgd netintr()
   1423   1.1       cgd {
   1424  1.49       cgd 	int n, s;
   1425  1.49       cgd 
   1426  1.49       cgd 	s = splhigh();
   1427  1.49       cgd 	n = netisr;
   1428  1.49       cgd 	netisr = 0;
   1429  1.49       cgd 	splx(s);
   1430  1.49       cgd 
   1431  1.49       cgd #define	DONETISR(bit, fn)						\
   1432  1.49       cgd 	do {								\
   1433  1.49       cgd 		if (n & (1 << (bit)))					\
   1434  1.49       cgd 			fn;						\
   1435  1.49       cgd 	} while (0)
   1436  1.49       cgd 
   1437   1.1       cgd #ifdef INET
   1438  1.72       cgd #if NARP > 0
   1439  1.49       cgd 	DONETISR(NETISR_ARP, arpintr());
   1440  1.72       cgd #endif
   1441  1.49       cgd 	DONETISR(NETISR_IP, ipintr());
   1442  1.70  christos #endif
   1443  1.70  christos #ifdef NETATALK
   1444  1.70  christos 	DONETISR(NETISR_ATALK, atintr());
   1445   1.1       cgd #endif
   1446   1.1       cgd #ifdef NS
   1447  1.49       cgd 	DONETISR(NETISR_NS, nsintr());
   1448   1.1       cgd #endif
   1449   1.1       cgd #ifdef ISO
   1450  1.49       cgd 	DONETISR(NETISR_ISO, clnlintr());
   1451   1.1       cgd #endif
   1452   1.1       cgd #ifdef CCITT
   1453  1.49       cgd 	DONETISR(NETISR_CCITT, ccittintr());
   1454  1.49       cgd #endif
   1455  1.49       cgd #ifdef NATM
   1456  1.49       cgd 	DONETISR(NETISR_NATM, natmintr());
   1457   1.1       cgd #endif
   1458  1.49       cgd #if NPPP > 1
   1459  1.49       cgd 	DONETISR(NETISR_PPP, pppintr());
   1460   1.8       cgd #endif
   1461  1.49       cgd 
   1462  1.49       cgd #undef DONETISR
   1463   1.1       cgd }
   1464   1.1       cgd 
   1465   1.1       cgd void
   1466   1.1       cgd do_sir()
   1467   1.1       cgd {
   1468  1.58       cgd 	u_int64_t n;
   1469   1.1       cgd 
   1470  1.59       cgd 	do {
   1471  1.60       cgd 		(void)splhigh();
   1472  1.58       cgd 		n = ssir;
   1473  1.58       cgd 		ssir = 0;
   1474  1.60       cgd 		splsoft();		/* don't recurse through spl0() */
   1475  1.59       cgd 
   1476  1.59       cgd #define	DO_SIR(bit, fn)							\
   1477  1.59       cgd 		do {							\
   1478  1.60       cgd 			if (n & (bit)) {				\
   1479  1.59       cgd 				cnt.v_soft++;				\
   1480  1.59       cgd 				fn;					\
   1481  1.59       cgd 			}						\
   1482  1.59       cgd 		} while (0)
   1483  1.59       cgd 
   1484  1.60       cgd 		DO_SIR(SIR_NET, netintr());
   1485  1.60       cgd 		DO_SIR(SIR_CLOCK, softclock());
   1486  1.60       cgd 
   1487  1.60       cgd #undef DO_SIR
   1488  1.59       cgd 	} while (ssir != 0);
   1489   1.1       cgd }
   1490   1.1       cgd 
   1491   1.1       cgd int
   1492   1.1       cgd spl0()
   1493   1.1       cgd {
   1494   1.1       cgd 
   1495  1.59       cgd 	if (ssir)
   1496  1.59       cgd 		do_sir();		/* it lowers the IPL itself */
   1497   1.1       cgd 
   1498  1.32       cgd 	return (alpha_pal_swpipl(ALPHA_PSL_IPL_0));
   1499   1.1       cgd }
   1500   1.1       cgd 
   1501   1.1       cgd /*
   1502   1.1       cgd  * The following primitives manipulate the run queues.  _whichqs tells which
   1503   1.1       cgd  * of the 32 queues _qs have processes in them.  Setrunqueue puts processes
   1504  1.52       cgd  * into queues, Remrunqueue removes them from queues.  The running process is
   1505  1.52       cgd  * on no queue, other processes are on a queue related to p->p_priority,
   1506  1.52       cgd  * divided by 4 actually to shrink the 0-127 range of priorities into the 32
   1507  1.52       cgd  * available queues.
   1508   1.1       cgd  */
   1509   1.1       cgd /*
   1510   1.1       cgd  * setrunqueue(p)
   1511   1.1       cgd  *	proc *p;
   1512   1.1       cgd  *
   1513   1.1       cgd  * Call should be made at splclock(), and p->p_stat should be SRUN.
   1514   1.1       cgd  */
   1515   1.1       cgd 
   1516   1.1       cgd void
   1517   1.1       cgd setrunqueue(p)
   1518   1.1       cgd 	struct proc *p;
   1519   1.1       cgd {
   1520   1.1       cgd 	int bit;
   1521   1.1       cgd 
   1522   1.1       cgd 	/* firewall: p->p_back must be NULL */
   1523   1.1       cgd 	if (p->p_back != NULL)
   1524   1.1       cgd 		panic("setrunqueue");
   1525   1.1       cgd 
   1526   1.1       cgd 	bit = p->p_priority >> 2;
   1527   1.1       cgd 	whichqs |= (1 << bit);
   1528   1.1       cgd 	p->p_forw = (struct proc *)&qs[bit];
   1529   1.1       cgd 	p->p_back = qs[bit].ph_rlink;
   1530   1.1       cgd 	p->p_back->p_forw = p;
   1531   1.1       cgd 	qs[bit].ph_rlink = p;
   1532   1.1       cgd }
   1533   1.1       cgd 
   1534   1.1       cgd /*
   1535  1.52       cgd  * remrunqueue(p)
   1536   1.1       cgd  *
   1537   1.1       cgd  * Call should be made at splclock().
   1538   1.1       cgd  */
   1539   1.1       cgd void
   1540  1.52       cgd remrunqueue(p)
   1541   1.1       cgd 	struct proc *p;
   1542   1.1       cgd {
   1543   1.1       cgd 	int bit;
   1544   1.1       cgd 
   1545   1.1       cgd 	bit = p->p_priority >> 2;
   1546   1.1       cgd 	if ((whichqs & (1 << bit)) == 0)
   1547  1.52       cgd 		panic("remrunqueue");
   1548   1.1       cgd 
   1549   1.1       cgd 	p->p_back->p_forw = p->p_forw;
   1550   1.1       cgd 	p->p_forw->p_back = p->p_back;
   1551   1.1       cgd 	p->p_back = NULL;	/* for firewall checking. */
   1552   1.1       cgd 
   1553   1.1       cgd 	if ((struct proc *)&qs[bit] == qs[bit].ph_link)
   1554   1.1       cgd 		whichqs &= ~(1 << bit);
   1555   1.1       cgd }
   1556   1.1       cgd 
   1557   1.1       cgd /*
   1558   1.1       cgd  * Return the best possible estimate of the time in the timeval
   1559   1.1       cgd  * to which tvp points.  Unfortunately, we can't read the hardware registers.
   1560   1.1       cgd  * We guarantee that the time will be greater than the value obtained by a
   1561   1.1       cgd  * previous call.
   1562   1.1       cgd  */
   1563   1.1       cgd void
   1564   1.1       cgd microtime(tvp)
   1565   1.1       cgd 	register struct timeval *tvp;
   1566   1.1       cgd {
   1567   1.1       cgd 	int s = splclock();
   1568   1.1       cgd 	static struct timeval lasttime;
   1569   1.1       cgd 
   1570   1.1       cgd 	*tvp = time;
   1571   1.1       cgd #ifdef notdef
   1572   1.1       cgd 	tvp->tv_usec += clkread();
   1573   1.1       cgd 	while (tvp->tv_usec > 1000000) {
   1574   1.1       cgd 		tvp->tv_sec++;
   1575   1.1       cgd 		tvp->tv_usec -= 1000000;
   1576   1.1       cgd 	}
   1577   1.1       cgd #endif
   1578   1.1       cgd 	if (tvp->tv_sec == lasttime.tv_sec &&
   1579   1.1       cgd 	    tvp->tv_usec <= lasttime.tv_usec &&
   1580   1.1       cgd 	    (tvp->tv_usec = lasttime.tv_usec + 1) > 1000000) {
   1581   1.1       cgd 		tvp->tv_sec++;
   1582   1.1       cgd 		tvp->tv_usec -= 1000000;
   1583   1.1       cgd 	}
   1584   1.1       cgd 	lasttime = *tvp;
   1585   1.1       cgd 	splx(s);
   1586  1.15       cgd }
   1587  1.15       cgd 
   1588  1.15       cgd /*
   1589  1.15       cgd  * Wait "n" microseconds.
   1590  1.15       cgd  */
   1591  1.32       cgd void
   1592  1.15       cgd delay(n)
   1593  1.32       cgd 	unsigned long n;
   1594  1.15       cgd {
   1595  1.15       cgd 	long N = cycles_per_usec * (n);
   1596  1.15       cgd 
   1597  1.15       cgd 	while (N > 0)				/* XXX */
   1598  1.15       cgd 		N -= 3;				/* XXX */
   1599   1.1       cgd }
   1600   1.1       cgd 
   1601   1.8       cgd #if defined(COMPAT_OSF1) || 1		/* XXX */
   1602  1.55       cgd void	cpu_exec_ecoff_setregs __P((struct proc *, struct exec_package *,
   1603  1.55       cgd 	    u_long, register_t *));
   1604  1.55       cgd 
   1605   1.1       cgd void
   1606  1.19       cgd cpu_exec_ecoff_setregs(p, epp, stack, retval)
   1607   1.1       cgd 	struct proc *p;
   1608  1.19       cgd 	struct exec_package *epp;
   1609   1.5  christos 	u_long stack;
   1610   1.5  christos 	register_t *retval;
   1611   1.1       cgd {
   1612  1.19       cgd 	struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
   1613   1.1       cgd 
   1614  1.19       cgd 	setregs(p, epp, stack, retval);
   1615  1.34       cgd 	p->p_md.md_tf->tf_regs[FRAME_GP] = execp->a.gp_value;
   1616   1.1       cgd }
   1617   1.1       cgd 
   1618   1.1       cgd /*
   1619   1.1       cgd  * cpu_exec_ecoff_hook():
   1620   1.1       cgd  *	cpu-dependent ECOFF format hook for execve().
   1621   1.1       cgd  *
   1622   1.1       cgd  * Do any machine-dependent diddling of the exec package when doing ECOFF.
   1623   1.1       cgd  *
   1624   1.1       cgd  */
   1625   1.1       cgd int
   1626  1.19       cgd cpu_exec_ecoff_hook(p, epp)
   1627   1.1       cgd 	struct proc *p;
   1628   1.1       cgd 	struct exec_package *epp;
   1629   1.1       cgd {
   1630  1.19       cgd 	struct ecoff_exechdr *execp = (struct ecoff_exechdr *)epp->ep_hdr;
   1631   1.5  christos 	extern struct emul emul_netbsd;
   1632   1.5  christos #ifdef COMPAT_OSF1
   1633   1.5  christos 	extern struct emul emul_osf1;
   1634   1.5  christos #endif
   1635   1.1       cgd 
   1636  1.19       cgd 	switch (execp->f.f_magic) {
   1637   1.5  christos #ifdef COMPAT_OSF1
   1638   1.1       cgd 	case ECOFF_MAGIC_ALPHA:
   1639   1.5  christos 		epp->ep_emul = &emul_osf1;
   1640   1.1       cgd 		break;
   1641   1.5  christos #endif
   1642   1.1       cgd 
   1643   1.1       cgd 	case ECOFF_MAGIC_NETBSD_ALPHA:
   1644   1.5  christos 		epp->ep_emul = &emul_netbsd;
   1645   1.1       cgd 		break;
   1646   1.1       cgd 
   1647   1.1       cgd 	default:
   1648  1.12       cgd 		return ENOEXEC;
   1649   1.1       cgd 	}
   1650   1.1       cgd 	return 0;
   1651   1.1       cgd }
   1652   1.1       cgd #endif
   1653  1.50       cgd 
   1654  1.50       cgd /* XXX XXX BEGIN XXX XXX */
   1655  1.50       cgd vm_offset_t alpha_XXX_dmamap_or;				/* XXX */
   1656  1.50       cgd 								/* XXX */
   1657  1.50       cgd vm_offset_t							/* XXX */
   1658  1.50       cgd alpha_XXX_dmamap(v)						/* XXX */
   1659  1.51       cgd 	vm_offset_t v;						/* XXX */
   1660  1.50       cgd {								/* XXX */
   1661  1.50       cgd 								/* XXX */
   1662  1.51       cgd 	return (vtophys(v) | alpha_XXX_dmamap_or);		/* XXX */
   1663  1.50       cgd }								/* XXX */
   1664  1.50       cgd /* XXX XXX END XXX XXX */
   1665