-- Copyright (C) 1984, 1985, 1986, 1987 by Xerox Corporation. All rights reserved. -- Germ>GermOpsImpl.mesa 23-Nov-87 8:39:34 by CAJ << The BOOTING ACTION defined by the Principles of Operation should include: 1. Put real memory behind any special processor pages (I/O pages); then put all remaining usable real memory behind other virtual memory pages beginning at virtual page 0, and working upward sequentially (skipping any already-mapped special processor pages). 2. Read consecutive pages of the Germ into virtual memory beginning at page Boot.pageGerm + Boot.mdsiGerm*Environment.MaxPagesInMDS (i.e page 1). At present, the way the initial microcode figures out the device and device address of the Germ, and the number of pages which comprise the Germ, is processor-dependent. 3. Set Boot.pRequest to e.g. [Boot.currentRequestBasicVersion, Boot.bootPhysicalVolume, locationOfPhysicalVolume]. 4. Set WDC>0, NWW=0, MDS=Boot.mdsiGerm, STKP=0. 5. Xfer[dest: Boot.pInitialLink]. RUNTIME FACILITIES implemented for programs which comprise the Germ: Start traps SIGNAL and ERRORs will result in mp code cGermERROR. GermOps: PointerFromPage, GermWorldError, ShowCodeInMP, ShowCardinalInMP, etc. See GermOps for complete list. ResidentHeap: MakeNode, FreeNode (see Storage Allocation notes) ResidentMemory: Allocate, Free, AllocateMDS, FreeMDS (see Storage Allocation notes) Runtime.IsBound System.MicrosecondsToPulses Runtime facilities NOT implemented for programs which comprise the Germ: Frame, Page, and Write fault processing Mesa operations START, RESTART, STOP, FORK, JOIN, NEW C/Mesa operations CONTROL Constant initialization of arrays of strings Processor instructions implemented by software STORAGE ALLOCATION NOTES: ResidentMemory facilities: Storage allocated during Germ initialization using the ResidentMemory interface is retained forever. ResidentMemory may be allocated by a BootChannel implementation at the time the channel is Created and freed when it is closed (ResidentMemory.Free and FreeMDS are implemented as no-ops; the storage is actually recovered in bulk after the Channel is closed). Currently, BootChannelSPP allocates temporary buffer space when its network channel is created. When network operations other than Inload[inloadeMode: load] are implemented, BootChannelSPP will have to allocate this buffer space at germ initialization time and retain it forever. ResidentHeap facilities: At present, heap storage may not be allocated during Germ initialization using the ResidentHeap interface. ResidentHeap may be allocated by a BootChannel implementation at the time the channel is Created and freed when it is closed (ResidentHeap.FreeNode is implemented as a no-op; the storage is actually recovered in bulk after the Channel is closed). ResidentHeap.MakeNode and FreeNode only return status=okay; any allocation errors will result in an MP code. The storage for ResidentHeap is allocated either in the page containing the frame allocation vector (AV), past the part that is acutally used or from germ VM after germ code, depending on the size heap needed. DEBUGGING: See the definition of GermOps.GermWorldError. debug mode is turned on by a boot switch. [If you can't get the germ past the boot-button boot, compile this module with debug turned on.] You may find it useful to insert special code that displays key values in the mp via GermOps.Show*InMP. Often, just displaying "progress codes" through a failing section of code is enough to point out the problem. If you get a reschedule error mp code, it is probably because you got a page or frame fault. [You get a reschedule error because the PDA FaultQueue.conditions are all zero and interrupts are disabled. [The germ initially zeroes these Conditions, and Pilot does so before calling the germ.]] The mp will show (in debug mode) the offending instruction. If it is a procedure call or ALLOC instruction, it is presumably a frame fault. You can verify this by allocating more frames in the bootmesa and trying again. Alternatively, a frame fault can be verified by inserting the following debugging code immediately before the problem statement: codeBase: LONG POINTER TO PACKED ARRAY [0..0) OF [0..256) = LOOPHOLE[FrameExtras.ReadCodebase[FrameExtras.MyGlobalFrame[]]]; IF PrincOps.AV[codeBase prefixHandle.entry[].pc]].tag # frame THEN GermOps.GermWorldError[]; The code given assumes a local function call. If this is not the case, you will have to supply the global frame address or codebase of the called module. The debugging tool LocalFrameTool has facilities for examing the germ's frame heap. This is useful for seeing how close the germ is to running out of frames. See comments in Germ.bootmesa for frame heap tuning strategies. The debugging tool Microscope has facilities for dumping germ memory. >> DIRECTORY Boot USING [ bootPhysicalVolume, bootPhysicalVolumeDiskAddress, countGermVM, currentRequestBasicVersion, currentRequestExtensionVersion, inLoad, Location, mdsiGerm, noOp, outLoad, pageGerm, pCountGerm, pRequest, Session, teledebug], BootChannel USING [ Create, Handle, Operation, Result, Transfer, transferCleanup, transferWait], BootFile USING [ currentVersion, MapEntry, Header, InLoadMode, maxEntriesPerHeader, maxEntriesPerTrailer, MDSIndex, Trailer], ControlModuleFormat USING [Call, MainBody], Device USING [nullType, Type], DeviceTypesExtras4 USING [FloppyTape], Environment USING [ Base, bytesPerWord, first64K, LongPointerFromPage, maxPagesInMDS, PageCount, PageFromLongPointer, PageNumber, wordsPerPage], EthernetFace USING [TurnOn], Frame USING [ Free, GetReturnFrame, ReadPC, ReadReturnLink, SetReturnLink], FrameExtras USING [ LongGFToGFTHandle, ReadCodebase, ReadGlobalLink, WriteCodebase], GermMarkers USING [GatesOfHellMarker], GermOps USING [ BackToPilot, BoundsReservedMemory, CallPilotInMds, GetTeledebugged, InitializeLinkage, InvokersMds, pCodeSharingHandles, ProcessMachineDependentSwitches, SharedCode], HeadStartChain USING [Start], Inline USING [BITOR, LongDiv, LowHalf, HighHalf], PageMap USING [ ExchangeFlags, Flags, flagsClean, flagsVacant, GetState, IsMapped, maskReadOnly, PageNumber, RealPageNumber, SetMapFlags, State], PhysicalVolumeFormat USING [currentVersion, Descriptor, Seal], PilotDiskFace USING [ GetControllerAttributes, GetNextController, InitializeController, nullControllerHandle, operationAlignment, operationSize], PilotMP USING [ cCantTeledebug, cGerm, cGermAction, cGermBadBootFile, cGermBadBootFileVersion, cGermBadPhysicalVolume, cGermControlTrap, cGermDeviceError, cGermDriver, cGermERROR, cGermFinished, cGermInsufficientRealMemory, cGermWrongPilot, Code, cGermRescheduleTrap, cWrongGerm], PilotSwitches USING [germExtendedErrorReports], PrincOps USING [ AV, AVHeapSize, BytePC, ESCTrapTable, GlobalCodebase, LocalFrameHandle, nullLocalFrame, ShortControlLink, StateVector], PrincOpsExtras2 USING [ ControlLink, GFTHandle, nullLink, ProcDesc, trapLink, UnboundLink, GFT, ControlLinkTag], ProcessOperations USING [ReadMDS, WriteWDC], ProcessorFace USING [ GetNextAvailableVM, microsecondsPerHundredPulses, mp, SetMP, SpecialSetMP, Start], PSB USING [Condition, PDA, PsbNull, QueueEmpty], ResidentHeap USING [HeapLocation], ResidentMemory USING [ AllocateInternal, AllocateMDSInternal, FreeInternal, Location], Runtime USING [ControlLink], SDDefs USING [ sCodeTrap, sControlTrap, SD, sError, sRescheduleError, sSignal], SpecialRuntimeExtras USING [GlobalFrameFromProgram], StartList USING [Base], System USING [Microseconds, Pulses, Switches], Trap USING [Parameter], Zone USING [Alignment, BlockSize, nil, Status]; GermOpsImpl: MONITOR LOCKS residentMemoryLock IMPORTS importedBootChannel: BootChannel, ControlModuleFormat, Environment, EthernetFace, GermMarkers, GermOps, Frame, FrameExtras, heads: HeadStartChain, Inline, ProcessorFace, PageMap, PilotDiskFace, ProcessOperations, SpecialRuntimeExtras, Trap EXPORTS BootChannel, GermOps, ResidentHeap, ResidentMemory, Runtime, System SHARES Boot, GermOps, PageMap, ResidentMemory = BEGIN -- PARAMETERS: debug: PUBLIC BOOLEAN Ź FALSE; -- set to TRUE by boot switch. -- TYPEs and TYPE CONVERSION: ConditionEmpty: PSB.Condition = [ -- TEMP until in PSB (AR 3927) tail: PSB.PsbNull, abortable: FALSE, wakeup: FALSE]; PMapEntry: TYPE = ORDERED POINTER TO BootFile.MapEntry; OrderedPMapEntry: PROC [pme: POINTER TO BootFile.MapEntry] RETURNS [ORDERED POINTER TO BootFile.MapEntry] = INLINE { RETURN[LOOPHOLE[pme]]}; PageNumber: TYPE = Environment.PageNumber; PageCount: TYPE = Environment.PageCount; -- CONSTANTS: pageZero: PageNumber = FIRST[PageNumber]; sizeMapEntry: CARDINAL = SIZE[BootFile.MapEntry]; bPW: CARDINAL = Environment.bytesPerWord; wordsPerPage: CARDINAL = Environment.wordsPerPage; flagsVacant: PageMap.Flags = PageMap.flagsVacant; flagsClean: PageMap.Flags = PageMap.flagsClean; -- GERM STORAGE ALLOCATION AND USE: -- ResidentHeap storage: -- This is in the first 64K for allocating IOCB's etc., since the germ is in -- the first 64K. -- The heap occupies one of two places depending on the size needed, which -- is calculated at germ init time. A small heap uses the space in the page -- reserved for the allocation vector, past the part actually used by the AV. -- A large heap is allocated in germ VM after germ code. First64KStorage: TYPE = ARRAY [0..0) OF WORD; pHeap: Environment.Base RELATIVE ORDERED POINTER TO First64KStorage; pHeapAllocEnd: Environment.Base RELATIVE ORDERED POINTER; pHeapAllocNext: Environment.Base RELATIVE ORDERED POINTER; -- next storage to be allocated. -- Page buffer storage: -- used to read/write boot file Header/Trailer pages and phys vol root page. pageBuffer: PageNumber; pBuffer: POINTER; -- pointer to pageBuffer. -- GERM GEOGRAPHY: pageGerm: PageNumber = Boot.pageGerm + Boot.mdsiGerm*Environment.maxPagesInMDS; pageEndGermVM: PageNumber = pageGerm + Boot.countGermVM; -- end VM page usable by Germ. pageGFT: PageNumber = Environment.PageFromLongPointer[PrincOpsExtras2.GFT]; beforePage: PageNumber; middlePage: PageNumber; afterPage: PageNumber; flushFloppy: BOOLEAN Ź TRUE; -- PROCEDURES: Create: PUBLIC --BootChannel.-- PROC [ pLocation: LONG POINTER TO Boot.Location, operation: BootChannel.Operation, buffer: LONG POINTER] RETURNS [result: BootChannel.Result, handle: BootChannel.Handle] = { -- Backstop Create routine to plug end of chain of BootChannel interfaces. -- (Possibly invoked by dummy call to initialize BootChannel implementations) RETURN[[error[PilotMP.cGermDeviceError]], NIL]}; ProcessRequests: PROC = -- Never returns to caller. Frees caller's frame. BEGIN bootChannel: BootChannel.Handle; result: BootChannel.Result; ProcessorFace.SetMP[PilotMP.cGermAction]; Frame.Free[Frame.GetReturnFrame[]]; -- free our caller's frame. Frame.SetReturnLink[ Inline.LowHalf[ LOOPHOLE[PrincOpsExtras2.trapLink]]]; -- (just in case) -- (The initial microcode has supplied the first Request.) IF Boot.pRequest.requestBasicVersion # Boot.currentRequestBasicVersion THEN GermWorldError[PilotMP.cWrongGerm]; -- reclaim initialization code memory (heads.Start must have been called). FlushMemory[middlePage, afterPage + 1]; -- inclusive interval DO --FOREVER-- BEGIN --scope of HandleProblem-- -- Each arm of the select statement below does: -- Process current Request; -- Generate new request, possibly by going back to Pilot until it -- generates one; SELECT Boot.pRequest.action FROM Boot.bootPhysicalVolume => BEGIN -- Reads physical volume root page of request's device and -- generates an inload Request for that device: pvDesc: POINTER TO PhysicalVolumeFormat.Descriptor = PointerFromPage[ pageBuffer]; Boot.pRequest.location.diskFileID.da Ź Boot.bootPhysicalVolumeDiskAddress; [result, bootChannel] Ź importedBootChannel.Create[ @Boot.pRequest.location, rawRead, LONG[pBuffer]]; IF result # [ok[]] THEN GO TO HandleProblem; result Ź DoTransfer[bootChannel, pageBuffer, 1]; IF result # [ok[]] THEN GO TO HandleProblem; result Ź DoTransfer[bootChannel, 0, BootChannel.transferWait]; IF result # [ok[]] THEN GO TO HandleProblem; IF pvDesc.seal ~= PhysicalVolumeFormat.Seal OR pvDesc.version ~= PhysicalVolumeFormat.currentVersion THEN GermWorldError[PilotMP.cGermBadPhysicalVolume]; [] Ź DoTransfer[ bootChannel, 0, BootChannel.transferCleanup]; -- shut down channel. Boot.pRequest.location.diskFileID Ź pvDesc.bootingInfo[pilot]; Boot.pRequest.action Ź Boot.inLoad; Boot.pRequest.requestExtensionVersion Ź Boot.currentRequestExtensionVersion; -- Fall through to process the generated inload Request.. END; Boot.inLoad => BEGIN mds: BootFile.MDSIndex; IF allocationDifficulty = impossible THEN -- -- (can alloc temp storage only for inLoad[inloadMode: load]) allocationDifficulty Ź hard; [result, bootChannel] Ź importedBootChannel.Create[ @Boot.pRequest.location, read, LONG[pBuffer]]; IF result # [ok[]] THEN GO TO HandleProblem; [mds, Boot.pRequest.pStartListHeader, result] Ź DoInLoad[bootChannel]; IF result # [ok[]] THEN GO TO HandleProblem; IF flushFloppy THEN {flushFloppy Ź FALSE; -- only do this once IF LOOPHOLE[Boot.pRequest.location.deviceType, CARDINAL] ~IN DeviceTypesExtras4.FloppyTape THEN -- Reclaim floppy section of Marker-ed memory -- unless booting from floppy tape. FlushMemory[beforePage, middlePage]}; Boot.pRequest.requestExtensionVersion Ź Boot.currentRequestExtensionVersion; IF Boot.pRequest.switches[ PilotSwitches.germExtendedErrorReports] = down OR (Boot.pRequest.pStartListHeader # NIL AND LOOPHOLE[Boot.pRequest.pStartListHeader.switches, System.Switches][ PilotSwitches.germExtendedErrorReports] = down) THEN debug Ź TRUE; Boot.pRequest.session Ź newSession; GermOps.InitializeLinkage[mds]; -- sets linkage for target mds ProcessorFace.SetMP[PilotMP.cGermFinished]; --[pRequest]Ź-- GermOps.CallPilotInMds[mds]; -- (uses entry point in given mds.) -- Now we're back with another Request. allocationDifficulty Ź impossible; -- all free real mem is owned by Pilot. END; Boot.noOp => { ProcessorFace.SetMP[PilotMP.cGermFinished]; --[pRequest] Ź -- GermOps.BackToPilot[]; -- (continues from where Pilot left off) -- Now we're back with another Request. allocationDifficulty Ź impossible}; -- all free real mem is owned by Pilot. Boot.outLoad => BEGIN mds: BootFile.MDSIndex = GermOps.InvokersMds[]; IF Boot.pRequest.requestExtensionVersion # Boot.currentRequestExtensionVersion THEN GermWorldError[PilotMP.cGermWrongPilot]; [result, bootChannel] Ź importedBootChannel.Create[ @Boot.pRequest.location, write, LONG[pBuffer]]; IF result # [ok[]] THEN GOTO HandleProblem; result Ź DoOutLoad[bootChannel, mds, Boot.pRequest.inLoadMode]; IF result # [ok[]] THEN GOTO HandleProblem; Boot.pRequest.session Ź continuingAfterOutLoad; -- (pRequest.requestExtensionVersion is already set right.) -- (The linkage to the client was already set up by his call to us.) ProcessorFace.SetMP[PilotMP.cGermFinished]; --[pRequest] Ź -- GermOps.BackToPilot[]; -- (continues from where Pilot left off) -- Now we're back with another Request. allocationDifficulty Ź impossible; -- all free real mem is owned by Pilot. END; Boot.teledebug => BEGIN IF ~IsBound[LOOPHOLE[GermOps.GetTeledebugged]] THEN GermWorldError[PilotMP.cCantTeledebug]; GermOps.GetTeledebugged[ pLocation: @Boot.pRequest.location, scratchPage: pageBuffer]; -- (The linkage to the client was already set up by his call to us.) ProcessorFace.SetMP[PilotMP.cGermFinished]; --[pRequest] Ź -- GermOps.BackToPilot[]; -- (continues from where Pilot left off) -- Now we're back with another Request. allocationDifficulty Ź impossible; -- all free real mem is owned by Pilot. END; ENDCASE => Error[]; EXITS HandleProblem --[result]-- => WITH r: result SELECT FROM error => GermWorldError[r.code]; tryOtherLocation => -- We overwrite the Location we were working on with the -- new suggested Location, fall through, and try again. Boot.pRequest.location Ź r.pOtherLocation; --ok,-- ENDCASE => Error[]; END; --scope of HandleProblem-- ProcessorFace.SetMP[PilotMP.cGermAction]; FreeResidentHeap[]; -- recover any heap storage used by BootChannel. IF Boot.pRequest.requestBasicVersion # Boot.currentRequestBasicVersion THEN GermWorldError[PilotMP.cGermWrongPilot]; ENDLOOP; --FOREVER-- END; --ProcessRequests-- DoTransfer: PROC [ handle: BootChannel.Handle, page: PageNumber, count: PageCount] RETURNS [result: BootChannel.Result] = BEGIN prevMP: PilotMP.Code = ProcessorFace.mp; ProcessorFace.SetMP[PilotMP.cGermDriver]; result Ź importedBootChannel.Transfer[handle, page, count]; ProcessorFace.SetMP[prevMP]; END; --DoTransfer-- --~~~~~~~~~~~~~~~~~~~~ InLoad and OutLoad ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ DoInLoad: PROC [channel: BootChannel.Handle] RETURNS [ mds: BootFile.MDSIndex, pStartListHeader: StartList.Base, result: BootChannel.Result] = BEGIN -- uses global highestMappedPage inLoadMode: BootFile.InLoadMode; remainingMapEntries: CARDINAL; curMapEntry: PMapEntry; -- in current header/trailer page. endMapEntry: PMapEntry; -- " startMapEntry: PMapEntry; -- " runMapEntry: PMapEntry; countRun: CARDINAL; -- current run of pages. page, pageIntervalEnd: PageNumber; -- interval of Pilot VM to be restored. realPage: PageMap.RealPageNumber; state: PageMap.State; FinishRun: PROCEDURE [] --RETURNS [result: BootChannel.Result]-- = -- (Returns result directly into paren't frame.) BEGIN IF countRun > 0 THEN BEGIN result Ź DoTransfer[channel, runMapEntry.virtual, page - runMapEntry.virtual]; IF result # [ok[]] THEN RETURN; countRun Ź 0; END; result Ź [ok[]]; END; --FinishRun-- -- Read first page of boot file, containing header: result Ź DoTransfer[channel, pageBuffer, 1]; IF result # [ok[]] THEN RETURN[TRASH, TRASH, result]; result Ź DoTransfer[channel, 0, BootChannel.transferWait]; IF result # [ok[]] THEN RETURN[TRASH, TRASH, result]; BEGIN OPEN header: LOOPHOLE[pBuffer, POINTER TO BootFile.Header]; IF header.version ~= BootFile.currentVersion THEN GermWorldError[PilotMP.cGermBadBootFileVersion]; pStartListHeader Ź header.pStartListHeader; inLoadMode Ź header.inLoadMode; mds Ź header.mds; remainingMapEntries Ź CARDINAL[header.countData]; startMapEntry Ź curMapEntry Ź OrderedPMapEntry[@header.entries[0]]; endMapEntry Ź startMapEntry + sizeMapEntry*MIN[BootFile.maxEntriesPerHeader, remainingMapEntries]; END; -- The following code is performing two variations of the same function: -- If inLoadMode=load, all Pilot-available real memory (excludes that -- behind Germ and I/O pages) is mapped behind consecutive Pilot -- VM pages starting at 0, and as we pass pages which the boot file -- specifies to be unmapped, we shuffle the real memory pages found -- there down to the end of mapped Pilot VM. -- If inLoadMode=restore, all Pilot-available real memory is mapped -- behind arbitrary pages, and as we pass pages which the boot file -- specifies to be unmapped, we merely ignore the real memory pages -- found there.. the boot file will cause them to be put in the -- right place. SELECT inLoadMode FROM load => CompactVM[onlyKeepVanillaRealMemory:TRUE]; restore => -- XXXXX pages not in boot file are set vacant: BEGIN IF AnyTempStorageAllocated[] THEN -- can't alloc any real mem.. Error[]; -- cause Pilot owns it all. -- If the processor has an associative page map, we must avoid duplicate -- use of real pages. We make an initial pass and unmap all of Pilot VM. -- This also serves to set vacant all pages not mentioned in boot file. [page, pageIntervalEnd] Ź GetNextPilotVM[pageZero]; WHILE page < pageIntervalEnd DO --process nonempty interval WHILE page < pageIntervalEnd DO PageMap.SetMapFlags[virtual: page, real: NULL, flags: flagsVacant]; page Ź page+1; ENDLOOP; [page, pageIntervalEnd] Ź GetNextPilotVM[page]; ENDLOOP; END; ENDCASE => Error[]; IF IsBound[LOOPHOLE[GermOps.ProcessMachineDependentSwitches]] THEN highestMappedPage Ź GermOps.ProcessMachineDependentSwitches[ LOOPHOLE[LONG[pBuffer]], highestMappedPage]; allocationDifficulty Ź impossible; -- memory must be static during inLoad. -- Starting at page 0 and scanning forward, restore virtual memory and -- hardware map from boot file: -- Within the following loop, we always have the following context: an -- interval of Pilot VM that we are processing/restoring, a header/trailer -- page of MapEntries, the total number of remaining MapEntries to be -- processed, and a run of mapped pages from the boot file. Initially, we -- have the MapEntries of the boot file header page. [page, pageIntervalEnd] Ź GetNextPilotVM[pageZero]; -- 1st interval to restore --ASSERT page = pageZero AND page <= curMapEntry.virtual; countRun Ź 0; -- no pages in current run yet. DO --UNTIL last mapEntry in last header/trailer page in boot file processed -- What do we do with this page of VM? -- (If inLoadMode=load, it has a real page behind it, and if -- inLoadMode=restore, it might.) IF page < curMapEntry.virtual THEN BEGIN --page not mentioned in boot file -- (Such pages are to be made vacant) IF countRun > 0 THEN -- (test for performance only) BEGIN --result Ź-- FinishRun[]; -- (sets countRun Ź 0) IF result # [ok[]] THEN RETURN; END; [state, realPage] Ź PageMap.ExchangeFlags[virtual: page, newFlags: flagsVacant]; IF inLoadMode = load THEN BEGIN IF state.flags = flagsVacant THEN -- should be real page there. GermWorldError[PilotMP.cGermInsufficientRealMemory]; PageMap.SetMapFlags[ -- shuffle real page to end of mapped VM. virtual: IF (highestMappedPage Ź highestMappedPage+1) = pageGFT THEN (highestMappedPage Ź highestMappedPage+1) ELSE highestMappedPage, real: realPage, flags: flagsClean]; END ELSE --inLoadMode = restore-- NULL; -- Forget any real page there now. page Ź page+1; END --page not mentioned in boot file-- ELSE BEGIN --page in boot file-- --ASSERT page = curMapEntry.virtual; -- Set up map and accumulate run-of-pages info to restore data.. IF countRun > 0 AND page = (curMapEntry - sizeMapEntry).virtual+1 THEN countRun Ź countRun+1 -- continuation of run ELSE BEGIN --result Ź-- FinishRun[]; -- (sets countRun Ź 0) IF result # [ok[]] THEN RETURN; runMapEntry Ź curMapEntry; -- remember start of new run. countRun Ź 1; END; IF inLoadMode = restore THEN -- Use the real page boot file says. PageMap.SetMapFlags[ -- (must make page writable to start) virtual: page, real: curMapEntry.real, flags: flagsClean] ELSE --inLoadMode = load-- BEGIN -- use the real page that's laying there. IF page > highestMappedPage THEN GermWorldError[PilotMP.cGermInsufficientRealMemory]; END; page Ź page+1; remainingMapEntries Ź remainingMapEntries-1; curMapEntry Ź curMapEntry + sizeMapEntry; IF curMapEntry >= endMapEntry THEN BEGIN -- clean up, get next Trailer -- first cleanup any pending I/O --result Ź-- FinishRun[]; -- (sets countRun Ź 0) IF result # [ok[]] THEN RETURN; result Ź DoTransfer[channel, 0, BootChannel.transferWait].result; IF result # [ok[]] THEN RETURN; -- Now we set map flags for all pages defined by this Trailer BEGIN OPEN trailer: LOOPHOLE[pBuffer, POINTER TO BootFile.Trailer]; FOR mapEntry: PMapEntry Ź startMapEntry, mapEntry + sizeMapEntry UNTIL mapEntry >= endMapEntry DO [] Ź PageMap.ExchangeFlags[ virtual: mapEntry.virtual, newFlags: mapEntry.flags]; ENDLOOP; END; -- Now read the next Trailer, if any IF remainingMapEntries = 0 THEN EXIT -- boot file processing complete. ELSE -- read next Trailer page to get more MapEntries BEGIN OPEN trailer: LOOPHOLE[pBuffer, POINTER TO BootFile.Trailer]; result Ź DoTransfer[channel, pageBuffer, 1]; IF result # [ok[]] THEN RETURN; result Ź DoTransfer[channel, 0, BootChannel.transferWait].result; IF result # [ok[]] THEN RETURN; IF trailer.version ~= BootFile.currentVersion THEN GermWorldError[PilotMP.cGermBadBootFileVersion]; startMapEntry Ź curMapEntry Ź OrderedPMapEntry[@trailer.entries[0]]; endMapEntry Ź startMapEntry + sizeMapEntry*MIN[ BootFile.maxEntriesPerTrailer, remainingMapEntries]; END; --OPEN trailer-- END; --clean up, get next Trailer-- END; --page in boot file-- IF page >= pageIntervalEnd THEN { --result Ź-- FinishRun[]; -- (sets countRun Ź 0) IF result # [ok[]] THEN RETURN; [page, pageIntervalEnd] Ź GetNextPilotVM[page]; IF page = pageIntervalEnd THEN Error[]; -- ran out of VM! IF curMapEntry.virtual < page THEN -- boot file has page on I/O or germ page. GermWorldError[PilotMP.cGermBadBootFile]; }; ENDLOOP; -- All boot file pages are now loaded/restored and the channel has -- no outstanding requests on it. Final call to shut down channel. [] Ź DoTransfer[channel, 0, BootChannel.transferCleanup]; IF inLoadMode = load THEN FreeTempResidentMemory[highestMappedPage]; END; --DoInLoad-- DoOutLoad: PROC [ channel: BootChannel.Handle, mds: BootFile.MDSIndex, inLoadMode: BootFile.InLoadMode] RETURNS [result: BootChannel.Result] = BEGIN remainingMapEntries: CARDINAL; page, pageIntervalEnd: PageNumber; -- interval of Pilot VM to be saved. firstHTMapEntry: PMapEntry; -- in current header/trailer page. curMapEntry: PMapEntry; -- " endMapEntry: PMapEntry; -- " runMapEntry: PMapEntry; -- current run of pages. realPage: PageMap.RealPageNumber; state: PageMap.State; -- Find how many pages we have to save: remainingMapEntries Ź 0; [page, pageIntervalEnd] Ź GetNextPilotVM[pageZero]; --UNTIL end of Pilot VM reached-- DO IF PageMap.IsMapped[page] THEN remainingMapEntries Ź remainingMapEntries+1; page Ź page+1; IF page >= pageIntervalEnd THEN { [page, pageIntervalEnd] Ź GetNextPilotVM[page]; IF page = pageIntervalEnd THEN EXIT}; ENDLOOP; -- Construct boot file Header page: BEGIN OPEN header: LOOPHOLE[pBuffer, POINTER TO BootFile.Header]; header.version Ź BootFile.currentVersion; -- header.creationDate Ź XXX; ++ fill this when we have a Pilot T.O.D clock? header.pStartListHeader Ź NIL; header.mds Ź mds; header.inLoadMode Ź inLoadMode; header.countData Ź remainingMapEntries; firstHTMapEntry Ź OrderedPMapEntry[@header.entries[0]]; endMapEntry Ź firstHTMapEntry + sizeMapEntry*MIN[BootFile.maxEntriesPerHeader, remainingMapEntries]; END; -- Starting at page 0 and scanning forward, save virtual memory and hardware -- map into boot file: -- Within the following loop, we always have the following context: -- an interval of Pilot VM that we are saving, -- a header/trailer page in which to generate MapEntries, -- the total number of remaining MapEntries to be processed, -- a run of mapped pages from the boot file. -- Initially, we are generating the MapEntries of the boot file header page. allocationDifficulty Ź impossible; -- memory must be static during outLoad. [page, pageIntervalEnd] Ź GetNextPilotVM[pageZero]; -- 1st interval to save. --UNTIL last page in VM saved in boot file-- DO -- First, scan enough VM to fill in MapEntries in Header/Trailer, then -- write H/T out: curMapEntry Ź firstHTMapEntry; -- We first wait for pending I/O to complete to ensure -- that the contents of pageBuffer may be overwritten. result Ź DoTransfer[channel, 0, BootChannel.transferWait]; IF result # [ok[]] THEN RETURN; DO --UNTIL desired number of mapped pages found [state, realPage] Ź PageMap.GetState[page]; IF state.flags ~= flagsVacant THEN BEGIN curMapEntry Ź [virtual: page, real: realPage, flags: state.flags]; curMapEntry Ź curMapEntry + sizeMapEntry; IF curMapEntry >= endMapEntry THEN {page Ź page+1; EXIT}; END; page Ź page+1; IF page >= pageIntervalEnd THEN BEGIN [page, pageIntervalEnd] Ź GetNextPilotVM[page]; IF page = pageIntervalEnd THEN Error[]; -- ran out of VM! END; ENDLOOP; -- Write out the H/T page. result Ź DoTransfer[channel, pageBuffer, 1]; IF result # [ok[]] THEN RETURN; -- Use the accumulated H/T page MapEntries to write out runs of data pages: curMapEntry Ź firstHTMapEntry; --UNTIL all mapEntries in H/T page processed-- DO runMapEntry Ź curMapEntry; -- current entry begins a new run. --UNTIL end of run found-- DO curMapEntry Ź curMapEntry + sizeMapEntry; IF curMapEntry >= endMapEntry OR curMapEntry.virtual ~= (curMapEntry - sizeMapEntry).virtual+1 THEN EXIT; -- run ends. ENDLOOP; result Ź DoTransfer[ -- write out a run of data pages channel, runMapEntry.virtual, (curMapEntry - sizeMapEntry).virtual + 1 - runMapEntry.virtual]; -- (last+1-first) IF result # [ok[]] THEN RETURN; IF curMapEntry >= endMapEntry THEN EXIT; -- all map entries processed ENDLOOP; remainingMapEntries Ź remainingMapEntries - (endMapEntry - firstHTMapEntry)/sizeMapEntry; IF remainingMapEntries = 0 THEN EXIT; -- all pages written to boot file. -- Construct next boot file Trailer page: BEGIN OPEN trailer: LOOPHOLE[pBuffer, POINTER TO BootFile.Trailer]; trailer.version Ź BootFile.currentVersion; firstHTMapEntry Ź OrderedPMapEntry[@trailer.entries[0]]; endMapEntry Ź firstHTMapEntry + sizeMapEntry*MIN[BootFile.maxEntriesPerTrailer, remainingMapEntries]; END; ENDLOOP; --loop for all {Trailer page, runs of data pages} groups. -- Wait for any pending I/O to complete before shutting down the channel result Ź DoTransfer[channel, 0, BootChannel.transferWait]; IF result # [ok[]] THEN RETURN; [] Ź DoTransfer[channel, 0, BootChannel.transferCleanup]; END; --DoOutLoad-- CompactVM: PROC [onlyKeepVanillaRealMemory:BOOLEAN Ź FALSE] = -- Finds all real pages currently mapped to Pilot virtual pages, and puts -- them (writable) behind contiguous Pilot virtual addresses starting at 0. -- Sets global highestMappedPage as the resulting highest page in VM which -- is mapped. BEGIN pageSource, pageSourceIntervalEnd, pageDest, pageDestIntervalEnd: PageNumber; reservedMin, reservedMax: PageNumber; IF onlyKeepVanillaRealMemory THEN [reservedMin: reservedMin, reservedMax: reservedMax] Ź GermOps.BoundsReservedMemory[]; [pageDest, pageDestIntervalEnd] Ź GetNextPilotVM[pageZero]; -- next interval to put mem into. pageSource Ź pageZero; --UNTIL end of VM reached-- DO [pageSource, pageSourceIntervalEnd] Ź GetNextPilotVM[pageSource]; -- next source interval to scan. IF pageSource = pageSourceIntervalEnd THEN EXIT; -- end of VM. WHILE pageSource < pageSourceIntervalEnd DO realPage: PageMap.RealPageNumber; state: PageMap.State; [state, realPage] Ź PageMap.ExchangeFlags[ virtual: pageSource, newFlags: flagsVacant]; IF (state.flags=flagsVacant) OR (onlyKeepVanillaRealMemory AND realPage IN [reservedMin..reservedMax]) THEN {-- either there's no real page, or its to be left out of VM--} ELSE { PageMap.SetMapFlags[ virtual: pageDest, real: realPage, flags: flagsClean]; highestMappedPage Ź pageDest; -- set the global variable. pageDest Ź pageDest+1; IF pageDest >= pageDestIntervalEnd THEN -- get next dest interval. [pageDest, pageDestIntervalEnd] Ź GetNextPilotVM[pageDest]; }; pageSource Ź pageSource+1; ENDLOOP; ENDLOOP; END; --CompactVM-- Error: PROCEDURE = {GermWorldError[PilotMP.cGermERROR]}; GetNextPilotVM: PUBLIC --GermOps.-- PROC [page: PageNumber] RETURNS [firstPage, endPage: PageNumber] = << Returns next area of virtual memory, beginning at or after given page, which is available for Pilot on this processor. Returns endPage=firstPage if no such available area exists. The available areas exclude pages used by the Germ, device face implementations, and unimplemented virtual pages but include pages allocated in the Principles of Operation (e.g. process data area, AV, SD, GFT). Similar to ProcessorFace.GetNextAvailableVM except that the Germ VM is also excluded. endPage is the page following the interval of Pilot VM.>> BEGIN PageBeforeOrAtInterval: PROC [pageInterval, pageEndInterval: PageNumber] RETURNS [BOOLEAN] = BEGIN -- If GetNextPilotVM.page is <= pageInterval, -- then sets GetNextPilotVM.firstPage, .endPage and returns TRUE. IF pageEndInterval = pageInterval -- (Germ caused null interval) OR page > pageInterval THEN RETURN[FALSE] ELSE --page <= pageInterval and non-null interval-- { firstPage Ź pageInterval; endPage Ź pageEndInterval; RETURN[TRUE]}; END; pageStart: PageNumber; count: PageCount; pageNext: PageNumber Ź pageZero; -- end of current interval / start of next. --REPEAT .. UNTIL interval at or after page-- DO [pageStart, count] Ź ProcessorFace.GetNextAvailableVM[pageNext]; IF count = 0 THEN RETURN[0, 0]; -- no further available VM. pageNext Ź pageStart + count; -- end of current interval SELECT TRUE FROM pageGerm IN [pageStart..pageNext) => { IF pageEndGermVM > pageNext THEN Error[]; -- Germ slops onto I/O page. IF PageBeforeOrAtInterval[pageStart, pageGerm] THEN RETURN; IF PageBeforeOrAtInterval[pageEndGermVM, pageNext] THEN RETURN}; pageGFT IN [pageStart..pageNext) => { IF PageBeforeOrAtInterval[pageStart, pageGFT] THEN RETURN; IF PageBeforeOrAtInterval[pageGFT+1, pageNext] THEN RETURN}; ENDCASE => IF PageBeforeOrAtInterval[pageStart, pageNext] THEN RETURN; ENDLOOP; END; --GetNextPilotVM-- --~~~~~~~~~~~~~~~~~~~~ Simple Mesa Runtime ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ << We can't set up handlers to catch Frame, Page, and Write Faults because the PDA belongs to the client being outloaded, and we can't modify it. However, at germ initialization, we zero the PDA fault vectors, and thereafter Pilot is supposed to manually save their contents and zero them before calling the germ. Thus any fault in the germ will result in a reschedule error, which we CAN catch and handle. >> CodeTrap: PROC = -- entered via SD[sCodeTrap] -- This trap is used to implement start traps. -- Neither single nor multiple control modules are implemented. -- The code here is derived from the code of Traps.CodeTrap[]. BEGIN d: RECORD [ -- keeps state away from trap params. trapee: PrincOps.LocalFrameHandle, gfi: PrincOpsExtras2.GFTHandle, dest: PrincOpsExtras2.ControlLink, -- procedure being called. opLength: INTEGER, state: dst PrincOps.StateVector]; -- holds args of called procedure. cb: PrincOps.GlobalCodebase; d.state Ź STATE; -- save args for called proc. Must be first. d.gfi Ź Trap.Parameter[]; -- Must be second. d.trapee Ź Frame.GetReturnFrame[]; cb Ź FrameExtras.ReadCodebase[d.gfi]; cb.out Ź FALSE; FrameExtras.WriteCodebase[gfi: d.gfi, cb: cb]; ControlModuleFormat.Call[ControlModuleFormat.MainBody[d.gfi]]; STATE Ź d.state; -- Must be last. END; ControlTrap: PROC = -- (entered via sControlTrap) BEGIN stuff: RECORD [ -- a record to keep state out of local zero fillerA, fillerB, fillerC: WORD, state: PrincOps.StateVector]; stuff.state Ź STATE; -- Must be first. resets stack pointer GermWorldError[PilotMP.cGermControlTrap]; END; Start: PUBLIC --GermOps.-- PROCEDURE [program: PROGRAM] = BEGIN -- This trap is used to implement start programs. -- Neither single nor multiple control modules are implemented. -- The code here is derived from the code of Traps.CodeTrap[]. -- This is called from the Germ*Start.mesa module specific to germ flavors. d: RECORD [ -- keeps state away from trap params. trapee: PrincOps.LocalFrameHandle, gfi: PrincOpsExtras2.GFTHandle, dest: PrincOpsExtras2.ControlLink, -- procedure being called. opLength: INTEGER, state: dst PrincOps.StateVector]; -- holds args of called procedure. cb: PrincOps.GlobalCodebase; d.state Ź STATE; -- save args for called proc. Must be first. d.gfi Ź FrameExtras.LongGFToGFTHandle[ SpecialRuntimeExtras.GlobalFrameFromProgram[program]]; -- Must be second. d.trapee Ź Frame.GetReturnFrame[]; cb Ź FrameExtras.ReadCodebase[d.gfi]; cb.out Ź FALSE; FrameExtras.WriteCodebase[gfi: d.gfi, cb: cb]; ControlModuleFormat.Call[ControlModuleFormat.MainBody[d.gfi]]; STATE Ź d.state; -- Must be last. END; --Start-- IsBound: PUBLIC --Runtime.-- PROC [link: Runtime.ControlLink] RETURNS [BOOLEAN] = BEGIN RETURN[ LOOPHOLE[link, PrincOpsExtras2.ControlLink] ~= PrincOpsExtras2.UnboundLink AND LOOPHOLE[link, PrincOpsExtras2.ControlLink] ~= PrincOpsExtras2.nullLink]; END; PointerFromPage: PUBLIC --GermOps.-- PROC [page: Environment.PageNumber] RETURNS [p: POINTER] = { lp: LONG POINTER Ź Environment.LongPointerFromPage[page]; IF Inline.HighHalf[lp] ~= ProcessOperations.ReadMDS[] THEN Error[]; RETURN[ Inline.LowHalf[ lp - ProcessOperations.ReadMDS[]*Environment.maxPagesInMDS]]}; RescheduleErrorTrap: PROC = -- (entered via sRescheduleError) BEGIN stuff: RECORD [ -- a record to keep state out of local zero fillerA, fillerB, fillerC: WORD, state: PrincOps.StateVector]; stuff.state Ź STATE; -- Must be first. resets stack pointer GermWorldError[PilotMP.cGermRescheduleTrap]; END; SignalHandler: PROC [signal: SIGNAL, code: PilotMP.Code] = { -- (entered via sSignal or sError KFCB) GermWorldError[PilotMP.cGermERROR]}; GermWorldError: PUBLIC --GermOps.-- PROC [ mpCode: --PilotMP.Code-- UNSPECIFIED] = -- See comments in GermOps for description of operation. BEGIN DO --FOREVER-- localFrame: PrincOps.LocalFrameHandle Ź Frame.GetReturnFrame[]; ShowCodeInMP[mpCode]; IF debug THEN BEGIN ShowCodeInMP[999]; THROUGH [1..5] DO gfi: PrincOpsExtras2.GFTHandle = FrameExtras.ReadGlobalLink[localFrame]; pc: PrincOps.BytePC = Frame.ReadPC[localFrame]; ShowCardinalInMP[gfi]; -- ShowCardinalInMP[localFrame]; ++ not very useful. ShowCardinalInMP[pc]; localFrame Ź Frame.ReadReturnLink[localFrame].frame; IF localFrame = PrincOps.nullLocalFrame THEN EXIT; ENDLOOP; END; ENDLOOP; --FOREVER-- END; --GermWorldError-- mpModulus: NAT = 1000; -- mp only guaranteed to be three digits. ShowCodeInMP: PUBLIC --GermOps.-- PROC [mpCode: PilotMP.Code] = { ProcessorFace.SpecialSetMP[mpCode]; FOR delay: LONG CARDINAL IN [0..400000) DO ENDLOOP}; ShowCardinalInMP: PUBLIC --GermOps.-- PROC [cardinal: UNSPECIFIED] = { ShowCodeInMP[cardinal/mpModulus]; ShowCodeInMP[cardinal MOD mpModulus]}; --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- ResidentHeap implementation, for allocating storage in the germ's world. -- See Storage Allocation notes at head of module. EnvBaseRelOrdPtr: PROC [rp: Environment.Base RELATIVE POINTER] RETURNS [Environment.Base RELATIVE ORDERED POINTER] = INLINE { RETURN[LOOPHOLE[rp]]}; MakeNode: PUBLIC --ResidentHeap.-- PROCEDURE [ n: Zone.BlockSize, alignment: Zone.Alignment Ź a1, location: ResidentHeap.HeapLocation Ź first64K] RETURNS [node: Environment.Base RELATIVE POINTER, s: Zone.Status] = BEGIN align: CARDINAL; IF n = 0 THEN RETURN [Zone.nil, okay]; align Ź SELECT alignment FROM a1 => 1, a2 => 2, a4 => 4, a8 => 8, ENDCASE => 16; node Ź LOOPHOLE[((LOOPHOLE[pHeapAllocNext, CARDINAL] + align-1)/align)*align]; --REPEAT ... UNTIL node does not cross page boundary-- DO IF (EnvBaseRelOrdPtr[node] + n) >= pHeapAllocEnd THEN Error[]; IF Environment.PageFromLongPointer[@Environment.first64K[node + n - 1]] = Environment.PageFromLongPointer[@Environment.first64K[node]] THEN EXIT; -- ELSE node crosses page boundary. Move up to page boundary and retry: node Ź LOOPHOLE[((LOOPHOLE[node, CARDINAL] + wordsPerPage - 1) /wordsPerPage)*wordsPerPage]; ENDLOOP; pHeapAllocNext Ź EnvBaseRelOrdPtr[node] + n; s Ź okay; END; FreeNode: PUBLIC --ResidentHeap.-- PROCEDURE [ p: Environment.Base RELATIVE POINTER, location: ResidentHeap.HeapLocation Ź first64K] -- For simplicity, FreeNode does nothing immediately; all of the temporary -- storage allocated is freed en masse after the BootChannel is closed. RETURNS [s: Zone.Status] = {RETURN[okay]}; FreeResidentHeap: PROC[] = INLINE { -- Recover any ResidentHeap allocated during BootChannel Creation. pHeapAllocNext Ź pHeap}; --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- ResidentMemory implementation, for allocating storage in the germ's world. -- See Storage Allocation notes at head of module. -- Allocate* and Free* may not be called during inLoad and outLoad, because -- the configuration of real memory must be static while the operations are -- in progress. -- For simplicity, the Free* calls do nothing immediately; all of the temporary -- storage allocated is freed en masse after the BootChannel is closed. residentMemoryLock: PUBLIC --ResidentMemory.-- MONITORLOCK; allocationDifficulty: { easy, -- highestMappedPage is valid and that's where to get real mem from. hard, -- highestMappedPage is not valid, but could be made so. impossible}; -- storage allocation not allowed at the moment. pageAllocFirst: PageNumber; -- end permanent storage / begin temp storage. pageAllocNext: PageNumber; -- next page to be allocated. highestMappedPage: PageNumber; -- value only valid if allocationDifficulty=easy. allocateMDSInternal: PUBLIC --ResidentMemory.-- --INTERNAL-- ResidentMemory.AllocateMDSInternal Ź [AllocateMDSLocal]; AllocateMDSLocal: PROC [count: PageCount] RETURNS [p: POINTER TO UNSPECIFIED] = BEGIN realPage: PageMap.RealPageNumber; IF allocationDifficulty = impossible THEN Error[]; -- can't alloc storage now IF allocationDifficulty = hard THEN { CompactVM[onlyKeepVanillaRealMemory: TRUE]; allocationDifficulty Ź easy}; p Ź PointerFromPage[pageAllocNext]; THROUGH [0..count) DO IF pageAllocNext >= pageEndGermVM THEN Error[]; -- out of germ vm. -- Snatch real page from last mapped page: realPage Ź PageMap.ExchangeFlags[ virtual: highestMappedPage, newFlags: flagsVacant].real; highestMappedPage Ź highestMappedPage-1; PageMap.SetMapFlags[ virtual: pageAllocNext, real: realPage, flags: flagsClean]; pageAllocNext Ź pageAllocNext+1; ENDLOOP; END; allocateInternal: PUBLIC --ResidentMemory.-- --INTERNAL-- ResidentMemory.AllocateInternal Ź [AllocateLocal]; AllocateLocal: PROC [ location: ResidentMemory.Location, count: PageCount] RETURNS [lp: LONG POINTER TO UNSPECIFIED] = -- Note that mds = first64K = hyperspace for the Germ. -- (Should actually check here to verify that location # pda. {RETURN[LONG[AllocateMDSLocal[count]]]}; freeInternal: PUBLIC --ResidentMemory.-- --INTERNAL-- ResidentMemory.FreeInternal Ź [FreeLocal]; FreeLocal: PROC [ location: ResidentMemory.Location, count: PageCount, lp: LONG POINTER TO UNSPECIFIED] = {}; -- (freed when channel closed) FreeTempResidentMemory: PROC [highestMappedPage: PageNumber] = { -- Recover any ResidentMemory allocated during BootChannel Creation. realPage: PageMap.RealPageNumber; FOR page: PageNumber IN [pageAllocFirst..pageAllocNext) DO realPage Ź PageMap.ExchangeFlags[ virtual: page, newFlags: flagsVacant].real; PageMap.SetMapFlags[ virtual: (highestMappedPage Ź highestMappedPage+1), real: realPage, flags: flagsClean]; ENDLOOP; pageAllocNext Ź pageAllocFirst}; AnyTempStorageAllocated: PROC RETURNS [anyAllocate: BOOLEAN] = INLINE { RETURN[pageAllocNext ~= pageAllocFirst]}; --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- System implementation. -- usec/sec * (hundredPulses/usec) * (100 pulses/hundredPuliss) MicrosecondsToPulses: PUBLIC --System.-- PROC [usec: System.Microseconds] RETURNS [System.Pulses] = BEGIN RETURN[ [ Times10[ Times10[LongDivide[ num: usec, den: ProcessorFace.microsecondsPerHundredPulses]]]]]; END; Times10: PROC [in: LONG CARDINAL] RETURNS [out: LONG CARDINAL] = { in Ź in + in; -- in = 2x out Ź in + in; -- out = 2*2x = 4x out Ź out + out + in}; -- out = 2*2*2x + 2x = 10x LongDivide: PROC [num: LONG CARDINAL, den: CARDINAL] RETURNS [quo: LONG CARDINAL Ź 0] = BEGIN OPEN n: LOOPHOLE[num, MACHINE DEPENDENT RECORD [lo, hi: CARDINAL]], q: LOOPHOLE[quo, MACHINE DEPENDENT RECORD [lo, hi: CARDINAL]]; quo Ź 0; num Ź num + (den - 1); q.hi Ź n.hi/den; n.hi Ź n.hi - q.hi*den; quo Ź quo + LONG[Inline.LongDiv[num, den]]; END; FlushMemory: PROCEDURE [startPage, endPage: PageNumber] = -- this causes real memory behind [startPage..endPage) to be made Vacant. BEGIN state: PageMap.State; realPage: PageMap.RealPageNumber; FOR page: PageNumber IN [startPage..endPage) DO [oldState: state, real: realPage] Ź PageMap.ExchangeFlags[ virtual: page, newFlags: flagsVacant]; IF state.flags ~= flagsVacant THEN PageMap.SetMapFlags[ virtual: IF (highestMappedPage Ź highestMappedPage+1) = pageGFT THEN (highestMappedPage Ź highestMappedPage+1) ELSE highestMappedPage, real: realPage, flags: flagsClean]; ENDLOOP; END; --FlushMemory-- --~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ BEGIN --main body code.. initialization-- -- Calls ProcessRequests[], which never returns. -- Assumes all SD entries set initally zero by MakeBoot. pageGermEnd: PageNumber; -- end of Germ's VM allocated by MakeBoot. ProcessorFace.SpecialSetMP[PilotMP.cGerm]; -- let them know we are here -- Interrupts are supposed to be disabled by the boot button, but just in case.. ProcessOperations.WriteWDC[1]; SDDefs.SD[SDDefs.sCodeTrap] Ź LOOPHOLE[CodeTrap]; -- (start traps) SDDefs.SD[SDDefs.sControlTrap] Ź LOOPHOLE[ControlTrap]; SDDefs.SD[SDDefs.sRescheduleError] Ź LOOPHOLE[RescheduleErrorTrap]; SDDefs.SD[SDDefs.sSignal] Ź SDDefs.SD[SDDefs.sError] Ź LOOPHOLE[SignalHandler]; IF PageMap.IsMapped[Environment.PageFromLongPointer[@PSB.PDA.fault]] THEN -- Clear fault queues to aid debugging (makes fault cause reschedule error). PSB.PDA.fault Ź ALL[[PSB.QueueEmpty, ConditionEmpty]]; ProcessorFace.Start[]; -- no heap allocation allowed during initialization. pHeapAllocNext Ź pHeapAllocEnd; BEGIN realPage: PageMap.RealPageNumber; -- (ProcessorFace must be started previously) CompactVM[]; -- (We don't have to compact now, we just need highest mapped page) -- reclaim real page behind ESCTrapTable realPage Ź PageMap.ExchangeFlags[ virtual: Environment.PageFromLongPointer[PrincOps.ESCTrapTable], newFlags: flagsVacant].real; PageMap.SetMapFlags[ virtual: (highestMappedPage Ź highestMappedPage+1), real: realPage, flags: flagsClean]; END; allocationDifficulty Ź easy; -- end of Germ's VM allocated by MakeBoot. pageGermEnd Ź pageGerm + Boot.pCountGerm; -- Flush any excess real memory from the Germ's VM: -- (Real memory may be there from the action of the initial microcode, -- or as a result of microcode+Germ swapping.) FlushMemory[pageGermEnd, pageEndGermVM]; -- Identify germ boundaries and make code readOnly. BEGIN FlagsOr: PROCEDURE [flags1, flags2: PageMap.Flags] RETURNS [PageMap.Flags] = LOOPHOLE[Inline.BITOR]; gatesOfHellDesc: PrincOpsExtras2.ControlLink = LOOPHOLE[GermMarkers.GatesOfHellMarker, PrincOpsExtras2.ProcDesc]; globalCodebase: LONG POINTER = SELECT gatesOfHellDesc.tag FROM shortProc => FrameExtras.ReadCodebase[ FrameExtras.LongGFToGFTHandle[LONG[gatesOfHellDesc.gf - PrincOpsExtras2.ControlLinkTag.shortProc.ORD]]].codebase, longProc => FrameExtras.ReadCodebase[ LOOPHOLE[gatesOfHellDesc, PrincOpsExtras2.ProcDesc].gfi - PrincOpsExtras2.ControlLinkTag.longProc.ORD].codebase, ENDCASE => NIL; gatesOfHellPage: PageNumber = Environment.PageFromLongPointer[ globalCodebase + LOOPHOLE[gatesOfHellDesc, PrincOpsExtras2.ProcDesc].pc / bPW]; oldflags: PageMap.Flags; FOR page: PageNumber IN [gatesOfHellPage + 1..afterPage] DO [state:[flags: oldflags]] Ź PageMap.GetState[page]; [] Ź PageMap.ExchangeFlags[ virtual: page, newFlags: FlagsOr[oldflags, PageMap.maskReadOnly]]; ENDLOOP; -- Germ's page buffer now lives on top of gatesOfHell marker, separate from -- any other permanent storage allocated following. pageBuffer Ź gatesOfHellPage; pBuffer Ź PointerFromPage[pageBuffer]; END; -- Init storage allocation to start just after germ code. -- Set up structures which must live forever, i.e., through world swaps, -- then init beginning of temp storage after that. pageAllocNext Ź pageGermEnd; heads.Start[]; -- start the heads (who could allocate resident memory) -- The size of the heap must be fixed at germ init time because memory -- cannot always be allocated later. In order not to tie up extra real memory, -- several assumptions are employed here in determining heap size. If these -- assumptions become invalid, the likely result will be MP 909 for heap -- overflow. -- Assumptions are as follows: The required size of the heap varies -- considerably depending on what disks are attached to the system being -- booted. The disk subsystem requires the largest heapspace of the various -- boot channels so is used to calculate the size to allocate. The maximum -- number of disk controllers is 1, and the disk boot channel allocates 2 -- disk operations. -- Heads must have been started. BEGIN maxDiskControllers: CARDINAL = 7; maxDiskOps: CARDINAL = 2; wordsSmallResHeapStorage: CARDINAL = 200; -- amount left in AV page. heapWordsNeeded: CARDINAL Ź (maxDiskControllers * (PilotDiskFace.GetControllerAttributes[ PilotDiskFace.GetNextController[PilotDiskFace.nullControllerHandle]] .globalStateSize + PilotDiskFace.operationAlignment - 1)) + (maxDiskOps * (PilotDiskFace.operationSize + PilotDiskFace.operationAlignment - 1)); IF heapWordsNeeded <= wordsSmallResHeapStorage THEN BEGIN pHeap Ź LOOPHOLE[@PrincOps.AV[PrincOps.AVHeapSize]]; pHeapAllocEnd Ź pHeap + wordsSmallResHeapStorage; END ELSE BEGIN pages: CARDINAL Ź (heapWordsNeeded + wordsPerPage - 1)/wordsPerPage; pHeap Ź LOOPHOLE[AllocateMDSLocal[count: pages]]; pHeapAllocEnd Ź pHeap + pages * wordsPerPage; END; pHeapAllocNext Ź pHeap; END; BEGIN -- Initialize the BootChannels.. allow them to allocate permanent storage: location: Boot.Location; location.deviceType Ź Device.nullType; [] Ź --(null device doesn't really create a Channel; just inits)-- importedBootChannel.Create[@location, read]; END; -- Remember end of permanent storage / begin temp storage now that Heads etc. -- have had their chance. pageAllocFirst Ź pageAllocNext; FreeResidentHeap[]; -- initialize/reset heap allocator. -- The following correspondences {codePackIndex, procedure} must be the same -- as in PilotKernel. IF YOU MAKE A CHANGE HERE, make the corresponding -- change there too. BEGIN --workaround for compiler constant folding problem-- index: GermOps.SharedCode; -- TEMP <> index Ź codePackA; GermOps.pCodeSharingHandles[index] Ź ProcessorFace.Start; <> index Ź codePackB; GermOps.pCodeSharingHandles[index] Ź LOOPHOLE[PilotDiskFace.InitializeController, PROCEDURE]; <> index Ź codePackC; GermOps.pCodeSharingHandles[index] Ź -- LOOPHOLE[EthernetFace.TurnOn]; -- may be unbound. <> index Ź codePackD; GermOps.pCodeSharingHandles[index] Ź NIL; END; --workaround for compiler constant folding problem-- Frame.SetReturnLink[ Inline.LowHalf[ LOOPHOLE[PrincOpsExtras2.trapLink]]]; -- (just in case) ProcessRequests[]; -- never returns. END; --main body code.. initialization-- END. LOG (For earlier log entries, see Mesa 8.0 archive version.) 3-Nov-81 19:01:38 WDK Germ is now a coroutine with Pilot. Major rework of InLoad and OutLoad. Germ moves to mds 0. New instruction set. Make compatible with new linkage mechanism in GermOps. Module renamed from BootSwapGerm to GermOpsImpl. 4-Nov-81 9:06:23 JGS EXPORT ResidentHeapImpl. 10-Nov-81 21:44:59 WDK ResidentHeap.MakeNode must not cross page boundaries for DLion. 17-Nov-81 9:49:28 WDK Added Noop Action. 22-Nov-81 15:42:09 WDK Export GermOps. 23-Nov-81 10:22:30 JGS Check curMapEntry >= endMapEntry in 1st of OR in Outload. 23-Nov-81 16:10:33 FXH entriesPerHeader ==> entriesPerTrailer in end of outload. 10-Dec-81 11:40:57 AWL System.MicrosecondsToPulses implemented here. 25-Oct-82 14:40:11 WDK Made compatible with new PageMap. 22-Dec-82 11:01:47 AWL Long page numbers, HeapLocation args to makeNode and FreeNode. 26-Feb-83 13:29:31 AWL Get rid of compiler truncation warnings. When storing page into a BootFile MapEntry in DoOutLoad, explicitly shorten it (BootFile.PageNumber[page]). 6-Jun-83 9:29:43 WDK Get LongPointerFromPage from Environment. Add check for too-big vm page number. Make compatible with new BootChannel, handling returned errors and new Locations. Add debug via mp facility, controlled by boot switch. Documented debugging and tuning strategies. Add another check for running out of real memory. Use unused AV for resident heap space. Recover real page behind esc trap table. 19-Jul-83 16:15:58 AWL CodeTrap changes for 32-bit procedure descriptors. BootFile.{PageNumber, RealPageNumber} are dead. Misc changes for 32-bit procedure descriptors. 21-Jul-83 15:08:39 AWL GetMainBody from RuntimeInternal not ControlModuleFormat. 27-Jul-83 12:27:42 AWL MakeNode[0] returns Zone.nil. 10-Aug-83 10:42:20 JXG mods to allow germ to load into special memory - export GetNextPilotVM 13-Sep-83 13:39:42 KAM fixed GetNextPilotVM so it returns vm interval if handed an arbitrary page 21-Sep-83 8:47:37 WDK Must set extension version sooner. 28-Oct-83 12:21:03 WDK Restored GetNextPilotVM to documented semantics (i.e. analagous as ProcessorFace). 28-Nov-83 17:25:59 WDK Turn debug mode off. 13-Jun-84 12:49:08 AWL New BootChannel interface for multiple buffering. Increase size of resident heap to 200 words. 8-Nov-84 13:51:43 KEK added code to reclaim memory behind floppy and initialization code (including MarkerPages and Start). 19-Mar-85 17:04:01 CAJ Moved {GatesOfHell, Before, Middle, After}Marker to GermMarkers, rearranged packaging order. 18-Apr-85 13:35:39 AWL Can't free global frame via Frame.Free! 2-Oct-85 23:09:15 CAJ Moved freeing of Floppy code and GatesOfHell; CompactVM with onlyKeepVanillaRealMemory=TRUE in AllocateMDSLocal. 17-Oct-85 11:02:07 CAJ Turn debug mode off for 12.0 release. 4-Sep-86 15:42:53 CAJ Add large object handling to ResidentHeap; MakeNode now pays attention to requested alignment. Turn debug back on. 4-Nov-86 7:11:05 CAJ Add transferPrimer call to outload. Make heap annex allocated only if disk op won't fit regular heap (until VM size overflow for Dove germ is resolved). 15-Jan-87 16:32:59 CAJ Changes to replace BoundsVanillaMemory with BoundsReservedMemory, which is same thing with reversed semantics, to allow Daisy to join the crew. 20-Jun-86 17:56:26 MEW Upgraded to move global frames out of MDS. (MDS relief) 16-Jan-87 11:46:52 CAJ MDS relief: merge in changes of 2 previous log entries. 19-Jan-87 6:51:00 CAJ Move page buffer on top of gatesOfHell marker instead of allocating at end of germ with other allocated storage to reclaim a page of VM. 27-Apr-87 13:08:53 CAJ BootChannel.Create now passes a buffer on non-init Creates. Remove transferPrimer. Remove heap annex restrictions. Turn debug off. Correct some comments. 15-Jun-87 10:11:47 CAJ Add real buffer to rawRead Create. 27-Oct-87 12:21:04 CAJ Make heap size determined at init time based on disk storage requirements. Remove heap annex. 23-Nov-87 8:37:06 CAJ Make markers global. Avoid flushing floppy code if booting from floppyTape. Add PLocation arg to GetTeledebugged. (GermOpsImpl is different from the corresponding 13.0 version only in the use of PilotDiskFace.operationAlignment, which differs between 13 and 14.)