![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_vfsutils.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / hfs|
Return to hfs_vfsutils.c CVS log | Up to [Apple XNU] / XNU / bsd / hfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* @(#)hfs_vfsutils.c 4.0 ! 23: * ! 24: * (c) 1997-2000 Apple Computer, Inc. All Rights Reserved ! 25: * ! 26: * hfs_vfsutils.c -- Routines that go between the HFS layer and the VFS. ! 27: * ! 28: * Change History (most recent first): ! 29: * ! 30: * 22-Jan-2000 Don Brady Remove calls to MountCheck. ! 31: * 7-Sep-1999 Don Brady Add HFS Plus hard-link support. ! 32: * 25-Aug-1999 Don Brady Dont't use vcbAlBlSt for HFS plus volumes (2350009). ! 33: * 9-Aug-1999 Pat Dirks Added support for ATTR_VOL_ENCODINGSUSED [#2357367]. ! 34: * 16-Jul-1999 Pat Dirks Fixed PackCommonCatalogInfoAttributeBlock to return full range of possible vnode types [#2317604] ! 35: * 15-Jun-1999 Pat Dirks Added support for return of mounted device in hfs_getattrlist [#2345297]. ! 36: * 9-Jun-1999 Don Brady Cleanup vcb accesses in hfs_MountHFSVolume. ! 37: * 3-Jun-1999 Don Brady Remove references to unused/legacy vcb fields (eg vcbXTClpSiz). ! 38: * 21-May-1999 Don Brady Add call to hfs_vinit in hfsGet to support mknod. ! 39: * 6-Apr-1999 Don Brady Fixed de-reference of NULL dvp in hfsGet. ! 40: * 22-Mar-1999 Don Brady Add support for UFS delete semantics. ! 41: * 1-Mar-1999 Scott Roberts Dont double MALLOC on long names. ! 42: * 23-Feb-1999 Pat Dirks Change incrementing of meta refcount to be done BEFORE lock is acquired. ! 43: * 2-Feb-1999 Pat Dirks For volume ATTR_CMN_SCRIPT use vcb->volumeNameEncodingHint instead of 0. ! 44: * 10-Mar-1999 Don Brady Removing obsolete code. ! 45: * 2-Feb-1999 Don Brady For volume ATTR_CMN_SCRIPT use vcb->volumeNameEncodingHint instead of 0. ! 46: * 18-Jan-1999 Pat Dirks Changed CopyCatalogToHFSNode to start with ACCESSPERMS instead of adding ! 47: * write access only for unlocked files (now handled via IMMUTABLE setting) ! 48: * 7-Dec-1998 Pat Dirks Changed PackCatalogInfoFileAttributeBlock to return proper I/O block size. ! 49: * 7-Dec-1998 Don Brady Pack the real text encoding instead of zero. ! 50: * 16-Dec-1998 Don Brady Use the root's crtime intead of vcb create time for getattrlist. ! 51: * 16-Dec-1998 Don Brady Use the root's crtime intead of vcb create time for getattrlist. ! 52: * 2-Dec-1998 Scott Roberts Copy the mdbVN correctly into the vcb. ! 53: * 3-Dec-1998 Pat Dirks Added support for ATTR_VOL_MOUNTFLAGS. ! 54: * 20-Nov-1998 Don Brady Add support for UTF-8 names. ! 55: * 18-Nov-1998 Pat Dirks Changed UnpackCommonAttributeBlock to call wait for hfs_chflags to update catalog entry when changing flags ! 56: * 13-Nov-1998 Pat Dirks Changed BestBlockSizeFit to try PAGE_SIZE only and skip check for MAXBSIZE. ! 57: * 10-Nov-1998 Pat Dirks Changed CopyCatalogToHFSNode to ensure consistency between lock flag and IMMUTABLE bits. ! 58: * 10-Nov-1998 Pat Dirks Added MapFileOffset(), LogicalBlockSize() and UpdateBlockMappingTable() routines. ! 59: * 18-Nov-1998 Pat Dirks Changed PackVolAttributeBlock to return proper logical block size ! 60: * for ATTR_VOL_IOBLOCKSIZE attribute. ! 61: * 3-Nov-1998 Umesh Vaishampayan Changes to deal with "struct timespec" ! 62: * change in the kernel. ! 63: * 23-Sep-1998 Don Brady In UnpackCommonAttributeBlock simplified setting of gid, uid and mode. ! 64: * 10-Nov-1998 Pat Dirks Added MapFileOffset(), LogicalBlockSize() and UpdateBlockMappingTable() routines. ! 65: * 17-Sep-1998 Pat Dirks Changed BestBlockSizeFit to try MAXBSIZE and PAGE_SIZE first. ! 66: * 8-Sep-1998 Don Brady Fix CopyVNodeToCatalogNode to use h_mtime for contentModDate (instead of h_ctime). ! 67: * 4-Sep-1998 Pat Dirks Added BestBlockSizeFit routine. ! 68: * 18-Aug-1998 Don Brady Change DEBUG_BREAK_MSG to a DBG_UTILS in MacToVFSError (radar #2262802). ! 69: * 30-Jun-1998 Don Brady Add calls to MacToVFSError to hfs/hfsplus mount routines (for radar #2249539). ! 70: * 22-Jun-1998 Don Brady Add more error cases to MacToVFSError; all HFS Common errors are negative. ! 71: * Changed hfsDelete to call DeleteFile for files. ! 72: * 4-Jun-1998 Pat Dirks Changed incorrect references to 'vcbAlBlkSize' to 'blockSize'; ! 73: * Added hfsCreateFileID. ! 74: * 4-Jun-1998 Don Brady Add hfsMoveRename to replace hfsMove and hfsRename. Use VPUT/VRELE macros ! 75: * instead of vput/vrele to catch bad ref counts. ! 76: * 28-May-1998 Pat Dirks Adjusted for change in definition of ATTR_CMN_NAME and removed ATTR_CMN_RAWDEVICE. ! 77: * 7-May-1998 Don Brady Added check for NULL vp to hfs_metafilelocking (radar #2233832). ! 78: * 24-Apr-1998 Pat Dirks Fixed AttributeBlockSize to return only length of variable attribute block. ! 79: * 4/21/1998 Don Brady Add SUPPORTS_MAC_ALIASES conditional (for radar #2225419). ! 80: * 4/21/1998 Don Brady Map cmNotEmpty errors to ENOTEMPTY (radar #2229259). ! 81: * 4/21/1998 Don Brady Fix up time/date conversions. ! 82: * 4/20/1998 Don Brady Remove course-grained hfs metadata locking. ! 83: * 4/18/1998 Don Brady Add VCB locking. ! 84: * 4/17/1998 Pat Dirks Fixed PackFileAttributeBlock to return more up-to-date EOF/PEOF info from vnode. ! 85: * 4/15/1998 Don Brady Add hasOverflowExtents and hfs_metafilelocking. Use ExtendBTreeFile instead ! 86: * of SetEndOfForkProc. Set forktype for system files. ! 87: * 4/14/1998 Deric Horn PackCatalogInfoAttributeBlock(), and related packing routines to ! 88: * pack attribute data given hfsCatalogInfo, without the objects vnode; ! 89: * 4/14/1998 Scott Roberts Add execute priviledges to all hfs objects. ! 90: * 4/9/1998 Don Brady Add MDB/VolumeHeader flushing to hfsUnmount; ! 91: * 4/8/1998 Don Brady Make sure vcbVRefNum field gets initialized (use MAKE_VREFNUM). ! 92: * 4/6/1998 Don Brady Removed calls to CreateVolumeCatalogCache (obsolete). ! 93: * 4/06/1998 Scott Roberts Added complex file support. ! 94: * 4/02/1998 Don Brady UpdateCatalogNode now takes parID and name as input. ! 95: * 3/31/1998 Don Brady Sync up with final HFSVolumes.h header file. ! 96: * 3/31/1998 Don Brady Check result from UFSToHFSStr to make sure hfs/hfs+ names are not greater ! 97: * than 31 characters. ! 98: * 3/30/1998 Don Brady In InitMetaFileVNode set VSYSTEM bit in vnode's v_flag. ! 99: * 3/26/1998 Don Brady Cleaned up hfs_MountXXX routines. Removed CloseBtreeFile and OpenBTreeFile. ! 100: * Simplified hfsUnmount (removed MacOS specific code). ! 101: * 3/17/1998 Don Brady AttributeBlockSize calculation did not account for the size field (4bytes). ! 102: * PackVolCommonAttributes and PackCommonAttributeBlock for ATTR_CMN_NAME ! 103: * were not setting up the name correctly. ! 104: * 3/17/1998 Don Brady Changed CreateCatalogNode interface to take kCatalogFolderNode and ! 105: * kCatalogFileNode as type input. Also, force MountCheck to always run. ! 106: * 12-nov-1997 Scott Roberts Initially created file. ! 107: * 17-Mar-98 ser Broke out and created CopyCatalogToHFSNode() ! 108: * ! 109: */ ! 110: #include <sys/param.h> ! 111: #include <sys/systm.h> ! 112: #include <sys/kernel.h> ! 113: #include <sys/malloc.h> ! 114: #include <sys/stat.h> ! 115: #include <sys/attr.h> ! 116: #include <sys/mount.h> ! 117: #include <sys/lock.h> ! 118: #include <kern/mapfs.h> ! 119: ! 120: #include "hfs.h" ! 121: #include "hfs_dbg.h" ! 122: ! 123: #include "hfscommon/headers/FileMgrInternal.h" ! 124: #include "hfscommon/headers/BTreesInternal.h" ! 125: #include "hfscommon/headers/HFSUnicodeWrappers.h" ! 126: ! 127: #define SUPPORTS_MAC_ALIASES 0 ! 128: #define kMaxSecsForFsync 5 ! 129: ! 130: #define BYPASSBLOCKINGOPTIMIZATION 0 ! 131: ! 132: #define kMaxLockedMetaBuffers 32 /* number of locked buffer caches to hold for meta data */ ! 133: ! 134: extern int (**hfs_vnodeop_p)(); ! 135: extern int (**hfs_specop_p)(); ! 136: extern int (**hfs_fifoop_p)(); ! 137: extern int count_lock_queue __P((void)); ! 138: ! 139: OSErr ValidMasterDirectoryBlock( HFSMasterDirectoryBlock *mdb ); ! 140: UInt16 DivUp( UInt32 byteRun, UInt32 blockSize ); ! 141: ! 142: /* Externs from vhash */ ! 143: extern void hfs_vhashins_sibling(dev_t dev, UInt32 nodeID, struct hfsnode *hp, struct hfsfilemeta **fm); ! 144: extern void hfs_vhashins(dev_t dev, UInt32 nodeID,struct hfsnode *hp); ! 145: extern struct vnode *hfs_vhashget(dev_t dev, UInt32 nodeID, UInt8 forkType); ! 146: ! 147: extern int hfs_vinit( struct mount *mntp, int (**specops)(), int (**fifoops)(), struct vnode **vpp); ! 148: extern int readlinknode(ExtendedVCB *vcb, hfsCatalogInfo *catInfo, UInt32 *nodeID); ! 149: ! 150: extern UInt16 CountRootFiles(ExtendedVCB *vcb); ! 151: extern OSErr GetVolumeNameFromCatalog(ExtendedVCB *vcb); ! 152: ! 153: static int InitMetaFileVNode(struct vnode *vp, off_t eof, u_long clumpSize, const HFSPlusExtentRecord extents, ! 154: HFSCatalogNodeID fileID, void * keyCompareProc); ! 155: ! 156: static void ReleaseMetaFileVNode(struct vnode *vp); ! 157: ! 158: void CopyCatalogToObjectMeta(struct hfsCatalogInfo *catalogInfo, struct vnode *vp, struct hfsfilemeta *fm); ! 159: void CopyCatalogToFCB(struct hfsCatalogInfo *catalogInfo, struct vnode *vp); ! 160: void hfs_set_metaname(char *name, struct hfsfilemeta *fm); ! 161: u_int32_t GetLogicalBlockSize(struct vnode *vp); ! 162: ! 163: /* BTree accessor routines */ ! 164: extern OSStatus GetBTreeBlock(FileReference vp, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block); ! 165: extern OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, ItemCount minBlockCount); ! 166: extern OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF); ! 167: extern OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options); ! 168: ! 169: ! 170: //******************************************************************************* ! 171: // Routine: hfs_MountHFSVolume ! 172: // ! 173: // ! 174: //******************************************************************************* ! 175: ! 176: OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb, ! 177: u_long sectors, struct proc *p) ! 178: { ! 179: ExtendedVCB *vcb = HFSTOVCB(hfsmp); ! 180: struct vnode *tmpvnode; ! 181: OSErr err; ! 182: HFSPlusExtentRecord extents; ! 183: DBG_FUNC_NAME("hfs_MountHFSVolume"); ! 184: DBG_PRINT_FUNC_NAME(); ! 185: ! 186: if (hfsmp == nil || mdb == nil) /* exit if bad paramater */ ! 187: return (EINVAL); ! 188: ! 189: err = ValidMasterDirectoryBlock( mdb ); /* make sure this is an HFS disk */ ! 190: if (err) ! 191: return MacToVFSError(err); ! 192: ! 193: /* don't mount volume if its dirty, it must be cleaned by fsck_hfs */ ! 194: if ((mdb->drAtrb & kHFSVolumeUnmountedMask) == 0) ! 195: return (EINVAL); ! 196: ! 197: /* ! 198: * The MDB seems OK: transfer info from it into VCB ! 199: * Note - the VCB starts out clear (all zeros) ! 200: * ! 201: */ ! 202: ! 203: DBG_ASSERT((hfsmp->hfs_raw_dev & 0xFFFF0000) == 0); ! 204: vcb->vcbVRefNum = MAKE_VREFNUM(hfsmp->hfs_raw_dev); ! 205: ! 206: vcb->vcbSigWord = mdb->drSigWord; ! 207: vcb->vcbCrDate = LocalToUTC(mdb->drCrDate); ! 208: vcb->vcbLsMod = LocalToUTC(mdb->drLsMod); ! 209: vcb->vcbAtrb = mdb->drAtrb; ! 210: vcb->vcbNmFls = mdb->drNmFls; ! 211: vcb->vcbVBMSt = mdb->drVBMSt; ! 212: vcb->nextAllocation = mdb->drAllocPtr; ! 213: vcb->totalBlocks = mdb->drNmAlBlks; ! 214: vcb->blockSize = mdb->drAlBlkSiz; ! 215: vcb->vcbClpSiz = mdb->drClpSiz; ! 216: vcb->vcbAlBlSt= mdb->drAlBlSt; ! 217: vcb->vcbNxtCNID = mdb->drNxtCNID; ! 218: vcb->freeBlocks = mdb->drFreeBks; ! 219: vcb->vcbVolBkUp = LocalToUTC(mdb->drVolBkUp); ! 220: vcb->vcbVSeqNum = mdb->drVSeqNum; ! 221: vcb->vcbWrCnt = mdb->drWrCnt; ! 222: vcb->vcbNmRtDirs = mdb->drNmRtDirs; ! 223: vcb->vcbFilCnt = mdb->drFilCnt; ! 224: vcb->vcbDirCnt = mdb->drDirCnt; ! 225: bcopy(mdb->drFndrInfo, vcb->vcbFndrInfo, sizeof(vcb->vcbFndrInfo)); ! 226: vcb->nextAllocation = mdb->drAllocPtr; ! 227: vcb->encodingsBitmap = 0; ! 228: vcb->vcbWrCnt++; /* Compensate for write of MDB on last flush */ ! 229: /* ! 230: * Copy the drVN field, which is a Pascal String to the vcb, which is a cstring ! 231: */ ! 232: ! 233: /* XXX need to supply real UTF-8 string! */ ! 234: bcopy( &mdb->drVN[1], vcb->vcbVN, mdb->drVN[0]); ! 235: vcb->vcbVN[mdb->drVN[0]] = '\0'; ! 236: ! 237: vcb->altIDSector = sectors - 2; ! 238: ! 239: // Initialize our dirID/nodePtr cache associated with this volume. ! 240: err = InitMRUCache( sizeof(UInt32), kDefaultNumMRUCacheBlocks, &(vcb->hintCachePtr) ); ! 241: ReturnIfError( err ); ! 242: ! 243: hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size); ! 244: ! 245: // XXX PPD: Should check here for hardware lock flag and set flags in VCB/MP appropriately ! 246: ! 247: ! 248: VCB_LOCK_INIT(vcb); ! 249: ! 250: /* ! 251: * Set up Extents B-tree vnode... ! 252: */ ! 253: err = GetInitializedVNode(hfsmp, &tmpvnode); ! 254: if (err) goto MtVolErr; ! 255: HFSToHFSPlusExtents(mdb->drXTExtRec, extents); ! 256: err = InitMetaFileVNode(tmpvnode, mdb->drXTFlSize, mdb->drXTClpSiz, extents, ! 257: kHFSExtentsFileID, CompareExtentKeys); ! 258: if (err) goto MtVolErr; ! 259: ! 260: /* ! 261: * Set up Catalog B-tree vnode... ! 262: */ ! 263: err = GetInitializedVNode(hfsmp, &tmpvnode); ! 264: if (err) goto MtVolErr; ! 265: HFSToHFSPlusExtents(mdb->drCTExtRec, extents); ! 266: err = InitMetaFileVNode(tmpvnode, mdb->drCTFlSize, mdb->drCTClpSiz, extents, ! 267: kHFSCatalogFileID, CompareCatalogKeys); ! 268: if (err) goto MtVolErr; ! 269: ! 270: /* mark the volume dirty (clear clean unmount bit) */ ! 271: vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask; ! 272: ! 273: /* ! 274: * all done with b-trees so we can unlock now... ! 275: */ ! 276: VOP_UNLOCK(vcb->catalogRefNum, 0, p); ! 277: VOP_UNLOCK(vcb->extentsRefNum, 0, p); ! 278: ! 279: err = noErr; ! 280: ! 281: if ( err == noErr ) ! 282: { ! 283: if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) // if the disk is not write protected ! 284: { ! 285: MarkVCBDirty( vcb ); // mark VCB dirty so it will be written ! 286: } ! 287: } ! 288: goto CmdDone; ! 289: ! 290: //-- Release any resources allocated so far before exiting with an error: ! 291: MtVolErr:; ! 292: ReleaseMetaFileVNode(vcb->catalogRefNum); ! 293: ReleaseMetaFileVNode(vcb->extentsRefNum); ! 294: ! 295: CmdDone:; ! 296: return( err ); ! 297: ! 298: } ! 299: ! 300: //******************************************************************************* ! 301: // Routine: hfs_MountHFSPlusVolume ! 302: // ! 303: // ! 304: //******************************************************************************* ! 305: ! 306: OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, ! 307: u_long embBlkOffset, u_long sectors, struct proc *p) ! 308: { ! 309: register ExtendedVCB *vcb; ! 310: HFSPlusForkData *fdp; ! 311: struct vnode *tmpvnode; ! 312: OSErr retval; ! 313: ! 314: if (hfsmp == nil || vhp == nil) /* exit if bad paramater */ ! 315: return (EINVAL); ! 316: ! 317: DBG_VFS(("hfs_MountHFSPlusVolume: signature=0x%x, version=%d, blockSize=%ld\n", vhp->signature, vhp->version, vhp->blockSize)); ! 318: ! 319: retval = ValidVolumeHeader(vhp); /* make sure this is an HFS Plus disk */ ! 320: if (retval) ! 321: return MacToVFSError(retval); ! 322: ! 323: /* don't mount a writable volume if its dirty, it must be cleaned by fsck_hfs */ ! 324: if (hfsmp->hfs_fs_ronly == 0 && (vhp->attributes & kHFSVolumeUnmountedMask) == 0) ! 325: return (EINVAL); ! 326: /* ! 327: * The VolumeHeader seems OK: transfer info from it into VCB ! 328: * Note - the VCB starts out clear (all zeros) ! 329: */ ! 330: vcb = HFSTOVCB(hfsmp); ! 331: ! 332: //DBG_ASSERT((hfsmp->hfs_raw_dev & 0xFFFF0000) == 0); ! 333: vcb->vcbVRefNum = MAKE_VREFNUM(hfsmp->hfs_raw_dev); ! 334: vcb->vcbSigWord = vhp->signature; ! 335: vcb->vcbCrDate = LocalToUTC(vhp->createDate); // NOTE: local time, not GMT! ! 336: vcb->vcbLsMod = vhp->modifyDate; ! 337: vcb->vcbAtrb = (UInt16) vhp->attributes; // VCB only uses lower 16 bits ! 338: vcb->vcbClpSiz = vhp->rsrcClumpSize; ! 339: vcb->vcbNxtCNID = vhp->nextCatalogID; ! 340: vcb->vcbVolBkUp = vhp->backupDate; ! 341: vcb->vcbWrCnt = vhp->writeCount; ! 342: vcb->vcbFilCnt = vhp->fileCount; ! 343: vcb->vcbDirCnt = vhp->folderCount; ! 344: ! 345: /* copy 32 bytes of Finder info */ ! 346: bcopy(vhp->finderInfo, vcb->vcbFndrInfo, sizeof(vhp->finderInfo)); ! 347: ! 348: vcb->vcbAlBlSt = 0; /* hfs+ allocation blocks start at first block of volume */ ! 349: vcb->vcbWrCnt++; /* compensate for write of Volume Header on last flush */ ! 350: ! 351: VCB_LOCK_INIT(vcb); ! 352: ! 353: /* Now fill in the Extended VCB info */ ! 354: vcb->nextAllocation = vhp->nextAllocation; ! 355: vcb->totalBlocks = vhp->totalBlocks; ! 356: vcb->freeBlocks = vhp->freeBlocks; ! 357: vcb->blockSize = vhp->blockSize; ! 358: vcb->checkedDate = vhp->checkedDate; ! 359: vcb->encodingsBitmap = vhp->encodingsBitmap; ! 360: ! 361: vcb->hfsPlusIOPosOffset = embBlkOffset * 512; ! 362: ! 363: vcb->altIDSector = embBlkOffset + sectors - 2; ! 364: ! 365: /* Update the logical block size in the mount struct (currently set up from the wrapper MDB) ! 366: using the new blocksize value: */ ! 367: hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size); ! 368: ! 369: // XXX PPD: Should check here for hardware lock flag and set flags in VCB/MP appropriately ! 370: // vcb->vcbAtrb |= kVolumeHardwareLockMask; // XXX this line for debugging only!!!! ! 371: ! 372: // Initialize our dirID/nodePtr cache associated with this volume. ! 373: retval = InitMRUCache( sizeof(UInt32), kDefaultNumMRUCacheBlocks, &(vcb->hintCachePtr) ); ! 374: if (retval != noErr) goto ErrorExit; ! 375: ! 376: /* ! 377: * Set up Extents B-tree vnode... ! 378: */ ! 379: retval = GetInitializedVNode(hfsmp, &tmpvnode); ! 380: if (retval) goto ErrorExit; ! 381: fdp = &vhp->extentsFile; ! 382: retval = InitMetaFileVNode(tmpvnode, fdp->logicalSize, fdp->clumpSize, fdp->extents, ! 383: kHFSExtentsFileID, CompareExtentKeysPlus); ! 384: if (retval) goto ErrorExit; ! 385: ! 386: /* ! 387: * Set up Catalog B-tree vnode... ! 388: */ ! 389: retval = GetInitializedVNode(hfsmp, &tmpvnode); ! 390: if (retval) goto ErrorExit; ! 391: fdp = &vhp->catalogFile; ! 392: retval = InitMetaFileVNode(tmpvnode, fdp->logicalSize, fdp->clumpSize, fdp->extents, ! 393: kHFSCatalogFileID, CompareExtendedCatalogKeys); ! 394: if (retval) goto ErrorExit; ! 395: ! 396: /* ! 397: * Set up Allocation file vnode... ! 398: */ ! 399: retval = GetInitializedVNode(hfsmp, &tmpvnode); ! 400: if (retval) goto ErrorExit; ! 401: fdp = &vhp->allocationFile; ! 402: retval = InitMetaFileVNode(tmpvnode, fdp->logicalSize, fdp->clumpSize, fdp->extents, ! 403: kHFSAllocationFileID, NULL); ! 404: if (retval) goto ErrorExit; ! 405: ! 406: /* ! 407: * Now that Catalog file is open get the volume name from the catalog ! 408: */ ! 409: retval = MacToVFSError( GetVolumeNameFromCatalog(vcb) ); ! 410: if (retval != noErr) goto ErrorExit; ! 411: ! 412: /* mark the volume dirty (clear clean unmount bit) */ ! 413: vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask; ! 414: ! 415: /* setup private/hidden directory for unlinked files */ ! 416: hfsmp->hfs_private_metadata_dir = FindMetaDataDirectory(vcb); ! 417: ! 418: /* ! 419: * all done with metadata files so we can unlock now... ! 420: */ ! 421: VOP_UNLOCK(vcb->allocationsRefNum, 0, p); ! 422: VOP_UNLOCK(vcb->catalogRefNum, 0, p); ! 423: VOP_UNLOCK(vcb->extentsRefNum, 0, p); ! 424: ! 425: if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) // if the disk is not write protected ! 426: { ! 427: MarkVCBDirty( vcb ); // mark VCB dirty so it will be written ! 428: } ! 429: ! 430: DBG_VFS(("hfs_MountHFSPlusVolume: returning (%d)\n", retval)); ! 431: ! 432: return (0); ! 433: ! 434: ! 435: ErrorExit: ! 436: /* ! 437: * A fatal error occured and the volume cannot be mounted ! 438: * release any resources that we aquired... ! 439: */ ! 440: ! 441: DBG_VFS(("hfs_MountHFSPlusVolume: fatal error (%d)\n", retval)); ! 442: ! 443: InvalidateCatalogCache(vcb); ! 444: ! 445: ReleaseMetaFileVNode(vcb->allocationsRefNum); ! 446: ReleaseMetaFileVNode(vcb->catalogRefNum); ! 447: ReleaseMetaFileVNode(vcb->extentsRefNum); ! 448: ! 449: return (retval); ! 450: } ! 451: ! 452: ! 453: /* ! 454: * ReleaseMetaFileVNode ! 455: * ! 456: * vp L - - ! 457: */ ! 458: static void ReleaseMetaFileVNode(struct vnode *vp) ! 459: { ! 460: if (vp) ! 461: { ! 462: FCB *fcb = VTOFCB(vp); ! 463: ! 464: if (fcb->fcbBTCBPtr != NULL) ! 465: (void) BTClosePath(fcb); /* ignore errors since there is only one path open */ ! 466: ! 467: /* release the node even if BTClosePath fails */ ! 468: if (VOP_ISLOCKED(vp)) ! 469: VPUT(vp); ! 470: else ! 471: VRELE(vp); ! 472: } ! 473: } ! 474: ! 475: ! 476: /* ! 477: * InitMetaFileVNode ! 478: * ! 479: * vp U L L ! 480: */ ! 481: static int InitMetaFileVNode(struct vnode *vp, off_t eof, u_long clumpSize, const HFSPlusExtentRecord extents, ! 482: HFSCatalogNodeID fileID, void * keyCompareProc) ! 483: { ! 484: FCB *fcb; ! 485: ExtendedVCB *vcb; ! 486: int result = 0; ! 487: ! 488: DBG_ASSERT(vp != NULL); ! 489: DBG_ASSERT(vp->v_data != NULL); ! 490: ! 491: vcb = VTOVCB(vp); ! 492: fcb = VTOFCB(vp); ! 493: ! 494: switch (fileID) ! 495: { ! 496: case kHFSExtentsFileID: ! 497: vcb->extentsRefNum = vp; ! 498: break; ! 499: ! 500: case kHFSCatalogFileID: ! 501: vcb->catalogRefNum = vp; ! 502: break; ! 503: ! 504: case kHFSAllocationFileID: ! 505: vcb->allocationsRefNum = vp; ! 506: break; ! 507: ! 508: default: ! 509: panic("InitMetaFileVNode: invalid fileID!"); ! 510: } ! 511: ! 512: fcb->fcbEOF = eof; ! 513: fcb->fcbPLen = eof; ! 514: fcb->fcbClmpSize = clumpSize; ! 515: H_FILEID(VTOH(vp)) = fileID; ! 516: H_DIRID(VTOH(vp)) = kHFSRootParentID; ! 517: H_FORKTYPE(VTOH(vp)) = kSysFile; ! 518: ! 519: bcopy(extents, fcb->fcbExtents, sizeof(HFSPlusExtentRecord)); ! 520: ! 521: /* ! 522: * Lock the hfsnode and insert the hfsnode into the hash queue: ! 523: */ ! 524: hfs_vhashins(H_DEV(VTOH(vp)), fileID, VTOH(vp)); ! 525: vp->v_flag |= VSYSTEM; /* tag our metadata files (used by vflush call) */ ! 526: ! 527: if (keyCompareProc != NULL) { ! 528: result = BTOpenPath(fcb, ! 529: (KeyCompareProcPtr) keyCompareProc, ! 530: GetBTreeBlock, ! 531: ReleaseBTreeBlock, ! 532: ExtendBTreeFile, ! 533: SetBTreeBlockSize); ! 534: result = MacToVFSError(result); ! 535: } ! 536: ! 537: return (result); ! 538: } ! 539: ! 540: ! 541: /************************************************************* ! 542: * ! 543: * Unmounts a hfs volume. ! 544: * At this point vflush() has been called (to dump all non-metadata files) ! 545: * ! 546: *************************************************************/ ! 547: ! 548: short hfsUnmount( register struct hfsmount *hfsmp, struct proc *p) ! 549: { ! 550: ExtendedVCB *vcb = HFSTOVCB(hfsmp); ! 551: int retval = E_NONE; ! 552: ! 553: (void) DisposeMRUCache(vcb->hintCachePtr); ! 554: InvalidateCatalogCache( vcb ); ! 555: // XXX PPD: Should dispose of any allocated volume cache here: call DisposeVolumeCacheBlocks( vcb )? ! 556: ! 557: (void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, p); ! 558: (void) hfs_metafilelocking(hfsmp, kHFSExtentsFileID, LK_EXCLUSIVE, p); ! 559: ! 560: if (vcb->vcbSigWord == kHFSPlusSigWord) ! 561: ReleaseMetaFileVNode(vcb->allocationsRefNum); ! 562: ! 563: ReleaseMetaFileVNode(vcb->catalogRefNum); ! 564: ReleaseMetaFileVNode(vcb->extentsRefNum); ! 565: ! 566: return (retval); ! 567: } ! 568: ! 569: ! 570: /* ! 571: * Performs a lookup on the given dirID, name. Returns the catalog info ! 572: * ! 573: * If len is -1, then it is a null terminated string, pass it along to MacOS as kUndefinedStrLen ! 574: */ ! 575: ! 576: short hfsLookup (ExtendedVCB *vcb, UInt32 parentDirID, char *name, short len, hfsCatalogInfo *catInfo) ! 577: { ! 578: OSErr result; ! 579: UInt32 length; ! 580: struct FInfo *fip; ! 581: ! 582: if (len == -1 ) { /* Convert it to MacOS terms */ ! 583: if (name) ! 584: length = strlen(name); ! 585: else ! 586: length = kUndefinedStrLen; ! 587: } ! 588: else ! 589: length = len; ! 590: ! 591: result = GetCatalogNode(vcb, parentDirID, name, length, catInfo->hint, &catInfo->spec, &catInfo->nodeData, &catInfo->hint); ! 592: ! 593: #if HFS_HARDLINKS ! 594: if (result) ! 595: goto exit; ! 596: ! 597: fip = (struct FInfo *) &catInfo->nodeData.cnd_finderInfo; ! 598: ! 599: /* ! 600: * if we encounter a link node (hardlink) then auto resolve it... ! 601: */ ! 602: if ((catInfo->nodeData.cnd_type == kCatalogFileNode) && ! 603: (fip->fdType == kHardLinkFileType) && ! 604: (fip->fdCreator == kHardLinkCreator) && ! 605: (fip->fdFlags & kIsAlias) ! 606: ) { ! 607: FSSpec nodeSpec; ! 608: UInt32 dataNodeID; ! 609: ! 610: result = readlinknode(vcb, catInfo, &dataNodeID); ! 611: if (result) ! 612: goto exit; ! 613: /* ! 614: * Get nodeData from the data node file. ! 615: * Use a local spec so that catInfo->spec is preserved ! 616: */ ! 617: result = GetCatalogNode(vcb, dataNodeID, NULL, 0, 0, &nodeSpec, &catInfo->nodeData, &catInfo->hint); ! 618: ! 619: /* make sure there's at lease 1 reference */ ! 620: if (result == 0) { ! 621: if (catInfo->nodeData.cnd_linkCount == 0) ! 622: catInfo->nodeData.cnd_linkCount = 1; ! 623: ! 624: /* Node should be in private metadata dir */ ! 625: DBG_ASSERT(nodeSpec.parID == VCBTOHFS(vcb)->hfs_private_metadata_dir); ! 626: } ! 627: } ! 628: ! 629: exit: ! 630: #endif ! 631: ! 632: if (result) ! 633: DBG_ERR(("on Lookup, GetCatalogNode returned: %d: dirid: %ld name: %s\n", result, parentDirID, name)); ! 634: ! 635: return MacToVFSError(result); ! 636: } ! 637: ! 638: ! 639: ! 640: short hfsDelete (ExtendedVCB *vcb, UInt32 parentDirID, StringPtr name, short isfile, UInt32 catalogHint) ! 641: { ! 642: OSErr result = noErr; ! 643: ! 644: /* XXX have all the file's blocks been flushed/trashed? */ ! 645: ! 646: /* ! 647: * DeleteFile will delete the catalog node and then ! 648: * free up any disk space used by the file. ! 649: */ ! 650: if (isfile) ! 651: result = DeleteFile(vcb, parentDirID, name, catalogHint); ! 652: else /* is a directory */ ! 653: result = DeleteCatalogNode(vcb, parentDirID, name, catalogHint); ! 654: ! 655: if (result) ! 656: DBG_ERR(("on Delete, DeleteFile returned: %d: dirid: %ld name: %s\n", result, parentDirID, name)); ! 657: ! 658: return MacToVFSError(result); ! 659: } ! 660: ! 661: ! 662: short hfsMoveRename (ExtendedVCB *vcb, UInt32 oldDirID, char *oldName, UInt32 newDirID, char *newName, UInt32 *hint) ! 663: { ! 664: OSErr result = noErr; ! 665: ! 666: result = MoveRenameCatalogNode(vcb, oldDirID,oldName, *hint, newDirID, newName, hint); ! 667: ! 668: if (result) ! 669: DBG_ERR(("on hfsMoveRename, MoveRenameCatalogNode returned: %d: newdirid: %ld newname: %s\n", result, newDirID, newName)); ! 670: ! 671: ! 672: return MacToVFSError(result); ! 673: } ! 674: ! 675: /* XXX SER pass back the hint so other people can use it */ ! 676: ! 677: ! 678: short hfsCreate(ExtendedVCB *vcb, UInt32 dirID, char *name, int mode) ! 679: { ! 680: OSErr result = noErr; ! 681: HFSCatalogNodeID catalogNodeID; ! 682: UInt32 catalogHint; ! 683: UInt32 type; ! 684: ! 685: /* just test for directories, the default is to create a file (like symlinks) */ ! 686: if ((mode & IFMT) == IFDIR) ! 687: type = kCatalogFolderNode; ! 688: else ! 689: type = kCatalogFileNode; ! 690: ! 691: result = CreateCatalogNode (vcb, dirID, name, type, &catalogNodeID, &catalogHint); ! 692: ! 693: return MacToVFSError(result); ! 694: } ! 695: ! 696: ! 697: short hfsCreateFileID (ExtendedVCB *vcb, UInt32 parentDirID, StringPtr name, UInt32 catalogHint, UInt32 *fileIDPtr) ! 698: { ! 699: return MacToVFSError(CreateFileIDRef(vcb, parentDirID, name, catalogHint, fileIDPtr)); ! 700: } ! 701: ! 702: ! 703: /********************************************************************************/ ! 704: /* */ ! 705: /* hfs_vget_catinfo - Returns a vnode derived from a hfs catInfo struct */ ! 706: /* */ ! 707: /********************************************************************************/ ! 708: ! 709: int hfs_vget_catinfo(struct vnode *parent_vp, struct hfsCatalogInfo *catInfo, u_int32_t forkType, struct vnode **target_vp) ! 710: { ! 711: int retval = E_NONE; ! 712: ! 713: ! 714: *target_vp = hfs_vhashget(H_DEV(VTOH(parent_vp)), catInfo->nodeData.cnd_nodeID, forkType); ! 715: ! 716: if (*target_vp == NULL) { ! 717: if (forkType == kAnyFork) ! 718: if (catInfo->nodeData.cnd_type == kCatalogFolderNode) ! 719: forkType = kDirectory; ! 720: else ! 721: forkType = kDataFork; ! 722: ! 723: retval = hfs_vcreate( VTOVCB(parent_vp), catInfo, forkType, target_vp); ! 724: }; ! 725: ! 726: return (retval); ! 727: } ! 728: ! 729: ! 730: ! 731: /********************************************************************************/ ! 732: /* */ ! 733: /* hfs_vget_fork - Returns a vnode derived from a sibling */ ! 734: /* vp is locked */ ! 735: /* */ ! 736: /********************************************************************************/ ! 737: ! 738: int hfs_vget_sibling(struct vnode *vp, u_int16_t forkType, struct vnode **vpp) ! 739: { ! 740: struct vnode * target_vp = NULL; ! 741: int retval = E_NONE; ! 742: ! 743: ! 744: DBG_ASSERT(vp != NULL); ! 745: DBG_ASSERT(VTOH(vp) != NULL); ! 746: DBG_ASSERT(VTOH(vp)->h_meta != NULL); ! 747: DBG_ASSERT(forkType==kDataFork || forkType==kRsrcFork); ! 748: ! 749: target_vp = hfs_vhashget(H_DEV(VTOH(vp)), H_FILEID(VTOH(vp)), forkType); ! 750: ! 751: /* ! 752: * If not in the hash, then we have to create it ! 753: */ ! 754: if (target_vp == NULL) { ! 755: struct proc *p = current_proc(); ! 756: hfsCatalogInfo catInfo; ! 757: ! 758: /* lock catalog b-tree */ ! 759: retval = hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_SHARED, p); ! 760: if (retval) ! 761: goto Err_Exit; ! 762: ! 763: catInfo.hint = H_HINT(VTOH(vp)); ! 764: retval = hfsLookup (VTOVCB(vp), H_DIRID(VTOH(vp)), H_NAME(VTOH(vp)), VTOH(vp)->h_meta->h_namelen, &catInfo); ! 765: ! 766: /* unlock catalog b-tree */ ! 767: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, p); ! 768: if (retval) ! 769: goto Err_Exit; ! 770: ! 771: retval = hfs_vcreate( VTOVCB(vp), &catInfo, forkType, &target_vp); ! 772: }; ! 773: ! 774: Err_Exit: ! 775: ! 776: if (!retval) { ! 777: DBG_ASSERT(target_vp!=NULL); ! 778: } else { ! 779: DBG_ASSERT(target_vp==NULL); ! 780: } ! 781: ! 782: *vpp = target_vp; ! 783: return (retval); ! 784: } ! 785: ! 786: ! 787: /************************************************************************/ ! 788: /* hfs_vcreate - Returns a vnode derived from hfs */ ! 789: /* */ ! 790: /* When creating the vnode, care must be made to set the */ ! 791: /* correct fields in the correct order. Calls to malloc() */ ! 792: /* and other subroutines, can cause a context switch, */ ! 793: /* and the fields must be ready for the possibility */ ! 794: /* */ ! 795: /* */ ! 796: /************************************************************************/ ! 797: ! 798: short hfs_vcreate(ExtendedVCB *vcb, hfsCatalogInfo *catInfo, UInt8 forkType, struct vnode **vpp) ! 799: { ! 800: struct hfsnode *hp; ! 801: struct vnode *vp; ! 802: struct hfsmount *hfsmp; ! 803: struct hfsfilemeta *fm; ! 804: struct mount *mp; ! 805: struct vfsFCB *xfcb; ! 806: dev_t dev; ! 807: short retval; ! 808: ! 809: #if HFS_DIAGNOSTIC ! 810: DBG_ASSERT(vcb != NULL); ! 811: DBG_ASSERT(catInfo != NULL); ! 812: DBG_ASSERT(vpp != NULL); ! 813: DBG_ASSERT((forkType == kDirectory) || (forkType == kDataFork) || (forkType == kRsrcFork)); ! 814: if (catInfo->nodeData.cnd_type == kCatalogFolderNode) { ! 815: DBG_ASSERT(forkType == kDirectory); ! 816: } else { ! 817: DBG_ASSERT(forkType != kDirectory); ! 818: } ! 819: #endif ! 820: ! 821: hfsmp = VCBTOHFS(vcb); ! 822: mp = HFSTOVFS(hfsmp); ! 823: dev = hfsmp->hfs_raw_dev; ! 824: ! 825: /* Check if unmount in progress */ ! 826: if (mp->mnt_flag & MNT_UNMOUNT) { ! 827: return (EPERM); ! 828: } ! 829: DBG_UTILS(("\thfs_vcreate: On '%s' with forktype of %d, nodeType of 0x%08lX\n", catInfo->spec.name, forkType, (unsigned long)catInfo->nodeData.cnd_type)); ! 830: ! 831: /* Must malloc() here, since getnewvnode() can sleep */ ! 832: MALLOC(hp, struct hfsnode *, sizeof(struct hfsnode), M_HFSNODE, M_WAITOK); ! 833: bzero((caddr_t)hp, sizeof(struct hfsnode)); ! 834: ! 835: /* ! 836: * Set that this node is in the process of being allocated ! 837: * Set it as soon as possible, so context switches well always hit upon it. ! 838: * if this is set then wakeup() MUST be called on hp after the flag is cleared ! 839: * DO NOT exit without clearing and waking up !!!! ! 840: */ ! 841: hp->h_nodeflags |= IN_ALLOCATING; /* Mark this as being allocating */ ! 842: lockinit(&hp->h_lock, PINOD, "hfsnode", 0, 0); ! 843: ! 844: ! 845: /* getnewvnode() does a VREF() on the vnode */ ! 846: /* Allocate a new vnode. If unsuccesful, leave after freeing memory */ ! 847: if ((retval = getnewvnode(VT_HFS, mp, hfs_vnodeop_p, &vp))) { ! 848: wakeup(hp); /* Shouldnt happen, but just to make sure */ ! 849: FREE (hp, M_HFSNODE); ! 850: *vpp = NULL; ! 851: return (retval); ! 852: }; ! 853: ! 854: /* ! 855: * Set the essentials before locking it down ! 856: */ ! 857: hp->h_vp = vp; /* Make HFSTOV work */ ! 858: vp->v_data = hp; /* Make VTOH work */ ! 859: H_FORKTYPE(hp) = forkType; ! 860: fm = NULL; ! 861: ! 862: /* ! 863: * Lock the hfsnode and insert the hfsnode into the hash queue, also if meta exists ! 864: * add to sibling list and return the meta address ! 865: */ ! 866: if (SIBLING_FORKTYPE(forkType)) ! 867: hfs_vhashins_sibling(dev, catInfo->nodeData.cnd_nodeID, hp, &fm); ! 868: else ! 869: hfs_vhashins(dev, catInfo->nodeData.cnd_nodeID, hp); ! 870: ! 871: /* ! 872: * If needed allocate and init the object meta data: ! 873: */ ! 874: if (fm == NULL) { ! 875: /* Allocate it....remember we can do a context switch here */ ! 876: MALLOC(fm, struct hfsfilemeta *, sizeof(struct hfsfilemeta), M_HFSFMETA, M_WAITOK); ! 877: bzero(fm, sizeof(struct hfsfilemeta)); ! 878: ! 879: /* Fill it in */ ! 880: /* ! 881: * NOTICE: XXX Even though we have added the vnode to the hash so it is alive on TWO ! 882: * accessable lists, we do not assign it until later, ! 883: * this helps to make sure we do not use a half initiated meta ! 884: */ ! 885: ! 886: /* Init the sibling list if needed */ ! 887: if (SIBLING_FORKTYPE(forkType)) { ! 888: simple_lock_init(&fm->h_siblinglock); ! 889: CIRCLEQ_INIT(&fm->h_siblinghead); ! 890: CIRCLEQ_INSERT_HEAD(&fm->h_siblinghead, hp, h_sibling); ! 891: }; ! 892: ! 893: simple_lock_init(&fm->h_metalock); ! 894: fm->h_dev = dev; ! 895: CopyCatalogToObjectMeta(catInfo, vp, fm); ! 896: ! 897: /* ! 898: * the vnode is finally alive, with the exception of the FCB below, ! 899: * It is finally locked and ready for its debutante ball ! 900: */ ! 901: hp->h_meta = fm; ! 902: }; ! 903: fm->h_usecount++; ! 904: ! 905: ! 906: /* ! 907: * Init the File Control Block. ! 908: */ ! 909: CopyCatalogToFCB(catInfo, vp); ! 910: if (forkType != kDirectory) ! 911: UpdateBlockMappingTable(hp); ! 912: ! 913: /* ! 914: * Finish vnode initialization. ! 915: * Setting the v_type 'stamps' the vnode as 'complete', so should be done almost last. ! 916: * ! 917: * At this point the vnode should be locked and fully allocated. And ready to be used ! 918: * or accessed. (though having it locked prevents most of this, it ! 919: * can still be accessed through lists and hashs). ! 920: */ ! 921: vp->v_type = IFTOVT(hp->h_meta->h_mode); ! 922: ! 923: /* ! 924: * Initialize the vnode from the inode, check for aliases, sets the VROOT flag. ! 925: * Note that the underlying vnode may have changed. ! 926: */ ! 927: if ((retval = hfs_vinit(mp, hfs_specop_p, hfs_fifoop_p, &vp))) { ! 928: wakeup((caddr_t)hp); ! 929: vput(vp); ! 930: *vpp = NULL; ! 931: return (retval); ! 932: } ! 933: ! 934: /* ! 935: * Finish inode initialization now that aliasing has been resolved. ! 936: */ ! 937: hp->h_meta->h_devvp = hfsmp->hfs_devvp; ! 938: VREF(hp->h_meta->h_devvp); ! 939: ! 940: hp->h_valid = HFS_VNODE_MAGIC; ! 941: hp->h_nodeflags &= ~IN_ALLOCATING; /* vnode is completely initialized */ ! 942: ! 943: /* Wake up anybody waiting for us to finish..see hfs_vhash.c */ ! 944: wakeup((caddr_t)hp); ! 945: ! 946: #if HFS_DIAGNOSTIC ! 947: ! 948: /* Lets do some testing here */ ! 949: DBG_ASSERT(hp->h_meta); ! 950: DBG_ASSERT(VTOH(vp)==hp); ! 951: DBG_ASSERT(HTOV(hp)==vp); ! 952: DBG_ASSERT(hp->h_meta->h_usecount>=1 && hp->h_meta->h_usecount<=2); ! 953: if (catInfo->nodeData.cnd_type == kCatalogFolderNode) { ! 954: DBG_ASSERT(vp->v_type == VDIR); ! 955: DBG_ASSERT(H_FORKTYPE(VTOH(vp)) == kDirectory); ! 956: } ! 957: #endif // HFS_DIAGNOSTIC ! 958: ! 959: ! 960: *vpp = vp; ! 961: return 0; ! 962: ! 963: } ! 964: ! 965: void CopyCatalogToObjectMeta(struct hfsCatalogInfo *catalogInfo, struct vnode *vp, struct hfsfilemeta *fm) ! 966: { ! 967: ExtendedVCB *vcb = VTOVCB(vp); ! 968: Boolean isHFSPlus, isDirectory; ! 969: ushort finderFlags; ! 970: ! 971: DBG_ASSERT (fm != NULL); ! 972: DBG_UTILS(("\tCopying to file's meta data: name:%s, nodeid:%ld\n", catalogInfo->spec.name, catalogInfo->nodeData.cnd_nodeID)); ! 973: ! 974: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord); ! 975: isDirectory = (catalogInfo->nodeData.cnd_type == kCatalogFolderNode); ! 976: finderFlags = ((struct FInfo *)(&catalogInfo->nodeData.cnd_finderInfo))->fdFlags; ! 977: ! 978: /* Copy over the dirid, and hint */ ! 979: fm->h_nodeID = catalogInfo->nodeData.cnd_nodeID; ! 980: fm->h_dirID = catalogInfo->spec.parID; ! 981: fm->h_hint = catalogInfo->hint; ! 982: ! 983: /* Copy over the name */ ! 984: hfs_set_metaname(catalogInfo->spec.name, fm); ! 985: DBG_ASSERT (fm->h_namelen == strlen(catalogInfo->spec.name)); ! 986: DBG_ASSERT (strcmp(fm->h_namePtr, catalogInfo->spec.name) == 0); ! 987: ! 988: ! 989: /* get dates in BSD format */ ! 990: fm->h_mtime = to_bsd_time(catalogInfo->nodeData.cnd_contentModDate); ! 991: fm->h_crtime = to_bsd_time(catalogInfo->nodeData.cnd_createDate); ! 992: fm->h_butime = to_bsd_time(catalogInfo->nodeData.cnd_backupDate); ! 993: if (isHFSPlus) { ! 994: fm->h_atime = to_bsd_time(catalogInfo->nodeData.cnd_accessDate); ! 995: fm->h_ctime = to_bsd_time(catalogInfo->nodeData.cnd_attributeModDate); ! 996: } ! 997: else { ! 998: fm->h_atime = to_bsd_time(catalogInfo->nodeData.cnd_contentModDate); ! 999: fm->h_ctime = to_bsd_time(catalogInfo->nodeData.cnd_contentModDate); ! 1000: } ! 1001: ! 1002: /* Now the rest */ ! 1003: if (isHFSPlus && (catalogInfo->nodeData.cnd_permissions & IFMT)) { ! 1004: fm->h_uid = catalogInfo->nodeData.cnd_ownerID; ! 1005: fm->h_gid = catalogInfo->nodeData.cnd_groupID; ! 1006: /* The 32-bit permissions field is unpacked to yield the two significant bytes of flags and the ! 1007: mode as follows: ! 1008: +------------------------------------+ ! 1009: permissions: | A | B | mode | ! 1010: +------------------------------------+ ! 1011: | ! 1012: V ! 1013: +------------------------------------+ ! 1014: fm->h_pflags: |XXXXXXXX| A |XXXXXXXX| B | ! 1015: +------------------------------------+ ! 1016: ! 1017: */ ! 1018: fm->h_pflags = (((catalogInfo->nodeData.cnd_permissions & 0xFF000000) >> 8) | /* A */ ! 1019: ((catalogInfo->nodeData.cnd_permissions & 0x00FF0000) >> 16)); /* B */ ! 1020: fm->h_mode = (mode_t)(catalogInfo->nodeData.cnd_permissions & 0x0000FFFF); ! 1021: fm->h_rdev = catalogInfo->nodeData.cnd_specialDevice; ! 1022: ! 1023: #if HFS_HARDLINKS ! 1024: if (catalogInfo->nodeData.cnd_type == kCatalogFileNode && ! 1025: catalogInfo->nodeData.cnd_linkCount > 0) { ! 1026: fm->h_nlink = catalogInfo->nodeData.cnd_linkCount; ! 1027: fm->h_metaflags |= IN_DATANODE; ! 1028: } ! 1029: #endif ! 1030: } else { ! 1031: /* ! 1032: * Set the permissions as determined by the mount auguments ! 1033: * but keep in account if the file or folder is hfs locked ! 1034: */ ! 1035: fm->h_metaflags |= IN_UNSETACCESS; ! 1036: fm->h_uid = VTOHFS(vp)->hfs_uid; ! 1037: fm->h_gid = VTOHFS(vp)->hfs_gid; ! 1038: /* Default access is full read/write/execute: */ ! 1039: fm->h_mode = ACCESSPERMS; /* 0777: rwxrwxrwx */ ! 1040: ! 1041: /* ... but no more than that permitted by the mount point's: */ ! 1042: if (isDirectory) { ! 1043: fm->h_mode &= VTOHFS(vp)->hfs_dir_mask; ! 1044: } ! 1045: else { ! 1046: fm->h_mode &= VTOHFS(vp)->hfs_file_mask; ! 1047: } ! 1048: ! 1049: if(isDirectory) ! 1050: fm->h_mode |= IFDIR; ! 1051: else if (SUPPORTS_MAC_ALIASES && (finderFlags & kIsAlias)) /* aliases will be symlinks in the future */ ! 1052: fm->h_mode |= IFLNK; ! 1053: else ! 1054: fm->h_mode |= IFREG; ! 1055: ! 1056: }; ! 1057: ! 1058: /* Make sure that there is no nodeType/mode mismatch */ ! 1059: if (isDirectory && ((fm->h_mode & IFMT) != IFDIR)) { ! 1060: fm->h_mode &= ~IFMT; /* Clear the bad bits */ ! 1061: fm->h_mode |= IFDIR; /* Set the proper one */ ! 1062: }; ! 1063: ! 1064: /* Make sure the IMMUTABLE bits are in sync with the locked flag in the catalog: */ ! 1065: if (!isDirectory) { ! 1066: if (catalogInfo->nodeData.cnd_flags & kHFSFileLockedMask) { ! 1067: /* The file's supposed to be locked: ! 1068: Make sure at least one of the IMMUTABLE bits is set: */ ! 1069: if ((fm->h_pflags & (SF_IMMUTABLE | UF_IMMUTABLE)) == 0) { ! 1070: fm->h_pflags |= UF_IMMUTABLE; /* Set the user-changable IMMUTABLE bit */ ! 1071: }; ! 1072: } else { ! 1073: /* The file's supposed to be unlocked: */ ! 1074: fm->h_pflags &= ~(SF_IMMUTABLE | UF_IMMUTABLE); ! 1075: }; ! 1076: }; ! 1077: ! 1078: if (isDirectory) { ! 1079: fm->h_valence = catalogInfo->nodeData.cnd_valence; ! 1080: fm->h_size = (2 * sizeof(hfsdotentry)) + ! 1081: (catalogInfo->nodeData.cnd_valence * AVERAGE_HFSDIRENTRY_SIZE); ! 1082: if (fm->h_size < MAX_HFSDIRENTRY_SIZE) ! 1083: fm->h_size = MAX_HFSDIRENTRY_SIZE; ! 1084: } else { ! 1085: fm->h_size = vcb->blockSize * ! 1086: (catalogInfo->nodeData.cnd_rsrcfork.totalBlocks + ! 1087: catalogInfo->nodeData.cnd_datafork.totalBlocks); ! 1088: } ! 1089: } ! 1090: ! 1091: ! 1092: void CopyCatalogToFCB(struct hfsCatalogInfo *catalogInfo, struct vnode *vp) ! 1093: { ! 1094: FCB *fcb = VTOFCB(vp); ! 1095: ExtendedVCB *vcb = VTOVCB(vp); ! 1096: Boolean isHFSPlus, isDirectory, isResource; ! 1097: HFSPlusExtentDescriptor *extents; ! 1098: UInt8 forkType; ! 1099: ! 1100: DBG_ASSERT (vp != NULL); ! 1101: DBG_ASSERT (fcb != NULL); ! 1102: DBG_ASSERT (vcb != NULL); ! 1103: DBG_ASSERT (VTOH(vp) != NULL); ! 1104: ! 1105: forkType = H_FORKTYPE(VTOH(vp)); ! 1106: isResource = (forkType == kRsrcFork); ! 1107: isDirectory = (catalogInfo->nodeData.cnd_type == kCatalogFolderNode); ! 1108: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord); ! 1109: ! 1110: /* Init the fcb */ ! 1111: fcb->fcbFlags = catalogInfo->nodeData.cnd_flags; ! 1112: ! 1113: if (forkType != kDirectory) { ! 1114: fcb->fcbFlags &= kHFSFileLockedMask; /* Clear resource, dirty bits */ ! 1115: if (fcb->fcbFlags != 0) /* if clear, its not locked, then.. */ ! 1116: fcb->fcbFlags = fcbFileLockedMask; /* duplicate the bit for later use */ ! 1117: ! 1118: fcb->fcbClmpSize = vcb->vcbClpSiz; /*XXX why not use the one in catalogInfo? */ ! 1119: ! 1120: if (isResource) ! 1121: extents = catalogInfo->nodeData.cnd_rsrcfork.extents; ! 1122: else ! 1123: extents = catalogInfo->nodeData.cnd_datafork.extents; ! 1124: ! 1125: /* Copy the extents to their correct location: */ ! 1126: bcopy (extents, fcb->fcbExtents, sizeof(HFSPlusExtentRecord)); ! 1127: ! 1128: if (isResource) { ! 1129: fcb->fcbEOF = catalogInfo->nodeData.cnd_rsrcfork.logicalSize; ! 1130: fcb->fcbPLen = catalogInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize; ! 1131: fcb->fcbFlags |= fcbResourceMask; ! 1132: } else { ! 1133: fcb->fcbEOF = catalogInfo->nodeData.cnd_datafork.logicalSize; ! 1134: fcb->fcbPLen = catalogInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize; ! 1135: }; ! 1136: }; ! 1137: ! 1138: ! 1139: } ! 1140: ! 1141: int hasOverflowExtents(struct hfsnode *hp) ! 1142: { ! 1143: ExtendedVCB *vcb = HTOVCB(hp); ! 1144: FCB *fcb = HTOFCB(hp); ! 1145: u_long blocks; ! 1146: ! 1147: if (vcb->vcbSigWord == kHFSPlusSigWord) ! 1148: { ! 1149: ! 1150: if (fcb->fcbExtents[7].blockCount == 0) ! 1151: return false; ! 1152: ! 1153: blocks = fcb->fcbExtents[0].blockCount + ! 1154: fcb->fcbExtents[1].blockCount + ! 1155: fcb->fcbExtents[2].blockCount + ! 1156: fcb->fcbExtents[3].blockCount + ! 1157: fcb->fcbExtents[4].blockCount + ! 1158: fcb->fcbExtents[5].blockCount + ! 1159: fcb->fcbExtents[6].blockCount + ! 1160: fcb->fcbExtents[7].blockCount; ! 1161: } ! 1162: else ! 1163: { ! 1164: if (fcb->fcbExtents[2].blockCount == 0) ! 1165: return false; ! 1166: ! 1167: blocks = fcb->fcbExtents[0].blockCount + ! 1168: fcb->fcbExtents[1].blockCount + ! 1169: fcb->fcbExtents[2].blockCount; ! 1170: } ! 1171: ! 1172: return ((fcb->fcbPLen / vcb->blockSize) > blocks); ! 1173: } ! 1174: ! 1175: ! 1176: int hfs_metafilelocking(struct hfsmount *hfsmp, u_long fileID, u_int flags, struct proc *p) ! 1177: { ! 1178: ExtendedVCB *vcb; ! 1179: struct vnode *vp = NULL; ! 1180: int numOfLockedBuffs; ! 1181: int retval = 0; ! 1182: ! 1183: vcb = HFSTOVCB(hfsmp); ! 1184: ! 1185: DBG_UTILS(("hfs_metafilelocking: vol: %d, file: %d %s%s%s\n", vcb->vcbVRefNum, fileID, ! 1186: ((flags & LK_TYPE_MASK) == LK_RELEASE ? "RELEASE" : ""), ! 1187: ((flags & LK_TYPE_MASK) == LK_EXCLUSIVE ? "EXCLUSIVE" : ""), ! 1188: ((flags & LK_TYPE_MASK) == LK_SHARED ? "SHARED" : "") )); ! 1189: ! 1190: ! 1191: switch (fileID) ! 1192: { ! 1193: case kHFSExtentsFileID: ! 1194: vp = vcb->extentsRefNum; ! 1195: break; ! 1196: ! 1197: case kHFSCatalogFileID: ! 1198: vp = vcb->catalogRefNum; ! 1199: break; ! 1200: ! 1201: case kHFSAllocationFileID: ! 1202: /* bitmap is covered by Extents B-tree locking */ ! 1203: /* FALL THROUGH */ ! 1204: default: ! 1205: panic("hfs_lockmetafile: invalid fileID"); ! 1206: } ! 1207: ! 1208: if (vp != NULL) { ! 1209: ! 1210: /* Release, if necesary any locked buffer caches */ ! 1211: if ((flags & LK_TYPE_MASK) == LK_RELEASE) { ! 1212: struct timeval tv = time; ! 1213: u_int32_t lastfsync = tv.tv_sec; ! 1214: ! 1215: (void) BTGetLastSync(VTOFCB(vp), &lastfsync); ! 1216: ! 1217: numOfLockedBuffs = count_lock_queue(); ! 1218: if ((numOfLockedBuffs > kMaxLockedMetaBuffers) || ((numOfLockedBuffs>1) && ((tv.tv_sec - lastfsync) > kMaxSecsForFsync))) { ! 1219: DBG_UTILS(("Synching meta deta: %d... # locked buffers = %d, fsync gap = %ld\n", H_FILEID(VTOH(vp)), ! 1220: numOfLockedBuffs, (tv.tv_sec - lastfsync))); ! 1221: hfs_fsync_transaction(vp); ! 1222: }; ! 1223: }; ! 1224: ! 1225: retval = lockmgr(&VTOH(vp)->h_lock, flags, &vp->v_interlock, p); ! 1226: }; ! 1227: ! 1228: return retval; ! 1229: } ! 1230: ! 1231: ! 1232: void CopyVNodeToCatalogNode (struct vnode *vp, struct CatalogNodeData *nodeData) ! 1233: { ! 1234: ExtendedVCB *vcb; ! 1235: FCB *fcb; ! 1236: struct hfsnode *hp; ! 1237: Boolean isHFSPlus, isResource; ! 1238: HFSPlusExtentDescriptor *extents; ! 1239: ! 1240: hp = VTOH(vp); ! 1241: vcb = HTOVCB(hp); ! 1242: fcb = HTOFCB(hp); ! 1243: isResource = (H_FORKTYPE(hp) == kRsrcFork); ! 1244: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord); ! 1245: ! 1246: /* date and time of last fork modification */ ! 1247: nodeData->cnd_contentModDate = to_hfs_time(hp->h_meta->h_mtime); ! 1248: ! 1249: if (isHFSPlus) { ! 1250: /* Make sure that there is no nodeType/mode mismatch */ ! 1251: if ((nodeData->cnd_type == kCatalogFolderNode) ! 1252: && ((hp->h_meta->h_mode & IFMT) != IFDIR)) { ! 1253: ! 1254: DBG_ASSERT((hp->h_meta->h_mode & IFMT) == IFDIR); ! 1255: hp->h_meta->h_mode &= ~IFMT; /* Clear the bad bits */ ! 1256: hp->h_meta->h_mode |= IFDIR; /* Set the proper one */ ! 1257: }; ! 1258: /* date and time of last modification (any kind) */ ! 1259: nodeData->cnd_attributeModDate = to_hfs_time(hp->h_meta->h_ctime); ! 1260: /* date and time of last access (MacOS X only) */ ! 1261: nodeData->cnd_accessDate = to_hfs_time(hp->h_meta->h_atime); ! 1262: if (! (hp->h_meta->h_metaflags & IN_UNSETACCESS)) { ! 1263: /* This is a tricky stuff-job: the pflags longword has two bytes of significance and they're ! 1264: combined with the mode field to yield a 32-bit permissions field as follows: ! 1265: ! 1266: +------------------------------------+ ! 1267: hp->h_meta->h_pflags: |XXXXXXXX| A |XXXXXXXX| B | ! 1268: +------------------------------------+ ! 1269: ! 1270: | ! 1271: V ! 1272: ! 1273: +------------------------------------+ ! 1274: permissions: | A | B | mode | ! 1275: +------------------------------------+ ! 1276: */ ! 1277: nodeData->cnd_permissions = (((hp->h_meta->h_pflags << 8) & 0xFF000000) | /* A */ ! 1278: ((hp->h_meta->h_pflags << 16) & 0x00FF0000) | /* B */ ! 1279: (hp->h_meta->h_mode & 0x0000FFFF)); ! 1280: nodeData->cnd_ownerID = hp->h_meta->h_uid; ! 1281: nodeData->cnd_groupID = hp->h_meta->h_gid; ! 1282: nodeData->cnd_specialDevice = hp->h_meta->h_rdev; ! 1283: }; ! 1284: }; ! 1285: ! 1286: /* the rest only applies to files */ ! 1287: if (nodeData->cnd_type == kCatalogFileNode) { ! 1288: if (hp->h_meta->h_pflags & (SF_IMMUTABLE | UF_IMMUTABLE)) { ! 1289: /* The file is locked: set the locked bit in the catalog. */ ! 1290: nodeData->cnd_flags |= kHFSFileLockedMask; ! 1291: } else { ! 1292: /* The file is unlocked: make sure the locked bit in the catalog is clear. */ ! 1293: nodeData->cnd_flags &= ~kHFSFileLockedMask; ! 1294: }; ! 1295: if (isResource) { ! 1296: extents = nodeData->cnd_rsrcfork.extents; ! 1297: nodeData->cnd_rsrcfork.logicalSize = fcb->fcbEOF; ! 1298: nodeData->cnd_rsrcfork.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 1299: } else { ! 1300: extents = nodeData->cnd_datafork.extents; ! 1301: nodeData->cnd_datafork.logicalSize = fcb->fcbEOF; ! 1302: nodeData->cnd_datafork.totalBlocks = fcb->fcbPLen / vcb->blockSize; ! 1303: }; ! 1304: ! 1305: bcopy ( fcb->fcbExtents, extents, sizeof(HFSPlusExtentRecord)); ! 1306: ! 1307: if (vp->v_type == VLNK) { ! 1308: ((struct FInfo *)(&nodeData->cnd_finderInfo))->fdType = kSymLinkFileType; ! 1309: ((struct FInfo *)(&nodeData->cnd_finderInfo))->fdCreator = kSymLinkCreator; ! 1310: ! 1311: /* Set this up as an alias */ ! 1312: #if SUPPORTS_MAC_ALIASES ! 1313: ((struct FInfo *)(&nodeData->cnd_finderInfo))->fdFlags |= kIsAlias; ! 1314: #endif ! 1315: } ! 1316: #if HFS_HARDLINKS ! 1317: nodeData->cnd_linkCount = hp->h_meta->h_nlink; ! 1318: #endif ! 1319: } ! 1320: } ! 1321: ! 1322: ! 1323: ! 1324: void MapFileOffset(struct hfsnode *hp, ! 1325: off_t filePosition, ! 1326: daddr_t *logBlockNumber, ! 1327: long *blockSize, ! 1328: long *blockOffset) { ! 1329: off_t extentOffset = filePosition; ! 1330: daddr_t precedingBlockCount; ! 1331: unsigned long logicalBlockSize = 0; ! 1332: unsigned long spaceRemaining; ! 1333: ! 1334: DBG_IO(("MapFileOffset: hp = 0x%08lX, vp = 0x%08lX ('%s'):\n", (u_long)hp, (u_long)HTOV(hp), H_NAME(hp))); ! 1335: // DBG_IO(("\tfilePosition 0x%08lX", (u_long)filePosition)); ! 1336: ! 1337: if (filePosition < hp->h_optimizedblocksizelimit) { ! 1338: int extent; ! 1339: ! 1340: precedingBlockCount = 0; ! 1341: for (extent = 0; extent < LOGBLOCKMAPENTRIES; ++extent) { ! 1342: if ((hp->h_logicalblocktable[extent].logicalBlockCount > 0) && ! 1343: (extentOffset < hp->h_logicalblocktable[extent].extentLength)) { ! 1344: logicalBlockSize = MAXLOGBLOCKSIZE; ! 1345: spaceRemaining = hp->h_logicalblocktable[extent].extentLength - ((extentOffset / logicalBlockSize) * logicalBlockSize); ! 1346: *blockSize = MIN(logicalBlockSize, spaceRemaining); ! 1347: // DBG_IO(("\tUsing entry #%d: preceding blocks = 0x%X, position = 0x%8lX:\n", ! 1348: // extent, precedingBlockCount, (u_long)extentOffset)); ! 1349: break; ! 1350: }; ! 1351: precedingBlockCount += hp->h_logicalblocktable[extent].logicalBlockCount; ! 1352: extentOffset -= hp->h_logicalblocktable[extent].extentLength; ! 1353: }; ! 1354: DBG_ASSERT(logicalBlockSize > 0); ! 1355: } else { ! 1356: // DBG_IO(("\tUsing h_uniformblocksizestart = 0x%X and h_optimizedblocksizelimit = 0x%lX:\n", ! 1357: // hp->h_uniformblocksizestart, (u_long)hp->h_optimizedblocksizelimit)); ! 1358: precedingBlockCount = hp->h_uniformblocksizestart; ! 1359: extentOffset -= hp->h_optimizedblocksizelimit; ! 1360: logicalBlockSize = GetLogicalBlockSize(HTOV(hp)); ! 1361: *blockSize = logicalBlockSize; ! 1362: }; ! 1363: ! 1364: *logBlockNumber = precedingBlockCount + (extentOffset / logicalBlockSize); ! 1365: *blockOffset = extentOffset % logicalBlockSize; ! 1366: DBG_IO(("\tfilePosition 0x%08lX -> logBlockNo = 0x%X, blockSize = 0x%lX, blockOffset = 0x%lX.\n", ! 1367: (u_long)filePosition, ! 1368: *logBlockNumber, ! 1369: *blockSize, ! 1370: *blockOffset)); ! 1371: } ! 1372: ! 1373: ! 1374: long LogicalBlockSize(struct hfsnode *hp, daddr_t logicalBlockNumber) { ! 1375: ! 1376: if (logicalBlockNumber < hp->h_uniformblocksizestart) { ! 1377: off_t fragmentOffset = 0; ! 1378: int extent; ! 1379: ! 1380: for (extent = 0; extent < LOGBLOCKMAPENTRIES; ++extent) { ! 1381: if ((hp->h_logicalblocktable[extent].logicalBlockCount > 0) && ! 1382: (logicalBlockNumber < hp->h_logicalblocktable[extent].logicalBlockCount)) { ! 1383: // *filePosition = fragmentOffset + (logicalBlockNumber * MAXLOGBLOCKSIZE); ! 1384: return MIN(MAXLOGBLOCKSIZE, hp->h_logicalblocktable[extent].extentLength - (logicalBlockNumber * MAXLOGBLOCKSIZE)); ! 1385: }; ! 1386: logicalBlockNumber -= hp->h_logicalblocktable[extent].logicalBlockCount; ! 1387: fragmentOffset += hp->h_logicalblocktable[extent].extentLength; ! 1388: }; ! 1389: } else { ! 1390: // *filePosition = hp->h_optimizedblocksizelimit + ((logicalBlockNumber - hp->h_uniformblocksizestart) * HTOHFS(hp)->logBlockSize); ! 1391: return (GetLogicalBlockSize(HTOV(hp))); ! 1392: }; ! 1393: ! 1394: DBG_ASSERT(0 /* cannot be reached */); ! 1395: return 0; ! 1396: }; ! 1397: ! 1398: ! 1399: void UpdateBlockMappingTableEntry(struct hfsnode *hp, int index, daddr_t firstFragmentBlockNumber, off_t newFragmentLength) { ! 1400: ! 1401: /* Compute the number of logical blocks, rounding up to include any small trailing fragments: */ ! 1402: hp->h_logicalblocktable[index].logicalBlockCount = (newFragmentLength + MAXLOGBLOCKSIZE - 1) / MAXLOGBLOCKSIZE; ! 1403: ! 1404: DBG_IO(("\tblocktable[%d]: length = 0x%lX, # blocks = 0x%lX.\n", ! 1405: index, ! 1406: (u_long)newFragmentLength, ! 1407: (u_long)hp->h_logicalblocktable[index].logicalBlockCount)); ! 1408: ! 1409: #if 0 ! 1410: currentFragmentLength = hp->h_logicalblocktable[index].extentLength; ! 1411: if ((newFragmentLength > currentFragmentLength) && (currentFragmentLength > 0)) { ! 1412: daddr_t currentLastBlockNumber; ! 1413: long currentLastBlockSize; ! 1414: long newLastBlockSize; ! 1415: struct buf *bp; ! 1416: int retval; ! 1417: ! 1418: currentLastBlockNumber = firstFragmentBlockNumber + (currentFragmentLength / MAXLOGBLOCKSIZE); ! 1419: currentLastBlockSize = currentFragmentLength % MAXLOGBLOCKSIZE; ! 1420: if (currentLastBlockSize > 0) { ! 1421: newLastBlockSize = MIN(MAXLOGBLOCKSIZE, ! 1422: newFragmentLength - ! 1423: ((currentLastBlockNumber - firstFragmentBlockNumber) * MAXLOGBLOCKSIZE)); ! 1424: if (newLastBlockSize != currentLastBlockSize) { ! 1425: DBG_IO(("\t\t(Adjusting block 0x%lX from 0x%lX to 0x%lX...)\n", ! 1426: (unsigned long)currentLastBlockNumber, ! 1427: currentLastBlockSize, ! 1428: newLastBlockSize)); ! 1429: retval = bread(HTOV(hp), currentLastBlockNumber, currentLastBlockSize, NOCRED, &bp); ! 1430: if (retval == 0) { ! 1431: bexpand(bp, newLastBlockSize, NULL, RELEASE_BUFFER); ! 1432: } else { ! 1433: DBG_IO(("\t\terror (%d.) acquiring block 0x%lX; bp = 0x%08lX\n", ! 1434: retval, ! 1435: (unsigned long)currentLastBlockNumber, ! 1436: (unsigned long)bp)); ! 1437: if (bp) brelse(bp); ! 1438: }; ! 1439: }; ! 1440: }; ! 1441: }; ! 1442: #endif ! 1443: hp->h_logicalblocktable[index].extentLength = newFragmentLength; ! 1444: } ! 1445: ! 1446: ! 1447: void UpdateBlockMappingTable(struct hfsnode *hp) ! 1448: { ! 1449: ExtendedVCB *vcb = HTOVCB(hp); ! 1450: FCB *fcb = HTOFCB(hp); ! 1451: Boolean isHFSPlus; ! 1452: off_t rangeMappedSoFar; ! 1453: u_long logicalBlocksMappedSoFar; ! 1454: int i; ! 1455: off_t newFragmentLength; ! 1456: ! 1457: isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord); ! 1458: DBG_IO(("UpdateBlockMappingTable: hp = 0x%08lX, vp = 0x%08lX ('%s'):\n", (u_long)hp, (u_long)HTOV(hp), H_NAME(hp))); ! 1459: if (H_FORKTYPE(hp) != kDirectory) { ! 1460: rangeMappedSoFar = 0; ! 1461: logicalBlocksMappedSoFar = 0; ! 1462: ! 1463: if ( ! isHFSPlus) { ! 1464: DBG_ASSERT(kHFSExtentDensity <= LOGBLOCKMAPENTRIES); ! 1465: for (i = 0; i < kHFSExtentDensity; ++i) { ! 1466: newFragmentLength = fcb->fcbExtents[i].blockCount * vcb->blockSize; ! 1467: UpdateBlockMappingTableEntry(hp, i, logicalBlocksMappedSoFar, newFragmentLength); ! 1468: rangeMappedSoFar += newFragmentLength; ! 1469: logicalBlocksMappedSoFar += hp->h_logicalblocktable[i].logicalBlockCount; ! 1470: } ! 1471: /* Zero out any remaining entries: */ ! 1472: for (i = kHFSExtentDensity; i < LOGBLOCKMAPENTRIES; ++i) { ! 1473: hp->h_logicalblocktable[i].extentLength = 0; ! 1474: }; ! 1475: #if HFS_DIAGNOSTIC ! 1476: if (rangeMappedSoFar < fcb->fcbPLen) DBG_ASSERT(hp->h_logicalblocktable[kHFSExtentDensity-1].extentLength > 0); ! 1477: #endif ! 1478: } else { ! 1479: for (i = 0; i < kHFSPlusExtentDensity; ++i) { ! 1480: newFragmentLength = fcb->fcbExtents[i].blockCount * vcb->blockSize; ! 1481: UpdateBlockMappingTableEntry(hp, i, logicalBlocksMappedSoFar, newFragmentLength); ! 1482: rangeMappedSoFar += newFragmentLength; ! 1483: logicalBlocksMappedSoFar += hp->h_logicalblocktable[i].logicalBlockCount; ! 1484: } ! 1485: /* No need to zero out the remaining entries [there are none]: */ ! 1486: DBG_ASSERT(LOGBLOCKMAPENTRIES <= kHFSPlusExtentDensity); ! 1487: #if HFS_DIAGNOSTIC ! 1488: if (rangeMappedSoFar < fcb->fcbPLen) DBG_ASSERT(hp->h_logicalblocktable[kHFSPlusExtentDensity-1].extentLength > 0); ! 1489: #endif ! 1490: }; ! 1491: ! 1492: hp->h_optimizedblocksizelimit = rangeMappedSoFar; ! 1493: hp->h_uniformblocksizestart = logicalBlocksMappedSoFar; ! 1494: DBG_IO(("\th_optimizedblocksizelimit = 0x%lX, h_uniformblocksizestart = 0x%lX.\n", ! 1495: (u_long)hp->h_optimizedblocksizelimit, (u_long)hp->h_uniformblocksizestart)); ! 1496: ! 1497: #if BYPASSBLOCKINGOPTIMIZATION ! 1498: hp->h_optimizedblocksizelimit = 0; ! 1499: hp->h_uniformblocksizestart = 0; ! 1500: #endif ! 1501: }; ! 1502: } ! 1503: ! 1504: ! 1505: /********************************************************************* ! 1506: ! 1507: Sets the name in the filemeta structure ! 1508: ! 1509: XXX Does not preflight if changing from one size to another ! 1510: XXX Currently not protected from context switching ! 1511: ! 1512: *********************************************************************/ ! 1513: ! 1514: void hfs_set_metaname(char *name, struct hfsfilemeta *fm) ! 1515: { ! 1516: int namelen = strlen(name); ! 1517: char *tname, *fname; ! 1518: ! 1519: #if HFS_DIAGNOSTIC ! 1520: DBG_ASSERT(name != NULL); ! 1521: DBG_ASSERT(fm != NULL); ! 1522: if (fm->h_namePtr) { ! 1523: DBG_ASSERT(fm->h_namelen == strlen(fm->h_namePtr)); ! 1524: if (strlen(fm->h_namePtr) > MAXHFSVNODELEN) ! 1525: DBG_ASSERT(fm->h_metaflags & IN_LONGNAME); ! 1526: }; ! 1527: if (fm->h_metaflags & IN_LONGNAME) { ! 1528: DBG_ASSERT(fm->h_namePtr != (char *)fm->h_fileName); ! 1529: DBG_ASSERT(fm->h_namePtr != NULL); ! 1530: }; ! 1531: #endif //HFS_DIAGNOSTIC ! 1532: ! 1533: /* ! 1534: * Details that have to be dealt with: ! 1535: * 1. No name is allocated. fm->h_namePtr should be NULL ! 1536: * 2. A name is being changed and: ! 1537: * a. it was in static space and now cannot fit ! 1538: * b. It was malloc'd and now will fit in the static ! 1539: * c. It did and will fit in the static ! 1540: * This could be a little smarter: ! 1541: * - Dont re'malloc if the new name is smaller (but then wasting memory) ! 1542: * - If its a longname but the same size, we still free and malloc ! 1543: * - ! 1544: */ ! 1545: ! 1546: ! 1547: /* Allocate the new memory */ ! 1548: if (namelen > MAXHFSVNODELEN) { ! 1549: /* ! 1550: * Notice the we ALWAYS allocate, even if the new is less then the old, ! 1551: * or even if they are the SAME ! 1552: */ ! 1553: MALLOC(tname, char *, namelen+1, M_TEMP, M_WAITOK); ! 1554: } ! 1555: else ! 1556: tname = fm->h_fileName; ! 1557: ! 1558: simple_lock(&fm->h_metalock); ! 1559: ! 1560: /* Check to see if there is something to free, if yes, remember it */ ! 1561: if (fm->h_metaflags & IN_LONGNAME) ! 1562: fname = fm->h_namePtr; ! 1563: else ! 1564: fname = NULL; ! 1565: ! 1566: /* Set the flag */ ! 1567: if (namelen > MAXHFSVNODELEN) { ! 1568: fm->h_metaflags |= IN_LONGNAME; ! 1569: } ! 1570: else { ! 1571: fm->h_metaflags &= ~IN_LONGNAME; ! 1572: }; ! 1573: ! 1574: /* Now copy it over */ ! 1575: bcopy(name, tname, namelen+1); ! 1576: ! 1577: fm->h_namePtr = tname; ! 1578: fm->h_namelen = namelen; ! 1579: ! 1580: simple_unlock(&fm->h_metalock); ! 1581: ! 1582: /* Lastly, free the old, if set */ ! 1583: if (fname != NULL) ! 1584: FREE(fname, M_TEMP); ! 1585: ! 1586: } ! 1587: ! 1588: int AttributeBlockSize(struct attrlist *attrlist) { ! 1589: int size; ! 1590: attrgroup_t a; ! 1591: ! 1592: #if ((ATTR_CMN_NAME | ATTR_CMN_DEVID | ATTR_CMN_FSID | ATTR_CMN_OBJTYPE | \ ! 1593: ATTR_CMN_OBJTAG | ATTR_CMN_OBJID | ATTR_CMN_OBJPERMANENTID | ATTR_CMN_PAROBJID | \ ! 1594: ATTR_CMN_SCRIPT | ATTR_CMN_CRTIME | ATTR_CMN_MODTIME | ATTR_CMN_CHGTIME | \ ! 1595: ATTR_CMN_ACCTIME | ATTR_CMN_BKUPTIME | ATTR_CMN_FNDRINFO | ATTR_CMN_OWNERID | \ ! 1596: ATTR_CMN_GRPID | ATTR_CMN_ACCESSMASK | ATTR_CMN_NAMEDATTRCOUNT | ATTR_CMN_NAMEDATTRLIST| \ ! 1597: ATTR_CMN_FLAGS) != ATTR_CMN_VALIDMASK) ! 1598: #error AttributeBlockSize: Missing bits in common mask computation! ! 1599: #endif ! 1600: DBG_ASSERT((attrlist->commonattr & ~ATTR_CMN_VALIDMASK) == 0); ! 1601: ! 1602: #if ((ATTR_VOL_FSTYPE | ATTR_VOL_SIGNATURE | ATTR_VOL_SIZE | ATTR_VOL_SPACEFREE | \ ! 1603: ATTR_VOL_SPACEAVAIL | ATTR_VOL_MINALLOCATION | ATTR_VOL_ALLOCATIONCLUMP | ATTR_VOL_IOBLOCKSIZE | \ ! 1604: ATTR_VOL_OBJCOUNT | ATTR_VOL_FILECOUNT | ATTR_VOL_DIRCOUNT | ATTR_VOL_MAXOBJCOUNT | \ ! 1605: ATTR_VOL_MOUNTPOINT | ATTR_VOL_NAME | ATTR_VOL_MOUNTFLAGS | ATTR_VOL_INFO | \ ! 1606: ATTR_VOL_MOUNTEDDEVICE| ATTR_VOL_ENCODINGSUSED) != ATTR_VOL_VALIDMASK) ! 1607: #error AttributeBlockSize: Missing bits in volume mask computation! ! 1608: #endif ! 1609: DBG_ASSERT((attrlist->volattr & ~ATTR_VOL_VALIDMASK) == 0); ! 1610: ! 1611: #if ((ATTR_DIR_LINKCOUNT | ATTR_DIR_ENTRYCOUNT) != ATTR_DIR_VALIDMASK) ! 1612: #error AttributeBlockSize: Missing bits in directory mask computation! ! 1613: #endif ! 1614: DBG_ASSERT((attrlist->dirattr & ~ATTR_DIR_VALIDMASK) == 0); ! 1615: #if ((ATTR_FILE_LINKCOUNT | ATTR_FILE_TOTALSIZE | ATTR_FILE_ALLOCSIZE | ATTR_FILE_IOBLOCKSIZE | \ ! 1616: ATTR_FILE_CLUMPSIZE | ATTR_FILE_DEVTYPE | ATTR_FILE_FILETYPE | ATTR_FILE_FORKCOUNT | \ ! 1617: ATTR_FILE_FORKLIST | ATTR_FILE_DATALENGTH | ATTR_FILE_DATAALLOCSIZE | ATTR_FILE_DATAEXTENTS | \ ! 1618: ATTR_FILE_RSRCLENGTH | ATTR_FILE_RSRCALLOCSIZE | ATTR_FILE_RSRCEXTENTS) != ATTR_FILE_VALIDMASK) ! 1619: #error AttributeBlockSize: Missing bits in file mask computation! ! 1620: #endif ! 1621: DBG_ASSERT((attrlist->fileattr & ~ATTR_FILE_VALIDMASK) == 0); ! 1622: ! 1623: #if ((ATTR_FORK_TOTALSIZE | ATTR_FORK_ALLOCSIZE) != ATTR_FORK_VALIDMASK) ! 1624: #error AttributeBlockSize: Missing bits in fork mask computation! ! 1625: #endif ! 1626: DBG_ASSERT((attrlist->forkattr & ~ATTR_FORK_VALIDMASK) == 0); ! 1627: ! 1628: size = 0; ! 1629: ! 1630: if ((a = attrlist->commonattr) != 0) { ! 1631: if (a & ATTR_CMN_NAME) size += sizeof(struct attrreference); ! 1632: if (a & ATTR_CMN_DEVID) size += sizeof(dev_t); ! 1633: if (a & ATTR_CMN_FSID) size += sizeof(fsid_t); ! 1634: if (a & ATTR_CMN_OBJTYPE) size += sizeof(fsobj_type_t); ! 1635: if (a & ATTR_CMN_OBJTAG) size += sizeof(fsobj_tag_t); ! 1636: if (a & ATTR_CMN_OBJID) size += sizeof(fsobj_id_t); ! 1637: if (a & ATTR_CMN_OBJPERMANENTID) size += sizeof(fsobj_id_t); ! 1638: if (a & ATTR_CMN_PAROBJID) size += sizeof(fsobj_id_t); ! 1639: if (a & ATTR_CMN_SCRIPT) size += sizeof(text_encoding_t); ! 1640: if (a & ATTR_CMN_CRTIME) size += sizeof(struct timespec); ! 1641: if (a & ATTR_CMN_MODTIME) size += sizeof(struct timespec); ! 1642: if (a & ATTR_CMN_CHGTIME) size += sizeof(struct timespec); ! 1643: if (a & ATTR_CMN_ACCTIME) size += sizeof(struct timespec); ! 1644: if (a & ATTR_CMN_BKUPTIME) size += sizeof(struct timespec); ! 1645: if (a & ATTR_CMN_FNDRINFO) size += 32 * sizeof(UInt8); ! 1646: if (a & ATTR_CMN_OWNERID) size += sizeof(uid_t); ! 1647: if (a & ATTR_CMN_GRPID) size += sizeof(gid_t); ! 1648: if (a & ATTR_CMN_ACCESSMASK) size += sizeof(u_long); ! 1649: if (a & ATTR_CMN_NAMEDATTRCOUNT) size += sizeof(u_long); ! 1650: if (a & ATTR_CMN_NAMEDATTRLIST) size += sizeof(struct attrreference); ! 1651: if (a & ATTR_CMN_FLAGS) size += sizeof(u_long); ! 1652: }; ! 1653: if ((a = attrlist->volattr) != 0) { ! 1654: if (a & ATTR_VOL_FSTYPE) size += sizeof(u_long); ! 1655: if (a & ATTR_VOL_SIGNATURE) size += sizeof(u_long); ! 1656: if (a & ATTR_VOL_SIZE) size += sizeof(off_t); ! 1657: if (a & ATTR_VOL_SPACEFREE) size += sizeof(off_t); ! 1658: if (a & ATTR_VOL_SPACEAVAIL) size += sizeof(off_t); ! 1659: if (a & ATTR_VOL_MINALLOCATION) size += sizeof(off_t); ! 1660: if (a & ATTR_VOL_ALLOCATIONCLUMP) size += sizeof(off_t); ! 1661: if (a & ATTR_VOL_IOBLOCKSIZE) size += sizeof(u_long); ! 1662: if (a & ATTR_VOL_OBJCOUNT) size += sizeof(u_long); ! 1663: if (a & ATTR_VOL_FILECOUNT) size += sizeof(u_long); ! 1664: if (a & ATTR_VOL_DIRCOUNT) size += sizeof(u_long); ! 1665: if (a & ATTR_VOL_MAXOBJCOUNT) size += sizeof(u_long); ! 1666: if (a & ATTR_VOL_MOUNTPOINT) size += sizeof(struct attrreference); ! 1667: if (a & ATTR_VOL_NAME) size += sizeof(struct attrreference); ! 1668: if (a & ATTR_VOL_MOUNTFLAGS) size += sizeof(u_long); ! 1669: if (a & ATTR_VOL_MOUNTEDDEVICE) size += sizeof(struct attrreference); ! 1670: if (a & ATTR_VOL_ENCODINGSUSED) size += sizeof(unsigned long long); ! 1671: }; ! 1672: if ((a = attrlist->dirattr) != 0) { ! 1673: if (a & ATTR_DIR_LINKCOUNT) size += sizeof(u_long); ! 1674: if (a & ATTR_DIR_ENTRYCOUNT) size += sizeof(u_long); ! 1675: }; ! 1676: if ((a = attrlist->fileattr) != 0) { ! 1677: if (a & ATTR_FILE_LINKCOUNT) size += sizeof(u_long); ! 1678: if (a & ATTR_FILE_TOTALSIZE) size += sizeof(off_t); ! 1679: if (a & ATTR_FILE_ALLOCSIZE) size += sizeof(off_t); ! 1680: if (a & ATTR_FILE_IOBLOCKSIZE) size += sizeof(size_t); ! 1681: if (a & ATTR_FILE_CLUMPSIZE) size += sizeof(off_t); ! 1682: if (a & ATTR_FILE_DEVTYPE) size += sizeof(u_long); ! 1683: if (a & ATTR_FILE_FILETYPE) size += sizeof(u_long); ! 1684: if (a & ATTR_FILE_FORKCOUNT) size += sizeof(u_long); ! 1685: if (a & ATTR_FILE_FORKLIST) size += sizeof(struct attrreference); ! 1686: if (a & ATTR_FILE_DATALENGTH) size += sizeof(off_t); ! 1687: if (a & ATTR_FILE_DATAALLOCSIZE) size += sizeof(off_t); ! 1688: if (a & ATTR_FILE_DATAEXTENTS) size += sizeof(extentrecord); ! 1689: if (a & ATTR_FILE_RSRCLENGTH) size += sizeof(off_t); ! 1690: if (a & ATTR_FILE_RSRCALLOCSIZE) size += sizeof(off_t); ! 1691: if (a & ATTR_FILE_RSRCEXTENTS) size += sizeof(extentrecord); ! 1692: }; ! 1693: if ((a = attrlist->forkattr) != 0) { ! 1694: if (a & ATTR_FORK_TOTALSIZE) size += sizeof(off_t); ! 1695: if (a & ATTR_FORK_ALLOCSIZE) size += sizeof(off_t); ! 1696: }; ! 1697: ! 1698: return size; ! 1699: } ! 1700: ! 1701: ! 1702: ! 1703: void PackVolCommonAttributes(struct attrlist *alist, ! 1704: struct vnode *root_vp, ! 1705: struct hfsCatalogInfo *root_catInfo, ! 1706: void **attrbufptrptr, ! 1707: void **varbufptrptr) { ! 1708: void *attrbufptr; ! 1709: void *varbufptr; ! 1710: attrgroup_t a; ! 1711: struct hfsnode *root_hp = VTOH(root_vp); ! 1712: struct mount *mp = VTOVFS(root_vp); ! 1713: struct hfsmount *hfsmp = VTOHFS(root_vp); ! 1714: ExtendedVCB *vcb = HFSTOVCB(hfsmp); ! 1715: u_long attrlength; ! 1716: ! 1717: attrbufptr = *attrbufptrptr; ! 1718: varbufptr = *varbufptrptr; ! 1719: ! 1720: if ((a = alist->commonattr) != 0) { ! 1721: if (a & ATTR_CMN_NAME) { ! 1722: attrlength = root_hp->h_meta->h_namelen+1; ! 1723: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 1724: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 1725: (void) strncpy((unsigned char *)varbufptr, H_NAME(root_hp), attrlength); ! 1726: ! 1727: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 1728: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 1729: ++((struct attrreference *)attrbufptr); ! 1730: }; ! 1731: if (a & ATTR_CMN_DEVID) *((dev_t *)attrbufptr)++ = hfsmp->hfs_raw_dev; ! 1732: if (a & ATTR_CMN_FSID) { ! 1733: *((fsid_t *)attrbufptr) = mp->mnt_stat.f_fsid; ! 1734: if (vcb->vcbSigWord == kHFSSigWord) ((fsid_t *)attrbufptr)->val[0] |= 0x40000000; ! 1735: ++((fsid_t *)attrbufptr); ! 1736: }; ! 1737: if (a & ATTR_CMN_OBJTYPE) *((fsobj_type_t *)attrbufptr)++ = 0; ! 1738: if (a & ATTR_CMN_OBJTAG) *((fsobj_tag_t *)attrbufptr)++ = VT_HFS; ! 1739: if (a & ATTR_CMN_OBJID) { ! 1740: ((fsobj_id_t *)attrbufptr)->fid_objno = 0; ! 1741: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1742: ++((fsobj_id_t *)attrbufptr); ! 1743: }; ! 1744: if (a & ATTR_CMN_OBJPERMANENTID) { ! 1745: ((fsobj_id_t *)attrbufptr)->fid_objno = 0; ! 1746: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1747: ++((fsobj_id_t *)attrbufptr); ! 1748: }; ! 1749: if (a & ATTR_CMN_PAROBJID) { ! 1750: ((fsobj_id_t *)attrbufptr)->fid_objno = 0; ! 1751: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1752: ++((fsobj_id_t *)attrbufptr); ! 1753: }; ! 1754: VCB_LOCK(vcb); ! 1755: if (a & ATTR_CMN_SCRIPT) *((text_encoding_t *)attrbufptr)++ = vcb->volumeNameEncodingHint; ! 1756: /* NOTE: all VCB dates are in local Mac OS time */ ! 1757: if (a & ATTR_CMN_CRTIME) { ! 1758: /* ! 1759: * HFS Plus stores the volume create date in *local* ! 1760: * time in the volume header. So don't use the create ! 1761: * date from the vcb. Use the root's crtime instead. ! 1762: */ ! 1763: if (vcb->vcbSigWord == kHFSPlusSigWord) { ! 1764: ((struct timespec *)attrbufptr)->tv_sec = root_hp->h_meta->h_crtime; ! 1765: } else { ! 1766: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(vcb->vcbCrDate); ! 1767: } ! 1768: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1769: ++((struct timespec *)attrbufptr); ! 1770: }; ! 1771: if (a & ATTR_CMN_MODTIME) { ! 1772: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(vcb->vcbLsMod); ! 1773: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1774: ++((struct timespec *)attrbufptr); ! 1775: }; ! 1776: if (a & ATTR_CMN_CHGTIME) { ! 1777: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(vcb->vcbLsMod); ! 1778: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1779: ++((struct timespec *)attrbufptr); ! 1780: }; ! 1781: if (a & ATTR_CMN_ACCTIME) { ! 1782: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(vcb->vcbLsMod); ! 1783: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1784: ++((struct timespec *)attrbufptr); ! 1785: }; ! 1786: if (a & ATTR_CMN_BKUPTIME) { ! 1787: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(vcb->vcbVolBkUp); ! 1788: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1789: ++((struct timespec *)attrbufptr); ! 1790: }; ! 1791: if (a & ATTR_CMN_FNDRINFO) { ! 1792: bcopy (&vcb->vcbFndrInfo, attrbufptr, sizeof(vcb->vcbFndrInfo)); ! 1793: (char *)attrbufptr += sizeof(vcb->vcbFndrInfo); ! 1794: }; ! 1795: VCB_UNLOCK(vcb); ! 1796: if (a & ATTR_CMN_OWNERID) *((uid_t *)attrbufptr)++ = root_hp->h_meta->h_uid; ! 1797: if (a & ATTR_CMN_GRPID) *((gid_t *)attrbufptr)++ = root_hp->h_meta->h_gid; ! 1798: if (a & ATTR_CMN_ACCESSMASK) *((u_long *)attrbufptr)++ = (u_long)root_hp->h_meta->h_mode; ! 1799: if (a & ATTR_CMN_NAMEDATTRCOUNT) *((u_long *)attrbufptr)++ = 0; /* XXX PPD TBC */ ! 1800: if (a & ATTR_CMN_NAMEDATTRLIST) { ! 1801: attrlength = 0; ! 1802: ((struct attrreference *)attrbufptr)->attr_dataoffset = 0; ! 1803: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 1804: ! 1805: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 1806: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 1807: ++((struct attrreference *)attrbufptr); ! 1808: }; ! 1809: if (a & ATTR_CMN_FLAGS) *((u_long *)attrbufptr)++ = root_hp->h_meta->h_pflags; ! 1810: }; ! 1811: ! 1812: *attrbufptrptr = attrbufptr; ! 1813: *varbufptrptr = varbufptr; ! 1814: } ! 1815: ! 1816: ! 1817: ! 1818: void PackVolAttributeBlock(struct attrlist *alist, ! 1819: struct vnode *root_vp, ! 1820: struct hfsCatalogInfo *root_catInfo, ! 1821: void **attrbufptrptr, ! 1822: void **varbufptrptr) { ! 1823: void *attrbufptr; ! 1824: void *varbufptr; ! 1825: attrgroup_t a; ! 1826: struct mount *mp = VTOVFS(root_vp); ! 1827: struct hfsmount *hfsmp = VTOHFS(root_vp); ! 1828: ExtendedVCB *vcb = HFSTOVCB(hfsmp); ! 1829: u_long attrlength; ! 1830: ! 1831: attrbufptr = *attrbufptrptr; ! 1832: varbufptr = *varbufptrptr; ! 1833: ! 1834: if ((a = alist->volattr) != 0) { ! 1835: VCB_LOCK(vcb); ! 1836: if (a & ATTR_VOL_FSTYPE) *((u_long *)attrbufptr)++ = (u_long)mp->mnt_vfc->vfc_typenum; ! 1837: if (a & ATTR_VOL_SIGNATURE) *((u_long *)attrbufptr)++ = (u_long)vcb->vcbSigWord; ! 1838: if (a & ATTR_VOL_SIZE) *((off_t *)attrbufptr)++ = (off_t)vcb->totalBlocks * (off_t)vcb->blockSize; ! 1839: if (a & ATTR_VOL_SPACEFREE) *((off_t *)attrbufptr)++ = (off_t)vcb->freeBlocks * (off_t)vcb->blockSize; ! 1840: if (a & ATTR_VOL_SPACEAVAIL) *((off_t *)attrbufptr)++ = (off_t)vcb->freeBlocks * (off_t)vcb->blockSize; ! 1841: if (a & ATTR_VOL_MINALLOCATION) *((off_t *)attrbufptr)++ = (off_t)vcb->blockSize; ! 1842: if (a & ATTR_VOL_ALLOCATIONCLUMP) *((off_t *)attrbufptr)++ = (off_t)(vcb->vcbClpSiz); ! 1843: if (a & ATTR_VOL_IOBLOCKSIZE) *((u_long *)attrbufptr)++ = (u_long)hfsmp->hfs_logBlockSize; ! 1844: if (a & ATTR_VOL_OBJCOUNT) *((u_long *)attrbufptr)++ = (u_long)vcb->vcbFilCnt + (u_long)vcb->vcbDirCnt; ! 1845: if (a & ATTR_VOL_FILECOUNT) *((u_long *)attrbufptr)++ = (u_long)vcb->vcbFilCnt; ! 1846: if (a & ATTR_VOL_DIRCOUNT) *((u_long *)attrbufptr)++ = (u_long)vcb->vcbDirCnt; ! 1847: if (a & ATTR_VOL_MAXOBJCOUNT) *((u_long *)attrbufptr)++ = 0xFFFFFFFF; ! 1848: if (a & ATTR_VOL_MOUNTPOINT) { ! 1849: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 1850: ((struct attrreference *)attrbufptr)->attr_length = strlen(mp->mnt_stat.f_mntonname) + 1; ! 1851: attrlength = ((struct attrreference *)attrbufptr)->attr_length; ! 1852: attrlength = attrlength + ((4 - (attrlength & 3)) & 3); /* round up to the next 4-byte boundary: */ ! 1853: (void) bcopy(mp->mnt_stat.f_mntonname, varbufptr, attrlength); ! 1854: ! 1855: /* Advance beyond the space just allocated: */ ! 1856: (char *)varbufptr += attrlength; ! 1857: ++((struct attrreference *)attrbufptr); ! 1858: }; ! 1859: if (a & ATTR_VOL_NAME) { ! 1860: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 1861: ((struct attrreference *)attrbufptr)->attr_length = VTOH(root_vp)->h_meta->h_namelen + 1; ! 1862: attrlength = ((struct attrreference *)attrbufptr)->attr_length; ! 1863: attrlength = attrlength + ((4 - (attrlength & 3)) & 3); /* round up to the next 4-byte boundary: */ ! 1864: bcopy(H_NAME(VTOH(root_vp)), varbufptr, attrlength); ! 1865: ! 1866: /* Advance beyond the space just allocated: */ ! 1867: (char *)varbufptr += attrlength; ! 1868: ++((struct attrreference *)attrbufptr); ! 1869: }; ! 1870: if (a & ATTR_VOL_MOUNTFLAGS) *((u_long *)attrbufptr)++ = (u_long)mp->mnt_flag; ! 1871: if (a & ATTR_VOL_MOUNTEDDEVICE) { ! 1872: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 1873: ((struct attrreference *)attrbufptr)->attr_length = strlen(mp->mnt_stat.f_mntfromname) + 1; ! 1874: attrlength = ((struct attrreference *)attrbufptr)->attr_length; ! 1875: attrlength = attrlength + ((4 - (attrlength & 3)) & 3); /* round up to the next 4-byte boundary: */ ! 1876: (void) bcopy(mp->mnt_stat.f_mntfromname, varbufptr, attrlength); ! 1877: ! 1878: /* Advance beyond the space just allocated: */ ! 1879: (char *)varbufptr += attrlength; ! 1880: ++((struct attrreference *)attrbufptr); ! 1881: }; ! 1882: if (a & ATTR_VOL_ENCODINGSUSED) *((unsigned long long *)attrbufptr)++ = (unsigned long long)vcb->encodingsBitmap; ! 1883: VCB_UNLOCK(vcb); ! 1884: }; ! 1885: ! 1886: *attrbufptrptr = attrbufptr; ! 1887: *varbufptrptr = varbufptr; ! 1888: } ! 1889: ! 1890: ! 1891: ! 1892: ! 1893: void PackVolumeInfo(struct attrlist *alist, ! 1894: struct vnode *root_vp, ! 1895: struct hfsCatalogInfo *root_catinfo, ! 1896: void **attrbufptrptr, ! 1897: void **varbufptrptr) { ! 1898: ! 1899: PackVolCommonAttributes(alist, root_vp, root_catinfo, attrbufptrptr, varbufptrptr); ! 1900: PackVolAttributeBlock(alist, root_vp, root_catinfo, attrbufptrptr, varbufptrptr); ! 1901: }; ! 1902: ! 1903: // Pack the common attribute contents of an objects hfsCatalogInfo ! 1904: void PackCommonCatalogInfoAttributeBlock(struct attrlist *alist, ! 1905: struct vnode *root_vp, ! 1906: struct hfsCatalogInfo *catalogInfo, ! 1907: void **attrbufptrptr, ! 1908: void **varbufptrptr ) ! 1909: { ! 1910: struct hfsnode *hp; ! 1911: void *attrbufptr; ! 1912: void *varbufptr; ! 1913: attrgroup_t a; ! 1914: u_long attrlength; ! 1915: ! 1916: hp = VTOH(root_vp); ! 1917: attrbufptr = *attrbufptrptr; ! 1918: varbufptr = *varbufptrptr; ! 1919: ! 1920: if ((a = alist->commonattr) != 0) ! 1921: { ! 1922: if (a & ATTR_CMN_NAME) ! 1923: { ! 1924: attrlength = strlen(catalogInfo->spec.name) + 1; ! 1925: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 1926: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 1927: (void) strncpy((unsigned char *)varbufptr, (unsigned char *) &(catalogInfo->spec.name), attrlength); ! 1928: // ((char *) varbufptr)[attrlength-1] = 0; // Now it's a C string ! 1929: ! 1930: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 1931: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 1932: ++((struct attrreference *)attrbufptr); ! 1933: }; ! 1934: if (a & ATTR_CMN_DEVID) *((dev_t *)attrbufptr)++ = H_DEV(hp); ! 1935: if (a & ATTR_CMN_FSID) { ! 1936: *((fsid_t *)attrbufptr) = VTOVFS(root_vp)->mnt_stat.f_fsid; ! 1937: if (VTOVCB(root_vp)->vcbSigWord == kHFSSigWord) ((fsid_t *)attrbufptr)->val[0] |= 0x40000000; ! 1938: ++((fsid_t *)attrbufptr); ! 1939: }; ! 1940: if (a & ATTR_CMN_OBJTYPE) ! 1941: { ! 1942: switch (catalogInfo->nodeData.cnd_type) { ! 1943: case kCatalogFolderNode: ! 1944: *((fsobj_type_t *)attrbufptr)++ = VDIR; ! 1945: break; ! 1946: ! 1947: case kCatalogFileNode: ! 1948: /* Files in an HFS+ catalog can represent many things (regular files, symlinks, block/character devices, ... */ ! 1949: if ((HTOVCB(hp)->vcbSigWord == kHFSPlusSigWord) && ! 1950: (catalogInfo->nodeData.cnd_permissions & IFMT)) { ! 1951: *((fsobj_type_t *)attrbufptr)++ = ! 1952: IFTOVT((mode_t)(catalogInfo->nodeData.cnd_permissions & 0x0000FFFF)); ! 1953: } else { ! 1954: *((fsobj_type_t *)attrbufptr)++ = VREG; ! 1955: }; ! 1956: break; ! 1957: ! 1958: default: ! 1959: *((fsobj_type_t *)attrbufptr)++ = VNON; ! 1960: break; ! 1961: }; ! 1962: } ! 1963: if (a & ATTR_CMN_OBJTAG) *((fsobj_tag_t *)attrbufptr)++ = root_vp->v_tag; ! 1964: if (a & ATTR_CMN_OBJID) ! 1965: { ! 1966: ((fsobj_id_t *)attrbufptr)->fid_objno = catalogInfo->nodeData.cnd_nodeID; ! 1967: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1968: ++((fsobj_id_t *)attrbufptr); ! 1969: }; ! 1970: if (a & ATTR_CMN_OBJPERMANENTID) ! 1971: { ! 1972: ((fsobj_id_t *)attrbufptr)->fid_objno = catalogInfo->nodeData.cnd_nodeID; ! 1973: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1974: ++((fsobj_id_t *)attrbufptr); ! 1975: }; ! 1976: if (a & ATTR_CMN_PAROBJID) ! 1977: { ! 1978: ((fsobj_id_t *)attrbufptr)->fid_objno = catalogInfo->spec.parID; ! 1979: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 1980: ++((fsobj_id_t *)attrbufptr); ! 1981: }; ! 1982: if (a & ATTR_CMN_SCRIPT) ! 1983: { ! 1984: if (HTOVCB(hp)->vcbSigWord == kHFSPlusSigWord) { ! 1985: *((text_encoding_t *)attrbufptr)++ = catalogInfo->nodeData.cnd_textEncoding; ! 1986: } else { ! 1987: *((text_encoding_t *)attrbufptr)++ = VTOHFS(root_vp)->hfs_encoding; ! 1988: } ! 1989: }; ! 1990: if (a & ATTR_CMN_CRTIME) ! 1991: { ! 1992: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(catalogInfo->nodeData.cnd_createDate); ! 1993: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 1994: ++((struct timespec *)attrbufptr); ! 1995: }; ! 1996: if (a & ATTR_CMN_MODTIME) ! 1997: { ! 1998: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(catalogInfo->nodeData.cnd_contentModDate); ! 1999: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2000: ++((struct timespec *)attrbufptr); ! 2001: }; ! 2002: if (a & ATTR_CMN_CHGTIME) ! 2003: { ! 2004: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(catalogInfo->nodeData.cnd_attributeModDate); ! 2005: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2006: ++((struct timespec *)attrbufptr); ! 2007: }; ! 2008: if (a & ATTR_CMN_ACCTIME) ! 2009: { ! 2010: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(catalogInfo->nodeData.cnd_accessDate); ! 2011: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2012: ++((struct timespec *)attrbufptr); ! 2013: }; ! 2014: if (a & ATTR_CMN_BKUPTIME) ! 2015: { ! 2016: ((struct timespec *)attrbufptr)->tv_sec = to_bsd_time(catalogInfo->nodeData.cnd_backupDate); ! 2017: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2018: ++((struct timespec *)attrbufptr); ! 2019: }; ! 2020: if (a & ATTR_CMN_FNDRINFO) ! 2021: { ! 2022: bcopy (&catalogInfo->nodeData.cnd_finderInfo, attrbufptr, sizeof(catalogInfo->nodeData.cnd_finderInfo)); ! 2023: (char *)attrbufptr += sizeof(catalogInfo->nodeData.cnd_finderInfo); ! 2024: }; ! 2025: if (a & ATTR_CMN_OWNERID) { ! 2026: *((uid_t *)attrbufptr)++ = catalogInfo->nodeData.cnd_ownerID; ! 2027: } ! 2028: if (a & ATTR_CMN_GRPID) { ! 2029: *((gid_t *)attrbufptr)++ = catalogInfo->nodeData.cnd_groupID; ! 2030: } ! 2031: if (a & ATTR_CMN_ACCESSMASK) { ! 2032: *((u_long *)attrbufptr)++ = ! 2033: (u_long)(mode_t)(catalogInfo->nodeData.cnd_permissions & 0x0000FFFF); ! 2034: } ! 2035: if (a & ATTR_CMN_NAMEDATTRCOUNT) *((u_long *)attrbufptr)++ = 0; /* XXX PPD TBC */ ! 2036: if (a & ATTR_CMN_NAMEDATTRLIST) ! 2037: { ! 2038: attrlength = 0; ! 2039: ((struct attrreference *)attrbufptr)->attr_dataoffset = 0; ! 2040: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 2041: ! 2042: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 2043: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 2044: ++((struct attrreference *)attrbufptr); ! 2045: }; ! 2046: if (a & ATTR_CMN_FLAGS) ! 2047: *((u_long *)attrbufptr)++ = ! 2048: (u_long) ((((catalogInfo->nodeData.cnd_permissions & 0xFFFF0000) >> 8) & 0x00FF0000) | ! 2049: (((catalogInfo->nodeData.cnd_permissions & 0xFFFF0000) >> 24) & 0x000000FF)); ! 2050: }; ! 2051: ! 2052: *attrbufptrptr = attrbufptr; ! 2053: *varbufptrptr = varbufptr; ! 2054: } ! 2055: ! 2056: ! 2057: void PackCommonAttributeBlock(struct attrlist *alist, ! 2058: struct vnode *vp, ! 2059: struct hfsCatalogInfo *catInfo, ! 2060: void **attrbufptrptr, ! 2061: void **varbufptrptr) { ! 2062: struct hfsnode *hp; ! 2063: void *attrbufptr; ! 2064: void *varbufptr; ! 2065: attrgroup_t a; ! 2066: u_long attrlength; ! 2067: ! 2068: hp = VTOH(vp); ! 2069: ! 2070: attrbufptr = *attrbufptrptr; ! 2071: varbufptr = *varbufptrptr; ! 2072: ! 2073: if ((a = alist->commonattr) != 0) { ! 2074: if (a & ATTR_CMN_NAME) { ! 2075: attrlength = hp->h_meta->h_namelen + 1; ! 2076: ((struct attrreference *)attrbufptr)->attr_dataoffset = (char *)varbufptr - (char *)attrbufptr; ! 2077: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 2078: (void) strncpy((unsigned char *)varbufptr, H_NAME(hp), attrlength); ! 2079: ! 2080: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 2081: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 2082: ++((struct attrreference *)attrbufptr); ! 2083: }; ! 2084: if (a & ATTR_CMN_DEVID) *((dev_t *)attrbufptr)++ = H_DEV(hp); ! 2085: if (a & ATTR_CMN_FSID) { ! 2086: *((fsid_t *)attrbufptr) = VTOVFS(vp)->mnt_stat.f_fsid; ! 2087: if (VTOVCB(vp)->vcbSigWord == kHFSSigWord) ((fsid_t *)attrbufptr)->val[0] |= 0x40000000; ! 2088: ++((fsid_t *)attrbufptr); ! 2089: }; ! 2090: if (a & ATTR_CMN_OBJTYPE) *((fsobj_type_t *)attrbufptr)++ = vp->v_type; ! 2091: if (a & ATTR_CMN_OBJTAG) *((fsobj_tag_t *)attrbufptr)++ = vp->v_tag; ! 2092: if (a & ATTR_CMN_OBJID) { ! 2093: ((fsobj_id_t *)attrbufptr)->fid_objno = H_FILEID(hp); ! 2094: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 2095: ++((fsobj_id_t *)attrbufptr); ! 2096: }; ! 2097: if (a & ATTR_CMN_OBJPERMANENTID) { ! 2098: ((fsobj_id_t *)attrbufptr)->fid_objno = H_FILEID(hp); ! 2099: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 2100: ++((fsobj_id_t *)attrbufptr); ! 2101: }; ! 2102: if (a & ATTR_CMN_PAROBJID) { ! 2103: ((fsobj_id_t *)attrbufptr)->fid_objno = H_DIRID(hp); ! 2104: ((fsobj_id_t *)attrbufptr)->fid_generation = 0; ! 2105: ++((fsobj_id_t *)attrbufptr); ! 2106: }; ! 2107: if (a & ATTR_CMN_SCRIPT) ! 2108: { ! 2109: if (HTOVCB(hp)->vcbSigWord == kHFSPlusSigWord) { ! 2110: *((text_encoding_t *)attrbufptr)++ = catInfo->nodeData.cnd_textEncoding; ! 2111: } else { ! 2112: *((text_encoding_t *)attrbufptr)++ = VTOHFS(vp)->hfs_encoding; ! 2113: } ! 2114: }; ! 2115: if (a & ATTR_CMN_CRTIME) { ! 2116: ((struct timespec *)attrbufptr)->tv_sec = hp->h_meta->h_crtime; ! 2117: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2118: ++((struct timespec *)attrbufptr); ! 2119: }; ! 2120: if (a & ATTR_CMN_MODTIME) { ! 2121: ((struct timespec *)attrbufptr)->tv_sec = hp->h_meta->h_mtime; ! 2122: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2123: ++((struct timespec *)attrbufptr); ! 2124: }; ! 2125: if (a & ATTR_CMN_CHGTIME) { ! 2126: ((struct timespec *)attrbufptr)->tv_sec = hp->h_meta->h_ctime; ! 2127: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2128: ++((struct timespec *)attrbufptr); ! 2129: }; ! 2130: if (a & ATTR_CMN_ACCTIME) { ! 2131: ((struct timespec *)attrbufptr)->tv_sec = hp->h_meta->h_atime; ! 2132: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2133: ++((struct timespec *)attrbufptr); ! 2134: }; ! 2135: if (a & ATTR_CMN_BKUPTIME) { ! 2136: ((struct timespec *)attrbufptr)->tv_sec = hp->h_meta->h_butime; ! 2137: ((struct timespec *)attrbufptr)->tv_nsec = 0; ! 2138: ++((struct timespec *)attrbufptr); ! 2139: }; ! 2140: if (a & ATTR_CMN_FNDRINFO) { ! 2141: bcopy (&catInfo->nodeData.cnd_finderInfo, attrbufptr, sizeof(catInfo->nodeData.cnd_finderInfo)); ! 2142: (char *)attrbufptr += sizeof(catInfo->nodeData.cnd_finderInfo); ! 2143: }; ! 2144: if (a & ATTR_CMN_OWNERID) *((uid_t *)attrbufptr)++ = hp->h_meta->h_uid; ! 2145: if (a & ATTR_CMN_GRPID) *((gid_t *)attrbufptr)++ = hp->h_meta->h_gid; ! 2146: if (a & ATTR_CMN_ACCESSMASK) *((u_long *)attrbufptr)++ = (u_long)hp->h_meta->h_mode; ! 2147: if (a & ATTR_CMN_NAMEDATTRCOUNT) *((u_long *)attrbufptr)++ = 0; /* XXX PPD TBC */ ! 2148: if (a & ATTR_CMN_NAMEDATTRLIST) { ! 2149: attrlength = 0; ! 2150: ((struct attrreference *)attrbufptr)->attr_dataoffset = 0; ! 2151: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 2152: ! 2153: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 2154: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 2155: ++((struct attrreference *)attrbufptr); ! 2156: }; ! 2157: if (a & ATTR_CMN_FLAGS) *((u_long *)attrbufptr)++ = hp->h_meta->h_pflags; ! 2158: }; ! 2159: ! 2160: *attrbufptrptr = attrbufptr; ! 2161: *varbufptrptr = varbufptr; ! 2162: } ! 2163: ! 2164: ! 2165: // Pack the directory attributes given hfsCatalogInfo ! 2166: void PackCatalogInfoDirAttributeBlock( struct attrlist *alist, struct vnode *vp, ! 2167: struct hfsCatalogInfo *catInfo, void **attrbufptrptr, void **varbufptrptr ) ! 2168: { ! 2169: void *attrbufptr; ! 2170: attrgroup_t a; ! 2171: u_long valence; ! 2172: ! 2173: attrbufptr = *attrbufptrptr; ! 2174: a = alist->dirattr; ! 2175: ! 2176: if ( (catInfo->nodeData.cnd_type == kCatalogFolderNode) && (a != 0) ) { ! 2177: valence = catInfo->nodeData.cnd_valence; ! 2178: if ((catInfo->spec.parID == kRootParID) && ! 2179: (VTOHFS(vp)->hfs_private_metadata_dir != 0)) { ! 2180: --valence; /* hide private dir */ ! 2181: } ! 2182: /* The 'link count' is faked */ ! 2183: if (a & ATTR_DIR_LINKCOUNT) ! 2184: *((u_long *)attrbufptr)++ = 2 + valence; ! 2185: if (a & ATTR_DIR_ENTRYCOUNT) ! 2186: *((u_long *)attrbufptr)++ = valence; ! 2187: }; ! 2188: ! 2189: *attrbufptrptr = attrbufptr; ! 2190: } ! 2191: ! 2192: ! 2193: void PackDirAttributeBlock(struct attrlist *alist, ! 2194: struct vnode *vp, ! 2195: struct hfsCatalogInfo *catInfo, ! 2196: void **attrbufptrptr, ! 2197: void **varbufptrptr) { ! 2198: void *attrbufptr; ! 2199: attrgroup_t a; ! 2200: u_long valence; ! 2201: ! 2202: attrbufptr = *attrbufptrptr; ! 2203: ! 2204: a = alist->dirattr; ! 2205: if ((vp->v_type == VDIR) && (a != 0)) { ! 2206: valence = catInfo->nodeData.cnd_valence; ! 2207: if ((catInfo->spec.parID == kRootParID) && ! 2208: (VTOHFS(vp)->hfs_private_metadata_dir != 0)) { ! 2209: --valence; /* hide private dir */ ! 2210: } ! 2211: ! 2212: /* The 'link count' is faked */ ! 2213: if (a & ATTR_DIR_LINKCOUNT) ! 2214: *((u_long *)attrbufptr)++ = 2 + valence; ! 2215: if (a & ATTR_DIR_ENTRYCOUNT) ! 2216: *((u_long *)attrbufptr)++ = valence; ! 2217: }; ! 2218: ! 2219: *attrbufptrptr = attrbufptr; ! 2220: } ! 2221: ! 2222: ! 2223: ! 2224: // Pack the file attributes from the hfsCatalogInfo for the file. ! 2225: void PackCatalogInfoFileAttributeBlock( struct attrlist *alist, struct vnode *root_vp, struct hfsCatalogInfo *catInfo, void **attrbufptrptr, void **varbufptrptr ) ! 2226: { ! 2227: void *attrbufptr; ! 2228: void *varbufptr; ! 2229: attrgroup_t a; ! 2230: u_long attrlength; ! 2231: ExtendedVCB *vcb = VTOVCB(root_vp); ! 2232: ! 2233: attrbufptr = *attrbufptrptr; ! 2234: varbufptr = *varbufptrptr; ! 2235: ! 2236: a = alist->fileattr; ! 2237: if ( (catInfo->nodeData.cnd_type == kCatalogFileNode) && (a != 0) ) ! 2238: { ! 2239: #if HFS_HARDLINKS ! 2240: if (a & ATTR_FILE_LINKCOUNT) { ! 2241: u_long linkcnt = catInfo->nodeData.cnd_linkCount; ! 2242: ! 2243: if (linkcnt < 1) ! 2244: linkcnt = 1; ! 2245: *((u_long *)attrbufptr)++ = linkcnt; ! 2246: } ! 2247: #else ! 2248: if (a & ATTR_FILE_LINKCOUNT) *((u_long *)attrbufptr)++ = 1; ! 2249: #endif ! 2250: if (a & ATTR_FILE_TOTALSIZE) { ! 2251: *((off_t *)attrbufptr)++ = ! 2252: (off_t)catInfo->nodeData.cnd_datafork.logicalSize + ! 2253: (off_t)catInfo->nodeData.cnd_rsrcfork.logicalSize; ! 2254: } ! 2255: if (a & ATTR_FILE_ALLOCSIZE) { ! 2256: *((off_t *)attrbufptr)++ = ! 2257: (off_t)(catInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize) + ! 2258: (off_t)(catInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize); ! 2259: } ! 2260: if (a & ATTR_FILE_IOBLOCKSIZE) { ! 2261: *((u_long *)attrbufptr)++ = (u_long)(VTOHFS(root_vp)->hfs_logBlockSize); ! 2262: } ! 2263: if (a & ATTR_FILE_CLUMPSIZE) { ! 2264: *((u_long *)attrbufptr)++ = vcb->vcbClpSiz; ! 2265: } ! 2266: if (a & ATTR_FILE_DEVTYPE) { ! 2267: *((u_long *)attrbufptr)++ = ! 2268: (u_long)catInfo->nodeData.cnd_specialDevice; ! 2269: } ! 2270: if (a & ATTR_FILE_FILETYPE) { ! 2271: *((u_long *)attrbufptr)++ = 0; /* XXX PPD */ ! 2272: } ! 2273: if (a & ATTR_FILE_FORKCOUNT) { ! 2274: *((u_long *)attrbufptr)++ = 2; /* XXX PPD */ ! 2275: } ! 2276: if (a & ATTR_FILE_FORKLIST) { ! 2277: attrlength = 0; ! 2278: ((struct attrreference *)attrbufptr)->attr_dataoffset = 0; ! 2279: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 2280: ! 2281: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 2282: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 2283: ++((struct attrreference *)attrbufptr); ! 2284: }; ! 2285: if (a & ATTR_FILE_DATALENGTH) { ! 2286: *((off_t *)attrbufptr)++ = ! 2287: (off_t)catInfo->nodeData.cnd_datafork.logicalSize; ! 2288: } ! 2289: if (a & ATTR_FILE_DATAALLOCSIZE) { ! 2290: *((off_t *)attrbufptr)++ = ! 2291: (off_t)(catInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize); ! 2292: } ! 2293: if (a & ATTR_FILE_DATAEXTENTS) { ! 2294: bcopy(&catInfo->nodeData.cnd_datafork.extents, attrbufptr, sizeof(extentrecord)); ! 2295: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2296: }; ! 2297: if (a & ATTR_FILE_RSRCLENGTH) { ! 2298: *((off_t *)attrbufptr)++ = ! 2299: (off_t)catInfo->nodeData.cnd_rsrcfork.logicalSize; ! 2300: } ! 2301: if (a & ATTR_FILE_RSRCALLOCSIZE) { ! 2302: *((off_t *)attrbufptr)++ = ! 2303: (off_t)(catInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize); ! 2304: } ! 2305: if (a & ATTR_FILE_RSRCEXTENTS) { ! 2306: bcopy(&catInfo->nodeData.cnd_rsrcfork.extents, attrbufptr, sizeof(extentrecord)); ! 2307: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2308: }; ! 2309: }; ! 2310: ! 2311: *attrbufptrptr = attrbufptr; ! 2312: *varbufptrptr = varbufptr; ! 2313: } ! 2314: ! 2315: ! 2316: void PackFileAttributeBlock(struct attrlist *alist, ! 2317: struct vnode *vp, ! 2318: struct hfsCatalogInfo *catInfo, ! 2319: void **attrbufptrptr, ! 2320: void **varbufptrptr) { ! 2321: struct hfsnode *hp = VTOH(vp); ! 2322: FCB *fcb = HTOFCB(hp); ! 2323: ExtendedVCB *vcb = HTOVCB(hp); ! 2324: Boolean isHFSPlus = (vcb->vcbSigWord == kHFSPlusSigWord); ! 2325: void *attrbufptr = *attrbufptrptr; ! 2326: void *varbufptr = *varbufptrptr; ! 2327: attrgroup_t a = alist->fileattr; ! 2328: u_long attrlength; ! 2329: ! 2330: if (a != 0) { ! 2331: #if HFS_HARDLINKS ! 2332: if (a & ATTR_FILE_LINKCOUNT) { ! 2333: u_long linkcnt = catInfo->nodeData.cnd_linkCount; ! 2334: ! 2335: if (linkcnt < 1) ! 2336: linkcnt = 1; ! 2337: *((u_long *)attrbufptr)++ = linkcnt; ! 2338: } ! 2339: #else ! 2340: if (a & ATTR_FILE_LINKCOUNT) *((u_long *)attrbufptr)++ = 1; ! 2341: #endif ! 2342: if (a & ATTR_FILE_TOTALSIZE) { ! 2343: *((off_t *)attrbufptr)++ = ! 2344: (off_t)catInfo->nodeData.cnd_datafork.logicalSize + ! 2345: (off_t)catInfo->nodeData.cnd_rsrcfork.logicalSize; ! 2346: } ! 2347: if (a & ATTR_FILE_ALLOCSIZE) { ! 2348: switch (H_FORKTYPE(hp)) { ! 2349: case kDataFork: ! 2350: *((off_t *)attrbufptr)++ = ! 2351: (off_t)fcb->fcbPLen + ! 2352: (off_t)(catInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize); ! 2353: break; ! 2354: case kRsrcFork: ! 2355: *((off_t *)attrbufptr)++ = ! 2356: (off_t)fcb->fcbPLen + ! 2357: (off_t)(catInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize); ! 2358: break; ! 2359: default: ! 2360: *((off_t *)attrbufptr)++ = ! 2361: (off_t)(catInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize) + ! 2362: (off_t)(catInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize); ! 2363: }; ! 2364: }; ! 2365: if (a & ATTR_FILE_IOBLOCKSIZE) *((u_long *)attrbufptr)++ = GetLogicalBlockSize(vp); ! 2366: if (a & ATTR_FILE_CLUMPSIZE) *((u_long *)attrbufptr)++ = fcb->fcbClmpSize; ! 2367: if (a & ATTR_FILE_DEVTYPE) { ! 2368: *((u_long *)attrbufptr)++ = (u_long)catInfo->nodeData.cnd_specialDevice; ! 2369: } ! 2370: if (a & ATTR_FILE_FILETYPE) *((u_long *)attrbufptr)++ = 0; /* XXX PPD */ ! 2371: if (a & ATTR_FILE_FORKCOUNT) *((u_long *)attrbufptr)++ = 2; /* XXX PPD */ ! 2372: if (a & ATTR_FILE_FORKLIST) { ! 2373: attrlength = 0; ! 2374: ((struct attrreference *)attrbufptr)->attr_dataoffset = 0; ! 2375: ((struct attrreference *)attrbufptr)->attr_length = attrlength; ! 2376: ! 2377: /* Advance beyond the space just allocated and round up to the next 4-byte boundary: */ ! 2378: (char *)varbufptr += attrlength + ((4 - (attrlength & 3)) & 3); ! 2379: ++((struct attrreference *)attrbufptr); ! 2380: }; ! 2381: if (H_FORKTYPE(hp) == kDataFork) { ! 2382: if (a & ATTR_FILE_DATALENGTH) ! 2383: #if MACH_NBC ! 2384: if ((vp->v_type == VREG) && vp->v_vm_info && vp->v_vm_info->mapped && ! 2385: (!vp->v_vm_info->filesize)) { ! 2386: *((off_t *)attrbufptr)++ = vp->v_vm_info->vnode_size; ! 2387: } ! 2388: else ! 2389: #endif /* MACH_NBC */ ! 2390: *((off_t *)attrbufptr)++ = fcb->fcbEOF; ! 2391: if (a & ATTR_FILE_DATAALLOCSIZE) *((off_t *)attrbufptr)++ = fcb->fcbPLen; ! 2392: if (a & ATTR_FILE_DATAEXTENTS) { ! 2393: bcopy ( fcb->fcbExtents, attrbufptr, sizeof(extentrecord)); ! 2394: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2395: }; ! 2396: } else { ! 2397: if (a & ATTR_FILE_DATALENGTH) { ! 2398: *((off_t *)attrbufptr)++ = ! 2399: (off_t)catInfo->nodeData.cnd_datafork.logicalSize; ! 2400: } ! 2401: if (a & ATTR_FILE_DATAALLOCSIZE) { ! 2402: *((off_t *)attrbufptr)++ = ! 2403: (off_t)(catInfo->nodeData.cnd_datafork.totalBlocks * vcb->blockSize); ! 2404: } ! 2405: if (a & ATTR_FILE_DATAEXTENTS) { ! 2406: bcopy(&catInfo->nodeData.cnd_datafork.extents, attrbufptr, sizeof(extentrecord)); ! 2407: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2408: }; ! 2409: }; ! 2410: if (H_FORKTYPE(hp) == kRsrcFork) { ! 2411: if (a & ATTR_FILE_RSRCLENGTH) ! 2412: #if MACH_NBC ! 2413: if ((vp->v_type == VREG) && vp->v_vm_info && vp->v_vm_info->mapped && ! 2414: (!vp->v_vm_info->filesize)) { ! 2415: *((off_t *)attrbufptr)++ = vp->v_vm_info->vnode_size; ! 2416: } ! 2417: else ! 2418: #endif /* MACH_NBC */ ! 2419: *((off_t *)attrbufptr)++ = fcb->fcbEOF; ! 2420: if (a & ATTR_FILE_RSRCALLOCSIZE) *((off_t *)attrbufptr)++ = fcb->fcbPLen; ! 2421: if (a & ATTR_FILE_RSRCEXTENTS) { ! 2422: bcopy ( fcb->fcbExtents, attrbufptr, sizeof(extentrecord)); ! 2423: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2424: }; ! 2425: } else { ! 2426: if (a & ATTR_FILE_RSRCLENGTH) { ! 2427: *((off_t *)attrbufptr)++ = ! 2428: (off_t)catInfo->nodeData.cnd_rsrcfork.logicalSize; ! 2429: } ! 2430: if (a & ATTR_FILE_RSRCALLOCSIZE) { ! 2431: *((off_t *)attrbufptr)++ = ! 2432: (off_t)(catInfo->nodeData.cnd_rsrcfork.totalBlocks * vcb->blockSize); ! 2433: } ! 2434: if (a & ATTR_FILE_RSRCEXTENTS) { ! 2435: bcopy(&catInfo->nodeData.cnd_rsrcfork.extents, attrbufptr, sizeof(extentrecord)); ! 2436: (char *)attrbufptr += sizeof(extentrecord) + ((4 - (sizeof(extentrecord) & 3)) & 3); ! 2437: }; ! 2438: }; ! 2439: }; ! 2440: ! 2441: *attrbufptrptr = attrbufptr; ! 2442: *varbufptrptr = varbufptr; ! 2443: } ! 2444: ! 2445: #if 0 ! 2446: void PackForkAttributeBlock(struct attrlist *alist, ! 2447: struct vnode *vp, ! 2448: struct hfsCatalogInfo *catInfo, ! 2449: void **attrbufptrptr, ! 2450: void **varbufptrptr) { ! 2451: /* XXX PPD TBC */ ! 2452: } ! 2453: #endif ! 2454: ! 2455: ! 2456: // This routine takes catInfo, and alist, as inputs and packs it into an attribute block. ! 2457: void PackCatalogInfoAttributeBlock ( struct attrlist *alist, struct vnode *root_vp, struct hfsCatalogInfo *catInfo, void **attrbufptrptr, void **varbufptrptr) ! 2458: { ! 2459: //XXX Preflight that alist only contains bits with fields in catInfo ! 2460: ! 2461: PackCommonCatalogInfoAttributeBlock( alist, root_vp, catInfo, attrbufptrptr, varbufptrptr ); ! 2462: ! 2463: switch ( catInfo->nodeData.cnd_type ) ! 2464: { ! 2465: case kCatalogFolderNode: ! 2466: PackCatalogInfoDirAttributeBlock( alist, root_vp, catInfo, attrbufptrptr, varbufptrptr ); ! 2467: break; ! 2468: ! 2469: case kCatalogFileNode: ! 2470: PackCatalogInfoFileAttributeBlock( alist, root_vp, catInfo, attrbufptrptr, varbufptrptr ); ! 2471: break; ! 2472: ! 2473: default: /* Without this the compiler complains about VNON,VBLK,VCHR,VLNK,VSOCK,VFIFO,VBAD and VSTR not being handled... */ ! 2474: /* XXX PPD - Panic? */ ! 2475: break; ! 2476: } ! 2477: } ! 2478: ! 2479: ! 2480: ! 2481: void PackAttributeBlock(struct attrlist *alist, ! 2482: struct vnode *vp, ! 2483: struct hfsCatalogInfo *catInfo, ! 2484: void **attrbufptrptr, ! 2485: void **varbufptrptr) ! 2486: { ! 2487: if (alist->volattr != 0) { ! 2488: DBG_ASSERT((vp->v_flag & VROOT) != 0); ! 2489: PackVolumeInfo(alist,vp, catInfo, attrbufptrptr, varbufptrptr); ! 2490: } else { ! 2491: PackCommonAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2492: ! 2493: switch (vp->v_type) { ! 2494: case VDIR: ! 2495: PackDirAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2496: break; ! 2497: ! 2498: case VREG: ! 2499: case VLNK: ! 2500: PackFileAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2501: break; ! 2502: ! 2503: /* Without this the compiler complains about VNON,VBLK,VCHR,VLNK,VSOCK,VFIFO,VBAD and VSTR ! 2504: not being handled... ! 2505: */ ! 2506: default: ! 2507: /* XXX PPD - Panic? */ ! 2508: break; ! 2509: }; ! 2510: }; ! 2511: }; ! 2512: ! 2513: ! 2514: ! 2515: void UnpackVolumeAttributeBlock(struct attrlist *alist, ! 2516: struct vnode *root_vp, ! 2517: ExtendedVCB *vcb, ! 2518: void **attrbufptrptr, ! 2519: void **varbufptrptr) { ! 2520: void *attrbufptr = *attrbufptrptr; ! 2521: attrgroup_t a; ! 2522: text_encoding_t nameEncoding; ! 2523: ! 2524: if ((alist->commonattr == 0) && (alist->volattr == 0)) { ! 2525: return; /* Get out without dirtying the VCB */ ! 2526: }; ! 2527: ! 2528: VCB_LOCK(vcb); ! 2529: ! 2530: a = alist->commonattr; ! 2531: ! 2532: if (a & ATTR_CMN_SCRIPT) { ! 2533: /* XXX PPD No use for this info right now... */ ! 2534: nameEncoding = *(((text_encoding_t *)attrbufptr)++); ! 2535: #if HFS_DIAGNOSTIC ! 2536: a &= ~ATTR_CMN_SCRIPT; ! 2537: #endif ! 2538: }; ! 2539: if (a & ATTR_CMN_CRTIME) { ! 2540: /* ! 2541: * HFS Plus stores the volume create date in *local* ! 2542: * time in the volume header. So don't set the create ! 2543: * date in the vcb. Set the root's crtime instead. ! 2544: */ ! 2545: if (vcb->vcbSigWord == kHFSPlusSigWord) { ! 2546: VTOH(root_vp)->h_meta->h_crtime = ! 2547: (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2548: } else { ! 2549: vcb->vcbCrDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2550: } ! 2551: ++((struct timespec *)attrbufptr); ! 2552: #if HFS_DIAGNOSTIC ! 2553: a &= ~ATTR_CMN_CRTIME; ! 2554: #endif ! 2555: }; ! 2556: if (a & ATTR_CMN_MODTIME) { ! 2557: vcb->vcbLsMod = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2558: ++((struct timespec *)attrbufptr); ! 2559: #if HFS_DIAGNOSTIC ! 2560: a &= ~ATTR_CMN_MODTIME; ! 2561: #endif ! 2562: }; ! 2563: if (a & ATTR_CMN_BKUPTIME) { ! 2564: vcb->vcbVolBkUp = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2565: ++((struct timespec *)attrbufptr); ! 2566: #if HFS_DIAGNOSTIC ! 2567: a &= ~ATTR_CMN_BKUPTIME; ! 2568: #endif ! 2569: }; ! 2570: if (a & ATTR_CMN_FNDRINFO) { ! 2571: bcopy (attrbufptr, &vcb->vcbFndrInfo, sizeof(vcb->vcbFndrInfo)); ! 2572: (char *)attrbufptr += sizeof(vcb->vcbFndrInfo); ! 2573: #if HFS_DIAGNOSTIC ! 2574: a &= ~ATTR_CMN_FNDRINFO; ! 2575: #endif ! 2576: }; ! 2577: ! 2578: DBG_ASSERT(a == 0); /* All common attributes for volumes must've been handled by now... */ ! 2579: ! 2580: a = alist->volattr & ~ATTR_VOL_INFO; ! 2581: if (a & ATTR_VOL_NAME) { ! 2582: copystr(((char *)attrbufptr) + *((u_long *)attrbufptr), vcb->vcbVN, sizeof(vcb->vcbVN), NULL); ! 2583: (char *)attrbufptr += sizeof(struct attrreference); ! 2584: #if HFS_DIAGNOSTIC ! 2585: a &= ~ATTR_VOL_NAME; ! 2586: #endif ! 2587: }; ! 2588: ! 2589: DBG_ASSERT(a == 0); /* All common attributes for volumes must've been handled by now... */ ! 2590: ! 2591: vcb->vcbFlags |= 0xFF00; // Mark the VCB dirty ! 2592: ! 2593: VCB_UNLOCK(vcb); ! 2594: } ! 2595: ! 2596: ! 2597: void UnpackCommonAttributeBlock(struct attrlist *alist, ! 2598: struct vnode *vp, ! 2599: struct hfsCatalogInfo *catInfo, ! 2600: void **attrbufptrptr, ! 2601: void **varbufptrptr) { ! 2602: struct hfsnode *hp = VTOH(vp); ! 2603: void *attrbufptr; ! 2604: attrgroup_t a; ! 2605: ! 2606: attrbufptr = *attrbufptrptr; ! 2607: ! 2608: DBG_ASSERT(catInfo != NULL); ! 2609: ! 2610: a = alist->commonattr; ! 2611: if (a & ATTR_CMN_SCRIPT) { ! 2612: /* XXX PPD No use for this info right now... */ ! 2613: ++((text_encoding_t *)attrbufptr); ! 2614: #if HFS_DIAGNOSTIC ! 2615: a &= ~ATTR_CMN_SCRIPT; ! 2616: #endif ! 2617: }; ! 2618: if (a & ATTR_CMN_CRTIME) { ! 2619: catInfo->nodeData.cnd_createDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2620: VTOH(vp)->h_meta->h_crtime = (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2621: ++((struct timespec *)attrbufptr); ! 2622: #if HFS_DIAGNOSTIC ! 2623: a &= ~ATTR_CMN_CRTIME; ! 2624: #endif ! 2625: }; ! 2626: if (a & ATTR_CMN_MODTIME) { ! 2627: catInfo->nodeData.cnd_contentModDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2628: VTOH(vp)->h_meta->h_mtime = (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2629: ++((struct timespec *)attrbufptr); ! 2630: #if HFS_DIAGNOSTIC ! 2631: a &= ~ATTR_CMN_MODTIME; ! 2632: #endif ! 2633: }; ! 2634: if (a & ATTR_CMN_CHGTIME) { ! 2635: catInfo->nodeData.cnd_attributeModDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2636: VTOH(vp)->h_meta->h_ctime = (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2637: ++((struct timespec *)attrbufptr); ! 2638: #if HFS_DIAGNOSTIC ! 2639: a &= ~ATTR_CMN_CHGTIME; ! 2640: #endif ! 2641: }; ! 2642: if (a & ATTR_CMN_ACCTIME) { ! 2643: catInfo->nodeData.cnd_accessDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2644: VTOH(vp)->h_meta->h_atime = (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2645: ++((struct timespec *)attrbufptr); ! 2646: #if HFS_DIAGNOSTIC ! 2647: a &= ~ATTR_CMN_ACCTIME; ! 2648: #endif ! 2649: }; ! 2650: if (a & ATTR_CMN_BKUPTIME) { ! 2651: catInfo->nodeData.cnd_backupDate = to_hfs_time((UInt32)((struct timespec *)attrbufptr)->tv_sec); ! 2652: VTOH(vp)->h_meta->h_butime = (UInt32)((struct timespec *)attrbufptr)->tv_sec; ! 2653: ++((struct timespec *)attrbufptr); ! 2654: #if HFS_DIAGNOSTIC ! 2655: a &= ~ATTR_CMN_BKUPTIME; ! 2656: #endif ! 2657: }; ! 2658: if (a & ATTR_CMN_FNDRINFO) { ! 2659: bcopy (attrbufptr, &catInfo->nodeData.cnd_finderInfo, sizeof(catInfo->nodeData.cnd_finderInfo)); ! 2660: (char *)attrbufptr += sizeof(catInfo->nodeData.cnd_finderInfo); ! 2661: #if HFS_DIAGNOSTIC ! 2662: a &= ~ATTR_CMN_FNDRINFO; ! 2663: #endif ! 2664: }; ! 2665: if (a & ATTR_CMN_OWNERID) { ! 2666: if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) { ! 2667: u_int32_t uid = (u_int32_t)*((uid_t *)attrbufptr)++; ! 2668: if (uid != (uid_t)VNOVAL) ! 2669: hp->h_meta->h_uid = uid; /* catalog will get updated by hfs_chown() */ ! 2670: } ! 2671: else { ! 2672: ((uid_t *)attrbufptr)++; ! 2673: } ! 2674: #if HFS_DIAGNOSTIC ! 2675: a &= ~ATTR_CMN_OWNERID; ! 2676: #endif ! 2677: }; ! 2678: if (a & ATTR_CMN_GRPID) { ! 2679: u_int32_t gid = (u_int32_t)*((gid_t *)attrbufptr)++; ! 2680: if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) { ! 2681: if (gid != (gid_t)VNOVAL) ! 2682: hp->h_meta->h_gid = gid; /* catalog will get updated by hfs_chown() */ ! 2683: }; ! 2684: #if HFS_DIAGNOSTIC ! 2685: a &= ~ATTR_CMN_GRPID; ! 2686: #endif ! 2687: }; ! 2688: if (a & ATTR_CMN_ACCESSMASK) { ! 2689: u_int16_t mode = (u_int16_t)*((u_long *)attrbufptr)++; ! 2690: if (VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) { ! 2691: if (mode != (mode_t)VNOVAL) { ! 2692: hp->h_meta->h_mode &= ~ALLPERMS; ! 2693: hp->h_meta->h_mode |= (mode & ALLPERMS); /* catalog will get updated by hfs_chmod() */ ! 2694: } ! 2695: }; ! 2696: #if HFS_DIAGNOSTIC ! 2697: a &= ~ATTR_CMN_ACCESSMASK; ! 2698: #endif ! 2699: }; ! 2700: if (a & ATTR_CMN_FLAGS) { ! 2701: u_long flags = *((u_long *)attrbufptr)++; ! 2702: /* Flags are settable only on HFS+ volumes. A special exception is made for the IMMUTABLE ! 2703: flags (SF_IMMUTABLE and UF_IMMUTABLE), which can be set on HFS volumes as well: */ ! 2704: if ((VTOVCB(vp)->vcbSigWord == kHFSPlusSigWord) || ! 2705: ((VTOVCB(vp)->vcbSigWord == kHFSSigWord) && ((flags & ~IMMUTABLE) == 0))) { ! 2706: if (flags != (u_long)VNOVAL) { ! 2707: hp->h_meta->h_pflags = flags; /* catalog will get updated by hfs_chflags */ ! 2708: }; ! 2709: }; ! 2710: #if HFS_DIAGNOSTIC ! 2711: a &= ~ATTR_CMN_FLAGS; ! 2712: #endif ! 2713: }; ! 2714: ! 2715: #if HFS_DIAGNOSTIC ! 2716: if (a != 0) { ! 2717: DEBUG_BREAK_MSG(("UnpackCommonAttributes: unhandled bit: 0x%08X\n", a)); ! 2718: }; ! 2719: #endif ! 2720: ! 2721: *attrbufptrptr = attrbufptr; ! 2722: // *varbufptrptr = varbufptr; ! 2723: } ! 2724: ! 2725: ! 2726: ! 2727: #if 0 ! 2728: void UnpackDirAttributeBlock(struct attrlist *alist, ! 2729: struct vnode *vp, ! 2730: struct hfsCatalogInfo *catInfo, ! 2731: void **attrbufptrptr, ! 2732: void **varbufptrptr) { ! 2733: void *attrbufptr; ! 2734: void *varbufptr; ! 2735: attrgroup_t a; ! 2736: u_long attrlength; ! 2737: ! 2738: attrbufptr = *attrbufptrptr; ! 2739: varbufptr = *varbufptrptr; ! 2740: ! 2741: /* XXX PPD TBC */ ! 2742: ! 2743: *attrbufptrptr = attrbufptr; ! 2744: *varbufptrptr = varbufptr; ! 2745: } ! 2746: #endif ! 2747: ! 2748: ! 2749: ! 2750: #if 0 ! 2751: void UnpackFileAttributeBlock(struct attrlist *alist, ! 2752: struct vnode *vp, ! 2753: struct hfsCatalogInfo *catInfo, ! 2754: void **attrbufptrptr, ! 2755: void **varbufptrptr) { ! 2756: void *attrbufptr; ! 2757: void *varbufptr; ! 2758: attrgroup_t a; ! 2759: u_long attrlength; ! 2760: ! 2761: attrbufptr = *attrbufptrptr; ! 2762: varbufptr = *varbufptrptr; ! 2763: ! 2764: /* XXX PPD TBC */ ! 2765: ! 2766: *attrbufptrptr = attrbufptr; ! 2767: *varbufptrptr = varbufptr; ! 2768: } ! 2769: #endif ! 2770: ! 2771: ! 2772: ! 2773: #if 0 ! 2774: void UnpackForkAttributeBlock(struct attrlist *alist, ! 2775: struct vnode *vp, ! 2776: struct hfsCatalogInfo *catInfo, ! 2777: void **attrbufptrptr, ! 2778: void **varbufptrptr) { ! 2779: void *attrbufptr; ! 2780: void *varbufptr; ! 2781: attrgroup_t a; ! 2782: u_long attrlength; ! 2783: ! 2784: attrbufptr = *attrbufptrptr; ! 2785: varbufptr = *varbufptrptr; ! 2786: ! 2787: /* XXX PPD TBC */ ! 2788: ! 2789: *attrbufptrptr = attrbufptr; ! 2790: *varbufptrptr = varbufptr; ! 2791: } ! 2792: #endif ! 2793: ! 2794: ! 2795: ! 2796: void UnpackAttributeBlock(struct attrlist *alist, ! 2797: struct vnode *vp, ! 2798: struct hfsCatalogInfo *catInfo, ! 2799: void **attrbufptrptr, ! 2800: void **varbufptrptr) { ! 2801: ! 2802: ! 2803: if (alist->volattr != 0) { ! 2804: UnpackVolumeAttributeBlock(alist, vp, VTOVCB(vp), attrbufptrptr, varbufptrptr); ! 2805: return; ! 2806: }; ! 2807: ! 2808: /* We're dealing with a vnode object here: */ ! 2809: UnpackCommonAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2810: ! 2811: #if 0 ! 2812: switch (vp->v_type) { ! 2813: case VDIR: ! 2814: UnpackDirAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2815: break; ! 2816: ! 2817: case VREG: ! 2818: /* case VCPLX: */ /* XXX PPD TBC */ ! 2819: UnpackFileAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2820: break; ! 2821: ! 2822: case VFORK: ! 2823: UnpackForkAttributeBlock(alist, vp, catInfo, attrbufptrptr, varbufptrptr); ! 2824: break; ! 2825: ! 2826: /* Without this the compiler complains about VNON,VBLK,VCHR,VLNK,VSOCK,VFIFO,VBAD and VSTR ! 2827: not being handled... ! 2828: */ ! 2829: default: ! 2830: /* XXX PPD - Panic? */ ! 2831: break; ! 2832: }; ! 2833: #endif ! 2834: ! 2835: }; ! 2836: ! 2837: ! 2838: unsigned long BestBlockSizeFit(unsigned long allocationBlockSize, ! 2839: unsigned long blockSizeLimit, ! 2840: unsigned long baseMultiple) { ! 2841: /* ! 2842: Compute the optimal (largest) block size (no larger than allocationBlockSize) that is less than the ! 2843: specified limit but still an even multiple of the baseMultiple. ! 2844: */ ! 2845: int baseBlockCount, blockCount; ! 2846: unsigned long trialBlockSize; ! 2847: ! 2848: if (allocationBlockSize % baseMultiple != 0) { ! 2849: /* ! 2850: Whoops: the allocation blocks aren't even multiples of the specified base: ! 2851: no amount of dividing them into even parts will be a multiple, either then! ! 2852: */ ! 2853: return 512; /* Hope for the best */ ! 2854: }; ! 2855: ! 2856: /* Try the obvious winner first, to prevent 12K allocation blocks, for instance, ! 2857: from being handled as two 6K logical blocks instead of 3 4K logical blocks. ! 2858: Even though the former (the result of the loop below) is the larger allocation ! 2859: block size, the latter is more efficient: */ ! 2860: if (allocationBlockSize % PAGE_SIZE == 0) return PAGE_SIZE; ! 2861: ! 2862: /* No clear winner exists: pick the largest even fraction <= MAXBSIZE: */ ! 2863: baseBlockCount = allocationBlockSize / baseMultiple; /* Now guaranteed to be an even multiple */ ! 2864: ! 2865: for (blockCount = baseBlockCount; blockCount > 0; --blockCount) { ! 2866: trialBlockSize = blockCount * baseMultiple; ! 2867: if (allocationBlockSize % trialBlockSize == 0) { /* An even multiple? */ ! 2868: if ((trialBlockSize <= blockSizeLimit) && ! 2869: (trialBlockSize % baseMultiple == 0)) { ! 2870: return trialBlockSize; ! 2871: }; ! 2872: }; ! 2873: }; ! 2874: ! 2875: /* Note: we should never get here, since blockCount = 1 should always work, ! 2876: but this is nice and safe and makes the compiler happy, too ... */ ! 2877: return 512; ! 2878: } ! 2879: ! 2880: ! 2881: /* ! 2882: * To make the HFS filesystem follow UFS unlink semantics, a remove of ! 2883: * an active vnode is translated to a move/rename so the file appears ! 2884: * deleted. The destination folder for these move/renames is setup here ! 2885: * and a reference to it is place in hfsmp->hfs_private_metadata_dir. ! 2886: */ ! 2887: u_long ! 2888: FindMetaDataDirectory(ExtendedVCB *vcb) ! 2889: { ! 2890: char namep[32]; ! 2891: hfsCatalogInfo catInfo; ! 2892: HFSCatalogNodeID dirID; ! 2893: int retval; ! 2894: ! 2895: dirID = 0; ! 2896: strncpy(namep, HFSPLUSMETADATAFOLDER, sizeof(namep)); ! 2897: ! 2898: /* lock catalog b-tree */ ! 2899: retval = hfs_metafilelocking(VCBTOHFS(vcb), kHFSCatalogFileID, LK_SHARED, current_proc()); ! 2900: if (retval) ! 2901: goto Err_Exit; ! 2902: ! 2903: catInfo.hint = kNoHint; ! 2904: if (hfsLookup(vcb, kRootDirID, namep, -1, &catInfo) == 0) ! 2905: dirID = catInfo.nodeData.cnd_nodeID; ! 2906: else if (VCBTOHFS(vcb)->hfs_fs_ronly == 0) { ! 2907: if (CreateCatalogNode(vcb, kRootDirID, namep, kCatalogFolderNode, &dirID, &catInfo.hint) == 0) { ! 2908: catInfo.hint = kNoHint; ! 2909: if (hfsLookup(vcb, kRootDirID, namep, -1, &catInfo) == 0) { ! 2910: ! 2911: /* directory with no permissions owned by root */ ! 2912: catInfo.nodeData.cnd_permissions = IFDIR; ! 2913: ! 2914: /* hidden and off the desktop view */ ! 2915: ((struct DInfo *)(&catInfo.nodeData.cnd_finderInfo))->frLocation.v = 22460; ! 2916: ((struct DInfo *)(&catInfo.nodeData.cnd_finderInfo))->frLocation.h = 22460; ! 2917: ((struct DInfo *)(&catInfo.nodeData.cnd_finderInfo))->frFlags |= (kIsInvisible + kNameLocked); ! 2918: ! 2919: (void) UpdateCatalogNode(vcb, kRootDirID, namep, catInfo.hint, &catInfo.nodeData); ! 2920: } ! 2921: } ! 2922: } ! 2923: ! 2924: /* unlock catalog b-tree */ ! 2925: (void) hfs_metafilelocking(VCBTOHFS(vcb), kHFSCatalogFileID, LK_RELEASE, current_proc()); ! 2926: ! 2927: ! 2928: Err_Exit: ! 2929: ! 2930: return dirID; ! 2931: } ! 2932: ! 2933: /* ! 2934: * This will return the correct logical block size for a given vnode. ! 2935: * For most files, it is the allocation block size, for meta data like ! 2936: * BTrees, this is kept as part of the BTree private nodeSize ! 2937: */ ! 2938: u_int32_t ! 2939: GetLogicalBlockSize(struct vnode *vp) ! 2940: { ! 2941: u_int32_t logBlockSize; ! 2942: ! 2943: DBG_ASSERT(vp != NULL); ! 2944: ! 2945: if ((vp->v_flag & VSYSTEM) && (VTOH(vp)->fcbBTCBPtr!=NULL)) { ! 2946: BTreeInfoRec bTreeInfo; ! 2947: int retval; ! 2948: ! 2949: /* ! 2950: * We do not lock the BTrees, because if we are getting block..then the tree ! 2951: * should be locked in the first place. ! 2952: * We just want the nodeSize wich will NEVER change..so even if the world ! 2953: * is changing..the nodeSize should remain the same. Which argues why lock ! 2954: * it in the first place?? ! 2955: */ ! 2956: ! 2957: (void) BTGetInformation (VTOFCB(vp), kBTreeInfoVersion, &bTreeInfo); ! 2958: ! 2959: logBlockSize = bTreeInfo.nodeSize; ! 2960: } ! 2961: else ! 2962: logBlockSize = VTOHFS(vp)->hfs_logBlockSize; ! 2963: ! 2964: ! 2965: DBG_ASSERT(logBlockSize > 0); ! 2966: ! 2967: return logBlockSize; ! 2968: } ! 2969: ! 2970: /* ! 2971: * Map HFS Common errors (negative) to BSD error codes (positive). ! 2972: * Positive errors (ie BSD errors) are passed through unchanged. ! 2973: */ ! 2974: short MacToVFSError(OSErr err) ! 2975: { ! 2976: if (err >= 0) { ! 2977: if (err > 0) { ! 2978: DBG_ERR(("MacToVFSError: passing error #%d unchanged...\n", err)); ! 2979: }; ! 2980: return err; ! 2981: }; ! 2982: ! 2983: if (err != 0) { ! 2984: DBG_ERR(("MacToVFSError: mapping error code %d...\n", err)); ! 2985: }; ! 2986: ! 2987: switch (err) { ! 2988: case dirFulErr: /* -33 */ ! 2989: case dskFulErr: /* -34 */ ! 2990: case btNoSpaceAvail: /* -32733 */ ! 2991: case fxOvFlErr: /* -32750 */ ! 2992: return ENOSPC; /* +28 */ ! 2993: ! 2994: case btBadNode: /* -32731 */ ! 2995: case ioErr: /* -36 */ ! 2996: return EIO; /* +5 */ ! 2997: ! 2998: case mFulErr: /* -41 */ ! 2999: case memFullErr: /* -108 */ ! 3000: return ENOMEM; /* +12 */ ! 3001: ! 3002: case tmfoErr: /* -42 */ ! 3003: /* Consider EMFILE (Too many open files, 24)? */ ! 3004: return ENFILE; /* +23 */ ! 3005: ! 3006: case nsvErr: /* -35 */ ! 3007: case fnfErr: /* -43 */ ! 3008: case dirNFErr: /* -120 */ ! 3009: case fidNotFound: /* -1300 */ ! 3010: return ENOENT; /* +2 */ ! 3011: ! 3012: case wPrErr: /* -44 */ ! 3013: case vLckdErr: /* -46 */ ! 3014: case fsDSIntErr: /* -127 */ ! 3015: return EROFS; /* +30 */ ! 3016: ! 3017: case opWrErr: /* -49 */ ! 3018: case fLckdErr: /* -45 */ ! 3019: return EACCES; /* +13 */ ! 3020: ! 3021: case permErr: /* -54 */ ! 3022: case wrPermErr: /* -61 */ ! 3023: return EPERM; /* +1 */ ! 3024: ! 3025: case fBsyErr: /* -47 */ ! 3026: return EBUSY; /* +16 */ ! 3027: ! 3028: case dupFNErr: /* -48 */ ! 3029: case fidExists: /* -1301 */ ! 3030: case cmExists: /* -32718 */ ! 3031: case btExists: /* -32734 */ ! 3032: return EEXIST; /* +17 */ ! 3033: ! 3034: case rfNumErr: /* -51 */ ! 3035: return EBADF; /* +9 */ ! 3036: ! 3037: case notAFileErr: /* -1302 */ ! 3038: return EISDIR; /* +21 */ ! 3039: ! 3040: case cmNotFound: /* -32719 */ ! 3041: case btNotFound: /* -32735 */ ! 3042: return ENOENT; /* 28 */ ! 3043: ! 3044: case cmNotEmpty: /* -32717 */ ! 3045: return ENOTEMPTY; /* 66 */ ! 3046: ! 3047: case cmFThdDirErr: /* -32714 */ ! 3048: return EISDIR; /* 21 */ ! 3049: ! 3050: case fxRangeErr: /* -32751 */ ! 3051: return EIO; /* 5 */ ! 3052: ! 3053: case bdNamErr: /* -37 */ ! 3054: return ENAMETOOLONG; /* 63 */ ! 3055: ! 3056: case fnOpnErr: /* -38 */ ! 3057: case eofErr: /* -39 */ ! 3058: case posErr: /* -40 */ ! 3059: case paramErr: /* -50 */ ! 3060: case badMDBErr: /* -60 */ ! 3061: case badMovErr: /* -122 */ ! 3062: case sameFileErr: /* -1306 */ ! 3063: case badFidErr: /* -1307 */ ! 3064: case fileBoundsErr: /* -1309 */ ! 3065: return EINVAL; /* +22 */ ! 3066: ! 3067: default: ! 3068: DBG_UTILS(("Unmapped MacOS error: %d\n", err)); ! 3069: return EIO; /* +5 */ ! 3070: } ! 3071: } ! 3072: ! 3073: ! 3074: /* ! 3075: * All of our debugging functions ! 3076: */ ! 3077: ! 3078: #if HFS_DIAGNOSTIC ! 3079: ! 3080: void debug_vn_status (char* introStr, struct vnode *vn) ! 3081: { ! 3082: DBG_VOP(("%s:\t",introStr)); ! 3083: if (vn != NULL) ! 3084: { ! 3085: if (vn->v_tag != VT_HFS) ! 3086: { ! 3087: DBG_VOP(("NON-HFS VNODE Ox%08lX\n", (unsigned long)vn)); ! 3088: } ! 3089: else if(vn->v_tag==VT_HFS && (vn->v_data==NULL || VTOH((vn))->h_valid != HFS_VNODE_MAGIC)) ! 3090: { ! 3091: DBG_VOP(("BAD VNODE PRIVATE DATA!!!!\n")); ! 3092: } ! 3093: else ! 3094: { ! 3095: DBG_VOP(("r: %d & ", vn->v_usecount)); ! 3096: if (lockstatus(&VTOH(vn)->h_lock)) ! 3097: { ! 3098: DBG_VOP_CONT(("is L\n")); ! 3099: } ! 3100: else ! 3101: { ! 3102: DBG_VOP_CONT(("is U\n")); ! 3103: } ! 3104: } ! 3105: } ! 3106: else ! 3107: { ! 3108: DBG_VOP(("vnode is NULL\n")); ! 3109: }; ! 3110: } ! 3111: ! 3112: void debug_vn_print (char* introStr, struct vnode *vn) ! 3113: { ! 3114: // DBG_FUNC_NAME("DBG_VN_PRINT"); ! 3115: DBG_ASSERT (vn != NULL); ! 3116: DBG_VFS(("%s: ",introStr)); ! 3117: DBG_VFS_CONT(("vnode: 0x%x is a ", (uint)vn)); ! 3118: switch (vn->v_tag) ! 3119: { ! 3120: case VT_UFS: ! 3121: DBG_VFS_CONT(("%s","UFS")); ! 3122: break; ! 3123: case VT_HFS: ! 3124: DBG_VFS_CONT(("%s","HFS")); ! 3125: break; ! 3126: default: ! 3127: DBG_VFS_CONT(("%s","UNKNOWN")); ! 3128: break; ! 3129: } ! 3130: ! 3131: DBG_VFS_CONT((" vnode\n")); ! 3132: if (vn->v_tag==VT_HFS) ! 3133: { ! 3134: if (vn->v_data==NULL) ! 3135: { ! 3136: DBG_VFS(("BAD VNODE PRIVATE DATA!!!!\n")); ! 3137: } ! 3138: else ! 3139: { ! 3140: DBG_VFS((" Name: %s Id: %ld ",H_NAME(VTOH(vn)), H_FILEID(VTOH(vn)))); ! 3141: } ! 3142: } ! 3143: else ! 3144: DBG_VFS((" ")); ! 3145: ! 3146: DBG_VFS_CONT(("Refcount: %d\n", vn->v_usecount)); ! 3147: if (VOP_ISLOCKED(vn)) ! 3148: { ! 3149: DBG_VFS((" The vnode is locked\n")); ! 3150: } ! 3151: else ! 3152: { ! 3153: DBG_VFS((" The vnode is not locked\n")); ! 3154: } ! 3155: } ! 3156: ! 3157: void debug_rename_test_locks (char* introStr, ! 3158: struct vnode *fvp, ! 3159: struct vnode *fdvp, ! 3160: struct vnode *tvp, ! 3161: struct vnode *tdvp, ! 3162: int fstatus, ! 3163: int fdstatus, ! 3164: int tstatus, ! 3165: int tdstatus ! 3166: ) ! 3167: { ! 3168: DBG_VOP(("\t%s: ", introStr)); ! 3169: if (fvp) {if(lockstatus(&VTOH(fvp)->h_lock)){DBG_VFS_CONT(("L"));} else {DBG_VFS_CONT(("U"));}} else { DBG_VFS_CONT(("X"));}; ! 3170: if (fdvp) {if(lockstatus(&VTOH(fdvp)->h_lock)){DBG_VFS_CONT(("L"));} else {DBG_VFS_CONT(("U"));}} else { DBG_VFS_CONT(("X"));}; ! 3171: if (tvp) {if(lockstatus(&VTOH(tvp)->h_lock)){DBG_VFS_CONT(("L"));} else {DBG_VFS_CONT(("U"));}} else { DBG_VFS_CONT(("X"));}; ! 3172: if (tdvp) {if(lockstatus(&VTOH(tdvp)->h_lock)){DBG_VFS_CONT(("L"));} else {DBG_VFS_CONT(("U"));}} else { DBG_VFS_CONT(("X"));}; ! 3173: DBG_VFS_CONT(("\n")); ! 3174: ! 3175: if (fvp) { ! 3176: if (lockstatus(&VTOH(fvp)->h_lock)) { ! 3177: if (fstatus==VOPDBG_UNLOCKED) { ! 3178: DBG_VOP(("\tfvp should be NOT LOCKED and it is\n")); ! 3179: } ! 3180: } else if (fstatus == VOPDBG_LOCKED) { ! 3181: DBG_VOP(("\tfvp should be LOCKED and it isnt\n")); ! 3182: } ! 3183: } ! 3184: ! 3185: if (fdvp) { ! 3186: if (lockstatus(&VTOH(fdvp)->h_lock)) { ! 3187: if (fdstatus==VOPDBG_UNLOCKED) { ! 3188: DBG_VOP(("\tfdvp should be NOT LOCKED and it is\n")); ! 3189: } ! 3190: } else if (fdstatus == VOPDBG_LOCKED) { ! 3191: DBG_VOP(("\tfdvp should be LOCKED and it isnt\n")); ! 3192: } ! 3193: } ! 3194: ! 3195: if (tvp) { ! 3196: if (lockstatus(&VTOH(tvp)->h_lock)) { ! 3197: if (tstatus==VOPDBG_UNLOCKED) { ! 3198: DBG_VOP(("\ttvp should be NOT LOCKED and it is\n")); ! 3199: } ! 3200: } else if (tstatus == VOPDBG_LOCKED) { ! 3201: DBG_VOP(("\ttvp should be LOCKED and it isnt\n")); ! 3202: } ! 3203: } ! 3204: ! 3205: if (tdvp) { ! 3206: if (lockstatus(&VTOH(tdvp)->h_lock)) { ! 3207: if (tdstatus==VOPDBG_UNLOCKED) { ! 3208: DBG_VOP(("\ttdvp should be NOT LOCKED and it is\n")); ! 3209: } ! 3210: } else if (tdstatus == VOPDBG_LOCKED) { ! 3211: DBG_VOP(("\ttdvp should be LOCKED and it isnt\n")); ! 3212: ! 3213: } ! 3214: } ! 3215: ! 3216: } ! 3217: #endif /* HFS_DIAGNOSTIC */ ! 3218: ! 3219: ! 3220: #if HFS_DIAGNOSTIC ! 3221: void debug_check_buffersizes(struct vnode *vp, struct hfsnode *hp, struct buf *bp) { ! 3222: DBG_ASSERT(bp->b_validoff == 0); ! 3223: DBG_ASSERT(bp->b_dirtyoff == 0); ! 3224: if (bp->b_lblkno < hp->h_uniformblocksizestart) { ! 3225: DBG_ASSERT((bp->b_bcount == MAXLOGBLOCKSIZE) || ! 3226: (bp->b_bcount == LogicalBlockSize(hp, bp->b_lblkno)) || ! 3227: ((bp->b_bcount % 512 == 0) && ! 3228: (bp->b_validend > 0) && ! 3229: (bp->b_dirtyend >= 0) && /* Could be partial block due to file growth */ ! 3230: (bp->b_bcount < LogicalBlockSize(hp, bp->b_lblkno)))); ! 3231: } else { ! 3232: DBG_ASSERT((bp->b_bcount == HTOHFS(hp)->hfs_logBlockSize) || ! 3233: ((bp->b_bcount % 512 == 0) && ! 3234: (bp->b_validend > 0) && ! 3235: (bp->b_dirtyend > 0) && ! 3236: (bp->b_bcount < HTOHFS(hp)->hfs_logBlockSize))); ! 3237: }; ! 3238: ! 3239: if (bp->b_validend == 0) { ! 3240: DBG_ASSERT(bp->b_dirtyend == 0); ! 3241: } else { ! 3242: DBG_ASSERT(bp->b_validend == bp->b_bcount); ! 3243: DBG_ASSERT(bp->b_dirtyend <= bp->b_bcount); ! 3244: }; ! 3245: ! 3246: if ((bp->b_lblkno == 0x21) || (bp->b_lblkno == 0x22)) DBG_ASSERT((hp->h_uniformblocksizestart > 0x21) || (bp->b_bcount != MAXLOGBLOCKSIZE)); ! 3247: } ! 3248: ! 3249: ! 3250: void debug_check_blocksizes(struct vnode *vp) { ! 3251: struct hfsnode *hp = VTOH(vp); ! 3252: struct buf *bp; ! 3253: ! 3254: if (vp->v_flag & VSYSTEM) return; ! 3255: ! 3256: for (bp = vp->v_cleanblkhd.lh_first; bp != NULL; bp = bp->b_vnbufs.le_next) { ! 3257: debug_check_buffersizes(vp, hp, bp); ! 3258: }; ! 3259: ! 3260: for (bp = vp->v_dirtyblkhd.lh_first; bp != NULL; bp = bp->b_vnbufs.le_next) { ! 3261: debug_check_buffersizes(vp, hp, bp); ! 3262: }; ! 3263: } ! 3264: ! 3265: extern void hfs_vhash_dbg(struct hfsnode *hp); ! 3266: ! 3267: /* Checks the valicity of a hfs vnode */ ! 3268: void debug_check_vnode(struct vnode *vp, int stage) { ! 3269: struct hfsnode *hp; ! 3270: u_long size; ! 3271: int i; ! 3272: ! 3273: /* vcb stuff */ ! 3274: if (VTOHFS(vp)->hfs_mount_flags & kHFSBootVolumeInconsistentMask) ! 3275: DEBUG_BREAK_MSG(("Volume is damaged!")); ! 3276: ! 3277: /* vnode stuff */ ! 3278: if (vp==NULL) ! 3279: DEBUG_BREAK_MSG(("Null vnode")); ! 3280: if (vp->v_tag != VT_HFS) ! 3281: DEBUG_BREAK_MSG(("Not a HFS vnode, it is a %d", vp->v_tag)); ! 3282: if (vp->v_data==NULL) ! 3283: DEBUG_BREAK_MSG(("v_data is NULL")); ! 3284: ! 3285: /* hfsnode stuff */ ! 3286: hp = VTOH(vp); ! 3287: if (hp->h_valid != HFS_VNODE_MAGIC) ! 3288: DEBUG_BREAK_MSG(("Bad Formed HFS node")); ! 3289: if (hp->h_vp==NULL || hp->h_vp!=vp) ! 3290: DEBUG_BREAK_MSG(("Bad hfsnode vnode pte")); ! 3291: if (hp->h_meta == NULL) ! 3292: DEBUG_BREAK_MSG(("Bad hfsnode meta ptr")); ! 3293: switch (H_FORKTYPE(hp)) { ! 3294: case kDataFork: ! 3295: case kRsrcFork: ! 3296: if ((hp->h_meta->h_siblinghead.cqh_first == NULL) || (hp->h_meta->h_siblinghead.cqh_last == NULL)) ! 3297: DEBUG_BREAK_MSG(("Null sibling header")); ! 3298: if ((hp->h_sibling.cqe_next==NULL) || (hp->h_sibling.cqe_prev==NULL)) ! 3299: DEBUG_BREAK_MSG(("Null sibling list")); ! 3300: if (hp->h_meta->h_usecount<1 || hp->h_meta->h_usecount>2) ! 3301: DEBUG_BREAK_MSG(("Bad sibling usecount")); ! 3302: break; ! 3303: case kDirectory: ! 3304: case kSysFile: ! 3305: if ((hp->h_meta->h_siblinghead.cqh_first != NULL) || (hp->h_meta->h_siblinghead.cqh_last != NULL)) ! 3306: DEBUG_BREAK_MSG(("Non Null sibling header")); ! 3307: if ((hp->h_sibling.cqe_next!=NULL) || (hp->h_sibling.cqe_prev!=NULL)) ! 3308: DEBUG_BREAK_MSG(("Null sibling list")); ! 3309: if (hp->h_meta->h_usecount!=1) ! 3310: DEBUG_BREAK_MSG(("Bad usecount")); ! 3311: ! 3312: break; ! 3313: default: ! 3314: DEBUG_BREAK_MSG(("Bad hfsnode fork type")); ! 3315: } ! 3316: ! 3317: /* hfsmeta stuff */ ! 3318: if (hp->h_meta->h_devvp == NULL) ! 3319: DEBUG_BREAK_MSG(("Bad hfsnode dev vnode")); ! 3320: if (H_DEV(hp) == 0) ! 3321: DEBUG_BREAK_MSG(("Bad dev id")); ! 3322: if (H_FILEID(hp) == 0) ! 3323: DEBUG_BREAK_MSG(("Bad file id")); ! 3324: ! 3325: if (((hp->h_meta->h_metaflags & IN_DATANODE)==0) && (H_DIRID(hp) == 0) && (H_FILEID(hp) != 1)) ! 3326: DEBUG_BREAK_MSG(("Bad dir id")); ! 3327: ! 3328: if (hp->h_meta->h_namePtr == NULL && hp->h_meta->h_namelen!=0) ! 3329: DEBUG_BREAK_MSG(("hfs meta h_namelen is not 0")); ! 3330: if (hp->h_meta->h_namePtr != NULL && strlen(hp->h_meta->h_namePtr) != hp->h_meta->h_namelen) ! 3331: DEBUG_BREAK_MSG(("Bad hfs meta h_namelen")); ! 3332: ! 3333: /* Check the hash */ ! 3334: hfs_vhash_dbg(hp); ! 3335: ! 3336: /* Check to see if we want to compare with the disk */ ! 3337: if (stage > 200) { ! 3338: int retval; ! 3339: hfsCatalogInfo catInfo; ! 3340: ! 3341: if (hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_SHARED, current_proc())) ! 3342: return; ! 3343: ! 3344: catInfo.hint = 0; ! 3345: if (hfsLookup(VTOVCB(vp), H_DIRID(hp), hp->h_meta->h_namePtr, hp->h_meta->h_namelen, &catInfo)) ! 3346: DEBUG_BREAK_MSG(("Could not find hfsnode Catalog record")); ! 3347: ! 3348: (void) hfs_metafilelocking(VTOHFS(vp), kHFSCatalogFileID, LK_RELEASE, current_proc()); ! 3349: ! 3350: if (H_FILEID(hp) != catInfo.nodeData.cnd_nodeID) ! 3351: DEBUG_BREAK_MSG(("hfsnode catalog node id mismatch")); ! 3352: if (H_DIRID(hp) != catInfo.spec.parID) ! 3353: DEBUG_BREAK_MSG(("hfsnode catalog dir id mismatch")); ! 3354: if (strcmp(hp->h_meta->h_namePtr, catInfo.spec.name) != 0) ! 3355: DEBUG_BREAK_MSG(("hfsnode catalog name mismatch")); ! 3356: /* Check dates too??? */ ! 3357: ! 3358: ! 3359: ! 3360: } ! 3361: ! 3362: for(i = 0, size = 0; i < kHFSPlusExtentDensity; i++) ! 3363: { ! 3364: size += hp->fcbExtents[i].blockCount; ! 3365: } ! 3366: if (size*VTOVCB(vp)->blockSize < hp->fcbPLen) ! 3367: DEBUG_BREAK_MSG(("fcbPLen too large")); ! 3368: if (hp->fcbEOF > hp->fcbPLen) ! 3369: DEBUG_BREAK_MSG(("fcbPLen is smaller than fcbEOF")); ! 3370: if (hp->fcbExtents[kHFSPlusExtentDensity-1].blockCount == 0) { ! 3371: if (size*VTOVCB(vp)->blockSize != hp->fcbPLen) ! 3372: DEBUG_BREAK_MSG(("fcbPLen does not match extents")); ! 3373: } else { ! 3374: if ( hp->fcbPLen < size*VTOVCB(vp)->blockSize) ! 3375: DEBUG_BREAK_MSG(("fcbPLen is smaller than extents")); ! 3376: } ! 3377: for(i = 0; i < kHFSPlusExtentDensity; i++) ! 3378: { ! 3379: if (hp->fcbExtents[i].blockCount == 0 || hp->fcbExtents[i].startBlock == 0) ! 3380: break; ! 3381: } ! 3382: if ((VTOVCB(vp)->vcbSigWord == kHFSSigWord) && i > kHFSExtentDensity) ! 3383: DEBUG_BREAK_MSG(("Illegal value in extents for ordinary HFS")); ! 3384: if (i > kHFSPlusExtentDensity) { ! 3385: for(; i < kHFSPlusExtentDensity; i++) ! 3386: { ! 3387: if (hp->fcbExtents[i].blockCount != 0 || hp->fcbExtents[i].startBlock != 0) ! 3388: DEBUG_BREAK_MSG(("Illegal value in extents")); ! 3389: } ! 3390: } ! 3391: ! 3392: /* BTree stuff */ ! 3393: if (vp->v_flag & VSYSTEM) { ! 3394: BTreeInfoRec info; ! 3395: ! 3396: BTGetInformation(hp, 0, &info); ! 3397: if (hp->fcbBTCBPtr == NULL) ! 3398: DEBUG_BREAK_MSG(("Null fcbBTCBPtr")); ! 3399: if (H_HINT(hp) == 0) ! 3400: DEBUG_BREAK_MSG(("hint is 0")); ! 3401: if (H_HINT(hp) > info.numNodes) ! 3402: DEBUG_BREAK_MSG(("hint > numNodes")); ! 3403: } ! 3404: ! 3405: } ! 3406: ! 3407: #endif /* HFS_DIAGNOSTIC */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.