<> <> <> <<>> <OISCP>EthernetOneDriver.mesa>> <> <> <> <> DIRECTORY Basics USING [bytesPerWord], BasicTime USING [GetClockPulses, MicrosecondsToPulses, Pulses], CommBuffer USING [Overhead], CommDriver USING [AllocBuffer, Buffer, FreeBuffer, GetNetworkChain, InsertReceiveProc, Network, RecvProc], CommDriverType USING [Encapsulation, ethernetOneBroadcastHost], Process USING [MsecToTicks, priorityForeground, SecondsToTicks, SetPriority, SetTimeout, Ticks], Pup USING [allHosts, Host, nullHost], XNS USING [broadcastHost, GetThisHost, Host]; XNSEthernetOneTranslation: CEDAR MONITOR LOCKS cH USING cH: Cache IMPORTS BasicTime, CommDriver, XNS, Process EXPORTS CommBuffer ~ { BYTE: TYPE ~ [0..100H); bytesPerWord: NAT ~ Basics.bytesPerWord; Buffer: TYPE ~ CommDriver.Buffer; Network: TYPE ~ CommDriver.Network; Encapsulation: PUBLIC TYPE ~ CommDriverType.Encapsulation; -- exported to CommBuffer thisHost: XNS.Host ~ XNS.GetThisHost[]; <> Pulses: TYPE ~ BasicTime.Pulses; MSecsToPulses: PROC [n: CARD] RETURNS[Pulses] ~ INLINE { RETURN [BasicTime.MicrosecondsToPulses[1000*n]] }; PulsesSince: PROC [then: Pulses] RETURNS[Pulses] ~ INLINE { RETURN [BasicTime.GetClockPulses[] - then] }; <> TranslationType: TYPE ~ MACHINE DEPENDENT RECORD [a, b: BYTE]; requestType: TranslationType ~ [010H, 041H]; replyType: TranslationType ~ [00eH, 038H]; HostPair: TYPE ~ MACHINE DEPENDENT RECORD [ nsHost: XNS.Host, pupHost: Pup.Host, filler: BYTE]; hostPairBytes: CARDINAL ~ bytesPerWord*SIZE[HostPair]; -- Should be BYTES[HostPair] TranslationPacketObject: TYPE ~ MACHINE DEPENDENT RECORD [ translationType: TranslationType, replier: HostPair, requestor: HostPair]; translationPacketBytes: CARDINAL ~ bytesPerWord*SIZE[TranslationPacketObject]; -- Should be BYTES[TranslationPacketObject]; Must be even! translationShortPacketBytes: CARDINAL ~ translationPacketBytes - hostPairBytes; -- CROCK: some old implementations send reply packets without the requestor field TranslationBuffer: TYPE ~ REF TranslationBufferObject; TranslationBufferObject: TYPE ~ MACHINE DEPENDENT RECORD [ ovh: CommBuffer.Overhead, translationType: TranslationType, replier: HostPair, requestor: HostPair]; <> numHashHeaders: CARDINAL ~ 101; HashIndex: TYPE ~ [0..numHashHeaders); Hash: PROC [nsHost: XNS.Host] RETURNS [HashIndex] ~ INLINE { RETURN [ nsHost.f MOD numHashHeaders ] }; Cache: TYPE ~ REF CacheObject; CacheObject: TYPE ~ MONITORED RECORD [ daemon: PROCESS, event: CONDITION, newPendingEntry: BOOL _ FALSE, sweepTime: Pulses, sendHead, sendTail: Buffer, broadcastHostEntry: CacheEntry, thisHostEntry: CacheEntry, pendingEntries: CacheEntry, validEntries: ARRAY HashIndex OF CacheEntry]; CacheEntry: TYPE ~ REF CacheEntryObject; CacheEntryObject: TYPE ~ RECORD [ next: CacheEntry, hosts: HostPair, whenToSend: Pulses, timeToLive: CARDINAL ]; UpToDate: PROC [eH: CacheEntry] RETURNS [BOOL] ~ INLINE { RETURN [eH.timeToLive > 0] }; <> pulsesPerSweep: Pulses _ MSecsToPulses[19000]; sweepTimeout: Process.Ticks _ Process.SecondsToTicks[20]; sweepsToLive: CARDINAL _ 6; pulsesPerResend: Pulses _ MSecsToPulses[230]; resendTimeout: Process.Ticks _ Process.MsecToTicks[250]; sendsToLive: CARDINAL _ 8; <> <> noTranslation: INT _ 0; notQuick: INT _ 0; GetEncapsulation: PROC [network: Network, nsHost: XNS.Host] RETURNS [Encapsulation] ~ { cH: Cache ~ NARROW[network.xns.translation]; eH: CacheEntry _ NIL; hashIndex: HashIndex ~ Hash[nsHost]; BEGIN <> IF (eH _ cH.validEntries[hashIndex]) # NIL THEN { IF (eH.hosts.nsHost = nsHost) AND UpToDate[eH] THEN GOTO Found; IF (eH _ eH.next) # NIL THEN { IF (eH.hosts.nsHost = nsHost) AND UpToDate[eH] THEN GOTO Found; NULL; -- more checks would go here ... }; }; IF nsHost = XNS.broadcastHost THEN { eH _ cH.broadcastHostEntry; GOTO Found }; IF nsHost = thisHost THEN { eH _ cH.thisHostEntry; GOTO Found }; notQuick _ notQuick.SUCC; IF (eH _ GetCacheEntry[cH, hashIndex, nsHost]) # NIL THEN GOTO Found; GOTO NotFound; EXITS Found => { TRUSTED { RETURN[ [ethernetOne[etherSpare1~0, etherSpare2~0, etherSpare3~0, etherSpare4~0, etherSpare5~0, ethernetOneDest~eH.hosts.pupHost, ethernetOneSource~network.pup.host, ethernetOneType~xns]] ] } }; NotFound => { noTranslation _ noTranslation.SUCC; TRUSTED { RETURN[ [ethernetOne[etherSpare1~0, etherSpare2~0, etherSpare3~0, etherSpare4~0, etherSpare5~0, ethernetOneDest~Pup.nullHost, ethernetOneSource~network.pup.host, ethernetOneType~translationFailed]] ] } }; END; }; GetCacheEntry: ENTRY PROC [cH: Cache, hashIndex: HashIndex, nsHost: XNS.Host] RETURNS [result: CacheEntry] ~ { <> eH, prevH: CacheEntry; <> eH _ cH.validEntries[hashIndex]; prevH _ NIL; WHILE eH # NIL DO IF eH.hosts.nsHost = nsHost THEN { IF UpToDate[eH] THEN { <> IF prevH # NIL THEN { prevH.next _ eH.next; eH.next _ cH.validEntries[hashIndex]; cH.validEntries[hashIndex] _ eH }; RETURN[eH] } ELSE { <> IF prevH # NIL THEN prevH.next _ eH.next ELSE cH.validEntries[hashIndex] _ eH.next; eH.timeToLive _ sendsToLive; eH.whenToSend _ BasicTime.GetClockPulses[]; eH.next _ cH.pendingEntries; cH.pendingEntries _ eH; cH.newPendingEntry _ TRUE; NOTIFY cH.event; RETURN[eH] }; }; prevH _ eH; eH _ eH.next ENDLOOP; <> FOR eH _ cH.pendingEntries, eH.next WHILE eH # NIL DO IF eH.hosts.nsHost = nsHost THEN RETURN [IF eH.hosts.pupHost # Pup.nullHost THEN eH ELSE NIL]; ENDLOOP; <> TRUSTED { cH.pendingEntries _ NEW[ CacheEntryObject _ [next~cH.pendingEntries, hosts~[nsHost~nsHost, pupHost~Pup.nullHost, filler~], whenToSend~BasicTime.GetClockPulses[], timeToLive~sendsToLive] ] }; cH.newPendingEntry _ TRUE; NOTIFY cH.event; RETURN[NIL] }; <> MakeRequest: PROC [cH: Cache, nsHost: XNS.Host, sendTo: Pup.Host _ Pup.allHosts] RETURNS [b: Buffer] ~ { <> <> bH: TranslationBuffer; b _ CommDriver.AllocBuffer[]; TRUSTED { bH _ LOOPHOLE[b] }; bH.translationType _ requestType; bH.replier _ [nsHost~nsHost, pupHost~Pup.nullHost, filler~0]; bH.requestor _ cH.thisHostEntry.hosts; TRUSTED { bH.ovh.encap _ Encapsulation[ethernetOne[etherSpare1~0, etherSpare2~0, etherSpare3~0, etherSpare4~0, etherSpare5~0, ethernetOneDest~sendTo, ethernetOneSource~cH.thisHostEntry.hosts.pupHost, ethernetOneType~translation]] }; }; ConvertToReply: PROC [cH: Cache, bH: TranslationBuffer] ~ { <> <> bH.translationType _ replyType; bH.replier _ cH.thisHostEntry.hosts; TRUSTED { bH.ovh.encap _ Encapsulation[ethernetOne[etherSpare1~0, etherSpare2~0, etherSpare3~0, etherSpare4~0, etherSpare5~0, ethernetOneDest~bH.requestor.pupHost, ethernetOneSource~cH.thisHostEntry.hosts.pupHost, ethernetOneType~translation]] }; }; <> AddTranslation: ENTRY PROC [cH: Cache, hosts: HostPair] ~ { eH, prevH: CacheEntry; i: HashIndex ~ Hash[hosts.nsHost]; IF hosts.pupHost = Pup.allHosts THEN RETURN; -- Sanity check <> eH _ cH.pendingEntries; prevH _ NIL; WHILE eH # NIL DO IF eH.hosts.nsHost = hosts.nsHost THEN { IF prevH = NIL THEN cH.pendingEntries _ eH.next ELSE prevH.next _ eH.next; eH.hosts.pupHost _ hosts.pupHost; EXIT }; prevH _ eH; eH _ eH.next ENDLOOP; <> IF eH = NIL THEN { eH _ cH.validEntries[i]; prevH _ NIL; WHILE eH # NIL DO IF eH.hosts.nsHost = hosts.nsHost THEN { IF prevH = NIL THEN cH.validEntries[i] _ eH.next ELSE prevH.next _ eH.next; <> IF eH.hosts.pupHost # hosts.pupHost THEN eH _ NIL; EXIT }; prevH _ eH; eH _ eH.next ENDLOOP; }; IF eH = NIL THEN eH _ NEW[ CacheEntryObject _ [next~, hosts~hosts, whenToSend~, timeToLive~]]; eH.timeToLive _ sweepsToLive; eH.next _ cH.validEntries[i]; cH.validEntries[i] _ eH; }; <> requestsReceived: INT _ 0; repliesReceived: INT _ 0; tooShort: INT _ 0; badProtocol: INT _ 0; RecvTranslation: CommDriver.RecvProc <<[network: Network, buffer: Buffer, bytes: NAT] RETURNS [Buffer]>> ~ { cH: Cache ~ NARROW[network.xns.translation]; bH: TranslationBuffer; <> IF bytes < translationShortPacketBytes THEN { tooShort _ tooShort.SUCC; RETURN [buffer] }; TRUSTED { bH _ LOOPHOLE[buffer] }; SELECT TRUE FROM bH.translationType = requestType => { <> IF bytes < translationPacketBytes THEN { tooShort _ tooShort.SUCC; RETURN [buffer] }; IF bH.replier.nsHost = thisHost THEN { requestsReceived _ requestsReceived.SUCC; AddTranslation[cH, bH.requestor]; ConvertToReply[cH, bH]; EnqueueForSending[cH, buffer]; buffer _ NIL; }; }; bH.translationType = replyType => { repliesReceived _ repliesReceived.SUCC; AddTranslation[cH, bH.replier]; }; ENDCASE => { badProtocol _ badProtocol.SUCC }; RETURN[buffer]; }; <> EnqueueForSending: ENTRY PROC [cH: Cache, b: Buffer] ~ { IF cH.sendHead = NIL THEN cH.sendHead _ b ELSE cH.sendTail.ovh.next _ b; cH.sendTail _ b; b.ovh.next _ NIL; NOTIFY cH.event }; InternalEnqueueForSending: INTERNAL PROC [cH: Cache, b: Buffer] ~ { IF cH.sendHead = NIL THEN cH.sendHead _ b ELSE cH.sendTail.ovh.next _ b; cH.sendTail _ b; b.ovh.next _ NIL; NOTIFY cH.event }; DequeueForSending: ENTRY PROC [cH: Cache] RETURNS [b: Buffer] ~ { IF (b _ cH.sendHead) = NIL THEN RETURN; IF (cH.sendHead _ NARROW[b.ovh.next]) = NIL THEN cH.sendTail _ NIL; }; InternalSendQueueIsEmpty: INTERNAL PROC [cH: Cache] RETURNS [BOOL] ~ INLINE { RETURN [cH.sendHead = NIL] }; WaitAndScanCache: ENTRY PROC [cH: Cache] ~ { eH, prevH: CacheEntry; IF InternalSendQueueIsEmpty[cH] AND NOT cH.newPendingEntry THEN { TRUSTED { IF cH.pendingEntries # NIL THEN Process.SetTimeout[@cH.event, resendTimeout] ELSE Process.SetTimeout[@cH.event, sweepTimeout] }; WAIT cH.event }; prevH _ NIL; eH _ cH.pendingEntries; WHILE eH # NIL DO IF PulsesSince[eH.whenToSend] >= 0 THEN { IF eH.timeToLive = 0 THEN { <> eH _ eH.next; IF prevH = NIL THEN cH.pendingEntries _ eH ELSE prevH.next _ eH; LOOP }; { <> destHost: Pup.Host ~ IF (eH.timeToLive > (sendsToLive/2)) AND (eH.hosts.pupHost # Pup.nullHost) THEN eH.hosts.pupHost ELSE Pup.allHosts; buffer: Buffer ~ MakeRequest[cH, eH.hosts.nsHost, destHost]; InternalEnqueueForSending[cH, buffer]; eH.timeToLive _ eH.timeToLive - 1; eH.whenToSend _ BasicTime.GetClockPulses[] + pulsesPerResend; }; }; prevH _ eH; eH _ eH.next; ENDLOOP; cH.newPendingEntry _ FALSE; IF PulsesSince[cH.sweepTime] >= pulsesPerSweep THEN { <> FOR i: HashIndex IN [0..numHashHeaders) DO FOR eH _ cH.validEntries[i], eH.next WHILE eH # NIL DO IF eH.timeToLive > 0 THEN eH.timeToLive _ eH.timeToLive - 1; ENDLOOP; ENDLOOP; cH.sweepTime _ BasicTime.GetClockPulses[]; }; }; Daemon: PROC [network: Network] ~ { cH: Cache ~ NARROW[ network.xns.translation ]; buffer: Buffer; Process.SetPriority[Process.priorityForeground]; DO WaitAndScanCache[cH]; WHILE (buffer _ DequeueForSending[cH]) # NIL DO network.xns.sendTranslate[network, buffer, translationPacketBytes]; CommDriver.FreeBuffer[buffer]; ENDLOOP; ENDLOOP; }; <> Init: PROC = { <> cH: Cache; FOR network: Network _ CommDriver.GetNetworkChain[], network.next UNTIL network = NIL DO IF network.type # ethernetOne THEN LOOP; cH _ NEW[ CacheObject _ [sweepTime~BasicTime.GetClockPulses[]] ]; cH.broadcastHostEntry _ NEW[ CacheEntryObject _ [hosts~[nsHost~XNS.broadcastHost, pupHost~CommDriverType.ethernetOneBroadcastHost, filler~], whenToSend~, timeToLive~] ]; cH.thisHostEntry _ NEW[ CacheEntryObject _ [hosts~[nsHost~thisHost, pupHost~network.pup.host, filler~], whenToSend~, timeToLive~] ]; network.xns.translation _ cH; network.xns.getEncapsulation _ GetEncapsulation; CommDriver.InsertReceiveProc[network~network, type~xnsTranslate, proc~RecvTranslation]; cH.daemon _ FORK Daemon[network]; ENDLOOP; }; TryHost: PROC [nsHost: XNS.Host] ~ { FOR network: Network _ CommDriver.GetNetworkChain[], network.next UNTIL network = NIL DO IF network.type = ethernetOne THEN { [] _ GetEncapsulation[network, nsHost]; EXIT }; ENDLOOP; }; TryLogan: PROC ~ { TryHost[ [a~02H, b~60H, c~8cH, d~00H, e~34H, f~48H] ] }; TryHubbard: PROC ~ { TryHost[ [a~02H, b~60H, c~8cH, d~10H, e~89H, f~25H] ] }; Try: PROC [n: LONG CARDINAL] = TRUSTED { t1: MACHINE DEPENDENT RECORD [b, c: CARDINAL]; t2: MACHINE DEPENDENT RECORD [a, b, c: CARDINAL]; t1 _ LOOPHOLE[n]; t2.a _ 0; t2.b _ t1.c; t2.c _ t1.b; TryHost[ LOOPHOLE[t2] ]; }; Init[]; }.