<> <> <> <<>> <> <<>> <> <> <> <> <> <<>> <<>> DIRECTORY Camelot, IO USING [int, PutFR, PutFR1], Mach, Rope USING [Cat, Fetch, Length, ROPE]; <<>> CamelotImpl: CEDAR PROGRAM IMPORTS IO, Mach, Rope EXPORTS Camelot ~ BEGIN OPEN Camelot, Mach; <> DSInitialize: PUBLIC PROC [dsPort: portT, raiseSignal: BOOL] RETURNS [serverID: serverIdT, tsPort, mPort, sPort: portT, sharedMemAddr: vmAddressT, seqDescList: ListOfSegmentDesc _ NIL, seqPortList: ListOfPorts, kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> innerDSInitialize: PROC [idsPort: portT, iserverID: POINTER TO serverIdT, itsPort, imPort, isPort: POINTER TO portT, isharedMemAddr: POINTER TO vmAddressT, iseqDescList: POINTER TO segmentDescListT, isegDescListCnt: POINTER TO INT, iseqPortList: POINTER TO portArrayT, isegPortListCnt: POINTER TO INT] RETURNS [kernReturnT]~ TRUSTED MACHINE CODE { ".DS_Initialize" }; ZsegDescList, DsegDescList: segmentDescListT _ NIL; ZsegDescListCnt: INT _ -1; ZsegPortList, DsegPortList: portArrayT _ NIL; ZsegPortListCnt: INT _ -1; initCode: INT _ SendErrorsStart; initCode _ innerDSInitialize[dsPort, @serverID, @tsPort, @mPort, @sPort, @sharedMemAddr, @ZsegDescList, @ZsegDescListCnt, @ZsegPortList, @ZsegPortListCnt]; IF raiseSignal AND initCode # KernSuccess THEN SIGNAL MachCall[initCode, Rope.Cat["DS_Initialize failed; code = ", IO.PutFR1["%g", IO.int[initCode]]]]; IF ZsegDescListCnt # ZsegPortListCnt AND raiseSignal THEN SIGNAL MachCall[-1, IO.PutFR["DS_Initialize failed; different number of segments and ports = %g segments and %g ports", IO.int[ZsegDescListCnt], IO.int[ZsegPortListCnt]]]; IF ZsegDescListCnt > 0 THEN TRUSTED { newItem: PROC RETURNS [lsd: ListOfSegmentDesc] ~ TRUSTED { lsd _ LIST[[ZsegDescList.serverId, ZsegDescList.segmentId, ZsegDescList.logicalDisk, ZsegDescList.unused, ZsegDescList.highSize, ZsegDescList.lowSize]]; ZsegDescList _ ZsegDescList + UNITS[segmentDescT]; }; DsegDescList _ ZsegDescList; seqDescList _ newItem[]; IF ZsegDescListCnt > 1 THEN { lastItem: ListOfSegmentDesc _ seqDescList; FOR item: INT IN [1..ZsegDescListCnt) DO lastItem.rest _ newItem[]; lastItem _ lastItem.rest; ENDLOOP; }; [] _ vmDeallocate[targetTask: taskSelf[], address: LOOPHOLE[DsegDescList], size: BYTES[segmentDescT]*ZsegDescListCnt, raiseSignal: TRUE]; }; IF ZsegPortListCnt > 0 THEN TRUSTED { newPort: PROC RETURNS [lp: ListOfPorts] ~ TRUSTED { lp _ LIST[[ZsegPortList.portNumber]]; ZsegPortList _ ZsegPortList + UNITS[portT]; }; DsegPortList _ ZsegPortList; seqPortList _ newPort[]; IF ZsegPortListCnt > 1 THEN { lastPort: ListOfPorts _ seqPortList; FOR item: INT IN [1..ZsegPortListCnt) DO lastPort.rest _ newPort[]; lastPort _ lastPort.rest; ENDLOOP; }; [] _ vmDeallocate[targetTask: taskSelf[], address: LOOPHOLE[DsegPortList], size: BYTES[portT]*ZsegPortListCnt, raiseSignal: TRUE]; }; }; <<>> DSPinObject: PUBLIC PROC [dsPort: portT, tid: tidT, optr: optrT, size: uInt, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ { <> innerDSPinObject: PROC [idsPort: portT, itid: tidT, ioptr: optrT, isize: uInt] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".DS_PinObject" }; pinCode: INT _ -1; pinCode _ innerDSPinObject[dsPort, tid, optr, size]; IF raiseSignal AND pinCode # KernSuccess THEN SIGNAL MachCall[pinCode, Rope.Cat["DS_PinObject failed; code = ", IO.PutFR1["%g", IO.int[pinCode]]]]; RETURN[pinCode]; }; <<>> DSLogNewValue: PUBLIC PROC [dsPort: portT, tid: tidT, optr: optrT, newValue: pointerT, newValueCnt: INT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ { <> innerDSLogNewValue: PROC [idsPort: portT, itid: tidT, ioptr: optrT, inewValue: pointerT, inewValueCnt: INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".DS_LogNewValue" }; logCode: INT _ -1; logCode _ innerDSLogNewValue[dsPort, tid, optr, newValue, newValueCnt]; IF raiseSignal AND logCode # KernSuccess THEN SIGNAL MachCall[logCode, Rope.Cat["DS_LogNewValue failed; code = ", IO.PutFR1["%g", IO.int[logCode]]]]; RETURN[logCode]; }; <<>> DSLogOldValueNewValue: PUBLIC PROC [dsPort: portT, tid: tidT, optr: optrT, oldValue: pointerT, oldValueCnt: INT, newValue: pointerT, newValueCnt: INT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ { <> innerDSLogOldValueNewValue: PROC [idsPort: portT, itid: tidT, ioptr: optrT, ioldValue: pointerT, ioldValueCnt: INT, inewValue: pointerT, inewValueCnt: INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".DS_LogOldValueNewValue" }; logCode: INT _ -1; logCode _ innerDSLogOldValueNewValue[dsPort, tid, optr, oldValue, oldValueCnt, newValue, newValueCnt]; IF raiseSignal AND logCode # KernSuccess THEN SIGNAL MachCall[logCode, Rope.Cat["DS_LogOldValueNewValue failed; code = ", IO.PutFR1["%g", IO.int[logCode]]]]; RETURN[logCode]; }; <<>> DSPrepare: PUBLIC PROC [dsPort: portT, topBTid: btidT, prepareData: pointerT, prepareDataCnt: INT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ { <> innerDSPrepare: PROC [idsPort: portT, itopBTid: btidT, iprepareData: pointerT, iprepareDataCnt: INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".DS_Prepare" }; prepareCode: INT _ -1; prepareCode _ innerDSPrepare[dsPort, topBTid, prepareData, prepareDataCnt]; IF prepareCode # KernSuccess THEN SIGNAL MachCall[prepareCode, Rope.Cat["DS_Prepare failed; code = ", IO.PutFR1["%g", IO.int[prepareCode]]]]; RETURN[prepareCode]; }; DSQInit: PUBLIC PROC [sharedMemAddr: Mach.vmAddressT] ~ { <> innerDSQInit: PROC [XsharedMemAddr: Mach.vmAddressT] ~ TRUSTED MACHINE CODE { ".Dsq_Init" }; innerDSQInit[sharedMemAddr]; }; <<>> <<>> <<>> <> camelotStringTFromRope: PROC [name: Rope.ROPE] RETURNS [camelotString: REF camelotStringT] ~ { oNSize: INT _ 0; camelotString _ NEW[camelotStringT]; oNSize _ Rope.Length[name]; IF oNSize >= Camelot.CAMELOTSTRINGLENGTH THEN ERROR; FOR index: INT IN [0..oNSize) DO camelotString[index] _ Rope.Fetch[name, index]; ENDLOOP; camelotString[oNSize] _ 0C; }; <<>> TAAddApplication: PUBLIC PROC [tPort: portT, atPort: portT, authName: Rope.ROPE, raiseSignal: BOOL] RETURNS [applicationID: applicationIdT, taPort: portT, kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> innerTAAddApplication: PROC [itPort: portT, iatPort: portT, iauthName: POINTER TO camelotStringT, iapplicationID: POINTER TO applicationIdT, itaPort: POINTER TO portT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".TA_AddApplication" }; camString: REF camelotStringT; camString _ camelotStringTFromRope[authName]; kernCode _ innerTAAddApplication[tPort, atPort, LOOPHOLE[camString], @applicationID, @taPort]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TA_AddApplication failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> TABegin: PUBLIC PROC [taPort: portT, parentTid: tidT, transType: transactionTypeT, raiseSignal: BOOL] RETURNS [newTid: tidT, kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> innerTABegin: PROC [taPortInner: portT, parentTidInner: tidT, transTypeInner: transactionTypeT, newTidInner: POINTER TO tidT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".TA_Begin" }; kernCode _ innerTABegin[taPort, parentTid, transType, @newTid]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TA_Begin failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> TAEnd: PUBLIC PROC [taPort: portT, tid: tidT, protocolType: protocolTypeT, raiseSignal: BOOL] RETURNS [timestamp: timestampT, status: INT, kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> innerTAEnd: PROC [taPortInner: portT, tidInner: tidT, protocolTypeInner: protocolTypeT, timestampInner: POINTER TO timestampT, statusInner: POINTER TO INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".TA_End" }; kernCode _ innerTAEnd[taPort, tid, protocolType, @timestamp, @status]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TA_End failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> TAKill: PUBLIC PROC [taPort: portT, tid: tidT, status: INT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> innerTAKill: PROC [taPortInner: portT, tidInner: tidT, statusInner: INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".TA_Kill" }; kernCode _ innerTAKill[taPort, tid, status]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TA_Kill failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> TSJoin: PUBLIC PROC [tsPort: portT, tid: tidT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT _ -1] ~ { <> innerTSJoin: PROC [tsPortInner: portT, tidInner: tidT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".TS_Join" }; kernCode _ innerTSJoin[tsPort, tid]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TA_Join failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> TDAddDataServer: PUBLIC PROC [tdPort: portT, serverID: serverIdT, sendPort: portT, raiseSignal: BOOL] RETURNS [rcvPort: portT, kernCode: Mach.kernReturnT _ -1] ~ TRUSTED { <> <> innerTDAddDataServer: PROC [itdPort: portT, iserverID: serverIdT, isendPort: portT, ircvPort: POINTER TO portT] RETURNS [kernReturnT]~ TRUSTED MACHINE CODE { ".TD_AddDataServer" }; kernCode _ innerTDAddDataServer[tdPort, serverID, sendPort, @rcvPort]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["TD_AddDataServer failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <> objectNameTFromRope: PROC [name: Rope.ROPE] RETURNS [objectNameString: REF objectNameT] ~ { oNSize: INT _ 0; objectNameString _ NEW[objectNameT]; oNSize _ Rope.Length[name]; IF oNSize >= ObjectNameLength THEN ERROR; FOR index: INT IN [0..oNSize) DO objectNameString[index] _ Rope.Fetch[name, index]; ENDLOOP; objectNameString[oNSize] _ 0C; }; <<>> <<>> CSSignIn: PUBLIC PROC [nameServerPort: Mach.portT, name: Rope.ROPE, port: Mach.portT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT] ~ { <> innerCSSignIn: PROC [inameServerPort: Mach.portT, iname: POINTER TO objectNameT, iport: Mach.portT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".CS_SignIn" }; objectNameString: REF objectNameT; objectNameString _ objectNameTFromRope[name]; kernCode _ innerCSSignIn[nameServerPort, LOOPHOLE[objectNameString], port]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["CS_SignIn failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> CSSignOut: PUBLIC PROC [nameServerPort: Mach.portT, name: Rope.ROPE, port: Mach.portT, raiseSignal: BOOL] RETURNS [kernCode: Mach.kernReturnT] ~ { <> innerCSSignOut: PROC [inameServerPort: Mach.portT, iname: POINTER TO objectNameT, iport: Mach.portT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".CS_SignOut" }; objectNameString: REF objectNameT; objectNameString _ objectNameTFromRope[name]; kernCode _ innerCSSignOut[nameServerPort, LOOPHOLE[objectNameString], port]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["CS_SignOut failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; <<>> innerLookup: PROC [nameServerPort: Mach.portT, name: Rope.ROPE, site: Rope.ROPE, numberWanted: INT, maxSeconds: INT, raiseSignal: BOOL, cs: BOOL] RETURNS [portList: Mach.ListOfPorts, kernCode: Mach.kernReturnT] ~ { <> innerCSLookup: PROC [inameServerPort: Mach.portT, iname: POINTER TO objectNameT, isite: POINTER TO objectNameT, inumberWanted: INT, imaxSeconds: INT, iportList: POINTER TO portArrayT, iportListCnt: POINTER TO INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".CS_Lookup" }; innerCALookup: PROC [inameServerPort: Mach.portT, iname: POINTER TO objectNameT, isite: POINTER TO objectNameT, inumberWanted: INT, imaxSeconds: INT, iportList: POINTER TO portArrayT, iportListCnt: POINTER TO INT] RETURNS [kernReturnT] ~ TRUSTED MACHINE CODE { ".CA_Lookup" }; objectNameString: REF objectNameT; siteString: REF objectNameT; ZportList, DportList: portArrayT _ NIL; ZportListCnt: INT _ -1; objectNameString _ objectNameTFromRope[name]; siteString _ objectNameTFromRope[site]; IF cs THEN TRUSTED { kernCode _ innerCSLookup[nameServerPort, LOOPHOLE[objectNameString], LOOPHOLE[siteString], numberWanted, maxSeconds, @ZportList, @ZportListCnt]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["CS_Lookup failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; } ELSE TRUSTED { kernCode _ innerCALookup[nameServerPort, LOOPHOLE[objectNameString], LOOPHOLE[siteString], numberWanted, maxSeconds, @ZportList, @ZportListCnt]; IF raiseSignal AND kernCode # KernSuccess THEN SIGNAL MachCall[kernCode, Rope.Cat["CA_Lookup failed; code = ", IO.PutFR1["%g", IO.int[kernCode]]]]; }; IF ZportListCnt > 0 THEN TRUSTED { newPort: PROC RETURNS [lp: ListOfPorts] ~ TRUSTED { lp _ LIST[[ZportList.portNumber]]; ZportList _ ZportList + UNITS[portT]; }; DportList _ ZportList; portList _ newPort[]; IF ZportListCnt > 1 THEN { lastPort: ListOfPorts _ portList; FOR item: INT IN [1..ZportListCnt) DO lastPort.rest _ newPort[]; lastPort _ lastPort.rest; ENDLOOP; }; [] _ vmDeallocate[targetTask: taskSelf[], address: LOOPHOLE[DportList], size: BYTES[portT]*ZportListCnt, raiseSignal: TRUE]; }; }; <<>> CSLookup: PUBLIC PROC [nameServerPort: Mach.portT, name: Rope.ROPE, site: Rope.ROPE, numberWanted: INT, maxSeconds: INT, raiseSignal: BOOL] RETURNS [portList: Mach.ListOfPorts, kernCode: Mach.kernReturnT] ~ { <> [portList, kernCode] _ innerLookup[nameServerPort, name, site, numberWanted, maxSeconds, raiseSignal, TRUE]; }; <<>> CALookup: PUBLIC PROC [nameServerPort: Mach.portT, name: Rope.ROPE, site: Rope.ROPE, numberWanted: INT, maxSeconds: INT, raiseSignal: BOOL] RETURNS [portList: Mach.ListOfPorts, kernCode: Mach.kernReturnT] ~ { <> [portList, kernCode] _ innerLookup[nameServerPort, name, site, numberWanted, maxSeconds, raiseSignal, FALSE]; }; <<>> <> <> <> <> <<"LOCK">> <<};>> <> <> <<};>> <<>> <<>> <> <> <> <<"TRY_LOCK">> <<};>> <> <> <<};>> <<>> <<>> <> <> <> <<"UNLOCK">> <<};>> <> <> <<};>> <<>> <<>> <> <> <> <<"UNLOCK">> <<};>> <> <> <<};>> <<>> <<>> <> END.