DIRECTORY
BufferDefs,
CommFlags USING [doDebug, doStats],
CommUtilDefs USING [GetEthernetHostNumber],
DriverTypes USING [Encapsulation, ethernetBroadcastHost],
DriverDefs USING [Glitch, GetDeviceChain, GetInputBuffer, Network, NetworkObject, AddDeviceToChain, PutOnGlobalDoneQueue, PutOnGlobalInputQueue],
EthernetDriverStats,
EthernetFace,
GermSwap USING [switches],
PupTypes USING [allHosts, PupErrorCode, PupHostID],
StatsDefs USING [StatBump, StatIncr, StatCounterIndex],
LoadState USING [SelfDestruct],
PrincOpsUtils USING [AllocateNakedCondition, BITAND, DeallocateNakedCondition, GlobalFrame, HighHalf, LongCopy, LowHalf, LongZero],
Process USING [Detach, DisableTimeout, MsecToTicks, SecondsToTicks, SetPriority, SetTimeout, Ticks, Yield],
ProcessorFace USING [GetGreenwichMeanTime, GetClockPulses, GreenwichMeanTime, microsecondsPerHundredPulses],
SpecialCommunication USING [],
NSAddress
USING [broadcastHostNumber, ProcessorID, HostNumber, GetProcessorID, nullHostNumber, nullNetworkNumber];
EthernetDriver:
MONITOR
IMPORTS BufferDefs, CommUtilDefs, DriverDefs, StatsDefs, EthernetFace, GermSwap, LoadState, PrincOpsUtils, Process, ProcessorFace, NSAddress
EXPORTS BufferDefs, DriverDefs, EthernetDriverStats, SpecialCommunication
SHARES BufferDefs, NSAddress =
{ OPEN StatsDefs, BufferDefs, EthernetFace, NSAddress;
EXPORTed TYPEs
Network: PUBLIC TYPE = DriverDefs.Network;
ether: DeviceHandle;
me: NSAddress.ProcessorID;
myEar: NSAddress.HostNumber;
what address am I listening for (verses me, my real address)
getGarbage: BOOL ← FALSE; -- when true, we deliver any packet
globalStatePtr: GlobalStatePtr; -- Allocate space if needed
inProcess, outProcess: PROCESS;
inWait, outWait: LONG POINTER TO CONDITION ← NIL;
firstOutputBuffer, lastOutputBuffer: Buffer;
firstInputBuffer, lastInputBuffer: Buffer;
inInterruptMask, outInterruptMask: WORD;
watcherProcess: PROCESS;
pleaseStop: BOOL;
timer: CONDITION;
timeLastRecv, timeSendStarted: Pulses;
oneSecondOfPulses: Pulses;
inputQueueLength: CARDINAL ← 1;
inputBuffersInQueue: CARDINAL;
myNetwork: DriverDefs.NetworkObject ← [
decapsulateBuffer: DecapsulateBuffer, encapsulatePup: EncapsulatePup,
encapsulateOis: EncapsulateOis, sendBuffer: SendBuffer,
forwardBuffer: ForwardBuffer, activateDriver: ActivateDriver,
deactivateDriver: DeactivateDriver, deleteDriver: DeleteDriver,
interrupt: InInterrupt,
changeNumberOfInputBuffers: MaybeChangeNumberOfInputBuffers, alive: TRUE,
speed: 10000, -- in kiloBits/sec
buffers:, spare:, device: ethernet, index:, netNumber: nullNetworkNumber,
hostNumber: 0, next: NIL, pupStats: NIL, stats: NIL];
FunnyRetransmissionMask: PUBLIC ERROR = CODE;
MachineIDTooBigForEthernet: PUBLIC ERROR = CODE;
DriverNotActive: PUBLIC ERROR = CODE;
DriverAlreadyActive: PUBLIC ERROR = CODE;
EthernetNetNumberScrambled: PUBLIC ERROR = CODE;
CantMakImageWhileEtherentDriverIsActive: PUBLIC ERROR = CODE;
OnlyTwoDriversArePossible: PUBLIC ERROR = CODE;
BufferMustBeAlmostQuadWordAligned: PUBLIC ERROR = CODE;
IOCBMustBeQuadWordAligned: PUBLIC ERROR = CODE;
IOCBMustBeInFirstMDS: PUBLIC ERROR = CODE;
etherStats: EthernetDriverStats.EtherStats ← NIL;
Alignment:
PROC [lp:
LONG
POINTER]
RETURNS [
CARDINAL] =
INLINE {
RETURN [PrincOpsUtils.BITAND[LOOPHOLE[PrincOpsUtils.LowHalf[lp]], 3]];
};
Hot Procedures
Pulses: TYPE = LONG CARDINAL;
MicrosecondsToPulses:
PROC[m:
LONG
CARDINAL]
RETURNS[ Pulses] =
{
RETURN[
MIN[LAST[LONG CARDINAL]/100,m/ProcessorFace.microsecondsPerHundredPulses]*100 ] };
InInterrupt:
ENTRY
PROC = {
acceptBuffer: BOOL;
this, new: Buffer;
status: Status;
lastMissed, missed: CARDINAL ← GetPacketsMissed[ether];
Process.SetPriority[3];
DO
UNTIL pleaseStop OR (this ← firstInputBuffer) # NIL DO WAIT inWait; ENDLOOP;
IF pleaseStop THEN EXIT;
status ← GetStatus[this.iocbChain];
IF CommFlags.doStats
AND status # pending
THEN
StatIncr[statEtherInterruptDuringInterrupt];
UNTIL pleaseStop
OR status # pending
DO
WAIT inWait;
status ← GetStatus[this.iocbChain];
IF CommFlags.doStats AND status = pending THEN StatIncr[statEtherMissingStatus];
ENDLOOP;
IF CommFlags.doStats
AND (missed ← GetPacketsMissed[ether]) # lastMissed
THEN {
StatBump[statEtherEmptyNoBuffer, missed - lastMissed];
lastMissed ← missed;
};
IF pleaseStop THEN EXIT;
firstInputBuffer ← firstInputBuffer.next;
SELECT status
FROM
ok => acceptBuffer ← TRUE;
ENDCASE => {
etherStats.badRecvStatus ← etherStats.badRecvStatus + 1;
IF status = overrun THEN etherStats.overruns ← etherStats.overruns + 1;
acceptBuffer ← getGarbage; -- we may be collecting garbage packets
IF CommFlags.doStats
THEN
SELECT status
FROM
packetTooLong => StatIncr[statEtherReceivedTooLong];
badAlignmentButOkCrc => StatIncr[statEtherReceivedNot16];
crc => StatIncr[statEtherReceivedBadCRC];
crcAndBadAlignment => StatIncr[statEtherReceivedNot16BadCRC];
overrun => StatIncr[statEtherReceivedOverrun];
ENDCASE => StatIncr[statEtherReceivedBadStatus];
};
IF acceptBuffer
THEN {
this.time ← timeLastRecv ← ProcessorFace.GetClockPulses[];
this.length ← GetPacketLength[this.iocbChain];
this.network ← LONG[@myNetwork]; -- LONG because of Mokelumne compiler bug
etherStats.packetsRecv ← etherStats.packetsRecv + 1;
etherStats.wordsRecv ← etherStats.wordsRecv + this.length;
IF CommFlags.doStats
THEN {
StatIncr[statEtherPacketsReceived];
StatBump[statEtherWordsReceived, this.length];
};
DriverDefs.PutOnGlobalInputQueue[this];
IF (new ← DriverDefs.GetInputBuffer[]) =
NIL
THEN {
Rats, couldn't get a new buffer
inputBuffersInQueue ← inputBuffersInQueue - 1;
NOTIFY timer;
etherStats.inputOff ← etherStats.inputOff + 1;
IF CommFlags.doStats THEN StatIncr[statEtherEmptyFreeQueue];
}; -- cant get new buffer clause
} -- acceptBuffer clause
ELSE {
new ← this; -- Some kind of error, recycle this buffer
}; -- reject buffer clause
add new buffer to end of input chain
IF new #
NIL
THEN {
new.device ← ethernet;
QueueInput[ether, @new.encapsulation, new.length, new.iocbChain];
new.next ← NIL;
IF firstInputBuffer = NIL THEN firstInputBuffer ← new
ELSE lastInputBuffer.next ← new;
lastInputBuffer ← new;
};
ENDLOOP;
};
OutInterrupt:
ENTRY
PROC = {
b: Buffer;
status: Status;
Process.SetPriority[3];
UNTIL pleaseStop
DO
DO
forever until something interesting happens
IF pleaseStop THEN EXIT;
we compute the values each time around since the value of b can change if
the watcher shoots down the output.
IF (b ← firstOutputBuffer) #
NIL
AND (status ← GetStatus[b.iocbChain]) #
pending THEN EXIT;
WAIT outWait;
ENDLOOP;
IF pleaseStop THEN EXIT; -- so that we do not do something below
SELECT status
FROM
ok => {
tries: CARDINAL ← GetRetries[b.iocbChain];
etherStats.packetsSent ← etherStats.packetsSent + 1;
etherStats.wordsSent ← etherStats.wordsSent + b.length;
IF tries > EthernetDriverStats.MaxTries THEN tries ← EthernetDriverStats.MaxTries;
etherStats.loadTable[tries] ← etherStats.loadTable[tries] + 1;
IF CommFlags.doStats
THEN {
statEtherSendsCollision1: StatsDefs.StatCounterIndex =
statEtherSendsCollision1;
first: CARDINAL = LOOPHOLE[statEtherSendsCollision1];
IF tries # 0 THEN StatIncr[LOOPHOLE[first + tries]];
};
};
ENDCASE => {
SELECT status
FROM
tooManyCollisions => {
etherStats.loadTable[16] ← etherStats.loadTable[16] + 1;
IF CommFlags.doStats THEN StatIncr[statEtherSendsCollisionLoadOverflow];
};
underrun => {
etherStats.overruns ← etherStats.overruns + 1;
IF CommFlags.doStats THEN StatIncr[statEtherSendOverrun];
};
ENDCASE => {
etherStats.badSendStatus ← etherStats.badSendStatus + 1;
IF CommFlags.doStats THEN StatIncr[statEtherSendBadStatus];
};
};
We don't resend things that screwup
firstOutputBuffer ← firstOutputBuffer.next;
DriverDefs.PutOnGlobalDoneQueue[b];
ENDLOOP;
};
GetElapsedPulses:
PROC [startTime: Pulses]
RETURNS [Pulses] =
INLINE {
RETURN[ProcessorFace.GetClockPulses[] - startTime];
};
Watcher:
PROC = {
fiveSecondsOfPulses: Pulses ← MicrosecondsToPulses[5000000];
fiveHalfSecondsOfPulses: Pulses ← MicrosecondsToPulses[2500000];
UNTIL pleaseStop
DO
In either case, an interrupt should be pending. 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 InputChainOK[] THEN EXIT;
REPEAT FINISHED => { WatcherNotify[]; };
ENDLOOP;
Check for lost output interrupt
THROUGH [0..25)
DO
IF OutputChainOK[] THEN EXIT;
REPEAT FINISHED => { WatcherNotify[]; };
ENDLOOP;
Check for stuck input
IF GetElapsedPulses[timeLastRecv] > fiveSecondsOfPulses THEN FixupInput[];
Check for stuck output
IF firstOutputBuffer #
NIL
AND
(GetElapsedPulses[timeSendStarted] > fiveHalfSecondsOfPulses) THEN
ShootDownOutput[];
IF InputBufferQueueOK[] THEN WatcherWait[];
ENDLOOP;
};
InputChainOK:
ENTRY
PROC
RETURNS [
BOOL] =
INLINE {
RETURN[
(firstInputBuffer =
NIL)
OR
(GetStatus[firstInputBuffer.iocbChain] = pending)];
};
OutputChainOK:
ENTRY
PROC
RETURNS [
BOOL] =
INLINE {
RETURN[
(firstOutputBuffer =
NIL)
OR
(GetStatus[firstOutputBuffer.iocbChain] = pending)];
};
InputBufferQueueOK:
PROC
RETURNS [
BOOL] =
INLINE {
b: Buffer;
enterTime: Pulses ← ProcessorFace.GetClockPulses[];
QueueInputBufferLocked:
ENTRY
PROC =
INLINE {
QueueInput[ether, @b.encapsulation, b.length, b.iocbChain];
IF firstInputBuffer = NIL THEN firstInputBuffer ← b
ELSE lastInputBuffer.next ← b;
lastInputBuffer ← b;
inputBuffersInQueue ← inputBuffersInQueue + 1;
};
WHILE (inputBuffersInQueue < myNetwork.buffers)
DO
not MONITOR protected compair !!
IF (b ← DriverDefs.GetInputBuffer[
TRUE]) #
NIL
THEN
{ b.device ← ethernet; b.next ← NIL; QueueInputBufferLocked[]; };
IF GetElapsedPulses[enterTime] > oneSecondOfPulses THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
WatcherWait: ENTRY PROC = INLINE { WAIT timer; };
WatcherNotify:
ENTRY
PROC =
INLINE {
IF CommFlags.doStats THEN StatIncr[statEtherLostInterrupts];
SmashCSBs[]; -- this will leave output dangling
};
FixupInput:
ENTRY
PROC =
INLINE {
IF CommFlags.doStats THEN StatIncr[statInputIdle];
SmashCSBs[]; -- this will leave output dangling
};
ShootDownOutput:
ENTRY
PROC =
INLINE {
This happens if the transciever is unplugged
b: Buffer;
TurnOff[ether];
UNTIL firstOutputBuffer =
NIL
DO
b ← firstOutputBuffer;
firstOutputBuffer ← firstOutputBuffer.next;
DriverDefs.PutOnGlobalDoneQueue[b];
IF CommFlags.doStats THEN StatIncr[statPacketsStuckInOutput];
ENDLOOP;
SmashCSBs[];
};
DecapsulateBuffer:
PROC [b: Buffer]
RETURNS [BufferType] = {
SELECT b.encapsulation.ethernetType
FROM
pup => {
IF 2*b.length < b.pupLength + 2*
SIZE[DriverTypes.Encapsulation]
THEN {
IF CommFlags.doStats THEN StatIncr[statPupsDiscarded];
RETURN[rejected];
};
RETURN[pup];
};
ois => {
IF 2*b.length < b.ois.pktLength + 2*
SIZE[DriverTypes.Encapsulation]
THEN
{ IF CommFlags.doStats THEN StatIncr[statOisDiscarded]; RETURN[rejected]; };
RETURN[ois];
};
translation => {
IF b.rawWords[0] = translationRequest THEN receiveRequest[b]
ELSE IF b.rawWords[0] = translationResponse THEN receiveAck[b]
ELSE
RETURN[rejected];
RETURN[processed];
};
ENDCASE => RETURN[rejected];
};
EncapsulatePup:
PROC [b: PupBuffer, destination: PupHostID] = {
foundIt: BOOL;
oisAddr: OisAddr;
[foundIt, oisAddr] ← translate[destination];
IF foundIt
THEN {
b.encapsulation ←
[ethernet[ethernetDest: oisAddr, ethernetSource: me, ethernetType: pup]];
b.length ← (b.pupLength + 1)/2 + SIZE[DriverTypes.Encapsulation];
}
ELSE {
b.encapsulation ←
[ethernet[
ethernetDest:, ethernetSource: NSAddress.nullHostNumber,
Marker for translation failed
ethernetType: pup]];
};
};
EncapsulateOis:
PROC [
b: OisBuffer, destination: NSAddress.HostNumber] = {
b.encapsulation ←
[ethernet[ethernetDest: destination, ethernetSource: me, ethernetType: ois]];
b.length ← (b.ois.pktLength + 1)/2 + SIZE[DriverTypes.Encapsulation];
};
ForwardBuffer:
PROC [b: Buffer]
RETURNS [PupTypes.PupErrorCode] = {
IF
FALSE
THEN
-- outputQueue.length>10 THEN
RETURN[gatewayResourceLimitsPupErrorCode]; -- transceiver unplugged?
SendBuffer[b];
RETURN[noErrorPupErrorCode];
};
SendBuffer:
ENTRY
PROC [b: Buffer] = {
IF pleaseStop THEN DriverDefs.Glitch[DriverNotActive];
IF b.encapsulation.ethernetSource = NSAddress.nullHostNumber
THEN
{ DriverDefs.PutOnGlobalDoneQueue[b]; RETURN; };
IF ~hearSelf
AND
(b.encapsulation.ethernetDest = me
OR
b.encapsulation.ethernetDest = DriverTypes.ethernetBroadcastHost) THEN
{ -- sending to ourself, copy it over since we can't hear it
copy: Buffer ← DriverDefs.GetInputBuffer[];
IF copy #
NIL
THEN {
copy.device ← ethernet;
PrincOpsUtils.LongCopy[
from: @b.encapsulation, nwords: b.length, to: @copy.encapsulation];
copy.length ← b.length;
copy.network ← LONG[@myNetwork]; -- LONG because of Mokelumne compiler bug
IF CommFlags.doStats THEN StatIncr[statEtherPacketsLocal];
IF CommFlags.doStats THEN StatBump[statEtherWordsLocal, b.length];
DriverDefs.PutOnGlobalInputQueue[copy];
}
ELSE IF CommFlags.doStats THEN StatIncr[statEtherEmptyFreeQueue];
};
SendBufferInternal[b];
};
SendBufferInternal:
INTERNAL
PROC [b: Buffer] = {
minWordsPerEthernetPacket: CARDINAL = (64/2)-2; --*** Should move to DriverTypes
words: CARDINAL ← MAX[b.length,minWordsPerEthernetPacket];
b.device ← ethernet;
QueueOutput[ether, @b.encapsulation, words, b.iocbChain];
IF CommFlags.doStats THEN StatIncr[statEtherPacketsSent];
IF CommFlags.doStats THEN StatBump[statEtherWordsSent, b.length];
IF firstOutputBuffer = NIL THEN firstOutputBuffer ← b
ELSE lastOutputBuffer.next ← b;
lastOutputBuffer ← b;
timeSendStarted ← ProcessorFace.GetClockPulses[];
};
for changing the number of buffers while running
numberOfExtraBuffer: CARDINAL = 3;
bufferAccessHandle: BufferDefs.BufferAccessHandle;
this should only be called from Boss
No MONITOR PROTECTION here.
MaybeChangeNumberOfInputBuffers:
PROC [increaseBuffers:
BOOL] = {
IF increaseBuffers
THEN {
IF bufferAccessHandle =
NIL
THEN {
bufferAccessHandle ← BufferDefs.MakeBufferPool[numberOfExtraBuffer];
myNetwork.buffers ← myNetwork.buffers + numberOfExtraBuffer;
};
}
ELSE {
IF bufferAccessHandle #
NIL
THEN {
myNetwork.buffers ← myNetwork.buffers - numberOfExtraBuffer;
BufferDefs.FreeBufferPool[bufferAccessHandle];
bufferAccessHandle ← NIL;
};
};
};
COLD code, only used when turning things on+off
AdjustLengtoOfD0EthernetInputQueue:
PUBLIC
PROC [n:
CARDINAL] = {
inputQueueLength ← n; };
CreateDefaultEthernetDrivers:
PUBLIC
PROC
RETURNS [
BOOL] = {
deviceNumber: CARDINAL ← 0;
etherDevice: DeviceHandle ← GetNextDevice[nullDeviceHandle];
IF GermSwap.switches[b] THEN RETURN[FALSE];
IF etherDevice = nullDeviceHandle THEN RETURN[FALSE];
WHILE etherDevice # nullDeviceHandle
DO
CreateAnEthernetDriver[etherDevice, deviceNumber];
etherDevice ← GetNextDevice[etherDevice];
deviceNumber ← deviceNumber + 1;
ENDLOOP;
RETURN[TRUE];
};
CreateAnEthernetDriver:
PROC [ etherDevice: DeviceHandle, deviceNumber:
CARDINAL] = {
IF deviceNumber # 0
THEN {
him: POINTER TO FRAME[EthernetDriver] ← NEW EthernetDriver;
him.SetupEthernetDriver[etherDevice];
}
ELSE SetupEthernetDriver[etherDevice];
};
SetupEthernetDriver:
PROC [etherDevice: DeviceHandle] = {
ether ← etherDevice;
myEar ← me ← NSAddress.GetProcessorID[];
myNetwork.netNumber ← nullNetworkNumber;
pleaseStop ← TRUE;
myNetwork.buffers ← inputQueueLength;
etherStats ← NEW[EthernetDriverStats.EtherStatsRep];
myNetwork.stats ← LOOPHOLE[etherStats];
PrincOpsUtils.LongZero[LOOPHOLE[etherStats], SIZE[EthernetDriverStats.EtherStatsRep]];
DriverDefs.AddDeviceToChain[@myNetwork, controlBlockSize];
};
ActivateDriver:
PROC = {
b: Buffer;
IF ~pleaseStop THEN DriverDefs.Glitch[DriverAlreadyActive];
oneSecondOfPulses ← MicrosecondsToPulses[1000000];
getGarbage ← pleaseStop ← FALSE;
TurnOff[ether];
AddCleanup[ether];
myEar ← me ← NSAddress.GetProcessorID[];
firstInputBuffer ← lastInputBuffer ← NIL;
firstOutputBuffer ← lastOutputBuffer ← NIL;
bufferAccessHandle ← NIL;
inputBuffersInQueue ← 0;
THROUGH [0..myNetwork.buffers)
DO
IF (b ← DriverDefs.GetInputBuffer[
TRUE])#
NIL
THEN {
inputBuffersInQueue ← inputBuffersInQueue + 1;
IF CommFlags.doDebug
AND Alignment[@b.encapsulation] # 3
THEN
DriverDefs.Glitch[BufferMustBeAlmostQuadWordAligned];
IF CommFlags.doDebug
AND Alignment[b.iocbChain] # 0
THEN
DriverDefs.Glitch[IOCBMustBeQuadWordAligned];
IF CommFlags.doDebug
AND PrincOpsUtils.HighHalf[b.iocbChain] # 0
THEN
DriverDefs.Glitch[IOCBMustBeInFirstMDS];
b.device ← ethernet;
IF firstInputBuffer = NIL THEN firstInputBuffer ← b;
IF lastInputBuffer # NIL THEN lastInputBuffer.next ← b;
lastInputBuffer ← b;
};
ENDLOOP;
[cv: inWait, mask: inInterruptMask] ← PrincOpsUtils.AllocateNakedCondition[];
Process.DisableTimeout[inWait];
[cv: outWait, mask: outInterruptMask] ← PrincOpsUtils.AllocateNakedCondition[];
Process.DisableTimeout[outWait];
SmashCSBs[];
inProcess ← FORK InInterrupt[];
outProcess ← FORK OutInterrupt[];
watcherProcess ← FORK Watcher[];
CreateCache[];
};
SetEthernetListener:
PUBLIC
ENTRY
PROC [physicalOrder:
CARDINAL, newHostNumber: NSAddress.HostNumber]
RETURNS [success:
BOOL] = {
him: POINTER TO FRAME[EthernetDriver];
network: Network ← GetNthDeviceLikeMe[physicalOrder];
IF network = NIL THEN RETURN[FALSE];
him ← LOOPHOLE[PrincOpsUtils.GlobalFrame[LOOPHOLE[network.interrupt]]];
him.EthernetListenForHost[newHostNumber];
RETURN[TRUE];
};
EthernetListenForHost:
PROC [newHostNumber: NSAddress.HostNumber] = {
myEar ← newHostNumber; SmashCSBs[]; };
SetEthernetCollectGarbageToo:
PUBLIC
ENTRY
PROC [physicalOrder:
CARDINAL, collectGarbage:
BOOL]
RETURNS [success:
BOOL] = {
him: POINTER TO FRAME[EthernetDriver];
network: Network ← GetNthDeviceLikeMe[physicalOrder];
IF network = NIL THEN RETURN[FALSE];
him ← LOOPHOLE[PrincOpsUtils.GlobalFrame[LOOPHOLE[network.interrupt]]];
him.SetCollectGarbageToo[collectGarbage];
RETURN[TRUE];
};
SetCollectGarbageToo:
PROC [collectGarbage:
BOOL] = {
getGarbage ← collectGarbage; };
GetNthDeviceLikeMe:
PROC [physicalOrder:
CARDINAL]
RETURNS [net: Network] = {
i: CARDINAL ← 0;
net ← DriverDefs.GetDeviceChain[];
WHILE net #
NIL
DO
IF net.device = myNetwork.device
THEN
IF (i ← i + 1) = physicalOrder THEN RETURN;
net ← net.next;
ENDLOOP;
};
Exported to EthernetDriverStats
GetEthernetConfig:
PUBLIC
SAFE
PROC
RETURNS [instances:
NAT ← 0] =
TRUSTED {
Returns how many instances are present for the Xerox product standard Ethernet.
net: Network ← DriverDefs.GetDeviceChain[];
WHILE net #
NIL
DO
IF net.device = myNetwork.device THEN instances ← instances + 1;
net ← net.next;
ENDLOOP;
};
GetEthernetStats:
PUBLIC
SAFE
PROC [instance:
NAT]
RETURNS [EthernetDriverStats.EtherStats ←
NIL] =
TRUSTED {
... returns the EtherStats object for the given instance of the Xerox product standard Ethernet driver. Note that these numbers are not monitor protected, so be prepared for strange results every so often. NIL will be returned for invalid instances.
net: Network ← GetNthDeviceLikeMe[instance+1];
IF net #
NIL
THEN
RETURN [
LOOPHOLE[net.stats]];
Note that it is OK to do this, since we are always holding onto the REF through the global frame associated with the network driver.
};
SmashCSBs:
PROC = {
b: Buffer;
TurnOn[
ether, LOOPHOLE[myEar, NSAddress.ProcessorID], inInterruptMask,
outInterruptMask, globalStatePtr];
FOR b ← firstInputBuffer, b.next
UNTIL b =
NIL
DO
QueueInput[ether, @b.encapsulation, b.length, b.iocbChain]; ENDLOOP;
timeLastRecv ← ProcessorFace.GetClockPulses[];
};
DeleteDriver:
PROC = {
IF ether # GetNextDevice[nullDeviceHandle] THEN LoadState.SelfDestruct[];
};
DeactivateDriver:
PROC = {
b: Buffer;
IF pleaseStop THEN DriverDefs.Glitch[DriverNotActive];
pleaseStop ← TRUE;
KillInterruptRoutines[];
JOIN inProcess;
JOIN outProcess;
TurnOff[ether];
PrincOpsUtils.DeallocateNakedCondition[inWait];
PrincOpsUtils.DeallocateNakedCondition[outWait];
inWait ← outWait ← NIL;
MaybeChangeNumberOfInputBuffers[FALSE];
KillDriverLocked[];
JOIN watcherProcess;
RemoveCleanup[ether];
UNTIL firstInputBuffer =
NIL
DO
b ← firstInputBuffer;
firstInputBuffer ← b.next;
ReturnFreeBuffer[b];
ENDLOOP;
UNTIL firstOutputBuffer =
NIL
DO
b ← firstOutputBuffer;
firstOutputBuffer ← b.next;
ReturnFreeBuffer[b];
ENDLOOP;
myNetwork.netNumber ← nullNetworkNumber;
in case we turn it on after moving to another machine
DeleteCache[];
};
KillInterruptRoutines:
ENTRY
PROC =
INLINE {
NOTIFY inWait^;
NOTIFY outWait^;
};
KillDriverLocked: ENTRY PROC = INLINE { NOTIFY timer; };
OisAddr: TYPE = NSAddress.HostNumber;
Ethernet1Addr: TYPE = PupTypes.PupHostID;
AddressPair:
TYPE =
MACHINE
DEPENDENT
RECORD [
oisAddr: OisAddr, ethernet1Addr: Ethernet1Addr, filler: [0..377B]];
CacheEntry: TYPE = REF CacheObject;
CacheObject:
TYPE =
MACHINE
DEPENDENT
RECORD [
nextLink: CacheEntry,
addressPair: AddressPair,
tries: CARDINAL,
timeStamp: ProcessorFace.GreenwichMeanTime,
status: CacheStatus,
filler: [0..37777B]];
CacheStatus: TYPE = {new, pending, active, zombie};
variables
translationRequest: CARDINAL = 10101B;
translationResponse: CARDINAL = 7070B;
cacheQueueHead: CacheEntry;
broadCastPairEntry: CacheEntry; -- permanent
myAddressPairEntry: CacheEntry; -- permanent
retryLimit: CARDINAL = 10B;
retryTime: LONG CARDINAL = 2; -- two seconds
demonActiveTime: Process.Ticks ← Process.SecondsToTicks[1]; -- one second
deactivateTime: LONG CARDINAL = 3*60; -- three minutes
demonSleepTime: Process.Ticks ← Process.SecondsToTicks[60*5]; -- five minutes
cacheEvent: CONDITION;
demonRunning: BOOL;
lastTranslationTime: ProcessorFace.GreenwichMeanTime;
translate:
PROC [Ethernet1Addr]
RETURNS [
BOOL, OisAddr] ←
InactiveTranslate;
receiveRequest: PROC [Buffer] ← InactiveReceiveAckOrRequest;
receiveAck: PROC [Buffer] ← InactiveReceiveAckOrRequest;
interface
CreateCache:
ENTRY
PROC =
INLINE {
cacheQueueHead ← broadCastPairEntry ← myAddressPairEntry ← NIL;
translate ← InactiveTranslate;
receiveRequest ← InactiveReceiveAckOrRequest;
receiveAck ← InactiveReceiveAckOrRequest;
demonRunning ← FALSE;
};
StartCache:
ENTRY
PROC [myEthernetOneAddr:
CARDINAL] =
INLINE {
aP: AddressPair ← [NSAddress.broadcastHostNumber, PupTypes.allHosts, 0];
translate ← Translate;
receiveRequest ← ReceiveRequest;
receiveAck ← ReceiveAck;
Process.SetTimeout[@cacheEvent, demonActiveTime];
broadCastPairEntry ← AddAddressPair[aP];
aP ← [me, [myNetwork.hostNumber ← myEthernetOneAddr], 0];
myAddressPairEntry ← AddAddressPair[aP];
demonRunning ← TRUE;
Process.Detach[FORK Demon[]];
};
DeleteCache:
PROC =
INLINE {
e: CacheEntry;
DeleteCacheLocked: ENTRY PROC = INLINE { NOTIFY cacheEvent; };
DeleteCacheLocked
WHILE demonRunning DO DeleteCacheLocked[]; Process.Yield[]; ENDLOOP;
cleanup in case demon was never running
WHILE (cacheQueueHead #
NIL)
DO
e ← cacheQueueHead;
cacheQueueHead ← e.nextLink;
Heap.FreeNode[p: e]; before conversion to REFs (ADB). --
ENDLOOP;
};
depth: CARDINAL;
FindEntry:
INTERNAL
PROC [ethernet1Addr: Ethernet1Addr]
RETURNS [entry: CacheEntry] = {
IF CommFlags.doStats THEN depth ← 0;
entry ← cacheQueueHead;
WHILE entry #
NIL
DO
IF ethernet1Addr = entry.addressPair.ethernet1Addr THEN RETURN;
entry ← entry.nextLink;
IF CommFlags.doStats THEN depth ← depth + 1;
ENDLOOP;
};
AddEntry:
INTERNAL
PROC [entry: CacheEntry] = {
entry.nextLink ← cacheQueueHead; cacheQueueHead ← entry; };
RemoveEntry:
INTERNAL
PROC [entry: CacheEntry] = {
e, pred: CacheEntry;
IF (pred ← cacheQueueHead) = entry
THEN {
cacheQueueHead ← cacheQueueHead.nextLink;
RETURN;
};
e ← pred.nextLink;
WHILE e #
NIL
DO
IF e = entry THEN { pred.nextLink ← entry.nextLink; RETURN; };
pred ← e;
e ← pred.nextLink;
ENDLOOP;
ERROR; -- entry not found
};
InactiveTranslate:
PROC [ethernet1Addr: Ethernet1Addr]
RETURNS [foundIt:
BOOL, oisAddr: OisAddr] = {
ethernetOneAddr: CARDINAL ← CommUtilDefs.GetEthernetHostNumber[];
StartCache[ethernetOneAddr];
[foundIt, oisAddr] ← Translate[ethernet1Addr];
};
Translate:
ENTRY
PROC [ethernet1Addr: Ethernet1Addr]
RETURNS [foundIt:
BOOL, oisAddr: OisAddr] = {
e: CacheEntry;
foundIt ← FALSE;
lastTranslationTime ← ProcessorFace.GetGreenwichMeanTime[];
IF (e ← FindEntry[ethernet1Addr]) #
NIL
THEN {
IF e # cacheQueueHead
THEN {
put e at the head of the queue
IF CommFlags.doStats THEN StatBump[cacheDepth, depth];
RemoveEntry[e];
AddEntry[e];
};
SELECT e.status
FROM
active => {
foundIt ← TRUE;
oisAddr ← e.addressPair.oisAddr;
e.timeStamp ← lastTranslationTime;
};
zombie => {
e.status ← new;
e.tries ← 0;
e.timeStamp ← lastTranslationTime;
NOTIFY cacheEvent;
};
ENDCASE => NULL;
} -- of found it
ELSE {
entry not found, so add a new one
IF CommFlags.doStats THEN StatIncr[cacheFault];
e ← NEW[CacheObject];
e.status ← new;
e.tries ← 0;
e.timeStamp ← lastTranslationTime;
e.addressPair ← [oisAddr:, ethernet1Addr: ethernet1Addr, filler:];
AddEntry[e];
NOTIFY cacheEvent;
};
};
AddAddressPair:
INTERNAL
PROC [aP: AddressPair]
RETURNS [e: CacheEntry] = {
IF (e ← FindEntry[aP.ethernet1Addr]) = NIL THEN {e ← NEW[CacheObject]; AddEntry[e]};
e.addressPair ← aP;
e.status ← active;
e.timeStamp ← ProcessorFace.GetGreenwichMeanTime[];
};
DeallocateEntry:
INTERNAL
PROC [e: CacheEntry] = {
there are two entries that we do not want to throw out!!
IF (e = broadCastPairEntry)
OR (e = myAddressPairEntry)
THEN
e.timeStamp ← ProcessorFace.GetGreenwichMeanTime[]
ELSE { RemoveEntry[e]; --Heap.FreeNode[p: e];-- };
};
Demon:
ENTRY
PROC = {
translationInactiveTime: LONG CARDINAL = 10*60;
demon will die if no services are needed in ten minutes
now: ProcessorFace.GreenwichMeanTime;
t: LONG CARDINAL;
e, nextE: CacheEntry;
pendingEntries: BOOL;
demonRunning ← TRUE;
lastTranslationTime ← ProcessorFace.GetGreenwichMeanTime[];
Process.SetPriority[3];
UNTIL pleaseStop
DO
WAIT cacheEvent;
IF (now ← ProcessorFace.GetGreenwichMeanTime[]) - lastTranslationTime > translationInactiveTime OR pleaseStop THEN EXIT;
pendingEntries ← FALSE;
e ← cacheQueueHead;
WHILE (e #
NIL)
DO
nextE ← e.nextLink;
t ← now - e.timeStamp;
SELECT e.status
FROM
active, zombie => {
IF t > deactivateTime THEN DeallocateEntry[e];
};
pending => {
pendingEntries ← TRUE;
IF t > retryTime
THEN {
e.tries ← e.tries + 1;
IF e.tries > retryLimit
THEN {
e.status ← zombie;
IF CommFlags.doStats THEN StatIncr[unsuccessfulTranslation];
}
ELSE {
IF CommFlags.doStats THEN StatIncr[translationRetries];
SendRequest[e];
e.timeStamp ← ProcessorFace.GetGreenwichMeanTime[];
};
};
};
new => {
pendingEntries ← TRUE;
SendRequest[e];
e.status ← pending;
e.timeStamp ← ProcessorFace.GetGreenwichMeanTime[];
};
ENDCASE => ERROR;
e ← nextE;
ENDLOOP; -- end of queue entries loop
IF pendingEntries THEN Process.SetTimeout[@cacheEvent, demonActiveTime]
ELSE Process.SetTimeout[@cacheEvent, demonSleepTime];
ENDLOOP; -- end of infinite loop
receiveAck ← InactiveReceiveAckOrRequest;
receiveRequest ← InactiveReceiveAckOrRequest;
translate ← InactiveTranslate;
e ← cacheQueueHead;
cacheQueueHead ← myAddressPairEntry ← broadCastPairEntry ← NIL;
WHILE e # NIL DO nextE ← e.nextLink; --Heap.FreeNode[p: e];-- e ← nextE; ENDLOOP;
demonRunning ← FALSE;
};
SendRequest:
INTERNAL
PROC [e: CacheEntry] = {
b: Buffer;
request: LONG POINTER TO AddressPair;
IF (b ← DriverDefs.GetInputBuffer[
TRUE]) #
NIL
THEN {
broadcast the translation request
b.encapsulation ←
[ethernet[
ethernetDest: DriverTypes.ethernetBroadcastHost, ethernetSource: me,
ethernetType: translation]];
b.length ← SIZE[DriverTypes.Encapsulation] + 2*SIZE[AddressPair] + 1;
b.rawWords[0] ← translationRequest;
request ← LOOPHOLE[@b.rawWords[1]];
request^ ← e.addressPair;
also send our addresses, so responder does not fault
request ← request + SIZE[AddressPair];
request^ ← myAddressPairEntry.addressPair;
send it
SendBufferInternal[b];
};
};
locks
we now own buffer b
we donot allow back door requests if we are not actively translating
InactiveReceiveAckOrRequest:
PROC [b: Buffer] = {
b.requeueProcedure[b];
};
we now own buffer b
ReceiveAck:
ENTRY
PROC [b: Buffer] = {
IF b.encapsulation.ethernetDest = myAddressPairEntry.addressPair.oisAddr
THEN {
receipt: LONG POINTER TO AddressPair ← LOOPHOLE[@b.rawWords[1]];
[] ← AddAddressPair[receipt^];
};
b.requeueProcedure[b];
};
locks
we now own buffer b
ReceiveRequest:
ENTRY
PROC [b: Buffer] = {
request, requesterAddr: LONG POINTER TO AddressPair;
request ← LOOPHOLE[@b.rawWords[1]];
IF (myAddressPairEntry #
NIL)
AND
(request.ethernet1Addr = myAddressPairEntry.addressPair.ethernet1Addr) THEN {
IF CommFlags.doStats THEN StatIncr[requestsForMe];
since the requester is probably going to talk to us, add his address before we take a fault
requesterAddr ← request + SIZE[AddressPair];
[] ← AddAddressPair[requesterAddr^];
request.oisAddr ← myAddressPairEntry.addressPair.oisAddr;
SendAck[request^, b.encapsulation.ethernetSource, b]; -- we lose ownership of b
}
ELSE b.requeueProcedure[b];
};
SendAck:
INTERNAL
PROC [aP: AddressPair, to: NSAddress.HostNumber, b: Buffer] =
INLINE {
response: LONG POINTER TO AddressPair;
IF b #
NIL
THEN {
b.encapsulation ← [ethernet[ethernetDest: to, ethernetSource: me, ethernetType: translation]];
b.length ← SIZE[DriverTypes.Encapsulation] + SIZE[AddressPair] + 1;
b.rawWords[0] ← translationResponse;
response ← LOOPHOLE[@b.rawWords[1]];
response^ ← aP;
send it
SendBufferInternal[b];
};
};
initialization
Process.SetTimeout[@timer, Process.MsecToTicks[1000]];
}. -- EthernetDriver