-- Copyright (C) 1981, 1982, 1984, 1985  by Xerox Corporation. All rights reserved. 
-- File: VMFile.mesa

-- HGM, 16-Sep-85 21:49:54
-- Last edited by Wobber:  2-Nov-82 12:27:34
-- Last edited by Gobbel: 11-Sep-81 16:41:44

DIRECTORY
  FileDefs USING [
    ComparePositions, FileHandle, FinalizeLocal, FinalizeIFS, FSInstance,
    InitializeLocal, InitializeIFS, Operations],
  Heap USING [systemZone],
  LogDefs USING [ShowTwoStrings],
  Time USING [Current],
  VMDefs USING [
    AccessFailure, defaultTime, FileHandle, FileSystemType, FileTime,
    OpenOptions, Page, PageNumber, Percentage, Position, Problem, Release,
    Start, UsePage, Wait],
  VMPrivate USING [
    CacheIndex, closedSeal, EnumerateCachePagesInFile, FileHandle, FileObject, FileSystem,
    FSInstance, Object, openSeal, PageHandle, underwaySeal,
    ValidateFile, ValidatePageNumber, Writable];

VMFile: MONITOR
  IMPORTS FileDefs, Heap, LogDefs, Time, VMDefs, VMPrivate
  EXPORTS VMDefs, VMPrivate =

  BEGIN OPEN VMDefs, VMPrivate;


  -- Global Variables --

  fileList: FileHandle;
  ChangeInOpenState: CONDITION;

  cacheLimit: CacheIndex;

  fsOps: PUBLIC ARRAY FileSystemType OF FileDefs.Operations;

  pilotFileSystem: FileSystem;


  -- Miscellaneous Declarations --

  CantDestroyReadOnlyFile: ERROR = CODE;
  FileInUse: ERROR = CODE;
  FileNotInList: ERROR = CODE;
  FileListSmashed: ERROR = CODE;
  LogoutIllegalWithOpenFiles: ERROR = CODE;
  PageInUse: ERROR = CODE;
  UseCountWrong: ERROR = CODE;


  -- Procedures, Signals, and Types Exported to VMDefs --

  FileObject: PUBLIC TYPE = VMPrivate.FileObject;
  FSInstance: PUBLIC TYPE = VMPrivate.FSInstance;

  -- File system access --

  Error: PUBLIC ERROR [reason: Problem] = CODE;
  UnableToLogin: PUBLIC ERROR [reason: Problem] = CODE;

  Login: PUBLIC ENTRY PROCEDURE [
    system: FileSystemType,
    server, userName, password, secondaryName, secondaryPassword: LONG STRING ← NIL]
    RETURNS [FileSystem] =
    BEGIN
    ENABLE UNWIND => NULL;
    instance: FileDefs.FSInstance;
    IF fsOps[system] = NIL THEN ERROR UnableToLogin[other];
    instance ← fsOps[system].login[
      server, userName, password, secondaryName, secondaryPassword];
    RETURN[Heap.systemZone.NEW[FSInstance ← [fsOps[system], instance]]]
    END;

  Logout: PUBLIC ENTRY PROCEDURE [fs: FileSystem] =
    BEGIN
    ENABLE UNWIND => NULL;
    EnsureNoOpenFiles[fs];
    fs.ops.logout[fs.instance];
    Heap.systemZone.FREE[@fs];
    END;

  AbortTransaction, CheckpointTransaction: PUBLIC PROCEDURE [fs: FileSystem] = {};

  -- File handling --

  OpenFile: PUBLIC PROCEDURE [
    system: FileSystem ← NIL, name: LONG STRING, options: OpenOptions ← oldReadOnly,
    cacheFraction: Percentage ← 0] RETURNS [vmFile: FileHandle] =
    BEGIN
    ENABLE UNWIND => LogDefs.ShowTwoStrings["Can't open "L, name];
    IF system = NIL THEN system ← pilotFileSystem;
    RETURN[OpenFileInner[system, name, options, cacheFraction]];
    END;

  OpenFileInner: ENTRY PROCEDURE [
    system: FileSystem, name: LONG STRING, options: OpenOptions ← oldReadOnly,
    cacheFraction: Percentage ← 0] RETURNS [vmFile: FileHandle] =
    BEGIN
    ENABLE UNWIND => NULL;
    new: BOOLEAN;
    [new, vmFile] ← AddToList[
      system.ops.open[system.instance, name, options], options];
    IF new THEN {
      vmFile.fs ← system; vmFile.cachePages ← (cacheFraction * cacheLimit) / 100};
    END;

  CantOpen: PUBLIC ERROR [reason: AccessFailure] = CODE;

  CloseFile: PUBLIC ENTRY PROCEDURE [file: FileHandle] = {
    ENABLE UNWIND => NULL;
    StartFileInternal[file];
    DoCloseDestroyOrAbandon[file, close]};

  GetOpenFileParameters: PUBLIC ENTRY PROCEDURE [file: FileHandle]
    RETURNS [
      system: FileSystem, options: OpenOptions, cacheFraction: Percentage] = {
    RETURN[file.fs, file.options, (file.cachePages * 100) / cacheLimit]};

  AbandonFile: PUBLIC ENTRY PROCEDURE [file: FileHandle] = {
    ENABLE UNWIND => NULL; DoCloseDestroyOrAbandon[file, abandon]};

  DestroyFile: PUBLIC ENTRY PROCEDURE [file: FileHandle] = {
    ENABLE UNWIND => NULL;
    StartFileInternal[file];
    DoCloseDestroyOrAbandon[file, destroy]};

  GetFileLength: PUBLIC ENTRY PROCEDURE [file: FileHandle]
    RETURNS [length: Position] = {
    ENABLE UNWIND => NULL;
    ValidateFile[file];
    RETURN[file.fs.ops.getLength[file.fh]]};

  SetFileLength: PUBLIC ENTRY PROCEDURE [file: FileHandle, position: Position] =
    BEGIN
    ENABLE UNWIND => NULL;
    oldLength: Position;
    atomicExtend: BOOLEAN ← FALSE;
    FlushTruncatedPage: PROCEDURE [page: PageHandle]
      RETURNS [found, unmap: BOOLEAN] =
      -- checks to see if 'page' should be flushed because of file truncation.
      BEGIN
      found ← unmap ← FALSE;
      IF page.page < position.page
        OR (page.page = position.page AND position.byte > 0) THEN RETURN;
      IF page.useCount ~= 1 THEN ERROR PageInUse;  -- useCount = 1 from enumeration
      unmap ← TRUE;
      END;

    ValidateFile[file];
    oldLength ← file.fs.ops.getLength[file.fh];
    ValidatePageNumber[position.page];
    SELECT FileDefs.ComparePositions[oldLength, position] FROM
      greater => [] ← EnumerateCachePagesInFile[file, FlushTruncatedPage];
      equal => RETURN;
      less =>
        atomicExtend ← oldLength.byte # 0
          AND
            (oldLength.page = position.page
              OR position = Position[oldLength.page + 1, 0]);
      ENDCASE;
    IF atomicExtend THEN
      BEGIN
      data: Page = UsePage[[file, oldLength.page]];
      file.fs.ops.extend[file.fh, position, data ! Error => Release[data]];
      Release[data];
      END
    ELSE file.fs.ops.setLength[file.fh, position];
    END;

  StartFile: PUBLIC ENTRY PROCEDURE [file: FileHandle] = {
    ENABLE UNWIND => NULL; StartFileInternal[file]};
  StartFileInternal: INTERNAL PROCEDURE [file: FileHandle] =
    BEGIN
    StartPage: PROCEDURE [page: PageHandle] RETURNS [found, unmap: BOOLEAN] =
      -- if 'page' is dirty, initiates a transfer of 'page' to the file.
      {Start[page.pointer]; RETURN[FALSE, FALSE]};
    ValidateFile[file];
    [] ← EnumerateCachePagesInFile[file, StartPage];
    END;

  WaitFile: PUBLIC ENTRY PROCEDURE [file: FileHandle] = {
    ENABLE UNWIND => NULL; WaitFileInternal[file]};
  WaitFileInternal: INTERNAL PROCEDURE [file: FileHandle] =
    BEGIN
    WaitPage: PROCEDURE [page: PageHandle] RETURNS [found, unmap: BOOLEAN] =
      -- waits until 'page' is in a stable state.
      {Wait[page.pointer]; RETURN[FALSE, FALSE]};
    ValidateFile[file];
    [] ← EnumerateCachePagesInFile[file, WaitPage];
    END;

  GetFileTimes: PUBLIC ENTRY PROCEDURE [file: FileHandle]
    RETURNS [read, write, create: VMDefs.FileTime] = {
    ENABLE UNWIND => NULL; [read, write, create] ← file.fs.ops.getTimes[file.fh]};

  SetCreationTime: PUBLIC ENTRY PROCEDURE [
    file: FileHandle, create: FileTime ← defaultTime] =
    BEGIN
    ENABLE UNWIND => NULL;
    IF create = defaultTime THEN create ← Time.Current[];
    file.fs.ops.setCreation[file.fh, create];
    END;


  -- Procedures and Signals Exported to VMPrivate --

  InitializeVMFile: PUBLIC PROCEDURE [maxCachePages: CacheIndex] =
    BEGIN
    fileList ← NIL;
    cacheLimit ← maxCachePages;
    fsOps[local] ← FileDefs.InitializeLocal[];
    pilotFileSystem ← Heap.systemZone.NEW[FSInstance ← FSInstance[fsOps[local], NIL]];
    pilotFileSystem.instance ← fsOps[local].login["Gobbel"L, "Randy"L];
    fsOps[ifs] ← FileDefs.InitializeIFS[];
    END;

  FinalizeVMFile: PUBLIC PROCEDURE =
    BEGIN
    fsOps[local].logout[pilotFileSystem.instance];
    Heap.systemZone.FREE[@pilotFileSystem];
    IF fileList ~= NIL THEN ERROR FileInUse;
    FileDefs.FinalizeIFS[];
    FileDefs.FinalizeLocal[];
    END;

  InvalidFile: PUBLIC ERROR = CODE;
  InvalidPageNumber: PUBLIC ERROR = CODE;


  -- Internal Procedures --

  AddToList: INTERNAL PROCEDURE [fFile: FileDefs.FileHandle, options: OpenOptions]
    RETURNS [newlyEntered: BOOLEAN, vmFile: FileHandle] =
    -- ensures that only a single entry for file 'fFile' appears in the fileList.
    INLINE --only called from OpenFile--
    BEGIN
    writable: BOOLEAN = options ~= oldReadOnly;
    newlyEntered ← FALSE;
    vmFile ← fileList;
    UNTIL vmFile = NIL DO
      IF vmFile.fh = fFile THEN
        SELECT vmFile.seal FROM
          openSeal =>
            IF writable THEN RETURN WITH ERROR CantOpen[accessDenied]
            ELSE {vmFile.openCount ← vmFile.openCount + 1; RETURN};
          underwaySeal => {WAIT ChangeInOpenState; vmFile ← fileList};
          ENDCASE => GO TO bogusList
      ELSE
        SELECT vmFile.seal FROM
          openSeal, underwaySeal => vmFile ← vmFile.link;
          ENDCASE => GO TO bogusList;
      REPEAT bogusList => ERROR FileListSmashed;
      ENDLOOP;
    vmFile ← Heap.systemZone.NEW[
      FileObject ← Object[
      file[
      seal: openSeal, useCount: 0, link: fileList, fh: fFile, fs:, cachePages: 0,
      options: options, altoFile: TRUE, openCount: 1]]];
    fileList ← vmFile;
    newlyEntered ← TRUE;
    END;

  DoCloseDestroyOrAbandon: INTERNAL PROCEDURE [
    file: FileHandle, op: {close, destroy, abandon}] =
    -- eliminates 'file' from file list and cleans it up as indicated by 'op'.
    BEGIN
    last: BOOLEAN;

    LockIfLastReference: INTERNAL PROCEDURE RETURNS [last: BOOLEAN] = INLINE
      BEGIN
      IF file.seal ~= openSeal OR file.openCount = 0 THEN ERROR InvalidFile;
      IF (last ← file.openCount = 1) THEN file.seal ← underwaySeal
      ELSE file.openCount ← file.openCount - 1;
      END;

    RemoveFile: INTERNAL PROCEDURE = INLINE
      BEGIN
      IF file = fileList THEN fileList ← file.link
      ELSE
        BEGIN
        IF fileList = NIL THEN GO TO Trouble;
        FOR prev: FileHandle ← fileList, prev.link UNTIL prev.link = NIL DO
          IF prev.link = file THEN {prev.link ← file.link; EXIT};
          REPEAT FINISHED => GO TO Trouble;
          ENDLOOP;
        EXITS Trouble => ERROR FileNotInList;
        END;
      file.seal ← closedSeal;  -- try to catch dangling references
      BROADCAST ChangeInOpenState;
      END;

    RemovePage: INTERNAL PROCEDURE [page: PageHandle]
      RETURNS [found, unmap: BOOLEAN] =
      BEGIN
      -- useCount = 1 in the following because of the enumeration
      IF op = abandon THEN page.useCount ← 1  -- force unmap to take effect
      ELSE IF page.useCount ~= 1 OR page.dirty THEN ERROR PageInUse;
      RETURN[FALSE, TRUE]
      END;

    IF op ~= abandon THEN WaitFileInternal[file];
    last ← LockIfLastReference[];
    SELECT op FROM
      close => file.fs.ops.close[file.fh];
      destroy =>
        IF Writable[file] THEN file.fs.ops.destroy[file.fh]
        ELSE ERROR CantDestroyReadOnlyFile;
      ENDCASE => file.fs.ops.abandon[file.fh];
    IF ~last THEN RETURN;
    [] ← EnumerateCachePagesInFile[file, RemovePage];
    IF file.useCount ~= 0 THEN ERROR UseCountWrong;
    RemoveFile[];
    Heap.systemZone.FREE[@file];
    END;

  EnsureNoOpenFiles: INTERNAL PROCEDURE [fs: FileSystem] =
    BEGIN
    vmFile: FileHandle ← fileList;
    UNTIL vmFile = NIL DO
      IF vmFile.fs = fs THEN ERROR LogoutIllegalWithOpenFiles
      ELSE
        SELECT vmFile.seal FROM
          openSeal, underwaySeal => vmFile ← vmFile.link;
          ENDCASE => ERROR FileListSmashed;
      ENDLOOP;
    END;

  END.