#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/stat.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/lock.h>
#include <sys/buf.h>
#include <sys/ubc.h>
#include <sys/unistd.h>
#include "hfs.h"
#include "hfs_catalog.h"
#include "hfs_dbg.h"
#include "hfs_mount.h"
#include "hfs_endian.h"
#include "hfs_cnode.h"
#include "hfscommon/headers/FileMgrInternal.h"
#include "hfscommon/headers/BTreesInternal.h"
#include "hfscommon/headers/HFSUnicodeWrappers.h"
extern int count_lock_queue __P((void));
extern uid_t console_user;
static void ReleaseMetaFileVNode(struct vnode *vp);
static int hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args);
u_int32_t GetLogicalBlockSize(struct vnode *vp);
extern OSStatus GetBTreeBlock(FileReference vp, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block);
extern OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, ItemCount minBlockCount);
extern OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF);
extern OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options);
char hfs_catname[] = "Catalog B-tree";
char hfs_extname[] = "Extents B-tree";
char hfs_vbmname[] = "Volume Bitmap";
char hfs_privdirname[] =
"\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80\xE2\x90\x80HFS+ Private Data";
OSErr hfs_MountHFSVolume(struct hfsmount *hfsmp, HFSMasterDirectoryBlock *mdb,
struct proc *p)
{
ExtendedVCB *vcb = HFSTOVCB(hfsmp);
int error;
ByteCount utf8chars;
struct cat_desc cndesc;
struct cat_attr cnattr;
struct cat_fork fork;
if (SWAP_BE32(mdb->drAlBlkSiz) == 0 ||
(SWAP_BE32(mdb->drAlBlkSiz) & 0x01FF) != 0)
return (EINVAL);
if ((hfsmp->hfs_fs_ronly == 0) && ((SWAP_BE16(mdb->drAtrb) & kHFSVolumeUnmountedMask) == 0))
return (EINVAL);
vcb->vcbSigWord = SWAP_BE16 (mdb->drSigWord);
vcb->vcbCrDate = to_bsd_time(LocalToUTC(SWAP_BE32(mdb->drCrDate)));
vcb->localCreateDate = SWAP_BE32 (mdb->drCrDate);
vcb->vcbLsMod = to_bsd_time(LocalToUTC(SWAP_BE32(mdb->drLsMod)));
vcb->vcbAtrb = SWAP_BE16 (mdb->drAtrb);
vcb->vcbNmFls = SWAP_BE16 (mdb->drNmFls);
vcb->vcbVBMSt = SWAP_BE16 (mdb->drVBMSt);
vcb->nextAllocation = SWAP_BE16 (mdb->drAllocPtr);
vcb->totalBlocks = SWAP_BE16 (mdb->drNmAlBlks);
vcb->blockSize = SWAP_BE32 (mdb->drAlBlkSiz);
vcb->vcbClpSiz = SWAP_BE32 (mdb->drClpSiz);
vcb->vcbAlBlSt = SWAP_BE16 (mdb->drAlBlSt);
vcb->vcbNxtCNID = SWAP_BE32 (mdb->drNxtCNID);
vcb->freeBlocks = SWAP_BE16 (mdb->drFreeBks);
vcb->vcbVolBkUp = to_bsd_time(LocalToUTC(SWAP_BE32(mdb->drVolBkUp)));
vcb->vcbWrCnt = SWAP_BE32 (mdb->drWrCnt);
vcb->vcbNmRtDirs = SWAP_BE16 (mdb->drNmRtDirs);
vcb->vcbFilCnt = SWAP_BE32 (mdb->drFilCnt);
vcb->vcbDirCnt = SWAP_BE32 (mdb->drDirCnt);
bcopy(mdb->drFndrInfo, vcb->vcbFndrInfo, sizeof(vcb->vcbFndrInfo));
if (!hfsmp->hfs_fs_ronly)
vcb->vcbWrCnt++;
error = hfs_to_utf8(vcb, mdb->drVN, NAME_MAX, &utf8chars, vcb->vcbVN);
if (error || (utf8chars == 0))
(void) mac_roman_to_utf8(mdb->drVN, NAME_MAX, &utf8chars, vcb->vcbVN);
hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size);
vcb->vcbVBMIOSize = kHFSBlockSize;
VCB_LOCK_INIT(vcb);
bzero(&cndesc, sizeof(cndesc));
cndesc.cd_parentcnid = kRootParID;
bzero(&cnattr, sizeof(cnattr));
cnattr.ca_nlink = 1;
cnattr.ca_mode = S_IFREG;
bzero(&fork, sizeof(fork));
cndesc.cd_nameptr = hfs_extname;
cndesc.cd_namelen = strlen(hfs_extname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
fork.cf_size = SWAP_BE32(mdb->drXTFlSize);
fork.cf_blocks = fork.cf_size / vcb->blockSize;
fork.cf_clump = SWAP_BE32(mdb->drXTClpSiz);
fork.cf_extents[0].startBlock = SWAP_BE16(mdb->drXTExtRec[0].startBlock);
fork.cf_extents[0].blockCount = SWAP_BE16(mdb->drXTExtRec[0].blockCount);
fork.cf_extents[1].startBlock = SWAP_BE16(mdb->drXTExtRec[1].startBlock);
fork.cf_extents[1].blockCount = SWAP_BE16(mdb->drXTExtRec[1].blockCount);
fork.cf_extents[2].startBlock = SWAP_BE16(mdb->drXTExtRec[2].startBlock);
fork.cf_extents[2].blockCount = SWAP_BE16(mdb->drXTExtRec[2].blockCount);
cnattr.ca_blocks = fork.cf_blocks;
error = hfs_getnewvnode(hfsmp, NULL, &cndesc, 0, &cnattr, &fork,
&vcb->extentsRefNum);
if (error) goto MtVolErr;
error = MacToVFSError(BTOpenPath(VTOF(vcb->extentsRefNum),
(KeyCompareProcPtr)CompareExtentKeys,
GetBTreeBlock, ReleaseBTreeBlock,
ExtendBTreeFile, SetBTreeBlockSize));
if (error) {
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto MtVolErr;
}
cndesc.cd_nameptr = hfs_catname;
cndesc.cd_namelen = strlen(hfs_catname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
fork.cf_size = SWAP_BE32(mdb->drCTFlSize);
fork.cf_blocks = fork.cf_size / vcb->blockSize;
fork.cf_clump = SWAP_BE32(mdb->drCTClpSiz);
fork.cf_extents[0].startBlock = SWAP_BE16(mdb->drCTExtRec[0].startBlock);
fork.cf_extents[0].blockCount = SWAP_BE16(mdb->drCTExtRec[0].blockCount);
fork.cf_extents[1].startBlock = SWAP_BE16(mdb->drCTExtRec[1].startBlock);
fork.cf_extents[1].blockCount = SWAP_BE16(mdb->drCTExtRec[1].blockCount);
fork.cf_extents[2].startBlock = SWAP_BE16(mdb->drCTExtRec[2].startBlock);
fork.cf_extents[2].blockCount = SWAP_BE16(mdb->drCTExtRec[2].blockCount);
cnattr.ca_blocks = fork.cf_blocks;
error = hfs_getnewvnode(hfsmp, NULL, &cndesc, 0, &cnattr, &fork,
&vcb->catalogRefNum);
if (error) {
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto MtVolErr;
}
error = MacToVFSError(BTOpenPath(VTOF(vcb->catalogRefNum),
(KeyCompareProcPtr)CompareCatalogKeys,
GetBTreeBlock, ReleaseBTreeBlock,
ExtendBTreeFile, SetBTreeBlockSize));
if (error) {
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto MtVolErr;
}
vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask;
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
if ( error == noErr )
{
if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) {
MarkVCBDirty( vcb ); }
}
goto CmdDone;
MtVolErr:
ReleaseMetaFileVNode(vcb->catalogRefNum);
ReleaseMetaFileVNode(vcb->extentsRefNum);
CmdDone:
return (error);
}
OSErr hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
off_t embeddedOffset, u_int64_t disksize, struct proc *p, void *args)
{
register ExtendedVCB *vcb;
struct cat_desc cndesc;
struct cat_attr cnattr;
UInt32 blockSize;
OSErr retval;
if ((SWAP_BE16(vhp->signature) != kHFSPlusSigWord &&
SWAP_BE16(vhp->signature) != kHFSJSigWord) ||
SWAP_BE16(vhp->version) != kHFSPlusVersion) {
printf("hfs: mount: sig 0x%x and version 0x%x are not HFS or HFS+.\n",
vhp->signature, vhp->version);
return (EINVAL);
}
blockSize = SWAP_BE32(vhp->blockSize);
if (blockSize < 512 || (blockSize & (blockSize-1)) != 0)
return (EINVAL);
if (hfsmp->hfs_fs_ronly == 0 && hfsmp->jnl == NULL && (SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) == 0)
return (EINVAL);
if ((disksize & (hfsmp->hfs_phys_block_size - 1)) ||
(embeddedOffset & (hfsmp->hfs_phys_block_size - 1)) ||
(SWAP_BE32(vhp->blockSize) < hfsmp->hfs_phys_block_size)) {
return (ENXIO);
}
vcb = HFSTOVCB(hfsmp);
vcb->vcbSigWord = SWAP_BE16(vhp->signature);
if (vcb->vcbSigWord == kHFSJSigWord) {
vcb->vcbSigWord = kHFSPlusSigWord;
}
vcb->vcbJinfoBlock = SWAP_BE32(vhp->journalInfoBlock);
vcb->vcbLsMod = to_bsd_time(SWAP_BE32(vhp->modifyDate));
vcb->vcbAtrb = (UInt16)SWAP_BE32(vhp->attributes);
vcb->vcbClpSiz = SWAP_BE32(vhp->rsrcClumpSize);
vcb->vcbNxtCNID = SWAP_BE32(vhp->nextCatalogID);
vcb->vcbVolBkUp = to_bsd_time(SWAP_BE32(vhp->backupDate));
vcb->vcbWrCnt = SWAP_BE32(vhp->writeCount);
vcb->vcbFilCnt = SWAP_BE32(vhp->fileCount);
vcb->vcbDirCnt = SWAP_BE32(vhp->folderCount);
bcopy(vhp->finderInfo, vcb->vcbFndrInfo, sizeof(vhp->finderInfo));
vcb->vcbAlBlSt = 0;
if (!hfsmp->hfs_fs_ronly)
vcb->vcbWrCnt++;
VCB_LOCK_INIT(vcb);
vcb->nextAllocation = SWAP_BE32(vhp->nextAllocation);
vcb->totalBlocks = SWAP_BE32(vhp->totalBlocks);
vcb->freeBlocks = SWAP_BE32(vhp->freeBlocks);
vcb->blockSize = SWAP_BE32(vhp->blockSize);
vcb->encodingsBitmap = SWAP_BE64(vhp->encodingsBitmap);
vcb->localCreateDate = SWAP_BE32(vhp->createDate);
vcb->hfsPlusIOPosOffset = embeddedOffset;
vcb->reserveBlocks = 0;
hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_phys_block_size);
vcb->vcbVBMIOSize = min(vcb->blockSize, MAXPHYSIO);
bzero(&cndesc, sizeof(cndesc));
cndesc.cd_parentcnid = kRootParID;
bzero(&cnattr, sizeof(cnattr));
cnattr.ca_nlink = 1;
cnattr.ca_mode = S_IFREG;
cndesc.cd_nameptr = hfs_extname;
cndesc.cd_namelen = strlen(hfs_extname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
SWAP_HFS_PLUS_FORK_DATA (&vhp->extentsFile);
cnattr.ca_blocks = vhp->extentsFile.totalBlocks;
retval = hfs_getnewvnode(hfsmp, NULL, &cndesc, 0, &cnattr,
(struct cat_fork *)&vhp->extentsFile,
&vcb->extentsRefNum);
SWAP_HFS_PLUS_FORK_DATA (&vhp->extentsFile);
if (retval) goto ErrorExit;
retval = MacToVFSError(BTOpenPath(VTOF(vcb->extentsRefNum),
(KeyCompareProcPtr) CompareExtentKeysPlus,
GetBTreeBlock, ReleaseBTreeBlock,
ExtendBTreeFile, SetBTreeBlockSize));
if (retval) {
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto ErrorExit;
}
cndesc.cd_nameptr = hfs_catname;
cndesc.cd_namelen = strlen(hfs_catname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
SWAP_HFS_PLUS_FORK_DATA(&vhp->catalogFile);
cnattr.ca_blocks = vhp->catalogFile.totalBlocks;
retval = hfs_getnewvnode(hfsmp, NULL, &cndesc, 0, &cnattr,
(struct cat_fork *)&vhp->catalogFile,
&vcb->catalogRefNum);
SWAP_HFS_PLUS_FORK_DATA(&vhp->catalogFile);
if (retval) {
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto ErrorExit;
}
retval = MacToVFSError(BTOpenPath(VTOF(vcb->catalogRefNum),
(KeyCompareProcPtr) CompareExtendedCatalogKeys,
GetBTreeBlock, ReleaseBTreeBlock,
ExtendBTreeFile, SetBTreeBlockSize));
if (retval) {
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto ErrorExit;
}
cndesc.cd_nameptr = hfs_vbmname;
cndesc.cd_namelen = strlen(hfs_vbmname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
SWAP_HFS_PLUS_FORK_DATA(&vhp->allocationFile);
cnattr.ca_blocks = vhp->allocationFile.totalBlocks;
retval = hfs_getnewvnode(hfsmp, NULL, &cndesc, 0, &cnattr,
(struct cat_fork *)&vhp->allocationFile,
&vcb->allocationsRefNum);
SWAP_HFS_PLUS_FORK_DATA(&vhp->allocationFile);
if (retval) {
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto ErrorExit;
}
retval = cat_idlookup(hfsmp, kHFSRootFolderID, &cndesc, &cnattr, NULL);
if (retval) {
VOP_UNLOCK(vcb->allocationsRefNum, 0, p);
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
goto ErrorExit;
}
vcb->vcbCrDate = cnattr.ca_itime;
vcb->volumeNameEncodingHint = cndesc.cd_encoding;
bcopy(cndesc.cd_nameptr, vcb->vcbVN, min(255, cndesc.cd_namelen));
cat_releasedesc(&cndesc);
vcb->vcbAtrb &= ~kHFSVolumeUnmountedMask;
if (hfsmp->jnl && hfsmp->hfs_fs_ronly == 0) {
hfs_flushvolumeheader(hfsmp, TRUE, TRUE);
}
VOP_UNLOCK(vcb->allocationsRefNum, 0, p);
VOP_UNLOCK(vcb->catalogRefNum, 0, p);
VOP_UNLOCK(vcb->extentsRefNum, 0, p);
hfsmp->hfs_private_metadata_dir = FindMetaDataDirectory(vcb);
if (hfsmp->jnl && (hfsmp->hfs_fs_ronly == 0))
hfs_remove_orphans(hfsmp);
if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) {
MarkVCBDirty( vcb ); }
if ( (vcb->vcbAtrb & kHFSVolumeJournaledMask)
&& (SWAP_BE32(vhp->lastMountedVersion) != kHFSJMountVersion)
&& (hfsmp->jnl == NULL)) {
retval = hfs_late_journal_init(hfsmp, vhp, args);
if (retval != 0) {
hfsmp->jnl = NULL;
goto ErrorExit;
} else if (hfsmp->jnl) {
hfsmp->hfs_mp->mnt_flag |= MNT_JOURNALED;
}
} else if (hfsmp->jnl) {
struct cat_attr jinfo_attr, jnl_attr;
hfsmp->hfs_jnlinfoblkid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jinfo_attr, NULL);
hfsmp->hfs_jnlfileid = GetFileInfo(vcb, kRootDirID, ".journal", &jnl_attr, NULL);
if (hfsmp->hfs_jnlinfoblkid == 0 || hfsmp->hfs_jnlfileid == 0) {
printf("hfs: danger! couldn't find the file-id's for the journal or journal_info_block\n");
printf("hfs: jnlfileid %d, jnlinfoblkid %d\n", hfsmp->hfs_jnlfileid, hfsmp->hfs_jnlinfoblkid);
}
}
return (0);
ErrorExit:
InvalidateCatalogCache(vcb);
ReleaseMetaFileVNode(vcb->allocationsRefNum);
ReleaseMetaFileVNode(vcb->catalogRefNum);
ReleaseMetaFileVNode(vcb->extentsRefNum);
return (retval);
}
static void ReleaseMetaFileVNode(struct vnode *vp)
{
struct filefork *fp;
if (vp && (fp = VTOF(vp))) {
if (fp->fcbBTCBPtr != NULL)
(void) BTClosePath(fp);
vrele(vp);
vgone(vp);
}
}
short hfsUnmount( register struct hfsmount *hfsmp, struct proc *p)
{
ExtendedVCB *vcb = HFSTOVCB(hfsmp);
int retval = E_NONE;
InvalidateCatalogCache( vcb );
if (vcb->vcbSigWord == kHFSPlusSigWord)
ReleaseMetaFileVNode(vcb->allocationsRefNum);
ReleaseMetaFileVNode(vcb->catalogRefNum);
ReleaseMetaFileVNode(vcb->extentsRefNum);
return (retval);
}
short
hfs_getcatalog(void *p1, u_long p2, void *p3, short p4, void *p5)
{
return ENOENT;
}
int overflow_extents(struct filefork *fp)
{
u_long blocks;
if (VTOVCB(FTOV(fp))->vcbSigWord == kHFSPlusSigWord) {
if (fp->ff_extents[7].blockCount == 0)
return (0);
blocks = fp->ff_extents[0].blockCount +
fp->ff_extents[1].blockCount +
fp->ff_extents[2].blockCount +
fp->ff_extents[3].blockCount +
fp->ff_extents[4].blockCount +
fp->ff_extents[5].blockCount +
fp->ff_extents[6].blockCount +
fp->ff_extents[7].blockCount;
} else {
if (fp->ff_extents[2].blockCount == 0)
return false;
blocks = fp->ff_extents[0].blockCount +
fp->ff_extents[1].blockCount +
fp->ff_extents[2].blockCount;
}
return (fp->ff_blocks > blocks);
}
int
hfs_metafilelocking(struct hfsmount *hfsmp, u_long fileID, u_int flags, struct proc *p)
{
ExtendedVCB *vcb;
struct vnode *vp = NULL;
int numOfLockedBuffs;
int retval = 0;
vcb = HFSTOVCB(hfsmp);
switch (fileID) {
case kHFSExtentsFileID:
vp = vcb->extentsRefNum;
break;
case kHFSCatalogFileID:
vp = vcb->catalogRefNum;
break;
case kHFSAllocationFileID:
default:
panic("hfs_lockmetafile: invalid fileID");
}
if ((flags & LK_TYPE_MASK) == LK_RELEASE) {
struct timeval tv = time;
u_int32_t lastfsync = tv.tv_sec;
(void) BTGetLastSync((FCB*)VTOF(vp), &lastfsync);
numOfLockedBuffs = count_lock_queue();
if ((numOfLockedBuffs > kMaxLockedMetaBuffers) || ((numOfLockedBuffs>1) && ((tv.tv_sec - lastfsync) > kMaxSecsForFsync))) {
hfs_btsync(vp, HFS_SYNCTRANS);
}
} else {
flags |= LK_RETRY;
}
retval = lockmgr(&VTOC(vp)->c_lock, flags, &vp->v_interlock, p);
return (retval);
}
#if HFS_DIAGNOSTIC
void RequireFileLock(FileReference vp, int shareable)
{
struct lock__bsd__ *lkp;
int locked = false;
pid_t pid;
void * self;
pid = current_proc()->p_pid;
self = (void *) current_thread();
lkp = &VTOC(vp)->c_lock;
simple_lock(&lkp->lk_interlock);
if (shareable && (lkp->lk_sharecount > 0) && (lkp->lk_lockholder == LK_NOPROC))
locked = true;
else if ((lkp->lk_exclusivecount > 0) && (lkp->lk_lockholder == pid) && (lkp->lk_lockthread == self))
locked = true;
simple_unlock(&lkp->lk_interlock);
if (!locked) {
switch (VTOC(vp)->c_fileid) {
case 3:
DEBUG_BREAK_MSG((" #\n # RequireFileLock: extent btree vnode not locked! v: 0x%08X\n #\n", (u_int)vp));
break;
case 4:
DEBUG_BREAK_MSG((" #\n # RequireFileLock: catalog btree vnode not locked! v: 0x%08X\n #\n", (u_int)vp));
break;
default:
DEBUG_BREAK_MSG((" #\n # RequireFileLock: file (%d) not locked! v: 0x%08X\n #\n", VTOC(vp)->c_fileid, (u_int)vp));
break;
}
}
}
#endif
int
hfs_owner_rights(struct hfsmount *hfsmp, uid_t cnode_uid, struct ucred *cred,
struct proc *p, int invokesuperuserstatus)
{
if ((cred->cr_uid == cnode_uid) ||
((cnode_uid == UNKNOWNUID) && (cred->cr_uid == console_user)) ||
((HFSTOVFS(hfsmp)->mnt_flag & MNT_UNKNOWNPERMISSIONS) &&
((cred->cr_uid == hfsmp->hfs_uid) ||
((hfsmp->hfs_uid == UNKNOWNUID) &&
(cred->cr_uid == console_user)))) ||
(invokesuperuserstatus && (suser(cred, &p->p_acflag) == 0))) {
return (0);
} else {
return (EPERM);
}
}
unsigned long BestBlockSizeFit(unsigned long allocationBlockSize,
unsigned long blockSizeLimit,
unsigned long baseMultiple) {
int baseBlockCount, blockCount;
unsigned long trialBlockSize;
if (allocationBlockSize % baseMultiple != 0) {
return 512;
};
if (allocationBlockSize % PAGE_SIZE == 0) return PAGE_SIZE;
baseBlockCount = allocationBlockSize / baseMultiple;
for (blockCount = baseBlockCount; blockCount > 0; --blockCount) {
trialBlockSize = blockCount * baseMultiple;
if (allocationBlockSize % trialBlockSize == 0) {
if ((trialBlockSize <= blockSizeLimit) &&
(trialBlockSize % baseMultiple == 0)) {
return trialBlockSize;
};
};
};
return 512;
}
u_long
FindMetaDataDirectory(ExtendedVCB *vcb)
{
struct hfsmount * hfsmp;
struct vnode * dvp = NULL;
struct cnode * dcp = NULL;
struct FndrDirInfo * fndrinfo;
struct cat_desc out_desc = {0};
struct timeval tv;
int error;
if (vcb->vcbSigWord != kHFSPlusSigWord)
return (0);
hfsmp = VCBTOHFS(vcb);
if (hfsmp->hfs_privdir_desc.cd_parentcnid == 0) {
hfsmp->hfs_privdir_desc.cd_parentcnid = kRootDirID;
hfsmp->hfs_privdir_desc.cd_nameptr = hfs_privdirname;
hfsmp->hfs_privdir_desc.cd_namelen = strlen(hfs_privdirname);
hfsmp->hfs_privdir_desc.cd_flags = CD_ISDIR;
}
error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, current_proc());
if (error)
return (0);
error = cat_lookup(hfsmp, &hfsmp->hfs_privdir_desc, 0, NULL,
&hfsmp->hfs_privdir_attr, NULL);
if (error == 0) {
(void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, current_proc());
hfsmp->hfs_metadata_createdate = hfsmp->hfs_privdir_attr.ca_itime;
return (hfsmp->hfs_privdir_attr.ca_fileid);
} else if (hfsmp->hfs_fs_ronly) {
(void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, current_proc());
return (0);
}
bzero(&hfsmp->hfs_privdir_attr, sizeof(struct cat_attr));
hfsmp->hfs_privdir_attr.ca_mode = S_IFDIR;
hfsmp->hfs_privdir_attr.ca_flags = SF_IMMUTABLE;
hfsmp->hfs_privdir_attr.ca_nlink = 2;
hfsmp->hfs_privdir_attr.ca_itime = vcb->vcbCrDate;
hfsmp->hfs_privdir_attr.ca_mtime = time.tv_sec;
fndrinfo = (struct FndrDirInfo *)&hfsmp->hfs_privdir_attr.ca_finderinfo;
fndrinfo->frLocation.v = SWAP_BE16 (22460);
fndrinfo->frLocation.h = SWAP_BE16 (22460);
fndrinfo->frFlags |= SWAP_BE16 (kIsInvisible + kNameLocked);
hfs_global_shared_lock_acquire(hfsmp);
if (hfsmp->jnl) {
if ((error = journal_start_transaction(hfsmp->jnl)) != 0) {
hfs_global_shared_lock_release(hfsmp);
return (0);
}
}
error = cat_create(hfsmp, &hfsmp->hfs_privdir_desc,
&hfsmp->hfs_privdir_attr, &out_desc);
(void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, current_proc());
if (error) {
if (hfsmp->jnl) {
journal_end_transaction(hfsmp->jnl);
}
hfs_global_shared_lock_release(hfsmp);
return (0);
}
hfsmp->hfs_privdir_desc.cd_hint = out_desc.cd_hint;
hfsmp->hfs_privdir_desc.cd_cnid = out_desc.cd_cnid;
hfsmp->hfs_privdir_attr.ca_fileid = out_desc.cd_cnid;
hfsmp->hfs_metadata_createdate = vcb->vcbCrDate;
if (VFS_ROOT(HFSTOVFS(hfsmp), &dvp) == 0) {
dcp = VTOC(dvp);
dcp->c_childhint = out_desc.cd_hint;
dcp->c_nlink++;
dcp->c_entries++;
dcp->c_flag |= C_CHANGE | C_UPDATE;
tv = time;
(void) VOP_UPDATE(dvp, &tv, &tv, 0);
vput(dvp);
}
hfs_volupdate(hfsmp, VOL_MKDIR, 1);
if (hfsmp->jnl) {
journal_end_transaction(hfsmp->jnl);
}
hfs_global_shared_lock_release(hfsmp);
cat_releasedesc(&out_desc);
return (out_desc.cd_cnid);
}
__private_extern__
u_long
GetFileInfo(ExtendedVCB *vcb, u_int32_t dirid, char *name,
struct cat_attr *fattr, struct cat_fork *forkinfo)
{
struct hfsmount * hfsmp;
struct vnode * dvp = NULL;
struct cnode * dcp = NULL;
struct FndrDirInfo * fndrinfo;
struct cat_desc jdesc;
struct timeval tv;
int error;
if (vcb->vcbSigWord != kHFSPlusSigWord)
return (0);
hfsmp = VCBTOHFS(vcb);
memset(&jdesc, 0, sizeof(struct cat_desc));
jdesc.cd_parentcnid = kRootDirID;
jdesc.cd_nameptr = name;
jdesc.cd_namelen = strlen(name);
error = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, current_proc());
if (error)
return (0);
error = cat_lookup(hfsmp, &jdesc, 0, NULL, fattr, forkinfo);
(void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, current_proc());
if (error == 0) {
return (fattr->ca_fileid);
} else if (hfsmp->hfs_fs_ronly) {
return (0);
}
}
__private_extern__
void
hfs_remove_orphans(struct hfsmount * hfsmp)
{
struct BTreeIterator * iterator = NULL;
struct FSBufferDescriptor btdata;
struct HFSPlusCatalogFile filerec;
struct HFSPlusCatalogKey * keyp;
FCB *fcb;
ExtendedVCB *vcb;
char filename[32];
char tempname[32];
size_t namelen;
int catlock = 0;
int result, started_tr = 0;
if (hfsmp->hfs_orphans_cleaned)
return;
vcb = HFSTOVCB(hfsmp);
fcb = VTOF(vcb->catalogRefNum);
btdata.bufferAddress = &filerec;
btdata.itemSize = sizeof(filerec);
btdata.itemCount = 1;
MALLOC(iterator, struct BTreeIterator *, sizeof(*iterator), M_TEMP, M_WAITOK);
bzero(iterator, sizeof(*iterator));
keyp = (HFSPlusCatalogKey*)&iterator->key;
keyp->parentID = hfsmp->hfs_private_metadata_dir;
hfs_global_shared_lock_acquire(hfsmp);
if (hfsmp->jnl) {
if (journal_start_transaction(hfsmp->jnl) != 0) {
hfs_global_shared_lock_release(hfsmp);
return;
}
started_tr = 1;
}
result = hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_EXCLUSIVE, current_proc());
if (result)
goto exit;
catlock = 1;
result = BTSearchRecord(fcb, iterator, NULL, NULL, iterator);
if (result)
goto exit;
for (;;) {
result = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
if (result)
break;
if (keyp->parentID != hfsmp->hfs_private_metadata_dir)
break;
if (filerec.recordType != kHFSPlusFileRecord)
continue;
(void) utf8_encodestr(keyp->nodeName.unicode, keyp->nodeName.length * 2,
filename, &namelen, sizeof(filename), 0, 0);
(void) sprintf(tempname, "%s%d", HFS_DELETE_PREFIX, filerec.fileID);
if (bcmp(tempname, filename, namelen) == 0) {
struct filefork fork = {0};
struct cnode cnode = {0};
cnode.c_desc.cd_parentcnid = hfsmp->hfs_private_metadata_dir;
cnode.c_desc.cd_nameptr = filename;
cnode.c_desc.cd_namelen = namelen;
cnode.c_desc.cd_cnid = filerec.fileID;
cnode.c_attr.ca_fileid = filerec.fileID;
cnode.c_blocks = filerec.dataFork.totalBlocks +
filerec.resourceFork.totalBlocks;
if (BTIterateRecord(fcb, kBTreePrevRecord, iterator,
NULL, NULL) != 0)
break;
if (filerec.dataFork.totalBlocks > 0) {
fork.ff_cp = &cnode;
cnode.c_datafork = ⋔
bcopy(&filerec.dataFork, &fork.ff_data, sizeof(struct cat_fork));
if (TruncateFileC(vcb, (FCB*)&fork, 0, false) != 0) {
printf("error truncting data fork!\n");
break;
}
}
if (filerec.resourceFork.totalBlocks > 0) {
fork.ff_cp = &cnode;
cnode.c_datafork = NULL;
cnode.c_rsrcfork = ⋔
bcopy(&filerec.resourceFork, &fork.ff_data, sizeof(struct cat_fork));
if (TruncateFileC(vcb, (FCB*)&fork, 0, false) != 0) {
printf("error truncting rsrc fork!\n");
break;
}
}
if (cat_delete(hfsmp, &cnode.c_desc, &cnode.c_attr) != 0) {
printf("error deleting cat rec!\n");
break;
}
hfsmp->hfs_privdir_attr.ca_entries--;
(void)cat_update(hfsmp, &hfsmp->hfs_privdir_desc,
&hfsmp->hfs_privdir_attr, NULL, NULL);
hfs_volupdate(hfsmp, VOL_RMFILE, 0);
}
}
exit:
if (catlock)
(void) hfs_metafilelocking(hfsmp, kHFSCatalogFileID, LK_RELEASE, current_proc());
if (started_tr) {
journal_end_transaction(hfsmp->jnl);
}
hfs_global_shared_lock_release(hfsmp);
FREE(iterator, M_TEMP);
hfsmp->hfs_orphans_cleaned = 1;
}
u_int32_t
GetLogicalBlockSize(struct vnode *vp)
{
u_int32_t logBlockSize;
DBG_ASSERT(vp != NULL);
logBlockSize = VTOHFS(vp)->hfs_logBlockSize;
if (vp->v_flag & VSYSTEM) {
if (VTOF(vp)->fcbBTCBPtr != NULL) {
BTreeInfoRec bTreeInfo;
(void) BTGetInformation (VTOF(vp), kBTreeInfoVersion, &bTreeInfo);
logBlockSize = bTreeInfo.nodeSize;
} else if (VTOC(vp)->c_fileid == kHFSAllocationFileID) {
logBlockSize = VTOVCB(vp)->vcbVBMIOSize;
}
}
DBG_ASSERT(logBlockSize > 0);
return logBlockSize;
}
__private_extern__
u_int32_t
hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)
{
struct vcb_t *vcb = HFSTOVCB(hfsmp);
u_int32_t freeblks;
freeblks = vcb->freeBlocks;
if (wantreserve) {
if (freeblks > vcb->reserveBlocks)
freeblks -= vcb->reserveBlocks;
else
freeblks = 0;
}
freeblks -= vcb->loanedBlocks;
return (freeblks);
}
short MacToVFSError(OSErr err)
{
if (err >= 0)
return err;
switch (err) {
case dskFulErr:
return ENOSPC;
case btNoSpaceAvail:
return EFBIG;
case fxOvFlErr:
return EOVERFLOW;
case btBadNode:
return EBADF;
case memFullErr:
return ENOMEM;
case cmExists:
case btExists:
return EEXIST;
case cmNotFound:
case btNotFound:
return ENOENT;
case cmNotEmpty:
return ENOTEMPTY;
case cmFThdDirErr:
return EISDIR;
case fxRangeErr:
return ERANGE;
case bdNamErr:
return ENAMETOOLONG;
case paramErr:
case fileBoundsErr:
return EINVAL;
case fsBTBadNodeSize:
return ENXIO;
default:
return EIO;
}
}
__private_extern__
char *
hfs_getnamehint(struct cnode *dcp, int index)
{
struct hfs_index *entry;
void *self;
if (index > 0) {
self = current_thread();
SLIST_FOREACH(entry, &dcp->c_indexlist, hi_link) {
if ((entry->hi_index == index)
&& (entry->hi_thread == self))
return (entry->hi_name);
}
}
return (NULL);
}
__private_extern__
void
hfs_savenamehint(struct cnode *dcp, int index, const char * namehint)
{
struct hfs_index *entry;
int len;
if (index > 0) {
len = strlen(namehint);
MALLOC(entry, struct hfs_index *, len + sizeof(struct hfs_index),
M_TEMP, M_WAITOK);
entry->hi_index = index;
entry->hi_thread = current_thread();
bcopy(namehint, entry->hi_name, len + 1);
SLIST_INSERT_HEAD(&dcp->c_indexlist, entry, hi_link);
}
}
__private_extern__
void
hfs_relnamehint(struct cnode *dcp, int index)
{
struct hfs_index *entry;
void *self;
if (index > 0) {
self = current_thread();
SLIST_FOREACH(entry, &dcp->c_indexlist, hi_link) {
if ((entry->hi_index == index)
&& (entry->hi_thread == self)) {
SLIST_REMOVE(&dcp->c_indexlist, entry, hfs_index,
hi_link);
FREE(entry, M_TEMP);
break;
}
}
}
}
__private_extern__
void
hfs_relnamehints(struct cnode *dcp)
{
struct hfs_index *entry;
struct hfs_index *next;
if (!SLIST_EMPTY(&dcp->c_indexlist)) {
for(entry = SLIST_FIRST(&dcp->c_indexlist);
entry != NULL;
entry = next) {
next = SLIST_NEXT(entry, hi_link);
SLIST_REMOVE(&dcp->c_indexlist, entry, hfs_index, hi_link);
FREE(entry, M_TEMP);
}
}
}
__private_extern__
int
hfs_namecmp(const char *str1, size_t len1, const char *str2, size_t len2)
{
u_int16_t *ustr1, *ustr2;
size_t ulen1, ulen2;
size_t maxbytes;
int cmp = -1;
if (len1 != len2)
return (cmp);
maxbytes = kHFSPlusMaxFileNameChars << 1;
MALLOC(ustr1, u_int16_t *, maxbytes << 1, M_TEMP, M_WAITOK);
ustr2 = ustr1 + (maxbytes >> 1);
if (utf8_decodestr(str1, len1, ustr1, &ulen1, maxbytes, ':', 0) != 0)
goto out;
if (utf8_decodestr(str2, len2, ustr2, &ulen2, maxbytes, ':', 0) != 0)
goto out;
cmp = FastUnicodeCompare(ustr1, ulen1>>1, ustr2, ulen2>>1);
out:
FREE(ustr1, M_TEMP);
return (cmp);
}
__private_extern__
int
hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
void *_args, int embeddedOffset, int mdb_offset,
HFSMasterDirectoryBlock *mdbp, struct ucred *cred)
{
JournalInfoBlock *jibp;
struct buf *jinfo_bp, *bp;
int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
int retval, blksize = hfsmp->hfs_phys_block_size;
struct vnode *devvp;
struct hfs_mount_args *args = _args;
devvp = hfsmp->hfs_devvp;
if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {
arg_flags = args->journal_flags;
arg_tbufsz = args->journal_tbuffer_size;
}
sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / blksize;
retval = meta_bread(devvp,
embeddedOffset/blksize +
(SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock),
SWAP_BE32(vhp->blockSize), cred, &jinfo_bp);
if (retval)
return retval;
jibp = (JournalInfoBlock *)jinfo_bp->b_data;
jibp->flags = SWAP_BE32(jibp->flags);
jibp->offset = SWAP_BE64(jibp->offset);
jibp->size = SWAP_BE64(jibp->size);
if (jibp->flags & kJIJournalInFSMask) {
hfsmp->jvp = hfsmp->hfs_devvp;
} else {
printf("hfs: journal not stored in fs! don't know what to do.\n");
brelse(jinfo_bp);
return EINVAL;
}
hfsmp->jnl_start = jibp->offset / SWAP_BE32(vhp->blockSize);
if (jibp->flags & kJIJournalNeedInitMask) {
printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
jibp->offset + (off_t)embeddedOffset, jibp->size);
hfsmp->jnl = journal_create(hfsmp->jvp,
jibp->offset + (off_t)embeddedOffset,
jibp->size,
devvp,
blksize,
arg_flags,
arg_tbufsz,
hfs_sync_metadata, hfsmp->hfs_mp);
jibp->flags &= ~kJIJournalNeedInitMask;
jibp->flags = SWAP_BE32(jibp->flags);
bwrite(jinfo_bp);
jinfo_bp = NULL;
jibp = NULL;
} else {
hfsmp->jnl = journal_open(hfsmp->jvp,
jibp->offset + (off_t)embeddedOffset,
jibp->size,
devvp,
blksize,
arg_flags,
arg_tbufsz,
hfs_sync_metadata, hfsmp->hfs_mp);
brelse(jinfo_bp);
jinfo_bp = NULL;
jibp = NULL;
if (hfsmp->jnl && mdbp) {
retval = meta_bread(devvp, mdb_offset, blksize, cred, &bp);
if (retval) {
brelse(bp);
printf("hfs: failed to reload the mdb after opening the journal (retval %d)!\n",
retval);
return retval;
}
bcopy(bp->b_data + HFS_PRI_OFFSET(blksize), mdbp, 512);
brelse(bp);
bp = NULL;
}
}
if (hfsmp->jnl == NULL) {
hfsmp->jnl_start = 0;
printf("hfs: failed to open/create the journal (retval %d).\n", retval);
return EINVAL;
}
return 0;
}
static int
hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args)
{
JournalInfoBlock *jibp;
struct buf *jinfo_bp, *bp;
int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
int retval, need_flush = 0, write_jibp = 0;
struct vnode *devvp;
struct cat_attr jib_attr, jattr;
struct cat_fork jib_fork, jfork;
ExtendedVCB *vcb;
u_long fid;
struct hfs_mount_args *args = _args;
devvp = hfsmp->hfs_devvp;
vcb = HFSTOVCB(hfsmp);
if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS)) {
if (args->journal_disable) {
return 0;
}
arg_flags = args->journal_flags;
arg_tbufsz = args->journal_tbuffer_size;
}
fid = GetFileInfo(vcb, kRootDirID, ".journal_info_block", &jib_attr, &jib_fork);
if (fid == 0 || jib_fork.cf_extents[0].startBlock == 0 || jib_fork.cf_size == 0) {
printf("hfs: can't find the .journal_info_block! disabling journaling (start: %d).\n",
jib_fork.cf_extents[0].startBlock);
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
hfsmp->hfs_jnlinfoblkid = fid;
if (SWAP_BE32(vhp->journalInfoBlock) != jib_fork.cf_extents[0].startBlock) {
printf("hfs: The journal_info_block moved (was: %d; is: %d). Fixing up\n",
SWAP_BE32(vhp->journalInfoBlock), jib_fork.cf_extents[0].startBlock);
vcb->vcbJinfoBlock = jib_fork.cf_extents[0].startBlock;
vhp->journalInfoBlock = SWAP_BE32(jib_fork.cf_extents[0].startBlock);
}
sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / hfsmp->hfs_phys_block_size;
retval = meta_bread(devvp,
vcb->hfsPlusIOPosOffset / hfsmp->hfs_phys_block_size +
(SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock),
SWAP_BE32(vhp->blockSize), NOCRED, &jinfo_bp);
if (retval) {
printf("hfs: can't read journal info block. disabling journaling.\n");
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
jibp = (JournalInfoBlock *)jinfo_bp->b_data;
jibp->flags = SWAP_BE32(jibp->flags);
jibp->offset = SWAP_BE64(jibp->offset);
jibp->size = SWAP_BE64(jibp->size);
fid = GetFileInfo(vcb, kRootDirID, ".journal", &jattr, &jfork);
if (fid == 0 || jfork.cf_extents[0].startBlock == 0 || jfork.cf_size == 0) {
printf("hfs: can't find the journal file! disabling journaling (start: %d)\n",
jfork.cf_extents[0].startBlock);
brelse(jinfo_bp);
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
hfsmp->hfs_jnlfileid = fid;
if ((jibp->offset / (u_int64_t)vcb->blockSize) != jfork.cf_extents[0].startBlock) {
printf("hfs: The journal file moved (was: %lld; is: %d). Fixing up\n",
(jibp->offset / (u_int64_t)vcb->blockSize), jfork.cf_extents[0].startBlock);
jibp->offset = (u_int64_t)jfork.cf_extents[0].startBlock * (u_int64_t)vcb->blockSize;
write_jibp = 1;
}
if (jibp->size != (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize) {
printf("hfs: The journal file changed size! (was %lld; is %lld). Fixing up.\n",
jibp->size, (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize);
jibp->size = (u_int64_t)jfork.cf_extents[0].blockCount * vcb->blockSize;
write_jibp = 1;
}
if (jibp->flags & kJIJournalInFSMask) {
hfsmp->jvp = hfsmp->hfs_devvp;
} else {
printf("hfs: journal not stored in fs! don't know what to do.\n");
brelse(jinfo_bp);
return EINVAL;
}
hfsmp->jnl_start = jibp->offset / SWAP_BE32(vhp->blockSize);
if (jibp->flags & kJIJournalNeedInitMask) {
printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
jibp->offset + (off_t)vcb->hfsPlusIOPosOffset, jibp->size);
hfsmp->jnl = journal_create(hfsmp->jvp,
jibp->offset + (off_t)vcb->hfsPlusIOPosOffset,
jibp->size,
devvp,
hfsmp->hfs_phys_block_size,
arg_flags,
arg_tbufsz,
hfs_sync_metadata, hfsmp->hfs_mp);
jibp->flags &= ~kJIJournalNeedInitMask;
write_jibp = 1;
} else {
arg_flags |= JOURNAL_RESET;
hfsmp->jnl = journal_open(hfsmp->jvp,
jibp->offset + (off_t)vcb->hfsPlusIOPosOffset,
jibp->size,
devvp,
hfsmp->hfs_phys_block_size,
arg_flags,
arg_tbufsz,
hfs_sync_metadata, hfsmp->hfs_mp);
}
if (write_jibp) {
jibp->flags = SWAP_BE32(jibp->flags);
jibp->offset = SWAP_BE64(jibp->offset);
jibp->size = SWAP_BE64(jibp->size);
bwrite(jinfo_bp);
} else {
brelse(jinfo_bp);
}
jinfo_bp = NULL;
jibp = NULL;
if (hfsmp->jnl == NULL) {
hfsmp->jnl_start = 0;
printf("hfs: failed to open/create the journal (retval %d).\n", retval);
return EINVAL;
}
return 0;
}