-- File: Pup10MBitImpl.mesa - last edit:
-- AOF 30-Jul-85 14:54:58
-- HGM 7-Dec-85 18:25:26
-- Copyright (C) 1985 by Xerox Corporation. All rights reserved.
DIRECTORY
Buffer USING [Buffer, GetBuffer, Type],
CommFlags USING [doDebug],
CommHeap USING [zone],
Driver USING [Network],
DriverTypes USING [Encapsulation],
Process USING [
DisableTimeout, EnableAborts, SecondsToTicks, SetPriority,
SetTimeout, Abort],
ProcessPriorities USING [priorityIOHigh],
Protocol1 USING [EncapsulatorProc, DecapsulatorProc],
PupPktOps USING [pupBuffers],
Pup10MBit USING [],
PupRouterDefs USING [ContextObject, NetworkContext],
PupStream USING [],
PupTypes USING [allHosts, PupHostID],
SpecialSystem USING [GetProcessorID, HostNumber, ProcessorID],
System USING [
broadcastHostNumber, GetClockPulses, HostNumber, MicrosecondsToPulses,
nullHostNumber, Pulses];
Pup10MBitImpl: MONITOR
IMPORTS
Process, Buffer, PupPktOps, CommHeap, SpecialSystem, System
EXPORTS Buffer, Pup10MBit, System =
BEGIN
Network: PUBLIC TYPE = Driver.Network;
HostNumber: PUBLIC TYPE = SpecialSystem.HostNumber;
chain: Handle ← NIL;
Handle: PUBLIC TYPE = LONG POINTER TO Object;
Object: PUBLIC TYPE = RECORD[
depth: CARDINAL ← 0,
me, all, head: TranslateEntry ← NIL,
event: CONDITION,
demon: PROCESS ← NIL,
driver: Network,
next: Handle];
TranslatePair: TYPE = LONG POINTER TO TranslateRecord;
TranslateRecord: TYPE = MACHINE DEPENDENT RECORD [
nsAddr: HostNumber, pupHost: PupTypes.PupHostID, filler: [0..377B]];
TranslateEntry: TYPE = LONG POINTER TO TranslateObject;
TranslateObject: TYPE = RECORD [
nextLink: TranslateEntry,
translatePair: TranslateRecord,
tries: CARDINAL,
timeStamp: System.Pulses,
status: TranslateStatus];
TranslateStatus: TYPE = {new, pending, active, zombie};
--constants
retryLimit: CARDINAL = 10B;
retryPulses: System.Pulses ← System.MicrosecondsToPulses[2000000];
deactivatePulses: System.Pulses ← System.MicrosecondsToPulses[180000000];
translationRequest: CARDINAL = 10101B;
translationResponse: CARDINAL = 7070B;
myNSHost: SpecialSystem.ProcessorID = SpecialSystem.GetProcessorID[];
Capsulators: PUBLIC PROC RETURNS[
decap: Protocol1.DecapsulatorProc, encap: Protocol1.EncapsulatorProc] =
{RETURN[DecapsulatePupEthernet, EncapsulatePupEthernet]};
Create: PUBLIC PROC[driver: Network, host: PupTypes.PupHostID]
RETURNS[xlate: Handle] =
BEGIN
xlate ← CommHeap.zone.NEW[Object];
xlate.me ← xlate.all ← xlate.head ← NIL;
xlate.demon ← NIL;
xlate.driver ← driver;
xlate.next ← NIL;
Process.EnableAborts[@xlate.event];
xlate.all ← AddTranslateRecord[xlate,
[System.broadcastHostNumber, PupTypes.allHosts, 0]];
xlate.me ← AddTranslateRecord[xlate, [myNSHost, [host], 0]];
xlate.demon ← FORK Demon[driver, xlate];
IF chain = NIL THEN chain ← xlate
ELSE
FOR finger: Handle ← chain, finger.next DO
IF finger.next # NIL THEN LOOP;
finger.next ← xlate;
EXIT;
ENDLOOP;
END; --Create
Destroy: PUBLIC PROC[xlate: Handle] =
BEGIN
IF xlate.demon # NIL THEN {Process.Abort[xlate.demon]; JOIN xlate.demon};
--cleanup in case demon was never running
UNTIL xlate.head = NIL DO
e: TranslateEntry ← xlate.head;
xlate.head ← e.nextLink;
CommHeap.zone.FREE[@e];
ENDLOOP;
IF chain = xlate THEN chain ← chain.next
ELSE
FOR finger: Handle ← chain, finger.next UNTIL finger.next = NIL DO
IF finger.next # xlate THEN LOOP;
finger.next ← finger.next.next;
EXIT;
ENDLOOP;
END; --Delete
EncapsulatePupEthernet: PUBLIC Protocol1.EncapsulatorProc =
--EncapsulatorProc: TYPE = PROC[b: Buffer.Buffer, immediate: LONG POINTER];
BEGIN
OPEN context: LOOPHOLE[b.context, PupRouterDefs.NetworkContext];
destination: CARDINAL ← immediate↑;
nsAddr: HostNumber ← Translate[context.protocol, [destination]];
b.encapsulation ←
[ethernet[ethernetDest: nsAddr,
ethernetSource: myNSHost,
ethernetType: pup]];
b.driver.length ← (b.pup.pupLength + 1)/2 + SIZE[DriverTypes.Encapsulation];
END; --EncapsulatePupEthernet
DecapsulatePupEthernet: PUBLIC Protocol1.DecapsulatorProc =
--DecapsulatorProc: TYPE = PROC[b: Buffer.Buffer] RETURNS[Buffer.Type];
BEGIN
bytes: CARDINAL;
ecap: CARDINAL = SIZE[DriverTypes.Encapsulation];
IF b.driver.length < ecap THEN RETURN[orphan]; --bad no matter what
SELECT b.encapsulation.ethernetType FROM
translation => {ReceiveTranslate[b]; RETURN[orphan]}; --one of those
# pup => RETURN[vagrant]; --still unknown
ENDCASE;
bytes ← (b.driver.length - ecap)*2;
IF bytes < b.pup.pupLength THEN RETURN[orphan] ELSE RETURN[pup];
END; --DecapsulatePupEthernet
Translate: PUBLIC ENTRY PROC[xlate: Handle, pupHost: PupTypes.PupHostID]
RETURNS [nsAddr: HostNumber] =
BEGIN
e: TranslateEntry;
SELECT TRUE FROM
((e ← FindTranslate[xlate, pupHost]) = NIL) =>
BEGIN
e ← CommHeap.zone.NEW[TranslateObject];
AddTranslate[xlate, e];
e.translatePair.pupHost ← pupHost;
e.translatePair.nsAddr ← System.nullHostNumber;
NOTIFY xlate.event;
e.status ← new; e.tries ← 0;
nsAddr ← System.nullHostNumber;
e.timeStamp ← System.GetClockPulses[];
END;
(e.status = active) =>
BEGIN
IF e # xlate.head THEN
{RemoveTranslate[xlate, e]; AddTranslate[xlate, e]};
nsAddr ← e.translatePair.nsAddr;
e.timeStamp ← System.GetClockPulses[];
END;
(e.status = zombie) =>
BEGIN
IF e # xlate.head THEN
{RemoveTranslate[xlate, e]; AddTranslate[xlate, e]};
NOTIFY xlate.event;
e.status ← new; e.tries ← 0;
nsAddr ← System.nullHostNumber;
e.timeStamp ← System.GetClockPulses[];
END;
ENDCASE;
END;
--interface
FindTranslate: INTERNAL PROC[xlate: Handle, pupHost: PupTypes.PupHostID]
RETURNS [entry: TranslateEntry] =
BEGIN
entry ← xlate.head;
WHILE entry # NIL DO
IF pupHost = entry.translatePair.pupHost THEN RETURN;
entry ← entry.nextLink;
ENDLOOP;
END;
AddTranslate: INTERNAL PROC[xlate: Handle, entry: TranslateEntry] =
BEGIN
entry.nextLink ← xlate.head;
xlate.head ← entry;
xlate.depth ← xlate.depth + 1;
END; --AddTranslate
RemoveTranslate: INTERNAL PROC[xlate: Handle, entry: TranslateEntry] =
BEGIN
e, pred: TranslateEntry;
IF (pred ← xlate.head) = entry THEN
{xlate.head ← xlate.head.nextLink; RETURN};
FOR e ← pred.nextLink, e.nextLink UNTIL e = NIL DO
IF e # entry THEN pred ← e
ELSE
BEGIN
pred.nextLink ← entry.nextLink;
xlate.depth ← xlate.depth - 1;
EXIT;
END;
ENDLOOP;
END;
AddTranslateRecord: ENTRY PROC[xlate: Handle, pair: TranslateRecord]
RETURNS [e: TranslateEntry] =
BEGIN
e ← FindTranslate[xlate, pair.pupHost];
SELECT e FROM
(NIL) => {e ← CommHeap.zone.NEW[TranslateObject]; AddTranslate[xlate, e]};
(xlate.all), (xlate.me) => RETURN;
ENDCASE;
e.translatePair ← pair; e.status ← active;
e.timeStamp ← System.GetClockPulses[];
END;
Demon: ENTRY PROC[driver: Network, xlate: Handle] =
BEGIN
SendRequest: INTERNAL PROC[] =
BEGIN
b: Buffer.Buffer;
request: TranslatePair;
b ← Buffer.GetBuffer[, PupPktOps.pupBuffers, send, smallBuffer, FALSE];
IF b # NIL THEN
BEGIN
b.encapsulation ←
[ethernet[
ethernetDest: System.broadcastHostNumber,
ethernetSource: myNSHost,
ethernetType: translation]];
b.driver.length ← SIZE[DriverTypes.Encapsulation] +
2*SIZE[TranslateRecord] + 1;
b.rawWords[0] ← translationRequest;
request ← LOOPHOLE[@b.rawWords[1]];
request↑ ← e.translatePair;
--also send our addresses, so responder does not fault
request ← request + SIZE[TranslateRecord];
request↑ ← xlate.me.translatePair;
driver.sendRawBuffer[b];
END;
END; --SendRequest
age: System.Pulses;
e, nextE: TranslateEntry;
pendingEntries: BOOLEAN;
Process.SetPriority[ProcessPriorities.priorityIOHigh];
--UNTIL ABORTED-- DO
ENABLE ABORTED => EXIT;
WAIT xlate.event;
pendingEntries ← FALSE;
FOR e ← xlate.head, nextE UNTIL e = NIL DO
nextE ← e.nextLink;
age ← [System.GetClockPulses[] - e.timeStamp];
SELECT e.status FROM
active, zombie =>
BEGIN
SELECT TRUE FROM
(age <= deactivatePulses) => NULL;
(e = xlate.me) => e.timeStamp ← System.GetClockPulses[];
(e = xlate.all) => e.timeStamp ← System.GetClockPulses[];
ENDCASE => {RemoveTranslate[xlate, e]; CommHeap.zone.FREE[@e]};
END;
pending =>
BEGIN
SELECT TRUE FROM
(age < retryPulses) => NULL;
((e.tries ← e.tries + 1) > retryLimit) => e.status ← zombie;
ENDCASE => {SendRequest[]; e.timeStamp ← System.GetClockPulses[]};
pendingEntries ← TRUE;
END;
new =>
BEGIN
e.status ← pending;
SendRequest[]; e.timeStamp ← System.GetClockPulses[];
pendingEntries ← TRUE;
END;
ENDCASE => IF CommFlags.doDebug THEN ERROR;
ENDLOOP; --end of queue entries loop
IF ~pendingEntries THEN Process.DisableTimeout[@xlate.event]
ELSE Process.SetTimeout[@xlate.event, Process.SecondsToTicks[1]];
ENDLOOP;
FOR e ← xlate.head, nextE UNTIL e = NIL DO
nextE ← e.nextLink; CommHeap.zone.FREE[@e]; e ← nextE; ENDLOOP;
xlate.head ← xlate.me ← xlate.all ← NIL;
END; --Demon
ReceiveTranslate: PROC[b: Buffer.Buffer] =
BEGIN
OPEN context: LOOPHOLE[b.context, PupRouterDefs.NetworkContext];
xlate: Handle = context.protocol;
SELECT b.rawWords[0] FROM
translationRequest =>
BEGIN
a: Buffer.Buffer;
requesterAddr: TranslatePair;
request: TranslatePair ← LOOPHOLE[@b.rawWords[1]];
request ← LOOPHOLE[@b.rawWords[1]];
IF request.pupHost = xlate.me.translatePair.pupHost THEN
BEGIN
--since the requester is probably going to talk to us,
--add his address before we take a fault
requesterAddr ← request + SIZE[TranslateRecord];
[] ← AddTranslateRecord[xlate, requesterAddr↑];
request.nsAddr ← xlate.me.translatePair.nsAddr;
--send the ack back
a ← Buffer.GetBuffer[, PupPktOps.pupBuffers, send, smallBuffer, FALSE];
IF a = NIL THEN RETURN; --nothing going to happen here
a.encapsulation ← [
ethernet[
ethernetDest: b.encapsulation.ethernetSource,
ethernetSource: myNSHost, ethernetType: translation]];
a.driver.length ← SIZE[DriverTypes.Encapsulation] +
SIZE[TranslateRecord] + 1;
a.rawWords[0] ← translationResponse;
LOOPHOLE[@a.rawWords[1], TranslatePair]↑ ← request↑;
-- UNIX checks to see if the answer is "for it"
-- MIN length roundup sends the extra bits
LOOPHOLE[@a.rawWords[1+SIZE[TranslateRecord]], TranslatePair]↑ ← requesterAddr↑;
NARROW[b.network, Network].sendRawBuffer[a];
END;
END;
translationResponse =>
BEGIN
IF b.encapsulation.ethernetDest = xlate.me.translatePair.nsAddr THEN
[] ← AddTranslateRecord[xlate,
LOOPHOLE[@b.rawWords[1], TranslatePair]↑];
END;
ENDCASE;
END; --ReceiveTranslate
-- NB: There aren't any reasonable values of PupHostID to reserve for starting/stopping
-- So this routine is actually just a lookup.
-- If the entry doesn't exist (or is dead) nullHostNumber is returned.
EnumerateTranslation: PUBLIC ENTRY PROC [old: PupTypes.PupHostID, network: Driver.Network]
RETURNS[new: PupTypes.PupHostID, translation: System.HostNumber] =
BEGIN
entry: TranslateEntry;
translation ← System.nullHostNumber;
new ← old;
FOR xlate: Handle ← chain, xlate.next UNTIL xlate = NIL DO
IF xlate.driver # network THEN LOOP;
entry ← FindTranslate[xlate, old];
IF entry # NIL AND entry.status = active THEN translation ← entry.translatePair.nsAddr;
EXIT;
ENDLOOP
END;
END... --Pup10MBitImpl