-- Control>PilotControl.mesa   ( 6-Apr-82 13:43:20 by Levin)

DIRECTORY
  Boot USING [Location, LP, LVBootFiles, nullDiskFileID, pRequest, Request],
  BootSwap USING [
    GetPStartListHeader, Initialize, InitializeMDS, mdsiGerm, sPilotSwitches],
  CommunicationPrograms USING [InitializeCommunication],
  ControlPrograms USING [SystemImpl],
  DebuggerSwap USING [Parameters],
  Device USING [nullType, Type],
  DriverStartChain USING [Start],
  Environment USING [
    maxPagesInMDS, PageCount, PageNumber, PageOffset, wordsPerPage],
  File USING [Capability, ID, nullID, PageNumber, Permissions, read, write],
  Frame USING [Free, GetReturnFrame, GetReturnLink, SetReturnFrame],
  HeadStartChain USING [Start],
  KernelFile USING [Pin],
  MiscPrograms,
  PilotClient USING [Run],
  PilotMP USING [
    Code, cBadBootFile, cClient, cCommunication, cControl, cMap, cStorage],
  PilotSwitches USING [],
  PrincOps USING [ControlLink, NullFrame, StateVector],
  Process USING [GetPriority, Priority, SetPriority],
  ProcessOperations USING [WriteWDC],
  ProcessorFace USING [SetMP, Start],
  ProcessPriorities USING
    [priorityClient, priorityPageFaultLow],
  RealMemory USING [Initialize, MoveToDisplayMemory],
  Runtime USING [CallDebugger, IsBound],
  RuntimePrograms USING [InitializeFrameImpl,
    InitializeInterrupt, InitializeInstructions, InitializePilotLoadState,
    InitializePilotNub, InitializeProcesses, InitializeSignals,
    InitializeSnapshot, Start, Traps],
  SDDefs USING [SD],
  Space USING [
    CopyIn, Create, defaultWindow, Delete, Handle, Kill, LongPointer, Map,
    nullHandle, PageNumber, WindowOrigin],
  SpecialSystem USING [NetworkAddress, nullNetworkAddress],
  StartList USING [
    Entry, Index, Header, SpaceIndex, SpaceType, StartIndex,
    SwapUnitInfo, Base, VersionID],
  StoragePrograms USING [
    DescribeSpace, empty, free, HandleFromPage, InitializeFileMgr,
    InitializeFiler, InitializeMStore, InitializeRegionCacheA,
    InitializeRegionCacheB, InitializeResidentMemoryA,
    InitializeResidentMemoryB, InitializeSimpleSpace,
    InitializeSwapper, InitializeTransactionData,
    InitializeVMMgr, IsUtilityPilot, LongPointerFromPage,
    nullSpaceHandle, outlaw, PageFromLongPointer, RecoverTransactions,
    ReplacementProcess, SpaceOptions, StartListProc, SuperFromPage],
  StoreDriverStartChain USING [Start],
  SwapperDriverStartChain USING [Start],
  System USING [GetLocalTimeParameters, LocalTimeParametersUnknown],
  SystemInternal USING [Unimplemented],
  TemporaryBooting USING [Switches],
  VMMapLog USING [
    Descriptor, EntryPointer, PatchTable, PatchTableEntry,
    PatchTableEntryPointer],
  XferTrap USING [WriteXTS];

PilotControl: PROGRAM
  IMPORTS
    Boot, BootSwap, CommunicationPrograms, ControlPrograms, DriverStartChain,
    Frame, HeadStartChain, KernelFile, MiscPrograms,
    PilotClient, Process, ProcessOperations, ProcessorFace, RealMemory, Runtime,
    RuntimePrograms, Space, StoragePrograms, StoreDriverStartChain,
    SwapperDriverStartChain, System, SystemInternal, XferTrap
  EXPORTS DebuggerSwap, PilotSwitches, StoragePrograms, System
  SHARES File, RuntimePrograms =
  BEGIN OPEN Environment;

  PEntry: TYPE = POINTER TO StartList.Entry;  -- for debugger

  --PilotSwitches.--switches: PUBLIC TemporaryBooting.Switches;

  -- EXPORTed to StoragePrograms:
  countVM: PUBLIC PageCount _ 40000B; -- size of VM implemented on
        -- a D0.  Should come from ProcessorFace!  ("_" due
        -- to compiler glitch)
  pageMDS: PUBLIC Environment.PageNumber; -- first page of Pilot's (only) MDS.
  lpMDS: PUBLIC LONG POINTER; -- to Pilot's (only) MDS.
  pageHyperspace: PUBLIC Environment.PageNumber; -- first page of
        -- non-MDS non-Germ VM.  (Hyperspace is assumed to follow MDS.)
  countHyperspace: PUBLIC Environment.PageCount;
  pageMDSGerm: PUBLIC Environment.PageNumber; -- first page of Germ's MDS.
  tableBase: PUBLIC StartList.Base; -- base pointer of the Start List.

  -- EXPORTed to System:  (exported here until directed exports appear)
  NetworkAddress: PUBLIC TYPE = SpecialSystem.NetworkAddress;
  nullNetworkAddress: PUBLIC NetworkAddress _
        SpecialSystem.nullNetworkAddress;

  -- EXPORTed to DebuggerSwap:
  canSwap: PUBLIC BOOLEAN _ FALSE; -- can we get to the debugger
  parameters: PUBLIC DebuggerSwap.Parameters;

  -- Parameters to PilotControl (from the booter via the germ):
  request: Boot.Request _ LOOPHOLE[Boot.LP[
    highbits: BootSwap.mdsiGerm, lowbits: Boot.pRequest], LONG POINTER TO
    Boot.Request]^; -- parameter to the germ which loaded us

  -- Assorted global variables:
  h: POINTER TO StartList.Header;
  -- Map log and patch table descriptor (see also CachedRegionImpl):
  mapLogDescriptor: VMMapLog.Descriptor _
    [self:, writer: FIRST[VMMapLog.EntryPointer],
     reader: FIRST[VMMapLog.EntryPointer],
     limit: FIRST[VMMapLog.EntryPointer],
     patchTable: @dummyPatchTable.patchTable]; -- overwritten by CachedRegionImpl
  DummyPatchTable: TYPE = RECORD [
    patchTable: VMMapLog.PatchTable,
    entries: ARRAY [0..5) OF VMMapLog.PatchTableEntry];
  dummyPatchTable: DummyPatchTable _
    [ [limit: FIRST[VMMapLog.PatchTableEntryPointer],
       maxLimit:
           FIRST[VMMapLog.PatchTableEntryPointer]
           + 5*SIZE[VMMapLog.PatchTableEntry],
       entries:], ];
  Bug: PRIVATE --PROGRAMMING--ERROR [type: BugType] = CODE;
  BugType: TYPE = {bug0, bug1, bug2, bug3, bug4, bug5, bug6, bug7, bug8, bug9};

  -- Heart of PilotControl
  ProcessStartList: PROCEDURE = -- Assume called from main body
    BEGIN
    pSwitches: LONG POINTER TO TemporaryBooting.Switches =
        LOOPHOLE[Boot.LP[
            highbits: BootSwap.mdsiGerm,
            lowbits: @SDDefs.SD[BootSwap.sPilotSwitches]]];
    lvBootFiles: Boot.LVBootFiles;
    dT: Device.Type; -- device type for debugger boot files
    dO: CARDINAL; -- device ordinal for debugger boot files
    state: PrincOps.StateVector;
    pageEndHyperspace: Environment.PageNumber;
    pageExcessRealMemory: PageNumber; -- real pages not backing
            -- bootloaded stuff.
    pageFreeVM: PageNumber; -- VM following that allocated by StartPilot.

    moveToReserved: BOOLEAN _ TRUE;  -- seems to work fine..

    -- Free the local frame of our MainBody code (who called us):
    Frame.Free[Frame.GetReturnFrame[]];

    -- Get keySwitch settings:
    switches _ pSwitches^;
    switches.u _ up; -- only Pilot sets UtilityPilot-ness

    ProcessorFace.SetMP[PilotMP.cControl];

    -- Get start traps working first.
    RuntimePrograms.Start[LOOPHOLE[RuntimePrograms.Traps]];

    -- Initialize processor face and real memory allocation table:
    ProcessorFace.Start[];
    RealMemory.Initialize[];

    BootSwap.InitializeMDS[]; -- (sets pMon)
    h _ BootSwap.GetPStartListHeader[];
    tableBase _ h.table;
    IF h.version ~= StartList.VersionID THEN
      Punt[PilotMP.cBadBootFile];  -- not the version of StartList
            -- we were compiled with
    pageMDSGerm _ BootSwap.mdsiGerm*maxPagesInMDS;
    pageMDS _ StoragePrograms.PageFromLongPointer[
        LOOPHOLE[1, POINTER]]; -- ("1" since "0" collides with NIL)
    lpMDS _ StoragePrograms.LongPointerFromPage[pageMDS];
    pageHyperspace _ pageMDS + maxPagesInMDS; -- follows MDS.
    pageEndHyperspace _
      IF pageMDSGerm > pageHyperspace THEN pageMDSGerm
      ELSE FIRST[PageNumber] + countVM; -- ends at Germ or end of VM.
    countHyperspace _ pageEndHyperspace - pageHyperspace;
    pageFreeVM _ h.lastVMPage + 1;
    pageExcessRealMemory _ h.lastBootLoadedPage + 1;

    MiscPrograms.InitializeUtilities[]; -- (must preceed Frames.)

    -- Initialize Mesa runtime:
    RuntimePrograms.InitializeInstructions[];
    Frame.SetReturnFrame[PrincOps.NullFrame];  -- so Processes
        -- can find top frame of this process and Detach it.
    RuntimePrograms.InitializeProcesses[
        pagePDA: h.pdaBase, countPDA: h.pdaPages];
    Process.SetPriority[ProcessPriorities.priorityClient];  -- default
            -- priority for Pilot processes that don't care.
    RuntimePrograms.InitializeFrameImpl[];  -- must follow Processes
        -- and Utilities.
    RuntimePrograms.InitializeSignals[];
    RuntimePrograms.InitializePilotNub[
      pageLoadState:
          tableBase[tableBase[h.initLoadState].parent].vmpage
          + tableBase[h.initLoadState].base,
      countLoadState: tableBase[h.initLoadState].pages,
      pVMMapLog: @mapLogDescriptor];
    BootSwap.Initialize[mdsiOther: BootSwap.mdsiGerm];
    InitializeDebuggerSwap[];  -- read in germ for debugger's world.
    -- InterruptKey is started below after KeyboardFace
    --    implementation is started.
    -- SnapshotImpl and PerformancePrograms are started below
    --    after the virtual memory is running.

    -- Mesa runtime now fully operational;  can swap if
    --    debugger pointers set with Othello command.
    IF switches.zero = down THEN Runtime.CallDebugger["Key Stop 0"];

    -- Get basic real and virtual memory facilities working:

    StoragePrograms.InitializeMStore[];
    -- Give excess real memory to MStore:
    StoragePrograms.DescribeSpace[
      StoragePrograms.free, pageExcessRealMemory,
      pageEndHyperspace - pageExcessRealMemory, Space.defaultWindow];
    -- Enumerate non-empty initially resident spaces, initialize VM allocator:
    StoragePrograms.InitializeSimpleSpace[];
    -- Tell SimpleSpace about unused hyperspace VM in which it
    --    can create SimpleSpaces:
    StoragePrograms.DescribeSpace[
      StoragePrograms.empty, pageFreeVM, pageEndHyperspace - pageFreeVM,
      Space.defaultWindow];
    -- Create region cache, initializes AllocateRuthlessly:
    StoragePrograms.InitializeRegionCacheA[];
    StoragePrograms.InitializeResidentMemoryA[];

    -- ResidentMemory now operational.
    MiscPrograms.InitializeZone[];
    MiscPrograms.InitializeResidentHeap[];
    HeadStartChain.Start[]; -- start heads

    RuntimePrograms.InitializeInterrupt[];  -- now that KeyboardFace.keyboard is defined
    START ControlPrograms.SystemImpl;

    StoreDriverStartChain.Start[];  -- start drivers used by Store

    -- Initialize the Store configuration.
    BEGIN OPEN StoragePrograms;
    ProcessorFace.SetMP[PilotMP.cStorage];
    switches.u _ IF IsUtilityPilot[] THEN down ELSE up;

    InitializeFiler;

    InitializeSwapper[@mapLogDescriptor];  -- SimpleSpace I/O
        -- is now operational.

    -- Describe initallyResident, cachedDescriptor, and
    --    outlaw Spaces to Swapper:
    InitializeRegionCacheB[];  -- describes region cache space.
    InitializeResidentMemoryB[];  -- describes resident memory spaces.
    -- Describe Germ MDS space:
    DescribeSpace[StoragePrograms.outlaw, pageMDSGerm,
                  maxPagesInMDS, Space.defaultWindow];
    -- Plant outlaw space on unmapped page 0 (LONG[NIL]^):
    DescribeSpace[
      StoragePrograms.outlaw, FIRST[PageNumber], 1, Space.defaultWindow];
    -- Plant outlaw space on unmapped mds page 0 (NIL^):
    IF pageMDS~=FIRST[PageNumber] THEN
      DescribeSpace[StoragePrograms.outlaw, pageMDS, 1, Space.defaultWindow];
    -- Describe non-empty initallyResident spaces:
    EnumerateStartList[DescribeInitiallyResidentSpaces];

    -- Start the virtual memory replacement process:
    BEGIN
    -- countThreshold is for replacement algorithm in
    --     MStore.AwaitBelowThreshold.
    throwAway: PROCESS;
    countThreshold: PageCount _ 4;
    priorityPrev: Process.Priority _ Process.GetPriority[];
    Process.SetPriority[ProcessPriorities.priorityPageFaultLow];
    throwAway _ FORK ReplacementProcess[ -- (no profit in detaching)
        IF IsUtilityPilot[] THEN 0 ELSE countThreshold];
    Process.SetPriority[priorityPrev];
    END;

   SwapperDriverStartChain.Start[];

    -- Part one of Transactions initialization: exported variables
    --    and simple spaces.
    InitializeTransactionData[];

    -- Start FileMgr, which will find system volume
    --    and debugger booting information:
    [debuggerDeviceType: dT, debuggerDeviceOrdinal: dO] _
      InitializeFileMgr[
        @LOOPHOLE[request.location, disk Boot.Location], @lvBootFiles];
    IF ~switches.u = down THEN
      EnumerateStartList[PinResidentDescriptorPageGroups];

    -- Set up debug pointers if necessary, also maybe disable map logging:
    SELECT TRUE FROM
      switches.k=down AND canSwap => NULL;  -- use the one we were given.
      switches.r=down => canSwap _ TRUE;  -- teledebugger.
	  -- first check for debugger on nondebugger volume type
      -- (but needing map logging), if not then check for remote debugger:
      dT#Device.nullType -- else see if FileMgr found a debugger.. --
      AND lvBootFiles[debugger].da ~= Boot.nullDiskFileID.da =>
	BEGIN
        parameters.locDebugger _
	  [deviceType: dT, deviceOrdinal: dO,
	  vp: disk[diskFileID: lvBootFiles[debugger]]];
        parameters.locDebuggee _
	  [deviceType: dT, deviceOrdinal: dO,
	  vp: disk[diskFileID: lvBootFiles[debuggee]]];
        canSwap _ TRUE; -- now can get to debugger
        END;
      ENDCASE; -- no debugger at all (formerly switches.m _ down. RL)
        -- (that needs map logging)

    --  Initialize the VMMgr:
    -- (also MapLogs the unitary and family spaces in the boot file.)
    InitializeVMMgr[countVM, @mapLogDescriptor];

    ProcessorFace.SetMP[PilotMP.cMap];
    -- Create swapUnits of non-initallyResident, non-cachedDescriptor spaces:
    EnumerateStartList[CreateInitiallyOutSpaces];

    -- Now everything allocated by StartPilot has been placed
    --    in the VMMgr databases and MapLogged.
    IF switches.one = down THEN Runtime.CallDebugger["Key Stop 1"];

    -- Move cool resident code pack to any available non-PrincOps
    --    real memory (e.g. Dandelion display memory):
    IF moveToReserved AND ~IsUtilityPilot[] THEN
      -- (GetAttributes not impl in UtilityPilot)
      RealMemory.MoveToDisplayMemory[ReservedMemoryHandle];

    RecoverTransactions[];
    END; -- of OPEN StoragePrograms

    -- Make sure LocalTimeParameters are saved on nonvolatile storage:
    [] _ System.GetLocalTimeParameters[
      ! System.LocalTimeParametersUnknown => CONTINUE];

    -- Initialize more of Misc configuration: 
    MiscPrograms.InitializeStream[];  -- (ByteBlt must be initialized first)

    -- Set default priority for those that don't care:
    Process.SetPriority[ProcessPriorities.priorityClient];

    RuntimePrograms.InitializeSnapshot[];  -- not initially resident
    MiscPrograms.InitializeHeap[];  -- uses Space
    DriverStartChain.Start[];  -- start remaining drivers
    ProcessorFace.SetMP[PilotMP.cCommunication];
    IF switches.c = up AND
      Runtime.IsBound[CommunicationPrograms.InitializeCommunication] THEN
      CommunicationPrograms.InitializeCommunication[];
    IF Runtime.IsBound[RuntimePrograms.InitializePilotLoadState] THEN
      RuntimePrograms.InitializePilotLoadState[
        tableBase[tableBase[h.initLoadState].parent].vmpage + tableBase[
	  h.initLoadState].base, tableBase[h.initLoadState].pages];
    -- Kill StartList so that UtilityPilot can Delete the space:
    Space.Kill[
       StoragePrograms.HandleFromPage[
          StoragePrograms.PageFromLongPointer[tableBase]]];
    -- Delete the StartList:
    Space.Delete[
       StoragePrograms.HandleFromPage[
          StoragePrograms.PageFromLongPointer[tableBase]]];

    -- Ready to start the client. . .
    ProcessorFace.SetMP[PilotMP.cClient];
    Process.SetPriority[ProcessPriorities.priorityClient];
    IF switches.two = down THEN Runtime.CallDebugger["Key Stop 2"L];
    state.instbyte _ state.stkptr _ 0;
    state.dest _ LOOPHOLE[PilotClient.Run, procedure PrincOps.ControlLink];
    state.source _ Frame.GetReturnLink[];  -- pass link for detached process to client.
    RETURN WITH state;  -- "call" PilotClient.Run, freeing our frame as we go.

    END;

  -- DescribeInitiallyResidentSpaces: Creates entries in the Swapper caches for (non-empty) initallyResident spaces.
  -- The motivations for this section are as follows:  The facility provided by the Swapper's DescribeSpace procedure is the only way to create and initialize space and region descriptors for data that are already in memory.  It is also the only way to create cachedDescriptor space and region descriptors.  Therefore, all initiallyResident or cachedDescriptor spaces and swapUnits must be processed by DescribeSpace, before the VMMgr is initialized.  To simplify our life, we require that all CachedDescriptor items be initiallyResident, thus restricting the processing here to only initiallyResident items.  (We don't process non-initiallyResident spaces and swapUnits here so as to minimize the amount of region cache space required during initialization, and to simplify the coding.)
  -- VMMControl.InitializeVMMgr uses the space and region cache entries created here to construct the initial Hierarchy and Projection databases, and to MapLog the mapped spaces.  For this process, the requirements on the caches are:  there must be a space cache entry for any space that is (itself) mapped;  there must be a region cache entry for every swapUnit.

  DescribeInitiallyResidentSpaces: StoragePrograms.StartListProc --[index]-- =
    -- Creates and maps spaces for:  all initiallyResident unitary or family spaces.
    -- Creates regions for:  all initiallyResident swap units, and unitary spaces.
    -- For the convenience of CreateInitiallyOutSpaces, the handle of each space entry is initialized to Space.nullHandle.
    -- Note: We assume that a family is entirely tiled with swap units (no holes).
    BEGIN
    defaultOptions: StoragePrograms.SpaceOptions =
      [ -- (the most probable options)
	-- The program logic below assumes these options as defaults!
	createSpace: FALSE, -- assume.
	pinSpaceD: FALSE, -- assume.
	mapped: TRUE, -- any non-empty space or swap unit is mapped.
	createRegion: TRUE, -- assume.
	pinRegionD: FALSE, -- assume.
	subspace: FALSE, -- assume.
	initiallyResident: TRUE, pinned: FALSE]; -- assume.
    options: StoragePrograms.SpaceOptions _ defaultOptions;
    -- set up the most probable options.
    WITH e: tableBase[index] SELECT FROM
      space => -- create space descriptor:
	BEGIN
	IF e.vmpage + e.pages > h.lastVMPage + 1 THEN ERROR Bug[bug1];
	e.handle _ LOOPHOLE[StoragePrograms.nullSpaceHandle];
	-- for CreateInitiallyOutSpaces.  (Note: Space.nullHandle is not initialized yet.)
	IF ~e.bootLoaded THEN RETURN;
	WITH t: e.type SELECT FROM
	  empty => RETURN; -- (handled separately by InitializeSimpleSpace)
	  unitary =>
	    options.pinSpaceD _
	      (tableBase[t.swapUnit].info.state = residentDescriptor);
	  family => options.pinSpaceD _ t.anyResidentDescriptorChildren;
	  ENDCASE => ERROR Bug[bug2];
	options.createSpace _ TRUE;
	options.createRegion _ FALSE;
	StoragePrograms.DescribeSpace[
	  options, e.vmpage, e.pages, WindowForSpace[LOOPHOLE[index]]];
	END;
      swapUnit => -- create region descriptor:
	BEGIN
	readOnlyWindow: Space.WindowOrigin =
	  [file: [File.nullID, File.read], base: 0];
	readWriteWindow: Space.WindowOrigin =
	  [file: [File.nullID, File.read + File.write], base: 0];
	IF tableBase[e.parent].bootLoaded THEN
	  BEGIN
	  options.subspace _ (tableBase[e.parent].type.class = family);
	  SELECT e.info.state FROM
	    resident => options.pinned _ TRUE;
	    residentDescriptor => options.pinRegionD _ TRUE;
	    swappable => --options.mapped _ TRUE--NULL;
	    ENDCASE => ERROR Bug[bug0];
	  StoragePrograms.DescribeSpace[
	    options, tableBase[e.parent].vmpage + e.base, e.pages,
	    IF e.info.readOnly THEN readOnlyWindow ELSE readWriteWindow];
	  END;
	END;
      ENDCASE => ERROR Bug[bug3];
    END;

  PinResidentDescriptorPageGroups: StoragePrograms.StartListProc --[index]-- =
    BEGIN
    WITH e: tableBase[index] SELECT FROM
      space => NULL;
      swapUnit =>
	IF e.info.state = residentDescriptor THEN
	  KernelFile.Pin[
	    file: [request.location.diskFileID.fID, File.read],
	    page: tableBase[e.parent].backingPage + e.base, count: e.pages];
      ENDCASE => ERROR;
    END;

  -- Creates and maps non-initiallyResident spaces.

  CreateInitiallyOutSpaces: StoragePrograms.StartListProc --[index]-- =
    -- Note: DescribeInitiallyResidentSpaces has initialized the handle of each space StartList.entry to Space.nullHandle.
    BEGIN
    WITH e: tableBase[index] SELECT FROM
      space => NULL;  -- defer creating ALL spaces so the space can be
                 -- correctly mapped to either the boot file or a temporary file
      swapUnit => -- We ASSUME that all swapUnit's of a space have the same
                      -- resident and readOnly attributes!!!
          BEGIN OPEN e;
          IF tableBase[parent].bootLoaded THEN RETURN;
          IF LOOPHOLE[tableBase[parent].handle, Space.Handle] = Space.nullHandle
           THEN CreateParent[parent, e.info.readOnly OR e.info.state = resident]; -- (sets handle)
          IF tableBase[parent].type.class = family THEN
             [] _ Space.Create[e.pages, LOOPHOLE[tableBase[parent].handle], base];
          END;
      ENDCASE => ERROR Bug[bug4];
    END;

  CreateParent: PROCEDURE [parent: StartList.SpaceIndex, mapToBootFile: BOOLEAN] =
    BEGIN OPEN p: tableBase[parent];
    parentsParent: Space.Handle;
    pageParentsParent: Space.PageNumber;
    window: Space.WindowOrigin;
    IF p.type.class = empty THEN ERROR Bug[bug5];
    [parentsParent, pageParentsParent] _ StoragePrograms.SuperFromPage[p.vmpage];
    p.handle _ LOOPHOLE[Space.Create[
      p.pages, parentsParent, p.vmpage - pageParentsParent]];
    window _ IF mapToBootFile THEN WindowForSpace[parent] -- map to boot file
                    ELSE Space.defaultWindow; -- map to temporary file
    Space.Map[LOOPHOLE[p.handle], window];
    IF ~mapToBootFile THEN -- must copy contents into the space in this case
       BEGIN
       --TEMPORARY BUG WORKAROUND.  We first touch the space before doing the
       -- CopyIn as CopyIn doesn't read the file if the space is out and dead as ours is.
       ptr: LONG POINTER TO WORD = Space.LongPointer[LOOPHOLE[p.handle]];
       ptr^ _ 0; -- THE WORKAROUND - touch the space
       Space.CopyIn[LOOPHOLE[p.handle], WindowForSpace[parent]];
       END;
    WITH t: p.type SELECT FROM
      family =>
          IF t.anyResidentDescriptorChildren THEN
             ERROR SystemInternal.Unimplemented;
      ENDCASE;
    END;

  WindowForSpace: PROCEDURE [space: StartList.SpaceIndex]
    RETURNS [Space.WindowOrigin] =
    BEGIN
    RETURN[
      Space.WindowOrigin[
	file: File.Capability[
	fID:
	SELECT tableBase[space].backingStore FROM
	  null => File.nullID,
	  self => request.location.diskFileID.fID,
	  ENDCASE => ERROR Bug[bug7],
	permissions:
	IF tableBase[space].readOnly THEN File.read ELSE File.read + File.write],
	base:
	tableBase[space].backingPage + request.location.diskFileID.firstPage]]
    END;

  EnumerateStartList: PUBLIC PROCEDURE [Proc: StoragePrograms.StartListProc] =
    BEGIN OPEN StartList;
    index: Index;
    size: CARDINAL;
    FOR index _ StartIndex, index + size UNTIL tableBase[index].option = stop DO
      Proc[index];
      size _
	WITH tableBase[index] SELECT FROM
	  space => SIZE[space Entry],
	  swapUnit => SIZE[swapUnit Entry],
	  ENDCASE => ERROR Bug[bug8];
      ENDLOOP;
    END;

  ReservedMemoryHandle: PROC = {};
  -- this procedure's only purpose is to provide a handle on the code pack to
  -- be moved to reserved memory

  InitializeDebuggerSwap: PROCEDURE =
    BEGIN OPEN parameters;
    locDebuggee _ LOOPHOLE[h.locDebuggee];
    locDebugger _ LOOPHOLE[h.locDebugger];
    -- Now can get to debugger if info was in boot file.
    IF locDebuggee.diskFileID.da ~= LOOPHOLE[LONG[0]] THEN canSwap _ TRUE;
    pMicrocodeCopy _ pGermCopy _ NIL; -- until microcode swapping installed

    END;

  -- When all else fails . . .
  Punt: PROCEDURE [c: PilotMP.Code] = INLINE
    {ProcessorFace.SetMP[c]; DO ENDLOOP};

  -- Main Body code:

  ProcessOperations.WriteWDC[1];
  -- Interrupts off (necessary for now on Dandelion)
  XferTrap.WriteXTS[off];
  ProcessStartList[]; -- never returns!

  END.

LOG
(For earlier log entries see Pilot 5.0 archive version.)

December 6, 1980  6:09 PM    Gobbel
   Move RuntimePerf, RuntimeLoader, and Communication out of kernel

December 15, 1980  3:11 PM    Gobbel
   Keyswitch for starting RuntimePerf code

January 7, 1981  12:13 PM    Gobbel
   Keyswitch for debuggers in nonstandard places that want map
   logging (for Bruce Malasky)

January 14, 1981  1:39 PM    Gobbel
   Move call to InitializeStream to after Store initialization; move
   cool resident code to funny memory

January 23, 1981  2:40 PM   Knutsen
   Start FrameImpl after Processes; shuffle process priorities

January 26, 1981  4:05 PM   Gobbel
   Add ReservedMemoryHandle;  AWL add swapper driver start chain

February 6, 1981  9:45 AM   Knutsen/McJones
   Call System.GetLocalParameters to make sure saved to nonvolatile storage.  PrincOps fields changed names.

February 17, 1981  9:15 PM   Knutsen
   Bug: root process wasn't properly Detached.  Make R switch imply canSwap.  Start using reserved memory.

March 9, 1981  5:54 PM   Yokota
   Statements associated with PerformancePrograms are eliminated.

 6-Apr-82 13:43:20   Levin
   Don't disable map logging if no debugger found.