* Copyright (c) 1982, 1987, 1990 The Regents of the University of California.
* This code is derived from software contributed to Berkeley by
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* @(#)machdep.c 7.4 (Berkeley) 6/3/91
extern vm_offset_t avail_end
;
#include "machine/specialreg.h"
#include "i386/isa/rtc.h"
* Declare these as initialized data so we can patch them.
int msgbufmapped
; /* set when safe to use msgbuf */
* Machine-dependent startup code
int boothowto
= 0, Maxmem
= 0;
register struct pte
*pte
;
int maxbufs
, base
, residual
;
vm_offset_t minaddr
, maxaddr
;
* Initialize error message buffer (at end of core).
/* avail_end was pre-decremented in pmap_bootstrap to compensate */
for (i
= 0; i
< btoc(sizeof (struct msgbuf
)); i
++)
pmap_enter(pmap_kernel(), msgbufp
, avail_end
+ i
* NBPG
,
kdb_init(); /* startup kernel debugger */
* Good {morning,afternoon,evening,night}.
printf("real mem = %d\n", ctob(physmem
));
* Allocate space for system data structures.
* The first available real memory address is in "firstaddr".
* The first available kernel virtual address is in "v".
* As pages of kernel virtual memory are allocated, "v" is incremented.
* As pages of memory are allocated and cleared,
* "firstaddr" is incremented.
* An index into the kernel page table corresponding to the
* virtual memory address maintained in "v" is kept in "mapaddr".
* Make two passes. The first pass calculates how much memory is
* needed and allocates it. The second pass assigns virtual
* addresses to the various data structures.
#define valloc(name, type, num) \
(name) = (type *)v; v = (caddr_t)((name)+(num))
#define valloclim(name, type, num, lim) \
(name) = (type *)v; v = (caddr_t)((lim) = ((name)+(num)))
valloc(cfree
, struct cblock
, nclist
);
valloc(callout
, struct callout
, ncallout
);
valloc(swapmap
, struct map
, nswapmap
= maxproc
* 2);
valloc(shmsegs
, struct shmid_ds
, shminfo
.shmmni
);
* Determine how many buffers to allocate.
* Use 10% of memory for the first 2 Meg, 5% of the remaining
* memory. Insure a minimum of 16 buffers.
* We allocate 1/2 as many swap buffer headers as file i/o buffers.
if (physmem
< (2 * 1024 * 1024))
bufpages
= physmem
/ 10 / CLSIZE
;
bufpages
= ((2 * 1024 * 1024 + physmem
) / 20) / CLSIZE
;
nswbuf
= (nbuf
/ 2) &~ 1; /* force even */
nswbuf
= 256; /* sanity */
valloc(swbuf
, struct buf
, nswbuf
);
valloc(buf
, struct buf
, nbuf
);
* End of first pass, size has been calculated so allocate memory
size
= (vm_size_t
)(v
- firstaddr
);
firstaddr
= (int)kmem_alloc(kernel_map
, round_page(size
));
panic("startup: no room for tables");
* End of second pass, addresses have been assigned
if ((vm_size_t
)(v
- firstaddr
) != size
)
panic("startup: table size inconsistency");
* Now allocate buffers proper. They are different than the above
* in that they usually occupy more virtual memory than physical.
buffer_map
= kmem_suballoc(kernel_map
, (vm_offset_t
)&buffers
,
minaddr
= (vm_offset_t
)buffers
;
if (vm_map_find(buffer_map
, vm_object_allocate(size
), (vm_offset_t
)0,
&minaddr
, size
, FALSE
) != KERN_SUCCESS
)
panic("startup: cannot allocate buffers");
residual
= bufpages
% nbuf
;
for (i
= 0; i
< nbuf
; i
++) {
* First <residual> buffers get (base+1) physical pages
* allocated for them. The rest get (base) physical pages.
* The rest of each buffer occupies virtual space,
* but has no physical memory allocated for it.
curbuf
= (vm_offset_t
)buffers
+ i
* MAXBSIZE
;
curbufsize
= CLBYTES
* (i
< residual
? base
+1 : base
);
vm_map_pageable(buffer_map
, curbuf
, curbuf
+curbufsize
, FALSE
);
vm_map_simplify(buffer_map
, curbuf
);
* Allocate a submap for exec arguments. This map effectively
* limits the number of processes exec'ing at any time.
exec_map
= kmem_suballoc(kernel_map
, &minaddr
, &maxaddr
,
* Allocate a submap for physio
phys_map
= kmem_suballoc(kernel_map
, &minaddr
, &maxaddr
,
* Finally, allocate mbuf pool. Since mclrefcnt is an off-size
* we use the more space efficient malloc in place of kmem_alloc.
mclrefcnt
= (char *)malloc(NMBCLUSTERS
+CLBYTES
/MCLBYTES
,
bzero(mclrefcnt
, NMBCLUSTERS
+CLBYTES
/MCLBYTES
);
mb_map
= kmem_suballoc(kernel_map
, (vm_offset_t
)&mbutl
, &maxaddr
,
for (i
= 1; i
< ncallout
; i
++)
callout
[i
-1].c_next
= &callout
[i
];
printf("avail mem = %d\n", ptoa(vm_page_free_count
));
printf("using %d buffers containing %d bytes of memory\n",
nbuf
, bufpages
* CLBYTES
);
* Set up CPU-specific registers, cache, etc.
* Set up buffers, so they can be used to read disk labels.
* Return the difference (in microseconds)
* between the current time and a previous
* time as represented by the arguments.
* If there is a pending clock interrupt
* which has not been serviced due to high
* ipl, return error code.
vmtime(otime
, olbolt
, oicr
)
register int otime
, olbolt
, oicr
;
return (((time
.tv_sec
-otime
)*60 + lbolt
-olbolt
)*16667);
struct sigcontext
*sf_scp
;
* Send an interrupt to process.
* Stack is set up to allow sigcode stored
* in u. to call routine, followed by kcall
* to sigreturn routine below. After sigreturn
* resets the signal mask, the stack, and the
* frame pointer, it returns to the user
sendsig(catcher
, sig
, mask
, code
)
register struct proc
*p
= curproc
;
register struct sigframe
*fp
;
struct sigacts
*ps
= p
->p_sigacts
;
oonstack
= ps
->ps_onstack
;
frmtrap
= curpcb
->pcb_flags
& FM_TRAP
;
* Allocate and validate space for the signal handler
* context. Note that if the stack is in P0 space, the
* call to grow() is a nop, and the useracc() check
* will fail if the process has not already allocated
* the space with a `brk'.
if (!ps
->ps_onstack
&& (ps
->ps_sigonstack
& sigmask(sig
))) {
fp
= (struct sigframe
*)(ps
->ps_sigsp
- sizeof(struct sigframe
));
fp
= (struct sigframe
*)(regs
[tESP
]
- sizeof(struct sigframe
));
fp
= (struct sigframe
*)(regs
[sESP
]
- sizeof(struct sigframe
));
if ((unsigned)fp
<= USRSTACK
- ctob(p
->p_vmspace
->vm_ssize
))
(void)grow((unsigned)fp
);
if (useracc((caddr_t
)fp
, sizeof (struct sigframe
), B_WRITE
) == 0) {
* Process has trashed its stack; give it an illegal
* instruction to halt it in its tracks.
SIGACTION(p
, SIGILL
) = SIG_DFL
;
* Build the argument list for the signal handler.
fp
->sf_handler
= catcher
;
/* save scratch registers */
* Build the signal context to be used by sigreturn.
fp
->sf_sc
.sc_onstack
= oonstack
;
fp
->sf_sc
.sc_mask
= mask
;
fp
->sf_sc
.sc_sp
= regs
[tESP
];
fp
->sf_sc
.sc_fp
= regs
[tEBP
];
fp
->sf_sc
.sc_pc
= regs
[tEIP
];
fp
->sf_sc
.sc_ps
= regs
[tEFLAGS
];
regs
[tEIP
] = (int)((struct pcb
*)kstack
)->pcb_sigc
;
fp
->sf_sc
.sc_sp
= regs
[sESP
];
fp
->sf_sc
.sc_fp
= regs
[sEBP
];
fp
->sf_sc
.sc_pc
= regs
[sEIP
];
fp
->sf_sc
.sc_ps
= regs
[sEFLAGS
];
regs
[sEIP
] = (int)((struct pcb
*)kstack
)->pcb_sigc
;
* System call to cleanup state after a signal
* has been taken. Reset signal mask and
* stack state from context left by sendsig (above).
* Return to previous pc and psl as specified by
* context left by sendsig. Check carefully to
* make sure that the user has not modified the
* psl to gain improper priviledges or to cause
sigreturn(p
, uap
, retval
)
struct sigcontext
*sigcntxp
;
register struct sigcontext
*scp
;
register struct sigframe
*fp
;
register int *regs
= p
->p_regs
;
fp
= (struct sigframe
*) regs
[sESP
] ;
if (useracc((caddr_t
)fp
, sizeof (*fp
), 0) == 0)
/* restore scratch registers */
regs
[sEAX
] = fp
->sf_eax
;
regs
[sEDX
] = fp
->sf_edx
;
regs
[sECX
] = fp
->sf_ecx
;
if (useracc((caddr_t
)scp
, sizeof (*scp
), 0) == 0)
if ((scp
->sc_ps
& PSL_MBZ
) != 0 || (scp
->sc_ps
& PSL_MBO
) != PSL_MBO
) {
p
->p_sigacts
->ps_onstack
= scp
->sc_onstack
& 01;
p
->p_sigmask
= scp
->sc_mask
&~
(sigmask(SIGKILL
)|sigmask(SIGCONT
)|sigmask(SIGSTOP
));
regs
[sEFLAGS
] = scp
->sc_ps
;
register long dummy
; /* r12 is reserved */
register int howto
; /* r11 == how to boot */
register int devtype
; /* r10 == major of root dev */
if ((howto
&RB_NOSYNC
) == 0 && waittime
< 0 && bfreelist
[0].b_forw
) {
printf("syncing disks... ");
* Release inodes held by texts before update.
vnode_pager_umount(NULL
);
sync((struct sigcontext
*)0);
for (iter
= 0; iter
< 20; iter
++) {
for (bp
= &buf
[nbuf
]; --bp
>= buf
; )
if ((bp
->b_flags
& (B_BUSY
|B_INVAL
)) == B_BUSY
)
DELAY(10000); /* wait for printf to finish */
devtype
= major(rootdev
);
printf("halting (in tight loop); hit reset\n\n");
splx(0xfffd); /* all but keyboard XXX */
dummy
= 0; dummy
= dummy
;
printf("howto %d, devtype %d\n", arghowto
, devtype
);
int dumpmag
= 0x8fca0101; /* magic number for savecore */
int dumpsize
= 0; /* also for savecore */
* Doadump comes here after turning off memory management and
* getting on the dump stack, either when called above, or by
if ((minor(dumpdev
)&07) != 1)
printf("\ndumping to dev %x, offset %d\n", dumpdev
, dumplo
);
switch ((*bdevsw
[major(dumpdev
)].d_dump
)(dumpdev
)) {
printf("device not ready\n");
printf("area improper\n");
register struct timeval
*tvp
;
while (tvp
->tv_usec
> 1000000) {
physstrat(bp
, strat
, prio
)
* vmapbuf clobbers b_addr so we must remember it so that it
* can be restored after vunmapbuf. This is truely rude, we
* should really be storing this in a field in the buf struct
* but none are available and I didn't want to add one at
* this time. Note that b_addr for dirty page pushes is
* restored in vunmapbuf. (ugh!)
/* pageout daemon doesn't wait for pushed pages */
if (bp
->b_flags
& B_DIRTY
)
while ((bp
->b_flags
& B_DONE
) == 0)
sleep((caddr_t
)bp
, prio
);
* Clear registers on exec
p
->p_regs
[sEBP
] = 0; /* bottom of the fp chain */
p
->p_addr
->u_pcb
.pcb_flags
= 0; /* no fp at all */
load_cr0(rcr0() | CR0_EM
); /* start emulating */
* Initialize 386 and configure to run kernel
* Initialize segments & interrupt table
#define GNULL_SEL 0 /* Null Descriptor */
#define GCODE_SEL 1 /* Kernel Code Descriptor */
#define GDATA_SEL 2 /* Kernel Data Descriptor */
#define GLDT_SEL 3 /* LDT - eventually one per process */
#define GTGATE_SEL 4 /* Process task switch gate */
#define GPANIC_SEL 5 /* Task state to consider panic from */
#define GPROC0_SEL 6 /* Task state process slot zero and up */
#define NGDT GPROC0_SEL+1
union descriptor gdt
[GPROC0_SEL
+1];
/* interrupt descriptor table */
struct gate_descriptor idt
[32+16];
/* local descriptor table */
#define LSYS5CALLS_SEL 0 /* forced by intel BCS */
#define L43BSDCALLS_SEL 2 /* notyet */
/* seperate stack, es,fs,gs sels ? */
/* #define LPOSIXCALLS_SEL 5 /* notyet */
struct i386tss tss
, panic_tss
;
extern struct user
*proc0paddr
;
/* software prototypes -- in more palitable form */
struct soft_segment_descriptor gdt_segs
[] = {
{ 0x0, /* segment base address */
0x0, /* length - all address space */
0, /* segment descriptor priority level */
0, /* segment descriptor present */
0, /* default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Code Descriptor for kernel */
{ 0x0, /* segment base address */
0xfffff, /* length - all address space */
SDT_MEMERA
, /* segment type */
0, /* segment descriptor priority level */
1, /* segment descriptor present */
1, /* default 32 vs 16 bit size */
1 /* limit granularity (byte/page units)*/ },
/* Data Descriptor for kernel */
{ 0x0, /* segment base address */
0xfffff, /* length - all address space */
SDT_MEMRWA
, /* segment type */
0, /* segment descriptor priority level */
1, /* segment descriptor present */
1, /* default 32 vs 16 bit size */
1 /* limit granularity (byte/page units)*/ },
{ (int) ldt
, /* segment base address */
sizeof(ldt
)-1, /* length - all address space */
SDT_SYSLDT
, /* segment type */
0, /* segment descriptor priority level */
1, /* segment descriptor present */
0, /* unused - default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Null Descriptor - Placeholder */
{ 0x0, /* segment base address */
0x0, /* length - all address space */
0, /* segment descriptor priority level */
0, /* segment descriptor present */
0, /* default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Panic Tss Descriptor */
{ (int) &panic_tss
, /* segment base address */
sizeof(tss
)-1, /* length - all address space */
SDT_SYS386TSS
, /* segment type */
0, /* segment descriptor priority level */
1, /* segment descriptor present */
0, /* unused - default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Proc 0 Tss Descriptor */
{ (int) kstack
, /* segment base address */
sizeof(tss
)-1, /* length - all address space */
SDT_SYS386TSS
, /* segment type */
0, /* segment descriptor priority level */
1, /* segment descriptor present */
0, /* unused - default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ }};
struct soft_segment_descriptor ldt_segs
[] = {
/* Null Descriptor - overwritten by call gate */
{ 0x0, /* segment base address */
0x0, /* length - all address space */
0, /* segment descriptor priority level */
0, /* segment descriptor present */
0, /* default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Null Descriptor - overwritten by call gate */
{ 0x0, /* segment base address */
0x0, /* length - all address space */
0, /* segment descriptor priority level */
0, /* segment descriptor present */
0, /* default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Null Descriptor - overwritten by call gate */
{ 0x0, /* segment base address */
0x0, /* length - all address space */
0, /* segment descriptor priority level */
0, /* segment descriptor present */
0, /* default 32 vs 16 bit size */
0 /* limit granularity (byte/page units)*/ },
/* Code Descriptor for user */
{ 0x0, /* segment base address */
0xfffff, /* length - all address space */
SDT_MEMERA
, /* segment type */
SEL_UPL
, /* segment descriptor priority level */
1, /* segment descriptor present */
1, /* default 32 vs 16 bit size */
1 /* limit granularity (byte/page units)*/ },
/* Data Descriptor for user */
{ 0x0, /* segment base address */
0xfffff, /* length - all address space */
SDT_MEMRWA
, /* segment type */
SEL_UPL
, /* segment descriptor priority level */
1, /* segment descriptor present */
1, /* default 32 vs 16 bit size */
1 /* limit granularity (byte/page units)*/ } };
/* table descriptors - used to load tables by microp */
struct region_descriptor r_gdt
= {
sizeof(gdt
)-1,(char *)gdt
struct region_descriptor r_idt
= {
sizeof(idt
)-1,(char *)idt
setidt(idx
, func
, typ
, dpl
) char *func
; {
struct gate_descriptor
*ip
= idt
+ idx
;
ip
->gd_looffset
= (int)func
;
ip
->gd_hioffset
= ((int)func
)>>16 ;
#define IDTVEC(name) __CONCAT(X, name)
extern IDTVEC(div
), IDTVEC(dbg
), IDTVEC(nmi
), IDTVEC(bpt
), IDTVEC(ofl
),
IDTVEC(bnd
), IDTVEC(ill
), IDTVEC(dna
), IDTVEC(dble
), IDTVEC(fpusegm
),
IDTVEC(tss
), IDTVEC(missing
), IDTVEC(stk
), IDTVEC(prot
),
IDTVEC(page
), IDTVEC(rsvd
), IDTVEC(fpu
), IDTVEC(rsvd0
),
IDTVEC(rsvd1
), IDTVEC(rsvd2
), IDTVEC(rsvd3
), IDTVEC(rsvd4
),
IDTVEC(rsvd5
), IDTVEC(rsvd6
), IDTVEC(rsvd7
), IDTVEC(rsvd8
),
IDTVEC(rsvd9
), IDTVEC(rsvd10
), IDTVEC(rsvd11
), IDTVEC(rsvd12
),
IDTVEC(rsvd13
), IDTVEC(rsvd14
), IDTVEC(rsvd14
), IDTVEC(syscall
);
int lcr0(), lcr3(), rcr0(), rcr2();
int _udatasel
, _ucodesel
, _gsel_tss
;
init386(first
) { extern ssdtosd(), lgdt(), lidt(), lldt(), etext
;
unsigned biosbasemem
, biosextmem
;
struct gate_descriptor
*gdp
;
extern int sigcode
,szsigcode
;
proc0
.p_addr
= proc0paddr
;
* Initialize the console before we print anything out.
cninit (KERNBASE
+0xa0000);
/* make gdt memory segments */
gdt_segs
[GCODE_SEL
].ssd_limit
= btoc((int) &etext
+ NBPG
);
for (x
=0; x
< NGDT
; x
++) ssdtosd(gdt_segs
+x
, gdt
+x
);
/* make ldt memory segments */
ldt_segs
[LUCODE_SEL
].ssd_limit
= btoc(UPT_MIN_ADDRESS
);
ldt_segs
[LUDATA_SEL
].ssd_limit
= btoc(UPT_MIN_ADDRESS
);
/* Note. eventually want private ldts per process */
for (x
=0; x
< 5; x
++) ssdtosd(ldt_segs
+x
, ldt
+x
);
setidt(0, &IDTVEC(div
), SDT_SYS386TGT
, SEL_KPL
);
setidt(1, &IDTVEC(dbg
), SDT_SYS386TGT
, SEL_KPL
);
setidt(2, &IDTVEC(nmi
), SDT_SYS386TGT
, SEL_KPL
);
setidt(3, &IDTVEC(bpt
), SDT_SYS386TGT
, SEL_UPL
);
setidt(4, &IDTVEC(ofl
), SDT_SYS386TGT
, SEL_KPL
);
setidt(5, &IDTVEC(bnd
), SDT_SYS386TGT
, SEL_KPL
);
setidt(6, &IDTVEC(ill
), SDT_SYS386TGT
, SEL_KPL
);
setidt(7, &IDTVEC(dna
), SDT_SYS386TGT
, SEL_KPL
);
setidt(8, &IDTVEC(dble
), SDT_SYS386TGT
, SEL_KPL
);
setidt(9, &IDTVEC(fpusegm
), SDT_SYS386TGT
, SEL_KPL
);
setidt(10, &IDTVEC(tss
), SDT_SYS386TGT
, SEL_KPL
);
setidt(11, &IDTVEC(missing
), SDT_SYS386TGT
, SEL_KPL
);
setidt(12, &IDTVEC(stk
), SDT_SYS386TGT
, SEL_KPL
);
setidt(13, &IDTVEC(prot
), SDT_SYS386TGT
, SEL_KPL
);
setidt(14, &IDTVEC(page
), SDT_SYS386TGT
, SEL_KPL
);
setidt(15, &IDTVEC(rsvd
), SDT_SYS386TGT
, SEL_KPL
);
setidt(16, &IDTVEC(fpu
), SDT_SYS386TGT
, SEL_KPL
);
setidt(17, &IDTVEC(rsvd0
), SDT_SYS386TGT
, SEL_KPL
);
setidt(18, &IDTVEC(rsvd1
), SDT_SYS386TGT
, SEL_KPL
);
setidt(19, &IDTVEC(rsvd2
), SDT_SYS386TGT
, SEL_KPL
);
setidt(20, &IDTVEC(rsvd3
), SDT_SYS386TGT
, SEL_KPL
);
setidt(21, &IDTVEC(rsvd4
), SDT_SYS386TGT
, SEL_KPL
);
setidt(22, &IDTVEC(rsvd5
), SDT_SYS386TGT
, SEL_KPL
);
setidt(23, &IDTVEC(rsvd6
), SDT_SYS386TGT
, SEL_KPL
);
setidt(24, &IDTVEC(rsvd7
), SDT_SYS386TGT
, SEL_KPL
);
setidt(25, &IDTVEC(rsvd8
), SDT_SYS386TGT
, SEL_KPL
);
setidt(26, &IDTVEC(rsvd9
), SDT_SYS386TGT
, SEL_KPL
);
setidt(27, &IDTVEC(rsvd10
), SDT_SYS386TGT
, SEL_KPL
);
setidt(28, &IDTVEC(rsvd11
), SDT_SYS386TGT
, SEL_KPL
);
setidt(29, &IDTVEC(rsvd12
), SDT_SYS386TGT
, SEL_KPL
);
setidt(30, &IDTVEC(rsvd13
), SDT_SYS386TGT
, SEL_KPL
);
setidt(31, &IDTVEC(rsvd14
), SDT_SYS386TGT
, SEL_KPL
);
lgdt(gdt
, sizeof(gdt
)-1);
lidt(idt
, sizeof(idt
)-1);
lldt(GSEL(GLDT_SEL
, SEL_KPL
));
/* determine amount of memory present so we can scale kernel PT */
for (i
= RAM_BEGIN
; i
< IOM_BEGIN
; i
+= NBPG
)
if (probemem(i
) == 0) break;
if (maxphysmem
== 0) maxphysmem
= RAM_END
;
for (i
= IOM_END
; i
< maxphysmem
; i
+= NBPG
)
if (probemem(i
) == 0) break;
Maxmem
= 8192 *1024 /NBPG
;
/* reconcile against BIOS's recorded values in RTC
* we trust neither of them, as both can lie!
biosbasemem
= rtcin(RTC_BASELO
)+ (rtcin(RTC_BASEHI
)<<8);
biosextmem
= rtcin(RTC_EXTLO
)+ (rtcin(RTC_EXTHI
)<<8);
if (biosbasemem
== 0xffff || biosextmem
== 0xffff) {
} else if (biosextmem
> 0 && biosbasemem
== 640) {
int totbios
= (biosbasemem
+ 0x60000 + biosextmem
)/4;
if (totbios
< maxmem
) maxmem
= totbios
;
physmem
= maxmem
- (0x100 -0xa0);
/* call pmap initialization to make new kernel address space */
pmap_bootstrap (first
, 0);
/* now running on new page tables, configured,and u/iom is accessible */
/* make a initial tss so microp can get interrupt stack on syscall! */
proc0
.p_addr
->u_pcb
.pcb_tss
.tss_esp0
= (int) kstack
+ UPAGES
*NBPG
;
proc0
.p_addr
->u_pcb
.pcb_tss
.tss_ss0
= GSEL(GDATA_SEL
, SEL_KPL
) ;
_gsel_tss
= GSEL(GPROC0_SEL
, SEL_KPL
);
/* make a call gate to reenter kernel with */
gdp
= &ldt
[LSYS5CALLS_SEL
].gd
;
x
= (int) &IDTVEC(syscall
);
gdp
->gd_selector
= GSEL(GCODE_SEL
,SEL_KPL
);
gdp
->gd_type
= SDT_SYS386CGT
;
gdp
->gd_hioffset
= ((int) &IDTVEC(syscall
)) >>16;
/* transfer to user mode */
_ucodesel
= LSEL(LUCODE_SEL
, SEL_UPL
);
_udatasel
= LSEL(LUDATA_SEL
, SEL_UPL
);
bcopy(&sigcode
, proc0
.p_addr
->u_pcb
.pcb_sigc
, szsigcode
);
proc0
.p_addr
->u_pcb
.pcb_flags
= 0;
proc0
.p_addr
->u_pcb
.pcb_ptd
= IdlePTD
;
extern struct pte
*CMAP1
, *CMAP2
;
extern caddr_t CADDR1
, CADDR2
;
* zero out physical memory
* specified in relocation units (NBPG bytes)
*(int *)CMAP2
= PG_V
| PG_KW
| ctob(n
);
* copy a page of physical memory
* specified in relocation units (NBPG bytes)
*(int *)CMAP2
= PG_V
| PG_KW
| ctob(n
);
bcopy((void *)frm
, (void *)CADDR2
, NBPG
);
* copy a page of physical memory
* specified in relocation units (NBPG bytes)
*(int *)CMAP1
= PG_V
| PG_KW
| ctob(frm
);
*(int *)CMAP2
= PG_V
| PG_KW
| ctob(to
);
bcopy(CADDR1
, CADDR2
, NBPG
);
schednetisr(NETISR_SCLK
);
* insert an element into a queue
register struct prochd
*element
, *head
;
element
->ph_link
= head
->ph_link
;
head
->ph_link
= (struct proc
*)element
;
element
->ph_rlink
= (struct proc
*)head
;
((struct prochd
*)(element
->ph_link
))->ph_rlink
=(struct proc
*)element
;
* remove an element from a queue
register struct prochd
*element
;
((struct prochd
*)(element
->ph_link
))->ph_rlink
= element
->ph_rlink
;
((struct prochd
*)(element
->ph_rlink
))->ph_link
= element
->ph_link
;
element
->ph_rlink
= (struct proc
*)0;
* Below written in C to allow access to debugging code
copyinstr(fromaddr
, toaddr
, maxlength
, lencopied
) u_int
*lencopied
, maxlength
;
void *toaddr
, *fromaddr
; {
if(lencopied
) *lencopied
= tally
;
*(char *)toaddr
++ = (char) c
;
if(lencopied
) *lencopied
= tally
;
if(lencopied
) *lencopied
= tally
;
copyoutstr(fromaddr
, toaddr
, maxlength
, lencopied
) u_int
*lencopied
, maxlength
;
void *fromaddr
, *toaddr
; {
c
= subyte(toaddr
++, *(char *)fromaddr
);
if (c
== -1) return(EFAULT
);
if (*(char *)fromaddr
++ == 0){
if(lencopied
) *lencopied
= tally
;
if(lencopied
) *lencopied
= tally
;
copystr(fromaddr
, toaddr
, maxlength
, lencopied
) u_int
*lencopied
, maxlength
;
void *fromaddr
, *toaddr
; {
*(u_char
*)toaddr
= *(u_char
*)fromaddr
++;
if (*(u_char
*)toaddr
++ == 0) {
if(lencopied
) *lencopied
= tally
;
if(lencopied
) *lencopied
= tally
;