// TfsWrite.Bcpl -- WriteDiskPages and AssignDiskPage procedures
// Copyright Xerox Corporation 1979, 1980, 1981

//	Last modified January 14, 1981  2:59 PM by Taft

get "Altofilesys.d"
get "Disks.d"
get "Tfs.d"

// procedures defined here

// defined elsewhere

// statics defined elsewhere
let TFSWritePages(disk, CAs, DAs, fp, firstPage, lastPage, lastAction,
    lvNumChars, lastNumChars, fixedCA, nil, errorRtn, nil, hintLastPage;
    numargs na) = valof
// See WriteDiskPages description in BFS section of O.S. manual.
// Note that DAs!(firstPage-1) will be referenced except when the
// label of firstPage doesn't need to be rewritten.
// The arguments following lastPage are optional, as for ActOnDiskPages
let numChars = nil; let firstNewPage = nil
DefaultArgs(lv na, 6, 0, 0, TFSwordsPerPage*2, 0, nil,
 lv DefaultTFSErrorRtn, nil, 0)
if lastAction eq 0 then lastAction = DCwriteD
if lvNumChars eq 0 then lvNumChars = lv numChars

if lastAction ne -1 then
   // Rewrite all existing pages
   test DAs!firstPage eq fillInDA
      ifso firstNewPage = firstPage
         firstPage = ActOnDiskPages(disk, CAs, DAs, fp, firstPage,
          lastPage, DCwriteD, lvNumChars, lastAction, fixedCA, 0, errorRtn,
          false, hintLastPage)
         if firstPage eq lastPage & (lastAction ne DCwriteD %
          @lvNumChars eq lastNumChars) resultis lastPage
         firstNewPage = firstPage+1

   // Code to assign more pages
      for i = firstNewPage to lastPage do
         DAs!i = AssignDiskPage(disk, DAs!(i-1))
         if DAs!i eq -1 then
            (@errorRtn)(errorRtn, disk>>DSK.driveNumber, ecDiskFull)

      // Check that the assigned pages are really free
      let errorRtnVec = vec 1
      errorRtnVec!0 = CheckFreePageErr  // error routine for this call
      errorRtnVec!1 = errorRtn  // my caller's error routine
      ActOnDiskPages(disk, 0, DAs, freePageFp, firstNewPage,
       lastPage, DCreadLnD, 0, 0, nil, CheckFreePage, errorRtnVec)
      for i = firstNewPage to lastPage do
         DAs!firstNewPage = DAs!i
         if DAs!i ne fillInDA then firstNewPage = firstNewPage+1
      ] repeatuntil firstNewPage-lastPage gr 0
// TFSWritePages (cont'd)

// All the pages have been checked.  Write labels and data.
// Create the CBZ dynamically so as not to have two of them (~250 words each)
// on the stack during the preceding calls to TFSActOnPages.
@lvNumChars = lastNumChars  //lvNumChars may be invalidated by Dvec
let cbz = CBzoneLength
Dvec(TFSWritePages, lv cbz)
TFSInitializeCbStorage(disk, cbz, firstPage, CBzoneLength, Wretry, errorRtn)

   for i = cbz>>CBZ.currentPage to lastPage do
      let cb = TFSGetCb(disk, cbz)

      // Set up eofDA as the page after the end of the file
      if ((i eq lastPage & lastNumChars ne TFSwordsPerPage*2) %
       (DAs!(i+1) eq fillInDA)) then DAs!(i+1) = eofDA

      // Set up label to be written on this page
      RealDiskDA(disk, DAs!(i+1), lv cb>>CB.label.next)
      RealDiskDA(disk, DAs!(i-1), lv cb>>CB.label.previous)
      cb>>CB.label.numChars = i eq lastPage? lastNumChars, TFSwordsPerPage*2

      TFSDoDiskCommand(disk, cb, (fixedCA ne 0? fixedCA, CAs!i),
       DAs!i, fp, i, DCwriteLD)
   while cbz>>CBZ.head ne 0 do TFSGetCb(disk, cbz)
   ]  //end of Wretry block

resultis lastPage

and CheckFreePage(disk, cb, cbz) be
let fid = lv cb>>CB.AddrL>>DL.fileId
for i = 0 to lFID-1 do if fid!i ne freePageFid!i then
   (cbz>>CBZ.DAs)!(cb>>CB.truePageNumber) = fillInDA
   TFSIncrement(lv disk>>TFSDSK.nBTErrors)

and CheckFreePageErr(errorRtnVec, cb, ec) be
// Error routine called when checking free pages.
// If we get an unrecoverable data error, just ignore the bad page and
// plunge on (TFSWritePages will assign another page instead).
// Call the normal error error routine for other errors.
test ec eq ecUnRecovDiskError
   ifso (cb>>CB.cbz>>CBZ.DAs)!(cb>>CB.truePageNumber) = fillInDA
   ifnot (@(errorRtnVec!1))(errorRtnVec!1, cb, ec)
and TFSAssignDiskPage(disk, vda, nil; numargs na) = valof
// See AssignDiskPage description in BFS section of O.S. manual.
// Assigns in a sequential manner, in order of increasing
// virtual disk addresses.  Second argument is a VDA previously
// assigned; the code tries to assign pages sequentially in this
// case.  However, for a new file, the VDA passed is eofDA; in
// this case, the code resumes looking in the bit table where it
// last left off trying to allocate a file.  The idea is to reduce
// bit table scanning time and also page in/outs.
// Returns -1 if the bit table is full, else the VDA of the page assigned.
// Special three-argument form does not really to an assignment --
// returns 0 if VDA+1 is assigned; true if it is available
let ddMgr = disk>>TFSDSK.ddMgr
LockDD(ddMgr, disk)
vda = vda eq eofDA? disk>>TFSDSK.lastPageAlloc, vda+1

// May have to do as many as n+2 iterations, where n is the number of
// bit table pages.
for i = 1 to (disk>>TFSDSK.diskBTsize rshift TFSlnWordsPerPage)+3 do
   // At top of loop: vda = VDA to be examined next.
   if vda<<VDA.wordNum ge disk>>TFSDSK.diskBTsize then vda = 0 // Wrap around
   let pa = vda<<VDA.pageNum
   let diskBTaddr = ReadDDPage(ddMgr, disk, pa+lengthTFSDDpreamble)
   // Test the bit corresponding to "vda".  If it fails, test the remainder
   // of the word one bit at a time.
   let wa = vda<<VDA.wordNumInPage
   let bitMask = oneBits!(vda<<VDA.bitNum)
      let free = ((diskBTaddr!wa) & bitMask) eq 0
      if na eq 3 then [ UnlockDD(ddMgr, disk); resultis free ]
      if free then
         diskBTaddr!wa = (diskBTaddr!wa) % bitMask
         disk>>TFSDSK.freePages = disk>>TFSDSK.freePages-1
         disk>>TFSDSK.lastPageAlloc = vda
         UnlockDD(ddMgr, disk, true)  //mark bt page dirty
         resultis vda
      bitMask = bitMask rshift 1
      vda = vda+1
      ] repeatuntil bitMask eq 0
   // Now search the rest of the page one word at a time.
   // On the last page we may run past the end of real data, but that's ok
   // because on the next pass vda will be wrapped around to zero.
   wa = wa+1 repeatuntil wa ge TFSwordsPerPage % diskBTaddr!wa ne -1

   // wa now addresses a word containing other than -1 if one was found.
   // wa eq TFSwordsPerPage otherwise.
   vda = (pa lshift TFSlnWordsPerPage + wa) lshift 4

UnlockDD(ddMgr, disk)
resultis -1  // Bit table full