tacit/minix
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

pde cache check works

Browse Source 
no more silly vm checkranges
This commit is contained in:
Ben Gras 2009-06-07 15:55:44 +00:00
parent 4dae6c4bbc
commit 0702c826a2
17 changed files with 98 additions and 230 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
drivers/at_wini/at_wini.c
View File

@ -493,7 +493,8 @@ PRIVATE void init_params()
dma_buf = mmap(0, ATA_DMA_BUF_SIZE, PROT_READ|PROT_WRITE,
MAP_PREALLOC | MAP_CONTIG | MAP_ANON, -1, 0);
prdt = mmap(0, PRDT_BYTES,
PROT_READ|PROT_WRITE, MAP_CONTIG | MAP_ANON, -1, 0);
PROT_READ|PROT_WRITE,
MAP_PREALLOC | MAP_CONTIG | MAP_ANON, -1, 0);
if(dma_buf == MAP_FAILED || prdt == MAP_FAILED) {
disable_dma = 1;
printf("at_wini%d: no dma\n", w_instance);

2
kernel/arch/i386/exception.c
View File

@ -160,8 +160,6 @@ struct proc *t;
/* Save proc_ptr, because it may be changed by debug statements. */
saved_proc = proc_ptr;
CHECK_RUNQUEUES;
ep = &ex_data[vec_nr];
if (vec_nr == 2) { /* spurious NMI on some machines */

143
kernel/arch/i386/memory.c
View File

@ -23,7 +23,7 @@ PRIVATE int psok = 0;
int verifyrange = 0;
extern u32_t newpde, overwritepde, linlincopies,
physzero, invlpgs, vmcheckranges, straightpdes;
physzero, invlpgs, straightpdes;
#define PROCPDEPTR(pr, pi) ((u32_t *) ((u8_t *) vm_pagedirs +\
I386_PAGE_SIZE * pr->p_nr + \
@ -36,7 +36,7 @@ u8_t *vm_pagedirs = NULL;
u32_t i386_invlpg_addr = 0;
#define WANT_FREEPDES 4
#define WANT_FREEPDES 100
#define NOPDE -1
#define PDEMASK(n) (1L << (n))
PRIVATE int nfreepdes = 0, freepdes[WANT_FREEPDES], inusepde = NOPDE;
@ -448,8 +448,6 @@ PUBLIC int vm_contiguous(struct proc *targetproc, u32_t vir_buf, size_t bytes)
return 1;
}
int vm_checkrange_verbose = 0;
extern u32_t vmreqs;
/*===========================================================================*
@ -531,81 +529,6 @@ int delivermsg(struct proc *rp)
NOREC_RETURN(deliver, r);
}
/*===========================================================================*
* vm_checkrange *
*===========================================================================*/
PUBLIC int vm_checkrange(struct proc *caller, struct proc *target,
vir_bytes vir, vir_bytes bytes, int wrfl, int checkonly)
{
u32_t flags, po, v;
int r;
NOREC_ENTER(vmcheckrange);
vmcheckranges++;
if(!HASPT(target))
NOREC_RETURN(vmcheckrange, OK);
/* If caller has had a reply to this request, return it. */
if(!verifyrange && RTS_ISSET(caller, VMREQUEST)) {
if(caller->p_vmrequest.who == target->p_endpoint) {
vmassert(caller->p_vmrequest.vmresult != VMSUSPEND);
RTS_LOCK_UNSET(caller, VMREQUEST);
#if 1
kprintf("SYSTEM: vm_checkrange: returning vmresult %d\n",
caller->p_vmrequest.vmresult);
#endif
NOREC_RETURN(vmcheckrange, caller->p_vmrequest.vmresult);
} else {
#if 1
kprintf("SYSTEM: vm_checkrange: caller has a request for %d, "
"but our target is %d\n",
caller->p_vmrequest.who, target->p_endpoint);
#endif
}
}
po = vir % I386_PAGE_SIZE;
if(po > 0) {
vir -= po;
bytes += po;
}
vmassert(target);
vmassert(bytes > 0);
for(v = vir; v < vir + bytes; v+= I386_PAGE_SIZE) {
u32_t phys;
int r;
/* If page exists and it's writable if desired, we're OK
* for this page.
*/
if((r=vm_lookup(target, v, &phys, &flags)) == OK &&
!(wrfl && !(flags & I386_VM_WRITE))) {
continue;
}
if(verifyrange) {
int wrok;
wrok = !(wrfl && !(flags & I386_VM_WRITE));
printf("checkrange failed; lookup: %d; write ok: %d\n",
r, wrok);
}
if(!checkonly) {
vmassert(k_reenter == -1);
vm_suspend(caller, target, vir, bytes, wrfl,
VMSTYPE_KERNELCALL);
}
NOREC_RETURN(vmcheckrange, VMSUSPEND);
}
NOREC_RETURN(vmcheckrange, OK);
}
char *flagstr(u32_t e, int dir)
{
static char str[80];
@ -692,16 +615,14 @@ void invlpg_range(u32_t lin, u32_t bytes)
o = lin % I386_PAGE_SIZE;
lin -= o;
limit = (limit + o) & I386_VM_ADDR_MASK;
#if 0
#if 1
for(i386_invlpg_addr = lin; i386_invlpg_addr <= limit;
i386_invlpg_addr += I386_PAGE_SIZE) {
invlpgs++;
level0(i386_invlpg_level0);
}
#else
vm_cr3= ptproc->p_seg.p_cr3;
vmassert(vm_cr3);
level0(set_cr3);
level0(reload_cr3);
#endif
}
@ -726,15 +647,15 @@ u32_t read_cr3(void)
* address space), SEG (hardware segment), VIRT (in-datasegment
* address if known).
*/
#define CREATEPDE(PROC, PTR, LINADDR, REMAIN, BYTES) { \
#define CREATEPDE(PROC, PTR, LINADDR, REMAIN, BYTES, PDE) { \
int proc_pde_index; \
FIXME("CREATEPDE: check if invlpg is necessary"); \
proc_pde_index = I386_VM_PDE(LINADDR); \
PDE = NOPDE; \
if((PROC) && (((PROC) == ptproc) || iskernelp(PROC))) { \
PTR = LINADDR; \
straightpdes++; \
} else { \
int use_pde = NOPDE; \
int fp; \
int mustinvl; \
u32_t pdeval, *pdevalptr, mask; \
@ -756,34 +677,41 @@ u32_t read_cr3(void)
int k = freepdes[fp]; \
if(inusepde == k) \
continue; \
use_pde = k; \
PDE = k; \
mask = PDEMASK(k); \
vmassert(mask); \
if(dirtypde & mask) \
continue; \
break; \
} \
vmassert(use_pde != NOPDE); \
vmassert(PDE != NOPDE); \
vmassert(mask); \
if(dirtypde & mask) { \
mustinvl = 1; \
overwritepde++; \
} else { \
mustinvl = 0; \
dirtypde |= mask; \
newpde++; \
} \
inusepde = use_pde; \
*PROCPDEPTR(ptproc, use_pde) = pdeval; \
inusepde = PDE; \
*PROCPDEPTR(ptproc, PDE) = pdeval; \
offset = LINADDR & I386_VM_OFFSET_MASK_4MB; \
PTR = I386_BIG_PAGE_SIZE*use_pde + offset; \
PTR = I386_BIG_PAGE_SIZE*PDE + offset; \
REMAIN = MIN(REMAIN, I386_BIG_PAGE_SIZE - offset); \
if(1 || mustinvl) { \
if(mustinvl) { \
invlpg_range(PTR, REMAIN); \
} \
} \
}
#define DONEPDE(PDE) { \
if(PDE != NOPDE) { \
dirtypde |= PDEMASK(PDE); \
*PROCPDEPTR(ptproc, PDE) = 0; \
} \
}
/*===========================================================================*
* lin_lin_copy *
@ -813,11 +741,12 @@ int lin_lin_copy(struct proc *srcproc, vir_bytes srclinaddr,
while(bytes > 0) {
phys_bytes srcptr, dstptr;
vir_bytes chunk = bytes;
int srcpde, dstpde;
/* Set up 4MB ranges. */
inusepde = NOPDE;
CREATEPDE(srcproc, srcptr, srclinaddr, chunk, bytes);
CREATEPDE(dstproc, dstptr, dstlinaddr, chunk, bytes);
CREATEPDE(srcproc, srcptr, srclinaddr, chunk, bytes, srcpde);
CREATEPDE(dstproc, dstptr, dstlinaddr, chunk, bytes, dstpde);
/* Copy pages. */
vmassert(intr_disabled());
@ -828,6 +757,9 @@ int lin_lin_copy(struct proc *srcproc, vir_bytes srclinaddr,
vmassert(catch_pagefaults);
catch_pagefaults = 0;
DONEPDE(srcpde);
DONEPDE(dstpde);
if(addr) {
if(addr >= srcptr && addr < (srcptr + chunk)) {
NOREC_RETURN(linlincopy, EFAULT_SRC);
@ -872,14 +804,16 @@ int vm_phys_memset(phys_bytes ph, u8_t c, phys_bytes bytes)
* We can do this 4MB at a time.
*/
while(bytes > 0) {
int pde;
vir_bytes chunk = bytes;
phys_bytes ptr;
inusepde = NOPDE;
CREATEPDE(((struct proc *) NULL), ptr, ph, chunk, bytes);
CREATEPDE(((struct proc *) NULL), ptr, ph, chunk, bytes, pde);
/* We can memset as many bytes as we have remaining,
* or as many as remain in the 4MB chunk we mapped in.
*/
phys_memset(ptr, p, chunk);
DONEPDE(pde);
bytes -= chunk;
ph += chunk;
}
@ -1077,6 +1011,25 @@ PUBLIC int data_copy(
return virtual_copy(&src, &dst, bytes);
}
/*===========================================================================*
* data_copy_vmcheck *
*===========================================================================*/
PUBLIC int data_copy_vmcheck(
endpoint_t from_proc, vir_bytes from_addr,
endpoint_t to_proc, vir_bytes to_addr,
size_t bytes)
{
struct vir_addr src, dst;
src.segment = dst.segment = D;
src.offset = from_addr;
dst.offset = to_addr;
src.proc_nr_e = from_proc;
dst.proc_nr_e = to_proc;
return virtual_copy_vmcheck(&src, &dst, bytes);
}
/*===========================================================================*
* arch_pre_exec *
*===========================================================================*/

23
kernel/arch/i386/mpx386.s
View File

@ -76,6 +76,7 @@ begbss:
.define _pagefault_count
.define _cr3_test
.define _cr3_reload
.define _reload_cr3
.define _write_cr3 ! write cr3
.define errexception
@ -419,7 +420,7 @@ _restart:
mov (loadedcr3), eax
mov eax, (_proc_ptr)
mov (_ptproc), eax
! mov (_dirtypde), 0
mov (_dirtypde), 0
0:
lea eax, P_STACKTOP(esp) ! arrange for next interrupt
mov (_tss+TSS3_S_SP0), eax ! to save state in process table
@ -566,16 +567,30 @@ _write_cr3:
mov ebp, esp
mov eax, 8(ebp)
inc (_cr3_test)
! cmp eax, (loadedcr3)
! jz 0f
cmp eax, (loadedcr3)
jz 0f
inc (_cr3_reload)
mov cr3, eax
mov (loadedcr3), eax
! mov (_dirtypde), 0
mov (_dirtypde), 0
0:
pop ebp
ret
!*===========================================================================*
!* reload_cr3 *
!*===========================================================================*
! PUBLIC void reload_cr3(void);
_reload_cr3:
push ebp
mov ebp, esp
inc (_cr3_reload)
mov (_dirtypde), 0
mov eax, cr3
mov cr3, eax
pop ebp
ret
!*===========================================================================*
!* level0_call *
!*===========================================================================*

1
kernel/arch/i386/proto.h
View File

@ -79,6 +79,7 @@ _PROTOTYPE( void i386_invlpg_level0, (void) );
_PROTOTYPE( int _memcpy_k, (void *dst, void *src, size_t n) );
_PROTOTYPE( int _memcpy_k_fault, (void) );
_PROTOTYPE( u32_t read_cr3, (void) );
_PROTOTYPE( void reload_cr3, (void) );
/* protect.c */
_PROTOTYPE( void prot_init, (void) );

22
kernel/arch/i386/system.c
View File

@ -153,6 +153,7 @@ PRIVATE void ser_debug(int c)
case '2':
ser_dump_queues();
break;
#if DEBUG_TRACE
#define TOGGLECASE(ch, flag) \
case ch: { \
if(verboseflags & flag) { \
@ -166,6 +167,7 @@ PRIVATE void ser_debug(int c)
}
TOGGLECASE('8', VF_SCHEDULING)
TOGGLECASE('9', VF_PICKPROC)
#endif
}
do_serial_debug--;
if(u) { unlock; }
@ -182,22 +184,13 @@ PRIVATE void printslot(struct proc *pp, int level)
return;
}
if(pp->p_ready && pp->p_rts_flags) {
printf("HUH? p_ready but rts flags!\n");
}
if(!pp->p_ready && !pp->p_rts_flags) {
printf("HUH? not p_ready but no rts flags!\n");
}
COL
kprintf("%d: %s %d prio %d/%d time %d/%d cr3 0x%lx rts %s misc %s ready %d",
kprintf("%d: %s %d prio %d/%d time %d/%d cr3 0x%lx rts %s misc %s",
proc_nr(pp), pp->p_name, pp->p_endpoint,
pp->p_priority, pp->p_max_priority, pp->p_user_time,
pp->p_sys_time, pp->p_seg.p_cr3,
rtsflagstr(pp->p_rts_flags), miscflagstr(pp->p_misc_flags),
pp->p_ready);
rtsflagstr(pp->p_rts_flags), miscflagstr(pp->p_misc_flags));
if(pp->p_rts_flags & SENDING) {
dep = pp->p_sendto_e;
@ -231,11 +224,6 @@ PRIVATE void printslot(struct proc *pp, int level)
COL
proc_stacktrace(pp);
if(pp->p_rts_flags & VMREQUEST) {
COL
printf("vmrequest set with: %s\n", pp->p_vmrequest.stacktrace);
}
if(depproc)
printslot(depproc, level+1);
}
@ -259,8 +247,6 @@ PUBLIC void ser_dump_proc()
{
struct proc *pp;
CHECK_RUNQUEUES;
for (pp= BEG_PROC_ADDR; pp < END_PROC_ADDR; pp++)
{
if (pp->p_rts_flags & SLOT_FREE)

8
kernel/debug.h
View File

@ -25,10 +25,10 @@
#define DEBUG_TIME_LOCKS 1
/* Runtime sanity checking. */
#define DEBUG_VMASSERT 1
#define DEBUG_SCHED_CHECK 1
#define DEBUG_STACK_CHECK 1
#define DEBUG_TRACE 1
#define DEBUG_VMASSERT 0
#define DEBUG_SCHED_CHECK 0
#define DEBUG_STACK_CHECK 0
#define DEBUG_TRACE 0
#if DEBUG_TRACE

2
kernel/proto.h
View File

@ -113,6 +113,8 @@ _PROTOTYPE( int virtual_copy_f, (struct vir_addr *src, struct vir_addr *dst,
vir_bytes bytes, int vmcheck) );
_PROTOTYPE( int data_copy, (endpoint_t from, vir_bytes from_addr,
endpoint_t to, vir_bytes to_addr, size_t bytes));
_PROTOTYPE( int data_copy_vmcheck, (endpoint_t from, vir_bytes from_addr,
endpoint_t to, vir_bytes to_addr, size_t bytes));
#define data_copy_to(d, p, v, n) data_copy(SYSTEM, (d), (p), (v), (n));
#define data_copy_from(d, p, v, n) data_copy((p), (v), SYSTEM, (d), (n));
_PROTOTYPE( void alloc_segments, (struct proc *rp) );

8
kernel/system.c
View File

@ -59,7 +59,7 @@ FORWARD _PROTOTYPE( void initialize, (void));
FORWARD _PROTOTYPE( struct proc *vmrestart_check, (message *));
u32_t cr3_test, cr3_reload, newpde, overwritepde,
linlincopies, physzero, invlpgs, npagefaults, vmreqs, vmcheckranges, straightpdes;
linlincopies, physzero, invlpgs, npagefaults, vmreqs, straightpdes;
/*===========================================================================*
* sys_task *
@ -98,20 +98,20 @@ PUBLIC void sys_task()
dt = u - prevu;
if(dt >= 5*system_hz) {
#define PERSEC(n) ((n)*system_hz/dt)
printf("%6d cr3 tests: %5lu cr3: %5lu straightpdes: %5lu newpde: %5lu overwritepde %5lu linlincopies: %5lu physzero: %5lu invlpgs: %5lu pagefaults: %5lu vmreq: %5lu vmcheckranges: %5lu\n",
printf("%6d cr3 tests: %5lu cr3: %5lu straightpdes: %5lu newpde: %5lu overwritepde %5lu linlincopies: %5lu physzero: %5lu invlpgs: %5lu pagefaults: %5lu vmreq: %5lu\n",
u/system_hz,
PERSEC(cr3_test), PERSEC(cr3_reload),
PERSEC(straightpdes), PERSEC(newpde),
PERSEC(overwritepde),
PERSEC(linlincopies), PERSEC(physzero),
PERSEC(invlpgs), PERSEC(npagefaults),
PERSEC(vmreqs), PERSEC(vmcheckranges));
PERSEC(vmreqs));
cr3_reload = 0;
cr3_test = 0;
newpde = overwritepde = linlincopies =
physzero = invlpgs = straightpdes = 0;
npagefaults = 0;
vmreqs = vmcheckranges = 0;
vmreqs = 0;
prevu = u;
}
}

27
kernel/system/do_getinfo.c
View File

@ -28,9 +28,8 @@ register message *m_ptr; /* pointer to request message */
*/
size_t length;
vir_bytes src_vir;
int proc_nr, nr_e, nr;
int proc_nr, nr_e, nr, r;
struct proc *caller;
phys_bytes ph;
int wipe_rnd_bin = -1;
caller = proc_addr(who_p);
@ -67,19 +66,6 @@ register message *m_ptr; /* pointer to request message */
src_vir = (vir_bytes) irq_hooks;
break;
}
case GET_SCHEDINFO: {
/* This is slightly complicated because we need two data structures
* at once, otherwise the scheduling information may be incorrect.
* Copy the queue heads and fall through to copy the process table.
*/
if((ph=umap_local(caller, D, (vir_bytes) m_ptr->I_VAL_PTR2,length)) == 0)
return EFAULT;
length = sizeof(struct proc *) * NR_SCHED_QUEUES;
CHECKRANGE_OR_SUSPEND(proc_addr(who_p), ph, length, 1);
data_copy(SYSTEM, (vir_bytes) rdy_head,
who_e, (vir_bytes) m_ptr->I_VAL_PTR2, length);
/* fall through to GET_PROCTAB */
}
case GET_PROCTAB: {
length = sizeof(struct proc) * (NR_PROCS + NR_TASKS);
src_vir = (vir_bytes) proc;
@ -174,15 +160,16 @@ register message *m_ptr; /* pointer to request message */
/* Try to make the actual copy for the requested data. */
if (m_ptr->I_VAL_LEN > 0 && length > m_ptr->I_VAL_LEN) return (E2BIG);
if((ph=umap_local(caller, D, (vir_bytes) m_ptr->I_VAL_PTR,length)) == 0)
return EFAULT;
CHECKRANGE_OR_SUSPEND(caller, ph, length, 1);
if(data_copy(SYSTEM, src_vir, who_e, (vir_bytes) m_ptr->I_VAL_PTR, length) == OK) {
r = data_copy_vmcheck(SYSTEM, src_vir, who_e,
(vir_bytes) m_ptr->I_VAL_PTR, length);
if(r != OK) return r;
if(wipe_rnd_bin >= 0 && wipe_rnd_bin < RANDOM_SOURCES) {
krandom.bin[wipe_rnd_bin].r_size = 0;
krandom.bin[wipe_rnd_bin].r_next = 0;
}
}
return(OK);
}

20
kernel/system/do_sigsend.c
View File

@ -29,18 +29,13 @@ message *m_ptr; /* pointer to request message */
struct sigcontext sc, *scp;
struct sigframe fr, *frp;
int proc, r;
phys_bytes ph;
if (!isokendpt(m_ptr->SIG_ENDPT, &proc)) return(EINVAL);
if (iskerneln(proc)) return(EPERM);
rp = proc_addr(proc);
ph = umap_local(proc_addr(who_p), D, (vir_bytes) m_ptr->SIG_CTXT_PTR, sizeof(struct sigmsg));
if(!ph) return EFAULT;
CHECKRANGE_OR_SUSPEND(proc_addr(who_p), ph, sizeof(struct sigmsg), 1);
/* Get the sigmsg structure into our address space. */
if((r=data_copy(who_e, (vir_bytes) m_ptr->SIG_CTXT_PTR,
if((r=data_copy_vmcheck(who_e, (vir_bytes) m_ptr->SIG_CTXT_PTR,
SYSTEM, (vir_bytes) &smsg, (phys_bytes) sizeof(struct sigmsg))) != OK)
return r;
@ -59,12 +54,9 @@ message *m_ptr; /* pointer to request message */
sc.sc_flags = 0; /* unused at this time */
sc.sc_mask = smsg.sm_mask;
ph = umap_local(rp, D, (vir_bytes) scp, sizeof(struct sigcontext));
if(!ph) return EFAULT;
CHECKRANGE_OR_SUSPEND(rp, ph, sizeof(struct sigcontext), 1);
/* Copy the sigcontext structure to the user's stack. */
if((r=data_copy(SYSTEM, (vir_bytes) &sc, m_ptr->SIG_ENDPT, (vir_bytes) scp,
(vir_bytes) sizeof(struct sigcontext))) != OK)
if((r=data_copy_vmcheck(SYSTEM, (vir_bytes) &sc, m_ptr->SIG_ENDPT,
(vir_bytes) scp, (vir_bytes) sizeof(struct sigcontext))) != OK)
return r;
/* Initialize the sigframe structure. */
@ -78,11 +70,9 @@ message *m_ptr; /* pointer to request message */
fr.sf_signo = smsg.sm_signo;
fr.sf_retadr = (void (*)()) smsg.sm_sigreturn;
ph = umap_local(rp, D, (vir_bytes) frp, sizeof(struct sigframe));
if(!ph) return EFAULT;
CHECKRANGE_OR_SUSPEND(rp, ph, sizeof(struct sigframe), 1);
/* Copy the sigframe structure to the user's stack. */
if((r=data_copy(SYSTEM, (vir_bytes) &fr, m_ptr->SIG_ENDPT, (vir_bytes) frp,
if((r=data_copy_vmcheck(SYSTEM, (vir_bytes) &fr,
m_ptr->SIG_ENDPT, (vir_bytes) frp,
(vir_bytes) sizeof(struct sigframe))) != OK)
return r;

6
kernel/system/do_sysctl.c
View File

@ -16,7 +16,6 @@
PUBLIC int do_sysctl(m_ptr)
register message *m_ptr; /* pointer to request message */
{
phys_bytes ph;
vir_bytes len, buf;
static char mybuf[DIAG_BUFSIZE];
struct proc *caller, *target;
@ -33,10 +32,7 @@ register message *m_ptr; /* pointer to request message */
caller->p_endpoint, len);
return EINVAL;
}
if((ph=umap_local(caller, D, buf, len)) == 0)
return EFAULT;
CHECKRANGE_OR_SUSPEND(caller, ph, len, 1);
if((s=data_copy(who_e, buf, SYSTEM, (vir_bytes) mybuf, len)) != OK) {
if((s=data_copy_vmcheck(who_e, buf, SYSTEM, (vir_bytes) mybuf, len)) != OK) {
kprintf("do_sysctl: diag for %d: len %d: copy failed: %d\n",
caller->p_endpoint, len, s);
return s;

3
kernel/system/do_umap.c
View File

@ -48,13 +48,11 @@ register message *m_ptr; /* pointer to request message */
case LOCAL_SEG:
phys_addr = lin_addr = umap_local(targetpr, seg_index, offset, count);
if(!lin_addr) return EFAULT;
CHECKRANGE_OR_SUSPEND(targetpr, lin_addr, count, 1);
naughty = 1;
break;
case REMOTE_SEG:
phys_addr = lin_addr = umap_remote(targetpr, seg_index, offset, count);
if(!lin_addr) return EFAULT;
CHECKRANGE_OR_SUSPEND(targetpr, lin_addr, count, 1);
naughty = 1;
break;
case GRANT_SEG:
@ -93,7 +91,6 @@ register message *m_ptr; /* pointer to request message */
kprintf("SYSTEM:do_umap: umap_local failed\n");
return EFAULT;
}
CHECKRANGE_OR_SUSPEND(targetpr, lin_addr, count, 1);
if(vm_lookup(targetpr, lin_addr, &phys_addr, NULL) != OK) {
kprintf("SYSTEM:do_umap: vm_lookup failed\n");
return EFAULT;

9
kernel/vm.h
View File

@ -2,15 +2,6 @@
#ifndef _VM_H
#define _VM_H 1
#define CHECKRANGE_OR_SUSPEND(pr, start, length, wr) { int mr; \
FIXME("CHECKRANGE_OR_SUSPEND exists"); \
if(vm_running && (mr=vm_checkrange(proc_addr(who_p), pr, start, length, wr, 0)) != OK) { \
return mr; \
} }
#define CHECKRANGE(pr, start, length, wr) \
vm_checkrange(proc_addr(who_p), pr, start, length, wr, 1)
/* Pseudo error codes */
#define VMSUSPEND -996
#define EFAULT_SRC -995

1
servers/is/dmp.c
View File

@ -21,7 +21,6 @@ struct hook_entry {
{ F5, monparams_dmp, "Boot monitor parameters" },
{ F6, irqtab_dmp, "IRQ hooks and policies" },
{ F7, kmessages_dmp, "Kernel messages" },
{ F9, sched_dmp, "Scheduling queues" },
{ F10, kenv_dmp, "Kernel parameters" },
{ F11, timing_dmp, "Timing details (if enabled)" },
{ SF1, mproc_dmp, "Process manager process table" },

48
servers/is/dmp_kernel.c
View File

@ -224,54 +224,6 @@ PUBLIC void image_dmp()
printf("\n");
}
/*===========================================================================*
* sched_dmp *
*===========================================================================*/
PUBLIC void sched_dmp()
{
struct proc *rdy_head[NR_SCHED_QUEUES];
struct kinfo kinfo;
register struct proc *rp;
vir_bytes ptr_diff;
int r;
/* First obtain a scheduling information. */
if ((r = sys_getschedinfo(proc, rdy_head)) != OK) {
report("IS","warning: couldn't get copy of process table", r);
return;
}
/* Then obtain kernel addresses to correct pointer information. */
if ((r = sys_getkinfo(&kinfo)) != OK) {
report("IS","warning: couldn't get kernel addresses", r);
return;
}
/* Update all pointers. Nasty pointer algorithmic ... */
ptr_diff = (vir_bytes) proc - (vir_bytes) kinfo.proc_addr;
for (r=0;r<NR_SCHED_QUEUES; r++)
if (rdy_head[r] != NIL_PROC)
rdy_head[r] =
(struct proc *)((vir_bytes) rdy_head[r] + ptr_diff);
for (rp=BEG_PROC_ADDR; rp < END_PROC_ADDR; rp++)
if (rp->p_nextready != NIL_PROC)
rp->p_nextready =
(struct proc *)((vir_bytes) rp->p_nextready + ptr_diff);
/* Now show scheduling queues. */
printf("Dumping scheduling queues.\n");
for (r=0;r<NR_SCHED_QUEUES; r++) {
rp = rdy_head[r];
if (!rp) continue;
printf("%2d: ", r);
while (rp != NIL_PROC) {
printf("%3d ", rp->p_nr);
rp = rp->p_nextready;
}
printf("\n");
}
printf("\n");
}
/*===========================================================================*
* kenv_dmp *

2
servers/vm/i386/memory.h
View File

@ -15,7 +15,7 @@
#define VM_PAGE_SIZE I386_PAGE_SIZE
/* Where do processes start in linear (i.e. page table) memory? */
#define VM_PROCSTART (I386_BIG_PAGE_SIZE*10)
#define VM_PROCSTART (I386_BIG_PAGE_SIZE*100)
#define CLICKSPERPAGE (I386_PAGE_SIZE/CLICK_SIZE)