![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to VolumeRequests.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Misc|
Return to VolumeRequests.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs / hfscommon / Misc |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* ! 26: File: VolumeRequests.c ! 27: ! 28: Contains: MountVolume and related utility routines for HFS & HFS Plus ! 29: ! 30: Version: HFS Plus 1.0 ! 31: ! 32: Written by: Deric Horn ! 33: ! 34: Copyright: � 1996-1998 by Apple Computer, Inc., all rights reserved. ! 35: ! 36: File Ownership: ! 37: ! 38: DRI: Deric Horn ! 39: ! 40: Other Contacts: Mark Day, Don Brady ! 41: ! 42: Technology: File Systems ! 43: ! 44: Writers: ! 45: ! 46: (JL) Jim Luther ! 47: (msd) Mark Day ! 48: (DSH) Deric Horn ! 49: (djb) Don Brady ! 50: ! 51: Change History (most recent first): ! 52: <Rhap> 7/28/98 djb GetDiskBlocks is now implemented in MacOSStubs.c (radar #2258148). ! 53: <Rhap> 4/3/98 djb Conditionally remove FSVars reference from GetVolumeNameFromCatalog. ! 54: <Rhap> 3/31/98 djb Sync up with final HFSVolumes.h header file. ! 55: <CS47> 1/29/98 DSH TrashAllFSCaches is responsible for trashing all file system and ! 56: disk caches. Called from FlushVol when the HFS bit is set. ! 57: <CS46> 12/12/97 DSH 2003877, when vcbAllocPtr was copied to nextAllocation it was ! 58: getting sign extended. ! 59: <CS45> 11/26/97 DSH 2003459, fcbs was not being initialized if volume was offline ! 60: and we are executing an unconditional unmount. ! 61: <CS44> 11/24/97 DSH 2005507, FlushVolumeControlBlock() keeps MDB drCrDate in sync ! 62: with VolumeHeader createDate. ! 63: <CS43> 11/11/97 DSH 1685873, RemountWrappedVolumes was only remounting the first ! 64: HFS+ volume in the queue, causing HFS wrappers to be mounted if ! 65: multiple volumes had been mounted before InitHFSPlus. ! 66: <CS42> 11/4/97 DSH Clear FCB when getting a new one. ! 67: <CS41> 11/3/97 JL #2001483 - Removed unneeded parameters from MountVolume, ! 68: MountHFSVolume, MountHFSPlusVolume, GetVolumeInformation, ! 69: GetXVolumeInformation and AddVCB (and added local variables as ! 70: needed). Return WDCBRecPtr from UnMountVolume. Set wdcb ! 71: parameter to NULL in GetXVolumeInformation if working directory ! 72: was not specified. ! 73: <CS40> 10/31/97 DSH Added consistencyStatus parameter to MountCheck ! 74: <CS39> 10/23/97 msd Bug 1685113. The VolumeHeader's createDate should be in local ! 75: time (not GMT) and identical to the MDB's drCrDate (and VCB's ! 76: vcbCrDate). When checking for a remount of an offline HFS Plus ! 77: volume, compare write counts instead of mod dates (which could ! 78: be fooled by the user changing time zones). Force MountCheck to ! 79: run if the volume was last mounted by Bride 1.0b2 or earlier. ! 80: <CS38> 10/17/97 msd Conditionalize DebugStrs. ! 81: <CS37> 10/13/97 djb Update volumeNameEncodingHint when updating the volume name. ! 82: <CS36> 10/10/97 msd Bug 1683571. The dates in the volume header are in GMT, so be ! 83: sure to convert them when mounting a volume or flushing the ! 84: volume header. ! 85: <CS35> 10/2/97 DSH In UnmountVolume() check that the drive is on line before ! 86: determining if wrapper volume needs to be renamed causing IO. ! 87: <CS34> 10/1/97 DSH Run on disk version of MountCheck instead of ROM version for ! 88: boot volumes1682475. ! 89: <CS33> 10/1/97 djb Add calls to InvalidateCatalogCache (part of radar #1678833). ! 90: <CS32> 9/26/97 DSH Removed debugging code: support for 'W' key wrapper mounting. ! 91: <CS31> 9/17/97 DSH hfsPlusIOPosOffset was uninitialized for Wrapperless volumes. ! 92: <CS30> 9/5/97 djb In MountVol initialize Catalog cache before calling Catalog! ! 93: <CS29> 9/4/97 msd PropertyCloseVolume renamed to AttributesCloseVolume. Remove ! 94: call to AttributesOpenVolume (it no longer exists). ! 95: <CS28> 9/2/97 DSH VolumeHeader is now 3rd sector in partition, altVH is 2nd to ! 96: last cor compatability. Initial support for wrapperless ! 97: volumes. ! 98: <CS27> 8/26/97 djb Only call CountRootFiles during MountVol. ! 99: <CS26> 8/20/97 msd If the HFS Plus volume version doesn't match, mount the wrapper ! 100: instead. ! 101: <CS25> 8/19/97 djb Add error handling to RenameWrapperVolume. ! 102: <CS24> 8/15/97 msd Bug 1673999. In MakeVCBsExtendedVCBs, copy old VCB's vcbAllocPtr ! 103: to new VCB's nextAllocation field. ! 104: <CS23> 8/12/97 djb Fixed GetXVolInfo to only use extended vcb fields for local ! 105: volumes (radar# 1673177) ! 106: <CS22> 8/11/97 DSH vcbNmAlBlks is now taken from the embededExtent.blockCount ! 107: (1669121). ! 108: <CS21> 8/11/97 djb Return actual count of files in root directory for HFS Plus ! 109: volumes (Radar #1669118). Added local CountRootFiles routine. ! 110: 8/5/97 msd Make sure version field in VolumeHeader is exactly ! 111: kHFSPlusVersion. 8/1/97 djb GetXVolumeInformation now returns ! 112: extFSErr when FSID is nonzero (Radar #1649503). ! 113: <CS20> 7/25/97 DSH Init and Dispose of GenericMRUCache within ExtendedVCB. ! 114: <CS19> 7/16/97 DSH FilesInternal.x -> FileMgrInternal.x to avoid name collision ! 115: <CS18> 7/15/97 DSH Remount Wrapper volumes mounted before HFS+ initialization ! 116: (166729) ! 117: <CS17> 7/15/97 djb Remove ioXVersion checking in GetXVolInfo (radar #1666217). ! 118: <CS16> 7/8/97 DSH Loading PrecompiledHeaders from define passed in on C line ! 119: <CS15> 7/7/97 djb Add GetVolumeNameFromCatalog routine. ! 120: <CS14> 7/7/97 DSH GetNewVRefNum now get's a recycled vRefNum. Bug 1664445 in ! 121: Installer was cacheing the vRefNum while CheckDisk unmounts and ! 122: remounts disk. ! 123: <CS13> 6/30/97 DSH shadowing values obsoleteVCBXTRef, and obsoleteVCBCTRef when ! 124: HFS+ volume is mounted. ! 125: <CS12> 6/26/97 DSH GetVolInfo returns HFS signature for HFS+ volumes, GetXVolInfo ! 126: returns real signature. ! 127: <CS11> 6/24/97 DSH MakeVCBsExtendedVCBs was using wdcb->count as count not byte ! 128: count. ! 129: <CS10> 6/18/97 djb Set/get volume encodingsBitmap. ! 130: <CS9> 6/16/97 msd Include String.h and Disks.h. ! 131: <CS8> 6/12/97 djb Get in sync with HFS Plus format changes. ! 132: <CS7> 6/11/97 msd Make GetXVolumeInformation return true allocation block size. It ! 133: now checks the ioXVersion field. ! 134: <CS6> 5/28/97 msd When flushing the volume header, write out the allocation file's ! 135: clump size (from the FCB). When mounting an HFS Plus volume, ! 136: zero the entire FCB extent record, not just the first extent, ! 137: for the various volume control files. ! 138: <CS5> 5/19/97 djb Add calls to CreateVolumeCatalogCache, ! 139: DisposeVolumeCatalogCache. ! 140: <CS4> 5/9/97 djb Get in sync with new FilesInternal.i ! 141: <CS3> 5/8/97 DSH Only mount HFS+ volumes with version < 2.0 in the VolumeHeader. ! 142: Return wrgVolTypErr if too new. ! 143: <CS2> 5/2/97 djb Disable Manual Eject code since its buggy! ! 144: <CS1> 4/25/97 djb first checked in ! 145: ! 146: <HFS32> 4/11/97 DSH MountHFSPlusVolume gets volume name from catalog, and ! 147: UnmountVolume shadows the name back to the wrapper partition. ! 148: <HFS31> 4/8/97 msd Once volume is mounted, call AttributesOpenVolume to allow a ! 149: buffer to be allocated. ! 150: <HFS30> 4/7/97 msd In FlushVolumeControlBlock, don't update the attributes BTree ! 151: fields in the Volume Header unless an attributes BTree was ! 152: already open. ! 153: <HFS29> 4/7/97 msd In SetupFCB, add case for attributes BTree. Add code to set up ! 154: the attributes BTree. Remove call to PropertyOpenVolume. In ! 155: FlushVolumeControlBlock, write out any changes to the attributes ! 156: BTree. ! 157: <HFS28> 4/4/97 djb Get in sync with volume format changes. ! 158: <HFS27> 3/31/97 djb Added catalogDataCache to VCB; Remove ClearMem routine. ! 159: <HFS26> 3/18/97 msd In MountHFSPlusVolume, the free blocks calculation can overflow, ! 160: setting vcbFreeBks to a too-small value. ! 161: <HFS25> 3/17/97 DSH Added some utility functions AddVCB, GetParallelFCBFromRefNum, ! 162: casting for SC, and made some functions extern for DFA. ! 163: <HFS24> 3/5/97 msd Add calls to Property Manager to open and close the volume. When ! 164: unmounting an HFS+ volume, the allocation (bitmap) file now gets ! 165: closed. ! 166: <HFS23> 2/19/97 djb Update to 16-bit HFS Plus signature. ! 167: <HFS22> 2/12/97 msd In GetXVolumeInformation, the result code could be ! 168: uninitialized. ! 169: <HFS21> 1/23/97 DSH UpdateAlternateVoumeControlBlock() ! 170: <HFS20> 1/15/97 djb Remove MountCheckStub. Add file names to fcbs for debugging. ! 171: <HFS19> 1/13/97 DSH Use ExtendedVCB nextAllocation instead of vcbAllocPtr through ! 172: all code. ! 173: <HFS18> 1/9/97 djb Get in sync with new VolumeHeader and Extended VCB. ! 174: <HFS17> 1/6/97 djb Changed API to ParallelFCBFromRefnum (pragma parameter was ! 175: broken). ! 176: <HFS16> 1/6/97 msd Set only the defined bits in the MDB drAtrb field (when copying ! 177: from VCB vcbAtrb field). ! 178: <HFS15> 1/6/97 DSH CloseFile requires VCB to be passed in. ! 179: <HFS14> 1/6/97 djb FlushVolumeControlBlock was writing to absolute block 0 instead ! 180: of to block zero of the embedded volume. ! 181: <HFS13> 12/20/96 msd A comparison was using "=" instead of "=="; might have caused ! 182: the wrong volume to be set as the default. ! 183: <HFS12> 12/19/96 DSH Setting up ExtendedVCBs ! 184: <HFS11> 12/19/96 djb Updated for new B-tree Manager interface. ! 185: <HFS10> 12/18/96 msd Change GetVCBRefNum so it can actually return a VCB pointer. ! 186: <HFS9> 12/12/96 djb Use new SPI for GetCatalogNode. ! 187: <HFS8> 12/12/96 msd Fix a bunch of errors (mostly type mismatch) when compiling with ! 188: Metrowerks. ! 189: <HFS7> 12/12/96 DSH adding some util functions ! 190: <HFS6> 12/10/96 msd Check PRAGMA_LOAD_SUPPORTED before loading precompiled headers. ! 191: <HFS5> 12/4/96 DSH Ported GetVolumeInformation & GetXVolumeInformation. ! 192: <3*> 11/20/96 DSH HFS Plus support to MountVolume ! 193: <HFS3> 11/20/96 DSH Added UnmountVol and related routines, also backed out <2> ! 194: because C_FXMKeyCmp is passed as a parameter from C but called ! 195: from Asm in BTOpen so we need a Case ON Asm entry point. ! 196: <HFS2> 11/20/96 msd Use CompareExtentKeys() instead of CFXMKeyCmp(). ! 197: <HFS1> 11/19/96 DSH first checked in ! 198: <1> 11/19/96 DSH first checked in ! 199: ! 200: */ ! 201: ! 202: #if ( PRAGMA_LOAD_SUPPORTED ) ! 203: #pragma load PrecompiledHeaders ! 204: #else ! 205: #if TARGET_OS_MAC ! 206: #include <Files.h> ! 207: #include <FSM.h> ! 208: #include <OSUtils.h> ! 209: #include <LowMemPriv.h> ! 210: #include <LowMem.h> ! 211: #include <StringCompare.h> ! 212: #include <Errors.h> ! 213: #include <Devices.h> ! 214: #include <SonyPriv.h> ! 215: #include <EDiskPriv.h> ! 216: #include <String.h> ! 217: #include <Disks.h> ! 218: #else ! 219: #include "../../hfs.h" ! 220: #include "../headers/system/MacOSStubs.h" ! 221: #endif /* TARGET_OS_MAC */ ! 222: #endif /* PRAGMA_LOAD_SUPPORTED */ ! 223: ! 224: #if TARGET_OS_MAC ! 225: #include <HardwarePriv.h> ! 226: #endif ! 227: ! 228: #include "../headers/FileMgrInternal.h" ! 229: #include "../headers/HFSVolumes.h" ! 230: ! 231: ! 232: #define kIDSectorOffset 2 ! 233: ! 234: // Exported routine prototypes ! 235: OSErr MountVolume( VolumeParam *volume, Boolean forceHFSWrapperToMount ); ! 236: ! 237: OSErr MountHFSVolume( short driveNumber, IOParam* lowMemParamBlock, OSErr err ); ! 238: ! 239: OSErr MountHFSPlusVolume( short driveNumber, IOParam* lowMemParamBlock, OSErr err, Boolean pureHFSPlusVolume ); ! 240: ! 241: OSErr GetVolumeInformation( HVolumeParam *volume, WDCBRecPtr *wdcb ); ! 242: ! 243: OSErr GetXVolumeInformation( XVolumeParam *volume, WDCBRecPtr *wdcb ); ! 244: ! 245: ! 246: // Utility function prototypes ! 247: #if TARGET_OS_MAC ! 248: OSErr FindFileControlBlock( File *index, Ptr *fcbsH ); ! 249: ! 250: Boolean GetNextFileControlBlock( UInt16 *index, Ptr fcbsPtr ); ! 251: ! 252: void Get1stFileControlBlock( UInt16 *index, Ptr *fcbsH ); ! 253: ! 254: void DisposeFileControlBlocks( ExtendedVCB *vcb ); ! 255: #else ! 256: OSErr GetNewFCB( ExtendedVCB *vcb, FileReference* fRefPtr); ! 257: #endif ! 258: ! 259: OSErr AccessBTree( ExtendedVCB *vcb, FileReference refNum, UInt32 fileID, UInt32 fileClumpSize, void *CompareRoutine ); ! 260: ! 261: UInt16 DivUp( UInt32 byteRun, UInt32 blockSize ); ! 262: ! 263: Boolean IsARamDiskDriver( void ); ! 264: ! 265: OSErr GetVCBRefNum( ExtendedVCB **vcb, short vRefNum ); ! 266: ! 267: OSErr ValidMasterDirectoryBlock( HFSMasterDirectoryBlock *mdb ); ! 268: ! 269: void RenameWrapperVolume( Str27 newVolumeName, UInt16 driveNumber ); ! 270: ! 271: OSErr CheckExternalFileSystem( ExtendedVCB *vcb ); ! 272: ! 273: OSErr FlushVolume( ExtendedVCB *vcb ); ! 274: ! 275: FCB *SetupFCB( ExtendedVCB *vcb, FileReference refNum, UInt32 fileID, UInt32 fileClumpSize ); ! 276: ! 277: OSErr GetDiskBlocks( ExtendedVCB *vcb, unsigned long *numBlocks); ! 278: ! 279: void AddVCB( ExtendedVCB *vcb, short driveNumber, short ioDRefNum ); ! 280: ! 281: short IsPressed( unsigned short k ); ! 282: ! 283: FileReference GetNewVRefNum(); ! 284: ! 285: OSErr GetVolumeNameFromCatalog(ExtendedVCB *vcb); ! 286: ! 287: #if TARGET_OS_MAC ! 288: static UInt16 CountRootFiles(ExtendedVCB *vcb); ! 289: #endif /* TARGET_OS_MAC */ ! 290: ! 291: ! 292: #if ( hasHFSManualEject ) ! 293: static void SetVCBManEject(ExtendedVCB *vcb); ! 294: #endif ! 295: ! 296: // External routines ! 297: ! 298: extern OSErr C_FlushMDB( ExtendedVCB *volume ); ! 299: ! 300: extern OSErr DisposeVolumeCacheBlocks( ExtendedVCB *vcb ); ! 301: ! 302: extern void DisposeVolumeControlBlock( ExtendedVCB *vcb ); ! 303: ! 304: extern OSErr DeturmineVolume1( VolumeParam *iopb, short *nameLength, Boolean *nameSpecified, ExtendedVCB **vcb, WDCBRec **wdcb, unsigned char **pathName ); ! 305: ! 306: extern OSErr DeturmineVolume3( VolumeParam *iopb, short *nameLength, Boolean *nameSpecified, ExtendedVCB **vcb, WDCBRec **wdcb, unsigned char **pathName ); ! 307: ! 308: extern OSErr FlushVolumeBuffers( ExtendedVCB *vcb ); ! 309: ! 310: extern void MultiplyUInt32IntoUInt64( UInt64 *wideResult, UInt32 num1, UInt32 num2 ); ! 311: ! 312: extern void TrashCatalogNodeCache( void ); ! 313: ! 314: ! 315: ! 316: #if TARGET_OS_MAC ! 317: //������������������������������������������������������������������������������� ! 318: // Routine: MountVolume ! 319: // ! 320: // Function: The VCB pointers are checked to see if a volume in the ! 321: // specified drive is already on-line (error if so). Reads in the ! 322: // directory master block and allocates memory for VCB and additional ! 323: // data structures, depending on the volume type: ! 324: // ! 325: // - For MFS volumes (handled in MFSVol), space is allocated for ! 326: // a volume buffer, as well as the block map, which is read in ! 327: // from disk). ! 328: // ! 329: // - For TFS volumes, space is allocated for a bitmap cache, a volume ! 330: // control cache (for B*-Tree use), and a volume cache. In addition, ! 331: // two FCBs are used by the B*-Trees. ! 332: // ! 333: // No new VCB storage is allocated for remounts. ! 334: // ! 335: //������������������������������������������������������������������������������� ! 336: ! 337: OSErr MountVolume( VolumeParam *volume, Boolean forceHFSWrapperToMount ) ! 338: { ! 339: Byte blockBuffer[512]; ! 340: IOParam *lowMemParamBlock; ! 341: short ioRefNum; ! 342: short vRefNum; ! 343: OSErr err; ! 344: DrvQEl *dqe; ! 345: Boolean pureHFSPlusVolume; ! 346: ! 347: ! 348: //--- FSQueueSync was already called by the MountVol glue. ! 349: ! 350: vRefNum = volume->ioVRefNum; ! 351: err = FindDrive( &ioRefNum, &dqe, vRefNum ); // Get driver refnum ! 352: if ( err == noErr ) ! 353: { ! 354: lowMemParamBlock = (IOParam *) LMParamBlock; ! 355: lowMemParamBlock->ioVRefNum = vRefNum; ! 356: lowMemParamBlock->ioRefNum = ioRefNum; ! 357: lowMemParamBlock->ioBuffer = (char *)blockBuffer; ! 358: lowMemParamBlock->ioPosMode = fsFromStart; ! 359: lowMemParamBlock->ioPosOffset = kIDSectorOffset * 512; // MDB is always at block #2 ! 360: lowMemParamBlock->ioReqCount = 512; // MDB is always 1 512 byte block ! 361: ! 362: err = PBReadSync( (ParmBlkPtr) lowMemParamBlock ); // Read the MDB ! 363: ! 364: pureHFSPlusVolume = ((HFSPlusVolumeHeader *)blockBuffer)->signature == kHFSPlusSigWord; ! 365: ! 366: if ( ( ((HFSMasterDirectoryBlock *)blockBuffer)->drEmbedSigWord == kHFSPlusSigWord // Wrapped HFS+ volume ! 367: || pureHFSPlusVolume == true ) // Pure HFS+ volume ! 368: && err == noErr ! 369: && forceHFSWrapperToMount == false ) // if we don't want to force the wrapper to mount ! 370: { ! 371: err = MountHFSPlusVolume( vRefNum, lowMemParamBlock, err, pureHFSPlusVolume ); ! 372: } ! 373: else // pass all other volume formats / errors to MountHFSVolume ! 374: { ! 375: err = MountHFSVolume( vRefNum, lowMemParamBlock, err ); ! 376: } ! 377: } ! 378: ! 379: return( err ); // pass the error back to CmdDone ! 380: } ! 381: #endif /* TARGET_OS_MAC */ ! 382: ! 383: ! 384: #if TARGET_OS_MAC ! 385: //������������������������������������������������������������������������������� ! 386: // Routine: MountHFSPlusVolume ! 387: // ! 388: // Function: Called by MountVolume() ! 389: // ! 390: // At this point we know that the MDB's Embeded signature indicates that ! 391: // this is an HFS Plus disk with an HFS wrapper. ! 392: // ! 393: //������������������������������������������������������������������������������� ! 394: ! 395: OSErr MountHFSPlusVolume( short driveNumber, IOParam* lowMemParamBlock, OSErr err, Boolean pureHFSPlusVolume ) ! 396: { ! 397: HFSMasterDirectoryBlock *mdb; ! 398: Byte blockBuffer[512]; ! 399: HFSPlusVolumeHeader *volumeHeader; ! 400: ExtendedVCB *vcb; ! 401: QHdr *vcbQHdr; ! 402: Byte *flagsP; ! 403: Byte *pbFlagsP; ! 404: SInt16 ioRefNum; ! 405: FSVarsRec *fsVars; ! 406: DrvQEl *dqe; ! 407: IOParam *currentIORequestPB; ! 408: FCB *fcb; ! 409: Ptr fcbsP; ! 410: ExtendedFCB *extendedFCB; ! 411: UInt32 hfsPlusIOPosOffset; ! 412: UInt16 hfsBlockCount; ! 413: UInt32 hfsBlockSize; ! 414: UInt32 lastMountedVersion; ! 415: UInt16 fcbIndexP; ! 416: ! 417: //-- Now read the HFS Plus VolumeHeader located at the first block within the embeded volume ! 418: ! 419: ioRefNum = lowMemParamBlock->ioRefNum; ! 420: ! 421: if ( pureHFSPlusVolume == false ) ! 422: { ! 423: mdb = (HFSMasterDirectoryBlock *) lowMemParamBlock->ioBuffer; ! 424: ! 425: hfsPlusIOPosOffset = (mdb->drEmbedExtent.startBlock * mdb->drAlBlkSiz) + ( mdb->drAlBlSt * 512 ); ! 426: ! 427: lowMemParamBlock->ioPosMode = fsFromStart; ! 428: lowMemParamBlock->ioPosOffset = hfsPlusIOPosOffset + (kIDSectorOffset * 512); // VolumeHeader is 2 sectors in ! 429: lowMemParamBlock->ioBuffer = (char *)blockBuffer; ! 430: ! 431: err = PBReadSync( (ParmBlkPtr) lowMemParamBlock ); // Read the VolumeHeader ! 432: } ! 433: else ! 434: { ! 435: hfsPlusIOPosOffset = 0; // From beginning of volume. ! 436: } ! 437: ! 438: volumeHeader = (HFSPlusVolumeHeader *) lowMemParamBlock->ioBuffer; ! 439: ! 440: err = ValidVolumeHeader( volumeHeader ); ! 441: ! 442: if (err == badMDBErr || err == noMacDskErr) ! 443: return err; // it's not valid, so don't try to mount it ! 444: ! 445: if ( err == noErr ) ! 446: { ! 447: err = notARemountErr; // cuz we're looking for remounts only here ! 448: vcbQHdr = LMGetVCBQHdr(); // search the queue of VCBs ! 449: ! 450: for ( vcb = (ExtendedVCB*)vcbQHdr->qHead ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 451: { ! 452: if ( (vcb->vcbDrvNum == 0) // matching volume better be off-line (0 drive num) ! 453: && (vcb->vcbSigWord == volumeHeader->signature) // Same signature? ! 454: && (vcb->vcbCrDate == volumeHeader->createDate) // Same create date? ! 455: && (vcb->vcbWrCnt == volumeHeader->writeCount) // Same write count? ! 456: ) ! 457: { ! 458: // At this point, we're fairly certain that the two volumes are, in fact, the same, ! 459: // but just to make sure (and avoid problems with stuck clocks), we'll compare the ! 460: // volume names as well: ! 461: ! 462: //�� How do I compare unicode names? ! 463: //�� do we just skip this check? ! 464: // if ( EqualString( vcb->volumeName, volumeHeader->volumeName, true, true) ) // caseSensitive, diacSensitive ! 465: break; // Remount ! 466: } ! 467: } ! 468: if ( vcb == nil ) goto RemountExit; ! 469: ! 470: ! 471: ((CntrlParam*)lowMemParamBlock)->csCode = drvStsCode; // Drive status! ! 472: ((CntrlParam*)lowMemParamBlock)->csParam[1] &= 0x00ff; // Clear status byte for return ! 473: ! 474: err = PBStatusSync( (ParmBlkPtr)lowMemParamBlock ); // refnum and drivenum set up by read call ! 475: ! 476: ! 477: //-- Now propagate the write protect status byte back to the vcb ! 478: flagsP = (Byte *)((Ptr)(&(vcb->vcbAtrb))) + 1; ! 479: pbFlagsP = (Byte *)((Ptr)(((CntrlParam*)lowMemParamBlock)->csParam)+2); ! 480: *flagsP = *pbFlagsP & kVolumeHardwareLockMask; ! 481: ! 482: vcb->vcbDrvNum = driveNumber; ! 483: vcb->vcbDRefNum = ioRefNum; // Driver RefNum ! 484: ! 485: #if ( hasHFSManualEject ) ! 486: SetVCBManEject(vcb); ! 487: #endif ! 488: ! 489: ! 490: if ( !(*flagsP & kVolumeHardwareLockMask) ) // if bit is NOT set ! 491: { ! 492: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // clear the kVolumeUnmounted attribute ! 493: MarkVCBDirty( vcb ); ! 494: err = FlushVolumeControlBlock( vcb ); ! 495: } ! 496: ! 497: err = noErr; ! 498: ! 499: } ! 500: ! 501: ! 502: RemountExit: ! 503: if ( err == noErr ) goto CmdDone; // noErr implies a successful remount ! 504: ! 505: //-- if we are allowing new mounts, let the ROM handle the details. Otherwise, let the error stand ! 506: fsVars = (FSVarsRec*)LMGetFSMVars(); ! 507: if ( fsVars->fsFlags & fsNoAllocateMask ) ! 508: goto CmdDone; ! 509: ! 510: LMSetNewMount( -1 ); // assume now that it's a new volume ! 511: ! 512: ! 513: ! 514: //-- First see if the disk is already mounted. ! 515: mv_Start: ! 516: err = paramErr; ! 517: driveNumber = lowMemParamBlock->ioVRefNum; ! 518: if ( driveNumber <= 0 ) goto MtVolDone; ! 519: err = GetVCBDriveNum( &vcb, driveNumber ); ! 520: if ( err == noErr ) ! 521: { ! 522: if ( vcb->vcbDrvNum != 0 ) ! 523: { ! 524: err = volOnLinErr; ! 525: goto MtVolDone; ! 526: } ! 527: } ! 528: ! 529: //-- Find the appropriate drive queue entry and allocate a VCB. ! 530: err = FindDrive( &ioRefNum, &dqe, driveNumber ); ! 531: if ( err != noErr ) goto MtVolDone; ! 532: ! 533: vcb = (ExtendedVCB *) NewPtrSysClear( sizeof( ExtendedVCB ) ); // Zero out the Extended VCB ! 534: ! 535: if ( vcb == nil ) goto MtVolDone; // exit if we got no memory ! 536: ! 537: AddVCB( vcb, driveNumber, ioRefNum ); // prep the VCB for cache calls ! 538: ! 539: //-- Now try reading in the Volume Header. ! 540: // We use "hfsPlusIOPosOffset / 512" cuz the VCB is not set up yet, so it's an absolute read ! 541: err = GetBlock_glue( gbDefault, (hfsPlusIOPosOffset / 512) + kIDSectorOffset , (Ptr*)&volumeHeader, vcb->vcbVRefNum, vcb ); // no Flags, VH is always block #0, vcb->vcbBufAdr == CacheQueueHeader ! 542: ! 543: if ( err != noErr ) goto MtVolEr2; // Quit & Release VCB on errors ! 544: ! 545: //-- Now check what manner of animal we have before us: ! 546: err = RelBlock_glue( (Ptr)volumeHeader, rbTrashMask ); ! 547: ! 548: err = ValidVolumeHeader( volumeHeader ); ! 549: if ( err != noErr ) ! 550: { ! 551: if ( err == noMacDskErr ) ! 552: goto MtVolEr2; ! 553: else ! 554: goto MtVolEr1; ! 555: } ! 556: ! 557: // The VolumeHeader seems OK: transfer info from buffer into VCB. ! 558: ! 559: // Initialize our dirID/nodePtr cache associated with this volume. ! 560: err = InitMRUCache( sizeof(UInt32), kDefaultNumMRUCacheBlocks, &(vcb->hintCachePtr) ); ! 561: ReturnIfError( err ); ! 562: ! 563: //-- Copy fields between [vcbSigWord, vcbVN] ! 564: ! 565: vcb->vcbCrDate = volumeHeader->createDate; // NOTE: local time, not GMT! ! 566: vcb->vcbLsMod = UTCToLocal(volumeHeader->modifyDate); ! 567: vcb->vcbAtrb = (UInt16)volumeHeader->attributes; // VCB uses 16 bits, next 16 are for future API changes ! 568: vcb->vcbClpSiz = volumeHeader->rsrcClumpSize; ! 569: vcb->vcbNxtCNID = volumeHeader->nextCatalogID; ! 570: vcb->vcbVolBkUp = UTCToLocal(volumeHeader->backupDate); ! 571: vcb->vcbWrCnt = volumeHeader->writeCount; ! 572: vcb->vcbXTClpSiz = volumeHeader->extentsFile.clumpSize; ! 573: vcb->vcbCTClpSiz = volumeHeader->catalogFile.clumpSize; ! 574: vcb->attributesClumpSize = volumeHeader->attributesFile.clumpSize; ! 575: vcb->vcbFilCnt = volumeHeader->fileCount; ! 576: vcb->vcbDirCnt = volumeHeader->folderCount; ! 577: BlockMoveData( volumeHeader->finderInfo, vcb->vcbFndrInfo, sizeof( SInt32 ) * 8 ); ! 578: ! 579: if ( pureHFSPlusVolume == true ) ! 580: { ! 581: UInt32 totalSectors = (volumeHeader->blockSize / 512) * volumeHeader->totalBlocks; ! 582: HFSBlocksFromTotalSectors( totalSectors, &hfsBlockSize, &hfsBlockCount ); ! 583: } ! 584: else ! 585: { ! 586: hfsBlockSize = mdb->drAlBlkSiz; ! 587: hfsBlockCount = mdb->drEmbedExtent.blockCount; ! 588: } ! 589: ! 590: // vcbFreeBks is the number of free bytes divided by the (HFS compatible) allocation block size. Since the ! 591: // number of free bytes could overflow a UInt32, we actually divide both free bytes and allocation block size by ! 592: // 512 before doing the division. This prevents intermediate values from overflowing until the volume size is ! 593: // 2 TB. It's OK to divide by 512 since both HFS and HFS Plus require allocation blocks to be a multiple of 512. ! 594: vcb->vcbFreeBks = (volumeHeader->freeBlocks * (volumeHeader->blockSize / 512)) / (hfsBlockSize / 512); ! 595: ! 596: ! 597: //-- Fields taken from the MDB ! 598: vcb->vcbSigWord = kHFSPlusSigWord; // new field in VCB space ! 599: vcb->vcbNmAlBlks = hfsBlockCount; // number of HFS allocation blocks HFS+ volume ! 600: vcb->vcbAlBlkSiz = hfsBlockSize; // add to extended vcb ! 601: ! 602: //-- Now fill in the Extended VCB info ! 603: vcb->vcbSigWord = volumeHeader->signature; ! 604: vcb->nextAllocation = volumeHeader->nextAllocation; ! 605: vcb->totalBlocks = volumeHeader->totalBlocks; ! 606: vcb->freeBlocks = volumeHeader->freeBlocks; ! 607: vcb->blockSize = volumeHeader->blockSize; ! 608: vcb->allocationsClumpSize = volumeHeader->allocationFile.clumpSize; ! 609: vcb->checkedDate = volumeHeader->checkedDate; ! 610: vcb->encodingsBitmap = volumeHeader->encodingsBitmap; ! 611: ! 612: // Set the allocation block start for this HFS Plus wrapped volume ! 613: vcb->vcbAlBlSt = hfsPlusIOPosOffset / 512; ! 614: vcb->hfsPlusIOPosOffset = hfsPlusIOPosOffset; ! 615: ! 616: //�� Questionables ! 617: vcb->vcbVBMSt = 0; //�� (We should set this) BitMap start NOT used in HFS Plus ! 618: vcb->vcbEmbedSigWord = 0; ! 619: vcb->vcbEmbedExtent.startBlock = 0; ! 620: vcb->vcbEmbedExtent.blockCount = 0; ! 621: ! 622: ! 623: //-- Mark all the unused VCB fields with 0 ! 624: vcb->vcbAllocPtr = 0; // use extended VCB value ! 625: ! 626: // Remember which implementation last mounted this volume ! 627: lastMountedVersion = volumeHeader->lastMountedVersion; ! 628: ! 629: currentIORequestPB = (IOParam *) ((QHdr *)LMGetFSQHdr())->qHead; // current request ! 630: currentIORequestPB->ioVRefNum = vcb->vcbVRefNum; // return volume refnum to user ! 631: ! 632: lowMemParamBlock = (IOParam *) LMParamBlock; ! 633: ((CntrlParam*)lowMemParamBlock)->csCode = drvStsCode; // drive status! ! 634: ((CntrlParam*)lowMemParamBlock)->csParam[1] &= 0x00ff; // Clear status byte for return ! 635: ! 636: err = PBStatusSync( (ParmBlkPtr)lowMemParamBlock ); ! 637: ! 638: flagsP = (Byte *)((Ptr)(&(vcb->vcbAtrb))) + 1; ! 639: pbFlagsP = (Byte *)((Ptr)(((CntrlParam*)lowMemParamBlock)->csParam)+2); ! 640: *flagsP = *pbFlagsP & kVolumeHardwareLockMask; ! 641: ! 642: if ( IsARamDiskDriver() ) ! 643: { ! 644: vcb->vcbAtrb |= kVolumeNoCacheRequiredMask; // yes:�mark VCB as a RAM Disk ! 645: } ! 646: ! 647: vcb->vcbXTAlBlks = 0; // Unused, use fcb.fcbPLen instead ! 648: vcb->vcbCTAlBlks = 0; // Unused, use fcb.fcbPLen instead ! 649: ! 650: vcb->vcbWrCnt++; // Compensate for write of MDB on last flush ! 651: ! 652: ! 653: //-- Try to find three free FCBs for use by the volume control B*-Trees: ! 654: ! 655: // ! 656: //-- Set up the Extent FCB ! 657: // ! 658: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); // Get new FCB ! 659: if ( err != noErr ) goto MtVolErr; ! 660: ! 661: fcb = GetFileControlBlock( fcbIndexP ); ! 662: fcb->fcbEOF = volumeHeader->extentsFile.logicalSize.lo; // Set extent tree's LEOF ! 663: fcb->fcbPLen = volumeHeader->extentsFile.totalBlocks * volumeHeader->blockSize; // Set extent tree's PEOF ! 664: ! 665: vcb->extentsRefNum = fcbIndexP; // Set Extents B*-Tree file RefNum ! 666: ! 667: ClearMemory( (Ptr)fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 668: ! 669: extendedFCB = ParallelFCBFromRefnum( fcbIndexP ); ! 670: BlockMoveData( volumeHeader->extentsFile.extents, extendedFCB->extents, sizeof(HFSPlusExtentRecord) ); ! 671: ! 672: // ! 673: //-- Set up the Catalog FCB ! 674: // ! 675: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); ! 676: if ( err != noErr ) goto MtVolErr; ! 677: ! 678: fcb = GetFileControlBlock( fcbIndexP ); ! 679: fcb->fcbEOF = volumeHeader->catalogFile.logicalSize.lo; // Set catalog tree's LEOF ! 680: fcb->fcbPLen = volumeHeader->catalogFile.totalBlocks * volumeHeader->blockSize; // Set catalog tree's PEOF ! 681: ! 682: vcb->catalogRefNum = fcbIndexP; // Set Catalog B*-Tree file RefNum ! 683: ! 684: ClearMemory( (Ptr)fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 685: ! 686: extendedFCB = ParallelFCBFromRefnum( fcbIndexP ); ! 687: BlockMoveData( volumeHeader->catalogFile.extents, extendedFCB->extents, sizeof(HFSPlusExtentRecord) ); ! 688: ! 689: ! 690: // ! 691: //-- Set up the Allocations FCB ! 692: // ! 693: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); ! 694: if ( err != noErr ) goto MtVolErr; ! 695: ! 696: fcb = GetFileControlBlock( fcbIndexP ); ! 697: fcb->fcbEOF = volumeHeader->allocationFile.logicalSize.lo; // Set catalog tree's LEOF ! 698: fcb->fcbPLen = volumeHeader->allocationFile.totalBlocks * volumeHeader->blockSize; // Set catalog tree's PEOF ! 699: ! 700: vcb->allocationsRefNum = fcbIndexP; // Set Catalog B*-Tree file RefNum ! 701: ! 702: ClearMemory( (Ptr)fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 703: ! 704: extendedFCB = ParallelFCBFromRefnum( fcbIndexP ); ! 705: BlockMoveData( volumeHeader->allocationFile.extents, extendedFCB->extents, sizeof(HFSPlusExtentRecord) ); ! 706: ! 707: ! 708: // ! 709: //-- Set up the Attributes FCB ! 710: // ! 711: vcb->attributesRefNum = 0; // In case there isn't an attributes BTree ! 712: ! 713: if (volumeHeader->attributesFile.extents[0].blockCount != 0) ! 714: { ! 715: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); ! 716: if ( err != noErr ) goto MtVolErr; ! 717: ! 718: fcb = GetFileControlBlock( fcbIndexP ); ! 719: fcb->fcbEOF = volumeHeader->attributesFile.logicalSize.lo; // Set attribute tree's LEOF ! 720: fcb->fcbPLen = volumeHeader->attributesFile.totalBlocks * volumeHeader->blockSize; // Set attribute tree's PEOF ! 721: ! 722: vcb->attributesRefNum = fcbIndexP; // Set Catalog B*-Tree file RefNum ! 723: ! 724: ClearMemory( (Ptr)fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 725: ! 726: extendedFCB = ParallelFCBFromRefnum( fcbIndexP ); ! 727: BlockMoveData( volumeHeader->attributesFile.extents, extendedFCB->extents, sizeof(HFSPlusExtentRecord) ); ! 728: } ! 729: ! 730: ! 731: vcb->vcbMAdr = (Ptr)*(long *)SysBMCPtr; // Set up the volume bitmap cache ! 732: vcb->vcbCtlBuf = (Ptr)*(long *)SysCtlCPtr; // Set up the volume control cache ! 733: ! 734: // ! 735: //-- Finish setting up the FCBs for the extent B*-Tree and the catalog B*-Tree: ! 736: // ! 737: ! 738: err = AccessBTree( vcb, vcb->extentsRefNum, kHFSExtentsFileID, vcb->vcbXTClpSiz, (void *) CompareExtentKeysPlus ); ! 739: if ( err != noErr ) goto MtChkErr; ! 740: ! 741: err = AccessBTree( vcb, vcb->catalogRefNum, kHFSCatalogFileID, vcb->vcbCTClpSiz, (void *) CompareExtendedCatalogKeys ); ! 742: if ( err != noErr ) goto MtChkErr; ! 743: ! 744: if (vcb->attributesRefNum) ! 745: { ! 746: err = AccessBTree( vcb, vcb->attributesRefNum, kHFSAttributesFileID, vcb->attributesClumpSize, (void *) CompareAttributeKeys ); ! 747: if ( err != noErr ) goto MtChkErr; ! 748: } ! 749: ! 750: (void) SetupFCB( vcb, vcb->allocationsRefNum, kHFSAllocationFileID, volumeHeader->allocationFile.clumpSize ); ! 751: ! 752: ! 753: err = CreateVolumeCatalogCache(vcb); ! 754: if ( err ) ! 755: goto MtChkErr; ! 756: ! 757: // set up root file count... ! 758: ! 759: vcb->vcbNmFls = CountRootFiles(vcb); ! 760: ! 761: ! 762: // Get the volume name from the catalog file ! 763: (void) GetVolumeNameFromCatalog(vcb); ! 764: ! 765: // If the volume was not unmounted properly, then run MountCheck. ! 766: // If the volume was last mounted by Bride 1.0b2 ('8.01'), then the create date may be wrong, so ! 767: // we should run MountCheck to fix it. ! 768: if ( !(vcb->vcbAtrb & (short)kVolumeUnmountedMask) || ! 769: lastMountedVersion == '8.01') ! 770: { ! 771: UInt32 consistencyStatus; ! 772: ! 773: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // From now until _Unmount (clear the bit) ! 774: *(Ptr)FSCallAsync = 0; ! 775: err = MountCheck( vcb, &consistencyStatus ); ! 776: if ( err ) ! 777: goto MtChkErr; ! 778: } ! 779: else ! 780: { ! 781: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // From now until _Unmount (clear the bit) ! 782: } ! 783: ! 784: CheckRemount: ! 785: ! 786: // ��This comment was in TFSVol.a, should look into it ! 787: // Deleted stuff patched out by KillCheckRemountNiceWay in FileMgrPatches.a <SM1> ! 788: ! 789: ! 790: MtVolOK: ! 791: err = noErr; ! 792: ! 793: MtVolDone: ! 794: if ( err == noErr ) ! 795: { ! 796: if ( !(vcb->vcbAtrb & kVolumeHardwareLockMask) ) // if the disk is not write protected ! 797: { ! 798: MarkVCBDirty( vcb ); // mark VCB dirty so it will be written ! 799: err = FlushVolumeControlBlock( vcb ); // Go flush the VCB info BEFORE close ! 800: } ! 801: } ! 802: goto CmdDone; ! 803: ! 804: ! 805: ! 806: MtChkErr: ! 807: (void) DisposeVolumeCatalogCache(vcb); ! 808: InvalidateCatalogCache( vcb ); ! 809: ! 810: *((OSErr *)HFSDSErr) = err; ! 811: err = badMDBErr; ! 812: ! 813: //-- Release any resources allocated so far before exiting with an error: ! 814: MtVolErr: ! 815: DisposeFileControlBlocks( vcb ); // deallocate control file FCBs ! 816: ! 817: MtVolEr1: ! 818: DisposeVolumeCacheBlocks( vcb ); // invalidate any cache blocks for this volume ! 819: ! 820: MtVolEr2: ! 821: if ( (Byte)LMGetNewMount() == 0 ) // only deallocate VCB for new mounts ! 822: { ! 823: // Remount case -- Must zero buffer and map ptrs in old VCB. ! 824: // Restore VCB to its original off-line state (ie clear VCBDrvNum, ! 825: // and move drive number to VCBDRefNum field) ! 826: vcb->vcbDRefNum = vcb->vcbDrvNum; // write drv number to VCBDRefNum field ! 827: vcb->vcbDRefNum = 0; // clear drive number field of VCB ! 828: vcb->vcbMAdr = nil; // clear mapptr in VCB ! 829: vcb->vcbBufAdr = nil; // clear buffptr in VCB ! 830: } ! 831: else ! 832: { ! 833: DisposeVolumeControlBlock( vcb ); ! 834: } ! 835: ! 836: if ( err <= 0 ) goto CmdDone; ! 837: ! 838: currentIORequestPB = (IOParam *) ((QHdr *)LMGetFSQHdr())->qHead; ! 839: goto mv_Start; ! 840: ! 841: CmdDone: ! 842: return( err ); ! 843: ! 844: } ! 845: #endif /* TARGET_OS_MAC */ ! 846: ! 847: ! 848: ! 849: #if TARGET_OS_MAC ! 850: //������������������������������������������������������������������������������� ! 851: // Routine: MountHFSVolume ! 852: // ! 853: // Function: The VCB pointers are checked to see if a volume in the ! 854: // specified drive is already on-line (error if so). Reads in the ! 855: // directory master block and allocates memory for VCB and additional ! 856: // data structures, depending on the volume type: ! 857: // ! 858: // - For MFS volumes (handled in MFSVol), space is allocated for ! 859: // a volume buffer, as well as the block map, which is read in ! 860: // from disk). ! 861: // ! 862: // - For TFS volumes, space is allocated for a bitmap cache, a volume ! 863: // control cache (for B*-Tree use), and a volume cache. In addition, ! 864: // two FCBs are used by the B*-Trees. ! 865: // ! 866: // No new VCB storage is allocated for remounts. ! 867: // ! 868: //������������������������������������������������������������������������������� ! 869: ! 870: OSErr MountHFSVolume( short driveNumber, IOParam* lowMemParamBlock, OSErr err ) ! 871: { ! 872: HFSMasterDirectoryBlock *mdb; ! 873: QHdr *vcbQHdr; ! 874: Byte *flagsP; ! 875: Byte *mdbFlagsP; ! 876: FSVarsRec *fsVars; ! 877: IOParam *currentIORequestPB; ! 878: Ptr fcbsP; ! 879: FCB *fcb; ! 880: ExtendedVCB *vcb; ! 881: DrvQEl *dqe; ! 882: short ioRefNum; ! 883: UInt16 fcbIndexP; ! 884: ! 885: if ( err != noErr ) ! 886: goto RemountExit; ! 887: ! 888: ioRefNum = lowMemParamBlock->ioRefNum; ! 889: mdb = (HFSMasterDirectoryBlock *) lowMemParamBlock->ioBuffer; // �� figure out how we use VolumeHeader & MasterDirectoryBlock, size of structures, etc. ! 890: ! 891: err = ValidMasterDirectoryBlock( mdb ); // is this an HFS/HFS PlusDisk ! 892: if ( err == noErr ) ! 893: { ! 894: err = notARemountErr; // cuz we're looking for remounts only here ! 895: vcbQHdr = LMGetVCBQHdr(); // search the queue of VCBs ! 896: ! 897: // CheckRemountLoop: ! 898: for ( vcb = (ExtendedVCB*)vcbQHdr->qHead ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 899: { ! 900: if ( (vcb->vcbDrvNum == 0) // matching volume better be off-line (0 drive num) ! 901: && (vcb->vcbSigWord == mdb->drSigWord) // Same signature? ! 902: && (vcb->vcbCrDate == mdb->drCrDate) // Same create date? ! 903: && (vcb->vcbLsMod == mdb->drLsMod) // Same mod date? ! 904: ) ! 905: { ! 906: // At this point, we're fairly certain that the two volumes are, in fact, the same, ! 907: // but just to make sure (and avoid problems with stuck clocks), we'll compare the ! 908: // volume names as well: ! 909: //�� Modify this call to use the extended VCB ascii name, not the Unicode name ! 910: if ( EqualString( vcb->vcbVN, mdb->drVN, true, true) ) // caseSensitive, diacSensitive ! 911: break; // Remount ! 912: } ! 913: } ! 914: if ( vcb == nil ) goto RemountExit; ! 915: ! 916: // We are now convinced that we have a remount. We will rebuild the attributes ! 917: // byte, which is the only one that could have changed. We'll also store the ! 918: // current drive number and driver refNum, and mark the volume dirty. ! 919: // Remount: ! 920: ! 921: ((CntrlParam*)lowMemParamBlock)->csCode = drvStsCode; // Drive status! ! 922: ((CntrlParam*)lowMemParamBlock)->csParam[1] &= 0x00ff; // Clear status byte for return ! 923: ! 924: err = PBStatusSync( (ParmBlkPtr)lowMemParamBlock ); // refnum and drivenum set up by read call ! 925: ! 926: //-- Now propagate the write protect status byte back to the vcb ! 927: flagsP = ((Byte *)(&(vcb->vcbAtrb))) + 1; ! 928: mdbFlagsP = ((Byte *)(((CntrlParam*)lowMemParamBlock)->csParam)+2); ! 929: *flagsP = *mdbFlagsP & kVolumeHardwareLockMask; ! 930: ! 931: vcb->vcbDrvNum = driveNumber; ! 932: vcb->vcbDRefNum = ioRefNum; // Driver RefNum ! 933: ! 934: #if ( hasHFSManualEject ) ! 935: SetVCBManEject(vcb); ! 936: #endif ! 937: ! 938: if ( !(*flagsP & kVolumeHardwareLockMask) ) // if bit is NOT set ! 939: { ! 940: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // clear the kVolumeUnmounted attribute ! 941: MarkVCBDirty( vcb ); ! 942: err = FlushVolumeControlBlock( vcb ); // Go flush the VCB info BEFORE close ! 943: } ! 944: ! 945: err = noErr; ! 946: } ! 947: ! 948: ! 949: RemountExit: ! 950: if ( err == noErr ) ! 951: goto CmdDone; // noErr implies a successful remount ! 952: ! 953: //-- if we are allowing new mounts, let the ROM handle the details. Otherwise, let the error stand ! 954: fsVars = (FSVarsRec*)LMGetFSMVars(); // $BB8 ! 955: if ( fsVars->fsFlags & fsNoAllocateMask ) ! 956: goto CmdDone; ! 957: ! 958: //�� This sets the word to -1, Asm only set the byte to -1 ! 959: LMSetNewMount( -1 ); // assume now that it's a new volume ! 960: ! 961: ! 962: ! 963: //-- First see if the disk is already mounted. ! 964: mv_Start: ! 965: err = paramErr; ! 966: driveNumber = lowMemParamBlock->ioVRefNum; ! 967: if ( driveNumber <= 0 ) ! 968: goto MtVolDone; ! 969: ! 970: err = GetVCBDriveNum( &vcb, driveNumber ); ! 971: if ( err == noErr ) ! 972: { ! 973: if ( vcb->vcbDrvNum != 0 ) ! 974: { ! 975: err = volOnLinErr; ! 976: goto MtVolDone; ! 977: } ! 978: } ! 979: ! 980: //-- Find the appropriate drive queue entry and allocate a VCB. ! 981: err = FindDrive( &ioRefNum, &dqe, driveNumber ); ! 982: if ( err != noErr ) goto MtVolDone; ! 983: ! 984: vcb = (ExtendedVCB *) NewPtrSysClear( sizeof( ExtendedVCB ) ); ! 985: ! 986: if ( vcb == nil ) goto MtVolDone; // exit if we got no memory ! 987: ! 988: AddVCB( vcb, driveNumber, ioRefNum ); // prep the VCB for cache calls ! 989: ! 990: //-- Now try reading in the master directory block. ! 991: err = GetBlock_glue( gbDefault, kIDSectorOffset, (Ptr*)&mdb, vcb->vcbVRefNum, vcb ); // no Flags, MDB is always block #2, vcb->vcbBufAdr == CacheQueueHeader ! 992: if ( err != noErr ) goto MtVolEr2; // Quit & Release VCB on errors ! 993: ! 994: //-- Now check what manner of animal we have before us: ! 995: err = RelBlock_glue( (Ptr)mdb, rbTrashMask ); ! 996: ! 997: err = ValidMasterDirectoryBlock( mdb ); ! 998: if ( err != noErr ) ! 999: { ! 1000: if ( err == noMacDskErr ) ! 1001: goto MtVolEr2; ! 1002: else ! 1003: goto MtVolEr1; ! 1004: } ! 1005: ! 1006: // The MDB seems OK: transfer all master directory info from buffer into VCB. ! 1007: ! 1008: // vcbSigWord is the start of duplicate mdb/vcb info. Asm VCBDInfoSt Equ 8 ! 1009: // copy all fields in mdb till the drVolBkUp field ! 1010: ! 1011: BlockMoveData( mdb, &(vcb->vcbSigWord), (Size)(&(mdb->drVolBkUp)) - (Size)mdb ); ! 1012: ! 1013: // Initialize our dirID/nodePtr cache associated with this volume. ! 1014: err = InitMRUCache( sizeof(UInt32), kDefaultNumMRUCacheBlocks, &(vcb->hintCachePtr) ); ! 1015: ReturnIfError( err ); ! 1016: ! 1017: //-- Some fields, vcbNmAlBlks, vcbAlBlkSiz, and vcbFreeBks are just around for API compatability. ! 1018: //-- The HFS/HFS Plus code we will use the corresponding ExtendedVCB fields. vcbNmAlBlks * vcbAlBlkSiz ! 1019: //-- still gives correct volume size. ! 1020: vcb->totalBlocks = vcb->vcbNmAlBlks; ! 1021: vcb->freeBlocks = vcb->vcbFreeBks; ! 1022: vcb->blockSize = vcb->vcbAlBlkSiz; ! 1023: ! 1024: ! 1025: currentIORequestPB = (IOParam *) ((QHdr *)LMGetFSQHdr())->qHead; // current request ! 1026: currentIORequestPB->ioVRefNum = vcb->vcbVRefNum; // return volume refnum to user ! 1027: ! 1028: lowMemParamBlock = (IOParam *) LMParamBlock; ! 1029: ((CntrlParam*)lowMemParamBlock)->csCode = drvStsCode; // drive status! ! 1030: ((CntrlParam*)lowMemParamBlock)->csParam[1] &= 0x00ff; // Clear status byte for return ! 1031: ! 1032: err = PBStatusSync( (ParmBlkPtr)lowMemParamBlock ); ! 1033: ! 1034: flagsP = ((Byte *)(&(vcb->vcbAtrb))) + 1; ! 1035: mdbFlagsP = ((Byte *)(((CntrlParam*)lowMemParamBlock)->csParam)+2); ! 1036: *flagsP = *mdbFlagsP & kVolumeHardwareLockMask; ! 1037: ! 1038: if ( IsARamDiskDriver() ) ! 1039: { ! 1040: vcb->vcbAtrb |= kVolumeNoCacheRequiredMask; // yes:�mark VCB as a RAM Disk ! 1041: } ! 1042: ! 1043: //-- copy all fields in mdb between drXTFlSize & drVolBkUp ! 1044: BlockMoveData( &(mdb->drVolBkUp), &(vcb->vcbVolBkUp), (Size)&(mdb->drXTFlSize) - (Size)&(mdb->drVolBkUp) ); // 66 bytes ! 1045: ! 1046: vcb->vcbXTAlBlks = DivUp( mdb->drXTFlSize, vcb->blockSize ); // Pick up PEOF of extent B*-Tree ! 1047: vcb->vcbCTAlBlks = DivUp( mdb->drCTFlSize, vcb->blockSize ); // Pick up PEOF of catalog B*-Tree ! 1048: ! 1049: // ��� WHY ARE WE RESTARTING THE ROAVING PTR ! 1050: vcb->nextAllocation = mdb->drAllocPtr; ! 1051: vcb->vcbAllocPtr = 0; // Restart the roving allocation ptr ! 1052: vcb->vcbWrCnt++; // Compensate for write of MDB on last flush ! 1053: ! 1054: ! 1055: //-- Try to find two free FCBs for use by the volume control B*-Trees: ! 1056: ! 1057: //-- Set up the Extent FCB ! 1058: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); ! 1059: if ( err != noErr ) goto MtVolErr; ! 1060: ! 1061: fcb = GetFileControlBlock( fcbIndexP ); ! 1062: fcb->fcbEOF = mdb->drXTFlSize; // Set catalog tree's LEOF ! 1063: fcb->fcbPLen = mdb->drXTFlSize; // Set catalog tree's PEOF ! 1064: ! 1065: vcb->extentsRefNum = fcbIndexP; // Set Extents B*-Tree file RefNum ! 1066: BlockMoveData( mdb->drXTExtRec, fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 1067: ! 1068: ! 1069: //-- Set up the Catalog FCB ! 1070: err = FindFileControlBlock( &fcbIndexP, &fcbsP ); ! 1071: if ( err != noErr ) goto MtVolErr; ! 1072: ! 1073: fcb = GetFileControlBlock( fcbIndexP ); ! 1074: fcb->fcbEOF = mdb->drCTFlSize; // Set catalog tree's LEOF ! 1075: fcb->fcbPLen = mdb->drCTFlSize; // Set catalog tree's PEOF ! 1076: ! 1077: vcb->catalogRefNum = fcbIndexP; // Set Catalog B*-Tree file RefNum ! 1078: BlockMoveData( mdb->drCTExtRec, fcb->fcbExtRec, sizeof(HFSExtentRecord) ); ! 1079: ! 1080: ! 1081: vcb->vcbMAdr = (Ptr)*(long *)SysBMCPtr; // Set up the volume bitmap cache ! 1082: vcb->vcbCtlBuf = (Ptr)*(long *)SysCtlCPtr; // Set up the volume control cache ! 1083: ! 1084: ! 1085: //-- Finish setting up the FCBs for the extent B*-Tree and the catalog B*-Tree: ! 1086: ! 1087: err = AccessBTree( vcb, vcb->extentsRefNum, kHFSExtentsFileID, vcb->vcbXTClpSiz, (void *) CompareExtentKeys ); ! 1088: if ( err != noErr ) goto MtChkErr; ! 1089: ! 1090: err = AccessBTree( vcb, vcb->catalogRefNum, kHFSCatalogFileID, vcb->vcbCTClpSiz, (void *) CompareCatalogKeys ); ! 1091: if ( err != noErr ) goto MtChkErr; ! 1092: ! 1093: err = CreateVolumeCatalogCache(vcb); ! 1094: if ( err ) goto MtChkErr; ! 1095: ! 1096: if ( !(vcb->vcbAtrb & (short)kVolumeUnmountedMask) ) ! 1097: { ! 1098: UInt32 consistencyStatus; ! 1099: ! 1100: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // From now until _Unmount (clear the bit) ! 1101: *(Ptr)FSCallAsync = 0; ! 1102: err = MountCheck( vcb, &consistencyStatus ); ! 1103: if ( err ) goto MtChkErr; ! 1104: } ! 1105: else ! 1106: { ! 1107: vcb->vcbAtrb &= ~kVolumeUnmountedMask; // From now until _Unmount (clear the bit) ! 1108: } ! 1109: ! 1110: CheckRemount: ! 1111: ! 1112: // ��This comment was in TFSVol.a, should look into it ! 1113: // Deleted stuff patched out by KillCheckRemountNiceWay in FileMgrPatches.a <SM1> ! 1114: ! 1115: ! 1116: MtVolOK: ! 1117: err = noErr; ! 1118: ! 1119: MtVolDone: ! 1120: if ( err == noErr ) ! 1121: { ! 1122: if ( !(vcb->vcbAtrb & kVolumeHardwareLockMask) ) // if the disk is not write protected ! 1123: { ! 1124: MarkVCBDirty( vcb ); // mark VCB dirty so it will be written ! 1125: err = FlushVolumeControlBlock( vcb ); // Go flush the VCB info BEFORE close ! 1126: } ! 1127: } ! 1128: goto CmdDone; ! 1129: ! 1130: ! 1131: ! 1132: MtChkErr: ! 1133: (void) DisposeVolumeCatalogCache(vcb); ! 1134: InvalidateCatalogCache( vcb ); ! 1135: ! 1136: ! 1137: *((OSErr *)HFSDSErr) = err; ! 1138: err = badMDBErr; ! 1139: ! 1140: //-- Release any resources allocated so far before exiting with an error: ! 1141: MtVolErr: ! 1142: DisposeFileControlBlocks( vcb ); // deallocate control file FCBs ! 1143: ! 1144: MtVolEr1: ! 1145: DisposeVolumeCacheBlocks( vcb ); // invalidate any cache blocks for this volume ! 1146: ! 1147: MtVolEr2: ! 1148: if ( (Byte)LMGetNewMount() == 0 ) // only deallocate VCB for new mounts ! 1149: { ! 1150: // Remount case -- Must zero buffer and map ptrs in old VCB. ! 1151: // Restore VCB to its original off-line state (ie clear VCBDrvNum, ! 1152: // and move drive number to VCBDRefNum field) ! 1153: vcb->vcbDRefNum = vcb->vcbDrvNum; // write drv number to VCBDRefNum field ! 1154: vcb->vcbDRefNum = 0; // clear drive number field of VCB ! 1155: vcb->vcbMAdr = nil; // clear mapptr in VCB ! 1156: vcb->vcbBufAdr = nil; // clear buffptr in VCB ! 1157: } ! 1158: else ! 1159: { ! 1160: DisposeVolumeControlBlock( vcb ); ! 1161: } ! 1162: ! 1163: if ( err <= 0 ) ! 1164: goto CmdDone; ! 1165: currentIORequestPB = (IOParam *) ((QHdr *)LMGetFSQHdr())->qHead; ! 1166: goto mv_Start; ! 1167: ! 1168: CmdDone: ! 1169: return( err ); ! 1170: ! 1171: } ! 1172: #endif /* TARGET_OS_MAC */ ! 1173: ! 1174: ! 1175: #if TARGET_OS_MAC ! 1176: //������������������������������������������������������������������������������� ! 1177: // Routine: UnMountVolume ! 1178: // ! 1179: // Function: All files on the volume in the drive are closed and any changed ! 1180: // directory information is written out to the diskette. Memory ! 1181: // for the VCB, volume buffer, and block map is deallocated. ! 1182: // ! 1183: //������������������������������������������������������������������������������� ! 1184: ! 1185: OSErr UnMountVolume( VolumeParam *volume, WDCBRecPtr *wdcb ) ! 1186: { ! 1187: FCB *fcb; ! 1188: OSErr err; ! 1189: SInt16 nameLength; ! 1190: Boolean nameSpecified; ! 1191: ExtendedVCB *vcb; ! 1192: unsigned char *pathName; ! 1193: UInt16 index; ! 1194: Ptr fcbs; ! 1195: Boolean doneSearching; ! 1196: Boolean isHFSPlus; ! 1197: FSSpec spec; ! 1198: UInt16 driveNumber; ! 1199: HFSMasterDirectoryBlock *mdb; ! 1200: Boolean mustRenameWrapperVolume = false; ! 1201: ! 1202: LMSetFlushOnly( 0 ); // Setup same as UnmountVol ! 1203: err = DeturmineVolume3( volume, &nameLength, &nameSpecified, &vcb, wdcb, &pathName ); ! 1204: if ( err != noErr ) ! 1205: goto CmdDone; ! 1206: ! 1207: isHFSPlus = ( vcb->vcbSigWord == kHFSPlusSigWord ); ! 1208: ! 1209: //-- Get the volume name from the catalog file to set in the HFS wrapper later ! 1210: if ( (isHFSPlus) && (vcb->vcbDrvNum != 0) ) // HFS+ volume and on-line ! 1211: { ! 1212: UInt32 hint; ! 1213: CatalogNodeData nodeData; ! 1214: ! 1215: err = GetCatalogNode( vcb, kHFSRootFolderID, NULL, kNoHint, &spec, &nodeData, &hint ); ! 1216: if ( err == noErr ) ! 1217: { ! 1218: err = GetBlock_glue( gbDefault, kIDSectorOffset, (Ptr*)&mdb, vcb->vcbVRefNum, vcb ); // Read the MDB ! 1219: if ( err == noErr ) ! 1220: { ! 1221: if ( mdb->drSigWord == kHFSSigWord ) // it's a wrapped volume ! 1222: { ! 1223: if ( memcmp( spec.name, mdb->drVN, spec.name[0]+1 ) != 0 ) // Has the name changed? ! 1224: { ! 1225: driveNumber = vcb->vcbDrvNum; ! 1226: mustRenameWrapperVolume = true; ! 1227: } ! 1228: } ! 1229: err = RelBlock_glue( (Ptr)mdb, rbTrashMask ); ! 1230: } ! 1231: } ! 1232: } ! 1233: ! 1234: // Initialize fcbs pointer ! 1235: Get1stFileControlBlock( &index, &fcbs ); ! 1236: ! 1237: if ( !(volume->ioTrap & kHFSMask) ) // if NOT Unconditional unmount? ! 1238: { ! 1239: //-- Search the FCB array for open files that reference the volume... ! 1240: do ! 1241: { ! 1242: fcb = GetFileControlBlock( index ); ! 1243: if ( (fcb->fcbFlNm != 0) && (fcb->fcbVPtr == vcb) ) // The file is currently open and on this volume ! 1244: { ! 1245: if ( fcb->fcbFlNm >= fsUsrCNID ) // is it a user file? ! 1246: { ! 1247: //-- Found an open user file on the volume, so return a busy condition... ! 1248: err = fBsyErr; ! 1249: break; ! 1250: } ! 1251: } ! 1252: ! 1253: doneSearching = GetNextFileControlBlock( &index, fcbs ); ! 1254: ! 1255: } while ( !doneSearching ); ! 1256: } ! 1257: ! 1258: if ( err == noErr ) ! 1259: { ! 1260: err = CheckExternalFileSystem( vcb ); ! 1261: if ( err == noErr ) ! 1262: { ! 1263: FlushVolume( vcb ); ! 1264: // Unmounting a TFS volume: close the volume control B*-Tree and use the ! 1265: // volume buffer to write out the MDB ! 1266: ! 1267: // From UnmountForTheNineties in FileMgrPatches.a ! 1268: // Here's the change: we no longer check whether the volume is offline. Instead we always ! 1269: // go ahead and close the control files, since we no longer close them on _Offline or _Eject. ! 1270: ! 1271: if ( vcb->vcbDrvNum != 0 ) // Check drive number: vol. offline? ! 1272: { ! 1273: err = FlushVolumeBuffers( vcb ); ! 1274: if ( err != noErr ) ! 1275: goto CmdDone; // Punt on errors ! 1276: } ! 1277: else ! 1278: { ! 1279: // here begins CloseControlFiles, which is derived from FlushBuffers ! 1280: // Now we have to close the control files because we no longer close them ! 1281: // in Eject and Offline ! 1282: ! 1283: if ( LMGetFlushOnly() == 0 ) // volume needs flushing ! 1284: { ! 1285: err = CloseFile( vcb, vcb->catalogRefNum, fcbs ); ! 1286: if ( err != noErr ) ! 1287: goto CmdDone; // Punt on errors ! 1288: ! 1289: err = CloseFile( vcb, vcb->extentsRefNum, fcbs ); ! 1290: if ( err != noErr ) ! 1291: goto CmdDone; // Punt on errors ! 1292: ! 1293: if ( isHFSPlus ) ! 1294: { ! 1295: err = AttributesCloseVolume( vcb ); ! 1296: if ( err != noErr ) ! 1297: goto CmdDone; ! 1298: ! 1299: err = CloseFile( vcb, vcb->allocationsRefNum, fcbs ); ! 1300: if ( err != noErr ) ! 1301: goto CmdDone; ! 1302: } ! 1303: ! 1304: (void) DisposeMRUCache(vcb->hintCachePtr); ! 1305: (void) DisposeVolumeCatalogCache(vcb); ! 1306: InvalidateCatalogCache( vcb ); ! 1307: DisposeVolumeCacheBlocks( vcb ); ! 1308: } ! 1309: } ! 1310: ! 1311: if ( LMGetFlushOnly() == 0 ) // volume needs flushing ! 1312: { ! 1313: // For UnMountVol, dequeue the VCB and trash any WDCBs for this volume ... ! 1314: DisposeVolumeControlBlock( vcb ); ! 1315: } ! 1316: ! 1317: // The volume is now unmounted, if it's an HFS+ volume, and the name does not match what's ! 1318: // in the MDB, mount the HFS wrapper rename the wrapper volume and unmount it. ! 1319: if ( mustRenameWrapperVolume ) ! 1320: { ! 1321: RenameWrapperVolume( spec.name, driveNumber ); ! 1322: } ! 1323: ! 1324: err = noErr; ! 1325: } ! 1326: } ! 1327: ! 1328: CmdDone: ! 1329: return( err ); ! 1330: } ! 1331: #endif /* TARGET_OS_MAC */ ! 1332: ! 1333: ! 1334: #if TARGET_OS_MAC ! 1335: //������������������������������������������������������������������������������� ! 1336: // Routine: RenameWrapperVolume ! 1337: // ! 1338: // Function: Called during UnmountVolume if the HFS+ volume name does not ! 1339: // match the name stored in the wrapper MDB. This function ! 1340: // renames the HFS wrapper volume. ! 1341: // ! 1342: //������������������������������������������������������������������������������� ! 1343: void RenameWrapperVolume( Str27 newVolumeName, UInt16 driveNumber ) ! 1344: { ! 1345: VolumeParam volume; ! 1346: ExtendedVCB *vcb; ! 1347: OSErr err; ! 1348: UInt32 hint; ! 1349: FSSpec spec; ! 1350: CatalogNodeData nodeData; ! 1351: Ptr pmsp; ! 1352: UInt32 modDate; ! 1353: WDCBRecPtr wdcbPtr; ! 1354: ! 1355: ClearMemory( &volume, sizeof(VolumeParam) ); ! 1356: volume.ioVRefNum = driveNumber; ! 1357: ! 1358: err = MountVolume( &volume, true ); ! 1359: if ( err != noErr ) ! 1360: return; // punt on errors ! 1361: ! 1362: err = GetVCBDriveNum( &vcb, driveNumber ); ! 1363: if ( err != noErr ) ! 1364: goto ErrorExit; // punt on errors ! 1365: ! 1366: modDate = vcb->vcbLsMod; ! 1367: ! 1368: err = GetCatalogNode( vcb, kHFSRootFolderID, NULL, kNoHint, &spec, &nodeData, &hint ); ! 1369: if ( err != noErr ) ! 1370: { ! 1371: #if DEBUG_BUILD ! 1372: DebugStr("\p GetCatalogNode failed"); ! 1373: #endif ! 1374: goto ErrorExit; // punt on errors ! 1375: } ! 1376: ! 1377: err = RenameCatalogNode( vcb, kHFSRootParentID, spec.name, newVolumeName, hint, &hint ); ! 1378: if ( err != noErr ) ! 1379: { ! 1380: #if DEBUG_BUILD ! 1381: DebugStr("\p RenameCatalogNode failed"); ! 1382: #endif ! 1383: goto ErrorExit; // punt on errors ! 1384: } ! 1385: ! 1386: BlockMoveData( newVolumeName, vcb->vcbVN, sizeof(Str27) ); ! 1387: vcb->vcbLsMod = modDate; ! 1388: MarkVCBDirty( vcb ); ! 1389: ! 1390: pmsp = LMGetPMSPPtr(); ! 1391: *((short*)(pmsp + kPoorMansSearchIndex)) = 0; // Invalidate Poor Mans search path ! 1392: ! 1393: ErrorExit: ! 1394: ! 1395: (void) UnMountVolume( &volume, &wdcbPtr ); ! 1396: } ! 1397: #endif /*TARGET_OS_MAC */ ! 1398: ! 1399: ! 1400: #if TARGET_OS_MAC ! 1401: //������������������������������������������������������������������������������� ! 1402: // Routine: CheckExternalFileSystem Asm: CkExtFS ! 1403: // ! 1404: // Function: Simple routine to separate out calls to be handled by an ! 1405: // external file system. ! 1406: // ! 1407: //������������������������������������������������������������������������������� ! 1408: OSErr CheckExternalFileSystem( ExtendedVCB *vcb ) ! 1409: { ! 1410: if ( vcb->vcbFSID == 0 ) ! 1411: { ! 1412: return( noErr ); ! 1413: } ! 1414: else ! 1415: { ! 1416: return( extFSErr ); ! 1417: } ! 1418: } ! 1419: #endif /* TARGET_OS_MAC */ ! 1420: ! 1421: ! 1422: ! 1423: ! 1424: //������������������������������������������������������������������������������� ! 1425: // Routine: CheckVolumeConsistancy ! 1426: // ! 1427: // Function: Check kBootVolumeInconsistentMask, and run MountCheck if necessary ! 1428: //������������������������������������������������������������������������������� ! 1429: OSErr CheckVolumeConsistency( ExtendedVCB *vcb ) ! 1430: { ! 1431: UInt32 consistencyStatus; ! 1432: OSErr err = noErr; ! 1433: ! 1434: #if TARGET_OS_RHAPSODY ! 1435: if ( vcb->vcbSigWord == kHFSSigWord) // and is an HFS disk ! 1436: #else /* TARGET_OS_RHAPSODY */ ! 1437: if ( ( *((UInt16*)&(((ROMHeaderRec *) LMGetROMBase())->MachineNumber)) == 0x077D ) && // is supermario based ! 1438: ( vcb->vcbSigWord == kHFSSigWord ) ) // and is an HFS disk ! 1439: #endif /* TARGET_OS_RHAPSODY */ ! 1440: { ! 1441: if ( vcb->vcbAtrb & kHFSBootVolumeInconsistentMask ) // was marked inconsistant ! 1442: { ! 1443: err = MountCheck( vcb, &consistencyStatus ); ! 1444: ! 1445: if ( err == noErr ) ! 1446: vcb->vcbAtrb &= ~kHFSVolumeSoftwareLockMask; // clear the bit ! 1447: } ! 1448: #if TARGET_OS_MAC ! 1449: if ( LMGetBootDrive() == vcb->vcbDrvNum ) // this is the boot volume ! 1450: vcb->vcbAtrb |= kHFSBootVolumeInconsistentMask; ! 1451: #endif /* TARGET_OS_MAC */ ! 1452: } ! 1453: ! 1454: return( err ); ! 1455: } ! 1456: ! 1457: ! 1458: ! 1459: ! 1460: //������������������������������������������������������������������������������� ! 1461: // Routine: VolumeWritable Asm: CVFlgs ! 1462: // ! 1463: // Function: Check the volume's flags to see if modify requests are allowed. ! 1464: // ! 1465: //������������������������������������������������������������������������������� ! 1466: OSErr VolumeWritable( ExtendedVCB *vcb ) ! 1467: { ! 1468: if ( !(vcb->vcbAtrb & 0x8000) ) // if the volume is not locked ! 1469: { ! 1470: if ( ! (*((Ptr)&(vcb->vcbAtrb) + 1) & kHFSVolumeHardwareLockMask) ) // if it's not write protected ! 1471: return( noErr ); ! 1472: else ! 1473: return( wPrErr ); ! 1474: } ! 1475: else ! 1476: { ! 1477: return( vLckdErr ); ! 1478: } ! 1479: } ! 1480: ! 1481: ! 1482: ! 1483: ! 1484: ! 1485: #if TARGET_OS_MAC ! 1486: ! 1487: //������������������������������������������������������������������������������� ! 1488: // Routine: FlushVolume Asm: FlushVFiles ! 1489: // ! 1490: // Function: All file buffers on the volume are flushed and any changed ! 1491: // directory information is written out to the disk. ! 1492: // ! 1493: //������������������������������������������������������������������������������� ! 1494: OSErr FlushVolume( ExtendedVCB *vcb ) ! 1495: { ! 1496: UInt16 index; ! 1497: Ptr fcbs; ! 1498: FCB *fcb; ! 1499: OSErr err; ! 1500: Boolean doneSearching; ! 1501: ! 1502: Get1stFileControlBlock( &index, &fcbs ); ! 1503: ! 1504: //ckNxtFCB ! 1505: err = noErr; ! 1506: do ! 1507: { ! 1508: fcb = GetFileControlBlock( index ); ! 1509: if ( (fcb->fcbFlNm != 0) && (fcb->fcbVPtr == vcb) ) // The file is currently open and on this volume ! 1510: { ! 1511: if ( fcb->fcbFlNm >= fsUsrCNID ) // is it a user file? ! 1512: { ! 1513: //-- Found an open user file on the volume, so return a busy condition... ! 1514: err = CloseFile( vcb, index, fcbs ); ! 1515: if ( err != noErr ) ! 1516: break; ! 1517: } ! 1518: } ! 1519: ! 1520: doneSearching = GetNextFileControlBlock( &index, fcbs ); ! 1521: ! 1522: } while ( !doneSearching ); ! 1523: ! 1524: return( err ); ! 1525: } ! 1526: ! 1527: ! 1528: ! 1529: //������������������������������������������������������������������������������� ! 1530: // Routine: DisposeFileControlBlocks from Asm: DsposFCBs ! 1531: // ! 1532: // Function: Clears the extent B*-Tree refNum & catalog refnum ! 1533: // ! 1534: //������������������������������������������������������������������������������� ! 1535: void DisposeFileControlBlocks( ExtendedVCB *vcb ) ! 1536: { ! 1537: OSErr err; ! 1538: ! 1539: err = AttributesCloseVolume( vcb ); ! 1540: #if DEBUG_BUILD ! 1541: if ( err != noErr ) DebugStr("\pHFS+: Can't close Property Manager"); ! 1542: #endif ! 1543: ! 1544: if ( vcb->extentsRefNum != 0 ) ! 1545: { ! 1546: //-- Clear extent B*-Tree refNum file number in FCB as unused ! 1547: ( (FCB *) ( LMGetFCBSPtr() + vcb->extentsRefNum ) )->fcbFlNm = 0L; ! 1548: } ! 1549: if ( vcb->catalogRefNum != 0 ) ! 1550: { ! 1551: //-- Clear catalog refnum file number in FCB as unused ! 1552: ( (FCB *) ( LMGetFCBSPtr() + vcb->catalogRefNum ) )->fcbFlNm = 0L; ! 1553: } ! 1554: ! 1555: if ( vcb->vcbSigWord == kHFSPlusSigWord && vcb->allocationsRefNum != 0) ! 1556: { ! 1557: //-- Clear allocation (bitmap) file number in FCB as unused ! 1558: ( (FCB *) ( LMGetFCBSPtr() + vcb->allocationsRefNum ) )->fcbFlNm = 0L; ! 1559: } ! 1560: } ! 1561: ! 1562: #endif /* TARGET_OS_MAC */ ! 1563: ! 1564: ! 1565: //������������������������������������������������������������������������������� ! 1566: // Routine: AccessBTree from Asm: AccessBT ! 1567: // ! 1568: // Function: Create an access path for a B*-Tree file: ! 1569: // 1. Initialize the FCB ! 1570: // 2. Attach a B*-Tree control block ! 1571: // ! 1572: // Note: For now the compare proc is the entry to the assembly glue calling a C compare function. ! 1573: // Once BTOpen is ported to C, we can pass in C comparison routines. ! 1574: // ! 1575: // Result: I/O result from BTOpen ! 1576: //������������������������������������������������������������������������������� ! 1577: #if TARGET_OS_MAC ! 1578: OSErr AccessBTree( ExtendedVCB *vcb, FileReference refNum, UInt32 fileID, UInt32 fileClumpSize, void *CompareRoutine ) ! 1579: { ! 1580: FCB *fcb; ! 1581: OSErr err; ! 1582: ! 1583: fcb = SetupFCB( vcb, refNum, fileID, fileClumpSize ); ! 1584: ! 1585: err = OpenBTree( refNum, CompareRoutine ); ! 1586: ! 1587: return( err ); ! 1588: } ! 1589: #endif /* TARGET_OS_MAC */ ! 1590: ! 1591: //������������������������������������������������������������������������������� ! 1592: // Routine: SetupFCB fills in the FCB info ! 1593: // ! 1594: // Returns: The filled up FCB ! 1595: //������������������������������������������������������������������������������� ! 1596: #if TARGET_OS_MAC ! 1597: FCB *SetupFCB( ExtendedVCB *vcb, FileReference refNum, UInt32 fileID, UInt32 fileClumpSize ) ! 1598: { ! 1599: FCB *fcb; ! 1600: ! 1601: fcb = (FCB *) GetFileControlBlock( refNum ); ! 1602: ! 1603: fcb->fcbFlags = 0; ! 1604: fcb->fcbSBlk = 0; ! 1605: fcb->fcbCrPs = 0; ! 1606: fcb->fcbFlNm = fileID; ! 1607: fcb->fcbVPtr = vcb; ! 1608: fcb->fcbClmpSize = fileClumpSize; ! 1609: ! 1610: // for debugging... ! 1611: switch (fileID) ! 1612: { ! 1613: case kHFSExtentsFileID: ! 1614: BlockMoveData( "\p**** EXTENTS B-TREE", fcb->fcbCName, sizeof("\p**** EXTENTS B-TREE") ); ! 1615: break; ! 1616: case kHFSCatalogFileID: ! 1617: BlockMoveData( "\p**** CATALOG B-TREE", fcb->fcbCName, sizeof("\p**** CATALOG B-TREE") ); ! 1618: break; ! 1619: case kHFSAllocationFileID: ! 1620: BlockMoveData( "\p**** VOLUME BITMAP", fcb->fcbCName, sizeof("\p**** VOLUME BITMAP") ); ! 1621: break; ! 1622: case kHFSAttributesFileID: ! 1623: BlockMoveData( "\p**** ATTRIBUTES B-TREE", fcb->fcbCName, sizeof("\p**** ATTRIBUTES B-TREE") ); ! 1624: break; ! 1625: } ! 1626: ! 1627: return( fcb ); ! 1628: } ! 1629: #endif /* TARGET_OS_MAC */ ! 1630: ! 1631: ! 1632: #if TARGET_OS_MAC ! 1633: ! 1634: //������������������������������������������������������������������������������� ! 1635: // Routine: FindFileControlBlock from Asm: FindFCB ! 1636: // ! 1637: // Function: Find an unused FCB ! 1638: // ! 1639: // Result: error ! 1640: //������������������������������������������������������������������������������� ! 1641: OSErr FindFileControlBlock( UInt16 *index, Ptr *fcbsH ) ! 1642: { ! 1643: Boolean doneSearching; ! 1644: OSErr err; ! 1645: FCB *fcb; ! 1646: ! 1647: Get1stFileControlBlock( index, fcbsH ); ! 1648: ! 1649: do ! 1650: { ! 1651: doneSearching = GetNextFileControlBlock( index, *fcbsH ); ! 1652: if ( doneSearching == false ) ! 1653: { ! 1654: fcb = GetFileControlBlock( *index ); ! 1655: if ( fcb->fcbFlNm == 0 ) // FCB unused? ! 1656: { ! 1657: ClearMemory( fcb, sizeof( FCB ) ); ! 1658: fcb->fcbFlNm = -1; // Mark it in use ! 1659: err = noErr; ! 1660: doneSearching = true; ! 1661: } ! 1662: } ! 1663: else ! 1664: { ! 1665: err = tmfoErr; ! 1666: } ! 1667: } while ( doneSearching == false ); ! 1668: ! 1669: return( err ); ! 1670: } ! 1671: ! 1672: ! 1673: //������������������������������������������������������������������������������� ! 1674: // Routine: Get1stFileControlBlock from Asm: Gt1stFCB ! 1675: // ! 1676: // Function: Point to the first FCB ! 1677: //������������������������������������������������������������������������������� ! 1678: void Get1stFileControlBlock( UInt16 *index, Ptr *fcbsH ) ! 1679: { ! 1680: // struct FCBSRec { ! 1681: // UInt16 length; // first word is FCB part length ! 1682: // FCB fcb[1]; // fcb array ! 1683: // }; ! 1684: *fcbsH = LMGetFCBSPtr(); ! 1685: *index = 2; ! 1686: } ! 1687: ! 1688: ! 1689: //������������������������������������������������������������������������������� ! 1690: // Routine: GetNextFileControlBlock from Asm: GtNxtFCB ! 1691: // ! 1692: // Function: Increment to the next FCB ! 1693: // Check if we've hit the end fcb yet ! 1694: // ! 1695: // Result: Return true if end was reached ! 1696: //������������������������������������������������������������������������������� ! 1697: Boolean GetNextFileControlBlock( UInt16 *index, Ptr fcbsP ) ! 1698: { ! 1699: ! 1700: *index += LMGetFSFCBLen(); ! 1701: ! 1702: return ( *index == *((UInt16 *)fcbsP) ); // first word is length ! 1703: } ! 1704: ! 1705: #endif /* TARGET_OS_MAC */ ! 1706: ! 1707: ! 1708: //������������������������������������������������������������������������������� ! 1709: // Routine: DivUp from Asm: DivUp ! 1710: // ! 1711: // Function: Given a number of bytes and block size, calculate the number of ! 1712: // blocks needd to hold all the bytes. ! 1713: // ! 1714: // Result: Number of physical blocks needed ! 1715: //������������������������������������������������������������������������������� ! 1716: UInt16 DivUp( UInt32 byteRun, UInt32 blockSize ) ! 1717: { ! 1718: UInt32 blocks; ! 1719: ! 1720: blocks = (byteRun + blockSize - 1) / blockSize; // Divide up, remember this is integer math. ! 1721: ! 1722: if ( blocks > 0xffff ) // maximum 16 bit value ! 1723: blocks = 0xffff; ! 1724: ! 1725: return( (UInt16) blocks ); ! 1726: } ! 1727: ! 1728: ! 1729: ! 1730: ! 1731: //������������������������������������������������������������������������������� ! 1732: // Routine: HFSBlocksFromTotalSectors ! 1733: // ! 1734: // Function: Given the total number of sectors on the volume, calculate ! 1735: // the 16Bit number of allocation blocks, and allocation block size. ! 1736: // ! 1737: // Result: none ! 1738: //������������������������������������������������������������������������������� ! 1739: void HFSBlocksFromTotalSectors( UInt32 totalSectors, UInt32 *blockSize, UInt16 *blockCount ) ! 1740: { ! 1741: UInt16 newBlockSizeInSectors = 1; ! 1742: UInt32 newBlockCount = totalSectors; ! 1743: ! 1744: while ( newBlockCount > 0XFFFF ) ! 1745: { ! 1746: newBlockSizeInSectors++; ! 1747: newBlockCount = totalSectors / newBlockSizeInSectors; ! 1748: } ! 1749: ! 1750: *blockSize = newBlockSizeInSectors * 512; ! 1751: *blockCount = newBlockCount; ! 1752: } ! 1753: ! 1754: ! 1755: ! 1756: ! 1757: //������������������������������������������������������������������������������� ! 1758: // Routine: ValidMasterDirectoryBlock ! 1759: // ! 1760: // Function: Run some sanity checks to make sure the MDB is valid ! 1761: // ! 1762: // Result: error ! 1763: //������������������������������������������������������������������������������� ! 1764: OSErr ValidMasterDirectoryBlock( HFSMasterDirectoryBlock *mdb ) ! 1765: { ! 1766: OSErr err; ! 1767: ! 1768: if ( (mdb->drSigWord == kHFSPlusSigWord) || (mdb->drSigWord == kHFSSigWord) ) // if HFS or HFS Plus volume ! 1769: { ! 1770: if ( (mdb->drAlBlkSiz != 0) && ((mdb->drAlBlkSiz & 0x01FF) == 0) ) // non zero multiple of 512 ! 1771: err = noErr; ! 1772: else ! 1773: err = badMDBErr; ! 1774: } ! 1775: else ! 1776: { ! 1777: err = noMacDskErr; ! 1778: } ! 1779: ! 1780: return( err ); ! 1781: } ! 1782: ! 1783: ! 1784: //������������������������������������������������������������������������������� ! 1785: // Routine: ValidVolumeHeader ! 1786: // ! 1787: // Function: Run some sanity checks to make sure the VolumeHeader is valid ! 1788: // ! 1789: // Result: error ! 1790: //������������������������������������������������������������������������������� ! 1791: OSErr ValidVolumeHeader( HFSPlusVolumeHeader *volumeHeader ) ! 1792: { ! 1793: OSErr err; ! 1794: ! 1795: if ( volumeHeader->signature == kHFSPlusSigWord && volumeHeader->version == kHFSPlusVersion ) ! 1796: { ! 1797: if ( (volumeHeader->blockSize != 0) && ((volumeHeader->blockSize & 0x01FF) == 0) ) // non zero multiple of 512 ! 1798: err = noErr; ! 1799: else ! 1800: err = badMDBErr; //�� I want badVolumeHeaderErr in Errors.i ! 1801: } ! 1802: else ! 1803: { ! 1804: err = noMacDskErr; ! 1805: } ! 1806: ! 1807: return( err ); ! 1808: } ! 1809: ! 1810: ! 1811: #if TARGET_OS_MAC ! 1812: ! 1813: //������������������������������������������������������������������������������� ! 1814: // Routine: FindDrive from Asm: FindDrive ! 1815: // ! 1816: // Function: Given a drive number, this routine returns the RefNum ! 1817: // for the driver by searching the system drive queue. ! 1818: // ! 1819: // Result: error ! 1820: //������������������������������������������������������������������������������� ! 1821: OSErr FindDrive( short *driverRefNum, DrvQEl **dqe, short driveNumber ) ! 1822: { ! 1823: OSErr err = nsDrvErr; // initialize as "drive not found" ! 1824: ! 1825: *dqe = ((DrvQEl*)LMGetDrvQHdr()->qHead); // get first DQE ! 1826: while ( *dqe != 0 ) // end of list? ! 1827: { ! 1828: if ( (**dqe).dQDrive != driveNumber ) // find the drive we're looking for? ! 1829: { ! 1830: *dqe = (DrvQEl*)(**dqe).qLink; // get ptr to next ! 1831: } ! 1832: else ! 1833: { ! 1834: *driverRefNum = (**dqe).dQRefNum; // return driver refnum ! 1835: if ( (**dqe).dQFSID == 0 ) // is this a Mac Filesystem? ! 1836: err = noErr; ! 1837: else ! 1838: err = extFSErr; // no, return error ! 1839: break; ! 1840: } ! 1841: } ! 1842: ! 1843: return( err ); ! 1844: } ! 1845: ! 1846: ! 1847: //������������������������������������������������������������������������������� ! 1848: // Routine: GetVCBDriveNum from Asm: GetVCBDrv ! 1849: // ! 1850: // Function: Determine VCB from DriveNum/VRefNum field ! 1851: // ! 1852: // Result: error ! 1853: //������������������������������������������������������������������������������� ! 1854: OSErr GetVCBDriveNum( ExtendedVCB **vcbResult, short driveNumber ) ! 1855: { ! 1856: ExtendedVCB *vcb; ! 1857: ! 1858: for ( vcb = (ExtendedVCB*)((LMGetVCBQHdr())->qHead) ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 1859: { ! 1860: if ( vcb->vcbDrvNum == driveNumber ) // success! ! 1861: break; ! 1862: if ( vcb->vcbDrvNum == 0 ) // offline ! 1863: { ! 1864: if ( vcb->vcbDRefNum == driveNumber * (-1) ) // offline match ! 1865: break; ! 1866: } ! 1867: } ! 1868: ! 1869: *vcbResult = vcb; ! 1870: ! 1871: if ( vcb == nil ) ! 1872: return( nsvErr ); ! 1873: else ! 1874: return( noErr ); ! 1875: } ! 1876: ! 1877: ! 1878: //������������������������������������������������������������������������������� ! 1879: // Routine: GetVCBRefNum from Asm: GetVCBRfn ! 1880: // ! 1881: // Function: Determine VCB from DriveNum/VRefNum field ! 1882: // ! 1883: // Result: error ! 1884: //������������������������������������������������������������������������������� ! 1885: OSErr GetVCBRefNum( ExtendedVCB **vcbResult, short vRefNum ) ! 1886: { ! 1887: ExtendedVCB *vcb; ! 1888: ! 1889: for ( vcb = (ExtendedVCB*)((LMGetVCBQHdr())->qHead) ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 1890: { ! 1891: if ( vcb->vcbVRefNum == vRefNum ) // success! ! 1892: { ! 1893: *vcbResult = vcb; ! 1894: return( noErr ); ! 1895: } ! 1896: } ! 1897: ! 1898: return( nsvErr ); ! 1899: } ! 1900: ! 1901: #endif /* TARGET_OS_MAC */ ! 1902: ! 1903: ! 1904: //������������������������������������������������������������������������������� ! 1905: // Routine: IsARamDiskDriver from Asm: IsRAMDiskDriver ! 1906: // ! 1907: // Function: Test if disk driver is a RAM disk ! 1908: // ! 1909: // Result: true if RAM disk ! 1910: //������������������������������������������������������������������������������� ! 1911: Boolean IsARamDiskDriver( void ) ! 1912: { ! 1913: #if TARGET_OS_MAC ! 1914: OSErr err; ! 1915: ParamBlockRec *pb; ! 1916: Byte diskType; ! 1917: ! 1918: pb = (ParamBlockRec *) LMParamBlock; // general purpose I/O param block ! 1919: pb->ioParam.ioCompletion = 0; // no completion routine ! 1920: pb->cntrlParam.csCode = infoCC; // pass control code ! 1921: pb->cntrlParam.csParam[0] = 0; // start out clean ! 1922: pb->cntrlParam.csParam[1] = 0; ! 1923: ! 1924: err = PBControlSync( pb ); // get driver info� ! 1925: ! 1926: if ( err == noErr ) // this control call supported ! 1927: { ! 1928: diskType = ((Byte *)(pb->cntrlParam.csParam))[3]; ! 1929: if ( (diskType == ramDiskType) || (diskType == romDiskType) ) ! 1930: return( true ); ! 1931: } ! 1932: ! 1933: return( false ); ! 1934: #else ! 1935: return( false ); ! 1936: #endif /* TARGET_OS_MAC */ ! 1937: } ! 1938: ! 1939: ! 1940: #if TARGET_OS_MAC ! 1941: ! 1942: OSErr MakeVCBsExtendedVCBs( void ) ! 1943: { ! 1944: VCB *oVCB; ! 1945: VCB *nextVCB; ! 1946: ExtendedVCB *exVCB; ! 1947: ExtendedVCB *firstNewVCBInQueue = nil; ! 1948: QHdr *vcbQHdr; ! 1949: UInt16 fcbIndex; ! 1950: UInt16 i; ! 1951: Ptr fcbs; ! 1952: FCB *fcb; ! 1953: WDCBArray *wdcbsAry; ! 1954: OSErr err; ! 1955: ! 1956: vcbQHdr = LMGetVCBQHdr(); // search the queue of VCBs ! 1957: ! 1958: for ( oVCB = (VCB *)vcbQHdr->qHead ; (oVCB != nil) && (oVCB != (VCB *)firstNewVCBInQueue) ; ) ! 1959: { ! 1960: nextVCB = (VCB *) oVCB->qLink; ! 1961: ! 1962: if ( (oVCB->vcbSigWord != kHFSPlusSigWord) && (oVCB->vcbFSID == 0) ) // if it's an HFS Plus VCB, assume it is already of ExtendedVCB type ! 1963: { ! 1964: exVCB = (ExtendedVCB *) NewPtrSysClear( sizeof(ExtendedVCB) ); // allocate space for the new ExtendedVCB ! 1965: ReturnIfError( MemError() ); ! 1966: BlockMoveData( oVCB, exVCB, sizeof(VCB) ); // copy the original VCB over ! 1967: ! 1968: if ( firstNewVCBInQueue == nil ) ! 1969: firstNewVCBInQueue = exVCB; ! 1970: ! 1971: //-- Set up the Extended fields, used internally in the HFS source ! 1972: exVCB->totalBlocks = exVCB->vcbNmAlBlks; ! 1973: exVCB->freeBlocks = exVCB->vcbFreeBks; ! 1974: exVCB->blockSize = exVCB->vcbAlBlkSiz; ! 1975: exVCB->nextAllocation = (UInt16)exVCB->vcbAllocPtr; // Almost certain to be zero ! 1976: // Note: SuperMario ROMs clear vcbAllocPtr and then flush the MDB. ! 1977: // So, when an HFS disk gets mounted, the allocation pointer is cleared both in ! 1978: // memory and on disk. The only way to fix this is to put HFS Plus in ROM. ! 1979: ! 1980: //-- Set up the caches for this volume ! 1981: err = InitMRUCache( sizeof(UInt32), kDefaultNumMRUCacheBlocks, &(exVCB->hintCachePtr) ); ! 1982: ReturnIfError( err ); ! 1983: ! 1984: err = CreateVolumeCatalogCache(exVCB); ! 1985: ReturnIfError( err ); ! 1986: ! 1987: //-- If we are dealing with the default VCB, set the corresponding ExtendedVCB as the default ! 1988: if ( oVCB == (VCB*) LMGetDefVCBPtr() ) ! 1989: LMSetDefVCBPtr( (Ptr) exVCB ); ! 1990: ! 1991: //-- Remove and deallocate the original VCB ! 1992: err = Dequeue( (QElemPtr) oVCB, (QHdrPtr) vcbQHdr ); // Dequeue the VCB from the VCB Queue ! 1993: ReturnIfError( err ); ! 1994: ! 1995: //-- Search the FCB list for refs to the old VCB pointer and update them ! 1996: Get1stFileControlBlock( &fcbIndex, &fcbs ); ! 1997: do ! 1998: { ! 1999: fcb = GetFileControlBlock( fcbIndex ); ! 2000: if ( fcb->fcbVPtr == (ExtendedVCB *) oVCB ) ! 2001: fcb->fcbVPtr = exVCB; ! 2002: } while ( GetNextFileControlBlock( &fcbIndex, fcbs ) == false );// while there's still some left ! 2003: ! 2004: //-- Search the WDCB list for refs to the old VCB pointer and update them ! 2005: wdcbsAry = (WDCBArray*)LMGetWDCBsPtr(); // Point to WDCB array ! 2006: for ( i=0 ; i< (wdcbsAry->count / sizeof(WDCBRec)) ; i++ ) ! 2007: { ! 2008: if ( wdcbsAry->wdcb[i].wdVCBPtr == oVCB ) ! 2009: wdcbsAry->wdcb[i].wdVCBPtr = (VCB *) exVCB; ! 2010: } ! 2011: ! 2012: //-- Deallocate memory used by the old VCB ! 2013: DisposePtr( (Ptr) oVCB ); ! 2014: ! 2015: //-- Insert the new extended vcb in the queue ! 2016: Enqueue( (QElemPtr) exVCB, (QHdrPtr) vcbQHdr ); ! 2017: } ! 2018: oVCB = nextVCB; ! 2019: } ! 2020: ! 2021: return( noErr ); ! 2022: } ! 2023: ! 2024: ! 2025: //������������������������������������������������������������������������������� ! 2026: // Routine: RemountWrappedVolumes ! 2027: // ! 2028: // Function: Called by InitHFSPlus, Attempt to re-mount all HFS+ volumes ! 2029: // previously mounted as HFS wrappers. ! 2030: // ! 2031: // Note: This routine assumes vcbEmbedSigWord is cleared during mount. ! 2032: // ! 2033: //������������������������������������������������������������������������������� ! 2034: extern void RemountWrappedVolumes( void ) ! 2035: { ! 2036: ExtendedVCB *vcb; ! 2037: ExtendedVCB *nextVCB; ! 2038: OSErr err; ! 2039: ! 2040: for ( vcb = (ExtendedVCB *) ((QHdr*)LMGetVCBQHdr())->qHead ; vcb != nil ; ) ! 2041: { ! 2042: // PBMountVol and UnmountVol modify the vcb queue, so save the link ! 2043: nextVCB = (ExtendedVCB *) vcb->qLink; ! 2044: ! 2045: if ( (vcb->vcbEmbedSigWord == kHFSPlusSigWord) && ( vcb->vcbFSID == 0) ) ! 2046: { ! 2047: err = UnmountVol( nil, vcb->vcbVRefNum ); ! 2048: if ( err == noErr ) ! 2049: { ! 2050: ParamBlockRec theParam; ! 2051: ! 2052: theParam.ioParam.ioCompletion = nil; ! 2053: theParam.ioParam.ioNamePtr = nil; ! 2054: theParam.ioParam.ioVRefNum = vcb->vcbDrvNum; ! 2055: (void) PBMountVol( &theParam ); ! 2056: } ! 2057: } ! 2058: ! 2059: vcb = nextVCB; ! 2060: } ! 2061: } ! 2062: ! 2063: ! 2064: //������������������������������������������������������������������������������� ! 2065: // Routine: FillHFSStack ! 2066: // ! 2067: // Function: Called by HFSInit. Fills the newly created HFS stack so we ! 2068: // can identify how much of the stack is actually being used. ! 2069: // ! 2070: //������������������������������������������������������������������������������� ! 2071: extern void FillHFSStack( void ) ! 2072: { ! 2073: Ptr p; ! 2074: SInt16 len = 0; ! 2075: char *s = "HFS+ By Don Brady, Mark Day, and Deric Horn. "; ! 2076: ! 2077: while ( s[len] != '\0' ) ! 2078: ++len; ! 2079: ! 2080: for ( p = LMGetHFSStkTop() - kFileSystemStackSize ; p + len < LMGetHFSStkTop() ; p += len ) ! 2081: { ! 2082: BlockMoveData( s, p, len ); ! 2083: } ! 2084: } ! 2085: ! 2086: ! 2087: //������������������������������������������������������������������������������� ! 2088: // Routine: CheckVolumeOffLine from Asm: ExtOffLinCk ! 2089: // ! 2090: // Function: Simple routine to separate out calls to be handled by an ! 2091: // external file system. ! 2092: // ! 2093: // Result: noErr if we handle it ! 2094: //������������������������������������������������������������������������������� ! 2095: //�� Same function appears in CatSearch.c as ExtOffLineCheck(), but the code is slightly different ! 2096: //�� we should delete one copy. ! 2097: OSErr CheckVolumeOffLine( ExtendedVCB *vcb ) ! 2098: { ! 2099: OSErr err; ! 2100: ! 2101: err = CheckExternalFileSystem( vcb ); ! 2102: if ( err == noErr && vcb->vcbDrvNum == 0 ) ! 2103: err = volOffLinErr; ! 2104: ! 2105: LMSetReqstVol( (Ptr)vcb ); ! 2106: ! 2107: return( err ); ! 2108: } ! 2109: ! 2110: #endif /* TARGET_OS_MAC */ ! 2111: ! 2112: ! 2113: ! 2114: ! 2115: //_______________________________________________________________________ ! 2116: // ! 2117: // Routine: CountRootFiles ! 2118: // ! 2119: // Input: pointer to VCB ! 2120: // ! 2121: // Function: Return a count of the number of files and folders in ! 2122: // the root directory of a volume. For HFS volumes, this ! 2123: // is maintained in the VCB (and MDB). For HFS Plus volumes, ! 2124: // we get the valence of the root directory from its catalog ! 2125: // record. ! 2126: //_______________________________________________________________________ ! 2127: UInt16 CountRootFiles(ExtendedVCB *vcb) ! 2128: { ! 2129: OSErr err; ! 2130: FSSpec spec; ! 2131: CatalogNodeData catNodeData; ! 2132: UInt32 hint; ! 2133: UInt16 rootCount; ! 2134: ! 2135: // if (vcb->vcbSigWord == kHFSSigWord || vcb->vcbFSID != 0) { ! 2136: // return vcb->vcbNmFls; ! 2137: // } ! 2138: ! 2139: // Here, it's an HFS Plus volume, so get the valence from the root ! 2140: // directory's catalog record. ! 2141: ! 2142: rootCount = 0; ! 2143: ! 2144: err = GetCatalogNode( vcb, kHFSRootFolderID, nil, kNoHint, &spec, &catNodeData, &hint ); ! 2145: if ( err == noErr ) { ! 2146: if (catNodeData.valence < 65536) ! 2147: rootCount = catNodeData.valence; ! 2148: else ! 2149: rootCount = 65535; // if the value is too large, pin it ! 2150: } ! 2151: ! 2152: return rootCount; ! 2153: } ! 2154: ! 2155: #if TARGET_OS_MAC ! 2156: ! 2157: //_______________________________________________________________________ ! 2158: // ! 2159: // Routine: GetVolumeInformation : GetVolInfo ! 2160: // Arguments: HVolumeParam *volume ! 2161: // Output: WDCBRec **wdcb (Needed for ExtFsHook in CmdDone) ! 2162: // OSErr err ! 2163: // ! 2164: // Function: Return information about the volume in a mounted drive. ! 2165: // If the IOVolIndex field is 0, the name of the default ! 2166: // volume is returned; if non-zero, the name of the nth ! 2167: // mounted volume is returned. The maximum length of a ! 2168: // volume name is 27 bytes. The drive number for the ! 2169: // volume is also returned. ! 2170: //_______________________________________________________________________ ! 2171: ! 2172: OSErr GetVolumeInformation( HVolumeParam *volume, WDCBRecPtr *wdcb ) ! 2173: { ! 2174: FSSpec spec; ! 2175: UInt32 maxBlocks; ! 2176: SInt16 nameLength; ! 2177: SInt16 volumeIndex; ! 2178: FileReference vRefNum; ! 2179: OSErr err; ! 2180: Ptr fcbs; ! 2181: FCB *fcb; ! 2182: ExtendedVCB *vcb; ! 2183: unsigned char *pathName; ! 2184: CatalogNodeData catNodeData; ! 2185: Boolean doneSearching; ! 2186: Boolean nameSpecified; ! 2187: WDCBArray *wdcbsAry; ! 2188: UInt16 fcbIndex; ! 2189: ! 2190: volumeIndex = volume->ioVolIndex; ! 2191: if ( volumeIndex == 0 ) ! 2192: { ! 2193: err = DeturmineVolume1( (VolumeParam*)volume, &nameLength, &nameSpecified, (ExtendedVCB **)&vcb, wdcb, &pathName ); ! 2194: if ( err != noErr ) goto CmdDone; ! 2195: } ! 2196: else if ( volume->ioVolIndex < 0 ) ! 2197: { ! 2198: err = DeturmineVolume3( (VolumeParam*)volume, &nameLength, &nameSpecified, (ExtendedVCB **)&vcb, wdcb, &pathName ); ! 2199: if ( err != noErr ) goto CmdDone; ! 2200: } ! 2201: else ! 2202: { ! 2203: nameSpecified = false; // Never any name specified (ioNamePtr is output arg) ! 2204: volume->ioVRefNum = 0; ! 2205: ! 2206: for ( vcb = (ExtendedVCB*)((LMGetVCBQHdr())->qHead) ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 2207: { ! 2208: if ( --volumeIndex == 0 ) ! 2209: break; ! 2210: } ! 2211: if ( vcb == nil ) ! 2212: { ! 2213: err = nsvErr; ! 2214: goto CmdDone; ! 2215: } ! 2216: } ! 2217: ! 2218: // first copy the heart of the VCB into the parameter block ! 2219: volume->ioVCrDate = vcb->vcbCrDate; ! 2220: volume->ioVLsMod = vcb->vcbLsMod; ! 2221: volume->ioVAtrb = vcb->vcbAtrb; ! 2222: volume->ioVNmFls = vcb->vcbNmFls; // don't call CountRootFiles(vcb) anymore ! 2223: volume->ioVBitMap = vcb->vcbVBMSt; ! 2224: volume->ioVNmAlBlks = vcb->vcbNmAlBlks; // we return the HFS volume format equivalents cuz ioVNmAlBlks is a short ! 2225: volume->ioVAlBlkSiz = vcb->vcbAlBlkSiz; ! 2226: volume->ioVClpSiz = vcb->vcbClpSiz; ! 2227: volume->ioAlBlSt = vcb->vcbAlBlSt; ! 2228: volume->ioVNxtCNID = vcb->vcbNxtCNID; ! 2229: volume->ioVFrBlk = vcb->vcbFreeBks; ! 2230: ! 2231: if ( vcb->vcbFSID != 0 ) ! 2232: volume->ioAllocPtr = vcb->vcbAllocPtr; // external file system ! 2233: else if ( vcb->nextAllocation < 0xFFFF ) ! 2234: volume->ioAllocPtr = vcb->nextAllocation; ! 2235: else ! 2236: volume->ioAllocPtr = 0xFFFF; ! 2237: ! 2238: ! 2239: Get1stFileControlBlock( &fcbIndex, &fcbs ); ! 2240: doneSearching = false; ! 2241: ! 2242: do ! 2243: { ! 2244: fcb = GetFileControlBlock( fcbIndex ); ! 2245: if ( fcb->fcbVPtr == (ExtendedVCB *) vcb ) // The file is currently open and on this volume ! 2246: { ! 2247: if ( fcb->fcbFlNm >= fsUsrCNID ) ! 2248: break; ! 2249: } ! 2250: doneSearching = GetNextFileControlBlock( &fcbIndex, fcbs ); ! 2251: } while ( doneSearching == false ); ! 2252: ! 2253: if ( doneSearching == true ) ! 2254: volume->ioVAtrb &= ~kFilesOpenMask; // Clear if no open files match ! 2255: else ! 2256: volume->ioVAtrb |= kFilesOpenMask; // Set if any files are opened ! 2257: ! 2258: if ( vcb == (ExtendedVCB *) LMGetDefVCBPtr() ) // Are we supposedly the default? ! 2259: volume->ioVAtrb |= kDefaultVolumeMask; // Set volume as the default ! 2260: else ! 2261: volume->ioVAtrb &= ~kDefaultVolumeMask; // Clear volume as the default ! 2262: ! 2263: *wdcb = nil; ! 2264: ! 2265: if ( (volume->ioVolIndex <= 0) && (nameSpecified == 0) ) ! 2266: { ! 2267: vRefNum = volume->ioVRefNum; ! 2268: if ( vRefNum > 0 ) // If driveNum, ignore it ! 2269: { ! 2270: goto retVRef; ! 2271: } ! 2272: else if ( vRefNum == 0 ) ! 2273: { ! 2274: vRefNum = 2; ! 2275: } ! 2276: else if ( vRefNum <= WDRfnMax ) ! 2277: { ! 2278: // a WDRefNum was supplied as VRefNum: change the number of files to be the <21Sep85> ! 2279: // valence of the directory in question: <21Sep85> ! 2280: vRefNum -= WDRfnMin; // Change WDRefNum to index ! 2281: } ! 2282: else ! 2283: { ! 2284: goto retVRef; ! 2285: } ! 2286: ! 2287: wdcbsAry = (WDCBArray*)LMGetWDCBsPtr(); // Point to WDCB array ! 2288: *wdcb = (WDCBRec*)((Ptr)wdcbsAry + vRefNum); ! 2289: ! 2290: err = CheckVolumeOffLine( vcb ); // check external FS err ! 2291: if ( err == noErr ) ! 2292: { ! 2293: if ( (**wdcb).wdDirID != fsRtDirID ) ! 2294: { ! 2295: //�� This will change to handle Don's meta struct ! 2296: err = GetCatalogNode( (ExtendedVCB*)vcb, (**wdcb).wdDirID, nil, (**wdcb).wdCatHint, &spec, &catNodeData, (UInt32*)&((**wdcb).wdCatHint) ); ! 2297: if ( err == noErr ) ! 2298: { ! 2299: volume->ioVNmFls = (UInt16) catNodeData.valence; ! 2300: } ! 2301: } ! 2302: } ! 2303: } ! 2304: ! 2305: // Do some hairy checking: if a working directory was specified, it shouldn't ! 2306: // be overwritten by the volRefNum. However, if a volume NAME was used, the ! 2307: // volRefNum field is ignored, and SHOULD be filled in with the volume's VRefNum. ! 2308: retVRef: ! 2309: if( (nameSpecified != 0) || (volume->ioVRefNum >= 0) ) ! 2310: { ! 2311: volume->ioVRefNum = vcb->vcbVRefNum; ! 2312: } ! 2313: // Copy the volume name field if specified. ! 2314: if ( volume->ioNamePtr != 0 ) ! 2315: BlockMoveData( vcb->vcbVN, volume->ioNamePtr, vcb->vcbVN[0]+1 ); ! 2316: ! 2317: ! 2318: // Many applications call GetVolInfo for preflighting when saving files. However, ! 2319: // they tend to use signed integers when calculating the volume's free space ! 2320: // (vcbFreeBlks * vcbAlBlkSize). If the free space is greater than 2 gigabytes they ! 2321: // get a negative result and think there is not enough space left on the volume. ! 2322: // ! 2323: // To fix this problem we high water mark vcbFreeBlks and vcbNmAlBlks so that when ! 2324: // multiplied by vcbAlBlkSiz the result is always less than or equal to 2GB. ! 2325: ! 2326: if ( volume->ioVAlBlkSiz > 0x8000 ) // Do the mock up ! 2327: { ! 2328: // Calculate the maximum number of allocation blocks that can fit within 2 gigabytes� <LgVol> ! 2329: // Divide 2 gig by block allocation size ! 2330: maxBlocks = 0x7FFFFFFF / volume->ioVAlBlkSiz; ! 2331: ! 2332: // Clip total and free to the maximum� ! 2333: if ( volume->ioVNmAlBlks > maxBlocks ) ! 2334: { ! 2335: volume->ioVNmAlBlks = maxBlocks; // pin the value limit ! 2336: ! 2337: if ( volume->ioVFrBlk > maxBlocks ) ! 2338: { ! 2339: volume->ioVFrBlk = maxBlocks; ! 2340: } ! 2341: } ! 2342: } ! 2343: ! 2344: // Subtract the physical sizes of the extent B*-Tree and the catalog B*-Tree <21Sep85> ! 2345: // from the volume size, so that the difference between the volume size and <21Sep85> ! 2346: // the free space reflects only the user's allocations: <21Sep85> ! 2347: volume->ioVNmAlBlks -= vcb->vcbXTAlBlks; // Take out XT allocation ! 2348: volume->ioVNmAlBlks -= vcb->vcbCTAlBlks; // Take out CT allocation ! 2349: ! 2350: if ( !(volume->ioTrap & kHFSMask) ) // TFGetVolInfo vs. plain GetVolInfo? ! 2351: { // GetVolInfo ! 2352: if ( volume->ioVNmAlBlks > kMaxHFSAllocationBlocks ) ! 2353: volume->ioVNmAlBlks = kMaxHFSAllocationBlocks; ! 2354: ! 2355: if ( volume->ioVFrBlk > kMaxHFSAllocationBlocks ) ! 2356: volume->ioVFrBlk = kMaxHFSAllocationBlocks; ! 2357: } ! 2358: else // Return some additional information for TGetVolInfo requests: ! 2359: { ! 2360: volume->ioVRefNum = vcb->vcbVRefNum; // ALWAYS return VRefNum ! 2361: volume->ioVDrvInfo = vcb->vcbDrvNum; // Driver number ! 2362: volume->ioVDRefNum = vcb->vcbDRefNum; // Driver RefNum ! 2363: volume->ioVFSID = vcb->vcbFSID; // File System ID ! 2364: ! 2365: // We return kHFSSigWord for HFS+ volumes for copatability with ! 2366: // existing applications. All StuffIt products, AppleShare, FileSharing, ! 2367: // and others incorrectly assume the volume is unsupported or MFS if the ! 2368: // sigWord is not 'BD'. GetXVolInfo() returns the "real" value. ! 2369: volume->ioVSigWord = vcb->vcbSigWord == kHFSPlusSigWord ? kHFSSigWord : vcb->vcbSigWord; ! 2370: ! 2371: ! 2372: //volume->ioVFilCnt = 0; // Clear ! 2373: //volume->ioVFilCnt = vcb->vcbNmFls; // Stuff low word as if MFS ! 2374: ! 2375: volume->ioVBkUp = vcb->vcbVolBkUp; // Last backup date ! 2376: volume->ioVSeqNum = vcb->vcbVSeqNum; // Volume sequence number ! 2377: volume->ioVWrCnt = vcb->vcbWrCnt; // Volume write count ! 2378: volume->ioVFilCnt = vcb->vcbFilCnt; // Files count for volume ! 2379: volume->ioVDirCnt = vcb->vcbDirCnt; // Directory count for volume ! 2380: ! 2381: BlockMoveData( vcb->vcbFndrInfo, volume->ioVFndrInfo, sizeof( SInt32 ) * 8 ); ! 2382: } ! 2383: ! 2384: GVIDone: ! 2385: LMSetReqstVol( (Ptr)vcb ); ! 2386: ! 2387: err = CheckExternalFileSystem( vcb ); ! 2388: ! 2389: CmdDone: ! 2390: return( err ); ! 2391: ! 2392: } ! 2393: ! 2394: ! 2395: ! 2396: ! 2397: //_______________________________________________________________________ ! 2398: // ! 2399: // Routine: GetXVolumeInformation : GetXVolInfo ! 2400: // Arguments: XVolumeParam *volume ! 2401: // Output: WDCBRecPtr *wdcb (Needed for ExtFsHook in CmdDone) ! 2402: // OSErr err ! 2403: // ! 2404: // Function: Return information about the volume in a mounted drive. ! 2405: // If the IOVolIndex field is 0, the name of the default ! 2406: // volume is returned; if non-zero, the name of the nth ! 2407: // mounted volume is returned. The maximum length of a ! 2408: // volume name is 27 bytes. The drive number for the ! 2409: // volume is also returned. ! 2410: //_______________________________________________________________________ ! 2411: ! 2412: OSErr GetXVolumeInformation( XVolumeParam *volume, WDCBRecPtr *wdcb ) ! 2413: { ! 2414: FSSpec spec; ! 2415: SInt16 nameLength; ! 2416: SInt16 volumeIndex; ! 2417: FileReference vRefNum; ! 2418: OSErr err; ! 2419: Ptr fcbs; ! 2420: FCB *fcb; ! 2421: ExtendedVCB *vcb; ! 2422: unsigned char *pathName; ! 2423: CatalogNodeData catNodeData; ! 2424: Boolean doneSearching; ! 2425: Boolean nameSpecified; ! 2426: WDCBArray *wdcbsAry; ! 2427: UInt16 fcbIndex; ! 2428: ! 2429: // The Installer doesn't setup ioXVersion (radar #1666217) ! 2430: #if 0 ! 2431: if (volume->ioXVersion != 0) ! 2432: return paramErr; ! 2433: #endif ! 2434: ! 2435: err = noErr; // Assume things will work ! 2436: ! 2437: volumeIndex = volume->ioVolIndex; ! 2438: if ( volumeIndex == 0 ) ! 2439: { ! 2440: err = DeturmineVolume1( (VolumeParam*)volume, &nameLength, &nameSpecified, (ExtendedVCB **)&vcb, wdcb, &pathName ); ! 2441: if ( err != noErr ) goto CmdDone; ! 2442: } ! 2443: else if ( volume->ioVolIndex < 0 ) ! 2444: { ! 2445: err = DeturmineVolume3( (VolumeParam*)volume, &nameLength, &nameSpecified, (ExtendedVCB **)&vcb, wdcb, &pathName ); ! 2446: if ( err != noErr ) goto CmdDone; ! 2447: } ! 2448: else ! 2449: { ! 2450: nameSpecified = false; // Never any name specified (ioNamePtr is output arg) ! 2451: volume->ioVRefNum = 0; ! 2452: ! 2453: for ( vcb = (ExtendedVCB*)((LMGetVCBQHdr())->qHead) ; vcb != nil ; vcb = (ExtendedVCB*)vcb->qLink ) // search the queue of VCBs ! 2454: { ! 2455: if ( --volumeIndex == 0 ) ! 2456: break; ! 2457: } ! 2458: if ( vcb == nil ) ! 2459: { ! 2460: err = nsvErr; ! 2461: goto CmdDone; ! 2462: } ! 2463: } ! 2464: ! 2465: // first copy the heart of the VCB into the parameter block ! 2466: volume->ioVCrDate = vcb->vcbCrDate; ! 2467: volume->ioVLsMod = vcb->vcbLsMod; ! 2468: volume->ioVAtrb = vcb->vcbAtrb; ! 2469: volume->ioVBitMap = vcb->vcbVBMSt; ! 2470: volume->ioVNmAlBlks = vcb->vcbNmAlBlks; // 16 bit value ! 2471: volume->ioVClpSiz = vcb->vcbClpSiz; ! 2472: volume->ioAlBlSt = vcb->vcbAlBlSt; ! 2473: volume->ioVNxtCNID = vcb->vcbNxtCNID; ! 2474: volume->ioVFrBlk = vcb->vcbFreeBks; ! 2475: volume->ioVNmFls = vcb->vcbNmFls; // don't call CountRootFiles(vcb) anymore ! 2476: ! 2477: if ( vcb->vcbFSID == 0 ) // an HFS or HFS Plus disk ! 2478: { ! 2479: volume->ioVAlBlkSiz = vcb->blockSize; // return true allocation blocks ! 2480: ! 2481: if ( vcb->nextAllocation < 0xFFFF ) ! 2482: volume->ioAllocPtr = vcb->nextAllocation; ! 2483: else ! 2484: volume->ioAllocPtr = 0xFFFF; ! 2485: } ! 2486: else // an external file system ! 2487: { ! 2488: volume->ioVAlBlkSiz = vcb->vcbAlBlkSiz; ! 2489: volume->ioAllocPtr = vcb->vcbAllocPtr; ! 2490: } ! 2491: ! 2492: ! 2493: Get1stFileControlBlock( &fcbIndex, &fcbs ); ! 2494: doneSearching = false; ! 2495: ! 2496: do ! 2497: { ! 2498: fcb = GetFileControlBlock( fcbIndex ); ! 2499: if ( fcb->fcbVPtr == vcb ) // The file is currently open and on this volume ! 2500: { ! 2501: if ( fcb->fcbFlNm >= fsUsrCNID ) ! 2502: break; ! 2503: } ! 2504: doneSearching = GetNextFileControlBlock( &fcbIndex, fcbs ); ! 2505: } while ( doneSearching == false ); ! 2506: ! 2507: if ( doneSearching == true ) ! 2508: volume->ioVAtrb &= ~kFilesOpenMask; // Clear if no open files match ! 2509: else ! 2510: volume->ioVAtrb |= kFilesOpenMask; // Set if any files are opened ! 2511: ! 2512: if ( vcb == (ExtendedVCB *) LMGetDefVCBPtr() ) // Are we supposedly the default? ! 2513: volume->ioVAtrb |= kDefaultVolumeMask; // Set volume as the default ! 2514: else ! 2515: volume->ioVAtrb &= ~kDefaultVolumeMask; // Clear volume as the default ! 2516: ! 2517: ! 2518: *wdcb = nil; ! 2519: ! 2520: if ( (volume->ioVolIndex <= 0) && (nameSpecified == 0) ) ! 2521: { ! 2522: vRefNum = volume->ioVRefNum; ! 2523: if ( vRefNum > 0 ) // If driveNum, ignore it ! 2524: { ! 2525: goto retVRef; ! 2526: } ! 2527: else if ( vRefNum == 0 ) ! 2528: { ! 2529: vRefNum = 2; ! 2530: } ! 2531: else if ( vRefNum <= WDRfnMax ) ! 2532: { ! 2533: // a WDRefNum was supplied as VRefNum: change the number of files to be the <21Sep85> ! 2534: // valence of the directory in question: <21Sep85> ! 2535: vRefNum -= WDRfnMin; // Change WDRefNum to index ! 2536: } ! 2537: else ! 2538: { ! 2539: goto retVRef; ! 2540: } ! 2541: ! 2542: wdcbsAry = (WDCBArray*)LMGetWDCBsPtr(); // Point to WDCB array ! 2543: *wdcb = (WDCBRec*)((Ptr)wdcbsAry + vRefNum); ! 2544: ! 2545: err = CheckVolumeOffLine( (ExtendedVCB*)vcb ); // check external FS err ! 2546: if ( err == noErr ) ! 2547: { ! 2548: if ( (**wdcb).wdDirID != fsRtDirID ) ! 2549: { ! 2550: //�� This will change to handle Don's meta struct ! 2551: err = GetCatalogNode( (ExtendedVCB*)vcb, (**wdcb).wdDirID, nil, (**wdcb).wdCatHint, &spec, &catNodeData, (UInt32*)&((**wdcb).wdCatHint) ); ! 2552: if ( err == noErr ) ! 2553: { ! 2554: volume->ioVNmFls = (UInt16) catNodeData.valence; ! 2555: } ! 2556: } ! 2557: } ! 2558: } ! 2559: ! 2560: // If a working directory was specified, it shouldn't be overwritten by ! 2561: // the volRefNum. However, if a volume NAME was used, the volRefNum ! 2562: // field is ignored, and SHOULD be filled in with the volume's VRefNum. ! 2563: retVRef: ! 2564: if( (nameSpecified != 0) || (volume->ioVRefNum >= 0) ) ! 2565: { ! 2566: volume->ioVRefNum = vcb->vcbVRefNum; ! 2567: } ! 2568: // Copy the volume name field if specified. ! 2569: if ( volume->ioNamePtr != 0 ) ! 2570: BlockMoveData( vcb->vcbVN, volume->ioNamePtr, vcb->vcbVN[0]+1 ); ! 2571: ! 2572: ! 2573: // Calculate the total and free bytes available on the volume as a 64 bit integer: ! 2574: ! 2575: if ( vcb->vcbSigWord == kHFSPlusSigWord ) ! 2576: { ! 2577: //-- Change to use ExtendedVCB fields for HFS Plus ! 2578: MultiplyUInt32IntoUInt64( &(volume->ioVTotalBytes), vcb->totalBlocks, vcb->blockSize ); ! 2579: MultiplyUInt32IntoUInt64( &(volume->ioVFreeBytes), vcb->freeBlocks, vcb->blockSize ); ! 2580: } ! 2581: else ! 2582: { ! 2583: //-- It's just an HFS volume or some other external file system ! 2584: MultiplyUInt32IntoUInt64( &(volume->ioVTotalBytes), volume->ioVNmAlBlks, volume->ioVAlBlkSiz ); ! 2585: MultiplyUInt32IntoUInt64( &(volume->ioVFreeBytes), volume->ioVFrBlk, volume->ioVAlBlkSiz ); ! 2586: } ! 2587: ! 2588: ! 2589: volume->ioVRefNum = vcb->vcbVRefNum; // VRefNum ! 2590: volume->ioVSigWord = vcb->vcbSigWord; // Volume signature ! 2591: volume->ioVDrvInfo = vcb->vcbDrvNum; // Driver number ! 2592: volume->ioVDRefNum = vcb->vcbDRefNum; // Driver RefNum ! 2593: volume->ioVFSID = vcb->vcbFSID; // File System ID ! 2594: volume->ioVBkUp = vcb->vcbVolBkUp; // Last backup date ! 2595: volume->ioVSeqNum = vcb->vcbVSeqNum; // Volume sequence number ! 2596: volume->ioVWrCnt = vcb->vcbWrCnt; // Volume write count ! 2597: volume->ioVFilCnt = vcb->vcbFilCnt; // Files count for volume ! 2598: volume->ioVDirCnt = vcb->vcbDirCnt; // Directory count for volume ! 2599: ! 2600: BlockMoveData( vcb->vcbFndrInfo, volume->ioVFndrInfo, sizeof( SInt32 ) * 8 ); ! 2601: ! 2602: CmdDone: ! 2603: if ( err == noErr && volume->ioVFSID != 0) ! 2604: { ! 2605: LMSetReqstVol((Ptr) vcb); ! 2606: err = extFSErr; // not an HFS or HFS Plus volume, let others have a crack at this call... ! 2607: } ! 2608: ! 2609: return( err ); ! 2610: } ! 2611: ! 2612: #endif /* TARGET_OS_MAC */ ! 2613: ! 2614: ! 2615: //_______________________________________________________________________ ! 2616: // ! 2617: // Routine: FlushVolumeControlBlock ! 2618: // Arguments: ExtendedVCB *vcb ! 2619: // Output: OSErr err ! 2620: // ! 2621: // Function: Flush volume information to either the VolumeHeader of the Master Directory Block ! 2622: //_______________________________________________________________________ ! 2623: ! 2624: OSErr FlushVolumeControlBlock( ExtendedVCB *vcb ) ! 2625: { ! 2626: OSErr err; ! 2627: #if TARGET_OS_MAC ! 2628: HFSPlusVolumeHeader *volumeHeader; ! 2629: FileReference index; ! 2630: FCB *fcb; ! 2631: ExtendedFCB *extendedFCB; ! 2632: #endif ! 2633: if ( ! IsVCBDirty( vcb ) ) // if it's not dirty ! 2634: return( noErr ); ! 2635: ! 2636: if ( vcb->vcbSigWord == kHFSPlusSigWord ) ! 2637: { ! 2638: #if TARGET_OS_MAC ! 2639: err = GetBlock_glue( gbDefault, (vcb->hfsPlusIOPosOffset / 512) + kIDSectorOffset, (Ptr*)&volumeHeader, vcb->vcbVRefNum, vcb ); // no Flags, VH is always block #0, vcb->vcbBufAdr == CacheQueueHeader ! 2640: #if( DEBUG_BUILD ) ! 2641: if ( volumeHeader->signature != vcb->vcbSigWord ) ! 2642: DebugStr("\p Bad VolumeHeader, signature does not match vcb" ); ! 2643: #endif ! 2644: ReturnIfError( err ); ! 2645: ! 2646: // 2005507, Keep the MDB creation date and VolumeHeader creation date in sync. ! 2647: if ( vcb->hfsPlusIOPosOffset != 0 ) // It's a wrapped HFS+ volume ! 2648: { ! 2649: HFSMasterDirectoryBlock *mdb; ! 2650: ! 2651: err = GetBlock_glue( gbDefault, ! 2652: kIDSectorOffset, ! 2653: (Ptr*)&mdb, ! 2654: vcb->vcbVRefNum, ! 2655: vcb ); ! 2656: if ( err == noErr ) ! 2657: { ! 2658: if ( mdb->drCrDate != vcb->vcbCrDate ) // The creation date changed ! 2659: { ! 2660: mdb->drCrDate = vcb->vcbCrDate; ! 2661: err = RelBlock_glue( (Ptr)mdb, rbWriteMask ); // Force it to be written ! 2662: } ! 2663: else ! 2664: { ! 2665: err = RelBlock_glue( (Ptr)mdb, rbFreeMask ); // Just release it ! 2666: } ! 2667: } ! 2668: } ! 2669: ! 2670: // volumeHeader->signature = vcb->signature; ! 2671: // volumeHeader->version = ! 2672: volumeHeader->attributes = vcb->vcbAtrb; // VCB uses 16 bits, next 16 are for future API changes ! 2673: volumeHeader->lastMountedVersion= kHFSPlusMountVersion; // Let others know we've mounted volume for writing ! 2674: //�� volumeName ! 2675: volumeHeader->createDate = vcb->vcbCrDate; // NOTE: local time, not GMT! ! 2676: volumeHeader->modifyDate = LocalToUTC(vcb->vcbLsMod); ! 2677: volumeHeader->backupDate = LocalToUTC(vcb->vcbVolBkUp); ! 2678: volumeHeader->checkedDate = vcb->checkedDate; ! 2679: volumeHeader->fileCount = vcb->vcbFilCnt; ! 2680: volumeHeader->folderCount = vcb->vcbDirCnt; ! 2681: volumeHeader->blockSize = vcb->blockSize; ! 2682: volumeHeader->totalBlocks = vcb->totalBlocks; ! 2683: volumeHeader->freeBlocks = vcb->freeBlocks; ! 2684: volumeHeader->nextAllocation = vcb->nextAllocation; ! 2685: volumeHeader->rsrcClumpSize = vcb->vcbClpSiz; ! 2686: volumeHeader->dataClumpSize = vcb->vcbClpSiz; ! 2687: volumeHeader->nextCatalogID = vcb->vcbNxtCNID; ! 2688: volumeHeader->writeCount = vcb->vcbWrCnt; ! 2689: volumeHeader->encodingsBitmap = vcb->encodingsBitmap; ! 2690: ! 2691: //���should we use the vcb or fcb clumpSize values ????? -djb ! 2692: volumeHeader->allocationFile.clumpSize = vcb->allocationsClumpSize; ! 2693: volumeHeader->extentsFile.clumpSize = vcb->vcbXTClpSiz; ! 2694: volumeHeader->catalogFile.clumpSize = vcb->vcbCTClpSiz; ! 2695: ! 2696: BlockMoveData( vcb->vcbFndrInfo, volumeHeader->finderInfo, sizeof(volumeHeader->finderInfo) ); ! 2697: ! 2698: index = vcb->extentsRefNum; ! 2699: extendedFCB = GetParallelFCB( index ); ! 2700: BlockMoveData( extendedFCB->extents, volumeHeader->extentsFile.extents, sizeof(HFSPlusExtentRecord) ); ! 2701: fcb = GetFileControlBlock( index ); ! 2702: volumeHeader->extentsFile.logicalSize.lo = fcb->fcbEOF; ! 2703: volumeHeader->extentsFile.logicalSize.hi = 0; ! 2704: volumeHeader->extentsFile.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 2705: ! 2706: index = vcb->catalogRefNum; ! 2707: extendedFCB = GetParallelFCB( index ); ! 2708: BlockMoveData( extendedFCB->extents, volumeHeader->catalogFile.extents, sizeof(HFSPlusExtentRecord) ); ! 2709: fcb = GetFileControlBlock( index ); ! 2710: volumeHeader->catalogFile.logicalSize.lo = fcb->fcbPLen; ! 2711: volumeHeader->catalogFile.logicalSize.hi = 0; ! 2712: volumeHeader->catalogFile.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 2713: ! 2714: index = vcb->allocationsRefNum; ! 2715: extendedFCB = GetParallelFCB( index ); ! 2716: BlockMoveData( extendedFCB->extents, volumeHeader->allocationFile.extents, sizeof(HFSPlusExtentRecord) ); ! 2717: fcb = GetFileControlBlock( index ); ! 2718: volumeHeader->allocationFile.logicalSize.lo = fcb->fcbPLen; ! 2719: volumeHeader->allocationFile.logicalSize.hi = 0; ! 2720: volumeHeader->allocationFile.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 2721: ! 2722: index = vcb->attributesRefNum; ! 2723: if (index != 0) // Only update fields if an attributes file existed and was open ! 2724: { ! 2725: extendedFCB = GetParallelFCB( index ); ! 2726: BlockMoveData( extendedFCB->extents, volumeHeader->attributesFile.extents, sizeof(HFSPlusExtentRecord) ); ! 2727: fcb = GetFileControlBlock( index ); ! 2728: volumeHeader->attributesFile.logicalSize.lo = fcb->fcbPLen; ! 2729: volumeHeader->attributesFile.logicalSize.hi = 0; ! 2730: volumeHeader->attributesFile.clumpSize = fcb->fcbClmpSize; ! 2731: volumeHeader->attributesFile.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 2732: } ! 2733: ! 2734: //-- Write the MDB out by releasing the block dirty ! 2735: ! 2736: err = RelBlock_glue( (Ptr)volumeHeader, rbWriteMask ); // force it to be written ! 2737: ! 2738: #if( hasHFSManualEject ) ! 2739: // The critical volume info that needs to be maintained ! 2740: // for volumes in manual-eject drives has just been flushed. ! 2741: if (err == noErr) ! 2742: vcb->vcbFlags &= ~vcbFlushCriticalInfoMask; ! 2743: #endif ! 2744: ! 2745: MarkVCBClean( vcb ); ! 2746: #else ! 2747: // This does now what above does also, so lets keep it all together in a single place ! 2748: err = C_FlushMDB( vcb ); // Go flush the VCB info BEFORE close ! 2749: #endif ! 2750: } ! 2751: else ! 2752: { ! 2753: // This routine doesn't really return an error!!! ! 2754: // So for now, we will just return noErr ! 2755: err = C_FlushMDB( vcb ); // Go flush the VCB info BEFORE close ! 2756: return( noErr ); ! 2757: } ! 2758: ! 2759: return( err ); ! 2760: } ! 2761: ! 2762: ! 2763: ExtendedFCB* GetParallelFCB(FileReference fref) ! 2764: { ! 2765: #if TARGET_OS_MAC ! 2766: ParallelFCB* pfcbArray; ! 2767: FSVarsRec* fsVars; ! 2768: short index; ! 2769: ! 2770: index = fref / sizeof(FCB); ! 2771: ! 2772: fsVars = (FSVarsRec*) LMGetFSMVars(); ! 2773: ! 2774: pfcbArray = (ParallelFCB*) fsVars->fcbPBuf; ! 2775: ! 2776: return &pfcbArray->extendedFCB[index]; ! 2777: #else ! 2778: return &VTOH(fref)->h_xfcb->fcb_extFCB; ! 2779: #endif /* TARGET_OS_MAC */ ! 2780: } ! 2781: ! 2782: ! 2783: //_______________________________________________________________________ ! 2784: // ! 2785: // Routine: FlushAlternateVolumeControlBlock ! 2786: // Arguments: ExtendedVCB *vcb ! 2787: // Boolean ifHFSPlus ! 2788: // Output: OSErr err ! 2789: // ! 2790: // Function: Flush volume information to either the Alternate VolumeHeader of the ! 2791: // Alternate Master Directory Block. Called by the BTree when the catalog ! 2792: // or extent files grow. Simply BlockMoves the original to the alternate ! 2793: // location. ! 2794: //_______________________________________________________________________ ! 2795: ! 2796: OSErr FlushAlternateVolumeControlBlock( ExtendedVCB *vcb, Boolean isHFSPlus ) ! 2797: { ! 2798: OSErr err; ! 2799: UInt32 alternateBlockLocation; ! 2800: ! 2801: err = FlushVolumeControlBlock( vcb ); ! 2802: ! 2803: if ( isHFSPlus ) // Flush the VolumeHeader ! 2804: { ! 2805: HFSPlusVolumeHeader *volumeHeader; ! 2806: HFSPlusVolumeHeader *alternateVolumeHeader; ! 2807: ! 2808: //-- Get the VolumeHeader Block, 1st block in the HFS Plus partition ! 2809: #if TARGET_OS_MAC ! 2810: err = GetBlock_glue( gbDefault, (vcb->hfsPlusIOPosOffset / 512) + kIDSectorOffset, (Ptr*)&volumeHeader, vcb->vcbVRefNum, vcb ); // VH is always 1st sector of HFS Plus partition ! 2811: #else ! 2812: err = GetBlock_glue( gbDefault, (vcb->hfsPlusIOPosOffset / 512) + kIDSectorOffset, (Ptr*)&volumeHeader, kNoFileReference, vcb ); // VH is always 1st sector of HFS Plus partition ! 2813: #endif ! 2814: ReturnIfError( err ); ! 2815: ! 2816: //-- Get the Alternate VolumeHeader Block, last sector in the HFS Plus partition ! 2817: alternateBlockLocation = (vcb->hfsPlusIOPosOffset / 512) + vcb->totalBlocks * (vcb->blockSize / 512) - 2; ! 2818: #if TARGET_OS_MAC ! 2819: err = GetBlock_glue( gbDefault, alternateBlockLocation, (Ptr*)&alternateVolumeHeader, vcb->vcbVRefNum, vcb ); // Alt VH is always 2nd to last sector of HFS Plus partition ! 2820: #else ! 2821: err = GetBlock_glue( gbDefault, alternateBlockLocation, (Ptr*)&alternateVolumeHeader, kNoFileReference, vcb ); // Alt VH is always 2nd to last sector of HFS Plus partition ! 2822: #endif ! 2823: if ( err == noErr ) ! 2824: { ! 2825: //-- Copy the VolumeHeader to the alternate location ! 2826: BlockMoveData( volumeHeader, alternateVolumeHeader, sizeof(HFSPlusVolumeHeader) ); ! 2827: ! 2828: //-- And write it back to the disk, NOW! ! 2829: err = RelBlock_glue( (Ptr)volumeHeader, rbFreeMask ); // free the MDB ! 2830: err = RelBlock_glue( (Ptr)alternateVolumeHeader, rbWriteMask ); // force it to be written ! 2831: } ! 2832: else ! 2833: { ! 2834: err = RelBlock_glue( (Ptr)volumeHeader, rbFreeMask ); // free the VH ! 2835: } ! 2836: } ! 2837: else // Flush the MasterDirectoryBlock ! 2838: { ! 2839: HFSMasterDirectoryBlock *mdb; ! 2840: HFSMasterDirectoryBlock *alternateMDB; ! 2841: UInt32 numBlocks; ! 2842: ! 2843: ! 2844: err = GetDiskBlocks( vcb, &numBlocks ); ! 2845: ReturnIfError( err ); ! 2846: ! 2847: //-- Get the MDB, 2nd block on HFS disk ! 2848: #if TARGET_OS_MAC ! 2849: err = GetBlock_glue( gbDefault, kIDSectorOffset, (Ptr*)&mdb, vcb->vcbVRefNum, vcb ); // no Flags, MDB is always block ! 2850: #else ! 2851: err = GetBlock_glue( gbDefault, kIDSectorOffset, (Ptr*)&mdb, kNoFileReference, vcb ); // no Flags, MDB is always block ! 2852: #endif ! 2853: ReturnIfError( err ); ! 2854: ! 2855: //-- Get the Alternate MDB, 2nd to last block on disk ! 2856: alternateBlockLocation = numBlocks - 2; ! 2857: #if TARGET_OS_MAC ! 2858: err = GetBlock_glue( gbDefault, alternateBlockLocation, (Ptr*)&alternateMDB, vcb->vcbVRefNum, vcb ); // no Flags, VH is always block #0, vcb->vcbBufAdr == CacheQueueHeader ! 2859: #else ! 2860: err = GetBlock_glue( gbDefault, alternateBlockLocation, (Ptr*)&alternateMDB, kNoFileReference, vcb ); // no Flags, VH is always block #0, vcb->vcbBufAdr == CacheQueueHeader ! 2861: #endif ! 2862: if ( err == noErr ) ! 2863: { ! 2864: //-- Copy the MDB to the alternate location ! 2865: BlockMoveData( mdb, alternateMDB, sizeof(HFSMasterDirectoryBlock) ); ! 2866: ! 2867: //-- And write it back to the disk, NOW! ! 2868: err = RelBlock_glue( (Ptr)mdb, rbFreeMask ); // free the MDB ! 2869: err = RelBlock_glue( (Ptr)alternateMDB, rbWriteMask ); // force it to be written ! 2870: } ! 2871: else ! 2872: { ! 2873: err = RelBlock_glue( (Ptr)mdb, rbFreeMask ); // free the MDB ! 2874: } ! 2875: } ! 2876: ! 2877: return( err ); ! 2878: } ! 2879: ! 2880: ! 2881: ! 2882: //_______________________________________________________________________ ! 2883: // ! 2884: // Routine: TrashAllFSCaches ! 2885: // Arguments: ExtendedVCB *vcb ! 2886: // Output: OSErr err ! 2887: // ! 2888: // Function: Trash all file system related caches as well as the disk cache. ! 2889: // This allows applications such as Disk First Aid or Norton Utilities ! 2890: // to be able to repair disks without first unmounting the volume. ! 2891: // ! 2892: // All file system caches should also have a call to the cache ! 2893: // trashing routine here! ! 2894: //_______________________________________________________________________ ! 2895: #if TARGET_OS_MAC ! 2896: OSErr TrashAllFSCaches( ExtendedVCB *vcb ) ! 2897: { ! 2898: OSErr err; ! 2899: FSVarsRec* fsVars = (FSVarsRec*) LMGetFSMVars(); ! 2900: ! 2901: InvalidateCatalogCache( vcb ); // Calls TrashCatalogIterator ! 2902: TrashCatalogNodeCache( ); // Trash Catalog node cache, gCatalogFSSpec ! 2903: err = TrashCacheBlocks( 0 ); // Trash BTree node cache ! 2904: TrashMRUCache( vcb->hintCachePtr ); // Trash the heuristic hint cache ! 2905: ClearMemory( fsVars->gAttributesBuffer, fsVars->gAttributesBufferSize ); // Clear the buffer used by MountCheck and CatSearch ! 2906: TrashVolumeDiskCache( vcb ); // Trash the disk cache, calls TRASHVBLKSA7 ! 2907: ! 2908: return( err ); ! 2909: } ! 2910: #endif /* TARGET_OS_MAC */ ! 2911: ! 2912: ! 2913: #if TARGET_OS_MAC ! 2914: OSErr GetDiskBlocks( ExtendedVCB *vcb, unsigned long *numBlocks) ! 2915: { ! 2916: /* Various constants for GetDiskBlocks() */ ! 2917: enum ! 2918: { ! 2919: /* return format list status code */ ! 2920: kFmtLstCode = 6, ! 2921: ! 2922: /* reference number of .SONY driver */ ! 2923: kSonyRefNum = 0xfffb, ! 2924: ! 2925: /* values returned by DriveStatus in DrvSts.twoSideFmt */ ! 2926: kSingleSided = 0, ! 2927: kDoubleSided = -1, ! 2928: kSingleSidedSize = 800, /* 400K */ ! 2929: kDoubleSidedSize = 1600, /* 800K */ ! 2930: ! 2931: /* values in DrvQEl.qType */ ! 2932: kWordDrvSiz = 0, ! 2933: kLongDrvSiz = 1, ! 2934: ! 2935: /* more than enough formatListRecords */ ! 2936: kMaxFormatListRecs = 16 ! 2937: }; ! 2938: ! 2939: DrvQEl *driveQElementPtr; ! 2940: unsigned long blocks; ! 2941: ParamBlockRec pb; ! 2942: DrvSts status; ! 2943: FormatListRec formatListRecords[kMaxFormatListRecs]; ! 2944: short formatListRecIndex; ! 2945: OSErr err; ! 2946: short driverRefNum; ! 2947: ! 2948: blocks = 0; ! 2949: ! 2950: // Find the drive queue element for this volume ! 2951: err = FindDrive( &driverRefNum, &driveQElementPtr, vcb->vcbDrvNum ); ! 2952: ReturnIfError( err ); ! 2953: ! 2954: // Make sure this is a real driver (dQRefNum < 0). ! 2955: // AOCE's Mail Enclosures volume uses 0 for dQRefNum which will cause ! 2956: // problems if you try to use it as a driver refNum. ! 2957: ! 2958: if ( driveQElementPtr->dQRefNum >= 0 ) ! 2959: { ! 2960: err = paramErr; ! 2961: } ! 2962: else ! 2963: { ! 2964: // Attempt to get the drive's format list. ! 2965: // (see the Technical Note "What Your Sony Drives For You") ! 2966: ! 2967: pb.cntrlParam.ioVRefNum = driveQElementPtr->dQDrive; ! 2968: pb.cntrlParam.ioCRefNum = driveQElementPtr->dQRefNum; ! 2969: pb.cntrlParam.csCode = kFmtLstCode; ! 2970: pb.cntrlParam.csParam[0] = kMaxFormatListRecs; ! 2971: *(long *)&pb.cntrlParam.csParam[1] = (long)&formatListRecords[0]; ! 2972: ! 2973: err = PBStatusSync(&pb); ! 2974: ! 2975: if ( err == noErr ) ! 2976: { ! 2977: // The drive supports ReturnFormatList status call. ! 2978: ! 2979: // Get the current disk's size. ! 2980: for( formatListRecIndex = 0; ! 2981: formatListRecIndex < pb.cntrlParam.csParam[0]; ! 2982: ++formatListRecIndex ) ! 2983: { ! 2984: if ( (formatListRecords[formatListRecIndex].formatFlags & ! 2985: diCIFmtFlagsCurrentMask) != 0 ) ! 2986: { ! 2987: blocks = formatListRecords[formatListRecIndex].volSize; ! 2988: } ! 2989: } ! 2990: if ( blocks == 0 ) ! 2991: { ! 2992: // This should never happen ! 2993: err = paramErr; ! 2994: } ! 2995: } ! 2996: else if ( driveQElementPtr->dQRefNum == (short)kSonyRefNum ) ! 2997: { ! 2998: // The drive is a non-SuperDrive floppy which only supports 400K and 800K disks ! 2999: ! 3000: err = DriveStatus(driveQElementPtr->dQDrive, &status); ! 3001: if ( err == noErr ) ! 3002: { ! 3003: switch ( status.twoSideFmt ) ! 3004: { ! 3005: case kSingleSided: ! 3006: blocks = kSingleSidedSize; ! 3007: break; ! 3008: case kDoubleSided: ! 3009: blocks = kDoubleSidedSize; ! 3010: break; ! 3011: default: ! 3012: // This should never happen ! 3013: err = paramErr; ! 3014: break; ! 3015: } ! 3016: } ! 3017: } ! 3018: else ! 3019: { ! 3020: // The drive is not a floppy and it doesn't support ReturnFormatList ! 3021: // so use the dQDrvSz field(s) ! 3022: ! 3023: err = noErr; // reset err ! 3024: switch ( driveQElementPtr->qType ) ! 3025: { ! 3026: case kWordDrvSiz: ! 3027: blocks = driveQElementPtr->dQDrvSz; ! 3028: break; ! 3029: case kLongDrvSiz: ! 3030: blocks = ((unsigned long)driveQElementPtr->dQDrvSz2 << 16) + ! 3031: driveQElementPtr->dQDrvSz; ! 3032: break; ! 3033: default: ! 3034: // This should never happen ! 3035: err = paramErr; ! 3036: break; ! 3037: } ! 3038: } ! 3039: } ! 3040: ! 3041: *numBlocks = blocks; ! 3042: ! 3043: return ( err ); ! 3044: } ! 3045: #endif /* TARGET_OS_MAC */ ! 3046: ! 3047: ! 3048: // ! 3049: // Sets up a VCB for calls to GetBlock() ! 3050: // ! 3051: void AddVCB( ExtendedVCB *vcb, short driveNumber, short ioRefNum ) ! 3052: { ! 3053: #if TARGET_OS_MAC ! 3054: OSErr err = noErr; ! 3055: WDCBArray *wdcbsAry; ! 3056: QHdr *vcbQHdr; ! 3057: WDCBRecPtr wdcb; ! 3058: ! 3059: vcbQHdr = LMGetVCBQHdr(); ! 3060: if ( vcbQHdr->qHead == nil ) ! 3061: { // Queue is empty, new vcb is the default now ! 3062: LMSetDefVCBPtr( (Ptr) vcb ); ! 3063: wdcbsAry = (WDCBArray*)LMGetWDCBsPtr(); // Point to WDCB array ! 3064: ! 3065: wdcb = &(wdcbsAry->wdcb[0]); ! 3066: wdcb->wdVCBPtr = (VCB *) vcb; // Set default VCB pointer in default WDCB ! 3067: wdcb->wdDirID = fsRtDirID; // Default to root directory ! 3068: wdcb->wdCatHint = 0; // Clear catalog hint ! 3069: wdcb->wdProcID = 0; // And procID of WDCB 'owner' ! 3070: vcbQHdr = LMGetVCBQHdr(); // Reset for VCB insertion ! 3071: } ! 3072: ! 3073: ! 3074: Enqueue( (QElemPtr)vcb, (QHdrPtr)vcbQHdr ); // Insert the new VCB in the queue ! 3075: ! 3076: vcb->vcbDrvNum = driveNumber; ! 3077: vcb->vcbDRefNum = ioRefNum; ! 3078: ! 3079: #if ( hasHFSManualEject ) ! 3080: SetVCBManEject(vcb); // set vcb maneject flag appropriately <SM7> <BH 03Aug93> ! 3081: #endif ! 3082: ! 3083: ! 3084: vcb->vcbBufAdr = LMGetSysVolCPtr(); // always use system-wide cache � ! 3085: ! 3086: vcb->vcbVRefNum = GetNewVRefNum(); // Assign a refNum to this new volume. ! 3087: ! 3088: if ( vcb == (ExtendedVCB *) LMGetDefVCBPtr() ) // Are we supposedly the default? ! 3089: { ! 3090: LMSetDefVRefNum( vcb->vcbVRefNum ); ! 3091: } ! 3092: #else ! 3093: #pragma unused(vcb,driveNumber,ioRefNum,wdcbH) ! 3094: #endif /* TARGET_OS_MAC */ ! 3095: } ! 3096: ! 3097: ! 3098: //-------------------------------------------------------------------------------------- ! 3099: // Routine: SetVCBManEject ! 3100: // Input: VCB ptr ! 3101: // Called by: MountVol ! 3102: // Function: Sets or clears the manual-eject bit in the flags word of the input VCB ! 3103: // based on the type of the drive indicated by vcbDrvNum. All registers ! 3104: // are preserved. The manual-eject flag should only be changed at MountVol ! 3105: // time. ! 3106: //-------------------------------------------------------------------------------------- ! 3107: ! 3108: #if ( hasHFSManualEject ) ! 3109: ! 3110: static void SetVCBManEject(ExtendedVCB *vcb) ! 3111: { ! 3112: DrvQEl *driveQElementPtr; ! 3113: DrvSts *driveStatsPtr; ! 3114: short driverRefNum; ! 3115: OSErr err; ! 3116: ! 3117: // Find the drive queue element for this volume ! 3118: err = FindDrive( &driverRefNum, &driveQElementPtr, vcb->vcbDrvNum ); ! 3119: ! 3120: if (err) return; ! 3121: ! 3122: driveStatsPtr = (DrvSts*) ((Ptr) driveQElementPtr - offsetof(DrvSts, qLink)); ! 3123: ! 3124: if ( driveStatsPtr->installed & (1 << kdqManualEjectBit) ) // manual eject drive asserted? ! 3125: vcb->vcbFlags |= vcbManualEjectMask; ! 3126: else ! 3127: vcb->vcbFlags &= ~vcbManualEjectMask; ! 3128: } ! 3129: ! 3130: #endif ! 3131: ! 3132: ! 3133: // ! 3134: // Simple utility function to deturmine if a keyboard key is pressed. ! 3135: // ! 3136: short IsPressed( UInt16 k ) // k = any keyboard scan code, 0-127 ! 3137: { ! 3138: #if TARGET_OS_MAC ! 3139: unsigned char km[16]; ! 3140: ! 3141: GetKeys( *( (KeyMap*) &km ) ); // Ugly casting to compile with MPWC & SC ! 3142: return ( ( km[k>>3] >> (k & 7) ) & 1); ! 3143: #else ! 3144: #pragma unused(k) ! 3145: return( 0 ); ! 3146: #endif /* TARGET_OS_MAC */ ! 3147: } ! 3148: ! 3149: ! 3150: #if TARGET_OS_MAC ! 3151: // ! 3152: // Utility function to allocate a new vRefNum. ! 3153: // This function cycles through all vRefNums, rather than reuse them. ! 3154: // ! 3155: FileReference GetNewVRefNum() ! 3156: { ! 3157: FileReference refNum; ! 3158: ExtendedVCB *tempVCB; ! 3159: OSErr err = noErr; ! 3160: ! 3161: #if (0) // See bug 1664445 ! 3162: { ! 3163: FSVarsRec *fsVars; ! 3164: ! 3165: fsVars = (FSVarsRec*)LMGetFSMVars(); ! 3166: for ( refNum = fsVars->nextVRefNum ; err == noErr ; refNum-- ) ! 3167: { ! 3168: if ( refNum >= 0x8001 ) // if we've cycled through all the possible vRef nums, start over ! 3169: refNum = -1; ! 3170: ! 3171: err = GetVCBRefNum( &tempVCB, refNum ); // Check if already assigned ! 3172: } ! 3173: ! 3174: fsVars->nextVRefNum = refNum; ! 3175: return( ++refNum ); // for loop post decrements ! 3176: } ! 3177: #else ! 3178: { ! 3179: for ( refNum = -1 ; err == noErr ; refNum-- ) ! 3180: { ! 3181: err = GetVCBRefNum( &tempVCB, refNum ); // Check if already assigned ! 3182: } ! 3183: return( ++refNum ); // for loop post decrements ! 3184: } ! 3185: #endif ! 3186: } ! 3187: #endif /* TARGET_OS_MAC */ ! 3188: ! 3189: //������������������������������������������������������������������������������� ! 3190: ! 3191: OSErr GetVolumeNameFromCatalog( ExtendedVCB *vcb ) ! 3192: { ! 3193: FSSpec spec; ! 3194: CatalogNodeData nodeData; ! 3195: UInt32 hint; ! 3196: OSErr err; ! 3197: #if TARGET_OS_MAC ! 3198: FSVarsRec *fsVars; ! 3199: ! 3200: fsVars = (FSVarsRec*) LMGetFSMVars(); ! 3201: if ( fsVars->gIsUnicodeInstalled ) ! 3202: #else ! 3203: if ( true ) ! 3204: #endif /*TARGET_OS_MAC */ ! 3205: { ! 3206: err = GetCatalogNode( vcb, kHFSRootFolderID, NULL, kNoHint, &spec, &nodeData, &hint ); ! 3207: ! 3208: if ( err == noErr ) ! 3209: { ! 3210: #if TARGET_OS_MAC ! 3211: BlockMoveData( spec.name, vcb->vcbVN, sizeof(Str27) ); ! 3212: #else ! 3213: vcb->vcbVN[0] = strlen(spec.name); ! 3214: BlockMoveData( spec.name, &vcb->vcbVN[1], sizeof(Str27)-1 ); ! 3215: #endif ! 3216: vcb->volumeNameEncodingHint = nodeData.textEncoding; // save encoding for FSFindTextEncodingForVolume ! 3217: } ! 3218: } ! 3219: else ! 3220: { ! 3221: err = paramErr; ! 3222: } ! 3223: ! 3224: return err; ! 3225: } ! 3226:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.