DIRECTORY
BufferDefs USING[ Buffer ],
DebuggerFormat USING[ LabelChecksum ],
DiskFace USING[ Label, Type ],
PrincOps,
Process USING[ EnableAborts ],
PupDefs USING[ GetFreePupBuffer, GetPupAddress, GetPupContentsBytes, MsToTocks, PupBuffer, PupNameTrouble, PupPackageDestroy, PupPackageMake, PupSocket, PupSocketDestroy, PupSocketMake, ReturnFreePupBuffer, SetPupContentsWords ],
PupTypes USING[ fillInSocketID, Pair, PupAddress, PupType ],
Rope USING[ ROPE ],
TeledebugProtocol,
WorldVM USING[ ],
WVMPrivate;

WVMRemote: MONITOR
IMPORTS DebuggerFormat, Process, PupDefs
EXPORTS WorldVM, WVMPrivate = {

Machine: PUBLIC TYPE = PupTypes.PupAddress;


ReadRemoteCore: PUBLIC PROC[host: Machine, data: REF WVMPrivate.PageData, mempage: WVMPrivate.PageNumber] RETURNS[map: WVMPrivate.MapEntry, ok: BOOL] = {
in: LONG POINTER TO TeledebugProtocol.CoreFetchAcknowledgement;
out: LONG POINTER TO TeledebugProtocol.CoreFetchRequest;
Lock[host];
DO ENABLE UNWIND => Unlock[];
p: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
out _ LOOPHOLE[@p.pupWords];
out^ _ [page: mempage];
p _ SendAndReceive[p, TeledebugProtocol.coreFetchRequest,
TeledebugProtocol.coreFetchRequestSize];
in _ LOOPHOLE[@p.pupWords];
IF PupWords[p] # TeledebugProtocol.coreFetchAcknowledgementSize
OR WVMPrivate.PageNumber[in.page] # mempage
THEN { PupDefs.ReturnFreePupBuffer[p]; LOOP };
data^ _ LOOPHOLE[in.data, WVMPrivate.PageData];
map.state.flags _ LOOPHOLE[in.flags, PrincOps.PageState].flags;
PupDefs.ReturnFreePupBuffer[p];
ok _ LOOPHOLE[in.flags, PrincOps.PageState].flags#PrincOps.flagsVacant;
EXIT
ENDLOOP;
Unlock[];
};

WriteRemoteCore: PUBLIC PROC[host: Machine, data: REF WVMPrivate.PageData, mempage: WVMPrivate.PageNumber, map: WVMPrivate.MapEntry] RETURNS[readOnly: BOOL] = {
in: LONG POINTER TO TeledebugProtocol.CoreStoreAcknowledgement;
out: LONG POINTER TO TeledebugProtocol.CoreStoreRequest;
readOnly _ map.state.flags.readonly;
IF NOT readOnly THEN map.state.flags.dirty _ TRUE;
Lock[host];
DO ENABLE UNWIND => Unlock[];
p: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
out _ LOOPHOLE[@p.pupWords];
out.page _ mempage;
out.flags _ LOOPHOLE[map.state.flags];
LOOPHOLE[@out.data, LONG POINTER TO WVMPrivate.PageData]^ _ data^;
p _ SendAndReceive[p, TeledebugProtocol.coreStoreRequest,
TeledebugProtocol.coreStoreRequestSize];
in _ LOOPHOLE[@p.pupWords];
IF PupWords[p] # TeledebugProtocol.coreStoreAcknowledgementSize
OR WVMPrivate.PageNumber[in.page] # mempage
THEN { PupDefs.ReturnFreePupBuffer[p]; LOOP };
IF in.flags#LOOPHOLE[map.state.flags, WORD] THEN ERROR;
PupDefs.ReturnFreePupBuffer[p];
EXIT;
ENDLOOP;
Unlock[];
};

ClientDiskTellsLies: ERROR = CODE;

ReadRemoteDisk: PUBLIC PROC[host: Machine, data: REF WVMPrivate.PageData, addr: WVMPrivate.DiskAddress, label: LONG POINTER TO DiskFace.Label] = {
in: LONG POINTER TO TeledebugProtocol.DiskFetchAcknowledgement;
out: LONG POINTER TO TeledebugProtocol.DiskAddressSetRequest;
Lock[host];
DO ENABLE UNWIND => Unlock[];
p: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
out _ LOOPHOLE[@p.pupWords];
out^ _ [addr.diskPage + addr.offset, addr.deviceType, addr.deviceOrdinal];
p _ SendAndReceive[p, TeledebugProtocol.diskFetchRequest,
TeledebugProtocol.diskAddressSetRequestSize];
IF PupWords[p] # TeledebugProtocol.diskFetchAcknowledgementSize
THEN { PupDefs.ReturnFreePupBuffer[p]; LOOP };
in _ LOOPHOLE[@p.pupWords];
IF data # NIL THEN data^ _ LOOPHOLE[in.data, WVMPrivate.PageData];
label^ _ LOOPHOLE[in.label, DiskFace.Label];
PupDefs.ReturnFreePupBuffer[p];
IF addr.labelCheck # DebuggerFormat.LabelChecksum[label^, addr.offset]
THEN ERROR ClientDiskTellsLies[];
EXIT
ENDLOOP;
Unlock[];
};

WriteRemoteDisk: PUBLIC PROC[host: Machine, data: REF WVMPrivate.PageData, addr: WVMPrivate.DiskAddress, label: LONG POINTER TO DiskFace.Label] = {
p: PupDefs.PupBuffer;
in: LONG POINTER TO TeledebugProtocol.DiskStoreAcknowledgement;
out: LONG POINTER TO TeledebugProtocol.DiskStoreRequest;
Lock[host];
DO ENABLE UNWIND => Unlock[];
SetDiskAddress[addr.deviceType, addr.deviceOrdinal, addr.diskPage + addr.offset];
p _ PupDefs.GetFreePupBuffer[];
out _ LOOPHOLE[@p.pupWords];
LOOPHOLE[@out.label, LONG POINTER TO DiskFace.Label]^ _ label^;
LOOPHOLE[@out.data, LONG POINTER TO WVMPrivate.PageData]^ _ data^;
p _ SendAndReceive[p, TeledebugProtocol.diskStoreRequest,
TeledebugProtocol.diskStoreRequestSize];
IF PupWords[p] # TeledebugProtocol.diskStoreAcknowledgementSize
THEN { PupDefs.ReturnFreePupBuffer[p]; LOOP };
in _ LOOPHOLE[@p.pupWords];
IF in.label = TeledebugProtocol.noLabel THEN ERROR ClientDiskTellsLies[];
PupDefs.ReturnFreePupBuffer[p];
EXIT
ENDLOOP;
Unlock[];
};

GoRemote: PUBLIC PROC[host: Machine] = {
p: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
Lock[host];
{
ENABLE UNWIND => Unlock[];
p _ SendAndReceive[p, TeledebugProtocol.go, 0];
p.pupID _ IncPair[p.pupID];
Send[p, TeledebugProtocol.goReply, 0];
};
Unlock[];
};

SetDiskAddress: PROC [device: DiskFace.Type, deviceOrdinal: CARDINAL, page: LONG CARDINAL] = {
in: LONG POINTER TO TeledebugProtocol.DiskAddressSetAcknowledgement;
out: LONG POINTER TO TeledebugProtocol.DiskAddressSetRequest;
DO p: PupDefs.PupBuffer _ PupDefs.GetFreePupBuffer[];
out _ LOOPHOLE[@p.pupWords];
out^ _ [page, device, deviceOrdinal];
p _ SendAndReceive[p, TeledebugProtocol.diskAddressSetRequest,
TeledebugProtocol.diskAddressSetRequestSize];
in _ LOOPHOLE[@p.pupWords];
IF PupWords[p] # TeledebugProtocol.diskAddressSetAcknowledgementSize 
OR in^ # [page, device, deviceOrdinal]
THEN { PupDefs.ReturnFreePupBuffer[p]; LOOP };
PupDefs.ReturnFreePupBuffer[p];
EXIT
ENDLOOP;
};



lastPupID: PupTypes.Pair _ [0, 0];

GetNextPupID: ENTRY PROC RETURNS [PupTypes.Pair] = INLINE {
RETURN[lastPupID_IncPair[IncPair[lastPupID]]]; };

IncPair: PROC [id: PupTypes.Pair] RETURNS [PupTypes.Pair] = INLINE {
OPEN id;
RETURN [[a+(IF b=LAST[CARDINAL] THEN 1 ELSE 0), b+1]];
};

PupWords: PROC [p: PupDefs.PupBuffer] RETURNS [CARDINAL] = INLINE {
w: CARDINAL = PupDefs.GetPupContentsBytes[p];
IF w MOD 2 # 0 THEN RETURN[LAST[CARDINAL]];
RETURN[w/2];
};

SendAndReceive: PROC [x: PupDefs.PupBuffer, t: PupTypes.PupType, words: CARDINAL] RETURNS [answer: PupDefs.PupBuffer] = {
requeued: BOOL _ TRUE;
done: CONDITION;
MyRequeue: ENTRY PROC[BufferDefs.Buffer] =
{ requeued _ TRUE; NOTIFY done };
WaitRequeue: ENTRY PROC =
{ ENABLE UNWIND => NULL; UNTIL requeued DO WAIT done ENDLOOP };
x.requeueProcedure _ MyRequeue;
x.pupID _ GetNextPupID[];
DO WaitRequeue[]; requeued _ FALSE; Send[x, t, words];
answer _ Receive[x.pupID ! ReceiveTimeout => LOOP];
EXIT
ENDLOOP;
WaitRequeue[]; PupDefs.ReturnFreePupBuffer[x];
};

Send: PROC [x: PupDefs.PupBuffer, t: PupTypes.PupType, words: CARDINAL] = {
x.pupType _ t;
PupDefs.SetPupContentsWords[x, words];
socket.put[x];
};

ReceiveTimeout: ERROR = CODE;
getMeAPup: CONDITION;
receivedPup: PupDefs.PupBuffer;
wantPup: BOOL; 

Receive: ENTRY PROC[thisPupID: PupTypes.Pair] RETURNS [PupDefs.PupBuffer] = {
ENABLE UNWIND => NULL;
DO wantPup _ TRUE;
receivedPup _ NIL;
WAIT getMeAPup;
IF receivedPup=NIL THEN RETURN WITH ERROR ReceiveTimeout;
IF receivedPup.pupID = thisPupID THEN RETURN[receivedPup];
PupDefs.ReturnFreePupBuffer[receivedPup];
ENDLOOP;
};

keepReceiving: BOOL;

ReceiveProcess: PROC = {
x: PupDefs.PupBuffer;
Pass: ENTRY PROC = INLINE {
IF wantPup
THEN { wantPup _ FALSE; receivedPup _ x; NOTIFY getMeAPup }
ELSE PupDefs.ReturnFreePupBuffer[x];
};
Notify: ENTRY PROC = INLINE {NOTIFY getMeAPup};
Like: PROC RETURNS [BOOL] = INLINE {
RETURN [
x.source = remote AND x.dest = socket.getLocalAddress[] AND
x.pupType = TeledebugProtocol.acknowledgement];
};
WHILE keepReceiving DO
x _ socket.get[];
IF x = NIL
THEN Notify[] -- timeout
ELSE IF Like[] THEN Pass[] ELSE PupDefs.ReturnFreePupBuffer[x];
ENDLOOP;
};




locked: BOOL _ FALSE;
unlocked: CONDITION;

socket: PupDefs.PupSocket;
remote: PupTypes.PupAddress;

Lock: ENTRY PROC[host: Machine] = {
ENABLE UNWIND => NULL;
WHILE locked DO WAIT unlocked ENDLOOP; locked _ TRUE;
socket.setRemoteAddress[remote _ host];
};

Unlock: ENTRY PROC = { locked _ FALSE; NOTIFY unlocked };

LookupFailed: PUBLIC ERROR = CODE;

LocateRemote: PUBLIC PROC [name: Rope.ROPE] RETURNS[ host: Machine ] = {
host _ PupDefs.GetPupAddress[TeledebugProtocol.teleSwatSocket, name !
PupDefs.PupNameTrouble => ERROR LookupFailed[] ];
};

receiveProcess: PROCESS;

StartTeledebugging: PROC = {
PupDefs.PupPackageMake[];
Process.EnableAborts[@getMeAPup];
remote.net _ [0]; remote.host _ [0];
socket _ PupDefs.PupSocketMake[
local: PupTypes.fillInSocketID, remote: remote,
ticks: PupDefs.MsToTocks[500] ];
keepReceiving _ TRUE; wantPup _ FALSE;
receiveProcess _ FORK ReceiveProcess;
Unlock[];
};

StopTeledebugging: PROC = {
Lock[remote];
keepReceiving _ FALSE; JOIN receiveProcess;
PupDefs.PupSocketDestroy[socket];
PupDefs.PupPackageDestroy[];
};

StartTeledebugging[];

}.



ξWVMRemote.mesa - TeleDebug protocol
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Andrew Birrell  July 29, 1983 3:56 pm
Russ Atkinson, February 6, 1985 9:37:28 pm PST
Public procedures
Sending diskFetchRequest with diskAddressSetRequestSize causes
a combined addressSet and diskFetch. (I didn't design it!)
Actual packet transmission/reception! --
first level of screening (don't care about others)
There is only one socket, protected by Lock/Unlock during remote calls --
Κ
Φ˜
codeš
œ#™#Kšœ
Οm
œ1™<Kš
œ%™%K™.—K˜š
Οk	˜	Kšœžœ˜Kšœžœ˜&Kšœ	žœ˜K˜	Kšœžœ˜KšœžœΨ
˜ε
Kšœ	žœ.˜<Kšœžœžœ˜K˜Kšœžœ˜K˜K˜—šœž˜Kšžœ!˜(Kšžœ˜—K˜Kšœ	žœ
žœ˜+K˜Kš
œ™K˜šΟnœžœ
žœžœ5žœžœž
œ
˜™
Kšœžœ
žœ
žœ,˜?Kšœžœ
žœ
žœ$˜8K˜šžœ
žœ
žœ
˜K˜2Kšœžœ˜K˜˜9K˜(—Kšœžœ˜šžœ=˜?Kšžœ)˜+Kšžœ#žœ˜.—Kšœžœ˜/Kšœžœ%˜?K˜Kšœžœ:˜GKš
ž˜—Kšžœ
˜K˜	Kš
œ˜K˜—šŸœžœ
žœžœPžœžœ˜ 
Kšœžœ
žœ
žœ,˜?Kšœžœ
žœ
žœ$˜8Kš
œ$˜$Kšžœ
žœ
žœžœ
˜2K˜šžœ
žœ
žœ
˜K˜2Kšœžœ˜K˜Kšœžœ˜&Kšžœžœ
žœ
žœ˜B˜9K˜(—Kšœžœ˜Kšžœ=˜?Kšžœ)˜+Kšžœ#žœ˜.Kš
žœ
žœžœžœ
žœ
˜7K˜Kšžœ
˜—Kšžœ
˜K˜	Kš
œ˜K˜—Kšœžœžœ
˜"K˜šŸœžœ
žœžœ;žœ
žœ
žœ˜’
Kšœžœ
žœ
žœ,˜?Kšœžœ
žœ
žœ)˜=K˜šžœ
žœ
žœ
˜K˜2Kšœžœ˜K˜JKš
œ>™>Kš
œ:™:˜9K˜-—Kšžœ=˜?Kšžœ#žœ˜.Kšœžœ˜Kšžœžœ
žœ	žœ˜BKšœ	žœ˜,K˜KšžœD˜FKšžœ
žœ˜!Kš
ž˜—Kšžœ
˜K˜	Kš
œ˜K˜—šŸœžœ
žœžœ;žœ
žœ
žœ˜“
K˜Kšœžœ
žœ
žœ,˜?Kšœžœ
žœ
žœ$˜8K˜šžœ
žœ
žœ
˜K˜QK˜Kšœžœ˜Kšžœ
žœ
žœ
žœ˜?Kšžœžœ
žœ
žœ˜B˜9K˜(—Kšžœ=˜?Kšžœ#žœ˜.Kšœžœ˜Kšžœ&žœ
žœ˜IK˜Kš
ž˜—Kšžœ
˜K˜	Kš
œ˜K˜—šŸœžœ
žœ˜(K˜2K˜š
œ
˜
Kšžœ
žœ
˜K˜/K˜K˜&Kš
œ˜—K˜	Kš
œ˜K˜—š
Ÿœžœ(žœžœ
žœ˜^Kšœžœ
žœ
žœ1˜DKšœžœ
žœ
žœ)˜=šžœ3˜5Kšœžœ˜K˜%˜>K˜-—Kšœžœ˜KšžœC˜EKšžœ$˜&Kšžœ#žœ˜.K˜Kš
ž˜—Kšžœ
˜Kš
œ˜K˜K˜—Kš
œ(™(K˜K˜"K˜š
Ÿœžœ
žœ
žœžœ˜;Kšžœ+˜1K˜—šŸœžœžœžœ˜DKšžœ˜Kšžœžœžœ
žœžœžœ˜6Kš
œ˜K˜—š
Ÿœžœžœžœžœ˜CKšœžœ"˜-Kšžœžœžœ
žœ
žœ
žœ˜+Kšžœ˜Kš
œ˜K˜—šŸœžœ4žœ
žœ ˜yKšœ
žœžœ
˜Kšœž	œ
˜šŸ	œžœ
žœ˜*Kšœ
žœžœ˜!—šŸœžœ
žœ˜Kšœžœ
žœžœžœ
žœ
žœžœ˜?—K˜K˜šžœžœ˜6Kšœ-žœ˜3Kš
ž˜—Kšžœ
˜K˜.Kš
œ˜K˜—šŸœžœ4žœ˜KK˜K˜&K˜Kš
œ˜K˜—Kšœžœžœ
˜Kšœž	œ
˜K˜Kšœ	žœ˜K˜š
Ÿœžœ
žœžœž
œ
˜MKšžœ
žœžœ
˜šžœžœ
˜Kšœžœ
˜Kšžœ˜Kšžœ
žœ
žœ
žœ
žœ
žœ˜9Kšžœžœ
žœ˜:K˜)—Kšžœ
˜Kš
œ˜K˜—Kšœžœ
˜K˜šŸœžœ˜K˜šŸœžœ
žœžœ˜Kšžœ˜
Kšžœ
žœžœ˜;Kšžœ ˜$Kš
œ˜—Kš
Ÿœžœ
žœžœžœ˜/š
Ÿœžœ
žœžœžœ˜$Kš
œ2™2šžœ˜Kšœžœ#ž˜;K˜/—Kš
œ˜—šžœž˜K˜Kšžœž˜
Kšžœ
Οc
˜Kšžœ
žœžœžœ ˜?—Kšžœ
˜Kš
œ˜K˜K˜K˜—Kš
œI™IK˜Kšœžœžœ
˜Kšœ
ž	œ
˜K˜K˜K˜K˜šŸœžœ
žœ˜#Kšžœ
žœžœ
˜Kš
žœžœ
žœ
žœžœ
˜5K˜'Kš
œ˜K˜—š
Ÿœžœ
žœžœžœ˜9K˜—Kšœžœ
žœžœ
˜"K˜š
Ÿœžœ
žœ
žœžœ˜Hš
œE˜EKšœžœ˜1—Kš
œ˜K˜—Kšœžœ
˜K˜šŸœžœ˜K˜K˜!K˜$˜K˜/K˜ —Kšœžœžœ
˜&Kšœžœ˜%K˜	Kš
œ˜K˜—šŸœžœ˜K˜
Kšœžœžœ˜+K˜!K˜Kš
œ˜K˜—K˜K˜Kš
œ˜K˜K˜—…—"~/B