DIRECTORY
BasicTime USING [ FromPupTime, Now, ToPupTime ],
BootFile USING [Entry, Header, maxEntriesPerHeader, maxEntriesPerTrailer, MemorySizeToFileSize, TrailerArray, TrailerStart ],
Booting USING [ Boot, Switches, switches ],
DebuggerFormat USING [ExternalStateVector, LabelChecksum, Run, SwapInfo, VersionID, VMRunTable ],
Disk USING [ Channel, DoIO, DriveAttributes, Label, NextChannel, ok, Request, Status ],
DiskFace USING [ Type ],
File USING [Error, FindVM, FP, Handle, Info, Open, PageCount, PageNumber, Read, SetSize, SystemVolume, wordsPerPage, Write ],
FileBackdoor USING [GetRoot],
IO USING [ GetChar, Flush, PutChar, PutF, PutRope, STREAM ],
PrincOps USING [ flagsVacant, PageCount, PageNumber, PageValue, PDA, wordsPerPage ],
PrincOpsUtils USING [ LongCopy ],
ProcessorFace USING [ GetNextAvailableVM ],
Rope USING [ ROPE ],
SimpleTerminal USING [ TurnOn ],
SystemVersion USING [ bootFileDate, Date, release, ReleaseNumber ],
VM USING [AddressForPageNumber, CantAllocate, Interval, PageCount, PageNumber, PagesForWords, Pin, SimpleAllocate],
VMBacking USING [StateFromPageValue];

RollbackImpl: MONITOR
IMPORTS BasicTime, BootFile, Booting, DebuggerFormat, Disk, File, FileBackdoor, IO, PrincOpsUtils, ProcessorFace, SimpleTerminal, SystemVersion, VM, VMBacking = {

vmPagesPerFilePage: VM.PageCount = VM.PagesForWords[File.wordsPerPage];
valuesPerPage: CARDINAL = PrincOps.wordsPerPage / SIZE[PrincOps.PageValue];
PageValueArray: TYPE = ARRAY [0..valuesPerPage) OF PrincOps.PageValue;
mapEntriesPerPage: CARDINAL = valuesPerPage;


outLdFile: File.Handle _ NIL;
outLdFirstPage: File.PageNumber;
outLdSpace: VM.Interval = VM.SimpleAllocate[vmPagesPerFilePage];
outLdPage: File.PageNumber _ [LAST[INT]];
outLdAddress: LONG POINTER TO ARRAY [0..PrincOps.wordsPerPage) OF WORD =
VM.AddressForPageNumber[outLdSpace.page];

ReadOutLdPage: PROC [page: File.PageNumber] = {
IF outLdPage # page THEN File.Read[outLdFile, outLdPage_page, 1, outLdAddress];
};


BFMEntryIndex: TYPE = [0..MAX[BootFile.maxEntriesPerHeader,
BootFile.maxEntriesPerTrailer]];

BootFileMapItem: TYPE = RECORD [
link: BFMPointer _ NIL,
lastMemPage: PrincOps.PageNumber,
filePageOffset: File.PageNumber,
entryCount: BFMEntryIndex,
entries: EntrySeq];

EntrySeq: TYPE = LONG POINTER TO BootFile.TrailerArray;

BFMPointer: TYPE = REF BootFileMapItem;

bfmHead: BFMPointer _ NIL;

OpenOutLdFile: PROC = {
bfm: BFMPointer;
bfh: LONG POINTER TO BootFile.Header;
entries: EntrySeq;
curmax: CARDINAL _ BootFile.maxEntriesPerHeader;
curbase: File.PageNumber _ [0];
OutLdPageSpace: PROC RETURNS [vm: LONG POINTER] = {
space: VM.Interval = VM.SimpleAllocate[vmPagesPerFilePage];
vm _ VM.AddressForPageNumber[space.page];
File.Read[outLdFile, curbase, 1, vm];
};
pagesremaining: CARDINAL;
bfmHead _ NIL;
bfh _ OutLdPageSpace[];
entries _ LOOPHOLE[@bfh.entries];
pagesremaining _ bfh.countData;
bfmHead _ bfm _ NEW[BootFileMapItem];
DO
bfm.entries _ entries;
bfm.entryCount _ MIN[curmax, pagesremaining];
bfm.lastMemPage _ bfm.entries[bfm.entryCount-1].page;
bfm.filePageOffset _ [curbase+1];
pagesremaining _ pagesremaining - bfm.entryCount;
IF pagesremaining = 0 THEN EXIT;
curbase _ [bfm.filePageOffset+bfm.entryCount];
curmax _ BootFile.maxEntriesPerTrailer;
entries _ OutLdPageSpace[] + BootFile.TrailerStart;
bfm.link _ NEW[BootFileMapItem];
bfm _ bfm.link;
ENDLOOP;
};

PageNotFound: ERROR[mempage: PrincOps.PageNumber] = CODE;
MalformedOutload: ERROR = CODE;

SearchOutLdFile: PROCEDURE [mempage: PrincOps.PageNumber] = {
FOR bfm: BFMPointer _ bfmHead, bfm.link UNTIL bfm = NIL DO
IF mempage <= PrincOps.PageNumber[bfm.lastMemPage] THEN {
FOR i: BFMEntryIndex IN [0..bfm.entryCount] DO
SELECT PrincOps.PageNumber[bfm.entries[i].page] FROM
< mempage => NULL;
> mempage => ERROR PageNotFound[mempage];
ENDCASE => {
ReadOutLdPage[[bfm.filePageOffset+i]];
RETURN
};
REPEAT FINISHED => ERROR MalformedOutload[];
ENDLOOP;
};
REPEAT FINISHED => ERROR PageNotFound[mempage]
ENDLOOP;
};

CopyRead: PUBLIC PROC [from: INT, nwords: INT, to: LONG POINTER] = {
n: PrincOps.PageNumber;
w: [0..PrincOps.wordsPerPage);
WHILE nwords > 0
DO amount: (0..PrincOps.wordsPerPage];
n _ from / PrincOps.wordsPerPage;
w _ from - n * LONG[PrincOps.wordsPerPage];
SearchOutLdFile[n];
amount _ MIN[nwords,PrincOps.wordsPerPage-w];
PrincOpsUtils.LongCopy[from: @outLdAddress[w], to: to, nwords: amount];
nwords _ nwords - amount; from _ from + amount; to _ to + amount;
ENDLOOP;
};


UnknownDrive: ERROR = CODE;
BadTransfer: ERROR = CODE;

DiskAddress: TYPE = RECORD[
deviceType: DiskFace.Type,
deviceOrdinal: CARDINAL,
diskPage: LONG CARDINAL, -- device-relative page number of start of run
offset: CARDINAL, -- page number from start of run, for label checksum calculation
labelCheck: CARDINAL -- label checksum of start of run
];

lastChannel: Disk.Channel _ NIL;
lastType: DiskFace.Type;
lastOrdinal: CARDINAL;

TransferBackingRun: PUBLIC ENTRY PROC [
data: LONG POINTER,
label: LONG POINTER TO Disk.Label,
which: { readAndChecksum, readAndVerify, write },
count: INT,
addr: DiskAddress] = {
ENABLE UNWIND => NULL;
req: Disk.Request;
status: Disk.Status;
countDone: INT;
IF lastChannel = NIL OR addr.deviceType # lastType OR addr.deviceOrdinal # lastOrdinal THEN {
FOR lastChannel _ Disk.NextChannel[NIL], Disk.NextChannel[lastChannel] UNTIL lastChannel = NIL DO
[type: lastType, ordinal: lastOrdinal] _ Disk.DriveAttributes[lastChannel];
IF addr.deviceType = lastType AND addr.deviceOrdinal = lastOrdinal THEN EXIT;
REPEAT FINISHED => ERROR UnknownDrive[];
ENDLOOP;
};
req _ [
diskPage: [addr.diskPage],
data: data,
command: SELECT which FROM
readAndChecksum => [header: verify, label: read, data: read],
readAndVerify => [header: verify, label: verify, data: read],
write => [header: verify, label: verify, data: write],
ENDCASE => ERROR,
count: count ];
[status, countDone] _ Disk.DoIO[lastChannel, label, @req];
IF status # Disk.ok THEN ERROR BadTransfer[];
IF which = readAndChecksum AND DebuggerFormat.LabelChecksum[label^, addr.offset + count-1] # addr.labelCheck THEN ERROR BadTransfer[];
label.filePage _ label.filePage - (count-1);
};



ReadBackingMap: PROC RETURNS [table: REF DebuggerFormat.VMRunTable] = {
swapInfo: DebuggerFormat.SwapInfo;
swapInfoAddr: INT = LOOPHOLE[@PrincOps.PDA.available];
esv: DebuggerFormat.ExternalStateVector;
esvAddr: INT;
CopyRead[from: swapInfoAddr, nwords: SIZE[DebuggerFormat.SwapInfo], to: @swapInfo];
esvAddr _ LOOPHOLE[swapInfo.externalStateVector];
CopyRead[esvAddr, SIZE[DebuggerFormat.ExternalStateVector], @esv];
SELECT esv.versionident FROM
DebuggerFormat.VersionID => {
IF esv.vmRunTable = NIL
THEN table  _ NIL
ELSE {
temp: ARRAY [0..SIZE[DebuggerFormat.VMRunTable[0]]) OF WORD;
cheat: POINTER TO DebuggerFormat.VMRunTable = LOOPHOLE[@temp];
CopyRead[
LOOPHOLE[esv.vmRunTable, INT],
SIZE[DebuggerFormat.VMRunTable[0]],
@temp ];
table  _ NEW[DebuggerFormat.VMRunTable[cheat.length]];
CopyRead[
LOOPHOLE[esv.vmRunTable, INT],
SIZE[DebuggerFormat.VMRunTable[cheat.length]],
LOOPHOLE[table, LONG POINTER] ];
};
};
ENDCASE => table  _ NIL;
};



in, out: IO.STREAM;

vmImageVersion: CARDINAL = 1;

VMImageHeader: TYPE = MACHINE DEPENDENT RECORD[
version(0): CARDINAL _ vmImageVersion,
runs(1): INT,
pages(3): INT,
bootVersion(5): SystemVersion.ReleaseNumber,
bootFileDate(8): SystemVersion.Date,
checkpointDate(10): SystemVersion.Date
];

VMImageRun: TYPE = MACHINE DEPENDENT RECORD[
pages: CARDINAL,
deviceType: DiskFace.Type,
deviceOrdinal: CARDINAL,
diskPage: LONG CARDINAL,
label: Disk.Label];

vmImageRunsPerPage: CARDINAL = File.wordsPerPage / SIZE[VMImageRun];

VMImageRunTable: TYPE = ARRAY [0..vmImageRunsPerPage) OF VMImageRun;

vmImageBufferPages: NAT _ 256;

NoBackingStore: ERROR[PrincOps.PageNumber] = CODE;
ShortFile: ERROR = CODE;
WrongPageCount: ERROR = CODE;

which: { checkpoint, rollback };

Complain: PROC [msg: Rope.ROPE] = {
out.PutRope[msg];
out.PutRope["\nType any character to "];
out.PutRope[IF which = checkpoint
THEN "resume the outloaded session: "
ELSE "re-boot with the \"f\" switch: "];
in.Flush[];
[] _ in.GetChar[];
IF which = checkpoint
THEN [] _ Booting.Boot[boot: [file[outLdFile, outLdFirstPage]], switches: ALL[FALSE] ]
ELSE [] _ Booting.Boot[boot: [self[]], switches: [f: TRUE] ];
ERROR
};

DoIt: PROC = TRUSTED {
ENABLE {
File.Error =>
Complain[SELECT why FROM
wentOffline => "System volume has gone offline",
nonCedarVolume => "System volume is not a cedar volume",
inconsistent => "System volume or checkpoint file is inconsistent - scavenge",
software => "Label-check when accessing the checkpoint file",
hardware => "Hard disk error when accessing the checkpoint file",
unknownFile => "The checkpoint file does not exist",
unknownPage => "Bogus checkpoint file (unknownPage)",
volumeFull => "Can't checkpoint (system volume full)",
fragmented => "Can't checkpoint (system volume fragmented)",
ENDCASE => "Unexpected file error - consult expert"];
PageNotFound => Complain["Can't find required swapped-in page in outload"];
MalformedOutload => Complain["The outload appears to be malformed"];
UnknownDrive => Complain["Can't find the disk drive for a swapped-out page"];
BadTransfer => Complain["Disk error when accessing a swapped out page"];
NoBackingStore => Complain["Can't find the backing store for a swapped out page"];
ShortFile => Complain["The checkpoint file appears to be truncated"];
WrongPageCount => Complain["I'm confused about how many pages to transfer"];
};
outloadDataPages: PrincOps.PageCount;
countVM: INT _ 0;
mapPages: CARDINAL;
mapBufferSpace: VM.Interval = VM.SimpleAllocate[VM.PagesForWords[File.wordsPerPage]];
mapBuffer: LONG POINTER TO PageValueArray =
VM.AddressForPageNumber[mapBufferSpace.page];
mapStart: File.PageNumber; -- start of map dump in checkpoint file
vmImagePos: File.PageNumber; -- start of vmImage in checkpoint file
vmImageBufferSpace: VM.Interval = AllocateBuffer[];
vmImageBufferAddr: LONG POINTER = VM.AddressForPageNumber[vmImageBufferSpace.page];
vmImageHeader: LONG POINTER TO VMImageHeader = vmImageBufferAddr;
vmImageRunTable: REF VMImageRunTable _ NEW[VMImageRunTable];
AllocateBuffer: PROC RETURNS [interval: VM.Interval] = {
DO
RETURN [VM.SimpleAllocate[vmImageBufferPages
! VM.CantAllocate =>
IF vmImageBufferPages > 4
THEN {vmImageBufferPages _ vmImageBufferPages / 2; LOOP}
ELSE REJECT;
]];
ENDLOOP;
};
GetMapStart: PROC RETURNS [File.PageNumber] = TRUSTED {
fp: File.FP;
header: LONG POINTER TO BootFile.Header = LOOPHOLE[mapBuffer];
[fp: fp, page: outLdFirstPage] _ FileBackdoor.GetRoot[File.SystemVolume[], checkpoint];
outLdFile _ File.Open[File.SystemVolume[], fp];
File.Read[file: outLdFile, from: outLdFirstPage, nPages: 1, to: header];
outloadDataPages _ header.countData;
RETURN [[outLdFirstPage+BootFile.MemorySizeToFileSize[outloadDataPages]]]
};
[in: in, out: out] _ SimpleTerminal.TurnOn[];
VM.Pin[vmImageBufferSpace];
out.PutRope[IF which = checkpoint THEN "\nCheckpoint." ELSE "\nRollback."];
{
count: PrincOps.PageCount;
page: PrincOps.PageNumber;
FOR countVM _ 0, page + count DO
[firstPage: page, count: count] _ ProcessorFace.GetNextAvailableVM[countVM];
IF count = 0 THEN EXIT;
ENDLOOP;
};
mapPages _ (countVM + mapEntriesPerPage - 1) / mapEntriesPerPage;
mapStart _ GetMapStart[];
vmImagePos _ [mapStart+mapPages];
IF which = checkpoint THEN {
GetMapPage: PROC [p: CARDINAL] = TRUSTED
{ File.Read[file: outLdFile, from: [mapStart+p], nPages: 1, to: mapBuffer] };
PutMapPage: PROC [p: CARDINAL] = TRUSTED
{ File.Write[file: outLdFile, to: [mapStart+p], nPages: 1, from: mapBuffer] };
firstEnumerate: BOOL _ TRUE;
InterestingPage: PROC [e: [0..mapEntriesPerPage)] RETURNS [yes: BOOL] = TRUSTED {
mapEntry: PrincOps.PageValue = mapBuffer[e];
IF mapEntry.state.flags = PrincOps.flagsVacant
THEN yes _ VMBacking.StateFromPageValue[mapEntry] = active
ELSE {
yes _ FALSE; 
IF firstEnumerate THEN {
mapBuffer[e].state.flags.referenced _ TRUE;
mapBuffer[e].state.flags.dirty _ TRUE;
};
};
};
firstPassCount: INT _ 0; -- consistency check between passes of EnumerateRuns
table: REF DebuggerFormat.VMRunTable;
runSize: CARDINAL; -- pages in current run;
runStart: VM.PageNumber; -- page number of first page in run
backingRun: LONG POINTER TO DebuggerFormat.Run _ NIL; -- covers entire run
EnumerateRuns: PROC [work: PROC] = {
pageNumber: VM.PageNumber _ 0;
runSize _ 0;
FOR p: CARDINAL IN [0..mapPages) DO
GetMapPage[p];
FOR e: [0..mapEntriesPerPage) IN [0..mapEntriesPerPage) DO
interesting: BOOL = InterestingPage[e];
IF runSize > 0 AND (NOT interesting OR pageNumber NOT IN
[backingRun.page..backingRun.page+backingRun.count) ) THEN { -- end of current run
work[];
runSize _ 0;
};
IF interesting THEN {
IF runSize = 0 THEN {
IF backingRun = NIL OR pageNumber NOT IN [backingRun.page..backingRun.page+backingRun.count)
THEN { -- find entry in backing run table
IF table = NIL THEN ERROR NoBackingStore[pageNumber];
FOR i: CARDINAL IN [0..table.nRuns) DO
backingRun _ @table[i];
IF pageNumber IN [backingRun.page..backingRun.page+backingRun.count)
THEN EXIT;
REPEAT FINISHED => ERROR NoBackingStore[pageNumber]
ENDLOOP;
};
runStart _ pageNumber;
};
runSize _ runSize+1;
};
pageNumber _ pageNumber+1;
ENDLOOP;
IF firstEnumerate THEN PutMapPage[p];
ENDLOOP;
IF runSize > 0 THEN work[];
firstEnumerate _ FALSE;
};
OpenOutLdFile[];
table _ ReadBackingMap[];
vmImageHeader^ _ [
runs: 0,
pages: 0,
bootVersion: SystemVersion.release,
bootFileDate: SystemVersion.bootFileDate,
checkpointDate: BasicTime.ToPupTime[BasicTime.Now[]]
];
{ -- First pass: count runs to determine file size needed
fileSize: File.PageCount; -- required checkpoint file size
CountRuns: PROC = {
vmImageHeader.runs _ vmImageHeader.runs+1;
vmImageHeader.pages _ vmImageHeader.pages + runSize;
};
out.PutRope["\nCounting swapped-out VM pages ... "];
EnumerateRuns[CountRuns];
firstPassCount _ vmImageHeader.pages;
fileSize _ vmImagePos+1+vmImageHeader.pages+
(vmImageHeader.runs +vmImageRunsPerPage-1) / vmImageRunsPerPage;
out.PutF["\nThe VM has %g pages, of which %g are swapped-in and %g are swapped-out (in %g runs).\nEnsuring checkpoint file length is at least %g ... ",
[integer[countVM]],
[integer[outloadDataPages]],
[integer[vmImageHeader.pages]],
[integer[vmImageHeader.runs]],
[integer[fileSize]]
];
IF File.Info[outLdFile].size < fileSize THEN File.SetSize[outLdFile, fileSize];
}; -- first pass
File.Write[outLdFile, vmImagePos, 1, vmImageHeader];
vmImagePos _ [vmImagePos+1];
{ -- Second pass: transfer the pages
vmImageRunTablePos: [0..vmImageRunsPerPage] _ 0;
pages: CARDINAL _ 0; -- pages used in vmImageBuffer
Copier: PROC = -- Add run to the vmImageRuntable we're building
{
offset: CARDINAL = runStart-backingRun.page;
vmImageRunTable[vmImageRunTablePos] _ [
pages: runSize,
deviceType: backingRun.deviceType,
deviceOrdinal: backingRun.deviceOrdinal,
diskPage: backingRun.diskPage + offset,
label: NULL ];
TransferBackingRun[
data: vmImageBufferAddr + pages * PrincOps.wordsPerPage,
label: @vmImageRunTable[vmImageRunTablePos].label,
which: readAndChecksum,
count: 1,
addr: [
deviceType: vmImageRunTable[vmImageRunTablePos].deviceType,
deviceOrdinal: vmImageRunTable[vmImageRunTablePos].deviceOrdinal,
diskPage: vmImageRunTable[vmImageRunTablePos].diskPage,
offset: offset,
labelCheck: backingRun.labelCheck]
];
vmImageRunTablePos _ vmImageRunTablePos+1;
IF vmImageRunTablePos = vmImageRunsPerPage THEN CopyToBuffer[];
};
CopyToBuffer: PROC = {
LOOPHOLE[vmImageBufferAddr + pages * PrincOps.wordsPerPage,
LONG POINTER TO VMImageRunTable]^ _ vmImageRunTable^;
pages _ pages + 1;
firstPassCount _ firstPassCount + 1;
IF pages = vmImageBufferPages THEN WriteBuffer[];
FOR r: CARDINAL IN [0..vmImageRunTablePos) DO
total: CARDINAL = vmImageRunTable[r].pages;
reqd: CARDINAL _ total;
WHILE reqd > 0 DO
amount: CARDINAL = MIN[vmImageBufferPages-pages, reqd];
label: Disk.Label _ vmImageRunTable[r].label;
label.filePage _ label.filePage + (total-reqd);
TransferBackingRun[
data: vmImageBufferAddr + pages * PrincOps.wordsPerPage,
label: @label,
which: readAndVerify,
count: amount,
addr: [
deviceType: vmImageRunTable[r].deviceType,
deviceOrdinal: vmImageRunTable[r].deviceOrdinal,
diskPage: vmImageRunTable[r].diskPage + (total-reqd),
offset: 0,
labelCheck: 0 ]
];
pages _ pages + amount;
IF pages = vmImageBufferPages THEN WriteBuffer[];
reqd _ reqd - amount;
ENDLOOP;
ENDLOOP;
vmImageRunTablePos _ 0;
};
WriteBuffer: PROC = {
File.Write[outLdFile, vmImagePos, pages, vmImageBufferAddr];
firstPassCount _ firstPassCount - pages;
vmImagePos _ [vmImagePos+pages];
out.PutChar['.];
pages _ 0;
};
out.PutF["ok\nCopying VM into checkpoint file (each dot = %g pages transferred) ",
[integer[vmImageBufferPages]]];
EnumerateRuns[Copier];
IF vmImageRunTablePos # 0 THEN CopyToBuffer[];
WriteBuffer[];
IF firstPassCount # 0 THEN ERROR WrongPageCount[];
}; -- second pass
}
ELSE {
remainingFile: File.PageCount; -- amount of file that should remain
remainingRuns: INT;
pages: CARDINAL _ 0; -- position in vmImageBuffer
ReadBuffer: PROC = {
amount: File.PageCount = MIN[vmImageBufferPages, remainingFile];
File.Read[outLdFile, vmImagePos, amount, vmImageBufferAddr];
vmImagePos _ [vmImagePos+amount];
remainingFile _ remainingFile - amount;
pages _ 0;
out.PutChar['.];
};
ReadImageRunTable: PROC = {
vmImageRunTable^ _ LOOPHOLE[vmImageBufferAddr + pages * PrincOps.wordsPerPage,
LONG POINTER TO VMImageRunTable]^;
pages _ pages + 1;
IF pages = vmImageBufferPages THEN ReadBuffer[];
};
File.Read[outLdFile, vmImagePos, 1, vmImageHeader];
vmImagePos _ [vmImagePos+1];
out.PutF["\nThis checkpoint was created on %g by boot file version %g.%g.%g of %g",
[time[BasicTime.FromPupTime[vmImageHeader.checkpointDate]]],
[integer[vmImageHeader.bootVersion.major]],
[integer[vmImageHeader.bootVersion.minor]],
[integer[vmImageHeader.bootVersion.patch]],
[time[BasicTime.FromPupTime[vmImageHeader.bootFileDate]]]
];
out.PutF["\nThere were %g swapped-in pages, and %g swapped-out pages in %g runs",
[integer[outloadDataPages]],
[integer[vmImageHeader.pages]],
[integer[vmImageHeader.runs]]
];
remainingFile _ vmImageHeader.pages+
(vmImageHeader.runs +vmImageRunsPerPage-1) / vmImageRunsPerPage;
IF File.Info[outLdFile].size < vmImagePos+remainingFile THEN ERROR ShortFile[];
remainingRuns _ vmImageHeader.runs;
out.PutF["\nCopying VM from checkpoint file (each dot = %g pages transferred) ",
[integer[vmImageBufferPages]]];
ReadBuffer[];
WHILE remainingRuns > 0 DO
runsThisTime: CARDINAL = MIN[remainingRuns, vmImageRunsPerPage];
remainingRuns _ remainingRuns - runsThisTime;
ReadImageRunTable[];
FOR r: CARDINAL IN [0 .. runsThisTime) DO
total: CARDINAL = vmImageRunTable[r].pages;
reqd: CARDINAL _ total;
WHILE reqd > 0 DO
amount: CARDINAL = MIN[vmImageBufferPages-pages, reqd];
label: Disk.Label _ vmImageRunTable[r].label;
label.filePage _ label.filePage + (total-reqd);
TransferBackingRun[
data: vmImageBufferAddr + pages * PrincOps.wordsPerPage,
label: @label,
which: write,
count: amount,
addr: [
deviceType: vmImageRunTable[r].deviceType,
deviceOrdinal: vmImageRunTable[r].deviceOrdinal,
diskPage: vmImageRunTable[r].diskPage + (total-reqd),
offset: 0,
labelCheck: 0 ]
];
pages _ pages + amount;
IF pages = vmImageBufferPages THEN ReadBuffer[];
reqd _ reqd - amount;
ENDLOOP;
ENDLOOP;
ENDLOOP;
};
out.PutRope[" ok\nInloading real memory from checkpoint file ... "];
IF Booting.switches[l] THEN {
out.PutRope["\nPausing (\"L\" switch).  Type any character to continue: "];
[] _ in.GetChar[];
};
[] _ Booting.Boot[boot: [file[outLdFile, outLdFirstPage]], switches: ALL[FALSE] ];
ERROR
};

IF Booting.switches[v] THEN { which _ checkpoint; DoIt[] };
IF Booting.switches[r] THEN { which _ rollback; DoIt[] };
[] _ File.FindVM[]; -- in this case we're continuing with the full boot sequence

}.
RollbackImpl.mesa (Checkpoint and Rollback: VM copying)
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Andrew Birrell  December 7, 1983 1:22 pm
Levin, September 22, 1983 1:48 pm
Russ Atkinson (RRA) June 5, 1985 3:33:47 pm PDT

Accessing outload image on checkpoint file. (Mainly stolen from WVMCache.mesa)
Layout of boot and outload files
returns pointer into vm containing data from outload file map page
Leaves result in outLdAddress
it's in this page of the bootFileMap
Reads from address space of outload file (cf. WorldVM.CopyRead)
Transfers from backing store (also stolen from WVMCache.mesa)
Assumes data is pinned and VM page aligned
VM backing data structure (ReadBackingMap stolen from WVMBackingMap.mesa)
Top level procedure
Just in case we are running tight enough to fall back to a smaller interval
Copy from VM backing storage to checkpoint file, then inload from checkpoint file
Mark it dirty because we won't restore the backing disk.
And mark it referenced so it won't look vacant!
( "firstEnumerate" optimizes so we only update the entry once )
The following are set by EnumerateRuns before calling "work":
call "work" for each run of interesting pages
start of a new run
Write the header to the checkpoint file
Read first page of run to get its label (sigh!)
Read the runs into the buffer
Write from buffer into checkpoint file
Copy from checkpoint file to VM backing storage, then inload from checkpoint file
Beyond here, we should not access vmImageHeader (it's overlaid on the buffer!)
Pause so user can read the screen
ΚL˜
codeš
œ7™7Kšœ
Οm
œ1™<Kš
œ(™(K™!K™/K™—š
Οk	˜	Kšœ
žœ!˜0Kšœ	žœo˜}Kšœžœ˜+KšœžœM˜aKšœžœM˜WKšœ	žœ
˜Kšœžœžœ`˜}Kšœ
žœ˜Kšžœ
žœ+žœ˜<Kšœ	žœ2žœ˜TKšœžœ˜!Kšœžœ˜+Kšœžœžœ˜Kšœžœ˜ Kšœžœ0˜CKšžœ
žœk˜sKšœ
žœ˜%—K˜šœž˜KšžœIžœ?žœ˜’
—˜Kšœžœ
žœ"˜GKšœžœžœ˜KKšœžœžœžœ˜FKšœžœ˜,K˜—Kš
œN™N˜Kšœžœ
˜K˜ Kšœžœžœ$˜@Kšœžœ
žœ˜)š
œžœ
žœ
žœ
žœžœ
žœ˜HKšžœ'˜)—K˜šΟn
œžœ˜/Kšžœžœ7˜OKš
œ˜—K˜Kš
œ ™ K˜šœžœžœ˜;Kš
œ ˜ —K˜šœžœžœ˜ Kšœžœ
˜Kš
œ!˜!K˜ K˜Kš
œ˜K˜—Kš	œ
žœžœ
žœ
žœ˜7K˜Kšœžœžœ˜'K˜Kšœžœ
˜K˜šŸ
œžœ˜K˜Kšœžœ
žœ
žœ˜%Kš
œ˜Kšœžœ ˜0K˜š
Ÿœžœ
žœžœ
žœ˜3Kš
œB™BKšœžœžœ$˜;Kšœžœ"˜)Kš
œ%˜%Kš
œ˜—Kšœžœ
˜Kšœ
žœ
˜K˜Kšœ
žœ˜!K˜Kšœžœ˜%š
ž˜Kš
œ˜Kšœžœ˜-K˜5K˜!K˜1Kšžœžœ
žœ
˜ K˜.Kš
œ'˜'Kš
œ3˜3Kšœžœ˜ K˜Kšžœ
˜—Kš
œ˜—K˜Kšœžœ!žœ
˜9Kšœžœžœ
˜K˜šŸœž	œ#˜=Kš
œ™šžœ%žœž˜:šžœ0žœ˜9Kš
œ$™$šžœžœž˜.šžœ*ž˜4šœ
žœ
˜Kšœ
žœ˜)šžœ˜K˜&Kš
ž˜Kš
œ˜———Kšžœ
žœžœ˜,Kšžœ
˜Kš
œ˜——Kšžœ
žœžœ˜.Kšžœ
˜—Kš
œ˜—K˜šŸœžœ
žœžœ
žœžœ
žœ˜DKš
œ?™?K˜K˜Kšžœ˜šžœ$˜&Kš
œ!˜!Kšœžœ˜+Kš
œ˜Kšœ	žœ!˜-Kš
œG˜GK˜A—Kšžœ
˜Kš
œ˜—K˜—Kš
œ=™=˜Kšœžœžœ
˜Kšœ
žœžœ
˜K˜šœ
žœžœ
˜K˜Kšœžœ
˜Kšœ
žœ
žœΟc.˜GKšœžœ @˜RKšœžœ
 !˜6K˜—K˜Kšœžœ
˜ K˜Kšœ
žœ
˜K˜šŸœžœ
žœ
žœ	žœ
žœ	žœ
žœ
žœFžœ˜³
Kš
œ*™*Kšžœ
žœžœ
˜K˜K˜Kšœžœ
˜š
žœžœ
žœžœ!žœ˜]šžœ žœ žœž˜aKš
œK˜KKšžœžœ"žœ
žœ
˜MKšžœ
žœžœ˜(Kšžœ
˜—Kš
œ˜—˜Kš
œ˜Kš
œ˜šœ	žœž˜Kš
œ=˜=Kš
œ=˜=Kš
œ6˜6Kšžœžœ
˜—Kš
œ˜—Kš
œ:˜:Kšžœžœ
žœ˜-KšžœžœNžœ
žœ˜†
Kš
œ,˜,Kš
œ˜—K˜K˜—Kš
œI™I˜šŸœžœ
žœ	žœ˜GKš
œ"˜"Kšœžœžœžœ˜6K˜(Kšœ	žœ
˜
Kšœ%žœ*˜SKšœ
žœ˜1Kšœžœ,˜Bšžœž˜š
œ˜šžœž˜Kšžœ
ž˜šžœ˜Kš	œžœžœ žœ
žœ
˜<Kšœžœ
žœžœ˜>Kš
œ	˜	Kšžœžœ˜Kšžœ˜#K˜Kšœ	žœ*˜6˜	Kšžœžœ˜Kšžœ*˜.Kšžœžœ
žœ˜ —Kš
œ˜——Kš
œ˜—Kšžœ
žœ
˜—Kš
œ˜—K˜K˜—Kš
œ™˜Kšœ	žœ
žœ
˜K˜Kšœžœ˜K˜š	œžœžœ
ž	œ
žœ
˜/Kšœžœ˜&Kšœ	žœ
˜
Kšœ
žœ
˜Kš
œ,˜,Kš
œ$˜$Kš
œ&˜&K˜—K˜š	œžœžœ
ž	œ
žœ
˜,Kšœžœ
˜K˜Kšœžœ
˜Kšœ
žœ
žœ
˜K˜—K˜Kšœžœžœ
˜DK˜Kšœžœžœžœ˜DK˜Kšœžœ˜K˜Kšœžœžœ
˜2Kšœžœžœ
˜Kšœžœžœ
˜K˜Kš
œ ˜ K˜šŸœžœžœ˜#K˜K˜(šœžœ˜!Kšžœ!˜%Kšžœ$˜(—K˜K˜šžœ˜KšžœFžœ
žœ˜VKšžœ1žœ˜=Kš
ž˜—Kš
œ˜—K˜šŸœžœžœ˜šžœ˜š
œ
˜
šœ	žœž˜Kš
œ0˜0Kš
œ8˜8Kš
œN˜NKš
œ=˜=Kš
œA˜AKš
œ4˜4Kš
œ5˜5Kš
œ6˜6Kš
œ<˜<Kšžœ.˜5——Kš
œK˜KKš
œD˜DKš
œM˜MKš
œH˜HKš
œR˜RKš
œE˜EKš
œL˜LKš
œ˜—K˜%Kšœ	žœ˜Kšœ
žœ
˜Kšœžœžœžœ#˜Ušœžœ
žœ
žœ˜+Kšžœ+˜-—Kšœ '˜BKšœ &˜CKšœžœ˜3Kšœžœ
žœžœ/˜SKšœžœ
žœ
žœ#˜AKšœžœžœ˜<šŸœžœ
žœžœ˜8Kš
œK™Kš
ž˜šžœžœ"˜,šœžœ˜šžœ˜Kšžœ/žœ
˜8Kšžœ
žœ
˜——Kš
œ˜—Kšžœ
˜—K˜—šŸœžœ
žœžœ˜7Kšœ	žœ
˜Kš	œžœ
žœ
žœžœ˜>Kš
œW˜WKš
œ/˜/Kš
œH˜HKš
œ$˜$KšžœC˜IKš
œ˜—K˜-Kšžœ˜Kšœžœžœžœ˜Kš
œ
˜
Kš
œ˜Kš
œ˜šžœž˜ K˜LKšžœžœ
žœ
˜Kšžœ
˜—Kš
œ˜—Kš
œA˜AKš
œ˜Kš
œ!˜!šžœžœ˜Kš
œQ™QšŸ
œžœžœž˜(Kš
œM˜M—šŸ
œžœžœž˜(Kš
œN˜N—Kšœžœžœ
˜š
Ÿœžœžœžœžœ˜QKš
œ,˜,šžœ,˜.Kšžœ6˜:šžœ˜Kšœžœ˜
Kš
œ8™8Kš
œ/™/K™?šžœžœ˜Kšœ&žœ
˜+Kšœ!žœ
˜&Kš
œ˜—Kš
œ˜——Kš
œ˜—Kšœžœ 4˜MKšœžœ˜%š
œ=™=Kšœ	žœ ˜+Kšœ
žœ
 #˜<Kš
œžœ
žœ
žœžœ ˜J—šŸ
œžœžœ˜$Kš
œ-™-Kšœžœ˜Kš
œ˜šžœžœ
žœž˜#Kš
œ˜šžœžœž˜:Kšœ
žœ˜'šžœžœžœ
žœžœ
ž˜8Kšœ5žœ ˜RK˜K˜Kš
œ˜—šžœžœ˜šžœ
žœ˜Kš
œ™Kšžœžœžœ
žœ4˜\šžœ "˜)Kšžœ	žœ
žœ
žœ˜5šžœžœ
žœž˜&Kš
œ˜šžœžœ4˜DKšžœ
žœ
˜
—Kšžœ
žœžœ˜3Kšžœ
˜—Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ˜Kšžœ
˜Kšžœžœ˜%—Kšžœ
˜—Kšžœ
žœ˜Kšœžœ
˜Kš
œ˜—K˜K˜˜K˜K˜	K˜#Kš
œ)˜)Kš
œ4˜4Kš
œ˜—šœ 7˜9Kšœ  ˜:šŸ	œžœ˜K˜*Kš
œ4˜4Kš
œ˜—Kš
œ4˜4K˜Kš
œ%˜%š
œ,˜,Kš
œ@˜@—˜—
K˜K˜Kš
œ˜K˜Kš
œ˜K˜—Kšžœ&žœ#˜OKšœ 
˜—Kš
œ'™'Kš
œ4˜4Kš
œ˜šœ "˜$Kš
œ0˜0Kšœžœ ˜3šŸœžœ 0˜?Kš
œ
˜
Kšœžœ˜,š
œ'˜'Kš
œ˜Kš
œ"˜"Kš
œ(˜(Kš
œ'˜'Kšœžœ˜—Kš
œ/™/˜Kš
œ8˜8Kš
œ2˜2Kš
œ˜Kš
œ	˜	˜Kš
œ;˜;Kš
œA˜AKš
œ7˜7Kš
œ˜Kš
œ"˜"—K˜—Kš
œ*˜*Kšžœ)žœ˜?Kš
œ˜—šŸœžœ˜Kš
œ™šžœ3˜;Kšžœ
žœ
žœ&˜5—K˜K˜$Kšžœžœ˜1šžœžœ
žœž˜-Kšœžœ˜+Kšœžœ	˜šžœ	ž˜Kšœžœžœ!˜7Kš
œ-˜-K˜/˜Kš
œ8˜8Kš
œ˜Kš
œ˜Kš
œ˜˜Kš
œ*˜*Kš
œ0˜0Kš
œ5˜5Kš
œ
˜
Kš
œ˜—K˜—K˜Kšžœžœ˜1K˜Kšžœ
˜—Kšžœ
˜—Kš
œ˜Kš
œ˜—šŸœžœ˜Kš
œ&™&Kš
œ<˜<K˜(Kš
œ ˜ K˜K˜
Kš
œ˜—š
œR˜RKš
œ˜—K˜Kšžœžœ˜.Kš
œ˜Kšžœžœ
žœ˜2—Kšœ ˜Kš
œ
˜
—šžœ˜Kš
œQ™QKšœ $˜CKšœžœ
˜Kšœžœ ˜1šŸ
œžœ˜Kšœžœ$˜@Kš
œ<˜<Kš
œ!˜!Kš
œ'˜'Kš
œ
˜
K˜Kš
œ˜—šŸœžœ˜šœžœ3˜NKšžœ
žœ
žœ˜"—K˜Kšžœžœ˜0Kš
œ˜—Kš
œ3˜3Kš
œ˜˜SKš
œ<˜<K˜+K˜+K˜+Kš
œ9˜9K˜—˜QK˜K˜K˜K˜—š
œ$˜$Kš
œ@˜@—Kšžœ6žœ
žœ
˜OKš
œ#˜#Kš
œN™Nš
œP˜PKš
œ˜—Kš
œ
˜
šžœž˜Kšœžœžœ$˜@Kš
œ-˜-Kš
œ˜šžœžœ
žœž˜)Kšœžœ˜+Kšœžœ	˜šžœ	ž˜Kšœžœžœ!˜7Kš
œ-˜-K˜/˜Kš
œ8˜8Kš
œ˜Kš
œ
˜
Kš
œ˜˜Kš
œ*˜*Kš
œ0˜0Kš
œ5˜5Kš
œ
˜
Kš
œ˜—K˜—K˜Kšžœžœ˜0K˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kš
œ˜—Kš
œD˜Dšžœžœ˜Kš
œ!™!Kš
œK˜KK˜Kš
œ˜—KšœEžœ
žœ˜RKš
ž˜Kš
œ˜—K˜Kšžœžœ ˜;Kšžœžœ˜9Kšœ <˜PK˜—Kš
œ˜—…—LΰhF