BootStartList USING [EntryPointer, Enumerate, IndexToEntryPointer, IndexToSpaceEntryPointer, Proc],

DebuggerSwap USING [CallDebugger, WorryCallDebugger],

GermSwap USING [switches],

MPCodes USING [vmInitialized],

PrincOps USING [AV, AVItem, FaultIndex, flagsVacant, FrameHandle, LargeReturnSlot, NoTimeout, PageValue, PDA, PsbHandle, PsbNull, qFrameFault, qPageFault, qWriteProtectFault, Queue, QueueEmpty, StateVector],

PrincOpsUtils USING [DisableInterrupts, EnableInterrupts, FrameSize, Free, GetReturnFrame, LongEnter, LongExit, LongReEnter, LongWait, LowHalf, MyLocalFrame, PsbIndexToHandle, Requeue, SetReturnFrame],

Process USING [Detach, DisableTimeout, priorityFaultHandlers, priorityForeground, SecondsToTicks, SetPriority, SetTimeout, Ticks, Yield],

ProcessorFace USING [SetMP],

VM USING [AddressFault, AddressForPageNumber, CantDoIO, DataState, Free, IOErrorType, Interval, PageCount, PageNumber, PageNumberForAddress, PagesForWords, PageState, SimpleAllocate, State, SwapIn, WordsForPages, WriteProtectFault],

VMEmergency,

VMInternal USING [AllocateRealMemoryForLocalFrames, AllocateVirtualMemoryInternal, allocationLock, AllocationOutcome, AnyFrameSizeIndex, FrameHeapPiece, FrameHeapPieceHeader, FsiFrame, GetPageValue, GetVMMap, InOut, LargeFrame, LargeFrameHeader, largeFrameThresholdFsi, lastVMPage, NormalFrameSizeIndex, PageStateFromFlags],

VMSideDoor USING [rmPages],

VMStatistics USING [];

debugInfo: LONG POINTER TO DebugInfo ← NIL;

DebugInfo: TYPE = RECORD [

FaultsInRing: NAT = 16;

PageFaultInfo: TYPE = RECORD [

Reserve a state vector for this process

Process.SetPriority[Process.priorityFaultHandlers];

DO

};

Reserve a state vector for this process

Process.SetPriority[Process.priorityFaultHandlers];

DO

};

Reserve a state vector for this process.

OPEN VMInternal;

Process.SetPriority[Process.priorityFaultHandlers];

DO

};

This process can run at any priority and without a reserved state vector.

Process.SetPriority[Process.priorityFaultHandlers];

DO

};

This process refills the emergency page list used by frame allocation when there are no available clean pages. We give this a foreground priority to try to stay ahead of greedy processes.

WaitForEmergency: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {

interval: VM.Interval = VM.SimpleAllocate[count: 1];

lagChange: INT ← -1;

eList: VMEmergency.EmergencyList = VM.AddressForPageNumber[interval.page];

eList.change ← 0;

eList.max ← 16;

eList.pages ← ALL[0];

Process.SetPriority[Process.priorityForeground];

VM.SwapIn[interval: interval, pin: TRUE];

VMEmergency.emergencyList ← eList; -- install the emergency list

{

DO

};

BROADCAST emergencyCond;

};

firstPage: VM.PageNumber ← faultedPage ;

lastPage: VM.PageNumber ← firstPage ;

pageState: VM.PageState ← VM.State[firstPage];

dataState: VM.DataState ← pageState.dataState;

pageCount: INT ← 1 ;

maxSize: INT = MAX[ReadOnlyPageInSize, ReadWritePageInSize];

IF firstPage > VMInternal.lastVMPage THEN RETURN [[page: firstPage, count: 0]];

IF pageState.hasRealMemory OR dataState = none OR dataState = undefined THEN

WHILE pageCount < maxSize AND lastPage < VMInternal.lastVMPage DO

WHILE pageCount < maxSize AND firstPage > 0 DO

RETURN[[page: firstPage, count: pageCount]]

};

If the successor of "process" on the queue differs from "process", we extract the page number on which it has faulted. Note that another process may come along and be inserted between the two, but this is unlikely and we're only looking for a hint to optimize disk arm motion.

nextProcess: PsbHandle = PrincOpsUtils.PsbIndexToHandle[PDA[process].link.next];

RETURN[

};

This routine can be called from a world-swap debugger to examine the current state of a page. It is also used inside of ReportFault to capture the state at the time of the fault.

IF page <= 0 OR page > VMInternal.lastVMPage THEN

RETURN [VMInternal.GetPageValue[page]];

};

Return: PROC ← LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];

state: StateVector = PDA[PDA[psb].context.state];

Variables for easy inspection from the debugger if something goes wrong

IF error = VM.AddressFault AND debugInfo # NIL THEN {

Splice me in as top-of-stack of psb.

PDA[PDA[psb].context.state].stkptr ← PDA[PDA[psb].context.state].instbyte ← 0;

PrincOpsUtils.SetReturnFrame[state.frame];

PDA[PDA[psb].context.state].frame ← LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];

Return to caller without disturbing this frame.

Return[];

Control returns here in the context of the faulting process. If it has

a dirty cleanup link, disaster may ensue if a signal is raised, since it is

almost certain to be uncaught and the AMEvents stuff will doubtless do a WAIT.

If someone caught it and did a wait, similar bad things would happen. So, we

call the world-swap debugger instead.

IF PDA[psb].flags.cleanup ~= PsbNull THEN

ERROR error[state.memPointer];

};

Return: PROC ← LOOPHOLE[PrincOpsUtils.GetReturnFrame[]];

state: StateVector = PDA[PDA[psb].context.state];

address: LONG POINTER = state.memPointer; -- for easy inspection from the debugger.

Splice me in as top-of-stack of psb.

PDA[PDA[psb].context.state].stkptr ← PDA[PDA[psb].context.state].instbyte ← 0;

PrincOpsUtils.SetReturnFrame[state.frame];

PDA[PDA[psb].context.state].frame ← LOOPHOLE[PrincOpsUtils.MyLocalFrame[]];

Return to caller without disturbing this frame.

Return[];

Control returns here in the context of the faulting process. If it has

a dirty cleanup link, disaster may ensue if a signal is raised, since it is

almost certain to be uncaught and the AMEvents stuff will doubtless do a WAIT.

If someone caught it and did a wait, similar bad things would happen. So, we

call the world-swap debugger instead.

IF PDA[psb].flags.cleanup ~= PsbNull THEN

ERROR VM.CantDoIO[reason, page];

};

Implementation note: The explicit use of PrincOpsUtils to invoke monitor instructions is required because FaultQueues do not have full CONDITION variables in them. Rather, they have only the Queue portion; there is no timeout field. Since the generated code for WAIT assumes a timeout word follows the Queue, the language construct can't be used. Of course, the use of monitor locks is really unnecessary anyway, since there is only a single process doing waits and the condition variable is notified by microcode with a naked notify. However, it is the easiest way to achieve the desired effect.

lock: MONITORLOCK;

pCondition: LONG POINTER TO CONDITION = LOOPHOLE[@PDA.fault[q].condition];

--Temp kludge to allow Laundry to get in: -- Process.Yield[]; -- (ADB)

UNTIL PrincOpsUtils.LongEnter[@lock] DO ENDLOOP;

WHILE PDA.fault[q].queue = QueueEmpty DO

psb ← PrincOpsUtils.PsbIndexToHandle[PDA.block[PDA.fault[q].queue.tail].link.next];

PrincOpsUtils.LongExit[@lock];

};

PrincOpsUtils.Requeue[@PDA.fault[q].queue, @PDA.ready, psb];

};

WaitForLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {

WaitForLargeFrameEntry[@largeFramesLock];

};

NotifyLargeFrameEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {

NotifyLargeFrameEntry[@largeFramesLock];

};

This is a specialized procedure for use by the frame fault handler. It is semantically equivalent to {interval ← Allocate[count, mds]; SwapIn[interval, kill: TRUE, pin: TRUE]}, but must be implemented carefully because of the delicate state of the world at the time it is invoked.

outcome: VMInternal.AllocationOutcome;

AllocateForLocalFramesEntry: ENTRY PROC [monitor: POINTER TO MONITORLOCK] = INLINE {

AllocateForLocalFramesEntry[@VMInternal.allocationLock];

IF outcome ~= ok THEN DebuggerSwap.WorryCallDebugger["No VM for frame heap"L];

FOR page: VM.PageNumber IN [interval.page..interval.page+interval.count) DO

NoteEmergency[@emergencyLock];

};

RETURN[PrincOpsUtils.LowHalf[VM.AddressForPageNumber[page]]]

};

myFramePage: VM.PageNumber = VM.PageNumberForAddress[PrincOpsUtils.MyLocalFrame[]];

FindOriginalFrameHeap: BootStartList.Proc = {

PDA.fault[qFrameFault] ← PDA.fault[qPageFault] ← PDA.fault[qWriteProtectFault] ←

Process.Detach[FORK PageFaultProcess];

Process.Detach[FORK WriteProtectFaultProcess];

BootStartList.Enumerate[FindOriginalFrameHeap];

Process.Detach[FORK FrameFaultProcess];

Process.DisableTimeout[@largeFramesInUse];

Process.Detach[FORK FlushLargeFramesProcess];

Process.Detach[FORK EmergencyRefillProcess];

SELECT VMSideDoor.rmPages FROM

IF GermSwap.switches[two] THEN DebuggerSwap.CallDebugger["Key stop 2 (VM)"L];

ProcessorFace.SetMP[MPCodes.vmInitialized];

};