[Cyan]<CedarChest6.0>Spy>SpyKernelImpl.mesa!4

SpyKernelImpl.mesa

Maxwell September 16, 1983 3:44 pm

Russ Atkinson March 8, 1985 7:12:36 pm PST

Bob Hagmann February 6, 1986 8:53:31 am PST

Russ Atkinson (RRA) March 31, 1986 2:41:59 pm PST

DIRECTORY

Basics USING [BITAND],

BasicTime USING [GetClockPulses, Pulses, PulsesToMicroseconds],

DebuggerSwap USING [CallDebugger],

FastBreak USING [FastBreakProc],

IntervalTimer USING [WaitForExpirationInterval],

IntervalTimerFace USING [exists],

PrincOps,

PrincOpsUtils USING [DisableInterrupts, EnableInterrupts, LongNotify, LongReEnter, LongWait, PsbIndexToHandle, PsbHandleToIndex, ReadPSB, ReadPTC],

PageMap USING [GetF, flagsVacant],

Process USING [Detach, GetCurrent, GetPriority, InitializeCondition, Priority, priorityRealTime, priorityNormal, SecondsToTicks, SetPriority],

Rope USING [ROPE],

SafeStorage USING [NWordsAllocated, NWordsReclaimed],

Loader USING [MakeProcedureResident, MakeGlobalFrameResident],

SpyClient USING [DataType],

SpyLog USING [active, Here, OpenForWrite, WriteData],

SpyOps USING [Count, DataType, Frame, SetAllocationBreak, SpyState, Stack, stackHeader, stackLength, StackType],

Terminal USING [Current, Virtual, WaitForBWVerticalRetrace],

VM USING [AddressFault, PageNumberForAddress],

VMStatistics USING [pageFaults];

SpyKernelImpl: MONITOR

IMPORTS Basics, BasicTime, DebuggerSwap, Loader, PrincOpsUtils, Process, SafeStorage, SpyLog, SpyOps, Terminal, VM, VMStatistics

EXPORTS SpyClient, SpyOps

= { OPEN PrincOps, Rope;

PsbIndex: TYPE = PrincOps.PsbIndex;

Ticks: TYPE = PrincOps.Ticks;

SpyKernel parameters

spyState: PUBLIC SpyOps.SpyState ← off;

watching: PUBLIC SpyOps.DataType ← CPU;

justMe: PUBLIC PsbIndex ← 0;

general statistics

runningTime: PUBLIC BasicTime.Pulses; -- total time running

pageFaults: PUBLIC LONG CARDINAL;

active, starts, stops: PUBLIC INTEGER ← 0;

wordsAllocated: PUBLIC LONG CARDINAL;

wordsReclaimed: PUBLIC LONG CARDINAL;

code: PUBLIC SpyOps.Count ← 0; -- page faults on code

data: PUBLIC SpyOps.Count ← 0; -- page faults on data

****************************************************************************

initializing the Spy and data

****************************************************************************

InitializeSpy: PUBLIC ENTRY PROC[dataType: SpyClient.DataType ← CPU, process: PsbIndex ← PrincOps.PsbNull, spyOnSpyLog: BOOL ← FALSE] RETURNS[errorMsg: ROPE] = {

DisableSpy[];

IF dataType IN [allocations..wordsAllocated] THEN errorMsg ← SpyOps.SetAllocationBreak[];

IF errorMsg # NIL THEN RETURN[errorMsg];

InitializeTables[];

watching ← dataType;

justMe ← IF dataType = process THEN process ELSE 0;

SpyLog.OpenForWrite[spyOnSpyLog];

EnableSpy[];

};

InitializeTables: PROC = {

runningTime ← 0;

code ← data ← 0;

wordsAllocated ← wordsReclaimed ← 0;

};

Initialize: PROC = {

dolphin ← BasicTime.PulsesToMicroseconds[1]#32; -- hack

Loader.MakeProcedureResident[Spy];

Loader.MakeProcedureResident[Record];

Loader.MakeProcedureResident[UserBreak];

Loader.MakeProcedureResident[PageFaultRecorder];

Loader.MakeGlobalFrameResident[Initialize];

Process.InitializeCondition[@processDead, 10000];

SetTimeouts[];

};

SetTimeouts: PROC = {

ticks: Ticks;

cutoff: Ticks;

found: BOOLEAN;

frame: PrincOps.FrameHandle;

IF IntervalTimerFace.exists THEN RETURN;

IF index = maxIndex THEN RETURN;

cutoff ← Process.SecondsToTicks[10];

PrincOpsUtils.DisableInterrupts[]; -- stops the clock. NO PAGE FAULTS ALLOWED!

ticks ← PrincOpsUtils.ReadPTC[];

FOR psbi: PsbIndex IN [PrincOps.StartPsb..PrincOps.StartPsb+PrincOps.PDA.count) DO

IF PrincOps.PDA.block[psbi].mds = 0 THEN LOOP;

IF PrincOps.PDA.block[psbi].mds - ticks > cutoff THEN LOOP; -- not significant

IF PrincOps.PDA.block[psbi].link.vector

THEN frame ← PDA[PrincOps.PDA.block[psbi].context.state].frame

ELSE frame ← PrincOps.PDA.block[psbi].context.frame;

found ← FALSE;

FOR i: CARDINAL IN [0..index) DO

IF timeout[i] = [frame.accesslink, frame.pc] THEN {found ← TRUE; EXIT};

ENDLOOP;

IF found THEN LOOP;

timeout[index] ← [frame.accesslink, frame.pc];

index ← index + 1;

IF index = maxIndex THEN EXIT;

ENDLOOP;

PrincOpsUtils.EnableInterrupts[];

};

****************************************************************************

starting and stopping the Spy

****************************************************************************

Note: These procedures need not be resident.

processDead: CONDITION;

spyProcess: PROCESS ← NIL;

oldSpyState: SpyOps.SpyState ← off;

startTime: BasicTime.Pulses;

startPageFaults: LONG CARDINAL;

startWordsAllocated: LONG CARDINAL;

startWordsReclaimed: LONG CARDINAL;

StartCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {

priority: Process.Priority;

starts ← starts + 1;

IF active = 0 THEN WHILE spyProcess # NIL DO WAIT processDead; ENDLOOP;

IF (active ← active + 1) > 1 THEN RETURN[useOldBreak: FALSE]; -- a psuedo start

startPageFaults ← VMStatistics.pageFaults;

startWordsAllocated ← SafeStorage.NWordsAllocated[];

startWordsReclaimed ← SafeStorage.NWordsReclaimed[];

startTime ← BasicTime.GetClockPulses[];

IF watching = breakProcess THEN justMe ← LOOPHOLE[Process.GetCurrent[]];

IF justMe # 0 THEN justMePrincOps ← @PrincOps.PDA[PrincOpsUtils.PsbIndexToHandle[justMe]];

SetTimeouts[]; -- do it a second time in case the first time missed some

priority ← Process.GetPriority[];

Process.SetPriority[Process.priorityRealTime];

SELECT watching FROM

CPU, process, breakProcess => Process.Detach[spyProcess ← FORK Spy[]];

pagefaults => Process.Detach[spyProcess ← FORK PageFaultRecorder[]];

allocations, wordsAllocated => {

RTStorageAccounting.AllocatorCallbackProcForSpy ← SensitiveBreak;

spyState ← on};

ENDCASE => spyState ← on;

Process.SetPriority[priority];

RETURN[useOldBreak: FALSE];

};

StopCounting: PUBLIC ENTRY FastBreak.FastBreakProc = {

IF active = 0 THEN RETURN[useOldBreak: FALSE]; -- already stopped

stops ← stops + 1;

IF (active ← active - 1) > 0 THEN RETURN; -- a psuedo stop

spyState ← off;

runningTime ← runningTime + BasicTime.GetClockPulses[] - startTime;

pageFaults ← pageFaults + VMStatistics.pageFaults - startPageFaults;

wordsAllocated ← wordsAllocated + SafeStorage.NWordsAllocated[] - startWordsAllocated;

wordsReclaimed ← wordsReclaimed + SafeStorage.NWordsReclaimed[] - startWordsReclaimed;

RETURN[useOldBreak: FALSE];

};

DisableSpy: PROC = {

IF spyState = disabled THEN RETURN;

oldSpyState ← spyState;

spyState ← disabled;

};

EnableSpy: PROC = {spyState ← oldSpyState};

*********************************************************************

watching CPU

*********************************************************************

All code invoked by this process should be resident

justMePrincOps: LONG POINTER TO ProcessStateBlock ← NIL;

wait: CARDINAL ← 0; -- used with dolphins

monitor: BOOLEAN ← FALSE; -- measure performance of spy

dolphin: BOOLEAN ← FALSE;

maxStackDepth: CARDINAL = 200;

timeout: ARRAY [0..maxIndex) OF RECORD[gfh: PrincOps.GlobalFrameHandle, pc: CARDINAL];

maxIndex: CARDINAL = 25;

index: CARDINAL← 0;

sampleInterval: INT ← 10*1000; -- measured in microseconds

screen: Terminal.Virtual = Terminal.Current[];

searchReadyList: BOOLEAN ← TRUE; -- sometimes the user gets the machine gets into a state where searching the ready list is a bad idea. This boolean allows the user to stop the Spy from searching the ready list.

Spy: PROC = {

top: PsbIndex;

frame: FrameHandle;

myPrincOps: PsbHandle = PrincOpsUtils.ReadPSB[];

handleMask: PsbLink = [

failed: FALSE, priority: 0, next: LAST[PsbIndex], reserved: 0, vector: FALSE];

NextHandle: PROC [link: CARDINAL] RETURNS [PsbHandle] = INLINE {

RETURN[LOOPHOLE[Basics.BITAND[link, LOOPHOLE[handleMask]]]]};

SearchReadyList: PROC = INLINE {

skip, once: BOOLEAN ← FALSE;

headOfReadyList, current: PsbHandle;

PrincOpsUtils.DisableInterrupts[];

top ← PrincOps.PsbNull;

headOfReadyList ← NextHandle[LOOPHOLE[PDA.ready]];

headOfReadyList ← NextHandle[LOOPHOLE[PDA[headOfReadyList].link]]; -- want the SECOND psb.

FOR current ← headOfReadyList, NextHandle[LOOPHOLE[PDA[current].link]] DO

psb: LONG POINTER TO ProcessStateBlock = @PDA[current];

link: PsbLink = psb.link;

level: Process.Priority = link.priority;

IF current = headOfReadyList THEN IF once THEN EXIT ELSE once ← TRUE;

IF level = 0 THEN LOOP;

IF current = myPrincOps THEN LOOP;

IF ~link.vector AND PDA.state[level] = NullStateVectorHandle THEN LOOP; -- no SV.

frame ← IF link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;

skip over a process that appears in the ready queue because it just timed out.

(The Spy wakes up with all of the other timeouts. Since it is the highest priority,

it will run first. All of the other timeouts will appear on the ready list. Most likely,

they will just check some condition and then go back to sleep. This will mask the

more interesting processes.)

skip ← FALSE;

FOR i: CARDINAL IN [0..maxIndex) DO

IF timeout[i] = [NIL, 0] THEN EXIT;

IF timeout[i] # [frame.accesslink, frame.pc] THEN LOOP;

skip ← TRUE; EXIT;

ENDLOOP;

IF skip THEN LOOP;

we have a good process!

top ← PrincOpsUtils.PsbHandleToIndex[current];

EXIT; ENDLOOP;

PrincOpsUtils.EnableInterrupts[];

};

spyState ← on;

MAIN LOOP

IF IntervalTimerFace.exists

THEN IntervalTimer.WaitForExpirationInterval[sampleInterval] ELSE

Terminal.WaitForBWVerticalRetrace[screen];

IF active <= 0 THEN EXIT;

IF spyState = disabled THEN LOOP;

IF dolphin AND wait > 0 THEN {wait ← wait - 1; LOOP} ELSE wait ← 8;

IF monitor THEN SpyLog.Here[];

IF justMe = 0 OR searchReadyList THEN SearchReadyList[];

SELECT TRUE FROM

justMe = 0 => Record[top, frame];

justMePrincOps.link.failed => Record[justMe, NIL, 2]; -- waiting ML

justMePrincOps.flags.waiting => Record[justMe, NIL, 3]; -- waiting CV

OnQueue[justMe, @PDA.fault[PrincOps.qPageFault].queue] =>

Record[justMe, NIL, 1]; -- waiting pagefault

OnQueue[justMe, @PDA.fault[PrincOps.qPageFault+4].queue] =>

Record[justMe, NIL, 1]; -- waiting pagefault

OnQueue[justMe, @PrincOps.PDA.ready] =>

SELECT TRUE FROM

PDA.state[justMePrincOps.link.priority] = NullStateVectorHandle AND

~justMePrincOps.link.vector => Record[justMe, NIL, 5]; -- waiting SV

searchReadyList AND justMe # top => Record[justMe, NIL, 4]; -- prempted by a higher priority process

ENDCASE => Record[justMe]; -- ready

ENDCASE => Record[justMe, NIL, 6]; -- in some unknown state

IF monitor THEN SpyLog.Here[];

ENDLOOP;

spyProcess ← NIL;

spyState ← off;

NotifyProcessDead[];

Process.SetPriority[Process.priorityNormal];

};

OnQueue: PROC[psbi: PsbIndex, queueHandle: PrincOps.QueueHandle] RETURNS[BOOL] = INLINE {

tail, prev: PsbIndex;

IF queueHandle^ = PrincOps.QueueEmpty THEN RETURN[FALSE];

prev ← tail ← queueHandle.tail;

THROUGH [FIRST[PsbIndex]..LAST[PsbIndex]+1] -- garbage protection --

DO next: PsbIndex = PrincOps.PDA.block[prev].link.next;

IF next = psbi THEN RETURN[TRUE];

prev ← next;

IF prev = tail THEN RETURN[FALSE];

ENDLOOP;

RETURN[FALSE] -- actually, the queue is thoroughly mangled! --

};

*********************************************************************

watching pagefaults

*********************************************************************

recordPageFaulted: BOOLEAN ← FALSE;

Data: TYPE = RECORD[process: CARDINAL, page: INTEGER];

CodeBase: TYPE = LONG POINTER TO PACKED ARRAY [0..0) OF PrincOps.op;

PageFaultRecorder: PROC = {

stolen from Ben.mesa

fault: Data;

type: CARDINAL;

codePage: INTEGER;

handle: PrincOps.PsbHandle;

frame: PrincOps.FrameHandle;

pda: PrincOps.PDABase = PrincOps.PDA;

qPageFault: PrincOps.FaultIndex = PrincOps.qPageFault;

pPageFaultCondition: LONG POINTER TO PrincOps.Condition =

@pda.fault[qPageFault].condition;

pPageFaultCONDITION: LONG POINTER TO CONDITION =

LOOPHOLE[pPageFaultCondition];

recorderLock: MONITORLOCK;

shouldNotifyPilot: BOOLEAN ← FALSE;

NO PAGE FAULTS ALLOWED!

spyState ← on;

wait for a page fault:

PrincOpsUtils.LongWait[@recorderLock, pPageFaultCONDITION, 1];

UNTIL PrincOpsUtils.LongReEnter[@recorderLock, pPageFaultCONDITION] DO

NULL ENDLOOP;

IF pda.fault[qPageFault].queue.tail = PrincOps.PsbNull THEN { -- timed out

IF shouldNotifyPilot

AND pda.fault[qPageFault].condition.tail ~= PrincOps.PsbNull THEN {

LongNakedNotify[pPageFaultCONDITION];

shouldNotifyPilot ← FALSE};

IF active <= 0 THEN EXIT;

LOOP}; -- go back and wait again.

figure out who faulted:

fault.process ← pda.block[pda.fault[qPageFault].queue.tail].link.next; -- walk to tail, then to head.

handle ← PrincOpsUtils.PsbIndexToHandle[fault.process];

fault.page ← VM.PageNumberForAddress[pda[pda[handle].context.state].memPointer];

frame ← IF pda[handle].link.vector

THEN pda[pda[handle].context.state].frame

ELSE pda[handle].context.frame;

codePage ← LOOPHOLE[frame.accesslink.code.longbase+frame.pc/2, INT]/256;

SELECT TRUE FROM

ABS[codePage - fault.page] <= 1 => {code ← code + 1; type ← 2};

Xfer[frame.accesslink.code.longbase, frame.pc] => {code ← code + 1; type ← 3};

ENDCASE => {data ← data + 1; type ← 1};

wake up the Pilot fault handler:

PrincOpsUtils.DisableInterrupts[];

IF pPageFaultCondition^.tail = PrincOps.PsbNull

THEN shouldNotifyPilot ← TRUE -- Pilot not ready for this fault yet...

ELSE LongNakedNotify[pPageFaultCONDITION];

PrincOpsUtils.EnableInterrupts[];

log the fault:

IF active <= 0 THEN EXIT;

IF recordPageFaulted THEN SpyLog.WriteData[@fault, SIZE[Data], CODE[Data]];

Record[fault.process, NIL, type];

ENDLOOP;

spyProcess ← NIL;

spyState ← off;

NotifyProcessDead[];

Process.SetPriority[Process.priorityNormal];

};

Xfer: PROC[base: CodeBase, pc: PrincOps.BytePC] RETURNS[BOOLEAN] = INLINE {

is the current pc pointing to some sort of xfer?

IF base[pc] IN [PrincOps.zEFC0..PrincOps.zKFCB] THEN RETURN[TRUE];

RETURN[FALSE];

};

LongNakedNotify: PROC [pCondition: LONG POINTER TO CONDITION] = INLINE {

Used ONLY to notify a condition from a high priority process outside the relevant monitor.

pCond: LONG POINTER TO PrincOps.Condition = LOOPHOLE[pCondition];

PrincOpsUtils.DisableInterrupts[];

IF pCond^.tail=PrincOps.PsbNull

THEN {pCond^.wakeup ← TRUE; PrincOpsUtils.EnableInterrupts[]}

ELSE {PrincOpsUtils.EnableInterrupts[]; PrincOpsUtils.LongNotify[pCondition]}};

NotifyProcessDead: ENTRY PROC = INLINE {NOTIFY processDead};

***************************************************************************

recording the information

***************************************************************************

stack: SpyOps.Stack;

break: BOOLEAN ← FALSE;

breakAtom: ATOM ← NIL;

AllocationBreak: PUBLIC FastBreak.FastBreakProc = {

data: FastBreakData, frame: PrincOps.FrameHandle, sv: PrincOps.SVPointer

words: CARDINAL;

type: SpyOps.StackType;

local: POINTER TO ARRAY [0..7] OF CARDINAL;

IF active = 0 THEN RETURN;

IF watching NOT IN [allocations..wordsAllocated] THEN RETURN;

words ← 1; type ← 0;

IF watching = wordsAllocated THEN local ← LOOPHOLE[@frame.local[0]];

IF data = NIL AND watching = wordsAllocated THEN words ← local[0];

IF data = LOOPHOLE[$Permanent, LONG POINTER] THEN {

type ← 1;

IF watching = wordsAllocated THEN words ← local[2];

};

IF data = LOOPHOLE[$Unsafe, LONG POINTER] THEN {

type ← 2;

IF watching = wordsAllocated THEN words ← local[4];

};

IF break AND data = LOOPHOLE[breakAtom, LONG POINTER] THEN

DebuggerSwap.CallDebugger["Allocation break"L];

Record[psbi: LOOPHOLE[Process.GetCurrent[]], type: type, frame: frame, count: words];

};

UserBreak: PUBLIC FastBreak.FastBreakProc = TRUSTED {

count: CARDINAL ← 1;

type: SpyOps.StackType ← 1;

IF spyState # on THEN RETURN[useOldBreak: FALSE];

IF watching # userDefined THEN RETURN[useOldBreak: FALSE];

IF data # NIL THEN type ← LOOPHOLE[data, LONG POINTER TO SpyOps.StackType]^;

Record[LOOPHOLE[Process.GetCurrent[]], frame, type, count];

RETURN[useOldBreak: FALSE];

};

Record: PUBLIC ENTRY PROC[psbi: PsbIndex, frame: FrameHandle ← NIL,

type: SpyOps.StackType ← 0, count: CARDINAL ← 1] = {

level: Process.Priority;

psb: LONG POINTER TO ProcessStateBlock;

IF spyState = disabled THEN RETURN;

IF active <= 0 THEN RETURN;

IF psbi = PrincOps.PsbNull THEN

IF PDA.fault[qPageFault].queue.tail = PrincOps.PsbNull

AND PDA.fault[qPageFault+4].queue.tail = PrincOps.PsbNull

THEN {LogStack[psbi, 0, NIL, count, 0]; RETURN}

ELSE {LogStack[psbi, 0, NIL, count, 1]; RETURN}; -- waiting for a page fault

psb ← @PDA[PrincOpsUtils.PsbIndexToHandle[psbi]];

level ← psb.link.priority;

IF frame = NIL THEN

frame ← IF psb.link.vector THEN PDA[psb.context.state].frame ELSE psb.context.frame;

LogStack[psbi, level, frame, count, type]

};

LogStack: INTERNAL PROC [process: PsbIndex, level: Process.Priority, frame: FrameHandle, count, type: CARDINAL] = {

Log the stack on the Trace Log --

sdLength: CARDINAL = PrincOps.SD[PrincOps.sGFTLength];

gf: GlobalFrameHandle ← NIL;

length: CARDINAL ← 0;

ValidFrame: PROC [f: ControlLink] RETURNS [FrameHandle] = {

This procedure is supposed to validate a control link. For various race conditions (presumably), we have observed address faults when the accesslink gets clobbered. Since we can't handle the address faults in here, we insist that the caller be prepared for such an eventuality. (RRA)

OPEN PrincOps;

Note: as a side-effect, this procedure sets 'gf', which is used by the other local procedures below and the main loop of IncrementBucket.

IF f.proc OR f.indirect OR f.frame = NIL OR (gf ← f.frame.accesslink) = NIL OR

(LOOPHOLE[gf, CARDINAL] MOD 4) # 0 THEN RETURN[NIL];

RETURN[f.frame]

};

IF ~SpyLog.active THEN RETURN;

stack.type ← type;

stack.count ← count;

stack.level ← level;

stack.process ← process;

frame ← ValidFrame[LOOPHOLE[frame] ! VM.AddressFault => {frame ← NIL; CONTINUE}];

THROUGH [0..maxStackDepth) UNTIL frame = NIL DO

save the current frame

this also saves the last ignored frame

IF length >= SpyOps.stackLength THEN {stack.level ← 7; length ← 0; EXIT};

stack.frame[length] ← [gf, frame.pc];

IF length > 0 AND stack.frame[length] = stack.frame[length-1]

THEN length ← length - 1; -- skip recursive frames

length ← length + 1;

frame ← ValidFrame[frame.returnlink ! VM.AddressFault => EXIT];

ENDLOOP;

SpyLog.WriteData[@stack,

SpyOps.stackHeader + length*SpyOps.Frame.SIZE,

SpyOps.Stack.CODE];

};

Initialize[];

22-Jan-82 Maxwell: Removed cross-partition code; converted to Cedar

4-Feb-82 Maxwell: Added stack active option

11-Mar-82 Maxwell: Added page fault recorder

October 14, 1982 10:07 am Maxwell: Removed Pilot Spy code

Bob Hagmann February 6, 1986 8:34:24 am PST

SetTimeouts can be invoked twice. If the index is alread at maxIndex, it tries to store past the end of the timeout array. Moved maxIndex up to 25 from 20

changes to: SetTimeouts