-- File: EthernetOneDriver.mesa -- Edit by: Andrew Birrell on: 9-Oct-81 16:43:32 -- Edit by: BLyon on: March 13, 1981 10:47 PM -- Last Edited by: Levin, June 15, 1983 11:02 am DIRECTORY BufferDefs, CommFlags USING [doDebug, doStats], CommUtilDefs USING [Zero], DriverDefs USING [ GetGiantVector, GiantVector, Glitch, GetDeviceChain, GetInputBuffer, Network, NetworkObject, AddDeviceToChain, PutOnGlobalDoneQueue, PutOnGlobalInputQueue], DriverTypes USING [ Byte, ethernetEncapsulationOffset, ethernetEncapsulationBytes], EthernetOneFace, GermSwap USING [switches], LoadState USING [SelfDestruct], PrincOpsUtils USING [ AllocateNakedCondition, BITAND, DeallocateNakedCondition, GlobalFrame, HighHalf, LongCOPY, LowHalf], Process USING [ Detach, DisableTimeout, MsecToTicks, SecondsToTicks, SetPriority, SetTimeout, Ticks, Yield], ProcessorFace USING [ GetGreenwichMeanTime, GetClockPulses, GreenwichMeanTime, microsecondsPerHundredPulses], PupTypes USING [allHosts, PupErrorCode, PupHostID], RPCPrivate USING[ rpcSocket ], StatsDefs USING [StatBump, StatIncr, StatCounterIndex], SpecialCommunication USING [], NSAddress USING [ broadcastHostNumber, ProcessorID, HostNumber, GetProcessorID, nullNetworkNumber]; EthernetOneDriver: MONITOR IMPORTS BufferDefs, CommUtilDefs, DriverDefs, GermSwap, StatsDefs, EthernetOneFace, LoadState, PrincOpsUtils, Process, ProcessorFace, NSAddress EXPORTS BufferDefs, DriverDefs, RPCPrivate--ReturnBuffer--, SpecialCommunication SHARES BufferDefs, DriverTypes, NSAddress = BEGIN OPEN StatsDefs, BufferDefs, EthernetOneFace, NSAddress; -- RPC: disable "doStats" for this module -- doStats: BOOLEAN = CommFlags.doStats AND FALSE; -- EXPORTed TYPEs Network: PUBLIC TYPE = DriverDefs.Network; ethernetEncapsulationOffset: CARDINAL = DriverTypes.ethernetEncapsulationOffset; ethernetEncapsulationBytes: CARDINAL = DriverTypes.ethernetEncapsulationBytes; ether: DeviceHandle; 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: BOOLEAN; timer: CONDITION; timeLastRecv, timeSendStarted: Pulses; fiveSecondsOfPulses: Pulses; fiveHalfSecondsOfPulses: Pulses; oneSecondOfPulses: Pulses; inputQueueLength: CARDINAL _ 1; inputBuffersInQueue: CARDINAL; --RPC-- loanedToRPC: CARDINAL; -- this number from inputBuffersInQueue aren't really -- in the input queue, because RPCRuntime has them! --RPC-- systemBufferSize: CARDINAL _ 0; 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: 3000, -- in kiloBits/sec buffers:, spare:, device: ethernetOne, index:, netNumber: nullNetworkNumber, hostNumber:, next: NIL, pupStats: NIL, stats: NIL]; myEar: CARDINAL; -- what address am I listening for (verses myNetwork.hostNumber, my real address). getGarbage: BOOLEAN _ FALSE; -- when true, we deliver any packet 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; BufferMustBeQuadWordAligned: PUBLIC ERROR = CODE; IOCBMustBeQuadWordAligned: PUBLIC ERROR = CODE; IOCBMustBeInFirstMDS: PUBLIC ERROR = CODE; EtherStatsInfo: TYPE = RECORD [ packetsSent: LONG CARDINAL, wordsSent: LONG CARDINAL, badSendStatus: LONG CARDINAL, overruns: LONG CARDINAL, packetsRecv: LONG CARDINAL, wordsRecv: LONG CARDINAL, badRecvStatus: LONG CARDINAL, inputOff: LONG CARDINAL, loadTable: ARRAY [0..16] OF LONG CARDINAL]; etherStatsInfo: EtherStatsInfo; etherStats: POINTER TO EtherStatsInfo _ @etherStatsInfo; -- 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 PROCEDURE = BEGIN acceptBuffer: BOOLEAN; 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 doStats AND status # pending THEN StatIncr[statEtherInterruptDuringInterrupt]; UNTIL pleaseStop OR status # pending DO WAIT inWait; status _ GetStatus[this.iocbChain]; IF doStats AND status = pending THEN StatIncr[statEtherMissingStatus]; ENDLOOP; IF doStats AND (missed _ GetPacketsMissed[ether]) # lastMissed THEN BEGIN StatBump[statEtherEmptyNoBuffer, missed - lastMissed]; lastMissed _ missed; END; IF pleaseStop THEN EXIT; firstInputBuffer _ firstInputBuffer.next; SELECT status FROM ok => acceptBuffer _ TRUE; ENDCASE => BEGIN etherStats.badRecvStatus _ etherStats.badRecvStatus + 1; acceptBuffer _ getGarbage; -- we may be collecting garbage packets IF doStats THEN SELECT status FROM packetTooLong => StatIncr[statEtherReceivedTooLong]; badAlignmentButOkCrc => StatIncr[statEtherReceivedNot16]; crc => StatIncr[statEtherReceivedBadCRC]; crcAndBadAlignment => StatIncr[statEtherReceivedNot16BadCRC]; overrun => BEGIN etherStats.overruns _ etherStats.overruns + 1; StatIncr[statEtherReceivedOverrun]; END; ENDCASE => StatIncr[statEtherReceivedBadStatus]; END; IF acceptBuffer THEN BEGIN allocateAnother: BOOLEAN; this.time _ timeLastRecv _ ProcessorFace.GetClockPulses[]; this.length _ GetPacketLength[this.iocbChain]; this.network _ LONG[@myNetwork]; -- LONG because of Mokelumne compiler bug IF doStats THEN BEGIN etherStats.packetsRecv _ etherStats.packetsRecv + 1; etherStats.wordsRecv _ etherStats.wordsRecv + this.length; StatIncr[statEtherPacketsReceived]; StatBump[statEtherWordsReceived, this.length]; END; -- RPC: side door into RPC packet dispatching code -- IF EnqueueRecvd # NIL AND this.encapsulation.ethernetOneType = pup AND 2*this.length >= this.pupLength + ethernetEncapsulationBytes AND this.dest.socket = RPCPrivate.rpcSocket THEN BEGIN this.next _ NIL -- assumed by SendBuffer --; IF EnqueueRecvd[LOOPHOLE[this,PupBuffer]] THEN { new _ NIL; allocateAnother _ (loanedToRPC+2 > inputBuffersInQueue) } ELSE { new _ this; allocateAnother _ FALSE; new.length _ systemBufferSize }; END ELSE { DriverDefs.PutOnGlobalInputQueue[this]; allocateAnother _ TRUE }; IF allocateAnother THEN BEGIN IF (new _ DriverDefs.GetInputBuffer[]) = NIL THEN BEGIN -- Rats, couldn't get a new buffer inputBuffersInQueue _ inputBuffersInQueue - 1; NOTIFY timer; IF doStats THEN BEGIN etherStats.inputOff _ etherStats.inputOff + 1; StatIncr[statEtherEmptyFreeQueue]; END; END; -- cant get new input buffer clause END ELSE -- we may have loaned the buffer to RPC; don't replace it -- IF new = NIL THEN loanedToRPC _ loanedToRPC + 1; END -- accept buffer clause ELSE BEGIN new _ this; -- Some kind of error, recycle this buffer END; -- reject buffer clause -- add new buffer to end of input chain IF new # NIL THEN BEGIN new.device _ ethernetOne; QueueInput[ ether, @new.encapsulation + ethernetEncapsulationOffset, new.length - ethernetEncapsulationOffset, new.iocbChain]; IF systemBufferSize = 0 THEN systemBufferSize _ new.length; new.next _ NIL; IF firstInputBuffer = NIL THEN firstInputBuffer _ new ELSE lastInputBuffer.next _ new; lastInputBuffer _ new; END; ENDLOOP; END; OutInterrupt: ENTRY PROCEDURE = BEGIN 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 => BEGIN IF doStats THEN BEGIN tries: CARDINAL _ GetRetries[b.iocbChain]; statEtherSendsCollision1: StatsDefs.StatCounterIndex = statEtherSendsCollision1; first: CARDINAL = LOOPHOLE[statEtherSendsCollision1]; etherStats.packetsSent _ etherStats.packetsSent + 1; etherStats.wordsSent _ etherStats.wordsSent + b.length; IF tries # 0 THEN StatIncr[LOOPHOLE[first + tries]]; etherStats.loadTable[tries] _ etherStats.loadTable[tries] + 1; END; END; ENDCASE => BEGIN IF doStats THEN SELECT status FROM tooManyCollisions => BEGIN etherStats.loadTable[16] _ etherStats.loadTable[16] + 1; StatIncr[statEtherSendsCollisionLoadOverflow]; END; underrun => BEGIN etherStats.overruns _ etherStats.overruns + 1; StatIncr[statEtherSendOverrun]; END; ENDCASE => BEGIN etherStats.badSendStatus _ etherStats.badSendStatus + 1; StatIncr[statEtherSendBadStatus]; END; END; -- We don't resend things that screwup firstOutputBuffer _ firstOutputBuffer.next; DriverDefs.PutOnGlobalDoneQueue[b]; ENDLOOP; END; GetElapsedPulses: PROCEDURE [startTime: Pulses] RETURNS [Pulses] = INLINE BEGIN RETURN[ProcessorFace.GetClockPulses[] - startTime]; END; Watcher: PROCEDURE = BEGIN 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 => BEGIN WatcherNotify[]; END; ENDLOOP; -- Check for lost output interrupt THROUGH [0..25) DO IF OutputChainOK[] THEN EXIT; REPEAT FINISHED => BEGIN WatcherNotify[]; END; 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; END; InputChainOK: ENTRY PROCEDURE RETURNS [BOOLEAN] = INLINE BEGIN RETURN[ (firstInputBuffer = NIL) OR (GetStatus[firstInputBuffer.iocbChain] = pending)]; END; OutputChainOK: ENTRY PROCEDURE RETURNS [BOOLEAN] = INLINE BEGIN RETURN[ (firstOutputBuffer = NIL) OR (GetStatus[firstOutputBuffer.iocbChain] = pending)]; END; InputBufferQueueOK: PROCEDURE RETURNS [BOOLEAN] = INLINE BEGIN b: Buffer; enterTime: Pulses _ ProcessorFace.GetClockPulses[]; QueueInputBufferLocked: ENTRY PROCEDURE = INLINE BEGIN QueueInput[ ether, @b.encapsulation + ethernetEncapsulationOffset, b.length - ethernetEncapsulationOffset, b.iocbChain]; IF systemBufferSize = 0 THEN systemBufferSize _ b.length; IF firstInputBuffer = NIL THEN firstInputBuffer _ b ELSE lastInputBuffer.next _ b; lastInputBuffer _ b; inputBuffersInQueue _ inputBuffersInQueue + 1; END; WHILE (inputBuffersInQueue < myNetwork.buffers) DO -- not MONITOR protected compair !! IF (b _ DriverDefs.GetInputBuffer[TRUE]) # NIL THEN BEGIN b.device _ ethernetOne; b.next _ NIL; QueueInputBufferLocked[]; END; IF GetElapsedPulses[enterTime] > oneSecondOfPulses THEN RETURN[FALSE]; ENDLOOP; RETURN[TRUE]; END; WatcherWait: ENTRY PROCEDURE = INLINE BEGIN WAIT timer; END; WatcherNotify: ENTRY PROCEDURE = INLINE BEGIN IF doStats THEN StatIncr[statEtherLostInterrupts]; SmashCSBs[]; -- this will leave output dangling END; FixupInput: ENTRY PROCEDURE = INLINE BEGIN IF doStats THEN StatIncr[statInputIdle]; SmashCSBs[]; -- this will leave output dangling END; ShootDownOutput: ENTRY PROCEDURE = INLINE BEGIN -- This happens if the transciever is unplugged b: Buffer; TurnOff[ether]; UNTIL firstOutputBuffer = NIL DO b _ firstOutputBuffer; firstOutputBuffer _ firstOutputBuffer.next; DriverDefs.PutOnGlobalDoneQueue[b]; IF doStats THEN StatIncr[statPacketsStuckInOutput]; ENDLOOP; SmashCSBs[]; END; EnqueueRecvd: PROC[BufferDefs.PupBuffer]RETURNS[BOOLEAN] _ NIL; GetRPCPackets: PUBLIC--RPCPrivate-- ENTRY PROC[ p: PROC[BufferDefs.PupBuffer]RETURNS[BOOLEAN] ] = { EnqueueRecvd _ p }; ReturnBuffer: PUBLIC--RPCPrivate-- ENTRY PROC[c: PupBuffer] = BEGIN b: Buffer = c; IF loanedToRPC > 0 THEN BEGIN QueueInput[ ether, @b.encapsulation + ethernetEncapsulationOffset, (b.length _ systemBufferSize) - ethernetEncapsulationOffset, b.iocbChain]; IF firstInputBuffer = NIL THEN firstInputBuffer _ b ELSE lastInputBuffer.next _ b; lastInputBuffer _ b; loanedToRPC _ loanedToRPC-1; END ELSE ReturnFreeBuffer[b]; END; DecapsulateBuffer: PROCEDURE [b: Buffer] RETURNS [BufferType] = BEGIN SELECT b.encapsulation.ethernetOneType FROM pup => BEGIN IF 2*b.length < b.pupLength + ethernetEncapsulationBytes THEN BEGIN IF doStats THEN StatIncr[statPupsDiscarded]; RETURN[rejected]; END; RETURN[pup]; END; ois => BEGIN IF 2*b.length < b.ois.pktLength + ethernetEncapsulationBytes THEN BEGIN IF doStats THEN StatIncr[statOisDiscarded]; RETURN[rejected]; END; RETURN[ois]; END; translation => BEGIN IF b.rawWords[0] = translationRequest THEN ReceiveRequest[b] ELSE IF b.rawWords[0] = translationResponse THEN receiveAck[b] ELSE RETURN[rejected]; RETURN[processed]; END; ENDCASE => RETURN[rejected]; END; EncapsulatePup: PROCEDURE [b: PupBuffer, destination: PupHostID] = BEGIN b.encapsulation _ [ethernetOne[ etherSpare1:, etherSpare2:, etherSpare3:, etherSpare4:, etherSpare5:, translationWorked: TRUE, ethernetOneDest: destination, ethernetOneSource: myNetwork.hostNumber, ethernetOneType: pup]]; b.length _ (b.pupLength + 1 + ethernetEncapsulationBytes)/2; END; EncapsulateOis: PROCEDURE [ b: OisBuffer, destination: NSAddress.HostNumber] = BEGIN foundIt: BOOLEAN; ethernetAddr: Ethernet1Addr; [foundIt, ethernetAddr] _ translate[destination]; IF foundIt THEN BEGIN b.encapsulation _ [ethernetOne[ etherSpare1:, etherSpare2:, etherSpare3:, etherSpare4:, etherSpare5:, translationWorked: TRUE, ethernetOneDest: ethernetAddr, ethernetOneSource: myNetwork.hostNumber, ethernetOneType: ois]]; b.length _ (b.ois.pktLength + 1 + ethernetEncapsulationBytes)/2; END ELSE BEGIN b.encapsulation _ [ethernetOne[ etherSpare1:, etherSpare2:, etherSpare3:, etherSpare4:, etherSpare5:, translationWorked: FALSE, ethernetOneDest:, ethernetOneSource:, ethernetOneType:]]; END; END; ForwardBuffer: PROCEDURE [b: Buffer] RETURNS [PupTypes.PupErrorCode] = BEGIN IF FALSE THEN -- outputQueue.length>10 THEN RETURN[gatewayResourceLimitsPupErrorCode]; -- transceiver unplugged? SendBuffer[b]; RETURN[noErrorPupErrorCode]; END; SendBuffer: ENTRY PROCEDURE [b: Buffer] = BEGIN IF pleaseStop THEN DriverDefs.Glitch[DriverNotActive]; IF ~b.encapsulation.translationWorked THEN BEGIN DriverDefs.PutOnGlobalDoneQueue[b]; RETURN; END; IF ~hearSelf AND (b.encapsulation.ethernetOneDest = myNetwork.hostNumber OR b.encapsulation.ethernetOneDest = PupTypes.allHosts) THEN BEGIN -- sending to ourself, copy it over since we can't hear it copy: Buffer _ DriverDefs.GetInputBuffer[]; IF copy # NIL THEN BEGIN copy.device _ ethernetOne; PrincOpsUtils.LongCOPY[ from: @b.encapsulation + ethernetEncapsulationOffset, nwords: b.length, to: @copy.encapsulation + ethernetEncapsulationOffset]; copy.length _ b.length; copy.network _ LONG[@myNetwork]; -- LONG because of Mokelumne compiler bug IF doStats THEN StatIncr[statEtherPacketsLocal]; IF doStats THEN StatBump[statEtherWordsLocal, b.length]; DriverDefs.PutOnGlobalInputQueue[copy]; END ELSE IF doStats THEN StatIncr[statEtherEmptyFreeQueue]; END; SendBufferInternal[b]; END; SendBufferInternal: INTERNAL PROCEDURE [b: Buffer] = BEGIN b.device _ ethernetOne; QueueOutput[ ether, @b.encapsulation + ethernetEncapsulationOffset, b.length, b.iocbChain]; IF doStats THEN StatIncr[statEtherPacketsSent]; IF doStats THEN StatBump[statEtherWordsSent, b.length]; IF firstOutputBuffer = NIL THEN firstOutputBuffer _ b ELSE lastOutputBuffer.next _ b; lastOutputBuffer _ b; timeSendStarted _ ProcessorFace.GetClockPulses[]; END; -- 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: PROCEDURE [increaseBuffers: BOOLEAN] = BEGIN IF increaseBuffers THEN BEGIN IF bufferAccessHandle = NIL THEN BEGIN bufferAccessHandle _ BufferDefs.MakeBufferPool[numberOfExtraBuffer]; myNetwork.buffers _ myNetwork.buffers + numberOfExtraBuffer; END; END ELSE BEGIN IF bufferAccessHandle # NIL THEN BEGIN myNetwork.buffers _ myNetwork.buffers - numberOfExtraBuffer; BufferDefs.FreeBufferPool[bufferAccessHandle]; bufferAccessHandle _ NIL; END; END; END; -- COLD code, only used when turning things on+off AdjustLengtoOfD0EthernetInputQueue: PUBLIC PROCEDURE [n: CARDINAL] = BEGIN inputQueueLength _ n; END; CreateDefaultEthernetOneDrivers: PUBLIC PROCEDURE RETURNS [BOOLEAN] = BEGIN deviceNumber: CARDINAL _ 0; etherDevice: DeviceHandle _ GetNextDevice[nullDeviceHandle]; IF GermSwap.switches[a] THEN RETURN[FALSE]; IF etherDevice = nullDeviceHandle THEN RETURN[FALSE]; WHILE etherDevice # nullDeviceHandle DO CreateAnEthernetOneDriver[etherDevice, deviceNumber]; etherDevice _ GetNextDevice[etherDevice]; deviceNumber _ deviceNumber + 1; ENDLOOP; RETURN[TRUE]; END; CreateAnEthernetOneDriver: PROCEDURE [ etherDevice: DeviceHandle, deviceNumber: CARDINAL] = BEGIN IF deviceNumber # 0 THEN BEGIN him: POINTER TO FRAME[EthernetOneDriver] _ NEW EthernetOneDriver; him.SetupEthernetOneDriver[etherDevice]; END ELSE SetupEthernetOneDriver[etherDevice]; END; SetupEthernetOneDriver: PROCEDURE [etherDevice: DeviceHandle] = BEGIN net, host: DriverTypes.Byte; ether _ etherDevice; [net, host] _ GetEthernet1Address[ether]; IF net # 0 AND net # myNetwork.netNumber.b AND myNetwork.netNumber # nullNetworkNumber THEN DriverDefs.Glitch[EthernetNetNumberScrambled]; IF myNetwork.netNumber = nullNetworkNumber THEN myNetwork.netNumber _ [a: 0, b: net]; pleaseStop _ TRUE; myNetwork.buffers _ inputQueueLength; DriverDefs.AddDeviceToChain[@myNetwork, controlBlockSize]; IF doStats THEN BEGIN myNetwork.stats _ etherStats; CommUtilDefs.Zero[etherStats, SIZE[EtherStatsInfo]]; END; END; ActivateDriver: PROCEDURE = BEGIN b: Buffer; net, host: DriverTypes.Byte; IF ~pleaseStop THEN DriverDefs.Glitch[DriverAlreadyActive]; fiveSecondsOfPulses _ MicrosecondsToPulses[5000000]; fiveHalfSecondsOfPulses _ MicrosecondsToPulses[2500000]; oneSecondOfPulses _ MicrosecondsToPulses[1000000]; [net, host] _ GetEthernet1Address[ether]; getGarbage _ pleaseStop _ FALSE; TurnOff[ether]; AddCleanup[ether]; firstInputBuffer _ lastInputBuffer _ NIL; firstOutputBuffer _ lastOutputBuffer _ NIL; bufferAccessHandle _ NIL; myEar _ myNetwork.hostNumber _ host; inputBuffersInQueue _ loanedToRPC _ 0; THROUGH [0..myNetwork.buffers) DO IF (b _ DriverDefs.GetInputBuffer[TRUE])#NIL THEN BEGIN inputBuffersInQueue _ inputBuffersInQueue + 1; IF CommFlags.doDebug AND PrincOpsUtils.BITAND[PrincOpsUtils.LowHalf[ LOOPHOLE[@b.encapsulation, LONG CARDINAL] + ethernetEncapsulationOffset], 3] # 0 THEN DriverDefs.Glitch[BufferMustBeQuadWordAligned]; IF CommFlags.doDebug AND PrincOpsUtils.BITAND[PrincOpsUtils.LowHalf[b.iocbChain], 3] # 0 THEN DriverDefs.Glitch[IOCBMustBeQuadWordAligned]; IF CommFlags.doDebug AND PrincOpsUtils.HighHalf[b.iocbChain] # 0 THEN DriverDefs.Glitch[IOCBMustBeInFirstMDS]; b.device _ ethernetOne; IF firstInputBuffer = NIL THEN firstInputBuffer _ b; IF lastInputBuffer # NIL THEN lastInputBuffer.next _ b; lastInputBuffer _ b; END; 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[]; END; SetEthernetOneListener: PUBLIC ENTRY PROCEDURE [ physicalOrder: CARDINAL, newHostNumber: CARDINAL] RETURNS [success: BOOLEAN] = BEGIN him: POINTER TO FRAME[EthernetOneDriver]; network: Network _ GetNthDeviceLikeMe[physicalOrder]; IF network = NIL THEN RETURN[FALSE]; him _ LOOPHOLE[PrincOpsUtils.GlobalFrame[network.interrupt]]; him.EthernetOneListenForHost[newHostNumber]; RETURN[TRUE]; END; EthernetOneListenForHost: PROCEDURE [newHostNumber: CARDINAL] = BEGIN myEar _ newHostNumber; SmashCSBs[]; END; GetNthDeviceLikeMe: PROCEDURE [physicalOrder: CARDINAL] RETURNS [net: Network] = BEGIN 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; END; SetEthernetOneCollectGarbageToo: PUBLIC ENTRY PROCEDURE [ physicalOrder: CARDINAL, collectGarbage: BOOLEAN] RETURNS [success: BOOLEAN] = BEGIN him: POINTER TO FRAME[EthernetOneDriver]; network: Network _ GetNthDeviceLikeMe[physicalOrder]; IF network = NIL THEN RETURN[FALSE]; him _ LOOPHOLE[PrincOpsUtils.GlobalFrame[network.interrupt]]; him.SetCollectGarbageToo[collectGarbage]; RETURN[TRUE]; END; SetCollectGarbageToo: PROCEDURE [collectGarbage: BOOLEAN] = BEGIN getGarbage _ collectGarbage; END; SmashCSBs: PROCEDURE = BEGIN b: Buffer; TurnOn[ether, myEar, inInterruptMask, outInterruptMask, globalStatePtr]; FOR b _ firstInputBuffer, b.next UNTIL b = NIL DO QueueInput[ ether, @b.encapsulation + ethernetEncapsulationOffset, b.length - ethernetEncapsulationOffset, b.iocbChain]; ENDLOOP; timeLastRecv _ ProcessorFace.GetClockPulses[]; END; DeleteDriver: PROCEDURE = BEGIN IF ether # GetNextDevice[nullDeviceHandle] THEN LoadState.SelfDestruct[]; END; DeactivateDriver: PROCEDURE = BEGIN 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; DeleteCache[]; END; KillInterruptRoutines: ENTRY PROCEDURE = INLINE BEGIN NOTIFY inWait^; NOTIFY outWait^; END; KillDriverLocked: ENTRY PROCEDURE = INLINE BEGIN NOTIFY timer; END; -- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -- Ugly thing to take care of handling the Ethernet1 (it uses 8 bit addresses). -- This will go away when OIS Communications stops using Ethernet1's. -- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -- types OisAddr: TYPE = NSAddress.HostNumber; Ethernet1Addr: TYPE = DriverTypes.Byte; 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: BOOLEAN; lastTranslationTime: ProcessorFace.GreenwichMeanTime; receiveAck: PROCEDURE [b: Buffer] _ InactiveReceiveAck; translate: PROCEDURE [OisAddr] RETURNS [BOOLEAN, Ethernet1Addr] _ InactiveTranslate; etherHost: Ethernet1Addr; oisHost: OisAddr; -- interface CreateCache: ENTRY PROCEDURE = INLINE BEGIN cacheQueueHead _ broadCastPairEntry _ myAddressPairEntry _ NIL; translate _ InactiveTranslate; receiveAck _ InactiveReceiveAck; demonRunning _ FALSE; [, etherHost] _ GetEthernet1Address[ether]; oisHost _ NSAddress.GetProcessorID[]; END; StartCache: ENTRY PROCEDURE = INLINE BEGIN etherHost: Ethernet1Addr; oisHost: OisAddr _ NSAddress.GetProcessorID[]; aP: AddressPair _ [NSAddress.broadcastHostNumber, PupTypes.allHosts, 0]; [, etherHost] _ GetEthernet1Address[ether]; translate _ Translate; receiveAck _ ReceiveAck; Process.SetTimeout[@cacheEvent, demonActiveTime]; broadCastPairEntry _ AddAddressPair[aP]; aP _ [oisHost, etherHost, 0]; myAddressPairEntry _ AddAddressPair[aP]; demonRunning _ TRUE; Process.Detach[FORK Demon[]]; END; DeleteCache: PROCEDURE = INLINE BEGIN e: CacheEntry; DeleteCacheLocked: ENTRY PROCEDURE = INLINE BEGIN NOTIFY cacheEvent; END; -- 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];-- ENDLOOP; END; -- assume protection by lock depth: CARDINAL; FindEntry: INTERNAL PROCEDURE [oisAddr: OisAddr] RETURNS [entry: CacheEntry] = BEGIN IF doStats THEN depth _ 0; entry _ cacheQueueHead; WHILE entry # NIL DO IF oisAddr = entry.addressPair.oisAddr THEN RETURN; entry _ entry.nextLink; IF doStats THEN depth _ depth + 1; ENDLOOP; END; -- assume protection by lock AddEntry: INTERNAL PROCEDURE [entry: CacheEntry] = BEGIN entry.nextLink _ cacheQueueHead; cacheQueueHead _ entry; END; -- assume protection by lock RemoveEntry: INTERNAL PROCEDURE [entry: CacheEntry] = BEGIN e, pred: CacheEntry; IF (pred _ cacheQueueHead) = entry THEN BEGIN cacheQueueHead _ cacheQueueHead.nextLink; RETURN; END; e _ pred.nextLink; WHILE e # NIL DO IF e = entry THEN BEGIN pred.nextLink _ entry.nextLink; RETURN; END; pred _ e; e _ pred.nextLink; ENDLOOP; ERROR; -- entry not found END; InactiveTranslate: PROCEDURE [oisAddr: OisAddr] RETURNS [foundIt: BOOLEAN, ethernet1Addr: Ethernet1Addr] = BEGIN StartCache[]; [foundIt, ethernet1Addr] _ Translate[oisAddr]; END; -- locks Translate: ENTRY PROCEDURE [oisAddr: OisAddr] RETURNS [foundIt: BOOLEAN, ethernet1Addr: Ethernet1Addr] = BEGIN e: CacheEntry; foundIt _ FALSE; lastTranslationTime _ ProcessorFace.GetGreenwichMeanTime[]; IF (e _ FindEntry[oisAddr]) # NIL THEN BEGIN IF e # cacheQueueHead THEN -- put e at the head of the queue BEGIN IF doStats THEN StatBump[cacheDepth, depth]; RemoveEntry[e]; AddEntry[e]; END; SELECT e.status FROM active => BEGIN foundIt _ TRUE; ethernet1Addr _ e.addressPair.ethernet1Addr; e.timeStamp _ lastTranslationTime; END; zombie => BEGIN e.status _ new; e.tries _ 0; e.timeStamp _ lastTranslationTime; NOTIFY cacheEvent; END; ENDCASE => NULL; END -- of found it ELSE -- entry not found, so add a new one BEGIN IF doStats THEN StatIncr[cacheFault]; e _ NEW[CacheObject]; e.status _ new; e.tries _ 0; e.timeStamp _ lastTranslationTime; e.addressPair _ [oisAddr: oisAddr, ethernet1Addr:, filler:]; AddEntry[e]; NOTIFY cacheEvent; END; END; -- assume protection by lock AddAddressPair: INTERNAL PROCEDURE [aP: AddressPair] RETURNS [e: CacheEntry] = BEGIN IF (e _ FindEntry[aP.oisAddr]) = NIL THEN BEGIN e _ NEW[CacheObject]; AddEntry[e]; END; e.addressPair _ aP; e.status _ active; e.timeStamp _ ProcessorFace.GetGreenwichMeanTime[]; END; -- assume protection by lock DeallocateEntry: INTERNAL PROCEDURE [e: CacheEntry] = BEGIN -- there are two entries that we do not want to throw out!! IF (e = broadCastPairEntry) OR (e = myAddressPairEntry) THEN e.timeStamp _ ProcessorFace.GetGreenwichMeanTime[] ELSE BEGIN RemoveEntry[e]; --Heap.FreeNode[p: e];-- END; END; -- locks Demon: ENTRY PROCEDURE = BEGIN 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: BOOLEAN; 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 => BEGIN IF t > deactivateTime THEN DeallocateEntry[e]; END; pending => BEGIN pendingEntries _ TRUE; IF t > retryTime THEN BEGIN e.tries _ e.tries + 1; IF e.tries > retryLimit THEN BEGIN e.status _ zombie; IF doStats THEN StatIncr[unsuccessfulTranslation]; END ELSE BEGIN IF doStats THEN StatIncr[translationRetries]; SendRequest[e]; e.timeStamp _ ProcessorFace.GetGreenwichMeanTime[]; END; END; END; new => BEGIN pendingEntries _ TRUE; SendRequest[e]; e.status _ pending; e.timeStamp _ ProcessorFace.GetGreenwichMeanTime[]; END; 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 _ InactiveReceiveAck; translate _ InactiveTranslate; e _ cacheQueueHead; cacheQueueHead _ myAddressPairEntry _ broadCastPairEntry _ NIL; WHILE e # NIL DO nextE _ e.nextLink; --Heap.FreeNode[p: e];-- e _ nextE; ENDLOOP; demonRunning _ FALSE; END; -- assume locked SendRequest: INTERNAL PROCEDURE [e: CacheEntry] = BEGIN b: Buffer; request: LONG POINTER TO AddressPair; IF (b _ DriverDefs.GetInputBuffer[]) # NIL THEN BEGIN -- broadcast the trnslation request b.encapsulation _ [ethernetOne[ etherSpare1:, etherSpare2:, etherSpare3:, etherSpare4:, etherSpare5:, translationWorked:, ethernetOneDest: PupTypes.allHosts, ethernetOneSource: myNetwork.hostNumber, ethernetOneType: translation]]; b.length _ (1 + ethernetEncapsulationBytes)/2 + 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]; END; END; -- locks -- we now own buffer b InactiveReceiveAck: PROCEDURE [b: Buffer] = BEGIN b.requeueProcedure[b]; END; ReceiveAck: ENTRY PROCEDURE [b: Buffer] = BEGIN IF b.encapsulation.ethernetOneDest = myAddressPairEntry.addressPair.ethernet1Addr THEN BEGIN receipt: LONG POINTER TO AddressPair _ LOOPHOLE[@b.rawWords[1]]; [] _ AddAddressPair[receipt^]; END; b.requeueProcedure[b]; END; -- locks -- we now own buffer b ReceiveRequest: ENTRY PROCEDURE [b: Buffer] = BEGIN request, requesterAddr: LONG POINTER TO AddressPair; request _ LOOPHOLE[@b.rawWords[1]]; IF request.oisAddr = oisHost THEN BEGIN -- since the requester is probably going to talk to us, add his address before we take a fault requesterAddr _ request + SIZE[AddressPair]; [] _ AddAddressPair[requesterAddr^]; IF doStats THEN StatIncr[requestsForMe]; request.ethernet1Addr _ etherHost; SendAck[request^, b.encapsulation.ethernetOneSource, b]; -- we lose ownership of b END ELSE b.requeueProcedure[b]; END; -- assume protection by lock -- we now own buffer b SendAck: INTERNAL PROCEDURE [aP: AddressPair, to: DriverTypes.Byte, b: Buffer] = INLINE BEGIN response: LONG POINTER TO AddressPair; IF b # NIL THEN BEGIN b.encapsulation _ [ethernetOne[ etherSpare1:, etherSpare2:, etherSpare3:, etherSpare4:, etherSpare5:, translationWorked:, ethernetOneDest: to, ethernetOneSource: myNetwork.hostNumber, ethernetOneType: translation]]; b.length _ (1 + ethernetEncapsulationBytes)/2 + SIZE[AddressPair] + 1; b.rawWords[0] _ translationResponse; response _ LOOPHOLE[@b.rawWords[1]]; response^ _ aP; -- send it SendBufferInternal[b]; END; END; -- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -- End of Ethernet1 uglyness -- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * -- initialization Process.SetTimeout[@timer, Process.MsecToTicks[1000]]; IF CommFlags.doDebug THEN BEGIN debugPointer: LONG POINTER TO DriverDefs.GiantVector _ DriverDefs.GetGiantVector[]; debugPointer.currentInputBuffer _ @firstInputBuffer; debugPointer.nextInputBuffer _ @lastInputBuffer; debugPointer.currentOutputBuffer _ @firstOutputBuffer; END; END. -- EthernetOneDriver February 23, 1980 9:10 PM By forrest; Change PrincOpsUtilsDefs to PrincOpsUtils, and move EtherStatsInfo Type from AltoEthernetDefs (RIP) to inside here. April 18, 1980 3:00 AM By Murray; Face changes (and other Pilotization). May 19, 1980 10:20 AM By BLyon; DisableTimeout, SetTimeout, MsecToTicks, SetPriority imported from Process instead of CommUtilDefs. May 27, 1980 11:44 AM By BLyon; Added ethernet1 translation uglyness. August 1, 1980 4:24 PM By BLyon; 8bit->32bit net number Kludge in CreateDefaultEthernetsDrivers and use NSAddress.nullNetworkNumber instead of 0. August 13, 1980 1:13 PM By BLyon; added InputChainOK and OutputChainOK to insure the bodies of the two loops in Watcher are protected by the monitor lock. August 25, 1980 1:50 PM By BLyon; multiple ethernets now possible. August 28, 1980 12:50 PM By McJones; converted to PrincOpsUtils.AllocateNakedCondition. September 5, 1980 4:44 PM By HGM; use hearSelf, a switch to ignore boards even if they are there. September 17, 1980 4:41 PM By BLyon; added myNetwork.buffers stuff. October 20, 1980 4:04 PM By BLyon; added SetYourHostNumber & myEar for Ois peeking. October 22, 1980 9:57 AM By BLyon; let the inputter collect garbage packets. November 6, 1980 6:34 PM By BLyon; Records input time in buffer.time. November 11, 1980 10:33 AM By BLyon; No longer smashes myNetwork.netNumber in DeactivateDriver. February 13, 1981 3:46 PM By BLyon; zombie translation entries can be changed to new if needed AND Demon is started immediately and never dies AND stores the ethernetOneHostNumber. February 24, 1981 3:28 PM By BLyon; undid February 13 - demon is created when needed and goes away when not needed AND changed WatcherNotify to SmashCSBs and to NOTIFY inWait^ and outWait^. Ź>˜Jš œījĻkœœœEœœœĻĮ˜Ō­—…—–Ö—