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