-- File: EthernetDriver.mesa - last edit:
-- AOF 17-Feb-88 15:25:51
-- MI 1-Aug-86 16:03:13
-- SMA 21-May-86 15:46:20
-- Copyright (C) 1984, 1985, 1986, 1987, 1988 by Xerox Corporation. All rights reserved.
DIRECTORY
Buffer USING [
AccessHandle, Buffer, DataBytesPerRawBuffer, Dequeue,
DestroyPool, Enqueue, MakePool, QueueInitialize, QueueObject],
CommFlags USING [doDebug, doStats, driverStats],
CommPriorities USING [driver],
CommSwitches USING [noEthernet],
CommUtil USING [AllocateIocbs, FreeIocbs],
Driver USING [
AddDeviceToChain, Glitch, GetDeviceChain, GetInputBuffer, Device,
DeviceObject, ChangeNumberOfInputBuffers, PutOnGlobalDoneQueue,
PutOnGlobalInputQueue, RemoveDeviceFromChain, ReturnFreeBuffer],
Environment USING [bytesPerWord],
EthernetFace USING [
AddCleanup, controlBlockSize, DeviceHandle, GetPacketLength, GetRetries,
GetStatus, GetPacketsMissed, GlobalStatePtr, hearSelf, QueueInput,
GetNextDevice, nullDeviceHandle, QueueOutput, RemoveCleanup, Status,
TurnOn, TurnOff, globalStateSize],
EthernetDriverFriends USING [EtherStatsInfo],
HostNumbers USING [IsMulticastID],
IEEE8023 USING [
Encapsulation, ethernetBroadcastHost, minWordsPerEthernetPacket,
EncapObject, EthernetCRC, maxBytesPerEthernetPacket],
Inline USING [LongCOPY],
Stats USING [StatBump, StatIncr, StatCounterIndex],
PrincOpsMinus USING [NewSelf],
Process USING [
Abort, DisableAborts, DisableTimeout, EnableAborts, GetPriority,
MsecToTicks, Priority, SetPriority, SetTimeout],
ProcessorFace USING [SetMP],
ResidentHeap USING [MakeNode, FreeNode],
Runtime USING [GlobalFrame, SelfDestruct],
SpecialCommunication USING [],
SpecialRuntime USING [AllocateNakedCondition, DeallocateNakedCondition],
SpecialSystem USING [
ProcessorID, HostNumber, GetProcessorID, nullHostNumber],
System USING [
GetClockPulses, Pulses, MicrosecondsToPulses, switches--['>]--],
Zone USING [Status];
EthernetDriver: MONITOR
IMPORTS
Buffer, CommUtil, Driver, Stats, EthernetFace, Inline, HostNumbers,
PrincOpsMinus, Process, ProcessorFace, ResidentHeap, Runtime, SpecialRuntime,
System, SpecialSystem
EXPORTS Buffer, IEEE8023, SpecialCommunication, System =
BEGIN
--EXPORTed TYPEs
Device: PUBLIC TYPE = Driver.Device; --to Buffer
HostNumber: PUBLIC <<System>> TYPE = SpecialSystem.HostNumber;
ether: EthernetFace.DeviceHandle;
myEar: HostNumber; --address I listen for
bpw: NATURAL = Environment.bytesPerWord;
localDevice: Device; --cache this to get around compiler
me: SpecialSystem.ProcessorID; --my real (hardware) address
all: SpecialSystem.HostNumber = IEEE8023.ethernetBroadcastHost;
getGarbage: BOOLEAN ← FALSE; --when true, we deliver any packet
globalStatePtr: EthernetFace.GlobalStatePtr; --Allocate space if needed
setupEthernetDriver: PROC[etherDevice: EthernetFace.DeviceHandle];
inputState: RECORD[
mask: WORD,
process: PROCESS,
lastMissed: CARDINAL,
q: Buffer.QueueObject,
access: Buffer.AccessHandle,
timeLastRecv: LONG CARDINAL,
inWait: LONG POINTER TO CONDITION,
queueAllowed, extraBuffers: NATURAL];
outputState: RECORD[
process: PROCESS,
mask: WORD,
q: Buffer.QueueObject,
outWait: LONG POINTER TO CONDITION,
timeSendDone: LONG CARDINAL];
watcherState: RECORD[pleaseStop: BOOLEAN, process: PROCESS, timer: CONDITION];
seconds: RECORD[one, fiveHalf, forty: LONG CARDINAL];
--IOCBs
iocbState: RECORD[first, free: FreeIocb, avail: INTEGER];
FreeIocb: TYPE = LONG POINTER TO IocbObject;
IocbObject: TYPE = RECORD[
next: FreeIocb, rest: SEQUENCE COMPUTED CARDINAL OF WORD];
--THE NETWORK OBJECT FOR THIS DRIVER
myDevice: Driver.DeviceObject ←
[matrix: NIL, sendRawBuffer: SendRawBuffer,
activateDriver: ActivateDriver, deactivateDriver: DeactivateDriver,
deleteDriver: DeleteDriver, buffers:, device: ethernet,
changeNumberOfInputBuffers: MaybeChangeNumberOfInputBuffers,
receiveBufferLen: 1500, -- This is the DLL size in 'bytes'.
alive: TRUE, index:, next: NIL, lineSpeed: 10000, lineNumber: 0, stats: NIL];
DriverNotActive: ERROR = CODE;
DriverAlreadyActive: ERROR = CODE;
LinkLayerNotMod4Minus1: ERROR = CODE;
IOCBSizeIsZero: ERROR = CODE;
LostAllIocbs: ERROR = CODE;
LostSomeIocbs: ERROR = CODE;
NilIocbInBuffer: ERROR = CODE;
OverlayingIocb: ERROR = CODE;
ResidentZoneTrouble: ERROR = CODE;
BadHostID: ERROR = CODE;
PacketTooLarge: ERROR = CODE;
numberOfExtraBuffer: CARDINAL = 4;
etherStats: EthernetDriverFriends.EtherStatsInfo;
maxEthernetWords: NATURAL = (IEEE8023.maxBytesPerEthernetPacket / bpw) -
SIZE[IEEE8023.EthernetCRC];
<<
The physical overhead is the number of bytes used by the MAC layer to
encapsulate a Network Protocol Data Unit. This physical overhead includes
802.2 encapsulation.
>>
physOverhead: NATURAL = bpw *
(SIZE[IEEE8023.EncapObject] + SIZE[IEEE8023.EthernetCRC]);
<<
This driver starts the reception of physical frame offset into the space
reserved by the buffer manager for the LLC. This is so frames received
using one LLC (eg. Ethernet) can be encapsulated using another LLC (eg.
IEEE 802.2) without wiping out the FixedOverhead portion of the buffer.
The offset is based on private knowledge that this driver shouldn't
know about, the lengths of the various encapsulations. The longest know
to date is an old Ethernet packet encapsulated using the IEEE 802.2
extended type field. That is SIZE[IEEE8023.EncapObject] words long.
The shortest is Ethernet.
errorCheck: NATURAL[22..1518] = Buffer.dataLinkReserve; -- this must be true
>>
offsetToDataUnit: NATURAL =
SIZE[IEEE8023.EncapObject] - SIZE[ethernet IEEE8023.EncapObject]; --words
checking: BOOLEAN ← CommFlags.doDebug;
SanityCheck: --INTERNAL-- PROC = --INLINE--
BEGIN
IF CommFlags.doDebug THEN
BEGIN
found: INTEGER ← 0;
IF ~checking THEN RETURN;
FOR link: FreeIocb ← iocbState.free, link.next UNTIL link = NIL DO
found ← found + 1;
ENDLOOP;
FOR b: Buffer.Buffer ← inputState.q.first, b.fo.next UNTIL b = NIL DO
IF b.fo.driver.iocb # NIL THEN found ← found + 1
ELSE Driver.Glitch[NilIocbInBuffer];
ENDLOOP;
FOR b: Buffer.Buffer ← outputState.q.first, b.fo.next UNTIL b = NIL DO
IF b.fo.driver.iocb # NIL THEN found ← found + 1
ELSE Driver.Glitch[NilIocbInBuffer];
ENDLOOP;
IF found # iocbState.avail THEN Driver.Glitch[LostSomeIocbs];
END;
END; --SanityCheck
GetBufferAndIocb: INTERNAL PROC[] RETURNS[b: Buffer.Buffer] =
BEGIN
receiveLength: NATURAL = myDevice.receiveBufferLen + physOverhead;
IF CommFlags.doDebug THEN SanityCheck[];
SELECT TRUE FROM
(iocbState.free = NIL) =>
{IF CommFlags.doStats THEN Stats.StatIncr[statsIocbWait]; RETURN[NIL]};
((b ← Driver.GetInputBuffer[FALSE, receiveLength]) = NIL) => RETURN;
ENDCASE;
IF CommFlags.doDebug AND (b.fo.driver.iocb # NIL) THEN
Driver.Glitch[OverlayingIocb];
b.fo.driver.iocb ← iocbState.free;
iocbState.free ← iocbState.free.next;
b.fo.driver.length ← receiveLength;
b.fo.driver.faceStatus ← ethernet[pending];
END; --GetBufferAndIocb
GetBufferAndIocbEntry: ENTRY PROC[] RETURNS[b: Buffer.Buffer] = INLINE
{RETURN GetBufferAndIocb[]}; --GetBufferAndIocbEntry
FreeBufferAndIocb: INTERNAL PROC[
queueProc: PROC[b: Buffer.Buffer], b: Buffer.Buffer] =
BEGIN
iocb: FreeIocb ← b.fo.driver.iocb;
IF iocb # NIL THEN
BEGIN
iocb.next ← iocbState.free;
iocbState.free ← iocb;
b.fo.driver.iocb ← NIL;
END;
IF CommFlags.doDebug THEN SanityCheck[];
queueProc[b];
END; --FreeBufferAndIocb
InInterrupt: ENTRY PROC =
BEGIN
words: CARDINAL;
acceptBuffer: BOOLEAN;
this, new: Buffer.Buffer;
status: EthernetFace.Status;
DO
ENABLE ABORTED => {inputState.process ← NIL; EXIT};
IF inputState.q.length = 0 THEN
BEGIN
<<
If the queue length was previously 0, then we can wait for the first
interrupt. 'inputState.inWait' has no timeout, so the process should
only wake when a packet is available. If the buffer is still pending,
something is amiss.
>>
WHILE inputState.q.length = 0 DO WAIT inputState.inWait; ENDLOOP;
status ← EthernetFace.GetStatus[inputState.q.first.fo.driver.iocb];
IF CommFlags.doStats AND status # pending THEN
Stats.StatIncr[statEtherInterruptDuringInterrupt];
END
ELSE status ← EthernetFace.GetStatus[inputState.q.first.fo.driver.iocb];
UNTIL status # pending DO
WAIT inputState.inWait;
status ← EthernetFace.GetStatus[inputState.q.first.fo.driver.iocb];
IF CommFlags.doStats AND status = pending
THEN Stats.StatIncr[statEtherMissingStatus];
ENDLOOP;
this ← Buffer.Dequeue[@inputState.q];
words ← EthernetFace.GetPacketLength[this.fo.driver.iocb];
IF words < IEEE8023.minWordsPerEthernetPacket THEN status ← otherError;
IF words > maxEthernetWords THEN status ← packetTooLong;
IF status = ok THEN acceptBuffer ← TRUE
ELSE
BEGIN
acceptBuffer ← getGarbage; --we may be collecting garbage packets
IF CommFlags.driverStats
THEN etherStats.badRecvStatus ← etherStats.badRecvStatus + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherReceivedBadStatus];
IF CommFlags.doStats OR CommFlags.driverStats THEN
SELECT status FROM
badAlignmentButOkCrc =>
BEGIN
acceptBuffer ← TRUE; --we're going to keep this one
IF CommFlags.driverStats THEN etherStats.badAlignmentButOkCrc ←
etherStats.badAlignmentButOkCrc + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherReceivedNot16];
END;
packetTooLong =>
BEGIN
IF CommFlags.driverStats
THEN etherStats.packetTooLong ← etherStats.packetTooLong + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherReceivedTooLong];
END;
crc =>
BEGIN
IF CommFlags.driverStats THEN
etherStats.badCrc ← etherStats.badCrc + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherReceivedBadCRC];
END;
crcAndBadAlignment =>
BEGIN
IF CommFlags.driverStats THEN
etherStats.crcAndBadAlignment ← etherStats.crcAndBadAlignment+1;
IF CommFlags.doStats THEN
Stats.StatIncr[statEtherReceivedNot16BadCRC];
END;
overrun =>
BEGIN
IF CommFlags.driverStats THEN
etherStats.overrun ← etherStats.overrun + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherReceivedOverrun];
END;
ENDCASE;
END;
SELECT TRUE FROM
(acceptBuffer) =>
BEGIN
inputState.timeLastRecv ← this.fo.time ← System.GetClockPulses[];
this.fo.driver.faceStatus ← ethernet[status];
this.fo.network ← localDevice;
this.linkLayer ← [(this.linkLayer.blockPointer + offsetToDataUnit),
0, (this.fo.driver.length ← words * bpw)]; --convert length to bytes
IF CommFlags.driverStats THEN
BEGIN
etherStats.packetsRecv ← etherStats.packetsRecv + 1;
etherStats.wordsRecv ← etherStats.wordsRecv + words;
END;
IF CommFlags.doStats THEN
BEGIN
Stats.StatIncr[statEtherPacketsReceived];
Stats.StatBump[statEtherWordsReceived, words];
END;
FreeBufferAndIocb[Driver.PutOnGlobalInputQueue, this]; --good input
IF (new ← GetBufferAndIocb[]) = NIL THEN
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statEtherEmptyFreeQueue];
NOTIFY watcherState.timer; --couldn't or didn't want a new buffer
LOOP; --there's nothing left to do here
END;
END;
(Buffer.DataBytesPerRawBuffer[this] < myDevice.receiveBufferLen) =>
BEGIN
FreeBufferAndIocb[Driver.ReturnFreeBuffer, this]; --can't reuse
IF (new ← GetBufferAndIocb[]) = NIL THEN
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statEtherEmptyFreeQueue];
NOTIFY watcherState.timer; --couldn't or didn't want a new buffer
LOOP; --there's nothing left to do here
END;
END;
ENDCASE => {new ← this; new.fo.next ← NIL}; --recycle this buffer
--add new buffer to end of input chain
new.fo.driver.faceStatus ← ethernet[pending];
EthernetFace.QueueInput[
ether, (new.linkLayer.blockPointer + offsetToDataUnit),
(new.fo.driver.length / bpw) - offsetToDataUnit, new.fo.driver.iocb];
Buffer.Enqueue[@inputState.q, new];
ENDLOOP;
END; --InInterrupt
OutInterrupt: ENTRY PROC =
BEGIN
b: Buffer.Buffer;
status: EthernetFace.Status;
DO
ENABLE ABORTED => {outputState.process ← NIL; EXIT};
--UNTIL EXIT-- DO
--we compute the values each time around since the value of b can
--change if the watcher shoots down the output.
SELECT TRUE FROM
(outputState.q.length = 0) => NULL; --any output queued?
--this one's complete
((status ← EthernetFace.GetStatus[
outputState.q.first.fo.driver.iocb]) # pending) => EXIT;
--then why did we interrupt??
ENDCASE => IF CommFlags.doStats THEN
Stats.StatIncr[statEtherMissingStatus];
WAIT outputState.outWait;
ENDLOOP;
b ← Buffer.Dequeue[@outputState.q]; --take it out of queue
b.fo.driver.faceStatus ← ethernet[status]; --and record the status
outputState.timeSendDone ← System.GetClockPulses[]; --still transmiting
IF status = ok THEN
BEGIN
IF CommFlags.doStats OR CommFlags.driverStats THEN
BEGIN
tries: CARDINAL = EthernetFace.GetRetries[b.fo.driver.iocb];
IF CommFlags.driverStats THEN
BEGIN
etherStats.packetsSent ← etherStats.packetsSent + 1;
etherStats.wordsSent ← etherStats.wordsSent +
b.fo.driver.length / bpw;
etherStats.loadTable[tries] ← etherStats.loadTable[tries] + 1;
END;
IF CommFlags.doStats AND tries # 0 THEN
Stats.StatIncr[LOOPHOLE[
Stats.StatCounterIndex[statEtherSendsCollision1].ORD + tries]];
END;
END
ELSE
BEGIN
IF CommFlags.driverStats THEN
etherStats.badSendStatus ← etherStats.badSendStatus + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherSendBadStatus];
IF CommFlags.doStats OR CommFlags.driverStats THEN
SELECT status FROM
tooManyCollisions =>
BEGIN
IF CommFlags.driverStats THEN
etherStats.tooManyCollisions ← etherStats.tooManyCollisions + 1;
IF CommFlags.doStats THEN
Stats.StatIncr[statEtherSendsCollisionLoadOverflow];
END;
underrun =>
BEGIN
IF CommFlags.driverStats THEN
etherStats.underrun ← etherStats.underrun + 1;
IF CommFlags.doStats THEN Stats.StatIncr[statEtherSendOverrun];
END;
ENDCASE;
END;
--We don't resend things that screwup
FreeBufferAndIocb[Driver.PutOnGlobalDoneQueue, b];
ENDLOOP;
END; --OutInterrupt
Watcher: PROC =
BEGIN
CheckQueues: ENTRY PROC = INLINE
BEGIN
enterTime ← System.GetClockPulses[]; --record time at start
--STUCK OUTPUT
SELECT TRUE FROM
(outputState.q.length = 0) => NULL;
((enterTime - outputState.timeSendDone) > seconds.fiveHalf) =>
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statPacketsStuckInOutput];
IF CommFlags.driverStats THEN
etherStats.stuckOutput ← etherStats.stuckOutput + 1;
outputState.timeSendDone ← enterTime;
GOTO smash;
END;
ENDCASE;
--IDLE INPUT
IF ((enterTime - inputState.timeLastRecv) > seconds.forty) THEN
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statInputIdle];
IF CommFlags.driverStats THEN
etherStats.idleInput ← etherStats.idleInput + 1;
inputState.timeLastRecv ← enterTime;
GOTO smash;
END;
EXITS smash => SmashCSBs[];
END; --CheckQueues
QueueInputOrWait: ENTRY PROC = INLINE
BEGIN
ENABLE UNWIND => NULL;
SELECT TRUE FROM
(b = NIL) => NULL; --just WAIT
(CommFlags.doDebug AND (b.fo.driver.iocb # NIL)) =>
Driver.Glitch[OverlayingIocb];
((b.fo.driver.iocb ← iocbState.free) # NIL) =>
BEGIN
iocbState.free ← iocbState.free.next;
b.fo.driver.faceStatus ← ethernet[pending];
-- EthernetFace uses words for degree of 'length'
EthernetFace.QueueInput[
ether, LOOPHOLE[b.linkLayer.blockPointer + offsetToDataUnit],
(bytes / bpw) - offsetToDataUnit, b.fo.driver.iocb];
Buffer.Enqueue[@inputState.q, b];
IF CommFlags.doDebug THEN SanityCheck[];
RETURN; --and get out of here with b # NIL
END;
ENDCASE => --the ENDCASE better be rare!
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statsIocbWait];
Driver.ReturnFreeBuffer[b]; b ← NIL --give the buffer back (ARGH!!)
END;
WAIT watcherState.timer; --this is an alternate WAIT
IF CommFlags.doStats OR CommFlags.driverStats THEN
BEGIN
lost, missed: CARDINAL;
missed ← EthernetFace.GetPacketsMissed[ether];
lost ← missed - inputState.lastMissed;
IF lost # 0 THEN
BEGIN
IF CommFlags.doStats
THEN Stats.StatBump[statEtherEmptyNoBuffer, lost];
IF CommFlags.driverStats
THEN etherStats.packetsMissed ← etherStats.packetsMissed + lost;
inputState.lastMissed ← missed;
END;
END;
END; --QueueInputOrWait
bytes: NATURAL;
b: Buffer.Buffer;
enterTime: LONG CARDINAL;
DO
ENABLE ABORTED => EXIT;
--Check for lost interrupts
IF CheckBuffer[@inputState.q.first] OR
CheckBuffer[@outputState.q.first] THEN WatchCarefully[];
CheckQueues[]; --for idle input and stuck output
WHILE (inputState.q.length < inputState.queueAllowed) DO
bytes ← myDevice.receiveBufferLen + physOverhead; --compute length
--don't lock monitor and wait for a buffer
b ← Driver.GetInputBuffer[TRUE, bytes]; --use cached length
QueueInputOrWait[]; -- queue buffer or give a chance to wait
IF b = NIL THEN EXIT; --but don't futz around forever
ENDLOOP;
IF (System.GetClockPulses[] - enterTime) < seconds.one THEN
{b ← NIL; QueueInputOrWait[]}; --just using as WAIT
ENDLOOP;
END; --Watcher
CheckBuffer: ENTRY PROC[p: LONG POINTER TO Buffer.Buffer]
RETURNS [trouble: BOOLEAN] =
BEGIN
b: Buffer.Buffer ← p↑;
IF b = NIL THEN RETURN[FALSE];
RETURN[(EthernetFace.GetStatus[b.fo.driver.iocb] # pending)];
END;
WatchCarefully: PROC =
BEGIN
<<
In status # pending, an interrupt should have happened. Since the interrupt
routine is higher priority than we are, it should get processed before we
can see it. If we get here, an interrupt has probably been lost. It could
have been generated between the time we started decoding the instruction
and the time that the data is actually fetched. That is why we look several
times. Of course, if it is still not zero when we look again, it could be
a new interrupt that has just arrived.
Check for lost input interrupt.
>>
THROUGH [0..25) DO
IF ~CheckBuffer[@inputState.q.first] THEN EXIT;
REPEAT FINISHED => WatcherNotify[];
ENDLOOP;
--Check for lost output interrupt
THROUGH [0..25) DO
IF ~CheckBuffer[@outputState.q.first] THEN EXIT;
REPEAT FINISHED => WatcherNotify[];
ENDLOOP;
END;
WatcherNotify: ENTRY PROC =
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statEtherLostInterrupts];
SmashCSBs[];
END;
SendRawBuffer: ENTRY PROC[b: Buffer.Buffer] =
BEGIN
ENABLE UNWIND => NULL; --I don't see any signals, but...
e: IEEE8023.Encapsulation = LOOPHOLE[b.linkLayer.blockPointer];
SELECT TRUE FROM
(~myDevice.alive) =>
{b.fo.status ← rejected; Driver.PutOnGlobalDoneQueue[b]; RETURN};
(e.ethernetDest = SpecialSystem.nullHostNumber) =>
{b.fo.status ← invalidDestAddr; Driver.PutOnGlobalDoneQueue[b]; RETURN};
(EthernetFace.hearSelf) => NULL; --is okay
(HostNumbers.IsMulticastID[@e.ethernetDest]),
(e.ethernetDest = me) =>
BEGIN --sending to ourself, copy it over since we can't hear it
-- Order buffer for length 'b.fo.driver.length' bytes.
copy: Buffer.Buffer ← Driver.GetInputBuffer[
FALSE, Buffer.DataBytesPerRawBuffer[b]];
IF copy # NIL THEN
BEGIN
words: NATURAL = (b.fo.driver.length + bpw - 1) / bpw;
Inline.LongCOPY[
from: e, to: copy.linkLayer.blockPointer, nwords: words];
copy.linkLayer.startIndex ← 0;
copy.linkLayer.stopIndexPlusOne ← b.fo.driver.length; --copy length
copy.fo.driver.length ← b.fo.driver.length; --same length as last one
copy.fo.driver.faceStatus ← ethernet[ok]; --should be ok from here on
copy.fo.network ← localDevice; --set the driver field
copy.fo.time ← System.GetClockPulses[]; --pretty close to this time
IF CommFlags.doStats THEN
BEGIN
Stats.StatIncr[statEtherPacketsLocal];
Stats.StatBump[statEtherWordsLocal, words];
END;
Driver.PutOnGlobalInputQueue[copy]; --doesn't have iocb associated
END
ELSE IF CommFlags.doStats THEN Stats.StatIncr[statEtherEmptyFreeQueue];
END;
ENDCASE;
SendBufferInternal[b];
END; --SendRawBuffer
SendBufferInternal: INTERNAL PROC[b: Buffer.Buffer] =
BEGIN
e: IEEE8023.Encapsulation = LOOPHOLE[b.linkLayer.blockPointer];
-- EthernetFace uses words for degree of 'length'
words: CARDINAL ← MAX[
(b.fo.driver.length + bpw - 1) / bpw, IEEE8023.minWordsPerEthernetPacket];
IF CommFlags.doDebug AND (b.fo.driver.length > bpw * maxEthernetWords) THEN
Driver.Glitch[PacketTooLarge];
b.fo.driver.faceStatus ← ethernet[pending];
IF CommFlags.doDebug AND (b.fo.driver.iocb # NIL) THEN
Driver.Glitch[OverlayingIocb];
IF (b.fo.driver.iocb ← iocbState.free) = NIL THEN
BEGIN
IF CommFlags.doStats THEN Stats.StatIncr[statsIocbWait];
b.fo.status ← aborted; Driver.PutOnGlobalDoneQueue[b]; RETURN;
END;
iocbState.free ← iocbState.free.next;
EthernetFace.QueueOutput[ether, e, words, b.fo.driver.iocb];
SELECT TRUE FROM
(outputState.q.length = 0) =>
outputState.timeSendDone ← System.GetClockPulses[];
(CommFlags.doStats) =>
Stats.StatIncr[statEtherSendFromOutputQueue];
ENDCASE;
Buffer.Enqueue[@outputState.q, b];
IF CommFlags.doDebug THEN SanityCheck[];
IF CommFlags.doStats THEN Stats.StatIncr[statEtherPacketsSent];
IF CommFlags.doStats THEN Stats.StatBump[statEtherWordsSent, words];
END; --SendBufferInternal
--No MONITOR PROTECTION here.
MaybeChangeNumberOfInputBuffers: PROC[increaseBuffers: BOOLEAN] =
BEGIN
IF increaseBuffers THEN
BEGIN
IF inputState.access = NIL THEN
BEGIN
inputState.access ← Buffer.MakePool[0, inputState.extraBuffers];
--make sure we don't over commit the buffers we've allocated
IF inputState.queueAllowed < inputState.extraBuffers THEN
inputState.queueAllowed ← myDevice.buffers ←
myDevice.buffers + inputState.extraBuffers;
END;
END
ELSE
BEGIN
IF inputState.access # NIL THEN
BEGIN
Buffer.DestroyPool[inputState.access]; inputState.access ← NIL;
--don't let the queue to negative | even empty
IF inputState.queueAllowed > inputState.extraBuffers THEN
inputState.queueAllowed ← myDevice.buffers ←
inputState.queueAllowed - inputState.extraBuffers;
END;
END;
END; --MaybeChangeNumberOfInputBuffers
--COLD code, only used when turning things on+off
AdjustLengtoOfD0EthernetInputQueue: PUBLIC PROC[n: CARDINAL] =
{inputState.queueAllowed ← n};
CreateDefaultEthernetDrivers: PUBLIC <<IEEE8023>> PROC RETURNS [BOOLEAN] =
BEGIN
deviceNumber: CARDINAL ← 0;
etherDevice: EthernetFace.DeviceHandle;
etherDevice ← EthernetFace.GetNextDevice[EthernetFace.nullDeviceHandle];
IF System.switches[CommSwitches.noEthernet] = down THEN RETURN[FALSE];
IF etherDevice = EthernetFace.nullDeviceHandle THEN RETURN[FALSE];
WHILE etherDevice # EthernetFace.nullDeviceHandle DO
CreateAnEthernetDriver[etherDevice, deviceNumber];
etherDevice ← EthernetFace.GetNextDevice[etherDevice];
deviceNumber ← deviceNumber + 1;
ENDLOOP;
RETURN[TRUE];
END; --CreateDefaultEthernetDrivers
CreateAnEthernetDriver: PROC[
etherDevice: EthernetFace.DeviceHandle, deviceNumber: CARDINAL] =
BEGIN
IF deviceNumber # 0 THEN
BEGIN
him: LONG POINTER TO FRAME[EthernetDriver];
him ← --NEW EthernetDriver-- PrincOpsMinus.NewSelf[];
START him; --so he'll initialize the procedure
him.setupEthernetDriver[etherDevice];
END
ELSE SetupEthernetDriver[etherDevice];
END; --CreateAnEthernetDriver
SetupEthernetDriver: PROC[etherDevice: EthernetFace.DeviceHandle] =
BEGIN
Wait: ENTRY PROC = INLINE {WAIT condition};
condition: CONDITION;
ether ← etherDevice;
myEar ← me ← SpecialSystem.GetProcessorID[];
IF HostNumbers.IsMulticastID[@myEar] THEN
BEGIN
Process.DisableTimeout[@condition]; --no tricks here
Process.DisableAborts[@condition]; --fools are so smart
ProcessorFace.SetMP[989]; --should probably warn PSCO
--UNTIL HELL FREEZES OVER-- DO Wait[]; ENDLOOP;
END;
watcherState.pleaseStop ← TRUE;
inputState.extraBuffers ← numberOfExtraBuffer; --set default
myDevice.buffers ← inputState.queueAllowed ← 1;
Driver.AddDeviceToChain[(localDevice ← @myDevice)];
IF CommFlags.driverStats THEN
BEGIN
myDevice.stats ← @etherStats;
etherStats ← [];
END;
END; --SetupEthernetDriver
ActivateDriver: PROC =
BEGIN
EnterMonitor: ENTRY PROC = INLINE {SmashCSBs[]};
iocbs: CARDINAL = (myDevice.buffers + inputState.extraBuffers) * 2;
IF ~watcherState.pleaseStop THEN Driver.Glitch[DriverAlreadyActive];
seconds.one ← System.MicrosecondsToPulses[1D6];
seconds.fiveHalf ← System.MicrosecondsToPulses[25D5];
seconds.forty ← System.MicrosecondsToPulses[40D6];
getGarbage ← watcherState.pleaseStop ← FALSE;
EthernetFace.TurnOff[ether];
EthernetFace.AddCleanup[ether];
inputState.access ← NIL;
inputState.queueAllowed ← myDevice.buffers;
Buffer.QueueInitialize[@inputState.q];
Buffer.QueueInitialize[@outputState.q];
inputState.timeLastRecv ← outputState.timeSendDone ← System.GetClockPulses[];
myEar ← me ← SpecialSystem.GetProcessorID[];
IF HostNumbers.IsMulticastID[@myEar] THEN Driver.Glitch[BadHostID];
IF EthernetFace.globalStateSize # 0 THEN
BEGIN
status: Zone.Status;
[globalStatePtr, status] ← ResidentHeap.MakeNode[
EthernetFace.globalStateSize, a8];
IF status # okay THEN Driver.Glitch[ResidentZoneTrouble];
END;
iocbState.free ← NIL;
IF EthernetFace.controlBlockSize = 0 THEN Driver.Glitch[IOCBSizeIsZero];
IF CommFlags.doDebug THEN {iocbState.avail ← iocbs};
iocbState.first ← iocbState.free ← CommUtil.AllocateIocbs[
EthernetFace.controlBlockSize * iocbs * bpw];
THROUGH [0..iocbs - 1) DO
iocbState.first ← iocbState.first.next ←
iocbState.first + EthernetFace.controlBlockSize;
REPEAT FINISHED =>
{iocbState.first.next ← NIL; iocbState.first ← iocbState.free};
ENDLOOP;
THROUGH [0..myDevice.buffers) DO
b: Buffer.Buffer = GetBufferAndIocbEntry[];
IF b # NIL THEN Buffer.Enqueue[@inputState.q, b];
ENDLOOP;
[cv: inputState.inWait, mask: inputState.mask] ←
SpecialRuntime.AllocateNakedCondition[];
Process.DisableTimeout[inputState.inWait];
[cv: outputState.outWait, mask: outputState.mask] ←
SpecialRuntime.AllocateNakedCondition[];
Process.DisableTimeout[outputState.outWait];
EnterMonitor[];
BEGIN
priority: Process.Priority ← Process.GetPriority[];
Process.SetPriority[CommPriorities.driver];
inputState.process ← FORK InInterrupt[];
outputState.process ← FORK OutInterrupt[];
Process.SetPriority[priority];
END;
Process.EnableAborts[@watcherState.timer];
Process.SetTimeout[@watcherState.timer, Process.MsecToTicks[1000]];
watcherState.process ← FORK Watcher[];
myDevice.alive ← TRUE; --and I'm alive
END;
SetEthernetListener: PUBLIC <<SpecialCommunication>> ENTRY PROC[
physicalOrder: CARDINAL, newHostNumber: HostNumber]
RETURNS [success: BOOLEAN] =
BEGIN
him: LONG POINTER TO FRAME[EthernetDriver];
network: Device ← GetNthDeviceLikeMe[physicalOrder];
IF network = NIL THEN RETURN[FALSE];
him ← LOOPHOLE[Runtime.GlobalFrame[LOOPHOLE[network.sendRawBuffer]]];
him.EthernetListenForHost[newHostNumber];
RETURN[TRUE];
END;
EthernetListenForHost: PROC[newHostNumber: HostNumber] ←
RealEthernetListenForHost;
-- The procedure variable for getting linkage to RealEthernetListenForHost.
RealEthernetListenForHost: INTERNAL PROC [newHostNumber: HostNumber] =
{myEar ← newHostNumber; SmashCSBs[]};
SetEthernetCollectGarbageToo: PUBLIC ENTRY PROC[
physicalOrder: CARDINAL, collectGarbage: BOOLEAN] RETURNS [success: BOOLEAN] =
BEGIN
him: LONG POINTER TO FRAME[EthernetDriver];
network: Device ← GetNthDeviceLikeMe[physicalOrder];
IF network = NIL THEN RETURN[FALSE];
him ← LOOPHOLE[Runtime.GlobalFrame[LOOPHOLE[network.sendRawBuffer]]];
him.SetCollectGarbageToo[collectGarbage];
RETURN[TRUE];
END;
SetCollectGarbageToo: PROC[collectGarbage: BOOLEAN] ←
RealSetCollectGarbageToo;
-- The procedure variable for getting linkage to RealSetCollectGarbageToo.
RealSetCollectGarbageToo: PROC[collectGarbage: BOOLEAN] =
BEGIN getGarbage ← collectGarbage; END;
GetNthDeviceLikeMe: PROC[physicalOrder: CARDINAL]
RETURNS [net: Device] =
BEGIN
i: CARDINAL ← 0;
net ← Driver.GetDeviceChain[];
WHILE net # NIL DO
IF net.device = myDevice.device THEN
IF (i ← i + 1) = physicalOrder THEN RETURN;
net ← net.next;
ENDLOOP;
END;
SmashCSBs: INTERNAL PROC =
BEGIN
b: Buffer.Buffer;
EthernetFace.TurnOff[ether]; --shut that down
IF (outputState.q.length # 0) THEN
BEGIN
UNTIL (b ← Buffer.Dequeue[@outputState.q]) = NIL DO
b.fo.status ← aborted;
Stats.StatIncr[statEtherReceivedKlobberedByReset];
FreeBufferAndIocb[Driver.PutOnGlobalDoneQueue, b];
ENDLOOP;
END;
EthernetFace.TurnOn[
ether, LOOPHOLE[myEar, SpecialSystem.ProcessorID], inputState.mask,
outputState.mask, globalStatePtr];
IF CommFlags.doStats THEN Stats.StatIncr[statInterfaceReset];
inputState.lastMissed ← EthernetFace.GetPacketsMissed[ether];
FOR b ← inputState.q.first, b.fo.next UNTIL b = NIL DO
-- EthernetFace uses words for degree of 'length'
EthernetFace.QueueInput[
ether, LOOPHOLE[b.linkLayer.blockPointer + offsetToDataUnit],
(b.fo.driver.length / bpw) - offsetToDataUnit, b.fo.driver.iocb];
ENDLOOP;
IF CommFlags.doDebug THEN SanityCheck[];
END; --SmashCSBs
DeleteDriver: PROC =
BEGIN
IF watcherState.pleaseStop THEN Driver.Glitch[DriverNotActive];
Driver.RemoveDeviceFromChain[localDevice]; --get's us out of chain
IF ether # EthernetFace.GetNextDevice[EthernetFace.nullDeviceHandle]
THEN Runtime.SelfDestruct[];
END; --DeleteDriver
DeactivateDriver: PROC =
BEGIN
process: PROCESS;
b: Buffer.Buffer;
IF watcherState.pleaseStop THEN Driver.Glitch[DriverNotActive];
watcherState.pleaseStop ← TRUE; --for others to check
myDevice.alive ← FALSE; --I'm dying - soon
IF (process ← inputState.process) = NIL THEN RETURN; --already deactive
UNTIL inputState.process = NIL DO
Process.EnableAborts[inputState.inWait]; Process.Abort[process];
REPEAT FINISHED => JOIN process;
ENDLOOP;
process ← outputState.process;
UNTIL outputState.process = NIL DO
Process.EnableAborts[outputState.outWait]; Process.Abort[process];
REPEAT FINISHED => JOIN process;
ENDLOOP;
Process.Abort[watcherState.process]; JOIN watcherState.process;
EthernetFace.TurnOff[ether];
SpecialRuntime.DeallocateNakedCondition[inputState.inWait];
SpecialRuntime.DeallocateNakedCondition[outputState.outWait];
inputState.inWait ← outputState.outWait ← NIL;
Driver.ChangeNumberOfInputBuffers[FALSE]; --call thur Boss to set flags
EthernetFace.RemoveCleanup[ether];
UNTIL (b ← Buffer.Dequeue[@inputState.q]) = NIL DO
b.fo.status ← aborted; --didn't make it
b.fo.driver.iocb ← NIL; --don't worry, iocbs will all be freed later
Driver.ReturnFreeBuffer[b]; --no interesting requeue on input
ENDLOOP;
UNTIL (b ← Buffer.Dequeue[@outputState.q]) = NIL DO
b.fo.status ← aborted; --didn't make it
b.fo.driver.iocb ← NIL; --don't worry, iocbs will all be freed later
Driver.PutOnGlobalDoneQueue[b]; --go thru requeue procedure
ENDLOOP;
CommUtil.FreeIocbs[iocbState.first];
iocbState.free ← iocbState.first ← NIL;
IF CommFlags.doDebug THEN iocbState.avail ← 0;
IF EthernetFace.globalStateSize # 0 THEN
BEGIN
status: Zone.Status;
status ← ResidentHeap.FreeNode[globalStatePtr];
IF status # okay THEN Driver.Glitch[ResidentZoneTrouble];
END;
END; --DeactivateDriver
--initialization
setupEthernetDriver ← SetupEthernetDriver; --for multi instances
END. --EthernetDriver
time - by - action
17-May-84 10:09:09 AOF Post Klamath.
5-Mar-85 19:50:07 AOF Treating broadcast as a subset of multicast.
5-Apr-85 10:55:50 AOF Use PilotSwitches.noEthernet instead of '>.
2-Aug-85 15:28:04 AOF Initialize and allocate 'globalStatePtr'
12-May-86 16:25:15 SMA New encapsulation scheme.
17-Jun-86 18:39:50 AOF Driver.GetInputBuffer takes a length.
23-Jun-86 8:57:31 AOF Readd code for changing input queue length.
1-Aug-86 16:02:41 MI Changed degree of driver.length from word to byte.
4-Aug-86 18:04:21 AOF Change number of buffers to add from 2 => 4.
18-Aug-86 20:06:36 AOF Lengths for copies of buffers come from device object.
20-Aug-86 11:12:21 AOF Fix copy for can't here self broadcasts.
14-Nov-86 13:31:47 AOF Don't start driver with a multicast host ID.
18-Nov-86 16:05:34 AOF PilotSwitches.noEthernet => CommSwitches.noEthernet
7-Jan-87 17:05:26 AOF Tweeks for MDS relief
19-Jan-87 15:21:41 AOF Use bytes for allocating IOCBs
6-Feb-87 9:28:08 AOF Adding physical overhead to buffer size
24-Mar-87 14:52:42 AOF set .fo.time in buffer copy in SendRawBuffer.
9-Apr-87 17:24:39 AOF Put code in to deal with odd length packets again.
14-Apr-87 11:09:15 AOF Allowing for encapsulation expansion on recieve buffers.
30-Jun-87 12:14:37 AOF Suppression of runts and too long in input
18-Jul-87 10:36:38 AOF Moving from EtherMAC to IEEE8023
24-Jul-87 16:46:25 AOF Glitch on transmitting too large packets
20-Aug-87 9:12:47 AOF Use interface definition of DLL size
31-Aug-87 9:37:45 AOF Redefinition of physical overhead
9-Sep-87 15:53:39 AOF User Boss's version of ChangeNumberOfInputBuffers
15-Oct-87 10:45:35 AOF Delete driver calling RemoveDeviceFromChain
23-Oct-87 10:48:21 AOF AR#12162 (EthernetDriver may recycle short buffer)
5-Nov-87 10:06:46 AOF AR#12162 More (changing buffer length ~monitored)
25-Jan-88 13:38:36 AOF Adjusting input length by start of frame adjustment
28-Jan-88 9:47:56 AOF AR#12727 - SmashCSBs wrong buffer length
17-Feb-88 15:24:59 AOF Fix for compiler bug NEWing self