DIRECTORY
BasicTime USING [Now, ToPupTime],
IFSFile USING [
AccessFailure, Completer, defaultTime, Error, FileTime, OpenOptions, Position, Problem],
IFSFilePrivate USING [
connectionTimeout, DoRead, DoWrite, FileAddressToPosition, FileHandle, fileLockTimeout,
FileObject, fileTimeAddress, FileWatcher, FreeSequinForFS, FSInstance, FSObject,
GetIORequestBlock, GetSequinForFS, IFSTIME, IFSTimes, InsertFile, IORequest,
PositionToFileAddress, PurgeFile, ReleaseFile, ValidateFile],
Leaf USING [
Answer, closeOp, deleteOp, FileAddress, IfsError, openOp, paramsOp,
Request, RequestObject],
PrincOps USING [zEXCH],
PrincOpsUtils USING [LongCopy],
Rope,
Sequin USING [
Broken, Buffer, Get, GetEmptyBuffer, Put, ReleaseBuffer];

IFSFileImplB: MONITOR
LOCKS file.LOCK USING file: IFSFilePrivate.FileHandle
IMPORTS BasicTime, IFSFile, IFSFilePrivate, PrincOpsUtils, Rope, Sequin
EXPORTS IFSFile, IFSFilePrivate = {
OPEN IFSFilePrivate;



ROPE: TYPE = Rope.ROPE;

IOSynchRecord: TYPE = RECORD [
done: BOOL,
outcome: IFSFile.Problem,
file: FileHandle,
finished: CONDITION _ [timeout: 0]];

IOSynch: TYPE = LONG POINTER TO IOSynchRecord;



IllegalExtend: ERROR = CODE;
IllegalTruncate: ERROR = CODE;
PacketTooSmall: ERROR = CODE;



FileObject: PUBLIC TYPE = IFSFilePrivate.FileObject;
FSObject: PUBLIC TYPE = IFSFilePrivate.FSObject;

Open: PUBLIC PROC
[instance: FSInstance, name: ROPE, options: IFSFile.OpenOptions _ oldReadOnly]
RETURNS [file: FileHandle] = {

DoOpen: PROC [file: FileHandle] RETURNS [problem: IFSFile.AccessFailure] = {
buffer: Sequin.Buffer;
request: Leaf.Request;
openOpOffset: CARDINAL _ 0;

Flush: PROC = {
Sequin.Put[file.sequin, buffer];
buffer _ Sequin.GetEmptyBuffer[];
request _ LOOPHOLE[buffer.data];
openOpOffset _ 0;
};

MapError: PROC [leafError: Leaf.IfsError] RETURNS [IFSFile.AccessFailure] = {
RETURN[
SELECT leafError FROM
accessDenied, illegalDIFAccess,
IN [userName .. connectPassword] => accessDenied,
fileNotFound, dirNotFound => notFound,
fileAlreadyExists => alreadyExists,
IN [nameMalformed .. nameTooLong] => illegalFileName,
fileBusy => accessConflict,
ENDCASE => other];
};

DO
fromCache: BOOL;
{ -- for EXITS serverDead
[file.sequin, fromCache] _ GetSequinForFS[instance];
buffer _ Sequin.GetEmptyBuffer[];
request _ LOOPHOLE[buffer.data];
IF ~fromCache THEN {
request^ _ [Leaf.paramsOp,
params[packetDataBytes: buffer.maxBytes,
fileLockTimeout: fileLockTimeout/5,
connectionTimeout: connectionTimeout/5]];
buffer.nBytes _ openOpOffset _ Leaf.paramsOp.length;
IF buffer.maxBytes - buffer.nBytes <= Leaf.openOp.length
THEN Flush[! Sequin.Broken => GO TO serverDead]
ELSE request _ LOOPHOLE[@buffer.data.words[SIZE[params Leaf.RequestObject]]];
};
request^ _ [Leaf.openOp, open[]];
{ENABLE
PacketTooSmall => {
IF openOpOffset ~= 0 THEN {
Flush[! Sequin.Broken => GO TO serverDead];
RETRY};
};
fs: FSInstance = file.fs;
WITH openReq: request SELECT open FROM
open => {
IF options ~= oldReadOnly THEN openReq.write _ openReq.extend _ TRUE;
SELECT options FROM
oldOrNew => openReq.create _ TRUE;
new => {openReq.vDefault _ next; openReq.create _ TRUE};
ENDCASE;
};
ENDCASE;
buffer.nBytes _ buffer.nBytes + Leaf.openOp.length;
buffer _ AddRopeToBuffer[buffer, fs.primaryName];
buffer _ AddRopeToBuffer[buffer, fs.primaryPassword];
buffer _ AddRopeToBuffer[buffer, fs.secondaryName];
buffer _ AddRopeToBuffer[buffer, fs.secondaryPassword];
buffer _ AddRopeToBuffer[buffer, name];
};  -- of handling PacketTooSmall
request.op.length _ buffer.nBytes - openOpOffset;
Sequin.Put[file.sequin, buffer ! Sequin.Broken => GO TO serverDead];
buffer _ Sequin.Get[file.sequin ! Sequin.Broken => GO TO serverDead];
{  -- for cantOpen
answer: Leaf.Answer _ LOOPHOLE[buffer.data];
IF ~fromCache THEN
{
IF answer.op.sense ~= reply THEN {problem _ other; GO TO cantOpen};
WITH ans: answer SELECT answer.op.type FROM
error => {problem _ MapError[ans.error]; GO TO cantOpen};
params => NULL;
ENDCASE => {problem _ other; GO TO cantOpen};
IF answer.op.length ~= buffer.nBytes THEN answer _ answer + answer.op.length/2
ELSE
{
Sequin.ReleaseBuffer[buffer];
buffer _ Sequin.Get[file.sequin ! Sequin.Broken => GO TO serverDead];
answer _ LOOPHOLE[buffer.data];
};
};
IF answer.op.sense ~= reply THEN {problem _ other; GO TO cantOpen};
WITH ans: answer SELECT answer.op.type FROM
error => {problem _ MapError[ans.error]; GO TO cantOpen};
open => {
problem _ ok;
file.leafHandle _ ans.handle;
file.length _ FileAddressToPosition[ans.eofAddress];
};
ENDCASE => {problem _ other; GO TO cantOpen};
EXITS
cantOpen => FreeSequinForFS[instance, file.sequin, problem ~= other];
};  -- for cantOpen
Sequin.ReleaseBuffer[buffer];
EXIT
EXITS
serverDead => {
FreeSequinForFS[instance, file.sequin, FALSE];
IF fromCache THEN LOOP  -- perhaps sequin had timed out
ELSE {problem _ io; EXIT};
};
};
ENDLOOP;
};

file _ InsertFile[instance, name, DoOpen];
file.watcher _ FORK FileWatcher[file];
};

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

Close: PUBLIC PROC [file: FileHandle] = {
DoClose: PROC [file: FileHandle] = {CleanupFile[file, close]};
ValidateFile[file];
ReleaseFile[file, DoClose];
};

Abandon: PUBLIC PROC [file: FileHandle] = {
DoAbandon: PROC [file: FileHandle] = {CleanupFile[file, abandon]};
ValidateFile[file];
ReleaseFile[file, DoAbandon];
};

Destroy: PUBLIC PROC [file: FileHandle] = {
DoDestroy: PROC [file: FileHandle] = {CleanupFile[file, destroy]};
ValidateFile[file];
PurgeFile[file, DoDestroy];
};

GetLength: PUBLIC ENTRY PROC [file: FileHandle] RETURNS [IFSFile.Position] = {
RETURN[file.length]
};

SetLength: PUBLIC PROC [file: FileHandle, length: IFSFile.Position] = {
oldLength: IFSFile.Position;
ValidateFile[file];
oldLength _ GetLength[file];
IF oldLength ~= length THEN DoIO[file, PrepareSetLength[file, length]];
};

GetTimes: PUBLIC PROC [file: FileHandle]
RETURNS [read, write, create: IFSFile.FileTime] = {
times: IFSTimes;
request: IORequest _ GetIORequestBlock[];
request^ _ [buffer: @times, address: fileTimeAddress,
op: read, bytesToGo: 2*SIZE[IFSTimes]];
DoIO[file, request];
RETURN[
IFSToMesaTime[times.read], IFSToMesaTime[times.write],
IFSToMesaTime[times.create]]
};

SetCreation: PUBLIC PROC [
file: FileHandle, create: IFSFile.FileTime _ IFSFile.defaultTime] = {
creation: IFSTIME;
request: IORequest _ GetIORequestBlock[];
IF create = IFSFile.defaultTime THEN create _ BasicTime.ToPupTime[BasicTime.Now[]];
creation _ MesaToIFSTime[create];
request^ _ [
buffer: @creation, address: fileTimeAddress, op: write, bytesToGo: 2*SIZE[IFSTIME]];
DoIO[file, request];
};



AddRopeToBuffer: PUBLIC PROC
[buffer: Sequin.Buffer, r: ROPE] RETURNS [Sequin.Buffer] = {
flat: ROPE = Rope.Flatten[r];
s: LONG STRING _ LOOPHOLE[flat];
startWord: CARDINAL = (buffer.nBytes + 1)/2;
nWords: CARDINAL;
IF s = NIL THEN s _ ""L;
nWords _ (s.length + 1)/2;
IF buffer.maxBytes < 2*(startWord + nWords) THEN ERROR PacketTooSmall;
buffer.data.words[startWord] _ s.length;
PrincOpsUtils.LongCopy[
from: @s.text, to: @buffer.data.words[startWord + 1], nwords: nWords];
buffer.nBytes _ buffer.nBytes + 2*(nWords + 1);
RETURN [buffer];
};



PrepareSetLength: ENTRY PROC
[file: FileHandle, length: IFSFile.Position] RETURNS [request: IORequest] = {
ENABLE UNWIND => NULL;
request _ GetIORequestBlock[];
request^ _ [buffer: NIL,
address: PositionToFileAddress[length, [write[newEOF: TRUE]]],
op: write, bytesToGo: 0];
file.length _ length;
};

CleanupFile: ENTRY PROC [file: FileHandle, op: {close, destroy, abandon}] = {
ENABLE UNWIND => NULL;
toCache: BOOL _ FALSE;
file.state _ closing;
BROADCAST file.ioSynch;
UNTIL file.state = closed DO WAIT file.ioSynch ENDLOOP;
IF (JOIN file.watcher) AND op ~= abandon THEN {
buffer: Sequin.Buffer _ Sequin.GetEmptyBuffer[];
request: Leaf.Request _ LOOPHOLE[buffer.data];
IF op = close THEN {
request^ _ [Leaf.closeOp, close[handle: file.leafHandle]];
buffer.nBytes _ Leaf.closeOp.length;
}
ELSE {
request^ _ [Leaf.deleteOp, delete[handle: file.leafHandle]];
buffer.nBytes _ Leaf.deleteOp.length;
};
Sequin.Put[file.sequin, buffer ! Sequin.Broken => GO TO ignore];
buffer _ Sequin.Get[file.sequin ! Sequin.Broken => GO TO ignore];
Sequin.ReleaseBuffer[buffer];
toCache _ TRUE;
EXITS
ignore => NULL;
};
FreeSequinForFS[file.fs, file.sequin, toCache];
};

DoIO: PROC [file: FileHandle, request: IORequest] = {
ioSynch: IOSynchRecord _ [done: FALSE, outcome: ok, file: file];
WaitForCompletion: ENTRY PROC [file: FileHandle] = INLINE
{UNTIL ioSynch.done DO WAIT ioSynch.finished; ENDLOOP};
request.proc _ NoteCompletion;
request.arg _ LOOPHOLE[LONG[@ioSynch]]; 
SELECT request.op FROM
read => DoRead[file, request];
write => DoWrite[file, request];
ENDCASE;
WaitForCompletion[file];
IF ioSynch.outcome ~= ok THEN ERROR IFSFile.Error[ioSynch.outcome];
};

NoteCompletion: IFSFile.Completer = {
ioSynch: IOSynch = LOOPHOLE[arg, IOSynch];
DoNotify: ENTRY PROC [file: FileHandle] = INLINE {
ioSynch.done _ TRUE; ioSynch.outcome _ outcome;
NOTIFY ioSynch.finished;
};
DoNotify[ioSynch.file];
};

IFSToMesaTime: PROC [IFSTIME] RETURNS [IFSFile.FileTime] = MACHINE CODE
{ PrincOps.zEXCH; };

MesaToIFSTime: PROC [IFSFile.FileTime] RETURNS [IFSTIME] = MACHINE CODE
{ PrincOps.zEXCH; };

}.


4IFSFileImplB.mesa
Levin - 13-Jan-82 10:03:26
Russ Atkinson, November 9, 1983 11:44 pm
Types --
Miscellaneous --
Procedures, Types, and Signals Exported to IFSFile --
send paramsOp only on fresh sequin
process params response
Procedures Exported to IFSFilePrivate --
Internal Procedures --
op = destroy
�Ê
蘚
œ™Jš
œ™J™(—J˜š
Ïk	˜	Jšœ
�œ˜!šœ�œ˜J˜X—šœ�œ˜J˜WJ˜PJšœ#�œ"˜LJ˜=—šœ�œ˜J˜CJ˜—Jšœ	�œ	˜Jšœ�œ˜Jš
œ˜šœ�œ˜J˜9—J˜—šœ�˜Jš�œ�œ
�œ ˜5Jš�œ@˜GJš�œ˜#Jš�œ˜J˜J˜Jš
œ™J˜Jš�œ�œ�œ
˜J˜šœ�œ�œ˜Jšœ�œ
˜J˜J˜Jšœ
�	œ˜$J˜—Jš	œ	�œ�œ
�œ
�œ˜.J˜J˜Jš
œ™J˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜J˜J˜Jš
œ5™5J˜Jšœ�œ
�œ˜4Jšœ
�œ
�œ˜0J˜šÏnœ�œ
�˜Jšœ�œ-˜NJš�œ˜J˜šžœ�œ�œ%˜LJ˜J˜Jšœ�œ˜J˜šžœ�œ˜J˜ J˜!Jšœ
�œ˜ J˜Jš�
œ
˜J˜—šžœ�œ�œ˜Mš�œ
˜š�œ�˜J˜Jš�œ/˜1J˜&J˜#Jš�œ3˜5J˜Jš�œ˜——š
œ˜J˜——š
�˜Jšœ�œ
˜šœÏc˜J˜4J˜!Jšœ
�œ˜ š�œ�œ˜Jš
œ"™"˜J˜(J˜#J˜)—J˜4š�œ6˜8Jš�œ�œ
�œ˜/Jš�œ�œ�œ˜M—Jš
œ˜—J˜!šœ
�˜š
œ˜š�œ�œ˜Jšœ�œ
�œ
˜+Jš�œ˜—Jš
œ˜—J˜š�œ�œ�˜&š
œ	˜	Jš�œ�œ"�œ
˜Eš�œ	�˜Jšœ�œ
˜"Jšœ2�œ˜8Jš�œ
˜—Jš
œ˜—Jš�œ
˜—J˜3Jš
œ1˜1Jš
œ5˜5Jš
œ3˜3Jš
œ7˜7Jš
œ'˜'JšœŸ˜!—J˜1Jšœ2�œ
�œ
˜DJšœ3�œ
�œ
˜EšœŸ˜Jšœ�œ˜,š�œ�˜Jš
œ
˜
Jš
œ™Jš�œ�œ�œ
�œ˜Cš�œ
�œ�˜+Jšœ)�œ
�œ˜9Jšœ
�œ
˜Jš�œ�œ
�œ˜-—Jš�œ#�œ%˜Nš
�˜Jš
œ
˜
J˜Jšœ3�œ
�œ
˜EJšœ	�œ˜Jš
œ˜—Jš
œ˜—Jš�œ�œ�œ
�œ˜Cš�œ
�œ�˜+Jšœ)�œ
�œ˜9š
œ	˜	J˜
J˜J˜4Jš
œ˜—Jš�œ�œ
�œ˜-—š
�˜J˜E—JšœŸ˜—J˜Jš
�˜š
�˜š
œ˜Jšœ'�œ˜.Jš�œ�œ
�œŸ˜7Jš�œ�œ˜Jš
œ˜——Jš
œ˜—Jš�œ
˜—Jš�
œ
˜J˜—J˜*Jšœ�œ˜&Jš�
œ
˜J˜—Jšœ
�œ
�œ#�œ
˜>J˜šžœ�œ
�œ˜)Jšžœ�œ1˜>J˜J˜Jš
œ˜J˜—šžœ�œ
�œ˜+Jšž	œ�œ3˜BJ˜J˜Jš
œ˜J˜—šžœ�œ
�œ˜+Jšž	œ�œ3˜BJ˜J˜Jš
œ˜J˜—š
ž	œ�œ
�œ
�œ�œ˜NJš�œ
˜Jš
œ˜J˜—šž	œ�œ
�œ1˜GJ˜J˜J˜Jš�œ�œ,˜GJš
œ˜J˜—šžœ�œ
�œ˜(Jš�œ,˜3J˜J˜)˜5Jšœ�œ˜'—J˜š�œ
˜J˜6J˜—Jš
œ˜J˜—šžœ�œ
�œ˜Jš
œE˜EJšœ
�œ
˜J˜)Jš�œ�œ/˜SJ˜!˜JšœE�œ
�œ˜T—J˜Jš
œ˜J˜J˜—Jš
œ(™(J˜šžœ�œ
�˜Jšœ�œ�œ˜<Jšœ�œ˜Jšœ�œ
�œ�œ˜ Jšœ�œ˜,Jšœ�œ
˜Jš�œ�œ
�œ	˜J˜Jš�œ*�œ
�œ˜FJ˜(š
œ˜Jš
œF˜F—J˜/Jš�œ
˜Jš
œ˜J˜J˜—Jš
œ™J˜šžœ�œ
�˜Jšœ,�œ˜MJš�œ
�œ�œ
˜J˜šœ�œ
˜Jšœ6�œ˜>J˜—J˜Jš�
œ
˜J˜—šžœ�œ
�œ6˜MJš�œ
�œ�œ
˜Jšœ	�œ�œ
˜Jš
œ˜Jš�	œ˜Jš�œ�œ
�œ�œ
˜7š�œ�œ�œ�œ˜/Jš
œ0˜0Jšœ�œ˜.š�œ�œ˜J˜:J˜$Jš
œ
˜
—š�œ˜Jš
œ™Jš
œ<˜<J˜%Jš
œ˜—Jšœ2�œ
�œ	˜@Jšœ3�œ
�œ	˜AJš
œ˜Jšœ
�œ
˜š
�˜Jšœ
�œ
˜—Jš
œ˜—Jš
œ/˜/Jš
œ˜J˜—šžœ�œ+˜5Jšœ �œ˜@šžœ�œ
�œ�˜9Jš	œ
�œ�œ
�œ�œ˜7—Jš
œ˜Jšœ�œ
�œ
˜(š�œ�˜J˜J˜ Jš�œ
˜—J˜Jš�œ�œ
�œ ˜CJš�
œ
˜J˜—š
œ%˜%Jšœ�œ˜*šžœ�œ
�œ�œ˜2Jšœ�œ˜/Jš�œ˜Jš
œ˜—J˜Jš
œ˜J˜—šž
œ�œ�œ�œ�œ
�˜GJš�
œ�
œ
˜J˜—šž
œ�œ�œ�œ�œ
�˜GJš�
œ�
œ
˜J˜—Jš�
œ
˜J˜——…—#Ê/æ