-- Copyright (C) 1982, 1983 by Xerox Corporation. All rights reserved.
-- SlaDriver.mesa, HGM, 30-Dec-83 15:54:15
DIRECTORY
Environment USING [Byte],
Heap USING [systemZone],
Inline USING [LowHalf],
System USING [GetClockPulses, HostNumber, MicrosecondsToPulses, nullNetworkNumber, Pulses],
Buffer USING [AccessHandle, Buffer, GetBuffer, MakePool, NSBuffer, PupBuffer, Type],
Driver USING [
NetworkObject, Network, PutOnGlobalDoneQueue,
AddDeviceToChain, GetInputBuffer, PutOnGlobalInputQueue, ReturnFreeBuffer],
DriverTypes USING [slaEncapsulationOffset, slaEncapsulationBytes],
Process USING [Detach, MsecToTicks, SetPriority, SetTimeout],
ProcessPriorities USING [priorityIOHigh],
PupTypes USING [PupHostID, PupErrorCode],
PupWireFormat USING [MesaToBcplLongNumber],
RS232CCorrespondents USING [xerox850],
RS232CEnvironment USING [CommParamObject],
RS232C USING [
ChannelHandle, ChannelSuspended, CompletionHandle, Create, DeviceStatus,
Get, GetStatus, PhysicalRecord, PhysicalRecordHandle, Put, Restart,
SetLineType, SetParameter, Suspend, TransferWait, TransferStatus, TransmitNow],
PhoneCreate USING [],
Sla USING [
dle, DriverStatistics, etx, LineInfo, longHop, maxHops, maxSlaHost, noPartner,
overheadPerPacket, RoutingTableEntry, RoutingTablePacket, SlaHost, State, stx,
syn],
SlaFormat USING [LineState, SlaStatsEntry, slaStatsReply, slaVersion];
SlaDriver: MONITOR
IMPORTS
Heap, Inline, Process, System, Buffer, Driver, PupWireFormat,
RS232C
EXPORTS Buffer, PhoneCreate
SHARES Buffer =
BEGIN
z: UNCOUNTED ZONE = Heap.systemZone;
nonAltoEtx: BOOLEAN ← FALSE;
Byte: TYPE = Environment.Byte;
-- EXPORTed TYPEs
Network: PUBLIC TYPE = Driver.Network;
info: LONG POINTER TO Sla.LineInfo;
RoutingTable: TYPE = ARRAY Sla.SlaHost OF Sla.RoutingTableEntry;
routingTable: LONG POINTER TO ARRAY Sla.SlaHost OF Sla.RoutingTableEntry ← NIL;
stats: Sla.DriverStatistics;
pool: Buffer.AccessHandle;
outstandingGets: CARDINAL = 2;
channelHandle: RS232C.ChannelHandle;
-- The microcode doesn't help as much as it should
copySize: CARDINAL = 2*1000;
Copy: TYPE = PACKED ARRAY [0..copySize) OF Byte;
sendCopy: LONG POINTER TO PACKED ARRAY [0..0) OF Byte;
recvCopy: ARRAY [0..outstandingGets) OF LONG POINTER TO PACKED ARRAY [0..0) OF Byte;
packetToSend: CONDITION;
currentOutputBuffer, headOutputBuffer, tailOutputBuffer: Buffer.Buffer;
packetsOnSendQueue: CARDINAL ← 0;
myNet: Driver.NetworkObject ← [
next: NIL,
decapsulateBuffer: Decapsulate,
encapsulateAndSendPup: SendPup,
encapsulateAndSendNS: SendNS,
sendRawBuffer: SendRawBuffer,
encapsulateAndForwardPup: ForwardPup,
encapsulateAndForwardNS: ForwardNS,
activateDriver: ActivateDriver,
deactivateDriver: DeactivateDriver,
deleteDriver: KillDriver,
changeNumberOfInputBuffers: NIL,
index:,
device: sla,
alive: TRUE,
buffers: 0,
netNumber: System.nullNetworkNumber,
pupNetNumber: 0,
pupHostNumber: 0,
pupStats: SlaStats, statsLevel0: @stats, statsLevel1: NIL];
me: Network ← @myNet;
CreateSla: PUBLIC PROCEDURE [host, net: CARDINAL] =
BEGIN
temp: LONG POINTER;
commParm: RS232CEnvironment.CommParamObject ← [
full, bitSynchronous, bps9600, directConn[]];
channelHandle ← RS232C.Create[0, @commParm, preemptNever, preemptNever];
currentOutputBuffer ← headOutputBuffer ← tailOutputBuffer ← NIL;
me.pupHostNumber ← host;
me.pupNetNumber ← net;
routingTable ← z.NEW[RoutingTable];
routingTable↑ ← ALL[[hops: Sla.longHop, line: 0]];
info ← z.NEW[Sla.LineInfo];
info↑ ← [
state: down, partner: Sla.noPartner, packetsSent: 0, packetsRecv: 0,
bytesSent: 0, bytesRecv: 0, sendErrors: 0, recvErrors: 0, syncErrors: 0,
crcErrors: 0, controlErrors: 0, garbagePackets: 0, deaths: 0, stuck: 0,
timeout: 0, overrun: 0];
stats ← [1, LOOPHOLE[info], routingTable];
pool ← Buffer.MakePool[1, outstandingGets];
temp ← z.NEW[Copy];
sendCopy ← temp;
FOR i: CARDINAL IN [0..outstandingGets) DO
temp ← z.NEW[Copy]; recvCopy[i] ← temp; ENDLOOP;
Driver.AddDeviceToChain[me];
END;
ActivateDriver: PROCEDURE =
BEGIN
RS232C.SetLineType[channelHandle, byteSynchronous];
RS232C.SetParameter[
channelHandle, [correspondent[RS232CCorrespondents.xerox850]]];
RS232C.SetParameter[channelHandle, [syncChar[Sla.syn]]];
RS232C.SetParameter[channelHandle, [dataTerminalReady[TRUE]]];
RS232C.SetParameter[channelHandle, [requestToSend[TRUE]]];
IF FALSE THEN RS232C.SetLineType[channelHandle, bitSynchronous];
Process.Detach[FORK Watcher[]];
Process.Detach[FORK Receiver[]];
Process.Detach[FORK Sender[]];
END;
DeactivateDriver, KillDriver: PROCEDURE = BEGIN ERROR; END;
Decapsulate: PROCEDURE [b: Buffer.Buffer] RETURNS [type: Buffer.Type] =
BEGIN
bytes: CARDINAL ← 2*b.driver.length;
IF bytes < DriverTypes.slaEncapsulationBytes THEN GOTO Rejected;
bytes ← bytes - DriverTypes.slaEncapsulationBytes;
SELECT b.encapsulation.slaType FROM
ns =>
BEGIN
IF bytes < b.ns.pktLength THEN GOTO Rejected;
type ← ns;
END;
pup =>
BEGIN
IF bytes < b.pup.pupLength THEN GOTO Rejected;
type ← pup;
END;
routing =>
BEGIN
ProcessRoutingPacket[b];
Driver.ReturnFreeBuffer[b];
type ← processed;
END;
ENDCASE => GOTO Rejected;
EXITS Rejected =>
BEGIN
type ← rejected;
info.garbagePackets ← info.garbagePackets + 1;
END;
END;
SendPup: ENTRY PROCEDURE [b: Buffer.PupBuffer, host: PupTypes.PupHostID] =
BEGIN
IF info.state # up AND info.state # loopedBack THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
IF packetsOnSendQueue > 15 THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
b.encapsulation ← [
sla[
slaSpare1: 0, slaSpare2: 0, slaSpare3: 0, slaHi: FALSE, slaBroadcast: FALSE,
slaTimeQueued: 0, slaSourceLine: 0, slaDestHost: 0, slaType: pup]];
b.driver.length ← (b.pup.pupLength + 1 + DriverTypes.slaEncapsulationBytes)/2;
SendBufferInternal[b];
END;
SendNS: ENTRY PROCEDURE [b: Buffer.NSBuffer, host: System.HostNumber] =
BEGIN
IF info.state # up AND info.state # loopedBack THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
IF packetsOnSendQueue > 15 THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
b.encapsulation ← [
sla[
slaSpare1: 0, slaSpare2: 0, slaSpare3: 0, slaHi: FALSE, slaBroadcast: FALSE,
slaTimeQueued: 0, slaSourceLine: 0, slaDestHost: 0, slaType: ns]];
b.driver.length ← (b.ns.pktLength + 1 + DriverTypes.slaEncapsulationBytes)/2;
SendBufferInternal[b];
END;
SendRawBuffer: ENTRY PROCEDURE [b: Buffer.Buffer] =
BEGIN
IF packetsOnSendQueue > 15 THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
SendBufferInternal[b];
END;
ForwardPup: ENTRY PROCEDURE [b: Buffer.PupBuffer, host: PupTypes.PupHostID]
RETURNS [PupTypes.PupErrorCode] =
BEGIN
IF info.state # up AND info.state # loopedBack THEN RETURN[cantGetTherePupErrorCode];
IF packetsOnSendQueue > 10 THEN RETURN[gatewayResourceLimitsPupErrorCode];
b.encapsulation ← [
sla[
slaSpare1: 0, slaSpare2: 0, slaSpare3: 0, slaHi: FALSE, slaBroadcast: FALSE,
slaTimeQueued: 0, slaSourceLine: 0, slaDestHost: 0, slaType: pup]];
b.driver.length ← (b.pup.pupLength + 1 + DriverTypes.slaEncapsulationBytes)/2;
SendBufferInternal[b];
RETURN[noErrorPupErrorCode];
END;
ForwardNS: ENTRY PROCEDURE [b: Buffer.PupBuffer, host: System.HostNumber] =
BEGIN
IF info.state # up AND info.state # loopedBack THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
IF packetsOnSendQueue > 10 THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
b.encapsulation ← [
sla[
slaSpare1: 0, slaSpare2: 0, slaSpare3: 0, slaHi: FALSE, slaBroadcast: FALSE,
slaTimeQueued: 0, slaSourceLine: 0, slaDestHost: 0, slaType: ns]];
b.driver.length ← (b.ns.pktLength + 1 + DriverTypes.slaEncapsulationBytes)/2;
SendBufferInternal[b];
END;
SendBufferInternal: INTERNAL PROCEDURE [b: Buffer.Buffer] =
BEGIN
IF b.encapsulation.slaDestHost # 0 THEN
BEGIN Driver.PutOnGlobalDoneQueue[b]; RETURN; END;
b.next ← NIL;
IF headOutputBuffer = NIL THEN headOutputBuffer ← tailOutputBuffer ← b
ELSE BEGIN tailOutputBuffer.next ← b; tailOutputBuffer ← b; END;
packetsOnSendQueue ← packetsOnSendQueue + 1;
NOTIFY packetToSend;
END;
Sender: PROCEDURE =
BEGIN
Process.SetPriority[ProcessPriorities.priorityIOHigh];
DO
StartSending[];
SendIt[];
FinishSending[];
ENDLOOP;
END;
StartSending: ENTRY PROCEDURE =
BEGIN
UNTIL headOutputBuffer # NIL DO WAIT packetToSend; ENDLOOP;
currentOutputBuffer ← headOutputBuffer;
headOutputBuffer ← currentOutputBuffer.next;
timeSendStarted ← System.GetClockPulses[]; -- Keep Watcher happy
END;
FinishSending: ENTRY PROCEDURE =
BEGIN
Driver.PutOnGlobalDoneQueue[currentOutputBuffer];
currentOutputBuffer ← NIL;
packetsOnSendQueue ← packetsOnSendQueue - 1;
END;
SendIt: PROCEDURE =
BEGIN
b: Buffer.Buffer ← currentOutputBuffer;
complHandle: RS232C.CompletionHandle;
rec: RS232C.PhysicalRecord ← [
header: [NIL, 0, 0], body:, trailer: [NIL, 0, 0]];
to: CARDINAL ← 2;
buffer: LONG POINTER TO PACKED ARRAY [0..0) OF Byte =
LOOPHOLE[@b.encapsulation + DriverTypes.slaEncapsulationOffset];
xferstatus: RS232C.TransferStatus;
IF b = NIL THEN ERROR;
-- DLE doubling via software (barf)
sendCopy[0] ← Sla.dle;
sendCopy[1] ← Sla.stx;
FOR from: CARDINAL IN [0..b.driver.length*2) DO -- even bytes
byte: Byte ← buffer[from];
IF byte = Sla.dle THEN BEGIN sendCopy[to] ← Sla.dle; to ← to + 1; END;
sendCopy[to] ← byte;
to ← to + 1;
ENDLOOP;
sendCopy[to] ← Sla.dle;
sendCopy[to + 1] ← Sla.etx;
IF nonAltoEtx THEN sendCopy[to + 1] ← Sla.etx - 200B; -- *************************
to ← to + 2;
IF to > copySize THEN ERROR;
rec.body ← [blockPointer: sendCopy, startIndex: 0, stopIndexPlusOne: to];
complHandle ← RS232C.Put[channelHandle, @rec !
RS232C.ChannelSuspended => GOTO Zapped];
timeSendStarted ← System.GetClockPulses[];
[, xferstatus] ← RS232C.TransmitNow[channelHandle, complHandle];
IF xferstatus = aborted THEN GOTO Zapped;
IF xferstatus = success THEN
BEGIN
info.packetsSent ← info.packetsSent + 1;
info.bytesSent ← info.bytesSent + 2*b.driver.length;
END
ELSE info.sendErrors ← info.sendErrors + 1;
EXITS Zapped => NULL;
END;
timeSendStarted: System.Pulses;
routingInterval: System.Pulses = System.MicrosecondsToPulses[5000000];
routingTimeout: System.Pulses = [3*routingInterval];
Watcher: ENTRY PROCEDURE =
BEGIN
routeTime: System.Pulses ← System.GetClockPulses[];
watchit: CONDITION;
Process.SetTimeout[@watchit, Process.MsecToTicks[500]];
Process.SetPriority[ProcessPriorities.priorityIOHigh];
DO
WAIT watchit;
-- should check for lost interrupts here if there is an easy way
FlushDeadLines[];
IF System.GetClockPulses[] - routeTime > routingInterval THEN
BEGIN
SendRoutingPacket[];
routeTime ← [routeTime + routingInterval];
IF System.GetClockPulses[] - routeTime > routingInterval THEN
-- don't thrash if buffers are hard to get
routeTime ← System.GetClockPulses[];
END;
ENDLOOP;
END;
-- 9600 baud is 1200 characters/sec. Allow 10% for slop and whatever to get 1000.
-- There is also the possibility for DLE doubling, so that is another factor of 2.
-- The framing is 9 bytes: SYN, SYN, SYN, DLE, STX, ..... DLE, ETX, CRC, CRC
-- Bletch, 2400 baud has come back again /HGM, 25-Jan-82 20:41:02
pulsesPerByte: System.Pulses = System.MicrosecondsToPulses[4*1000*2];
FlushDeadLines: INTERNAL PROCEDURE =
BEGIN
b: Buffer.Buffer;
stuck, timeout: BOOLEAN;
t: System.Pulses ← System.GetClockPulses[];
THROUGH [0..1) DO
b ← currentOutputBuffer;
stuck ←
(b # NIL
AND
((t - timeSendStarted) >
(Sla.overheadPerPacket + b.driver.length*2)*pulsesPerByte));
timeout ← (t - timeOfLastRT) > routingTimeout;
IF stuck THEN
BEGIN
tick: CONDITION;
Process.SetTimeout[@tick, 1];
RS232C.Suspend[channelHandle, output];
UNTIL packetsOnSendQueue = 0 DO WAIT tick; ENDLOOP;
RS232C.Restart[channelHandle, output];
END;
IF timeout OR stuck THEN
BEGIN
PurgeLineFromRT[];
IF info.state = up OR info.state = loopedBack THEN
BEGIN
info.deaths ← info.deaths + 1;
IF timeout THEN info.timeout ← info.timeout + 1;
IF stuck THEN info.stuck ← info.stuck + 1;
END;
info.state ← down;
info.partner ← Sla.noPartner;
END;
ENDLOOP;
END;
Receiver: PROCEDURE =
BEGIN
rec: RS232C.PhysicalRecord ← [
header: [NIL, 0, 0], body:, trailer: [NIL, 0, 0]];
complArray: ARRAY [0..outstandingGets) OF RS232C.CompletionHandle;
Process.SetPriority[ProcessPriorities.priorityIOHigh];
FOR i: CARDINAL IN [0..outstandingGets) DO
rec.body ← [recvCopy[i], 0, copySize];
complArray[i] ← RS232C.Get[channelHandle, @rec];
ENDLOOP;
DO
FOR i: CARDINAL IN [0..outstandingGets) DO
transferStatus: RS232C.TransferStatus;
bytes: CARDINAL;
[bytes, transferStatus] ← RS232C.TransferWait[
channelHandle, complArray[i]];
SELECT TRUE FROM
transferStatus = success AND bytes < 6 + 22 =>
BEGIN info.garbagePackets ← info.garbagePackets + 1; END;
transferStatus = success =>
BEGIN
b: Buffer.Buffer ← Driver.GetInputBuffer[];
to: CARDINAL ← 0;
IF b # NIL THEN
BEGIN
maxBytes: CARDINAL ←
2*(b.driver.length - DriverTypes.slaEncapsulationOffset);
finger: LONG POINTER TO PACKED ARRAY [0..0) OF Byte = recvCopy[i];
thumb: LONG POINTER TO PACKED ARRAY [0..0) OF Byte =
LOOPHOLE[@b.encapsulation + DriverTypes.slaEncapsulationOffset];
dleSeen: BOOLEAN ← FALSE;
FOR i: CARDINAL IN [2..bytes - 4) DO -- 2 for dle stx, 4 for dle etx crc crc
byte: Byte ← finger[i];
IF dleSeen THEN dleSeen ← FALSE
ELSE IF byte = Sla.dle THEN BEGIN dleSeen ← TRUE; LOOP; END;
IF to > maxBytes THEN EXIT; -- Ignore rest of packet
thumb[to] ← byte;
to ← to + 1;
ENDLOOP;
b.driver ← [
length: to/2,
iocb: NIL,
faceStatus: unknown[100H] ];
b.network ← me;
Driver.PutOnGlobalInputQueue[b];
END;
info.packetsRecv ← info.packetsRecv + 1;
info.bytesRecv ← info.bytesRecv + to;
END
ENDCASE =>
BEGIN
info.recvErrors ← info.recvErrors + 1;
SELECT transferStatus FROM
dataLost => info.overrun ← info.overrun + 1;
checksumError => info.crcErrors ← info.crcErrors + 1;
deviceError => info.controlErrors ← info.controlErrors + 1;
ENDCASE => NULL;
END;
IF transferStatus = deviceError THEN
BEGIN
globalStatus: RS232C.DeviceStatus ← RS232C.GetStatus[channelHandle];
IF globalStatus.dataLost THEN
BEGIN
RS232C.SetParameter[channelHandle, [latchBitClear[globalStatus]]];
END;
END;
rec.body ← [recvCopy[i], 0, copySize];
complArray[i] ← RS232C.Get[channelHandle, @rec];
ENDLOOP;
ENDLOOP; -- of UNTIL
END;
SlaStats: PUBLIC PROCEDURE [b: Buffer.PupBuffer, network: Network]
RETURNS [BOOLEAN] =
BEGIN
stateToExternalState: ARRAY Sla.State OF SlaFormat.LineState = [
down: down, loopedBack: loopedBack, halfUp: halfUp, up: up];
activeLines: CARDINAL = 1;
sizeOfRoutingTable: CARDINAL = Sla.maxSlaHost*SIZE[Sla.RoutingTableEntry];
rte: LONG POINTER TO Sla.RoutingTableEntry;
sse: LONG POINTER TO SlaFormat.SlaStatsEntry;
b.pup.pupWords[0] ← SlaFormat.slaStatsReply;
b.pup.pupWords[1] ← SlaFormat.slaVersion;
b.pup.pupWords[2] ← Sla.maxSlaHost;
rte ← LOOPHOLE[@b.pup.pupWords[3]];
FOR host: Sla.SlaHost IN Sla.SlaHost DO
rte↑ ← routingTable[host]; rte ← rte + SIZE[Sla.RoutingTableEntry]; ENDLOOP;
b.pup.pupWords[3 + sizeOfRoutingTable] ← activeLines - 1;
sse ← LOOPHOLE[@b.pup.pupWords[4 + sizeOfRoutingTable]];
sse↑ ← [
packetsSent: PupWireFormat.MesaToBcplLongNumber[info.packetsSent],
packetsRecv: PupWireFormat.MesaToBcplLongNumber[info.packetsRecv],
bytesSent: PupWireFormat.MesaToBcplLongNumber[info.bytesSent],
bytesRecv: PupWireFormat.MesaToBcplLongNumber[info.bytesRecv],
syncErrors: Inline.LowHalf[info.syncErrors],
badCrc: Inline.LowHalf[info.crcErrors],
controlError: Inline.LowHalf[info.controlErrors],
state: stateToExternalState[info.state]];
b.pup.pupLength ←
22 + 2*(4 + sizeOfRoutingTable + activeLines*SIZE[SlaFormat.SlaStatsEntry]);
RETURN[TRUE];
END;
timeOfLastRT: System.Pulses;
ProcessRoutingPacket: ENTRY PROCEDURE [b: Buffer.Buffer] =
BEGIN
p: LONG POINTER TO Sla.RoutingTablePacket = LOOPHOLE[@b.rawWords];
timeOfLastRT ← System.GetClockPulses[];
PurgeLineFromRT[];
IF p.sourceHost = me.pupHostNumber THEN
BEGIN
info.state ← loopedBack;
routingTable[me.pupHostNumber] ← [hops: 1, line: 0];
END
ELSE
BEGIN
SELECT info.state FROM
up => IF p.rt[me.pupHostNumber].hops # 1 THEN info.state ← halfUp;
halfUp => IF p.rt[me.pupHostNumber].hops = 1 THEN info.state ← up;
ENDCASE => info.state ← halfUp;
IF info.state = up THEN
FOR i: CARDINAL IN (0..MIN[p.numEntries, Sla.maxSlaHost]) DO
newHop: CARDINAL = p.rt[i].hops + 1;
rte: LONG POINTER TO Sla.RoutingTableEntry = @routingTable[i];
IF newHop <= rte.hops THEN
BEGIN
rte.hops ← IF newHop <= Sla.maxHops THEN newHop ELSE Sla.longHop;
rte.line ← 0;
END;
ENDLOOP;
END;
info.partner ← p.sourceHost;
END;
PurgeLineFromRT: PROCEDURE =
BEGIN
FOR host: Sla.SlaHost IN Sla.SlaHost DO
routingTable[host].hops ← Sla.longHop; ENDLOOP;
END;
SendRoutingPacket: INTERNAL PROCEDURE =
BEGIN
b: Buffer.Buffer;
p: LONG POINTER TO Sla.RoutingTablePacket;
UNTIL (b ← Buffer.GetBuffer[raw, pool, send, fullBuffer, FALSE]) # NIL DO
pause: CONDITION;
Process.SetTimeout[@pause, Process.MsecToTicks[100]];
WAIT pause;
ENDLOOP;
p ← LOOPHOLE[@b.rawWords];
p.sourceHost ← me.pupHostNumber;
p.numEntries ← Sla.maxSlaHost;
p.rt ← routingTable↑;
p.rt[me.pupHostNumber].hops ← 0;
IF info.state = halfUp AND info.partner IN Sla.SlaHost THEN
p.rt[info.partner].hops ← 1;
b.driver.length ← DriverTypes.slaEncapsulationBytes/2 + SIZE[Sla.RoutingTablePacket];
b.encapsulation ← [
sla[
slaSpare1:, slaSpare2:, slaSpare3:, slaHi: TRUE, slaBroadcast: TRUE,
slaTimeQueued:, slaSourceLine: 0, slaDestHost: 0, slaType: routing]];
SendBufferInternal[b];
END;
END.