DiskImpl.mesa
Copyright © 1985 by Xerox Corporation. All rights reserved.
Andrew Birrell October 28, 1983 10:11 am
Levin, August 8, 1983 3:30 pm
Bob Hagmann, May 10, 1984 8:47:57 am PDT
Russ Atkinson (RRA) January 30, 1985 10:47:05 pm PST
DIRECTORY
Basics USING [ LongDivMod ],
Disk USING [PageCount, PageNumber, Request, Status],
DiskFace USING [ControllerHandle, DeterminationMode, DetermineDiskShape, DeviceHandle, DiskAddress, DontCare, GetControllerAttributes, GetDeviceAttributes, GetDeviceType, GetNextController, GetNextDevice, InitializeCleanup, InitializeController, Initiate, Label, nullControllerHandle, nullDeviceHandle, Operation, OperationPtr, operationSize, Poll, Status, Type],
PrincOpsUtils USING[ AllocateNakedCondition ],
Process USING[ Detach, SecondsToTicks, SetPriority, SetTimeout, priorityFaultHandlers ],
ProcessorFace USING[ GetClockPulses ],
VM USING[ lowCore ];
DiskImpl: MONITOR
IMPORTS Basics, DiskFace, PrincOpsUtils, Process, ProcessorFace, VM
EXPORTS Disk, DiskFace = BEGIN
Channel: TYPE = LONG POINTER TO ChannelObject;
ChannelObject: PUBLIC TYPE = MONITORED RECORD[
drive: DiskFace.DeviceHandle,
ordinal: CARDINAL,
-- above fields are immutable; remainder are protected by monitor lock --
cylinders, movingHeads, fixedHeads, sectorsPerTrack: CARDINAL ← 0,
freeOps: LONG POINTER TO Operation,
freed: CONDITION,
taken: CONDITION,
waiters: INT,
rest: Channel];
OperationPtr: TYPE = LONG POINTER TO Operation;
Operation: TYPE = MACHINE DEPENDENT RECORD[
rest(0): OperationPtr,
wait(2): CONDITION,
status(4): DiskFace.Status,
label(5): LONG POINTER TO DiskFace.Label,
fill(7): ARRAY [7..opFieldPosition) OF WORD,
faceOp(opFieldPosition): DiskFace.Operation,
extra(opFieldPosition+SIZE[DiskFace.Operation]): SEQUENCE COMPUTED CARDINAL OF WORD
];
opFieldPosition: CARDINAL = 16; -- N.B. This must be a multiple of 16 to align DiskFace.Operation
channelList: Channel ← NIL;
NextChannel: PUBLIC SAFE PROC[prev: Channel, wait: BOOL] RETURNS[next: Channel] =
TRUSTED BEGIN
DO next ← EntryNext[prev];
IF next # NIL OR NOT wait THEN EXIT;
[] ← AwaitChange[AwaitChange[0]];
ENDLOOP;
END;
change: CONDITION;
AwaitChange: ENTRY PROC[old: INT] RETURNS[new: INT] = TRUSTED
{ ENABLE UNWIND => NULL; DO WAIT change ENDLOOP--TEMP!!-- };
lastDrive: DiskFace.DeviceHandle ← DiskFace.nullDeviceHandle;
EntryNext: ENTRY PROC[prev: Channel] RETURNS[next: Channel] = TRUSTED
BEGIN
ENABLE UNWIND => NULL;
next ← IF prev = NIL THEN channelList ELSE prev.rest;
-- check whether next drive has changed state --
WHILE next # NIL
AND next.changeCount # DiskChannel.GetDriveAttributes[next.oldDrive].changeCount
DO Assign[prev, next.rest]; next ← next.rest; ENDLOOP;
IF next = NIL
THEN BEGIN
-- check whether there is a new drive --
new: DiskFace.DeviceHandle = DiskFace.GetNextDevice[lastDrive];
IF new # DiskFace.nullDeviceHandle
THEN { Assign[prev, NewDrive[new]]; lastDrive ← new };
next ← IF prev = NIL THEN channelList ELSE prev.rest;
END;
END;
Assign: INTERNAL PROC[tail: Channel, new: Channel] =
TRUSTED{ IF tail = NIL THEN channelList ← new ELSE tail.rest ← new };
lastOrdinal: CARDINAL ← 0;
opsPerDrive: INT ← 2;
NewDrive: INTERNAL PROC[new: DiskFace.DeviceHandle] RETURNS[channel: Channel] = TRUSTED
BEGIN
channel ← VM.lowCore.NEW[ChannelObject ← [
drive: new,
ordinal: lastOrdinal,
freeOps: NIL,
waiters: 0,
rest: NIL] ];
lastOrdinal ← lastOrdinal+1;
FOR i: INT IN [0..opsPerDrive)
DO
new: OperationPtr =
VM.lowCore.NEW[Operation[DiskFace.operationSize-SIZE[DiskFace.Operation]]];
new.label ← VM.lowCore.NEW[DiskFace.Label];
new.rest ← channel.freeOps;
channel.freeOps ← new;
ENDLOOP;
END;
InspectDiskShape: PUBLIC SAFE PROC[channel: Channel, mode: DiskFace.DeterminationMode]
RETURNS[nowKnown: BOOL] =
TRUSTED BEGIN
myOp: OperationPtr = AllocOp[channel];
nowKnown ← DiskFace.DetermineDiskShape[channel.drive, @myOp.faceOp, mode !
UNWIND => FreeOp[channel, myOp];];
FreeOp[channel, myOp];
IF nowKnown
THEN BEGIN
cylinders, movingHeads, fixedHeads, sectorsPerTrack: CARDINAL;
[cylinders, movingHeads, fixedHeads, sectorsPerTrack] ←
DiskFace.GetDeviceAttributes[channel.drive];
NoteShapeKnown[channel, cylinders, movingHeads, fixedHeads, sectorsPerTrack];
END;
END;
NoteShapeKnown: ENTRY PROC[channel: Channel, cylinders, movingHeads, fixedHeads, sectorsPerTrack: CARDINAL] =
BEGIN
ENABLE UNWIND => NULL;
channel.cylinders ← cylinders;
channel.movingHeads ← movingHeads;
channel.fixedHeads ← fixedHeads;
channel.sectorsPerTrack ← sectorsPerTrack;
END;
SameDrive: PUBLIC SAFE PROC[a,b: Channel] RETURNS[BOOL] =
TRUSTED { RETURN[ a.ordinal = b.ordinal ] };
Valid: PUBLIC SAFE PROC[channel: Channel] RETURNS[BOOL] =
TRUSTED { RETURN[TRUE] };
DriveAttributes: PUBLIC ENTRY SAFE PROC[channel: Channel] RETURNS[ type: DiskFace.Type, ordinal: INT, ready: BOOL, nPages: Disk.PageCount] = TRUSTED
BEGIN
ENABLE UNWIND => NULL;
type ← DiskFace.GetDeviceType[channel.drive];
ordinal ← channel.ordinal;
nPages ← (LONG[channel.cylinders] * channel.movingHeads) * channel.sectorsPerTrack;
END;
-- Performing operations! --
GetAddress: ENTRY PROC[channel: Channel, page: INT] RETURNS[addr: DiskFace.DiskAddress] =
BEGIN
ENABLE UNWIND => NULL;
cylinder: CARDINAL;
temp: CARDINAL;
[quotient: cylinder, remainder: temp] ← Basics.LongDivMod[
num: page, den: channel.sectorsPerTrack * channel.movingHeads];
RETURN[ [cylinder: cylinder,
sector: temp MOD channel.sectorsPerTrack, head: temp/channel.sectorsPerTrack ] ]
END;
AllocOp: ENTRY PROC[channel: Channel] RETURNS[op: OperationPtr] =
BEGIN
ENABLE UNWIND => NULL;
IF channel.freeOps = NIL
THEN BEGIN
channel.waiters ← channel.waiters+1;
WHILE channel.freeOps = NIL
DO WAIT channel.freed[ ! UNWIND => channel.waiters ← channel.waiters-1 ] ENDLOOP;
channel.waiters ← channel.waiters-1;
END;
op ← channel.freeOps; channel.freeOps ← op.rest; op.rest ← NIL;
BROADCAST channel.taken;
END;
FreeOp: ENTRY PROC[channel: Channel, op: OperationPtr] =
BEGIN
ENABLE UNWIND => NULL;
op.rest ← channel.freeOps; channel.freeOps ← op;
IF channel.waiters > 0
THEN BEGIN -- let any waiter have the processor, to enqueue the next request
NOTIFY channel.freed;
IF channel.waiters ~= 0 THEN WAIT channel.taken;
END;
END;
largestRequestRun: INT = MIN[LAST[CARDINAL], 1000];
The largest number of pages in a single request handed to the DiskFace. DiskFace.Operation limits it to a CARDINAL, and we restrict it further to avoid hogging of the device by a single client.
DoIO: PUBLIC UNSAFE PROC[channel: Channel, label: LONG POINTER TO DiskFace.Label, request: LONG POINTER TO Disk.Request] RETURNS[ status: Disk.Status, countDone: Disk.PageCount] = TRUSTED
BEGIN
myOp: OperationPtr = AllocOp[channel];
countDone ← 0;
status ← [unchanged[goodCompletion]]; -- in case request.count is already zero
Beware: if you ask DiskFace to transfer 0 pages, it may transfer 64K pages instead (so don't)!
UNTIL request.count = 0
DO BEGIN -- Loop to break up large transfers.
ENABLE UNWIND => FreeOp[channel, myOp];
reqPages: INT = MIN[request.count, largestRequestRun];
doneThisTime: INT;
myOp.label^ ← label^;
myOp.faceOp ← [
clientHeader: GetAddress[channel, request.diskPage],
labelPtr: myOp.label,
dataPtr: request.data,
incrementDataPtr: request.incrementDataPtr,
unused: NULL,
command: request.command,
tries: request.tries,
pageCount: reqPages,
deviceStatus: NULL,
diskHeader: NULL,
device: channel.drive
];
myOp.status ← inProgress;
DoOperation[myOp];
doneThisTime ← reqPages - myOp.faceOp.pageCount;
countDone ← countDone + doneThisTime;
status ← [unchanged[myOp.status]];
request.diskPage ← [request.diskPage + doneThisTime];
label^ ← myOp.label^;
request.data ← myOp.faceOp.dataPtr;
request.count ← request.count - doneThisTime;
IF myOp.status # goodCompletion THEN EXIT;
END;
ENDLOOP;
FreeOp[channel, myOp];
END;
currentOperations: CARDINAL ← 0;
Pulses: TYPE = LONG CARDINAL;
becameActive: Pulses; -- pulse reading when we changed from inactive to active
activeTotal: Pulses ← 0; -- total number of pulses while we have been active
totalReads, totalWrites, totalReadPages, totalWritePages: INT ← 0;
GetStatistics: PUBLIC ENTRY SAFE PROC RETURNS[
active, total: Pulses, reads, writes, readPages, writePages: INT ] = CHECKED
BEGIN
ENABLE UNWIND => NULL;
total ← ProcessorFace.GetClockPulses[];
active ← activeTotal + (IF currentOperations#0 THEN (total - becameActive) ELSE 0);
reads ← totalReads;
writes ← totalWrites;
readPages ← totalReadPages;
writePages ← totalWritePages;
END;
DoOperation: ENTRY PROC[myOp: OperationPtr] =
BEGIN
ENABLE UNWIND => NULL;
IF myOp.faceOp.command.data = write OR myOp.faceOp.command.label = write
THEN {totalWrites ← totalWrites+1; totalWritePages ← totalWritePages+myOp.faceOp.pageCount }
ELSE {totalReads ← totalReads+1; totalReadPages ← totalReadPages+myOp.faceOp.pageCount };
DiskFace.Initiate[@myOp.faceOp];
IF currentOperations = 0 THEN becameActive ← ProcessorFace.GetClockPulses[];
currentOperations ← currentOperations+1;
WHILE myOp.status = inProgress DO WAIT myOp.wait ENDLOOP;
END;
DiskInterrupt: ENTRY PROC[controller: DiskFace.ControllerHandle] =
BEGIN
cv: LONG POINTER TO CONDITION;
mask: WORD;
size: CARDINAL = DiskFace.GetControllerAttributes[controller];
GlobalState: TYPE = RECORD[SEQUENCE COMPUTED CARDINAL OF WORD];
globalState: LONG POINTER = VM.lowCore.NEW[GlobalState[size]];
[cv, mask] ← PrincOpsUtils.AllocateNakedCondition[];
-- Enable a timeout because disk world-swap can give our interrupt to the debugger!
Process.SetTimeout[cv, Process.SecondsToTicks[1]];
DiskFace.InitializeController[controller, globalState, mask];
DiskFace.InitializeCleanup[controller];
Process.SetPriority[Process.priorityFaultHandlers];
DO -- forever, once per naked wakeup
status: DiskFace.Status;
faceOp: DiskFace.OperationPtr;
retriedCount: CARDINAL;
myOp: OperationPtr;
WAIT cv; -- wakeup after one or more requests have completed
DO -- take all completed requests from controller
[status, faceOp, retriedCount] ← DiskFace.Poll[controller];
IF status = inProgress OR faceOp = NIL THEN EXIT;
myOp ← LOOPHOLE[faceOp-opFieldPosition];
myOp.status ← status;
currentOperations ← currentOperations-1;
IF currentOperations = 0
THEN activeTotal ← activeTotal + (ProcessorFace.GetClockPulses[] - becameActive);
NOTIFY myOp.wait;
ENDLOOP;
ENDLOOP;
END;
InitializeControllers: ENTRY PROC =
BEGIN
FOR this: DiskFace.ControllerHandle ← DiskFace.GetNextController[DiskFace.nullControllerHandle],
DiskFace.GetNextController[this]
UNTIL this = DiskFace.nullControllerHandle
DO Process.Detach[FORK DiskInterrupt[this]] ENDLOOP;
END;
--DiskFace.--DontCare: PUBLIC TYPE = DiskFace.DiskAddress;
GetBootChainLink: PUBLIC SAFE PROC[channel: Channel, diskPage: Disk.PageNumber] RETURNS [DiskFace.DontCare] = TRUSTED
{ RETURN[ GetAddress[channel, diskPage] ] };
GetPageNumber: PUBLIC ENTRY SAFE PROC[channel: Channel, link: DontCare] RETURNS[ Disk.PageNumber] = TRUSTED
{ RETURN[ [LONG[link.cylinder * channel.movingHeads + link.head] * channel.sectorsPerTrack
+ link.sector] ] };
GetDeviceFromChannel: PUBLIC ENTRY SAFE PROC[channel: Channel] RETURNS [DiskFace.DeviceHandle] = TRUSTED { RETURN [channel.drive];};
InitializeControllers[];
END.