-- Copyright (C) 1984  by Xerox Corporation. All rights reserved. 
-- BootServerFileTajo.mesa, HGM,  4-Jun-84 22:39:29 

DIRECTORY
  Ascii USING [CR],
  Checksum USING [ComputeChecksum],
  Environment USING [bytesPerPage, wordsPerPage],
  File USING [nullFile],
  Inline USING [LowHalf],
  MFile USING [
    AcquireTemp, AddNotifyProc, CopyFileHandle, Error, GetLength, GetProperties,
    GetTimes, Handle, ReadOnly, Release, ReleaseChoice, Rename, RemoveNotifyProc,
    SetAccess, SetTimes, SwapNames],
  MSegment USING [Address, Create, Handle, Delete],
  MStream USING [Copy, Create, GetLength, Handle, WriteOnly],
  Put USING [Text],
  Space USING [Map, nullInterval, Unmap],
  SpecialMFile USING [GetCapaWithAccess, LeaderPages],
  Stream USING [Block, Delete, GetBlock, Handle, PutBlock, SetPosition],
  String USING [AppendChar, AppendString, Equivalent],
  Time USING [Append, AppendCurrent, Current, Unpack],

  BootServer USING [AppendBFN],
  BootServerFriends USING [
    BootFile, EnumerateBootTable, pagesPerSwapUnit, ReleaseFile, timeNotKnown],
  PupWireFormat USING [
    BcplLongNumber, BcplToMesaLongNumber, MesaToBcplLongNumber];

BootServerFileTajo: MONITOR
  IMPORTS
    Checksum, Inline, MFile, MSegment, MStream, Put, Space, SpecialMFile, Stream,
    String, Time, BootServer, BootServerFriends, PupWireFormat
  EXPORTS BootServerFriends =
  BEGIN

  BootFile: TYPE = BootServerFriends.BootFile;
  FileHandle: PUBLIC TYPE = MFile.Handle;

  FileAlreadyActive: ERROR = CODE;
  FileNotLocked: ERROR = CODE;
  FileLocked: ERROR = CODE;
  FileBusy: ERROR = CODE;
  ConfusionInFlushOneSpace: ERROR = CODE;
  PageCountUnderflow: ERROR = CODE;

  pagesInVM: PUBLIC CARDINAL ¬ 0;
  maxPagesInVM: PUBLIC CARDINAL ¬ 4000; -- SmallTalk is using 3000 page boot files!

  ActivateFileSystem: PUBLIC PROCEDURE =
    BEGIN
    MFile.AddNotifyProc[Arrived, ["*", null, readOnly], NIL];
    MFile.AddNotifyProc[Died, ["*", null, writeOnly], NIL];
    END;

  DeactivateFileSystem: PUBLIC PROCEDURE =
    BEGIN
    MFile.RemoveNotifyProc[Arrived, ["*", null, readOnly], NIL];
    MFile.RemoveNotifyProc[Died, ["*", null, writeOnly], NIL];
    END;

  ActivateFile: PUBLIC ENTRY PROCEDURE [bf: BootFile] =
    BEGIN
    IF bf.handle # NIL THEN ERROR FileAlreadyActive;
    bf.handle ¬ MFile.ReadOnly[
      bf.fileName, [PleaseReleaseFile, bf] ! MFile.Error => CONTINUE];
    IF bf.handle = NIL THEN RETURN;
    BlessBootFile[bf];
    IF bf.handle = NIL THEN RETURN;
    bf.unknown ¬ FALSE;
    bf.file ¬ SpecialMFile.GetCapaWithAccess[bf.handle];
    bf.bytes ¬ MFile.GetLength[bf.handle];
    bf.pages ¬ Inline.LowHalf[
      (bf.bytes + Environment.bytesPerPage - 1)/Environment.bytesPerPage];
    END;

  BlessBootFile: PROCEDURE [bf: BootServerFriends.BootFile] =
    BEGIN
    IF bf.pup THEN BEGIN BlessPupBootFile[bf]; RETURN; END;
    IF ~TestFileChecksum[bf.handle] THEN
      BEGIN
      text: STRING = [100];
      Time.AppendCurrent[text];
      String.AppendString[text, "  "L];
      String.AppendString[text, bf.fileName];
      String.AppendString[text, " has a bad file checksum"L];
      LogString[text];
      MFile.Release[bf.handle];
      bf.handle ¬ NIL;
      bf.file ¬ File.nullFile;
      bf.unknown ¬ TRUE;
      RETURN;
      END;
    bf.create ¬ MFile.GetTimes[bf.handle].create;
    END;

  DeactivateFile: PUBLIC ENTRY PROCEDURE [bf: BootFile] =
    BEGIN
    IF bf.space # Space.nullInterval THEN ERROR FileBusy;
    IF bf.useCount # 0 THEN ERROR FileBusy;
    IF bf.handle = NIL THEN RETURN;
    bf.file ¬ File.nullFile;
    MFile.Release[bf.handle];
    bf.handle ¬ NIL;
    END;

  ReadStreamFromBootFile: PUBLIC ENTRY PROCEDURE [bf: BootFile]
    RETURNS [Stream.Handle] =
    BEGIN
    IF bf.useCount = 0 THEN ERROR FileNotLocked;
    RETURN[
      MStream.Create[
        MFile.CopyFileHandle[bf.handle, []], [PleaseReleaseStream, bf]]];
    END;

  SetupSpace: PUBLIC ENTRY PROCEDURE [bf: BootFile] =
    BEGIN
    IF bf.useCount = 0 THEN ERROR FileNotLocked;
    IF bf.space # Space.nullInterval THEN RETURN;
    UNTIL (pagesInVM + bf.pages) < maxPagesInVM DO
      IF pagesInVM = 0 THEN EXIT; -- In case SmallTalk gets even bigger!!
      FlushOneSpace[bf];
      ENDLOOP;
    bf.space ¬ Space.Map[
      window: [bf.file, SpecialMFile.LeaderPages[], bf.pages],
      class: file,
      access: readOnly,
      life: alive,
      swapUnits: [uniform[BootServerFriends.pagesPerSwapUnit]] ];
    pagesInVM ¬ pagesInVM + bf.pages;
    END;

  FlushOneSpace: INTERNAL PROCEDURE [first: BootFile] =
    BEGIN
    hit: BootFile ¬ NIL;
    FOR bf: BootFile ¬ first, bf.next UNTIL bf = NIL DO
      IF bf.useCount > 0 THEN LOOP;
      IF bf.space # Space.nullInterval THEN hit ¬ bf;
      ENDLOOP;
    IF hit = NIL THEN ERROR ConfusionInFlushOneSpace;
    KillSpaceInternal[hit];
    END;

  KillSpace: PUBLIC ENTRY PROCEDURE [bf: BootFile] =
    BEGIN IF bf.useCount # 0 THEN ERROR FileLocked; KillSpaceInternal[bf]; END;

  KillSpaceInternal: INTERNAL PROCEDURE [bf: BootFile] =
    BEGIN
    IF bf.pages > pagesInVM THEN ERROR PageCountUnderflow;
    [] ¬ Space.Unmap[bf.space.pointer, return];
    bf.space ¬ Space.nullInterval;
    pagesInVM ¬ pagesInVM - bf.pages;
    END;


  -- Routines used to receive new boot files from other serers

  CreateTempFile: PUBLIC PROCEDURE RETURNS [fh: MFile.Handle, sh: Stream.Handle] =
    BEGIN
    fh ¬ NIL;  -- In case volume full (or whatever)
    sh ¬ NIL;
    fh ¬ MFile.AcquireTemp[binary, 200*LONG[Environment.bytesPerPage] ! MFile.Error => CONTINUE];
    IF fh = NIL THEN RETURN;
    sh ¬ MStream.Create[MFile.CopyFileHandle[fh, []], []];
    END;

  MakeTempFileIntoBootFile: PUBLIC PROCEDURE [bf: BootFile, fh: MFile.Handle]
    RETURNS [ok: BOOLEAN] =
    BEGIN
    -- ** Check to see if we like it
    ok ¬ TRUE;
    IF TRUE THEN  -- BUGS AND KROCKS   ********************
      BEGIN
      to, from: Stream.Handle;
      to ¬ MStream.WriteOnly[bf.fileName, [], binary];
      from ¬ MStream.Create[MFile.CopyFileHandle[fh, [], readOnly], []];
      [] ¬ MStream.Copy[from: from, to: to, bytes: LAST[LONG CARDINAL]];
      Stream.Delete[from];
      Stream.Delete[to];
      MFile.Release[fh];
      RETURN;
      END;
    MFile.SetAccess[fh, rename];
    IF bf.handle = NIL THEN
      BEGIN
      MFile.Rename[fh, bf.fileName]  -- This doesn't work yet....
      END
    ELSE
      BEGIN
      old: MFile.Handle ¬ MFile.CopyFileHandle[bf.handle, []];
      MFile.SetAccess[
        old, rename ! MFile.Error => BEGIN ok ¬ FALSE; CONTINUE; END];
      IF ok THEN MFile.SwapNames[fh, old];
      MFile.Release[old];
      END;
    MFile.Release[fh];
    END;

  DeleteTempFile: PUBLIC PROCEDURE [fh: MFile.Handle] =
    BEGIN MFile.Release[fh]; END;


  -- Routines to process files retrieved via FTP or stored via FTPServe
  -- (also used indirectly if we retrieve it ourselves)
  -- Beware, these should not use the same LOCK or things will get tangled

  PleaseReleaseFile: PROCEDURE [file: MFile.Handle, instanceData: BootFile]
    RETURNS [MFile.ReleaseChoice] =
    BEGIN
    BEGIN
    name: STRING = [100];
    [] ¬ MFile.GetProperties[file, name];
    Hack[name, "ReleaseFile"L];
    END;
    BootServerFriends.ReleaseFile[instanceData];
    RETURN[goAhead];
    END;

  PleaseReleaseStream: PROCEDURE [stream: MStream.Handle, instanceData: BootFile]
    RETURNS [MFile.ReleaseChoice] =
    BEGIN
    BEGIN
    name: STRING = [100];
    [] ¬ MFile.GetProperties[instanceData.handle, name];
    Hack[name, "ReleaseStream"L];
    END;
    RETURN[later];
    END;

  Arrived: PROCEDURE [
    name: LONG STRING, file: MFile.Handle, clientInstanceData: LONG POINTER]
    RETURNS [BOOLEAN] =
    BEGIN
    Check: PROCEDURE [bf: BootFile] =
      BEGIN
      IF ~bf.inTransit AND ~bf.unknown THEN RETURN;
      IF ~String.Equivalent[name, bf.fileName] THEN RETURN;
      ActivateFile[bf];
      bf.inTransit ¬ FALSE;
      IF bf.handle = NIL THEN RETURN;
      AnnounceArrival[bf];
      END;
    BootServerFriends.EnumerateBootTable[Check];
    RETURN[FALSE];
    END;

  AnnounceArrival: PROCEDURE [bf: BootFile] =
    BEGIN
    text: STRING = [150];
    Time.AppendCurrent[text];
    String.AppendString[text, "  "L];
    String.AppendString[text, bf.fileName];
    String.AppendString[text, " (#"L];
    BootServer.AppendBFN[text, bf.code];
    String.AppendString[text, ") was created on "L];
    IF bf.create = BootServerFriends.timeNotKnown THEN
      String.AppendString[text, "???"L]
    ELSE Time.Append[text, Time.Unpack[bf.create]];
    LogString[text];
    END;

  Died: PROCEDURE [
    name: LONG STRING, file: MFile.Handle, clientInstanceData: LONG POINTER]
    RETURNS [BOOLEAN] =
    BEGIN
    Check: PROCEDURE [bf: BootFile] =
      BEGIN
      IF ~bf.inTransit THEN RETURN;
      IF ~String.Equivalent[name, bf.fileName] THEN RETURN;
      bf.inTransit ¬ FALSE;
      END;
    IF file = NIL THEN
      BEGIN  -- File was deleted
      BootServerFriends.EnumerateBootTable[Check];
      END
    ELSE NULL;  -- File exists, Arrived will notice it
    RETURN[FALSE];
    END;

  Hack: PROCEDURE [name: LONG STRING, s: STRING] =
    BEGIN Message[s, " "L, name]; END;

  -- Leftover Pup stuff

  --For more on boot files see the BuildBoot documentation

  -- Boot files created after late Dec 78 have a time stamp stored in words 3+4.
  -- OutLd leaves it zero.  GateControl smashes it to "now".

  --There are two kinds of boot file.

  --B-Files produced by BuildBoot.run:
  --	File page 1:	DiskBoot loader
  --	File page 2:	locations #0-#377
  --	File page 3:	locations #1000 - #1377
  --	File page 4:	locations #1400 - #1777
  --	...
  --	File page n:	locations #(n-1)B7 - #(n-1)B7+#377
  --B-Files have 0 in the second data word
  --B-Files are started by jmp @0 when loading is complete

  --S-Files produced by Swat OutLd:
  --	File page 1:	Special loader
  --	File page 2:	locations #1000 - #1377
  --	File page 3:	locations #1400 - #1777
  --	...
  --	File page 253:	locations #176400-176777
  --	File page 254:	locations #400 - #777
  --	File page 255:	locations #0 - #377
  --S-Files have a non-zero value in the second data word
  --Some S-Files can be started by jmp @0.
  --This is the kind we use, but we re-format them first

  BootFileHeader: TYPE = RECORD [  -- disk boot loader is first page
    other: ARRAY [0..3) OF WORD, timeStamp: PupWireFormat.BcplLongNumber];

  BlessPupBootFile: PROCEDURE [bf: BootServerFriends.BootFile] =
    BEGIN
    old, new: MStream.Handle ¬ NIL;
    buffer: ARRAY [0..Environment.wordsPerPage) OF WORD;
    finger: Stream.Block = [LOOPHOLE[LONG[@buffer]], 0, Environment.bytesPerPage];
    bfh: POINTER TO BootFileHeader = LOOPHOLE[@buffer];
    old ¬ MStream.Create[MFile.CopyFileHandle[bf.handle, []], []];
    BEGIN
    bytes: CARDINAL;
    [bytes, ] ¬ Stream.GetBlock[old, finger];
    IF bytes # Environment.bytesPerPage THEN GOTO Empty;
    bf.bytes ¬ MStream.GetLength[old];
    bf.pages ¬ Inline.LowHalf[
      (bf.bytes + Environment.bytesPerPage - 1)/Environment.bytesPerPage];
    bf.create ¬ LOOPHOLE[PupWireFormat.BcplToMesaLongNumber[bfh.timeStamp]];
    IF bf.create # MFile.GetTimes[bf.handle].create THEN
      BEGIN
      text: STRING = [200];
      Time.AppendCurrent[text];
      String.AppendString[text, "  Fixing Create Time for "L];
      String.AppendString[text, bf.fileName];
      String.AppendString[text, ".  Was: "L];
      Time.Append[text, Time.Unpack[MFile.GetTimes[bf.handle].create]];
      String.AppendString[text, ",  Will be: "L];
      Time.Append[text, Time.Unpack[bf.create]];
      LogString[text];
      MFile.SetTimes[file: bf.handle, create: bf.create];
      END;
    IF buffer[1] # 0 THEN
      BEGIN  -- fixup S-format file
      text: STRING = [100];
      scratch: MFile.Handle ¬ MFile.AcquireTemp[
        binary, bf.pages ! MFile.Error => GOTO DiskFull];
      MFile.SetTimes[file: scratch, create: bf.create];
      Stream.Delete[old];
      Time.AppendCurrent[text];
      String.AppendString[text, "  Reformatting "L];
      String.AppendString[text, bf.fileName];
      LogString[text];
      old ¬ MStream.Create[MFile.CopyFileHandle[bf.handle, [], readOnly], []];
      new ¬ MStream.Create[MFile.CopyFileHandle[scratch, [], writeOnly], []];
      [] ¬ MStream.Copy[from: old, to: new, bytes: LAST[LONG CARDINAL]];
      Stream.Delete[new];
      Stream.Delete[old];
      new ¬ MStream.Create[MFile.CopyFileHandle[scratch, [], readOnly], []];
      old ¬ MStream.Create[MFile.CopyFileHandle[bf.handle, [], writeOnly], []];
      [bytes, ] ¬ Stream.GetBlock[new, finger];
      IF bytes # Environment.bytesPerPage THEN GOTO Empty;
      buffer[1] ¬ 0;
      BEGIN  -- smash crufty time stamp to now
      -- Note that our clock may be wrong at this point.  If it is fast, other boot servers will ignore our file.  If it is slow, we will go get a new boot file.  I think that will work out ok.
      bfh.timeStamp ¬ PupWireFormat.MesaToBcplLongNumber[Time.Current[]];
      bf.create ¬ LOOPHOLE[PupWireFormat.BcplToMesaLongNumber[bfh.timeStamp]];
      END;
      Stream.PutBlock[old, finger];  -- garbage DiskBoot loader
      THROUGH [2..255] DO
        [bytes, ] ¬ Stream.GetBlock[new, finger];
        IF bytes # Environment.bytesPerPage THEN GOTO Short;
        ENDLOOP;
      Stream.PutBlock[old, finger];  -- locations 0B to 377B
      Stream.SetPosition[new, Environment.bytesPerPage];
      THROUGH [2..253] DO
        [] ¬ Stream.GetBlock[new, finger]; Stream.PutBlock[old, finger]; ENDLOOP;
      Stream.Delete[new];
      -- It may have shrunk if there was trash on the end of Swatee when creating a Mesa boot file
      Stream.Delete[old];  -- Truncate file
      old ¬ MStream.Create[MFile.CopyFileHandle[bf.handle, []], []];
      bf.bytes ¬ MStream.GetLength[old];
      bf.pages ¬ Inline.LowHalf[
        (bf.bytes + Environment.bytesPerPage - 1)/Environment.bytesPerPage];
      END;
    EXITS
      DiskFull =>
        BEGIN
        text: STRING = [100];
        Time.AppendCurrent[text];
        String.AppendString[text, "  Disk full while copying over "L];
        String.AppendString[text, bf.fileName];
        LogString[text];
        MFile.Release[bf.handle];
        bf.handle ¬ NIL;
        bf.file ¬ File.nullFile;
        bf.unknown ¬ TRUE;
        END;
      Empty,
      Short =>
        BEGIN
        text: STRING = [100];
        Time.AppendCurrent[text];
        String.AppendString[text, "  "L];
        String.AppendString[text, bf.fileName];
        IF new = NIL THEN String.AppendString[text, " is empty."L]
        ELSE String.AppendString[text, " is SHORT.   ******"L];
        LogString[text];
        IF new # NIL THEN Stream.Delete[new];
        MFile.Release[bf.handle];
        bf.handle ¬ NIL;
        bf.file ¬ File.nullFile;
        bf.unknown ¬ TRUE;
        END;
    END;
    Stream.Delete[old];
    END;

  Message: PROCEDURE [s1, s2, s3, s4: LONG STRING ¬ NIL] =
    BEGIN
    text: STRING = [200];
    String.AppendString[text, "BootServer: "L];
    String.AppendString[text, s1];
    IF s2 # NIL THEN String.AppendString[text, s2];
    IF s3 # NIL THEN String.AppendString[text, s3];
    IF s4 # NIL THEN String.AppendString[text, s4];
    LogString[text];
    END;

  LogString: PROCEDURE [text: LONG STRING] =
    BEGIN
    String.AppendChar[text, '.];
    String.AppendChar[text, Ascii.CR];
    Put.Text[NIL, text];
    END;


  TestFileChecksum: PROCEDURE [file: MFile.Handle] RETURNS [ok: BOOLEAN] =
    BEGIN
    seg: MSegment.Handle;
    words: LONG CARDINAL;
    buffer: LONG POINTER;
    cs: WORD;
    words ¬ (MFile.GetLength[file] + 1)/2;
    seg ¬ MSegment.Create[MFile.CopyFileHandle[file, []], [], 0];
    buffer ¬ MSegment.Address[seg];
    BEGIN
    loc: LONG POINTER ¬ buffer + words - 1;
    IF words > 100*Environment.wordsPerPage THEN
      BEGIN  -- 64K limit on microcode
      hunk: CARDINAL ¬ 20*Environment.wordsPerPage;
      finger: LONG POINTER ¬ buffer;
      left: LONG CARDINAL ¬ words;
      cs ¬ 0;
      UNTIL left = 0 DO
        IF left < hunk THEN hunk ¬ Inline.LowHalf[left];
        cs ¬ Checksum.ComputeChecksum[cs, hunk, finger];
        left ¬ left - hunk;
        finger ¬ finger + hunk;
        ENDLOOP;
      END
    ELSE cs ¬ Checksum.ComputeChecksum[0, Inline.LowHalf[words], buffer];
    ok ¬ cs = 0;
    END;
    MSegment.Delete[seg];
    END;


  END.