Macintosh-SW/supermario
1
0
Fork 0
mirror of https://github.com/elliotnunn/supermario.git synced 2024-11-22 04:31:30 +00:00
Code Issues Projects Releases Wiki Activity
master
supermario/base/SuperMarioProj.1994-02-09/OS/HFS/TFSVOL.a
Elliot Nunn 2e16381318 Bring in sources, and document
2019-06-29 23:17:50 +08:00

2922 lines
126 KiB
Plaintext
Raw Permalink Blame History

;
; File: TFSVOL.a
;
; Contains: This file contains mostly volume-level routines for the Turbo
; File System.
;
; Copyright: © 1984-1993 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <SM8> 8/27/93 BH Backed out SetVolInfo changes from <SM7>. The flushing stuff is
; now in CmdDone.
; <SM7> 8/3/93 BH Changed MountVol to set the manual-eject flag in the VCB for
; volumes mounted in manual-eject drives. Changed SetVolInfo to
; flush changed critical volume info for manual-eject drives.
; <6> 3/10/93 gs Fix bug #1063340 in MountVol MtCheck to prevent an overflow when
; determining the maximum number of leaf records for the Catalog
; and Extents b*trees.
; <SM5> 3/9/93 CSS Fix Radar bug #1059140. The patch for UnmountForTheNineties
; was applied incorrectly. The patch only closed the control files
; on Unmounting the volume. They did this by patching only the
; _Unmount trap. SuperMario rolled it in line with FlUnMnt which is
; shared by _FlushVol and _Unmount. Rather than roll it only into
; _Unmountvol, I coditionalized the new code with a test against FlushOnly
; this should keep the code from executing in the Flush case. This is
; a lower risk solution than moving code around now (Cyclone is beta).
; <SM4> 12/1/92 RB Exported PickWDCB so it can be vectorized for FSM use.
; <SM3> 10/22/92 CSS Change some branch short instructions to branches.
; <SM2> 5/21/92 kc Append "Trap" to the names of Dequeue, EnQueue, Eject,
; UnMountVol, FlushVol, GetVol, SetVol, OpenWD, CloseWD and
; GetWDInfo to avoid name conflict with the glue.
; <SM1> 4/1/92 kc Rolled in OpenWDPatch, FixDtrmV3, MountVolFor1991, KillCheckRemountNiceWay
; NoCloseOnOffline and NoCloseOnEject and UnmountForTheNineties
; from FileMgrPatches.a
; • Pre-SuperMario comments follow •
; <2> 9/13/91 JSM Add a header.
; <1.6> 6/12/89 JB Changed UnmountVol to disallow unmounting of volumes with open
; files EXCEPT FOR the following: files with FNum < $10 (internal
; system files), files with FNum == 'GRT ' (AppleShare hack).
; External file system "internal files" are now included in the
; check such that they may unmount sucessfully with internal files
; left open.
; <1.5> 4/3/89 MSH Put in the AppleShare hack for unmount.
; <1.4> 3/21/89 CSL change JSR to DEQueue and EnQueue to BSR.L to fix link error.
; <1.3> 3/2/89 DNF removed references to forROM; HFS now builds identically for ram
; or rom
; <1.2> 11/16/88 CCH Took out include of "nTraps.a"
; <1.1> 11/10/88 CCH Fixed Header.
; <1.0> 11/9/88 CCH Adding to EASE.
; <1.0> 2/11/88 BBM Adding file for the first time into EASE…
; 11/4/87 JB (C958) Rolled in changes to UnmountVol from the following
; patches: PM243, PA244, PB245, and PMAB271. Moved the label
; 'FlUnMnt' 2 instructions forward (branched to only from
; UnMountVol).
; 2/19/87 BB Vectored MtCheck, FindDrive, CheckReMount, and DtrmV2.
; 12/10/86 BB Removed range check in XferVName, neither BufPtr or MemTop are
; valid upper limits in the Twitcher environment. Also added use
; of StripAddress in XferVName. [SHF: added include for ntraps.a
; for _StripAddress.]
; 10/27/86 BB Vectored DtrmV3,CkExtFS, and BMChk routines.
; 10/24/86 BB Changed range check in XferVName to use MemTop rather than
; BufPtr.
; 10/2/86 BB Fixed bug in MountVol (wasn't saving D0 accross a CmpString
; call.
; <C193> 10/1/86 WRL Set offset to zero before doing VCB pointer check in routine
; CkWDRefnum in TFSVOL.a.
; 9/16/86 BB Fixed rename problem in MountVol (use of pointer to a cache
; buffer).
; 9/15/86 BB Added check for a zero VCB pointer in CkWDRefNum indicating that
; the WD is already closed.
; 4/15/86 PWD fix bug in GetWDRefNum (one path forgot to init high word of D1
; before doing a DIVU.
; 1/13/86 LAK Incorporated fix to remount check from ROM75Fix.
; 10/29/85 LAK Vectored DtrmV1 routine.
; 10/28/85 PWD Changed to pass control call to drivers anyway if 64 <= DIP <=
; 127 mung VCB as for _Offline call for these drivers. Changed
; NoEject from byte-boolean to a tri-state flag: -1 [offline], 0
; [eject], or +1[special eject call].
; 10/27/85 PWD Changed _GetVolInfo to ignore volume control files in
; determining volume busy status. Set attributes bit 5 if default
; on this volume.
; 10/24/85 LAK Fixed Eject bug (FlushBuffers wasn't preserving D2 which FClose
; clobbers).
; 10/20/85 LAK Added LEOF remount checking for MFS volumes.
; 10/14/85 PWD Added ReadWDCB routine for external file system support. Moved
; remount check to last step in MountVol. Added DumpCaches routine
; to dispose of cache blocks with defunct VRefNum/VCBPtr [on
; remount]. Added LEOF check again.
; 10/13/85 PWD Fixed bug in GetVolInfo: don't try to read working directory
; valence for external FS volumes.
; 10/11/85 PWD Changed GetVolInfo to pin NmAlBlks and NmFrBlks at
; (32767*1000)/1024 instead of 32767 for programs that figure in
; 'decimal K'
; 10/11/85 PWD Backed out of LEOF check on remount for Beta-ROMs. The current
; algorithm fails to correctly back out of a remount attempt,
; leaving the original VCB changed. Maybe we can dispose of it
; somehow?? Restore its original state??
; 10/10/85 LAK Call new routine MarkVCBDirty for Eject/Unmount and Mount to
; avoid changing the modification date for just the consistency
; bit (Finder gets infinitely confused otherwise in resync loop on
; single-drive system).
; 10/7/85 PWD Changed to separate out BMChk routine, use it to check 1st
; B*-Tree extent allocation status. Added code to check LEOF of
; open file on remount.
; 10/6/85 PWD Threw in SetVolName for use in SetVolInfo (from TFSDir2).
; 10/4/85 PWD Fixed bug in GetVol, SetVol (test D1 bit rather than IOTrap(A0)
; bit).
; 10/1/85 LAK Munged MountVol a lot to share code with MFS mount (which now
; uses the volume cache). Removed AdjustIntErr: this function is
; now done in CmdDone. MountVol modified to test for
; Offline/Ejected vol after call to GetVCBDrv which now also looks
; for these. No longer save first 4 bytes of non-Mac disk in
; FSTemp4 for Format package since it can't tell anyways. Call
; Offline on TMFOErr also at MountVol.
; 9/30/85 PWD Move PMSP hook to correct place. If HFSBit is set in GetVol
; call, go to GetDir.
; 9/26/85 PWD Added SetupDef entry point for raw internal access from external
; FS.
; 9/25/85 PWD Overhauled PMSP: removed root from directories considered; added
; support for PMSPHook and PMSP Enable/Disable calls. Left
; interrupts enabled during search of FCB table.
; 9/24/85 PWD Fixed bug (MOVE.L vs. MOVEM.L) in directory valence lookup in
; GetVolInfo
; 9/24/85 PWD Changed SetVol to branch to SetDir when TFS bit is set.
; 9/22/85 PWD Fixed setting of DefVRefNum in SetVol, changed OpenWD to allow
; MFS volumes as argument if directory is root, changed HSetVol
; (a.k.a. SetDir) to allow MFS volumes specified by name, changed
; MountVol to set up new VCB fields for B*-Tree allocation sizes,
; changed GetVolInfo to subtract B*-Tree allocation from NmAlBlks,
; and return directory valence instead of root valence if
; directory referenced is not the root.
; 9/21/85 LAK Call FlushCache with D0=volume refnum, not 0 (this option no
; longer supported). This is more efficient (we used to trash all
; cache blocks for all volumes when we ejected or unmounted a
; volume) as well as being easier on the cache.
; 9/8/85 LAK Don't mount the volume if a catalog loop is detected. Call
; UpdateFree as part of MountVol consistency check. Zero roving
; allocation ptr on mount. Save first 4 bytes of non-Mac disk in
; FSTemp4 for Format package so it can discern Apple II diskettes.
; 9/6/85 LAK Slight modification to DtrmV3 prefix to prevent passing to
; DtrmVol if IOFileName points to a zero-length string (for the
; dubious result of making CatMove work with a zero-length string
; . . .).
; 9/5/85 LAK Set CacheFlag before flushing control cache.
; 8/31/85 LAK Made XferVName a bit more robust. Fixed GetWDInfo call bug.
; Mount scan now sets an inconsistent bit if it had to mark a bit
; in the allocation map . . .
; 8/30/85 LAK Added calls to TrashVBlks for Mount/UnmountVol. Rewrote
; DtrmVl/3. Fixed bug causing extents tree scan to be skipped.
; 8/29/85 LAK Call FlushMDB BEFORE closing the catalog and extents file FCBs
; in UnMountVol. Rewrote Eject mess . . . it's always synchronous
; now.
; 8/28/85 LAK Some changes to use WDCB lookup routines in TFSDir2.
; 8/27/85 LAK Much munging and saving in the InitCache, RelCache stuff.
; 8/22/85 PWD Changed _HGetVolInfo to return VRefNum in ioVRefNum field.
; 8/15/85 PWD Changed _GetVolInfo to return ioVFilCnt and ioVDirCnt.
; 8/6/85 PWD Fixed bugs in external FS treatment: changed _(TF)GetVolInfo to
; pass control to external FS AFTER stuffing I/O PB fields.
; 7/12/85 PWD Added MarkVCB routine to set VCB dirty instantly
; 7/11/85 PWD Moved FlushMDB routine into TFSCommon
; 6/29/85 PWD Fixed bug in mount to set up default WDCB when first volume is
; mounted in addition to setting DefVCBPtr.
; 6/20/85 PWD Changed to use combined file/directory CNode numbering Changed
; to return volRefNum on GetVolInfo and GetWDInfo ONLY if no WDCB
; was specified, or if a volume name was used.
; 6/19/85 PWD Changed non-hardware internal errors to FSDSIntErr instead of
; IOErr.
; 5/14/85 PWD Added SetVolInfo trap.
; 5/11/85 PWD Changed MountVol to share caches between volumes in a system to
; allow use on 128K machines
; 5/10/85 PWD Added TFGetVolInfo
; 5/1/85 PWD Added GetWDInfo
; 4/25/85 PWD Changed _Eject to leave non-ejectable volumes online, but call
; the driver anyway. Fixed code to turn all disk errors into IOErr
; before returning to the user.
; 4/25/85 PWD Fixed bug in OpenWD due to missing BRA to successful completion
; Fixed bug in GetWDCBRfn from double offset.
; 4/22/85 PWD Fixed FlushVol to write VCBLsMod date.
; 3/14/85 PWD Added WD code (OpenWD, CloseWD, SetDir, GetDir).
; 3/12/85 LAK FSVol/Eject: save and restore IOCompletion address over async
; FlushVol call (so Eject part of Eject may be done
; asynchronously).
; 2/12/85 PWD Adapted for use in Turbo FS from original Mac FS code: split
; MFS-specific code off into MFSVol, changed MountVol, UnMountVol,
; FlushVol, OffLine and Eject to handle TFS volumes and pass MFS
; volume matters to appropriate MFSVol entries. Added
; FindFCB,AccessBT, and FreeFCB routines
; 1/25/85 LAK Uncommented status call in MountVol. Use EnQueue, DeQueue
; routines directly.
; 8/7/84 GSS New today.
;
;
;_______________________________________________________________________
;
; External Routines: MountVol,UnMountVol,GetVol,SetVol,
; FlushVol,GetVolInfo,SetVolInfo,Eject,Offline,
; OpenWD,CloseWD,SetDir,GetDir
;
; Internal Routines: DtrmVol,FindDrive,CVFlgs,CkExtFS,
; FindFCB,AccessBT
;
;_______________________________________________________________________
;_______________________________________;
; ;
; MakeStkPB utility . . . ;
;_______________________________________;
BLANKS ON
STRING ASIS
MakeStkPB MOVE.L (SP)+,A0
MOVEQ #(IOVQElSize/2)-1,D0
@1 CLR.W -(SP) ; get IO param block off stack
DBRA D0,@1 ; (with IOFileName zeroed)
MOVE.L A0,-(SP)
MOVE.L SP,A0
ADDQ #4,A0
RTS
;_______________________________________________________________________
;
; Routine: MountVol
; Arguments: A0 (input) -- pointer to volume parameter block, uses:
; IOVDrvNum (name not allowed)
; D0 (output) -- error code
; This call is executed synchronously.
; Calls: FSQueueSync,GetVCBDrv,GetVCBRfn,FindDrive,CmdDone,
;
; Function: The VCB pointers are checked to see if a volume in the
; specified drive is already on-line (error if so). Reads in the
; directory master block and allocates memory for VCB and additional
; data structures, depending on the volume type:
;
; - For MFS volumes (handled in MFSVol), space is allocated for
; a volume buffer, as well as the block map, which is read in
; from disk).
;
; - For TFS volumes, space is allocated for a bitmap cache, a volume
; control cache (for B*-Tree use), and a volume cache. In addition,
; two FCBs are used by the B*-Trees.
;
; No new VCB storage is allocated for remounts.
;
; Fix _MountVol to
; not allocate any memory during disk switch operations.
; not attempt to _Offline other volumes to free up memory
; not reopen btree files on remounts
;
; In order to make the disk switch hook run without moving memory, we need
; to be able to check for a remount without moving memory. If we find a
; remount, we succeed. If we see the #fsNoAllocate flag, we'll return an
; error, causing the disk switch code to eject the disk and wait for another.
; Otherwise we jump into the ROM and let it do a new mount.
;
; When we do see a remount, we tweak the driver refNum and drive number and
; we're done, since the btree files will always be open.
;
; The flag #fsNoAllocate will be set by the disk switch hook to inform the
; file system that it should allow only remounts (i.e. not allocate any memory).
; If new mounts are allowed, we jump straight into the ROM code which mounts the
; volume, skipping the old code which attempted to _Offline other mounted
; volumes in favor of a newly mounted one.
;
; Exciting note for you wanna-be assemblers out there who write instructions
; into lomem at TrapAgain and jump to them. You know who you are (Disk Switch
; Hook). You might have been worried about flushing those whizzy processor
; caches that some of our more profitable macintoshes sport these days. However,
; as an added introductory bonus, successful mountvol calls flush the caches
; because they call _BlockMove when they fill in the fresh VCB from the MDB.
; _BlockMove is just one of those cache-flushing kind of guys.
;
; Modification History:
;
; 07 Aug 84 GSS New today
; 26 Oct 84 RFA Commented out Status call since Ron's driver doesn't support it
; 25 Jan 85 LAK Uncommented above call for Mac.
; 12 Feb 85 PWD Adapted for use with TFS Volumes; pass control to MFSMount
; for MFS volumes.
; 14 Feb 85 PWD Changed to link VCB into VCB queue immediately (it's needed
; for GetBlock to work. Unlink before passing control to MFSVol
; 27-Feb-85 PWD Fixed cache release code: use RelCache to dispose of vol. cache,
; and removed vol. cache code from DsposCaches (vol. cache is
; released in DsposBuf).
; 25-Apr-85 PWD Changed to return IOErr on internal errors.
; 11-MAy-85 PWD Changed to allocate caches only for first TFS volume, and share
; the caches on a system-wide basis with subsequently mounted volumes.
; 24-Jun-85 PWD Changed to update root name from volume name in VCB on mount
; 23-Jul-85 PWD Changed disk recognition algorithm to use only SigWord,
; CrDate, and volume name.
; 24-Jul-85 PWD Added increment of VCBWrCnt on mount to account for last
; write of MDB. Changed to copy information fresh from MDB
; into existing VCB on remount.
; 22-Aug-85 PWD Changed to flush MDB after mount with consistency flag cleared.
; <27Aug85> LAK Got rid of all calls to InitCache, RelCache. Added subroutine
; AdjustIntErr. Removed support for SysCRefcnt. Minor cleanup.
; <30Aug85> LAK Fixed bug causing extents tree scan to be skipped.
; <08Sep85> LAK Don't mount the volume if a catalog loop is detected. Call UpdateFree
; as part of MountVol consistency check. Zero roving allocation ptr on
; mount.
; 22-Sep-85 PWD Added code at mount to compute VCBXTAlBks and VCBCTAlBks.
; <01Oct85> LAK Removed AdjustIntErr: this function is now done in CmdDone.
; <07Oct85> PWD Changed to check 1st B*-Tree extent allocations status in cons. check
; Changed to check LEOF of open files on remount.
; <11Oct85> PWD Backed out of LEOF check on remount for Beta-ROMs.
; <14Oct85> PWD Changed to do all remount checking (including LEOF) immediately before
; a successful return.
; <03Nov85> LAK Fixed bug in MountVol out-of-memory (Mountvol has replaced IODrvNum in
; user parameter block with bogus vrefnum).
; This helps us in tight memory situations.
;_______________________________________________________________________
; Rolled in MountVolFor1991 patch from FileMgrPatches.a <SM1>
MountVol:
bsr FSQueueSync ; wait until all current calls are done
movea.l a0, a5 ; save caller's pb
move.w ioDrvNum(a5), d2 ; where FindDrive likes it
bsr FindDrive ; get driver refnum in D1 (drive num still in D2)
bne MtVolDone
suba.w #512,a6 ; a disk block
lea.l Params,a0 ; the old lomem param block
move.w d2,ioDrvNum(a0) ; drive number
move.w d1,ioRefNum(a0) ; driver RefNum
move.l a6,ioBuffer(a0) ; buffer
move.w #fsFromStart,ioPosMode(a0) ; position mode 1 (from disk start)
move.l #1024, ioPosOffset(a0) ; The MDB is always block #2
move.l #512,ioByteCount(a0) ; All MDBs are 1 512 byte block
_Read
bne RemountExit
moveq.l #NoMacDskErr,d0 ; Assume it's for another file system.
cmp.w #tSigWord,drSigWord(a6) ; Does it bear the Turbo Seal?
beq.s @GotMacDisk
cmp.w #sigWord,drSigWord(a6) ; Is it a trustworthy MFS volume?
bne RemountExit
@GotMacDisk:
moveq.l #badMDBErr,d0 ; in case master directory block is bad
move.l drAlBlkSiz(a6),d3 ; make sure this is non-zero, 512 multiple
beq RemountExit ; exit if 0
andi.w #$01FF,d3 ; 512-byte multiple?
bne RemountExit ; exit if not
move.w #notARemountErr,d0 ; 'cause we're looking for remounts only here
move.l VCBQHdr+qHead,d3 ; search the queue of VCBs
CheckRemountLoop:
beq RemountExit ; we fail if we don't see a remount <SM3> CSS
move.l d3,a2
tst.w vcbDrvNum(a2) ; matching volume better be off-line (0 drive num)
bne.s @Next
move.w vcbSigWord(a2),d3 ; Pick up Sigword of mounted volume
cmp.w drSigWord(a6),d3 ; Same signature?
bne.s @Next
move.l vcbCrDate(a2),d3 ; Pick up creation date of mounted volume
cmp.l drCrDate(a6),d3 ; Same create date?
bne.s @Next
move.l vcbLsMod(a2),d3 ; Pick up mod date of mounted volume
cmp.l drLsMod(a6),d3 ; Same mod date?
bne.s @Next
; At this point, we're fairly certain that the two volumes are, in fact, the same,
; but just to make sure (and avoid problems with stuck clocks), we'll compare the
; volume names as well:
lea.l vcbVN(a2),a1 ; Point to name of mounted volume
lea.l drVN(a6),a3 ; Point to name of current volume
moveq.l #(vcbMaxNam+1)-1,d3 ; check 28 bytes in name field (incl. length)
@loop:
cmpm.b (a1)+,(a3)+ ; field match?
dbne d3,@loop
beq.s Remount
@Next:
move.l qLink(a2),d3
bra.s CheckRemountLoop
; We are now convinced that we have a remount. We will rebuild the attributes
; byte, which is the only one that could have changed. We'll also store the
; current drive number and driver refNum, and mark the volume dirty.
Remount:
move.w #drvStsCode,csCode(a0) ; drive status!
clr.b 2+csParam(a0) ; Clear status byte for return
_Status ; refnum and drivenum set up by read call
moveq.l #-128,d0 ; $80 mask
and.b 2+csParam(a0),d0 ; WriteProt status get
move.b d0,vcbAtrb+1(a2) ; write-protect, zeroed consistency status
_AssumeEq vcbWrProt,7
move.w d2,vcbDrvNum(a2) ; drive number
move.w d1,vcbDRefNum(a2) ; driver RefNum
IF hasManEject THEN ; <SM7> <BH 03Aug93>
BSR SetVCBManEject ; set vcb maneject flag appropriately <SM7> <BH 03Aug93>
ENDIF ; <SM7> <BH 03Aug93>
jsr TFSVCBTst ; remounted a TFS volume? <32>
bne.s NoRemountErrExit ; Nope - don't mess with the MDB <33>
btst.b #vcbWrProt,vcbAtrb+1(a2); Is volume write protected? <32>
bne.s NoRemountErrExit ; If so, don't try to flush the MDB <33>
bclr.b #vcbAtVOK,vcbAtrb(a2) ; From now 'til unmount we're dirty <32>
jsr MarkVCBDirty ; mark VCB dirty so it will be written <32>
jsr FlushMDB ; write it <32>
NoRemountErrExit:
moveq.l #noErr,d0
RemountExit:
adda.w #512, a6 ; deallocate MDB buffer
tst.w d0 ; check the error
beq.s CmdDone ; noErr implies a successful remount
; if we are allowing new mounts, let the ROM handle the details. Otherwise,
; let the error stand
move.l FSVarsPtr,a1
btst.b #fsNoAllocate, FSVars.fsFlags(a1)
bne CmdDone ; let the error stand
ST NewMount ; assume now that it's a new volume
; First see if the disk is already mounted.
mv_Start MOVEQ #ParamErr,D0
MOVE.W IOVDrvNum(A0),D2 ; drive number
BLE.S toMVDone ; br if none specified
MOVE.W D2,D0 ; see if there's a vol already mounted
BSR GetVCBDrv ;
BNE.S mv_getDrive ; br if not
TST.W VCBDrvNum(A2) ; is it offline? <01Oct85>
BEQ.S mv_getDrive ; br if so . . . (probably a remount) <01Oct85>
MOVEQ #VolOnLinErr,D0 ; report an error
toMVDone BRA MtVolDone
; Find the appropriate drive queue entry and allocate a VCB.
mv_getDrive:
BSR FindDrive ; get driver refnum in D1 (drive num still in D2)
BNE.S toMVDone ; br if not found or for external FS
MOVE.L A0,A2 ; preserve A0 a bit
MOVE.L #VCBLength,D0 ; get memory for VCB
_NewPtr ,SYS,CLEAR ; off the system heap, zeroed
; Note: VCBFSID,VCBDirIndex,VCBFlags are 0, as well as VCBXTRef, VCBCTRef,
; VCBMAdr, VCBCtlBuf, and VCBBufAdr.
BNE.S toMVDone ; exit if we got no memory
LEA VCBQHdr,A1 ; Point to head of VCB queue
TST.L QHead(A1) ; Check: is queue empty right now?
BNE.S @1 ; If not, never mind
MOVE.L A0,DefVCBPtr ; If empty, this is now default, too.
MOVE.L WDCBsPtr,A1 ; Point to WDCB array
MOVE.L A0,WDVCBPtr+2(A1) ; Set default VCB pointer in default WDCB
MOVEQ #FSRtDirID,D0 ; Default to root directory
MOVE.L D0,WDDirID+2(A1) ; Set directory to default to
CLR.L WDCatHint+2(A1) ; Clear catalog hint
CLR.L WDProcID+2(A1) ; And procID of WDCB 'owner'
LEA VCBQHdr,A1 ; Reset A1 for VCB insertion
@1 JSR EnqueueTrap ; Insert the new VCB in the queue
EXG A0,A2 ; VCB ptr
MOVE.W D2,VCBDrvNum(A2) ; put drive number
MOVE.W D1,VCBDRefNum(A2) ; and driver refnum into VCB
IF hasManEject THEN ; <SM7> <BH 03Aug93>
BSR SetVCBManEject ; set vcb maneject flag appropriately <SM7> <BH 03Aug93>
ENDIF ; <SM7> <BH 03Aug93>
MOVEA.L SysVolCPtr,A1 ; set up A1
MOVE.L A1,VCBBufAdr(A2) ; always use system-wide cache . . .
; Assign a refNum to this new volume.
MOVEQ #0,D0 ; Begin with a clean slate
mv_GetVRef SUBQ.W #1,D0 ; Start with -1 and count down
MOVEM.L D0/A2,-(SP)
BSR GetVCBRfn ; Check if already assigned
MOVEM.L (SP)+,D0/A2 ;
BEQ.S mv_GetVRef ; If EQ, VRefNum already assigned
MOVE.W D0,VCBVRefNum(A2) ; note for us
CMP.L DefVCBPtr,A2 ; Are we supposedly the default?
BNE.S mv_GetMDB ; Nope - don't worry about it.
MOVE.W D0,DefVRefNum ; Set up default VRefNum now, too
; Now try reading in the master directory block.
mv_GetMDB:
MOVEQ #0,D1 ; Clear flag bytes
MOVEQ #2,D2 ; MDB is always block 2 (third block on disk)
JSR GetBlock ; With A1 still pointing to volume CQH.
BNE MtVolEr2 ; Quit & Release VCB on errors <02Sep85>
MOVE.L A0,A5 ; Save buffer ptr for later <01Oct85>
; Now check what manner of animal we have before us:
MOVEQ #kRBTrash,D1 ; trash it in case VCB gets reused . . .<01Oct85>
JSR RelBlock ; Release hold on cache block <02Sep85>
CMP.W #TSigWord,DrSigWord(A5) ; Does it bear the Turbo Seal? <08Sep85>
BEQ.S mv_GotMDB ; If so, give it the full treatment <01Oct85>
MOVEQ #NoMacDskErr,D0 ; Assume it's for another file system. <01Oct85>
CMP.W #SigWord,DrSigWord(A5) ; Is it a trustworthy MFS volume? <08Sep85>
BNE MtVolEr2 ; br if not <01Oct85>
; Now do a little more checking before starting to use the data.
mv_GotMDB:
MOVEQ #BadMDBErr,D0 ; in case master directory block is bad
MOVE.L DrAlBlkSiz(A5),D1 ; make sure this is non-zero, 512 multiple
BEQ MtVolEr1 ; exit if 0 (shared MFS/TFS exit)
AND.W #$01FF,D1 ; 512-byte multiple?
BNE MtVolEr1 ; exit if not (shared MFS/TFS exit)
; The MDB seems OK: transfer all master directory info from buffer into VCB.
LEA VCBDInfoSt(A2),A1 ; Destination is in VCB
MOVEQ #VCBDILen,D0 ; Length of MFS/TFS info in MDB
_BlockMove ; Copy the information
MV_GetWPStatus:
MOVE.L FSQHead,A0 ; A0 -> current request
MOVE.W VCBVRefNum(A2),IOVRefNum(A0) ; return volume refnum to user
LEA Params,A0 ; general purpose I/O param block
MOVE.W #DrvStsCode,CSCode(A0) ; drive status!
CLR.B 2+CSParam(A0) ; Clear status byte for return
_Status ; refnum and drivenum set up by read call
MOVEQ #-128,D0 ; $80 mask
AND.B 2+CSParam(A0),D0 ; WriteProt status get
MOVE.B D0,VCBAtrb+1(A2) ; write-protect, zeroed consistency status
_AssumeEq VCBWrProt,7
; Now the MFS code diverges from the TFS code.
BSR TFSVCBTst ; Is it an MFS volume? <01Oct85>
BNE MV_GetMFSMap ; Br if so (do the MFS-specific stuff) <01Oct85>
LEA DrTInfoSt(A5),A0 ; Advance pointer to additional TFS stuff
LEA VCBTDInfoSt(A2),A1 ; Point to additional TFS-specific info
MOVEQ #VCBTDILen,D0 ; Length of additional information
_BlockMove ; Copy the additional information in
MOVE.L VCBAlBlkSiz(A2),D1 ; Pick up allocation block size <22Sep85>
MOVE.L DrXTFlSize(A5),D0 ; Pick up PEOF of extent B*-Tree <22Sep85>
JSR DivUp ; Divide (AlBlkSiz MUST BE <64KB!) <22Sep85>
MOVE.W D0,VCBXTAlBks(A2) ; Store result for use in GetVolInfo <22Sep85>
MOVE.L DrCTFlSize(A5),D0 ; Pick up PEOF of catalog B*-Tree <22Sep85>
JSR DivUp ; Compute its allocation similarly <22Sep85>
MOVE.W D0,VCBCTAlBks(A2) ; And store the result for later use <22Sep85>
CLR.W VCBAllocPtr(A2) ; Restart the roving allocation ptr <08Sep85>
ADDQ.L #1,VCBWrCnt(A2) ; Compensate for write of MDB on last flush
; Try to find two free FCBs for use by the volume control B*-Trees:
BSR FindFCB ; Try to find a free FCB (set up D0/D1/A1)
BNE MtVolErr ; Br if we failed to find one <01Oct85>
MOVE.W D1,VCBXTRef(A2) ; Set Extents B*-Tree file RefNum
MOVE.L DrXTFlSize(A5),FCBEOF(A1,D1) ; Set extent tree's LEOF <01Oct85>
MOVE.L DrXTFlSize(A5),FCBPLen(A1,D1) ; Set extent tree's PEOF <01Oct85>
MOVEQ #lenXDR,D0 ; Length of extent record
LEA DrXTExtRec(A5),A0 ; Point to only XT extent record
LEA FCBExtRec(A1,D1),A1 ; Point to extent record in FCB <01Oct85>
_BlockMove ; Copy in the extent record
BSR FindFCB ; Try to find another FCB (set up D0/D1/A1)
BNE MtVolErr ; Punt on error
MOVE.W D1,VCBCTRef(A2) ; Save catalog file refNum
MOVE.L DrCTFlSize(A5),FCBEOF(A1,D1) ; Set catalog tree's LEOF <01Oct85>
MOVE.L DrCTFlSize(A5),FCBPLen(A1,D1) ; Set catalog tree's PEOF <01Oct85>
MOVEQ #lenXDR,D0 ; Length of extent record
LEA DrCTExtRec(A5),A0 ; Point to first catalog extent record
LEA FCBExtRec(A1,D1),A1 ; Point to extent record in FCB <01Oct85>
_BlockMove ; Copy in the extent record
MOVE.L SysBMCPtr,VCBMAdr(A2) ; Set up the volume bitmap cache
MOVE.L SysCtlCPtr,VCBCtlBuf(A2) ; Set up the volume control cache
; Finish setting up the FCBs for the extent B*-Tree and the catalog B*-Tree:
MOVE.W VCBXTRef(A2),D0 ; Get extent-tree refNum
MOVEQ #FSXTCNID,D1 ; extent-tree file ID
MOVE.L VCBXTClpSiz(A2),D2 ; clump size
MOVE.L VCBCtlBuf(A2),A1 ; extent-tree cache
LEA FXMKeyCmp,A3 ; Key comparison routine for extent tree
BSR AccessBT ; Set up access to B*-Tree file
BNE MtChkErr ; Exit on errors <01Oct85>
MOVE.W VCBCTRef(A2),D0 ; Get catalog-tree refNum
MOVEQ #FSCTCNID,D1 ; catalog-tree file ID
MOVE.L VCBCTClpSiz(A2),D2 ; clump size
MOVE.L VCBCtlBuf(A2),A1 ; catalog-tree cache
LEA CMKeyCmp,A3 ; Key comparison routine for catalog tree
BSR AccessBT ; Set up access to B*-Tree file
BNE MtChkErr ; Exit on errors <01Oct85>
BCLR #VCBAtVOK,VCBAtrb(A2) ; From now until _Unmount <22Aug85>
; ... the disk is inconsistent <22Aug85>
BEQ MtCheck ; If it was clear, do the time consuming <01Oct85>
; disk check
; NOTE: The MFS code re-joins this common thread of execution here:
CheckRemount:
MOVE.L jCheckRemount,-(SP) ; jump table entry for vCheckRemount <19Feb87>
RTS ; go there <19Feb87>
vCheckRemount ; 'vectored' CheckRemount routine <19Feb87>
; Deleted stuff patched out by KillCheckRemountNiceWay in FileMgrPatches.a <SM1>
MtVolOK MOVEQ #0,D0 ; no errors
MtVolDone TST.W D0 ; Any errors encountered?
BNE.S @1 ; Yes - leave well enough alone, then
BSR TFSVCBTst ; Mounted a TFS volume?
BNE.S @1 ; Nope - don't mess with the MDB
BTST #VCBWrProt,VCBAtrb+1(A2) ; Is volume write protected?
BNE.S @1 ; If so, don't try to flush the MDB
BSR MarkVCBDirty ; Make sure it's marked dirty <10Oct85>
BSR FlushMDB ; Flush the MDB out to mark the volume inconsistent
@1 BRA CmdDone ; return to command finish
MtChkErr MOVE.W D0,HFSDSErr ; Save the error code for debugging <01Oct85>
MOVEQ #badMDBErr,D0 ; Indicate the MDB is bad for all internal errors
; Release any resources allocated so far before exiting with an error:
MtVolErr BSR DsposFCBs ; deallocate control file FCBs
; The following two exits are shared with MFS mount code . . .
MtVolEr1 BSR DsposVBlks ; invalidate any cache blocks for this volume
MtVolEr2 TST.B NewMount ; only deallocate VCB for new mounts
BEQ.S @1 ; remount case
BSR DsposVCB ; new mount -- get rid of VCB
@0 TST.W D0 ; Check: was this a real error? (or OK Mount) <PWD 07Oct85>
BLE CmdDone ; Yes - We're all done, then. <PWD 07Oct85>
MOVE.L FSQHead,A0 ; A0 -> current request <PWD 07Oct85>
BRA mv_Start ; So start all over again, but don't even THINK <PWD 07Oct85>
; about the possibility of a ReMount this time. <PWD 07Oct85>
; Remount case -- Must zero buffer and map ptrs in old VCB.
; Restore VCB to its original off-line state (ie clear VCBDrvNum,
; and move drive number to VCBDRefNum field)
@1 ADDA #VCBDrvNum, A2 ; A2 --> drive number field of VCB
MOVE.W (A2),D3 ; D3 = drive number
CLR.W (A2)+ ; clear drive number field of VCB
MOVE.W D3,(A2)+ ; write drv number to VCBDRefNum field
ADDQ #4,A2 ; A2 --> VCB's buffptr field
CLR.L (A2)+ ; clear buffptr in VCB
CLR.L (A2)+ ; clear mapptr in VCB
BRA.S @0 ; <27Aug85>
; Before releasing the volume to the world, do some quick consistency checks
; (and possibly some patch-ups) on the volume:
;
; 1. Make sure the name of the root reflects the volume name in the VCB:
MtCheck:
MOVE.L jMtCheck,-(SP) ; jump table entry for vMtCheck <19Feb87>
RTS ; go there <19Feb87>
vMtCheck ; 'vectored' MtCheck routine <19Feb87>
MOVEQ #FSRtDirID,D0 ; Root directory ID
MOVEQ #0,D2 ; No catalog hint
MOVE.L D2,A0 ; Nil CName
JSR CMGetCN ; Look up the root directory
BNE.S MtChkErr ; Punt on errors
MOVEQ #0,D0 ; Clear all unused bytes
LEA ckrCName(A0),A1 ; Point to CName in key
MOVE.B (A1)+,D0 ; Pick up length byte
SWAP D0 ; Stash 'second' string length
LEA VCBVN(A2),A0 ; Source is volume name
MOVE.B (A0)+,D0 ; Pick up 'first' string length
SWAP D0 ; Put things in order for _CmpString
_CmpString ,MARKS,CASE ; EVERYTHING counts here...
BEQ.S BMScan ; If this is OK, check the rest of the catalog
; the names don't match, check length of volume name
SUBQ.L #1,A1 ; Point back to root name again <16Sep86>
SUBQ.L #1,A0 ; Point back to volume name again <16Sep86>
MOVEQ #0,D0 ; Pick up length byte <02Oct86>
MOVE.B (A0),D0 ; <02Oct86>
BEQ.S @2 ; use root name if zero -> <16Sep86>
CMPI.W #VCBMaxNam,D0 ; check if length greater than max <16Sep86>
BLE.S @1 ; br if not -> <16Sep86>
MOVE.B #VCBMaxNam,(A0) ; truncate it to max length <16Sep86>
; the length of volume name is ok, rename the root directory
@1 MOVEQ #FSRtDirID,D0 ; root DirID <16Sep86>
MOVEA.L A0,A1 ; volume name is new name <16Sep86>
SUBA.L A0,A0 ; use only the DirID to identify root <16Sep86>
MOVEQ #0,D2 ; no hint <16Sep86>
JSR CMRenameCN ; rename the root directory <16Sep86>
BNE.S MtChkErr ; punt on errors <16Sep86>
BRA.S BMScan ; continue with bit map check <16Sep86>
; the length of the volume name is zero, check root name length
@2 MOVEQ #0,D0 ; Pick up length byte <02Oct86>
MOVE.B (A1),D0 ; <02Oct86>
BEQ MtChkErr ; give up if root name is zero also <16Sep86>
CMPI.W #VCBMaxNam,D0 ; check if length greater than max <16Sep86>
BLE.S @3 ; br if not -> <16Sep86>
MOVEQ #VCBMaxNam,D0 ; truncate it to max length <16Sep86>
; the root name length is ok, change volume name to root name
@3 MOVE.B D0,(A0)+ ; move in the length byte <16Sep86>
SUBQ.W #1,D0 ; adjust D0 for DBRA <16Sep86>
ADDQ.L #1,A1 ; position pass root name length byte <16Sep86>
@4 MOVE.B (A1)+,(A0)+ ; move in <16Sep86>
DBRA D0,@4 ; .. the name <16Sep86>
; EXG A0,A1 ; Sigh - CMRename likes 'em differently <16Sep86>
; MOVEQ #FSRtParID,D0 ; This directory exists in the root parent <16Sep86>
; <Use catalog hint still in D2>
; JSR CMRenameCN ; Change the name <16Sep86>
; BNE MtChkErr ; Punt on errors <16Sep86>
; 2. Make sure the bitmap reflects the allocation status of all extent records:
BMScan: MOVE.L FCBsPtr,A1 ; Point to FCB table <07Oct85>
MOVE.W VCBXTRef(A2),D1 ; Pick up extent B*-tree refNum <07Oct85>
LEA FCBExtRec(A1,D1),A0 ; Point to extent record there <07Oct85>
BSR BMChk ; Check this extent record <07Oct85>
MOVE.W VCBCTRef(A2),D1 ; Pick up catalog B*-Tree refNum <07Oct85>
LEA FCBExtRec(A1,D1),A0 ; Point to extent record for B*-Tree <07Oct85>
BSR BMChk ; Check this extent's allocation status <07Oct85>
; Start by scanning the remainder of the catalog to verify all extent
; records in the catalog:
MOVEQ #FSRtDirID,D0 ; Root directory ID
; Use catalog hint in D2
SUBA.L A0,A0 ; Generate a nil CName
JSR CMGetCN ; Look up the root directory
BNE MtChkErr ; Punt on errors
MOVEA.L FCBsPtr,A1 ; Point to the FCBs
MOVE.W VCBCTRef(A2),D1 ; Pick up the catalog refNum
; Before starting a scan of the catalog, make a conservative estimate of the
; upper limit of B*-Tree records that could conceivably be encountered in a
; scan of all leaf nodes by dividing the catalog's PEOF by the size of the
; smalles CNode (a directory entry):
MOVE.L FCBPLen(A1,D1),D0 ; Pick up the catalog size in bytes
LSR.L #6,D0 ; divide by 64 (less than smallest record size)
MOVE.L D0,D2 ; D2 = max. number of CNodes possible
MOVEQ #FSUsrCNID-1,D4 ; Reset largest CNID found <29Aug85>
MOVEQ #0,D3 ; Clear inconsistency flag
MOVEQ #0,D5 ; Clear file count
MOVEQ #0,D6 ; Clear directory count
MOVEQ #0,D7 ; Clear root content counts (high & low)
CTScan: SUBQ.L #1,D2 ; Count down by ones
BLT MtChkErr ; No mounting on loop errors <08Sep85>
@10 MOVE.W VCBCTRef(A2),D0 ; Catalog tree refNum
MOVEQ #1,D1 ; Get first record following current record
MOVE.L D2,-(A6) ; Save record count across call
JSR BTGetRecord ;
MOVE.L (A6)+,D2 ; Restore record count, destroying hint.
TST.W D0 ; Check for error on BTGetRecord
BNE.S @90 ; Punt on errors
CMP.B #cdrDirRec,cdrType(A1) ; Is this a directory?
BNE.S @25 ; If not, check for files
ADDQ.L #1,D6 ; Bump the total directory count
CMP.L #FSRtDirID,ckrParID(A0) ; Is this directory in the root?
BNE.S @15 ; If not, nothing special
SWAP D7 ; Get access to the high word
ADDQ.W #1,D7 ; Bump the root directory count
SWAP D7 ; And store it back.
@15 CMP.L dirDirID(A1),D4 ; Is this DirID bigger than cur. maximum?
BHS.S CTScan ; If not, keep looking
MOVE.L dirDirID(A1),D4 ; Otherwise, retain this new high
BRA.S CTScan ; And ignore directories otherwise
@25 CMP.B #cdrFilRec,cdrType(A1) ; Is this a file?
BNE.S CTScan ; If not, just keep on looking
ADDQ.L #1,D5 ; Bump the total file count
CMP.L #FSRtDirID,ckrParID(A0) ; Is this directory in the root?
BNE.S @30 ; If not, nothing special
ADDQ.W #1,D7 ; Bump the root file count
@30 CMP.L filFlNum(A1),D4 ; Is this file number a new maximum?
BCC.S @50 ; If not, just check its allocation
MOVE.L filFlNum(A1),D4 ; Otherwise, remember this peak
; Check the blocks allocated to this file (both forks):
@50 LEA filExtRec(A1),A0 ; Point to extent record for data fork
BSR BMChk ; Check its allocation status <07Oct85>
LEA filRExtRec(A1),A0 ; Point to extent record for resource fork
BSR BMChk ; Check its allocation status <07Oct85>
BRA.S CTScan ; Go for the next record
@90 CMP.W #BTNotFound,D0 ; Was record not found?
BNE MtChkErr ; Punt on other errors
VCBChk: CMP.L VCBNxtCNID(A2),D4 ; Is the maximum found in scan consistent?
BCS.S @10 ; If so, that's nice [expected]
ADDQ.L #1,D4 ; Otherwise, THIS is the next CNode ID
MOVE.L D4,VCBNxtCNID(A2) ; Record the new maximum
BSET #0,VCBAtrb+1(A2) ; Mark error in VCB attributes
MOVEQ #-1,D3 ; Mark a scan error
@10 CMP.L VCBFilCnt(A2),D5 ; Check total number of files on volume
BEQ.S @20 ; If same, continue
MOVE.L D5,VCBFilCnt(A2) ; Otherwise, fix the inconsistency
BSET #1,VCBAtrb+1(A2) ; Mark error in VCB attributes
MOVEQ #-1,D3 ; But mark the scan error
@20 CMP.L VCBDirCnt(A2),D6 ; Check total number of directories on volume
BEQ.S @30 ; If same, continue
MOVE.L D6,VCBDirCnt(A2) ; Fix the inconsistency
BSET #1,VCBAtrb+1(A2) ; Mark the error in VCB attributes
MOVEQ #-1,D3 ; Mark the scan error
@30 CMP.W VCBNmFls(A2),D7 ; Check the number of files in the root
BEQ.S @40 ; If that's OK, continue
MOVE.W D7,VCBNmFls(A2) ; Otherwise, overwrite the VCB info.
BSET #1,VCBAtrb+1(A2) ; Mark error in VCB attributes
MOVEQ #-1,D3 ; And mark a scan error
@40 SWAP D7 ; Get the root directory count in low word
CMP.W VCBNmRtDirs(A2),D7 ; Check the number of root directories
BEQ.S @90 ; Continue if all seems well
MOVE.W D7,VCBNmRtDirs(A2) ; Otherwise, update the VCB info.
BSET #1,VCBAtrb+1(A2) ; Mark error in VCB attributes
MOVEQ #-1,D3 ; And mark a scan error
@90
; Next, scan the extent tree to make sure all extent records are actually
; marked as allocated:
XTScan:
; Before starting a scan of the extenbt tree, make a conservative estimate of the
; upper limit of B*-Tree records that could conceivably be encountered in a
; scan of all leaf nodes by dividing the catalog's PEOF by the size of an extent
; record:
MOVEA.L FCBsPtr,A1 ; Point to the FCB array
MOVE.W VCBXTRef(A2),D1 ; Pick up the extent tree refNum
MOVE.L FCBPLen(A1,D1),D0 ; Pick up the extent tree size in bytes
LSR.L #4,D0 ; divide by 16 (less than smallest record size)
MOVE.L D0,D5 ; D5 = max. number of extent records
MOVE.W VCBXTRef(A2),D0 ; Extent tree refNum
SUB.W #lenXKR,A6 ; Allocate an extent tree key on the stack
MOVEA.L A6,A0 ; Set up pointer to extent key
MOVE.W #$0700,xkrKeyLen(A0); Set up key length & fork type
CLR.L xkrFNum(A0) ; Clear file number in key
CLR.W xkrFABN(A0) ; Clear starting allocation block in key
MOVEQ #0,D2 ; Clear B*-Tree hint
JSR BTSearch ; Look for this key [which cannot exist]
ADD.W #lenXKR,A6 ; Deallocate key from stack
MOVEQ #0,D1 ; Select record right of insertion point
@10 SUBQ.L #1,D5 ; Count down by one
BLT MtChkErr ; No mounting on loop errors <08Sep85>
@20 MOVE.W VCBXTRef(A2),D0 ; Set up extent tree RefNum again
JSR BTGetRecord ; Try to get it
BNE.S @90 ; Stop on errors
; Check the allocation status of this extent record:
MOVEA.L A1,A0 ; Point to extent record
BSR.S BMChk ; Check the allocation status <07Oct85>
MOVEQ #1,D1 ; Set up to get next record
@50 BRA.S @10 ; And go for it
@90 CMP.W #BTNotFound,D0 ; No more records to be found?
BNE MtChkErr ; If not, that's serious trouble
; Finally, refigure the free block count by counting all zero bits in allocation map
JSR UpdateFree ; VSM routine does this for us . . . <08Sep85>
BRA CheckRemount ; This mount is OK: Check for remount <14Oct85>
BMChk
MOVE.L jBMChk,-(SP) ; jump table entry for vBMChk <27Oct86>
RTS ; go there <27Oct86>
vBMChk ; 'vectored' BMChk routine <27Oct86>
MOVE.L (SP)+,-(A6) ; Save return address <09Oct85>
BSR CVFlgs ; Can we write the volume? <18Oct85>
BNE.S @10 ; If not, no point fixing the bitmap <18Oct85>
JSR BlkChk ; Check the allocation status <07Oct85>
BEQ.S @10 ; Continue if all was well <07Oct85>
MOVEQ #-1,D3 ; Make a note of the inconsistency <07Oct85>
BSET #2,VCBAtrb+1(A2) ; Mark error in allocation map <07Oct85>
@10 MOVE.L (A6)+,-(SP) ; Restore original return address <09Oct85>
RTS ; <07Oct85>
IF hasManEject THEN ; <SM7> <BH 03Aug93>
;--------------------------------------------------------------------------------------
; Routine: SetVCBManEject
; Input: A2 = VCB ptr
; Called by: MountVol
; Function: Sets or clears the manual-eject bit in the flags word of the input VCB
; based on the type of the drive indicated by vcbDrvNum. All registers
; are preserved. The manual-eject flag should only be changed at MountVol
; time.
;--------------------------------------------------------------------------------------
SetVCBManEject
MOVEM.L A0/D0,-(SP) ; save regs
MOVE.W vcbDrvNum(A2),D0 ; get drive num
MOVEA.L DrvQHdr+qHead,A0 ; get first DQE
@check CMP.W dqDrive(A0),D0 ; match?
BEQ.S @found ; yep: go set the flag
MOVEA.L qLink(A0),A0 ; no: check the next one
BRA.S @check
@found MOVE.W vcbFlags(A2),D0 ; get flags word
BTST #dqManEjBit,dqInstall(A0) ; is this a manual-eject drive?
BEQ.S @no ; no: clear the flag
BSET #vcbManEjBit,D0 ; yes: set it
BRA.S @exit
@no BCLR #vcbManEjBit,D0 ; clear the flag
@exit MOVE.W D0,vcbFlags(A2) ; store flags
MOVEM.L (SP)+,A0/D0 ; restore regs
RTS ; goodbye
ENDIF
;________________________________________________________________________________
;
; Routines: DsposFCBs, DsposVCB, DsposVBlks
; Function: Shared routines for tearing down volume structures.
;________________________________________________________________________________
DsposFCBs MOVEM.L D0-D1/A1,-(SP) ; preserve all regs <01Oct85>
MOVEA.L FCBsPtr,A1 ; Point to FCB table <01Oct85>
MOVE.W VCBXTRef(A2),D1 ; Get Extent B*-Tree refNum
BEQ.S @1 ; br if unallocated
CLR.L FCBFlNm(A1,D1) ; Clear file number to FCB as unused <01Oct85>
@1 MOVE.W VCBCTRef(A2),D1 ; Get catalog refnum
BEQ.S @2 ; If zero, it's unallocated
CLR.L FCBFlNm(A1,D1) ; Clear file number to FCB as unused <01Oct85>
@2 MOVEM.L (SP)+,D0-D1/A1 ; restore all regs <01Oct85>
RTS ;
DsposVCB MOVE.L D0,-(SP) ; preserve error code
; Close any working directories left open for this volume (the VCB is about to
; disappear):
BSR Gt1stWDVMatch ; sets up A1, D1 <28Aug85>
@1 BNE.S @2 ; br if no more WDCBs <28Aug85>
CLR.L WDVCBPtr(A1,D1) ; free the WDCB <28Aug85>
CLR.L WDDirID(A1,D1) ; <30Aug85>
BSR GtNxtWDVMatch ; <28Aug85>
BRA.S @1 ; <28Aug85>
@2 MOVE.L A2,A0 ; dequeue this VCB
LEA VCBQHdr,A1 ; ptr to VCB queue header
JSR DequeueTrap ; unlink this VCB from the VCB queue
CMP.L DefVCBPtr,A2 ; did we unmount our default? <30Aug85>
BNE.S @3 ; br if not <30Aug85>
CLR.L DefVCBPtr ; if so, no more default <30Aug85>
CLR.W DefVRefNum ; And no more default VRefNum <30Aug85>
@3 _DisposPtr ; dispose VCB and buffer memory <30Aug85>
DsposExit MOVE.L (SP)+,D0 ; restore error code
RTS
; DsposVBlks trashes all cache blocks for a given volume (specified by A2=VCB ptr).
; It is called on mount errs and when unmounting a volume.
DsposVBlks MOVE.L A1,-(SP) ; save all regs <30Aug85>
MOVE.L SysBMCPtr,A1 ; System-wide bitmap cache pointer <30Aug85>
JSR TrashVBlks ; A2=VCB ptr <30Aug85>
MOVE.L SysVolCPtr,A1 ; System-wide volume cache pointer <30Aug85>
JSR TrashVBlks ; A2=VCB ptr <30Aug85>
MOVE.L SysCtlCPtr,A1 ; System-wide control cache pointer <30Aug85>
JSR TrashVBlks ; A2=VCB ptr <30Aug85>
MOVE.L (SP)+,A1 ; <30Aug85>
RTS ; <30Aug85>
;________________________________________________________________________________
;
; Routine: FindFCB
;
; Arguments: D1.W (out) - FCB index (suitable for use as File RefNum).
; A1.L (out) - FCB ptr
; D0.W (out) - TMFOErr or 0 if ok.
; All other regs preserved.
;
; Function: Find an unused FCB
;
; Modification history:
; 22-Jul-85 PWD Changed to skip first FCB (#2), left free for system file.
; <01Oct85> LAK Rewrote to use Gt1stFCB, GtNxtFCB routines, and to return A1/D0/D1.
;________________________________________________________________________________
FindFCB:
BSR Gt1stFCB ; get (A1,D1) pointing to first FCB <01Oct85>
BRA.S @2 ; skip first FCB (save for System file) <01Oct85>
@1 TST.L FCBFlNm(A1,D1) ; FCB unused? <01Oct85>
BNE.S @2 ; br if so <01Oct85>
MOVEQ #-1,D0 ; get -1 <01Oct85>
MOVE.L D0,FCBFlNm(A1,D1) ; Found a free one: mark as in-use <01Oct85>
MOVEQ #0,D0 ; no error <01Oct85>
BRA.S @3 ; <01Oct85>
@2 BSR GtNxtFCB ; get next one until we run out <01Oct85>
BCS.S @1 ; <01Oct85>
MOVEQ #TMFOErr,D0 ; too many files open <01Oct85>
@3 RTS ; <01Oct85>
;________________________________________________________________________________
;
; Routine: AccessBT
;
; Function: Create an access path for a B*-Tree file:
; 1. Initialize the FCB
; 2. Attach a B*-Tree control block
;
; Inputs:
; D0.W - File FCB
; D1.L - File ID
; D2.L - File clump size
; A1 - Cache buffer
; A2 - VCB pointer
; A3 - Address of key comparison routine
;
; Outputs:
; D0.W - I/O result from BTOpen
;________________________________________________________________________________
AccessBT: MOVE.L (SP)+,-(A6) ; Save return address
MOVEM.L D3/A0,-(A6) ; Save scratch registers
MOVEA.L FCBsPtr,A0 ; Point to FCB table
LEA 0(A0,D0.W),A0 ; Point to FCB itself
CLR.W FCBFlags(A0) ; Clear flag bytes
CLR.W FCBSBlk(A0) ; Start block is undefined
CLR.L FCBCrPs(A0) ; Current position is undefined
MOVE.L D1,FCBFlNm(A0) ; Set file ID
MOVE.L A2,FCBVPtr(A0) ; Set VCB pointer
MOVE.L D2,FCBClmpSize(A0) ; Set File Clump Size
MOVEA.L A3,A0 ; Key comparison routine
JSR BTOpen ; Open file for B*-Tree access
MOVEM.L (A6)+,D3/A0 ; Restore registers
MOVE.L (A6)+,-(SP) ; Restore return address
TST.W D0
RTS
;_______________________________________________________________________
;
; Routine: FindDrive
; Arguments: D2.W (input) -- drive number
; D1.W (output) -- driver refnum for this drive number
; D2.W (output) -- drive number
; D0.W (output) -- error code (no such drive)
; A3.L (output) -- pointer to DQE for drive in question
; All other registers are preserved.
; Calls: QWordSearch
; Called By: Eject,MountVol
; Function: Given a drive number, this routine returns the RefNum
; for the driver by searching the system drive queue.
;
; Modification History:
; 06 Dec 82 LAK New today.
; 13 Jan 83 LAK Removed block offset - now returns drive number in D2
; 01 Jun 83 LAK Checks added DQFSID field, reporting ExtFSErr if nonzero
; 25 Apr 85 PWD Changed to return DQE pointer in A3 for use in Eject.
;_______________________________________________________________________
FindDrive:
MOVE.L jFindDrive,-(SP) ; jump table entry for vFindDrive <19Feb87>
RTS ; go there <19Feb87>
vFindDrive ; 'vectored' FindDrive routine <19Feb87>
MOVE.L A0,-(SP) ; preserve A0
MOVE.W D2,D0 ; search using this drive number as the key
LEA DrvQHdr,A0 ; search the queue of drive numbers
MOVEQ #DQDrive,D1 ; for drive number
BSR QWordSearch
BNE.S @2 ; exit if not found
MOVEA.L A0,A3 ; Return pointer to DQE
MOVE DQRefNum(A0),D1 ; return refnum
MOVE.W DQFSID(A0),D0 ; is it for us?
BEQ.S @1 ; br if so
MOVEQ #ExtFSErr,D0 ; otherwise, report an error
@1 MOVEA.L (SP)+,A0 ; restore A0
RTS
@2 MOVEQ #NSDrvErr,D0 ; no such drive number
BRA.S @1
;_______________________________________________________________________
;
; Routine: OffLine
; Arguments:
; Calls:
; Called By:
; Function:
;
; Modification History:
;
; In order to make the disk switch hook run without moving memory, we need
; to leave the btree control files (catalog and extents) open when putting
; a volume offline, so that the subsequent _Mount call won't have to allocate
; a new btree control block.
;
; 5 Jul 84 GSS Added this call to the TFS code
;_______________________________________________________________________
; Rolled in NoCloseOnOffline patch from FileMgrPatches.a <SM1>
OffLine:
BSR FSQueueSync ; wait until all current calls are done <SM1>
ST NoEject ; NoEject.B = -1: mark vol. offline but
; don't eject the diskette
BRA Eject1 ; share code with Eject
;_______________________________________________________________________
;
; Routine: Eject
; Arguments: A0 (input) -- pointer to volume parameter block, uses IODrvNum,
; IOFileName
; D0 (output) -- error code
; This call is executed synchronously until the eject call is
; actually made.
; Calls: _FlushVol,_Control
;
; Function: The volume in the drive is flushed and its block map and buffer
; block are deallocated. A control call to the disk driver
; is made to eject the diskette.
;
; Modification History:
; 06-Dec-82 LAK New today.
; 13-Jan-83 LAK Disk control call now uses drive number parameter. Completion
; routine is now just CmdDone.
; 01-Jun-83 LAK Changed to just flush the volume before ejecting; VCB
; drive number and driver number are zeroed.
; 05-Jul-84 GSS Patched from MSFileFix code
; 12-Feb-85 PWD Split off MFS code and adapted for use in Turbo FS.
; 25-Apr-85 PWD Changed to leave non-ejectable volumes online.
; 26-Jun-85 PWD Changed to not call driver for non-ejectable disks
; <30Aug85> LAK Changed to force Eject to be synchronous since FlushMDB must be
; done BEFORE closing of volume B-tree files. Why not use
; a separate parameter block for Eject so we can return immediately?
; <14Oct85> PWD Added DumpCaches routine for use by MountVol on remount.
; <28Oct85> PWD Changed to pass control call to drivers anyway if 64 <= DIP <= 127
; mung VCB as for _Offline call for these drivers. Changed to
; interpret NoEject as tri-state flag: -1[offline], 0[eject], or
; +1 [offline w. special eject control call].
;
; Notes:
; - CmdDone gets result code from D0 and assumes it is being called when the
; first routine on the queue is satisfied, so it all works . . .
; - Should the diskette still be ejected if the flush does not work?
; Should directory writes be verified for paranoid users?
;
;_______________________________________________________________________
; Rolled in NoCloseOnEject patch from FileMgrPatches.a <SM1>
; DumpCaches is called by MountVol when a remount is detected to flush out any <14Oct85>
; changes the consistency check may have brought [part. in the bitmap cache], <14Oct85>
; and trash the cache blocks marked with the now-defunct VRefNum/VCBPtr <14Oct85>
; <14Oct85>
; Called by: MountVol <14Oct85>
DumpCaches: MOVE.L (SP)+,-(A6) ; Save return address across ,ASYNC I/O <14Oct85>
MOVEM.L A1/D1-D2,-(A6) ; Free same scratch registers as below <24Oct85>
CLR.B FlushOnly ; Trash cache blocks after flushing <14Oct85>
BRA.S flVCaches ; Go flush the cache buffers <14Oct85>
; FlushBuffers is a code-sharing routine used by Eject and Flush/UnMountVol to flush the
; MDB (marking the volume consistent for Eject and UnMount), and flushing (and
; closing for Eject and UnMount) the volume control files . . . it likes to have
; the FlushOnly flag and A2 set appropriately on entry . . . It also flushes all buffers
; (and invalidates all cache blocks for the volume if FlushOnly=0).
;
; Called By: Eject, FlushVol, MFSFlush
FlushBuffers: ; <01Oct85>
MOVE.L (SP)+,-(A6) ; Save return address for ,ASYNC calls <29Aug85>
MOVEM.L A1/D1-D2,-(A6) ; Save all regs except D0 <24Oct85>
BSR TFSVCBTst ; Is it an MFS volume? <01Oct85>
BNE.S flVCaches ; Br if so (just flush caches) <01Oct85>
TST.B FlushOnly ; Just flushing? <29Aug85>
BNE.S @1 ; Br if so <29Aug85>
BSR CVFlgs ; Is volume write protected? <01Oct85>
BNE.S @1 ; If so, don't try to mark it dirty <01Oct85>
BSET #VCBAtVOK,VCBAtrb(A2) ; Indicate vol was unmounted ok <29Aug85>
BSR MarkVCBDirty ; mark VCB dirty so it will be written <10Oct85>
@1 JSR FlushMDB ; Go flush the VCB info BEFORE close <29Aug85>
MOVEA.L FCBsPtr,A1 ; Point to FCB array <29Aug85>
MOVE.W VCBCTRef(A2),D1 ; Catalog B*-Tree file refnum <29Aug85>
BSR FClose ; Close the file itself <29Aug85>
BNE.S flBufExit ; Punt on errors <29Aug85>
TST.B FlushOnly ; Just flushing? <29Aug85>
BNE.S @2 ; If so, the FCB's still 'live' <29Aug85>
CLR.W VCBCTRef(A2) ; Indicate it's gone <29Aug85>
@2 MOVE.W VCBXTRef(A2),D1 ; Extent B*-Tree file refnum <29Aug85>
BSR FClose ; Close the file itself <29Aug85>
BNE.S flBufExit ; Rats - and we were SO CLOSE... <29Aug85>
TST.B FlushOnly ; Just flushing? <29Aug85>
BNE.S flVCaches ; If so, there's still data in the FCB <29Aug85>
CLR.W VCBCTRef(A2) ; It's a goner now... <29Aug85>
; Flush the volume caches (this code is shared with MFSFlush)
flVCaches:
MOVEQ #0,D1 ; Clear options byte (we'll trash later)
ST CacheFlag ; Yes, REALLY flush . . . <05Sep85>
MOVE.L SysBMCPtr,A1 ; System-wide bitmap cache pointer <30Aug85>
MOVE.W VCBVRefNum(A2),D0 ; Volume refnum <21Sep85>
JSR FlushCache ; A2=VCB ptr <30Aug85>
MOVE.L SysCtlCPtr,A1 ; System-wide control cache pointer <30Aug85>
MOVE.W VCBVRefNum(A2),D0 ; Volume refnum <21Sep85>
JSR FlushCache ; A2=VCB ptr <30Aug85>
MOVE.L SysVolCPtr,A1 ; System-wide volume cache pointer <30Aug85>
MOVE.W VCBVRefNum(A2),D0 ; Volume refnum <21Sep85>
JSR FlushCache ; A2=VCB ptr <30Aug85>
TST.B FlushOnly ; Just flushing? <30Aug85>
BNE.S flBufOK ; If so, that's all we ask <30Aug85>
BSR DsposVBlks ; Otherwise, trash blocks for A2 volume <30Aug85>
flBufOK MOVEQ #0,D0 ; it's cool <29Aug85>
flBufExit MOVEM.L (A6)+,A1/D1-D2 ; Restore regs <24Oct85>
MOVE.L (A6)+,-(SP) ; Restore the return address <29Aug85>
TST.W D0 ; <29Aug85>
RTS ; <29Aug85>
EjectTrap:
BSR FSQueueSync ; wait until all current calls are done <SM1>
CLR.B NoEject ; want to really eject here . . .
Eject1:
BSR DtrmV3 ; check name, drive number, etc. <30Aug85>
BNE.S @1 ; br if drive not mounted (why flush?) <30Aug85>
BSR CkExtFS ; see if it's for an external fs <30Aug85>
BNE.S EjectDone ; exit if so <30Aug85>
BRA.S ejectMnted ; otherwise, go the 'mounted volume' route <30Aug85>
@1 MOVE.W IOVDrvNum(A0),D2 ; drive number
ejectDrvNum BSR FindDrive ; get disk driver refnum in D1
BNE.S ejectDone ; exit if no mapping for this drive <29Aug85>
TST.B NoEject ; REALLY eject this thing?
BEQ EjectIt ; OK, OK; it's going already...
ejectDone BRA CmdDone ; we're done . . . <29Aug85>
ejectMnted LEA VCBDrvNum(A2),A1
MOVE.W (A1),D2 ; on-line, non-ejected?
BNE.S @0 ; br if so <29Aug85>
MOVE.W 2(A1),D2 ; is it already ejected?
BPL.S ejectDone ; just exit if so
TST.B NoEject ; no eject?
BNE.S ejectDone ; br if so (it's already offline . . .) <29Aug85>
NEG.W D2 ; get non-ejected offline disk's drive number
NEG.W 2(A1) ; mark it now ejected . . .
BRA.S ejectDrvNum ; and eject it (pass D2=drive number)
; NOTE: the previous OffLine call would have marked
; a TFS disk consistent.
; OK, it's on-line and not ejected . . . so make it offline and eject if appropriate . . .
@0 BSR FindDrive ; Find DQE from drive number in D2
BNE.S ejectDone ; Punt if can't be found
TST.B NoEject ; Just an _Offline call? <28Oct85>
BNE.S @5 ; Yes - don't try harder than needed <28Oct85>
CMP.B #8,DQDIP(A3) ; Check drive ejectability: <29Aug85>
BLT.S @5 ; Skip if it's ejectable <28Oct85>
ST NoEject ; If DQDIP > 8, it's non-ejectable <28Oct85>
CMP.B #64,DQDIP(A3) ; Send a _Control call anyway? <28Oct85>
BLT.S @5 ; No need - we're set as is. <28Oct85>
MOVE.B #1,NoEject ; If >64, call the driver anyway. <28Oct85>
@5 ST FlushOnly ; only flushing (don't close . . .) <11Sep85>
BSR FlushVFiles ; flush all files on this volume <11Sep85>
BSR TFSVCBTst ; Are we dealing with a TFS volume? <01Oct85>
BNE.S @10 ; Nope.
; note that the following line is the opposite of the OLD code. We only want to flush
; these files, since _Unmount will close them later. However, we do want to mark the
; vcb consistent as it goes offline.
BSR CVFlgs ; Is volume write protected? <31>
BNE.S @1 ; If so, don't try to mark it dirty <31>
BSET.B #vcbAtVOK,vcbAtrb(a2) ; Indicate vol was unmounted ok <31>
BSR MarkVCBDirty ; mark VCB dirty so it will be written <31>
@1 BSR FlushMDB ; Go flush the VCB info BEFORE flushing <31>
ST.B FlushOnly ; just flush the control files
BSR FlushBuffers ; and flush MDB as 'consistent' <01Oct85>
BRA.S ejectMark ; now go mark it . . . <29Aug85>
; FlushOnly is still set for MFS (otherwise MFSFlush would dispose the VCB)
@10 BSR MFSFlush ; flush the MFS allocation map and MDB <11Sep85>
BSR MDspsMap ; and dispose MFS map buffer <01Oct85>
BSR DsposVBlks ; finally, trash blocks for A2 volume <01Oct85>
; OK, mark it offline by zeroing the drive number field in the VCB. Then, put the
; drive number in the driver refnum field in the VCB and if it's really just Offline,
; negate that field.
ejectMark CLR.W (A1)+ ; zero drive number to mark it offline/ejected
TST.B NoEject ; Real eject call <28Oct85>
BEQ.S @1 ; br if so <28Oct85>
NEG.W D2 ; neg drive number for offline indication <29Aug85>
@1 MOVE.W D2,(A1)+ ; store drive number here for disk-switch <29Aug85>
; (negated drivenum for offline)
TST.B NoEject ; eject or offline? <29Aug85>
BEQ.S ejectIt ; go eject it if eject call <29Aug85>
; OffLine calls requeue the VCB for fairness (let some other drive get taken offline next time)
MOVE.L A2,A0 ; VCB queue element <29Aug85>
LEA VCBQHdr,A1 ; VCB queue header <29Aug85>
BSR.L DequeueTrap ; DeQueue then EnQueue to force VCB to <29Aug85><v1.4>
BSR.L EnQueueTrap ; the end for round-robin offline scheme <29Aug85><v1.4>
TST.B NoEject ; Was this a real _Offline call? <28Oct85>
BMI ejectDone ; Yes - offline br to command done <29Aug85>
; Here is where it finally gets ejected . . .
ejectIt ; shared by MFS and TFS eject code . . .
LEA Params,A0 ; general purpose I/O param block <29Aug85>
LEA IODrvNum(A0),A1 ; prepare to fill in 3-in-a-row <29Aug85>
MOVE.W D2,(A1)+ ; IODrvNum (the drive) <29Aug85>
MOVE.W D1,(A1)+ ; IORefNum (driver handling this drive) <29Aug85>
MOVE.W #EjectCode,(A1) ; CSCode (eject it!) <29Aug85>
LEA CmdDone,A1 ; completion routine just says done <29Aug85>
MOVE.L A1,IOCompletion(A0) ; <29Aug85>
_Control ,ASYNC ; asynchronous call <29Aug85>
RTS ; always return at this level <29Aug85>
;_______________________________________________________________________
;
; Routine: UnMountVol
; Arguments: A0 (input) -- pointer to volume parameter block, uses IODrvNum,
; IOFileName
; D0 (output) -- error code
; This call is executed synchronously.
; Calls: FlushVolume
;
; Function: All files on the volume in the drive are closed and any changed
; directory information is written out to the diskette. Memory
; for the VCB, volume buffer, and block map is deallocated.
;
; Modification History:
; 06 Dec 82 LAK No longer ejects the diskette (This combination function
; is now done by calling Eject). If the default volume is
; unmounted, the default volume pointer is set to the first
; VCB in the VCB queue.
; 21 Dec 82 LAK Rewrote to share code with FlushVol; now calls DtrmVol to
; figure out the VCB pointer.
; 22 Apr 85 PWD Fixed to write VCBLsMod field.
; 22-Aug-85 PWD Changed to set 'volume consistent' flag in volume attributes
; before flushing MDB.
; <04Nov87> JB (C958) Rolled in UnMountVol patches PM243, PA244, PB245, and PMAB271.
; Two functional changes: 1) disallow unmount if files are
; open, and 2) allow unconditional unmount (HFS bit set)
; for the shutdown case.
; 09Jun89 BB/JB Reorder the comparison for "internal file" and "HFS vol" when
; determining whether to ignore opened FCB's. External FS's now
; can have UnMount succeed if they have "internal" files open.
; Inserted a check for MFS volumes before using file number as
; a qualifier for unmount with files open. MFS volumes will not
; allow unmount with any files open. NOTE: MultiFinder makes sure
; that the 'Desktop' file is closed before UnmountVol is called.
;_______________________________________________________________________
UnMountVolTrap:
; <SM1> FM rolled in for SuperMario, DesktopCloseDownProc closes the catalog
; and extents files. Since _Offline now no longer does this, we must make sure
; that UnMountVol always does.
bsr DesktopCloseDownProc ; <SM1> FM go take care of the desktop database <36>
bsr.s FSQueueSync ; Get in sync... <04Nov87>
clr.b FlushOnly ; Setup same as UnmountVol <04Nov87>
bsr DtrmV3 ; Call DtrmV3 to do setup stuff <04Nov87>
bne FlVolExit ; Xfer if error... <04Nov87>
moveq #0,d0 ; Initialize result code <04Nov87>
btst #HFSBit,ioTrap(a0) ; Unconditional unmount? <04Nov87>
bne FlUnMnt ; Xfer if so... <04Nov87>
;
; On return from DtrmV3, A2 contains the VCB ptr of the volume
; in question. Search the FCB array for open files that reference
; the volume...
;
movem.l a1/d1/d2,-(sp) ; Save some scratch regs <04Nov87>
move.l FCBsPtr,a1 ; FCB array base address <04Nov87>
moveq #2,d1 ; Index of 1st FCB <04Nov87>
@2
move.l fcbFlNm(a1,d1),d2 ; Is the file currently open? <04Nov87>
beq.s @4 ; Nope, try next FCB... <04Nov87>
cmp.l fcbVPtr(a1,d1),a2 ; Is the file on this volume? <04Nov87>
bne.s @4 ; No, try next FCB... <04Nov87>
cmp.w #SigWord,vcbSigWord(a2) ; Is this an MFS volume? <1.6>
beq.s @3 ; Yes, error if files are open... <1.6>
cmp.l #FSUsrCNID,d2 ; Is it an internal file? <1.6>
blo.s @4 ; Ignore it if so... <1.6>
; dead code stripped <SM1>
@3
;
; Found an open user file on the volume, so return a
; busy condition...
;
moveq #fBsyErr,d0 ; Assert UnmountVol error <04Nov87>
bra.s @5 ; Get out... <04Nov87>
@4
add.w FSFCBLen,d1 ; Next FCB array entry <04Nov87>
cmp.w (a1),d1 ; Reached the end yet? <04Nov87>
blo.s @2 ; Continue if not... <04Nov87>
@5
movem.l (sp)+,a1/d1/d2 ; Restore regs <04Nov87>
tst.w d0 ; Were files open? <04Nov87>
bne FlVolExit ; Xfer if error... <04Nov87>
bra.s FlUnMnt ; Else, go unmount... <04Nov87>
;_______________________________________________________________________
;
; Routine: FlushVolume
; Arguments: A0 (input) -- VCB pointer to volume to flush
; D0 (output) -- error code
; Calls: FClose,MyWriteDB
; Called By: UnMountVol
; Function: All file buffers on the volume are flushed and any changed
; directory information is written out to the diskette.
;
; Modification History:
; 20 Nov 82 LAK Clears the modified bit after writing out the VCB.
; Removed logic to get rid of a file's own buffer after closing
; it (should be done by close routine; also changing open to
; get a pointer to a buffer from the user -> so user would
; deallocate after a close or an eject . . .
; Removed logic to deallocate the VCB buffers: this is now done
; by unmount volume . . .
; 06 Dec 82 LAK Modified for new file system data structures . . .
; 07 Dec 82 LAK Made into an external procedure.
; 21 Dec 82 LAK Changed to flush file buffers but not close the files; now
; combines code of both unmountvol and flushvol.
; 13 Jan 83 LAK Zeros rest of last block map block before writing it out;
; some cosmetic and minor changes. Fills in IODrvNum field.
; 26 Jan 83 LAK Doesn't read in the master block first anymore; always
; flushes dirty volume buffer.
; 02 Jun 83 LAK Made flush of off-line volume a no-op; also allows unmount
; of an off-line volume.
; 11 Mar 85 PWD Changed to call BTClose for files with non-nil FCBBTCBPtrs as
; a temporary patch (eventually this will be part of FlClose).
; 4 Apr 85 PWD B*-Tree are now handled by FClose; removed calls to BTClose.
; 1 May 85 PWD Added code to free WDCBs pointing to unmounted volume
; on UnMount
; 4-Jun-85 PWD Changed to write MDB as last block (should always have highest
; sequence number in tags).
; <29Aug85> LAK MDB cannot be written after control files are closed.
;_______________________________________________________________________
FlushVFiles:
MOVE.L (SP)+,-(A6) ; Save return address for ,ASYNC calls <30Aug85>
MOVEM.L A0-A5/D1-D7,-(A6) ; Save all regs except D0 <11Sep85>
; scan through the FCBs and flush any files on this volume that are open
; (also close them if we are unmounting the volume . . .)
BSR Gt1stFCB
ckNxtFCB TST.L FCBFlNm(A1,D1) ; file open?
BEQ.S ckNxtF1 ; br if not
CMP.L FCBVPtr(A1,D1),A2 ; pointing at this VCB?
BNE.S ckNxtF1 ; nope.
BSR TFSVCBTst ; Are we dealing with a TFS volume? <01Oct85>
BNE.S @1 ; Nope - all's safe <28Aug85>
CMP.L #FSUsrCNID,FCBFlNm(A1,D1) ; Check file id - internal file?
BCS.S ckNxtF1 ; If LO, yes - wait until later <28Aug85>
@1 BSR FClose ; file is on this volume so flush it
BNE.S fvFilesExit ; report any errors
ckNxtF1 BSR GtNxtFCB ; look at next file
BCS.S ckNxtFCB ; until we have looked at them all
MOVEQ #0,D0 ; we're cool
fvFilesExit
MOVEM.L (A6)+,A0-A5/D1-D7 ; Restore regs <11Sep85>
MOVE.L (A6)+,-(SP) ; restore return address
TST.W D0
RTS
FlushVolTrap:
BSR FSQueue ; wait our turn
ST FlushOnly ; only flushing . . .
; first, find the appropriate VCB in our queue
BSR.S DtrmV3 ; check name, drive number, etc.
BNE.S FlVolExit ; exit if no such volume
FlUnMnt: ; <04Nov87>
BSR.S CkExtFS ; see if it's for an external fs
BNE.S FlVolExit ; exit if so
BSR.S FlushVFiles ; flush all files on this volume
BNE.S FlVolExit
; All files on this volume are flushed now. Update the volume information as
; appropriate, depending on the file structure:
BSR TFSVCBTst ; is this a TFS volume? <01Oct85>
BEQ.S @1 ; br if so <11Sep85>
BSR MFSFlush ; flush the MFS allocation map and MDB <11Sep85>
BRA.S FlVolExit ; and exit . . . <11Sep85>
; Unmounting a TFS volume: close the volume control B*-Tree and use the
; volume buffer to write out the MDB
;
; From UnmountForTheNineties in FileMgrPatches.a
; Here's the change: we no longer check whether the volume is offline. Instead we always
; go ahead and close the control files, since we no longer close them on _Offline or _Eject.
;
@1: tst.w vcbDrvNum(a2) ; Check drive number: vol. offline?
beq.s CloseControlFiles ; If zero, it is; control files are open & flushed
BSR FlushBuffers ; share routine with Eject to do it all <01Oct85>
BNE.S FlIOErrExit ; Punt on errors
BRA.S FlVolDone ;
; here begins CloseControlFiles, which is derived from FlushBuffers
; Now we have to close the control files because we no longer close them
; in Eject and Offline
CloseControlFiles
tst.b FlushOnly ; only do this if we are in fact unmounting the volume <SM5> CSS
bne.s FLVolOK ; just a flush <SM5> CSS
movea.l FCBsPtr,A1 ; Point to FCB array
move.w vcbCTRef(a2),d1 ; Catalog B*-Tree file refnum
jsr FClose ; Close the file itself
bne.s FlVolExit ; Punt on errors
move.w vcbXTRef(a2),d1 ; Extent B*-Tree file refnum
jsr FClose ; Close the file itself
bne.s FlVolExit ; Rats - and we were SO CLOSE.. •• is this what we want?
jsr DsposVBlks ; Trash blocks for a2 volume
FlVolDone TST.B FlushOnly ; only flushing?
BNE.S FlVolOK ; br if so
; For UnMountVol, dequeue the VCB and trash any WDCBs for this volume . . .
BSR DsposVCB ; share code with MountVol error routine <30Aug85>
FlVolOK MOVEQ #0,D0 ; no error
FlIOErrExit ;
FlVolExit BRA CmdDone
;_______________________________________________________________________
;
; Routine: CkExtFS
; Arguments: A2.L (input) -- VCB pointer
; D0.W (output) -- 0=belongs to us, ExtFSErr=belongs to another
; Called By:
; Function: Simple routine to separate out calls to be handled by an
; external file system.
;
; Modification History:
; 06 Dec 82 LAK New today.
;_______________________________________________________________________
CkExtFS:
MOVE.L jCkExtFS,-(SP) ; jump table entry for vCkExtFS <27Oct86>
RTS ; go there <27Oct86>
vCkExtFS ; 'vectored' CkExtFS routine <27Oct86>
MOVE.W VCBFSID(A2),D0 ; is this VCB for us?
BEQ.S @1 ; br if so
MOVEQ #ExtFSErr,D0
@1 RTS
;_______________________________________________________________________
;
; Routine: DtrmVol,DtrmV1,DtrmV2,DtrmV3
; Arguments: HFSFlags (input) -- who really sets this up??? <29Aug85>
; A0.L (input) -- IOFileName(A0) = ptr to path name
; D0.W (output) -- 0 or error code: NSVErr
; D2.W (output) -- pathname length (not including any vol prefix)
; D3.W (output) -- 0 if no vol name specified, non-zero otherwise
; A2.L (output) -- VCB pointer
; A3.L (output) -- WDCB pointer or zero (if none specified)
; A4.L (output) -- pathname ptr (not including any vol prefix)
; All other regs are preserved
; Makes use of the fact that all IO parameter blocks have
; their filename pointers and drive numbers in the same spot.
; Calls: _CmpString,QWordSearch,GetVCBDrv,GetVCBRfn
; Called By: SetVol,UnMountVol,FlushVol,Open,Create,Delete,Rename,
; GetFileInfo(DtrmV1),GetVolInfo(DtrmV1,DtrmV3)
; Function: Determine what volume is being used in a name. Main entry
; requires a name pointer; DtrmV2 also does, but the pointer is
; passed in D2. DtrmV1 just looks at drive number; DtrmV3
; looks at name field if not nil, otherwise drive number.
;
; Modification History:
; 02 Dec 82 LAK Changed to set CCR when done. Changed to reflect that volumes
; off-line have a zero VCB pointer. Preserves non-interface
; regs. Searches thru VCB queue as mountVol, unmountVol do.
; 10 Dec 82 LAK Changed to look at drive number field when there is no
; volume prefix. Now uses global string compare proc.
; 13 Dec 82 LAK Added entry point DtrmVol1 for GetFileInfo.
; 13 Jan 83 LAK Calls OS _CmpString proc. Don't ignore parity bit when looking
; for colon in name.
; 23 Jan 83 LAK Changed DtrmV2 entrypoint to have pointer already; report
; error at DtrmVol and DtrmV2 entrys if name ptr is nil;
; deleted DtrmV1 (just call GetDrvVCB).
; 25 May 83 LAK A4 points to first filename byte now.
; 02 Jun 83 LAK Changed to support VRefNum: GetDrvVCB has been factored
; out and made into GetVCBDrv, GetVCBRfn
; 23 Feb 85 GJC added TFS support for pathnames of the form
; volname:<dirname:><dirname:><etc>filename (scan filename from
; left to right).
; also, added support for working directory queue and
; WDRefnums (search WDCB queue for VRefNums < WDRfnMax).
; 28-Feb-85 PWD Changed to stash WDCB pointers in A3, always return VCB pointer
; in A2. Note that A3 is CLEARED in cases where no WDCB is
; specified, INCLUDING MFS CALLS.
; 1-Mar-85 PWD Changed to check for and ignore zero-length volume names
; (possible if WDCB/partial pathname is specified). Name pointer
; is left pointing AFTER leading colon at first pathname element.
; 22-Aug-85 PWD Changed to skip search path if requested through lo-mem flag
; (for GetFileInfo/GetCatInfo by index).
; <29Aug85> LAK Rewrote in a more straightforward fashion. Only error returned
; now is NSVErr.
; <06Sep85> LAK Slight modification to DtrmV3 prefix to prevent passing to DtrmVol
; if IOFileName points to a zero-length string (for the dubious
; result of making CatMove work with a zero-length string . . .).
; <25Sep85> PWD Added support for PMSPHook and PMSP Enable/Disable.
;
; Test: no vol name, very short vol names, vol name which is only a colon,
; internal-external-no volume,only drive specified
;
; NOTE: WHY ZERO THE ENTIRE PMSP BLOCK?
;_______________________________________________________________________
DtrmV3:
MOVE.L jDtrmV3,-(SP) ; jump table entry for vDtrmV3 <27Oct86>
RTS ; go there <27Oct86>
vDtrmV3 ; 'vectored' DtrmV3 routine <27Oct86>
MOVE.L IOFileName(A0),D2 ; entry for flush,set,eject,unmountvol <06Sep85>
MOVE.L D2,A4 ; <06Sep85>
BEQ.S DtrmV1 ; br if nil filename pointer (D2,A4=0) <06Sep85>
TST.B (A4) ; is it a zero-length name? <06Sep85>
BNE DtrmVol ; if non-zero, check for vol prefix <06Sep85>
MOVEQ #0, d2 ; make sure string length is set to zero <SM1>
; (this is from FixDtrmV3 in FileMgrPatches.a)
DtrmV1:
MOVE.L jDtrmV1,-(SP) ; jumptable entry for vDtrmV1 <29Oct85>
RTS ; go there <29Oct85>
vDtrmV1 ; 'vectored' DtrmV1 routine <29Oct85>
MOVEQ #0,D3 ; No volume name specified <29Aug85>
SUB.L A3,A3 ; Assume no WDCB spec'd for now... <29Aug85>
MOVE.W IOVRefNum(A0),D0 ; volume refnum
BEQ.S dtrmDeflt ; br if no drive/vrefnum specified <29Aug85>
BMI.S dtrmVRef ; br if volume refnum <29Aug85>
BSR GetVCBDrv ; try to figure VCB by drive number <29Aug85>
BRA.S dtrmGotCk ; <29Aug85>
dtrmVRef CMP.W #WDRfnMax,D0 ; Check against max. WDRefNum <29Aug85>
BLE.S @1 ; If LE, it's a working directory RefNum <29Aug85>
BSR GetVCBRfn ; try to figure VCB by volume refnum <29Aug85>
BRA.S dtrmGotCk ; <29Aug85>
@1 BSR GetWDCBRfn ; search WDCB queue for WD entry <29Aug85>
dtrmGotCk BEQ.S dtrmGotVol ; br if A2->VCB <29Aug85>
dtrmErrRTS MOVEQ #NSVErr,D0 ; let's be consistent nowadays . . . <29Aug85>
RTS
dtrmDeflt MOVE.L DefVCBPtr,D0 ; Is a default set up? <29Aug85>
BEQ.S dtrmErrRTS ; br if no name, no drive, no refnum, no default
MOVEA.L D0,A2 ; Otherwise, set it up for use
MOVEA.L WDCBsPtr,A3 ; Point to the WDCB array
ADDQ.L #2,A3 ; Point to the default WDCB there
; OK, we have A2 set up with the VCB pointer, and A3 -> WDCB if specified by WDCB or default
dtrmGotVol MOVEQ #0,D0 ; All's well so far
MOVE.L A2,ReqstVol ; save in case of offline, ext fs vols
; Now that we've determined a volume to work with, check to make sure some
; defaults are set up to deal with the possibility that the file we're looking
; for doesn't appear in the first directory tried (if none was specified
; explicitly):
BTST #NoPMSP,HFSFlags ; PMSP disabled? <25Sep85>
BNE.S @0 ; If set, don't search any other directories <25Sep85>
BTST #SkipPMSP,HFSFlags ; Don't bother with PMSP for this operation? <22Aug85>
BEQ.S dtrmPath ; If flag isn't set, give it a chance <22Aug85>
; Zero the search path:
@0 MOVE.L A4,-(SP) ; Create scratch registers <22Aug85>
MOVEA.L PMSPPtr,A4 ; Point to the search path <22Aug85>
ADDQ.L #2,A4 ; Point to first entry <22Aug85>
MOVEQ #((PMSPSize-SPHdrSize-2)/2)-1,D0 ; Pick up length of PMSP <22Aug85>
@1 CLR.W (A4)+ ; Clear out the search path <22Aug85>
DBRA D0,@1 ; <22Aug85>
MOVE.L (SP)+,A4 ; Restore the original A4 <22Aug85>
dtrmExOK MOVEQ #0,D0 ; All's well so far <29Aug85>
RTS ; So quit while we're ahead. <29Aug85>
dtrmPath BTST #HFSBit,ioTrap(A0) ; Use of HFSBit (9) mod 8 is OK on high byte
BEQ.S @1 ; If no TFS trap, there's no DirID
TST.L ioDirID(A0) ; Otherwise, was one specified?
BNE.S dtrmExOK ; Yes - there'll be no defaulting.
@1 MOVEM.L A4/A1/D2/D4,-(SP) ; Save scratch registers from all this wickedness
; for use as PMSP pointers...
MOVEA.L PMSPPtr,A4 ; Point off to the Poor Man's Search Path
MOVE.W PMSPIndx(A4),D4 ; Pick up the default volume index
BGT.S dtrmPthUse ; If it's initialized, go for it
; Initialize the search path list:
MOVEQ #2,D4 ; Index beyond the size word to set up 1st entry
MOVE.W VCBVRefNum(A2),D2 ; Pick up the volume's VRefNum for use
; The first entry is the default volume/directory:
MOVE.L A3,D0 ; Was a WDCB [or default] specified?
BEQ.S @2 ; Nope - use the root
MOVE.L WDDirID(A3),D0 ; Otherwise, we want the default DirID
BRA.S @3 ; [A3 points to a WDCB]
@2 MOVEQ #FSRtDirID,D0 ; No WDCB - use the root
@3 BSR.S AddSPEntry ; Add this entry to the search path
; The remainder only makes sense for TFS volumes, which actually have
; distinguishable directories:
BSR TFSVCBTst ; is this a TFS volume? <01Oct85>
BNE.S dtrmPthEnd ; Nope - put an end to it all
; The second entry is the directory referred to by BootDrive, if it's
; a working directory on the same volume:
dtrmPth2 MOVE.W BootDrive,D0 ; Pick up BootDrive
BGE.S dtrmPth3 ; If it's a real DriveNum, forget it
; (it would just refer to the root, anyways)
CMP.W #WDRfnMax,D0 ; Is it a working directory?
BGT.S dtrmPth3 ; If not, forget it
BSR GetWDCBRfn ; Look up the VCB (sets A2 and A3)
BNE.S dtrmPth3 ; Punt on errors
CMP.W VCBVRefNum(A2),D2 ; Same volume?
BNE.S dtrmPth3 ; If not, forget it
MOVE.L WDDirID(A3),D0 ; Pick up the DirID from the WDCB
BSR.S AddSPEntry ; And add the entry to the PMSP
; The third entry is the system directory on the same volume:
dtrmPth3 MOVEA.L ReqstVol,A2 ; Revert back to the requested volume
MOVE.L VCBFndrInfo(A2),D0 ; Pick up the system DirID
BEQ.S dtrmPthEnd ; If it doesn't exist, just skip it.
BSR.S AddSPEntry ; Add this to the search path, too
; The fourth entry is the root of the volume: <25Sep85>
*EX-CODE:* MOVEQ #FSRtDirID,D0 ; Pick up the root directory ID <25Sep85>
*EX-CODE:* BSR.S AddSPEntry ; And add it to the search path <25Sep85>
; *Add directories on the boot drive, too? (a setup FROUGHT with peril!)*
dtrmPthEnd CLR.W SPVRefNum(A4,D4) ; Zero last VRefNum to indicate end of PMSP.
MOVEQ #2,D4 ; Set up to point to first entry in PMSP
MOVE.W D4,PMSPIndx(A4) ; Store it for future reference
; Check if a PMSP hook was defined, and give it a chance to change the PMSP table <30Sep85>
; (pointed to by A4), and/or the PMSP index (D4) using the VCB (A2) and IOPB (A0) <30Sep85>
MOVE.L PMSPHook(A4),D0 ; Pick up the hook, if any <30Sep85>
BEQ.S dtrmPthUse ; If zero, no hook is currently installed <30Sep85>
MOVEA.L D0,A1 ; Shift hook address over for dispatch <30Sep85>
JSR (A1) ; Call the PMSP hook <30Sep85>
dtrmPthUse MOVE.W SPVRefNum(A4,D4),D0 ; Pick up the default VRefNum
BSR GetVCBRfn ; Find the corresponding VCB
BNE.S @1 ; Br if found no more
MOVEA.L WDCBsPtr,A3 ; Point to WDCB table
ADDA.W #(2+WDCBLen),A3 ; Point A3 off to newly created default
MOVE.L A2,WDVCBPtr(A3) ; Set up second WDCB VCB pointer
MOVE.L SPDirID(A4,D4),WDDirID(A3) ; Set up second WDCB DirID
CLR.L WDCatHint(A3) ; No catalog hint
CLR.L WDProcID(A3) ; No ProcID
MOVEQ #0,D0 ; We're all set, and all is well.
@1 MOVEM.L (SP)+,A4/A1/D2/D4 ; Restore scratch registers to original state <25Sep85>
RTS
;_______________________________________________________________________
;
; Add an entry to the Poor Man's Search path
;
; Input: D0 = DirID
; D2 = VRefNum
; D4 = PMSP index of next free entry
; A4 = PMSP table pointer
;
; Output: D4 = updated to point to next entry if entry is used.
;
; D0 is clobbered.
;_______________________________________________________________________
AddSPEntry:
; Look for an existing entry in the PMSP with the same VRefNum/DirID combination:
MOVE.L D4,-(SP) ; Save PMSP index across search
MOVEQ #2,D4 ; Index D4 to first entry in PMSP
@10 CMP.L (SP),D4 ; Reached the free slot already?
BCC.S @60 ; Yes - fill in the entry
CMP.W SPVRefNum(A4,D4),D2 ; Match on VRefNum?
BNE.S @40 ; If not, give up
CMP.L SPDirID(A4,D4),D0 ; Match on DirID?
BEQ.S @50 ; Yes - No need to fill this one in again
@40 ADDQ.W #SPEntLen,D4 ; Point to the next entry
CMP.W (A4),D4 ; Exceeded the table size?
BLO.S @10 ; Nope - continue
@50 MOVEQ #0,D0 ; Yes - no more room
@60 MOVE.L (SP)+,D4 ; Restore D4 to index to free entry again
; Now consider adding the new entry:
TST.L D0 ; Check the DirID: still want to use it?
BEQ.S @90 ; If it's zeroed, there's no point
MOVE.W D2,SPVRefNum(A4,D4) ; Otherwise, set up the VRefNum
MOVE.L D0,SPDirID(A4,D4) ; And the new DirID
ADDQ.W #SPEntLen,D4 ; Advance to the next entry
@90 RTS
DtrmVol: MOVE.L IOFileName(A0),D2 ; get pointer to 'volume:<dirname:>filename'
DtrmV2:
MOVE.L jDtrmV2,-(SP) ; jump table entry for vDtrmV2 <19Feb87>
RTS ; go there <19Feb87>
vDtrmV2 ; 'vectored' DtrmV2 routine <19Feb87>
MOVEM.L D4-D6/A0-A1,-(SP) ; save regs
TST.L D2 ; Name specified?
BEQ.S NoNameErr ; need a name this entrypoint
MOVE.L D2,A4
MOVEQ #0,D2 ; clear index into name (long for later add)
MOVEA.L D2,A3 ; Clear WDCB pointer (never specified)
MOVE.B (A4)+,D2 ; len of file name
BEQ.S NoNameErr ; no zero-length names
MOVEQ #0,D3 ; initialize loop count to zero
@1 MOVE.B 0(A4,D3),D4 ; watch for colons in the name
CMP.B #$3A,D4 ; ':'?
BEQ.S @2 ; found possible volume name
ADDQ.W #1,D3 ; scan entire name from front to back
CMP.W D3,D2 ; have we scanned the entire length yet?
BNE.S @1 ; If more to scan, go for it
BRA.S @3 ; Otherwise, go look by DrvNum/VRefNum
@2 SUB.L D3,D2 ; file name len excluding volume part
SUBQ.W #1,D2 ; and the colon
MOVE.L A4,A1 ; ptr to 1st char of vol name string
ADD.L D3,A4 ; ptr to first colon in pathname string
ADDA.L #1,A4 ; now pointing to the pathname
TST.W D3 ; Have we scanned over any characters?
BGT.S VolSpcfd ; Yes - go look for volume by name
@3 BSR DtrmV1 ; no volume prefix; use DrvNum/VRefNum
DtrmDone MOVEM.L (SP)+,D4-D6/A0-A1 ; restore regs
TST.W D0 ; set condition codes
RTS
NoNameErr MOVEQ #BdNamErr,D0 ; zero name pointer
BRA.S DtrmDone
; A volume name was specified. figure out which one (if any)
VolSpcfd MOVE.L VCBQHdr+QHead,D0 ; search the VCB queue
CkVol: BEQ.S @2 ; br if end of queue reached
MOVE.L D0,A2 ; next VCB pointer
LEA VCBVN(A2),A0 ; string pointer
MOVEQ #0,D0
MOVE.B (A0)+,D0 ; length of (A0) string
SWAP D0
MOVE.W D3,D0 ; length of (A1) string
_CmpString ; compare strings @A0, @A1
BNE.S @1 ; br if not equal
MOVE.L A2,ReqstVol ; note the requested volume
BRA.S DtrmDone ; br if it compares
@1 MOVE.L QLink(A2),D0
BNE.S CkVol
@2 MOVEQ #NSVErr,D0 ; no volume name match, so volname must
BRA.S DtrmDone ; be dir name, so use drvnum/vrefnum
;_______________________________________________________________________
;
; Routine: SetPMSP
; Arguments: A0.L (input) -- I/O volume parameter block: uses ioCompletion
; and ioMisc ($1C).
; D0.W (output) -- error code
; Calls: FSQueue,CmdDone
;
; Function: Specify the behavior of TFS' Poor Man's Search Path.
;
; ioCompletion(A0) is the address of a hook procedure (zero to disable)
; which is called when TFS has just initialized the PMSP table.
; The hook is called with (A4,D4) pointing to the first PMSP entry.
;
; ioMisc(A0) is a word, the LSB of which determines whether the PMSP is
; used at all (if set) or ignored alltogether (if clear).
;
; Modification History:
; <25Sep85> PWD New today.
;_______________________________________________________________________
SetPMSP: BSR FSQueue ; Patiently wait our turn
MOVE.L ioPMSPHook(A0),D0 ; Pick up the hook procedure
BMI.S @1 ; If negative, don't install it
MOVEA.L PMSPPtr,A1 ; Point to the PMSP table
MOVE.L D0,PMSPHook(A1) ; Install the new hook
@1 MOVE.W ioPMSPFlg(A0),D0 ; Pick up the accompanying boolean
BCLR #NoPMSP,HFSFlags ; Clear flag, enabling PMSP
BTST #0,D0 ; Test the LDB [a la Pascal]
BNE.S SetPMSPOK ; If enabled, we're set
BSET #NoPMSP,HFSFlags ; If flag is clear, PMSP is off
SetPMSPOK MOVEQ #0,D0 ; Always a big hit
BRA CmdDone ; So let's just call it a day here
;_______________________________________________________________________
;
; Routine: GetVolInfo
; Arguments: A0.L (input) -- I/O volume parameter block: uses all volume
; fields.
; D0.W (output) -- error code
; Calls: FSQueue,CmdDone
;
; Function: Return information about the volume in a mounted drive.
; If the IOVolIndex field is 0,
; the name of the default volume is returned; if non-zero, the
; name of the nth mounted volume is returned. The maximum length
; of a volume name is 27 bytes. The drive number for the volume
; is also returned.
;
; Modification History:
; 07 Dec 82 LAK Changed to support new file system data structures.
; 16 Dec 82 LAK Removed backup file lgth subtract in free blk determination.
; 21 Dec 82 LAK Changed to call DtrmVol to figure the volume name. Free
; blocks comes from VCB info already stored.
; 14 Jan 83 LAK The latest changes.
; 23 Jan 83 LAK Changed to use the volindex field, call XferVName.
; 03 Jun 83 LAK Added in-use bit: true if any files on the volume are open;
; returns volume refnum now instead of drive number.
; 6-Aug-85 PWD Changed to call external file system for non-Macintosh volumes
; AFTER filling in the I/O parameter block information.
; 15-Aug-85 PWD Changed to add ioVFilCnt and ioVDirCnt fields
; 21-Sep-85 PWD Changed to exclude B*-Tree file allocations from NmAlBlks
; 21-Sep-85 PWD Changed to return directory valence instead of VCBNmFls if
; ioVRefNum is a working directory refNum.
; 24-Sep-85 PWD Fixed bug (MOVE.L vs. MOVEM.L) in directory valence lookup
; 11-Oct-85 PWD Changed to pin NmAlBlks and NmFrBlks at (32767*1000)/1024
; instead of 32767 for programs that figure in 'decimal K'
; 13-Oct-85 PWD Fixed bug: don't try to read working directory valence for
; external FS volumes.
; 27-Oct-85 PWD Changed to ignore volume control files in determining vol. busy
; Changed to set bit 5 in attributes if volume is default
;
; - if this was the twin of GetFileInfo, the volume really shouldn't have to
; be mounted . . . if it is, get the info from the VCB and block map: if
; not, read the drive's master block into a stack buffer (would have to
; read the block map, tho, to determine the number of free blocks) . . .
;_______________________________________________________________________
GetVolInfo:
BSR FSQueue ; queue up the request
MOVE.W IOVolIndex(A0),D2 ; if positive,
BGT.S @3 ; go search by index
BEQ.S @1 ; if zero, go by drive number/default
BSR DtrmV3 ; if negative, go by name
BRA.S @2
@1 BSR DtrmV1 ; figure by drvnum, vrefnum, or default
@2 BNE TGVIDone
BRA.S RetVolInfo
@3 MOVEQ #0,D3 ; Never any name specified <25Sep85>
; (ioFileName is output arg) <25Sep85>
CLR.W ioVRefNum(A0) ; make sure this gets filled in later <25Sep85>
MOVE.L VCBQHdr+QHead,D1 ; we want nth VCB in queue
@4 BEQ NSVErrXit ; exit with err at end of queue
SUBQ.W #1,D2 ; the one we want?
MOVE.L D1,A2
BEQ.S RetVolInfo ; br if so
MOVE.L QLink(A2),D1 ; if not, keep traversing the queue
BRA.S @4
; first copy the heart of the VCB into the parameter block
RetVolInfo MOVEQ #IOVDirLen-2,D0 ; number of bytes to straight copy
@4 MOVE.W VCBCrDate(A2,D0.W),IOVCrDate(A0,D0.W)
SUBQ #2,D0
BPL.S @4
BSET #6,ioVAtrb+1(A0) ; set if any files are opened <28Oct85>
BSR Gt1stFCB ; get (A1,D1) pointing to first FCB
@0 CMP.L FCBVPtr(A1,D1),A2 ; file open on this volume?
BNE.S @1 ; br if so
BSR TFSVCBTst ; Are we looking at a TFS VCB? <27Oct85>
BNE.S @2 ; Nope - all files are fair game <27Oct85>
MOVE.L FCBFlNm(A1,D1),D0 ; Check the file number <27Oct85>
CMP.L #FSUsrCNID,D0 ; Is it a system control file? <27Oct85>
BHS.S @2 ; Accept only the highest quality... <27Oct85>
@1 BSR GtNxtFCB ; get next one until we run out
BCS.S @0
BCLR #6,ioVAtrb+1(A0) ; 0 if no open files match <28Oct85>
@2 BCLR #5,ioVAtrb+1(A0) ; Assume this volume is not the default.<27Oct85>
CMPA.L DefVCBPtr,A2 ; Check the default volume pointer <27Oct85>
BNE.S @3 ; If this isn't it . . . <27Oct85>
BSET #5,ioVAtrb+1(A0) ; If this is default, drop a hint. <27Oct85>
@3 SUBA.L A3,A3 ; Clear WDCB pointer <14Oct85>
TST.W ioVolIndex(A0) ; Check volIndex: <21Sep85>
BGT.S retVRef ; If vol was indexed, leave things be <21Sep85>
TST.W D3 ; Was a volume name specified? <21Sep85>
BNE.S retVRef ; If so, always return real file count <21Sep85>
MOVE.W ioVRefNum(A0),D1 ; Check VRefNum supplied: <21Sep85>
BGT.S retVRef ; If driveNum, ignore it <21Sep85>
BLT.S @5 ; If negative, might be a WDRefNum <21Sep85>
MOVEQ #2,D1 ; If 0, look at default WDCB <21Sep85>
BRA.S @7 ; <21Sep85>
@5 CMP.W #WDRfnMax,D1 ; Otherwise, compare to max WDRefNum <21Sep85>
BGT.S retVRef ; If it's a real VRefNum, we're OK <21Sep85>
; a WDRefNum was supplied as VRefNum: change the number of files to be the <21Sep85>
; valence of the directory in question: <21Sep85>
SUB.W #WDRfnMin,D1 ; Change WDRefNum to index <21Sep85>
@7 MOVE.L WDCBsPtr,A3 ; Point to WDCB array <12Oct85>
ADD.W D1,A3 ; Point A3 to WDCB for ext. FS <13Oct85>
BSR ExtOffLinCk ; Is this an external file system vol? <13Oct85>
BNE.S retVRef ; Yes - don't try to read the catalog <13Oct85>
MOVEM.L A0-A1,-(A6) ; Use A0,A1 as scratch registers <21Sep85>
MOVEA.L WDCBsPtr,A1 ; Point to WDCB array <21Sep85>
MOVE.L WDDirID(A1,D1),D0 ; Pick up the DirID in question <21Sep85>
CMP.L #FSRtDirID,D0 ; Is it the root directory anyway? <21Sep85>
BEQ.S @8 ; If so, don't make special efforts <21Sep85>
MOVE.L WDCatHint(A1,D1),D2 ; Pick up directory hint <21Sep85>
SUBA.L A0,A0 ; CName = Nil <21Sep85>
JSR CMGetCN ; Look up the directory <21Sep85>
BNE.S @8 ; If can't find it, forget it. <21Sep85>
MOVE.W dirVal(A1),D0 ; Store directory valence <21Sep85>
MOVEM.L (A6)+,A0-A1 ; Restore scratch regs <21Sep85>
MOVE.W D0,ioVNmFls(A0) ; Replace file count w. dir. valence <21Sep85>
BRA.S retVRef ; And continue <21Sep85>
@8 MOVEM.L (A6)+,A0-A1 ; Continue without changing file count <24Sep85>
; Do some hairy checking: if a working directory was specified, it shouldn't
; be overwritten by the volRefNum. However, if a volume NAME was used, the
; volRefNum field is ignored, and SHOULD be filled in with the volume's VRefNum.
retVRef TST.W D3 ; Was a volume name specified?
BNE.S @10 ; If so, always return volRefNum
TST.W IOVRefNum(A0) ; VRefNum or WDRefNum supplied?
BLT.S @20 ; If so, leave it alone
@10 MOVE.W VCBVRefNum(A2),IOVRefNum(A0) ; return volume refnum
@20 BSR XferVName ; copy volume name
retAlBks BSR TFSVCBTst ; Are we dealing with a TFS volume? <13Oct85>
BNE.S @25 ; If not, don't fiddle with NmAlBlks<21Sep85>
; Subtract the physical sizes of the extent B*-Tree and the catalog B*-Tree <21Sep85>
; from the volume size, so that the difference between the volume size and <21Sep85>
; the free space reflects only the user's allocations: <21Sep85>
MOVE.W VCBXTAlBks(A2),D0 ; Pick up extent B*-Tree size <21Sep85>
SUB.W D0,ioVNmAlBlks(A0) ; Take out XT allocation <21Sep85>
MOVE.W VCBCTAlBks(A2),D0 ; Pick up catalog B*-Tree size <21Sep85>
SUB.W D0,ioVNmAlBlks(A0) ; Take out CT allocation <21Sep85>
@25 BTST #HFSBit,ioTrap(A0) ; TFGetVolInfo vs. plain GetVolInfo?
BNE.S @40 ; Br if it's TGetVolInfo
MOVE.W #AlBlkLim,D0 ; Pick up our favorite constant, 32767 <11Oct85>
CMP.W ioVNmAlBlks(A0),D0 ; Check the number of allocation blocks: <11Oct85>
BHI.S @30 ; If we're under the limit, we're fine. <11Oct85>
MOVE.W D0,ioVNmAlBlks(A0) ; Otherwise, pin the value there <11Oct85>
CMP.W ioVFrBlk(A0),D0 ; Check the number of free blocks: <11Oct85>
BHI.S @30 ; If we're under the limit, we're fine. <11Oct85>
MOVE.W D0,ioVFrBlk(A0) ; Otherwise, pin the value there <11Oct85>
@30 BRA.S GVIDone
; Return some additional information for TGetVolInfo requests:
@40 MOVE.W VCBVRefNum(A2),ioVRefNum(A0) ; ALWAYS return VRefNum <25Sep85>
MOVE.W VCBSigWord(A2),ioVSigWord(A0) ; Volume signature
MOVE.W VCBDrvNum(A2),ioVDrvInfo(A0) ; Driver number
MOVE.W VCBDRefNum(A2),ioVDRefNum(A0) ; Driver RefNum
MOVE.W VCBFSID(A2),ioVFSID(A0) ; File System ID
CLR.L ioVFilCnt(A0) ; Clear top word
MOVE.W VCBNmFls(A2),ioVFilCnt+2(A0) ; Stuff low word as if MFS
CLR.L ioVDirCnt(A0) ; Clear top word
MOVE.W #1,ioVDirCnt+2(A0) ; Stuff low word as if MFS
BSR TFSVCBTst ; Are we dealing with a TFS volume? <01Oct85>
BNE.S TGVIOK ; No - the information below doesn't exist
MOVE.L VCBVolBkup(A2),ioVBkup(A0) ; Last backup date
MOVE.W VCBVSeqNum(A2),ioVSeqNum(A0) ; Volume sequence number
MOVE.L VCBWrCnt(A2),ioVWrCnt(A0) ; Volume write count
MOVE.L VCBFilCnt(A2),ioVFilCnt(A0) ; Files count for volume
MOVE.L VCBDirCnt(A2),ioVDirCnt(A0) ; Directory count for volume
MOVE.L A0,-(SP) ; Free up A0 as a scratch register
LEA ioVFndrInfo(A0),A1 ; Destination finder info
LEA VCBFndrInfo(A2),A0 ; Volume's finder info
MOVEQ #32,D0 ; Length of finder info
_BlockMove ; Copy finder info
MOVE.L (SP)+,A0 ; Restore original A0
GVIDone MOVE.L A2,ReqstVol ; Make sure ReqstVol is set up
BSR TFSVCBTst ; Are we dealing with a TFS volume? <01Oct85>
BNE.S TGVIOK ; No - dont' pass to unsuspecting ext. FS
BSR CkExtFS
BNE.S TGVIDone
TGVIOK MOVEQ #0,D0 ; No errors
TGVIDone BRA CmdDone
;_______________________________________________________________________
;
; Routine: SetVolInfo
; Arguments: A0.L (input) -- I/O PB pointer
; D0.W (output) -- error code (volume locked, wr prot error)
; Called By:
; Function: Change certain user-alterable fields in the VCB
;
; Modification History:
; 14-May-85 PWD New today.
; 6-Oct-85 PWD Moved SetVolName here from TFSDir2. Changed SetVolInfo to
; use SetVolName.
;_______________________________________________________________________
SetVolInfo:
BSR FSQueue ; Wait our turn
BSR DtrmV1 ; Determine volume by drvnum/refnum
BNE.S SVIDone ; Punt on errors
BSR CVFlgs ; Check if volume can be modified
BNE.S SVIDone ; Give up easily
BSR ExtOffLinCk ; Check if volume is on-line, non ext. FS
BNE.S SVIDone ; Be a wimp - give up now.
; Set user-modifiable fields in the VCB:
MOVE.L IOVCrDate(A0),VCBCrDate(A2) ; Volume creation date
MOVE.L IOVLsMod(A0),VCBLsMod(A2) ; Date of last modification
MOVE.W IOVAtrb(A0),D0 ; Volume attributes
AND.W #$8000,D0 ; Clear all but vol. locked bit
MOVE.W VCBAtrb(A2),D1 ; Current volume attributes
AND.W #$7FFF,D1 ; Clear vol. locked bit
OR.W D0,D1 ; Combine attributes
MOVE.W D1,VCBAtrb(A2) ; Set new volume attributes
BSR TFSVCBTst ; Is it a TFS volume? <01Oct85>
BNE.S @3 ; br if not - MFS VCBs don't have <01Oct85>
; this info
MOVE.L IOVClpSiz(A0),VCBClpSiz(A2) ; Volume clump size
MOVE.L IOVBkup(A0),VCBVolBkup(A2) ; Last backup date
MOVE.W IOVSeqNum(A0),VCBVSeqNum(A2); Volume sequence number
MOVE.L A0,-(SP) ; Save IOPB pointer
LEA IOVFndrInfo(A0),A0 ; Point to finder info source
LEA VCBFndrInfo(A2),A1 ; Finder info in VCB
MOVEQ #32,D0 ; Length of finder info
_BlockMove ; Copy it in
MOVEA.L (SP)+,A0 ; Restore IOPB pointer
@3 MOVE.L IOVNPtr(A0),D0 ; New name specified?
BEQ.S @10 ; If not, forget it
MOVEA.L D0,A1 ; Point to new name <PWD 06Oct85>
BSR.S SetVolName ; Update name in VCB <PWD 06Oct85>
@10 BSR MarkVCB
MOVEQ #0,D0 ; All went well...
SVIDone BRA CmdDone
SetVolName
MOVEM.L A1/A2,-(SP) ; Save original VCB pointer
LEA VCBVN(A2),A2 ; point to 1st char in name destination <PWD 06Oct85>
MOVEQ #1,D0 ; set up to copy 1st character in name <PWD 06Oct85>
@1 CMP.B (A1),D0 ; Exceeded source length? <PWD 06Oct85>
BGT.S @5 ; If so, call it off <PWD 06Oct85>
CMP.B #':',0(A1,D0) ; Hit a colon? <PWD 06Oct85>
BEQ.S @5 ; Yes - punt. <PWD 06Oct85>
CMP.B #VCBMaxNam,D0 ; Exceeded the max. length? <PWD 06Oct85>
BGT.S @5 ; Yes - stop here. <PWD 06Oct85>
MOVE.B 0(A1,D0),0(A2,D0) ; move in new name <PWD 06Oct85>
ADDQ.W #1,D0 ; Advance to the next character <PWD 06Oct85>
BRA.S @1 ; And try again <PWD 06Oct85>
@5 SUBQ.W #1,D0 ; Back up to real # characters copied <PWD 06Oct85>
MOVE.B D0,(A2) ; Set new name length <PWD 06Oct85>
MOVEM.L (SP)+,A1/A2 ; Reset pointer to VCB <PWD 06Oct85>
BSR MarkVCB ; mark VCB info changed <PWD 06Oct85>
RTS ; And call it a day
;_______________________________________________________________________
;
; Routine: CVFlgs
; Arguments: A2.L (input) -- VCB pointer
; D0.W (output) -- error code (volume locked, wr prot error)
; Called By:
; Function: Check the volume's flags to see if modify requests are allowed.
;
; Modification History:
; 08 Dec 82 LAK Changed to support new file system data structures.
;
;_______________________________________________________________________
CVFlgs MOVEQ #VLckdErr,D0 ; assume volume locked
TST.W VCBAtrb(A2) ; volume locked?
BMI.S CVExit ; br if so
MOVEQ #WPrErr,D0 ; assume diskette is write protected
TST.B VCBAtrb+1(A2) ; bit 7=1 means write protected
BMI.S CVExit ; br if so
MOVEQ #0,D0 ; otherwise, no error
CVExit RTS ; that's all folks (BEQ FOR OK)
;_______________________________________________________________________
;
; Routine: GetVol
; Arguments: A0.L (input) -- ptr to volume parameter block, uses IOVNPtr,
; IOVDrvNum
; D0.W (output) -- error code
; Calls: FSQueue,CmdDone
; Function: Find out what the name of the default volume is. The volume
; name is stored at IOVNPtr(A0). The maximum length
; of a volume name is 27 bytes. The drive number for the volume
; is also returned.
;
; Modification History:
; 06 Dec 82 LAK Rewrote to reflect file system data structure changes.
; Changed to return name of nth volume (0=default).
; 21 Dec 82 LAK Returns drive number, too.
; 23 Jan 83 LAK Changed to just return the name of the default volume.
; 02 Jun 83 LAK Changed to return volume refnum instead of drive number.
; 30-May-85 PWD Changed to return VRefNum only if drive number of volindex given
;
; Test: existing vol name, illegal vol name, etc.
;_______________________________________________________________________
GetVolTrap:
BTST #HFSBit,D1 ; Check if request is TFS-flavor <04Oct85> PWD
BNE GetDir ; If so, go to different code altogether<01oct85> BBM
BSR FSQueue ; wait for my turn
MOVE.L DefVCBPtr,D0 ; ptr to default VCB
BEQ.S NSVErrXit ; error if no default volume
MOVEA.L D0,A2 ;
MOVE.W DefVRefNum,ioVRefNum(A0) ; Return the original default RefNum
; (which could be a WDRefNum)
BSR.S XferVName ; Go copy volume name and set D0=0
GetVolDone BRA CmdDone
NSVErrXit MOVEQ #NSVErr,D0
BRA.S GetVolDone
; Quick little routine shared by GetVol, GetVolInfo, GetWDCBInfo: returns
; the volume name if IOVNPtr(A0) is not zero . . .
; Returns: D0=0 always . . .
XferVName MOVEM.L A1-A2,-(SP) ; Save regs except D0 <31Aug85>
LEA VCBVN(A2),A2 ; ptr to vol name
MOVE.L IOVNPtr(A0),D0 ; ptr to return name buffer
BEQ.S @3 ; don't return name if pointer is nil
; AND.L Lo3Bytes,D0 ; let's add in a range check cause <10Dec86>
; CMP.L MemTop,D0 ; it's a common error to forget to <10Dec86>
; BGT.S @3 ; fill in the name ptr . . . <10Dec86>
_StripAddress ; clean up the address before using it <10Dec86>
MOVE.L D0,A1 ; A1 = cleaned up name buffer ptr
MOVEQ #0,D0 ; Clear upper bytes
MOVE.B (A2),D0 ; len of volume name
@2 MOVE.B (A2)+,(A1)+ ; move a char of name
DBRA D0,@2 ; loop until all + 1 done (length too)
@3 MOVEM.L (SP)+,A1-A2 ; Restore regs <31Aug85>
MOVEQ #0,D0 ; Always a success
RTS
;_______________________________________________________________________
;
; Routine: SetVol
; Arguments: A0.L (input) -- ptr to volume parameter block: volume may be
; specified by either IODrvNum or IOFileName
; D0.W (output) -- error code
; All other regs are preserved
; Calls: DtrmV3
; Function: Set the current default volume. The volume must be mounted
; and may be specified by either name or drive number. If neither
; is specified, the default volume is set to the current value
; if there is a current default (otherwise an error is reported).
; The volume name may be followed by a filename (for convenience).
;
; Modification History:
; 06 Dec 82 LAK Rewrote to reflect file system data structure changes.
; 14 Jan 83 LAK Minor rework.
; 14-Mar-85 PWD Changed to set up default WDCB
; 9-Jul-85 PWD Changed to preserve default VRefNum (or WDRefNum) in DefVRefNum
; 20-Sep-85 PWD Fixed bug in determination of new DefVRefNum when vol. spec'd by name
; 24-Sep-85 PWD Changed to branch to SetDir when TFS bit is set on trap
;
; Test: existing vol name, illegal vol name, etc.
;_______________________________________________________________________
SetVolTrap:
BTST #HFSBit,D1 ; Check if request is TFS-flavor <02Oct85>
BNE.S SetDir ; If so, go to different code altogether<24Sep85>
BSR FSQueue ; wait for my turn
BSR DtrmV3 ; determine the volume being asked for
BNE.S @20 ; br if we couldn't <31Aug85>
MOVE.W VCBVRefNum(A2),D0 ; Pick up the new default vol's refNum <20Sep85>
TST.W D3 ; Was a volume name spec'd? <20Sep85>
BNE.S @3 ; If so, use its VRefNum straight <20Sep85>
TST.W ioVRefNum(A0) ; Otherwise, was a driveNum given? <20Sep85>
BGT.S @3 ; If so, use the VRefNum from the VCB <20Sep85>
MOVE.W ioVRefNum(A0),D0 ; Pick up the VRefNum supplied
BEQ.S @5 ; If none was supplied, leave the world as is
@3 MOVE.W D0,DefVRefNum ; Save this VRefNum/WDRefNum for posterity
; ... but mostly for GetVol's use
@5 MOVEQ #FSRtDirID,D6 ; Default directory is the volume's root
MOVE.L A3,D7 ; Working directory specified (may zero hint)
BEQ.S @10 ; If not, hint is zeroed, we're all set
MOVE.L WDDirID(A3),D6 ; Directory ID of working directory
MOVE.L WDCatHint(A3),D7 ; Catalog hint
@10 BSR SetDefWDCB ; And go fill in the default WDCB
MOVEQ #0,D0 ; Return success
@20 BRA CmdDone ; And call it a day.
;_______________________________________________________________________
;
; Routine: SetDir
; Arguments: A0.L (input) -- I/O parameter block
; D0.W (output) -- error code
; Called By:
; Function: Set the default directory (and, implicitly, the default volume).
;
; Modification History:
;
; 14-Mar-85 PWD New today.
; 21-Sep-85 PWD Changed to alloc null file names (or just 'vol name:') as well
; as Nil file name pointers.
;
;_______________________________________________________________________
SetDir:
BSR FSQueue ; Wait for our turn to come
BSR FndFilName ; Look for the indicated directory
BEQ.S @0 ; continue if all went well
; Special hack to allow MFS volumes to be specified by volume name only (which
; normally causes FndFilName to choke on the zero-length file name remaining):
CMP.W #BdNamErr,D0 ; Was it a bad name? <21Sep85>
BNE.S SetDirExit ; Nope - give up <21Sep85>
TST.B D2 ; Yes - 'cuz there wasn't one? <21Sep85>
BNE.S SetDirExit ; Nope - give up after all <21Sep85>
MOVEQ #FSRtDirID,D6 ; Yes - OK, use the root on MFS <21Sep85>
BRA.S SetDefDir ; Yes - that's OK here... <21Sep85>
@0 MOVEQ #DirNFErr,D0 ; Let's be pessimistic here
CMP.B #CDRDirRec,CDRType(A5) ; Was record a directory?
BNE.S SetDirExit ; Thought so...
MOVE.L DirDirID(A5),D6 ; DirID to set up = directory's DirID
;
; Since SetDir may arrive at the final directory from a pathname relative to a
; working directory, SetDir cannot simply set DefVRefNum to the WDRefNum supplied,
; to be returned by GetVol. SetDir ALWAYS stores the real VRefNum, therefore...
;
SetDefDir MOVE.W VCBVRefNum(A2),DefVRefNum ; Save this VRefNum for posterity
; ... but mostly for GetVol's use
MOVEQ #0,D7 ; No catalog hint known.
BSR SetDefWDCB ; Set up the default WDCB
SetDirOK MOVEQ #0,D0 ; Return success
SetDirExit BRA CmdDone ; And that's all, folks!
;_______________________________________________________________________
;
; Routine: GetDir
; Arguments: A0.L (input) -- I/O parameter block
; D0.W (output) -- error code
; Called By:
; Function: Get the default volume's name and the current default directory.
;
; Modification History:
;
; 14-Mar-85 PWD New today.
; 14-Oct-85 PWD Added call to XferVName now that RetDefInfo doesn't do it anymore
;_______________________________________________________________________
GetDir:
BSR FSQueue ; Wait our turn
BSR Gt1stWDCB ; Set up A1, D1 to point at first WDCB <28Aug85>
MOVEQ #NSVErr,D0 ; Assume no default directory set
TST.L WDVCBPtr(A1,D1) ; Is this entry actually set up?
BEQ.S @1 ; If not, we're finished right here & now <28Aug85>
BSR RetDefInfo ; Otherwise - return the WDCB information
BSR XferVName ; Return the name of the associated volume <PWD 14Oct85>
MOVE.W DefVRefNum,ioVRefNum(A0) ; Return the original default RefNum
MOVEQ #0,D0 ; A totally stunning success
@1 BRA CmdDone ; Call it a day.
;_______________________________________________________________________
;
; Routine: OpenWD
; Arguments: A0.L (input) -- I/O parameter block
; D0.W (output) -- error code
; Called By:
; Function: Create a working directory control block from the pathname
; information in the parameter block.
;
; Modification History:
;
; 14-Mar-85 PWD New today.
; 1-Jul-85 PWD Changed to recycle WDRefNums for callers with same procID
; and return WDRefNum in ioVRefNum field.
; 21-Sep-85 PWD Changed to allow opening of root of MFS volumes with DirID=2
; and null or nil filename.
;_______________________________________________________________________
OpenWDTrap:
BSR FSQueue ; Wait for our turn to come
BSR FndFilName ; Look for the indicated directory
BEQ.S @1 ; Br if found
CMP.W #BdNamErr,D0 ; Was it a bad filename? <21Sep85>
BNE.S opnWDExit ; If not, there's no more hope <21Sep85>
TST.B D2 ; Otherwise, check the name length <21Sep85>
BNE.S opnWDExit ; If nonzero, it's real BdNamErr <21Sep85>
BRA.S @2 ; Return VRefNum for MFS null file names<21Sep85>
@1 MOVEQ #DirNFErr,D0 ; Let's be pessimistic here
CMP.B #CDRDirRec,CDRType(A5) ; Was record a directory?
BNE.S opnWDExit ; Thought so...
MOVE.L DirDirID(A5),D6 ; DirID to set up = directory's DirID
CMP.L #FSRtDirID,D6 ; Accessing the root? <21Sep85>
BEQ.S @2 ; Nope - create a real new WDCB <21Sep85>
MOVEQ #0,D7 ; No catalog hint known.
BSR.S PickWDCB ; Look for a suitable WDCB
BRA.S opnWDExit
@2 MOVE.W VCBVRefNum(A2),ioVRefNum(A0) ; Return the VRefNum as WDRfn <21Sep85>
opnWDOK MOVEQ #0,D0 ; Call it a success <21Sep85>
opnWDExit BRA CmdDone ; we're finished . . .
SetDefWDCB MOVE.L A2,DefVCBPtr ; set the (new?) default
MOVEQ #2,D1 ; Pick the default-WDCB
FillWDCB MOVE.L WDCBsPtr,A1 ; Point to the WDCB array
MOVE.L A2,WDVCBPtr(A1,D1.W) ; Set the default VCB
MOVE.L D6,WDDirID(A1,D1.W) ; In the default WDCB
MOVE.L D7,WDCatHint(A1,D1.W) ; Catalog hint for this directory
MOVE.L ioWDProcID(A0),D0 ; Pick up caller's procID
MOVE.L D0,WDProcID(A1,D1.W) ; Mark WDCB with it
ADD.W #WDRfnMin,D1 ; Offset into the WDCB Refnum range
RTS ; And return it to the caller
; Look for a matching working directory, starting with the third (the first two are
; reserved to hold the system-wide volume and directory defaults).
EXPORT PickWDCB ; <SM4> rb
PickWDCB:
MOVEA.L A2,A5 ; A5 <> 0, MF is not running flag (A2 <> 0)
;; A0=iopb, A2=VCB, D3.L=ProcID, D6.L=DirID, D7.L=0. A3,A4,D2,D4,D5 are free.
;; A5.L=caller's procID because I run out of D regs ...
MOVEA.L FSVarsPtr,A3
MOVEa.L FSVars.wdcbPBuf(A3),A3 ; A3=WDCB parallel array
MOVE cbPBufULen(A3),D3 ; D3=Ext. WDCB unit length
LEA wdcbPBufData(A3),A3 ; skip info words (A3 = 1st WDCB)
MOVEA.L A3,A4 ; A4 = 1st WDCB
ADDA D3,A3 ; A3 = 2nd WDCB
MOVEQ #0,D4 ; ID1= 0
MOVEQ #0,D5 ; ID2= 0 (no serial ID)
BSR ProcessMgrExists ; check Process Mgr ready?
BNE.S @nomf ; no, don't bother with serial ID
;; Process Mgr is available, we are open for business
SUBA.L A5,A5 ; A5=0 if MultiFinder is ready <06Aug90>
MOVE.L A0,-(SP) ; save iopb
LEA -10(SP),SP ; make room for PSN and OSErr
PEA 2(SP) ; push address of PSN storage
_GetSystemClientProcess ; call OS (can trash pascal registers)
LEA 2(SP),SP ; don't need to check for error
MOVE.L (SP)+,D4 ; D4 = process ID1
MOVE.L (SP)+,D5 ; D5 = process ID2
MOVEA.L (SP)+,A0 ; restore iopb
@nomf: MOVEQ #0,D2 ; Clear free WDCB index
jsr Gt1stWDCB ; Set up A1, D1 (point at first WDCB)
jsr GtNxtWDCB ; Point at 2nd WDCB
; (A1,D1)=WDCB, D2=freeRefNum,
@1 ADDA D3,A3 ; Point at next Extended WDCB
jsr GtNxtWDCB ; Point at next (3rd) WDCB
BCC.S @3 ; Br if we've seen them all
TST.L WDVCBPtr(A1,D1) ; Is this WDCB free?
BNE.S @2 ; If NE, no
TST.W D2 ; Already found a free one?
BNE.S @1 ; Yes - continue scan
MOVE.W D1,D2 ; No - hang on to this WD index
BRA.S @1 ; And continue scanning
@2 CMP.L WDVCBPtr(A1,D1),A2 ; For same volume?
BNE.S @1 ; Nope - keep looking
CMP.L WDDirID(A1,D1),D6 ; Same directory?
BNE.S @1 ; Nope - keep looking
MOVE.L A5,D0 ; MF ready? <06Aug90>
BEQ.S @mfON ; yes, check serial number <06Aug90>
;; MultiFinder is not ready, check wdProcID <06Aug90>
MOVE.L ioWDProcID(A0),D0 ; Pick up owner's ProcID <06Aug90>
CMP.L WDProcID(A1,D1.W),D0 ; same ProcID? <06Aug90>
BNE.S @1 ; Nope - sigh. <06Aug90>
BRA.S @wdFnd ; found it <06Aug90>
@mfON CMP.L xWDCBPid2(A3),D5 ; For same owner?
BNE.S @1 ; Nope - sigh.
CMP.L xWDCBPid1(A3),D4 ; For same owner?
BNE.S @1 ; Nope - sigh.
@wdFnd ;; Recycle the WD RefNum:
CLR ioWDCreated(A0) ; say we are not creating one <10/9/89>
ADDI #WDRfnMin,D1 ; Offset the index to make a WDRefNum
BRA.S @4 ; Return the current WDRefNum
; Use a new WDCB:
@3 MOVE.W D2,D1 ; Free WDCB found?
BEQ.S pickNoMore ; Nope - die.
MOVE #1,ioWDCreated(A0) ; we are creating a new one <10/9/89>
;; Now A1 --> WDCBs, D1.W = WDrefnum, A4 = 1st Ext. WDCB, D4,D5=ID, D6=DirID, D7=hint
MOVEQ #0,D0
MOVE D1,D0 ; D0=WDRefNum
MOVE #WDCBLen,D3 ; D3 = WDCB len
DIVU D3,D0 ; Divide by length to get WDCB's number
LSL #L2ExtWDCBLen,D0 ; index into the extended FCB
MOVE.L D4,xWDCBPid1(A4,D0) ; save it
MOVE.L D5,xWDCBPid2(A4,D0) ; save it
jsr FillWDCB ; user's ProcID data still stored in WDCB by this call
@4 MOVE.W D1,IOVRefNum(A0) ; Store in user's I/O parameter block
MOVEQ #0,D0 ; Total success
RTS ;
pickNoMore MOVEQ #TMWDOErr,D0 ; No WDCBs are free: fail miserably
RTS
;_______________________________________________________________________
;
; Routine: CloseWD
; Arguments: A0.L (input) -- I/O parameter block
; D0.W (output) -- error code
; Called By:
; Function: Release the storage used for a working directory control block.
;
; Modification History:
;
; 14-Mar-85 PWD New today.
; 1-Jul-85 PWD Changed to do away with VCBWDCnt maintenance
; Changed to take WDRefNum in ioVRefNum field.
; 6-Aug-85 PWD Changed to call external FS (WITHOUT clearing WDCB!)
; 20-Aug-85 PWD Changed to make VRefNum arg a no-op.
;
;_______________________________________________________________________
CloseWDTrap:
BSR FSQueue ; Wait for our turn to come
MOVEQ #0,D1 ; Clear top half of D1
MOVE.W IOVRefNum(A0),D1 ; Pick up the WDRefNum
BSR CkWDRefNum ; Check if it's OK for use, set up A1=WDCBSptr <31Aug85>
BEQ.S @1 ; Br if so
CMP.W #WDRfnMax,D1 ; Is it a VRefNum? <20Sep85>
BHI.S clsWDOK ; OK HI ($F000-$FFFF) . . . (assume valid VRefNum)
BRA.S clsWDExit ; Punt on errors
; The refnum provided checked out OK:
@1 SUB.W #WDRfnMin,D1 ; Offset to change to WD array index
MOVEA.L WDVCBPtr(A1,D1),A2 ; Pick up volume referred to
TST.W VCBFSID(A2) ; Mac FS?
BEQ.S @2 ; Yes - please continue
MOVE.L A2,ReqstVol ; No - indicate such to the external FS
ADD.L A1,D1 ; Point D1 to WDCB
MOVEQ #ExtFSErr,D0 ; And leave this one alone
BRA.S clsWDExit ;
@2 CLR.L WDVCBPtr(A1,D1) ; Clear the VCB pointer to free the WDCB
clsWDOK MOVEQ #0,D0 ; Success at last!
clsWDExit BRA CmdDone ; Leave by common exit
;_______________________________________________________________________
;
; Routine: GetWDInfo
; Arguments: A0.L (input) -- I/O parameter block
; D0.W (output) -- error code NSVErr = couldn't find it
; Called By:
; Function: Read the information in a WDCB for a given volume.
;
; Modification History:
;
; 1-May-85 PWD New today.
; 1-Jul-85 PWD Changed to match procID on indexed requests.
; 6-Aug-85 PWD Changed to call external FS for ext. FS volumes AFTER
; copying volume information.
; 22-Aug-85 PWD Changed to return root information for requests by RefNum
; <28Aug85> LAK Fixed bug in indexed get. Now allows specification by
; default volume even, or drive number . . . why not? No
; more ParamErr, it's NSVErr or it's ok.
;_______________________________________________________________________
GetWDInfoTrap:
BSR FSQueue ; Wait our turn
BSR.S GetWDCBInfo ; Return the WDCB information <PWD 14Oct85>
BNE.S GtWDIExit ; Punt on errors <PWD 14Oct85>
EXT.L D1
ADD.L A1,D1 ; Point D1 to WDCB for extFS
MOVE.L A2,ReqstVol ; in case of extFSErr
BSR CkExtFS ; Is this an external file system volume? <PWD 14Oct85>
BNE.S GtWDIExit ; br if not (pass D1=WDCB ptr or 0 if not a WDCB)
GtWDIOK MOVEQ #0,D0 ; Otherwise, a total success
GtWDIExit BRA CmdDone ; And call it a day. <PWD 14Oct85>
;
; Subroutine shared between _GetWDInfo (queuing) and _ReadWDCB (non-queueing): <PWD 14Oct85>
;
GetWDCBInfo TST.W ioWDIndex(A0) ; Test working dir index
BGT.S IndxWDInfo ; If positive, look up WD by index/volume
; Return information for a specific Working Directory, indicated by RefNum:
MOVEQ #0,D1 ; CkWDRefNum needs high word of D1 inited to zero <15APR86> PWD
MOVE.W IOVRefNum(A0),D1 ; Pick up a WDRefNum/VRefNum
BSR CkWDRefNum ; Check its integrity (trashes D0, sets A1=WDCBsPtr)
BEQ.S getWD_1 ; br if it's a valid WDCB refnum <22Aug85>
BSR DtrmV1 ; Does VRefNum specify a valid volume? <22Aug85>
BNE.S GetWDIExit ; Give up easily <22Aug85>
; By special arrangement, calling _GetWDInfo with a VRefNum will fill out <22Aug85>
; a working directory arrangement for the root: <22Aug85>
CLR.L ioWDProcID(A0) ; No proc. id's defined for system <22Aug85>
MOVEQ #FSRtDirID,D0 ; <22Aug85>
MOVE.L D0,ioWDDirID(A0) ; Pick up the volume's root directory ID<22Aug85>
MOVE.W VCBVRefNum(A2),ioWDVRefNum(A0) ; Return the volume's refNum <22Aug85>
MOVE.W VCBVRefNum(A2),ioVRefNum(A0) ; for both fields . . . <22Aug85>
MOVEQ #0,D1 ; no WDCB ptr for extFS . . . <28Aug85>
BRA.S XferVN ; proceed to return the name (pass A2) <22Aug85>
; WD refnum was supplied and ioWDIndex<=0, so return a specific entry . . .
getWD_1
MOVEQ #NSVErr,D0 ; Let's just assume thing's aren't cool
SUB.W #WDRfnMin,D1 ; Change refNum to index
TST.L WDVCBPtr(A1,D1) ; This entry really in use?
BEQ.S GetWDIExit ; Nope - too bad.
BRA.S XferWDInfo ; Yes - fill in the info (pass A1, D1)
IndxWDInfo
MOVEQ #NSVErr,D0 ; Let's be pessimistic for a moment...
MOVEQ #0,D2 ; assume no volume match
TST.W IOVRefNum(A0) ; Was a VRefNum supplied?
BEQ.S @1 ; Nope - go for it
BSR DtrmV3 ; Find the VCB
BNE.S GetWDIExit ; Punt if no volume found
MOVE.L A2,D2 ; Stash VCB pointer
; Try to find the requested WDCB:
@1 MOVE.W ioWDIndex(A0),D4 ; Get a hold of the working dir. index
MOVE.L ioWDProcID(A0),D3 ; Pick up the caller's procID, if any
MOVEQ #NSVErr,D0 ; Start out pessimistic
BSR Gt1stWDCB ; Set up A1, D1 (point at first WDCB)
BSR GtNxtWDCB ; Point at 2nd WDCB
getWDLoop BSR GtNxtWDCB ; Point at next WDCB (the first two WDCBs are not counted)
BCC.S GetWDIExit ; Br if we've seen them all
TST.L WDVCBPtr(A1,D1) ; Is this WDCB in use?
BEQ.S getWDLoop ; If EQ, it's not (only count the used ones)
TST.L D3 ; Match on procID?
BEQ.S @1 ; If not, don't bother checking
CMP.L WDProcID(A1,D1),D3 ; Is it for this caller?
BNE.S getWDLoop ; If no match, it's not
@1 TST.L D2 ; Match on volume?
BEQ.S @2 ; No - this WDCB is OK
CMP.L WDVCBPtr(A1,D1),D2 ; Yes - for requested volume?
BNE.S getWDLoop ; If not, skip it.
@2 SUBQ.W #1,D4 ; Count down: one done
BGT.S getWDLoop ; Keep going until the right one's found
XferWDInfo BSR.S RetWDInfo ; Copy out the Working directory information
XferVN BSR XferVName ; Copy volume name (sets D0) <PWD 14Oct85>
GetWDIExit TST.W D0 ; Set condition codes <PWD 14Oct85>
RTS ; And call it a day. <PWD 14Oct85>
ReadWDCB: MOVEM.L D3-D7/A1-A6,-(SP) ; Save registers [normally done in FSQueue] <PWD 14Oct85>
MOVEA.L HFSStkTop,A6 ; Set up A6 for use as stack pointer <PWD 14Oct85>
BSR GetWDCBInfo ; Pick up the WDCB information requested <PWD 14Oct85>
MOVEM.L (SP)+,D3-D7/A1-A6 ; Restore scratch registers [normally CmdDone] <PWD 14Oct85>
MOVE.W D0,IOResult(A0) ; post result code <PWD 14Oct85>
RTS ; Call it a day <PWD 14Oct85>
; Small routine to transfer the information of interest:
; (RetDefInfo called by GetDir)
; Expects: A1,D1
; Returns: A2=WDVCBPtr(A1,D1)
; Blows: D0
RetWDInfo: ; GetWDInfo entry
MOVE.L WDProcID(A1,D1),ioWDProcID(A0) ; Copy ProcID (NOT FOR GETDIR . . .)
RetDefInfo: ; GetDir entry
MOVEA.L WDVCBPtr(A1,D1),A2 ; Point to VCB for associated volume
MOVE.W VCBVRefNum(A2),ioWDVRefNum(A0) ; Copy VRefNum
MOVE.L WDDirID(A1,D1),ioWDDirID(A0) ; Copy WD's DirID
MOVE.W D1,D0 ; use D0 as scratch <31Aug85>
ADD.W #WDRfnMin,D0 ; Convert index back to WD RefNum <31Aug85>
MOVE.W D0,ioVRefNum(A0) ; And return it to the user <31Aug85>
RTS ; Call it a day <14Oct85>
;_______________________________________________________________________
;
; Routine: CkWDRefNum
; Arguments: D1.L (input) -- WDCB RefNum (top half should be 0)
; D0.W (output) -- 0 for success, or RFNumErr
; A1.L (output) -- WDCBsPtr
; Called By:
; Function: A quick common routine to check a WDCB refnum for validity.
;
; Modification History:
;
; 1-May-85 PWD New today.
; <28Aug85> LAK Some short branches, please. Also removed redundant check
; against min and max (this is accomplished by the unsigned
; compare against index bounds).
; <15Sep86> BB Added check for a zero VCB pointer in the WDCB indicating
; that the WD is already closed.
;_______________________________________________________________________
;
CkWDRefNum MOVE.L D1,-(SP) ; Save D1 across the call <29Aug85>
MOVEQ #RFNumErr,D0 ; Let's just assume thing's aren't cool
SUB.W #WDRfnMin,D1 ; Offset to zero
MOVEA.L WDCBsPtr,A1 ; Point to the WDCB array
CMP.W (A1),D1 ; Pointing beyond the end?
BCC.S WDRfnCkExit ; Yes - bad news. <28Aug85>
SUBQ.W #2,D1 ; Compensate for the length word
DIVU #WDCBLen,D1 ; Divide by the length of a WDCB
SWAP D1 ; Get a hold of the remainder
TST.W D1 ; Check if it's zero
BNE.S WDRfnCkExit ; Unmasked at last! <28Aug85>
MOVE.L (SP),D1 ; WD RefNum <15Sep86>
SUB.W #WDRfnMin,D1 ; Offset to zero <C193>
TST.L WDVCBPtr(A1,D1) ; check VCB pointer <15Sep86>
BEQ.S WDRfnCkExit ; its zero, WD is aready closed <15Sep86>
MOVEQ #0,D0 ; OK - all seems well.
WDRfnCkExit MOVE.L (SP)+,D1 ; Restore original D1 value <29Aug85>
TST.W D0 ; Set CCR <28Aug85>
RTS
;_______________________________________________________________________
;
; Routine: SetUpWDCB, SetupDef
; Arguments: A0.L (input) -- I/O Parameter block
; Uses: ioVRefNum - Volume to refer to
; ioDirID - Directory of choice
; ioWDProcID - Caller's procID
;
; D0.W (output) -- error code, or 0 for success
; ioVRefNum(A0) -- Updated with WDRefNum if D0 = 0 on output.
; (from SetUpWDCB)
; Called By:
; Function: A low-level routine to set up a WDCB, or the default WDCB
; in particular
;
; Modification History:
;
; 22-May-85 PWD New today.
; 26-Sep-85 PWD Added SetupDef entry point for external FS support.
;_______________________________________________________________________
; NOTE: This code executes under special conditions: since it does NOT call
; FSQueue on entry, A6 is never set up; any code called from this routine
; cannot rely on A6 being set. Furthermore, it does NOT provide the
; standard full-fledged file finding: VRefNum/DirID is the ONLY valid input.
SetUpWDCB:
MOVEM.L D3-D7/A1-A6,-(SP) ; Save registers (not done in FSQueue now...)
MOVEA.L HFSStkTop,A6 ; Set up A6 for use as stack pointer <PWD 14Oct85>
BSR DtrmV1 ; Determine the volume of choice
BNE.S SetWDExit ; Punt on errors
MOVE.L ioDirID(A0),D6 ; Requested DirID
MOVEQ #0,D7 ; No known catalog hint
BSR PickWDCB ; Select and fill a WDCB, or
BNE.S SetWDExit ; ... bail out with an error
MOVE.W D1,ioVRefNum(A0) ; Return a WDRefNum, because
SetWDOK MOVEQ #0,D0 ; ... All went well
SetWDExit MOVEM.L (SP)+,D3-D7/A1-A6 ; Restore scratch registers
MOVE.W D0,ioResult(A0) ; Set up result code <PWD 14Oct85>
RTS ; And call it a day.
; [returns directly to trap dispatcher]
SetupDef: MOVEM.L D3-D7/A1-A6,-(SP) ; Save registers, same as SetUpWDCB <26Sep85>
MOVEA.L HFSStkTop,A6 ; Set up A6 for use as stack pointer <PWD 14Oct85>
BSR DtrmV1 ; Determine volume by refNum/driveNum <26Sep85>
BNE.S SetWDExit ; Punt on errors <26Sep85>
MOVE.W VCBVRefNum(A2),DefVRefNum ; Save this one for posterity <26Sep85>
MOVE.L ioDirID(A0),D6 ; Requested DirID <26Sep85>
MOVEQ #0,D7 ; No hint known <26Sep85>
BSR SetDefWDCB ; Set up the full default WDCB <26Sep85>
BRA.S SetWDOK ; And call it a day <26Sep85>
; [returns directly to trap dispatcher] <26Sep85>
Reference in New Issue View Git Blame Copy Permalink