// 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" external [ // procedures defined here TFSWritePages TFSAssignDiskPage // defined elsewhere ActOnDiskPages AssignDiskPage RealDiskDA TFSInitializeCbStorage TFSGetCb TFSDoDiskCommand DefaultTFSErrorRtn TFSIncrement MoveBlock DefaultArgs Dvec ReadDDPage LockDD UnlockDD // statics defined elsewhere freePageFp freePageFid oneBits ] //---------------------------------------------------------------------------- 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 ifnot [ 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) Wretry: [ 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<>TFSDSK.diskBTsize then vda = 0 // Wrap around let pa = vda<>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 ]