#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <errno.h>
#include <mach/mach.h>
#include <sys/disk.h>
#include "lf_hfs.h"
#include "lf_hfs_locks.h"
#include "lf_hfs_format.h"
#include "lf_hfs.h"
#include "lf_hfs_endian.h"
#include "lf_hfs_logger.h"
#include "lf_hfs_mount.h"
#include "lf_hfs_utils.h"
#include "lf_hfs_logger.h"
#include "lf_hfs_raw_read_write.h"
#include "lf_hfs_vfsutils.h"
#include "lf_hfs_vfsops.h"
#include "lf_hfs_file_mgr_internal.h"
#include "lf_hfs_btrees_internal.h"
#include "lf_hfs_format.h"
#include "lf_hfs_file_extent_mapping.h"
#include "lf_hfs_sbunicode.h"
#include "lf_hfs_xattr.h"
#include "lf_hfs_unicode_wrappers.h"
#include "lf_hfs_link.h"
#include "lf_hfs_btree.h"
#include "lf_hfs_journal.h"
static int hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args);
u_int32_t GetFileInfo(ExtendedVCB *vcb, const char *name,
struct cat_attr *fattr, struct cat_fork *forkinfo);
unsigned char hfs_catname[] = "Catalog B-tree";
unsigned char hfs_extname[] = "Extents B-tree";
unsigned char hfs_vbmname[] = "Volume Bitmap";
unsigned char hfs_attrname[] = "Attribute B-tree";
unsigned char hfs_startupname[] = "Startup File";
int hfs_ValidateHFSPlusVolumeHeader(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp)
{
u_int16_t signature = SWAP_BE16(vhp->signature);
u_int16_t hfs_version = SWAP_BE16(vhp->version);
if (signature == kHFSPlusSigWord)
{
if (hfs_version != kHFSPlusVersion)
{
LFHFS_LOG(LEVEL_ERROR, "hfs_ValidateHFSPlusVolumeHeader: invalid HFS+ version: %x\n", hfs_version);
return (EINVAL);
}
} else if (signature == kHFSXSigWord)
{
if (hfs_version != kHFSXVersion)
{
LFHFS_LOG(LEVEL_ERROR, "hfs_ValidateHFSPlusVolumeHeader: invalid HFSX version: %x\n", hfs_version);
return (EINVAL);
}
} else
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_ValidateHFSPlusVolumeHeader: unknown Volume Signature : %x\n", signature);
return (EINVAL);
}
u_int32_t blockSize = SWAP_BE32(vhp->blockSize);
if (blockSize < 512 || !powerof2(blockSize))
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_ValidateHFSPlusVolumeHeader: invalid blocksize (%d) \n", blockSize);
return (EINVAL);
}
if (blockSize < hfsmp->hfs_logical_block_size)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_ValidateHFSPlusVolumeHeader: invalid physical blocksize (%d), hfs_logical_blocksize (%d) \n",
blockSize, hfsmp->hfs_logical_block_size);
return (EINVAL);
}
return 0;
}
int hfs_CollectBtreeStats(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, off_t embeddedOffset, void *args)
{
int retval = 0;
register ExtendedVCB *vcb = HFSTOVCB(hfsmp);
u_int32_t blockSize; blockSize = SWAP_BE32(vhp->blockSize);
uuid_t throwaway;
hfs_getvoluuid (hfsmp, throwaway);
hfsmp->scan_var = 0;
hfs_scan_blocks(hfsmp);
if (hfsmp->jnl && (hfsmp->hfs_flags & HFS_READ_ONLY) == 0)
{
hfs_flushvolumeheader(hfsmp, 0);
}
if ((hfsmp->hfs_flags & HFS_X) != 0)
{
hfsmp->hfs_flags |= HFS_FOLDERCOUNT;
}
if ( (vcb->vcbAtrb & kHFSVolumeJournaledMask) &&
(SWAP_BE32(vhp->lastMountedVersion) != kHFSJMountVersion) &&
(hfsmp->jnl == NULL))
{
retval = hfs_late_journal_init(hfsmp, vhp, args);
if (retval != 0)
{
if (retval == EROFS)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_late_journal_init returned (%d), maybe an external jnl?\n", retval);
retval = EINVAL;
goto ErrorExit;
}
hfsmp->jnl = NULL;
if (!(hfsmp->hfs_flags & HFS_READ_ONLY))
{
hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;
uint64_t mdb_offset = (uint64_t)((embeddedOffset / blockSize) + HFS_PRI_SECTOR(blockSize));
void *pvBuffer = hfs_malloc(hfsmp->hfs_physical_block_size);
if (pvBuffer == NULL)
{
retval = ENOMEM;
goto ErrorExit;
}
retval = raw_readwrite_read_mount( hfsmp->hfs_devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys), hfsmp->hfs_physical_block_size, pvBuffer, hfsmp->hfs_physical_block_size, NULL, NULL);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: JNL header raw_readwrite_read_mount failed with %d\n", retval);
hfs_free(pvBuffer);
goto ErrorExit;
}
HFSPlusVolumeHeader *jvhp = (HFSPlusVolumeHeader *)(pvBuffer + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord)
{
LFHFS_LOG(LEVEL_ERROR, "hfs_MountHFSPlusVolume: Journal replay fail. Writing lastMountVersion as FSK!\n");
jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);
retval = raw_readwrite_write_mount( hfsmp->hfs_devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys), hfsmp->hfs_physical_block_size, pvBuffer, hfsmp->hfs_physical_block_size, NULL, NULL);
hfs_free(pvBuffer);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: JNL header raw_readwrite_write_mount failed with %d\n", retval);
goto ErrorExit;
}
}
else
{
hfs_free(pvBuffer);
}
}
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_late_journal_init returned (%d)\n", retval);
retval = EINVAL;
goto ErrorExit;
}
else if (hfsmp->jnl)
{
hfsmp->hfs_mp->mnt_flag |= MNT_JOURNALED;
}
}
else if (hfsmp->jnl || ((vcb->vcbAtrb & kHFSVolumeJournaledMask) && (hfsmp->hfs_flags & HFS_READ_ONLY)))
{
struct cat_attr jinfo_attr, jnl_attr;
if (hfsmp->hfs_flags & HFS_READ_ONLY)
{
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
}
hfsmp->hfs_jnlinfoblkid = GetFileInfo(vcb, ".journal_info_block", &jinfo_attr, NULL);
hfsmp->hfs_jnlfileid = GetFileInfo(vcb, ".journal", &jnl_attr, NULL);
if (hfsmp->hfs_jnlinfoblkid == 0 || hfsmp->hfs_jnlfileid == 0)
{
LFHFS_LOG(LEVEL_DEFAULT, "hfs_MountHFSPlusVolume: danger! couldn't find the file-id's for the journal or journal_info_block\n");
LFHFS_LOG(LEVEL_DEFAULT, "hfs_MountHFSPlusVolume: jnlfileid %llu, jnlinfoblkid %llu\n", hfsmp->hfs_jnlfileid, hfsmp->hfs_jnlinfoblkid);
}
if (hfsmp->hfs_flags & HFS_READ_ONLY)
{
vcb->vcbAtrb |= kHFSVolumeJournaledMask;
}
if (hfsmp->jnl == NULL)
{
hfsmp->hfs_mp->mnt_flag &= ~(u_int64_t)((unsigned int)MNT_JOURNALED);
}
}
if ( !(vcb->vcbAtrb & kHFSVolumeHardwareLockMask) ) {
MarkVCBDirty( vcb ); }
if (hfsmp->hfs_mp->mnt_flag & MNT_CPROTECT)
{
if ((vcb->vcbAtrb & kHFSContentProtectionMask) == 0)
{
retval = EINVAL;
goto ErrorExit;
}
}
else
{
if (vcb->vcbAtrb & kHFSContentProtectionMask)
{
hfsmp->hfs_mp->mnt_flag |= MNT_CPROTECT;
}
}
#if LF_HFS_CHECK_UNMAPPED // TBD:
hfs_metadatazone_init(hfsmp, false);
if (hfsmp->hfs_flags & HFS_METADATA_ZONE)
{
if (vcb->nextAllocation >= hfsmp->hfs_metazone_start &&
vcb->nextAllocation <= hfsmp->hfs_metazone_end)
{
HFS_UPDATE_NEXT_ALLOCATION(hfsmp, hfsmp->hfs_metazone_end + 1);
}
}
else
#endif
{
if (vcb->nextAllocation <= 1)
{
vcb->nextAllocation = hfsmp->hfs_min_alloc_start;
}
}
vcb->sparseAllocation = hfsmp->hfs_min_alloc_start;
hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
hfs_privatedir_init(hfsmp, DIR_HARDLINKS);
hfs_remove_orphans(hfsmp);
retval = hfs_erase_unused_nodes(hfsmp);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_erase_unused_nodes returned (%d) for %s \n", retval, hfsmp->vcbVN);
goto ErrorExit;
}
hfsmp->hfs_flags |= HFS_XATTR_EXTENTS;
return (0);
ErrorExit:
hfsUnmount(hfsmp);
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: encountered error (%d)\n", retval);
return (retval);
}
int hfs_MountHFSPlusVolume(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, off_t embeddedOffset, u_int64_t disksize, bool bFailForDirty)
{
int retval = 0;
register ExtendedVCB *vcb;
struct cat_desc cndesc;
struct cat_attr cnattr;
struct cat_fork cfork;
u_int32_t blockSize;
uint64_t spare_sectors;
int newvnode_flags = 0;
BTreeInfoRec btinfo;
u_int16_t signature = SWAP_BE16(vhp->signature);
retval = hfs_ValidateHFSPlusVolumeHeader(hfsmp, vhp);
if (retval)
return retval;
if (signature == kHFSXSigWord)
{
signature = kHFSPlusSigWord;
hfsmp->hfs_flags |= HFS_X;
}
blockSize = SWAP_BE32(vhp->blockSize);
if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0 &&
hfsmp->jnl == NULL &&
(SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) == 0 &&
bFailForDirty)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: cannot mount dirty non-journaled volumes\n");
return (EINVAL);
}
if ((disksize & (hfsmp->hfs_logical_block_size - 1)) ||
(embeddedOffset & (hfsmp->hfs_logical_block_size - 1)))
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_logical_blocksize (%d) \n",hfsmp->hfs_logical_block_size);
return (ENXIO);
}
if (blockSize < hfsmp->hfs_physical_block_size)
{
hfsmp->hfs_physical_block_size = hfsmp->hfs_logical_block_size;
hfsmp->hfs_log_per_phys = 1;
}
vcb = HFSTOVCB(hfsmp);
vcb->vcbSigWord = signature;
vcb->vcbJinfoBlock = SWAP_BE32(vhp->journalInfoBlock);
vcb->vcbLsMod = to_bsd_time(SWAP_BE32(vhp->modifyDate));
vcb->vcbAtrb = 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_flags & HFS_READ_ONLY) == 0)
{
vcb->vcbWrCnt++;
}
vcb->nextAllocation = SWAP_BE32(vhp->nextAllocation);
vcb->totalBlocks = SWAP_BE32(vhp->totalBlocks);
vcb->allocLimit = vcb->totalBlocks;
vcb->freeBlocks = SWAP_BE32(vhp->freeBlocks);
vcb->blockSize = blockSize;
vcb->encodingsBitmap = SWAP_BE64(vhp->encodingsBitmap);
vcb->localCreateDate = SWAP_BE32(vhp->createDate);
vcb->hfsPlusIOPosOffset = (uint32_t) embeddedOffset;
vcb->reserveBlocks = 0;
hfsmp->hfs_logBlockSize = BestBlockSizeFit(vcb->blockSize, MAXBSIZE, hfsmp->hfs_logical_block_size);
vcb->vcbVBMIOSize = MIN(vcb->blockSize, MAXPHYSIO);
spare_sectors = hfsmp->hfs_logical_block_count - (((uint64_t)vcb->totalBlocks * blockSize) / hfsmp->hfs_logical_block_size);
if (spare_sectors > (uint64_t)(blockSize / hfsmp->hfs_logical_block_size))
{
hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) + HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);
hfsmp->hfs_fs_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) + HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, (((uint64_t)vcb->totalBlocks * blockSize) / hfsmp->hfs_logical_block_size));
}
else
{
hfsmp->hfs_partition_avh_sector = (hfsmp->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) + HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);
hfsmp->hfs_fs_avh_sector = hfsmp->hfs_partition_avh_sector;
}
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: partition_avh_sector=%qu, fs_avh_sector=%qu\n", hfsmp->hfs_partition_avh_sector, hfsmp->hfs_fs_avh_sector);
bzero(&cndesc, sizeof(cndesc));
cndesc.cd_parentcnid = kHFSRootParentID;
cndesc.cd_flags |= CD_ISMETA;
bzero(&cnattr, sizeof(cnattr));
cnattr.ca_linkcount = 1;
cnattr.ca_mode = S_IFREG;
cndesc.cd_nameptr = hfs_extname;
cndesc.cd_namelen = strlen((char *)hfs_extname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSExtentsFileID;
cfork.cf_size = SWAP_BE64 (vhp->extentsFile.logicalSize);
cfork.cf_new_size= 0;
cfork.cf_clump = SWAP_BE32 (vhp->extentsFile.clumpSize);
cfork.cf_blocks = SWAP_BE32 (vhp->extentsFile.totalBlocks);
cfork.cf_vblocks = 0;
cnattr.ca_blocks = cfork.cf_blocks;
for (int iExtentCounter = 0; iExtentCounter < kHFSPlusExtentDensity; iExtentCounter++)
{
cfork.cf_extents[iExtentCounter].startBlock = SWAP_BE32 (vhp->extentsFile.extents[iExtentCounter].startBlock);
cfork.cf_extents[iExtentCounter].blockCount = SWAP_BE32 (vhp->extentsFile.extents[iExtentCounter].blockCount);
}
retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &hfsmp->hfs_extents_vp, &newvnode_flags);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_getnewvnode returned (%d) getting extentoverflow BT\n", retval);
goto ErrorExit;
}
hfsmp->hfs_extents_cp = VTOC(hfsmp->hfs_extents_vp);
retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_extents_vp), (KeyCompareProcPtr) CompareExtentKeysPlus));
hfs_unlock(hfsmp->hfs_extents_cp);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: BTOpenPath returned (%d) getting extentoverflow BT\n", retval);
goto ErrorExit;
}
cndesc.cd_nameptr = hfs_catname;
cndesc.cd_namelen = strlen((char *)hfs_catname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSCatalogFileID;
cfork.cf_size = SWAP_BE64 (vhp->catalogFile.logicalSize);
cfork.cf_clump = SWAP_BE32 (vhp->catalogFile.clumpSize);
cfork.cf_blocks = SWAP_BE32 (vhp->catalogFile.totalBlocks);
cfork.cf_vblocks = 0;
cnattr.ca_blocks = cfork.cf_blocks;
for (int iExtentCounter = 0; iExtentCounter < kHFSPlusExtentDensity; iExtentCounter++)
{
cfork.cf_extents[iExtentCounter].startBlock = SWAP_BE32 (vhp->catalogFile.extents[iExtentCounter].startBlock);
cfork.cf_extents[iExtentCounter].blockCount = SWAP_BE32 (vhp->catalogFile.extents[iExtentCounter].blockCount);
}
retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &hfsmp->hfs_catalog_vp, &newvnode_flags);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_getnewvnode returned (%d) getting catalog BT\n", retval);
goto ErrorExit;
}
hfsmp->hfs_catalog_cp = VTOC(hfsmp->hfs_catalog_vp);
retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_catalog_vp), (KeyCompareProcPtr) CompareExtendedCatalogKeys));
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: BTOpenPath returned (%d) getting catalog BT\n", retval);
hfs_unlock(hfsmp->hfs_catalog_cp);
goto ErrorExit;
}
if ((hfsmp->hfs_flags & HFS_X) &&
BTGetInformation(VTOF(hfsmp->hfs_catalog_vp), 0, &btinfo) == 0)
{
if (btinfo.keyCompareType == kHFSBinaryCompare)
{
hfsmp->hfs_flags |= HFS_CASE_SENSITIVE;
(void) BTOpenPath(VTOF(hfsmp->hfs_catalog_vp), (KeyCompareProcPtr)cat_binarykeycompare);
}
}
hfs_unlock(hfsmp->hfs_catalog_cp);
cndesc.cd_nameptr = hfs_vbmname;
cndesc.cd_namelen = strlen((char *)hfs_vbmname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSAllocationFileID;
cfork.cf_size = SWAP_BE64 (vhp->allocationFile.logicalSize);
cfork.cf_clump = SWAP_BE32 (vhp->allocationFile.clumpSize);
cfork.cf_blocks = SWAP_BE32 (vhp->allocationFile.totalBlocks);
cfork.cf_vblocks = 0;
cnattr.ca_blocks = cfork.cf_blocks;
for (int iExtentCounter = 0; iExtentCounter < kHFSPlusExtentDensity; iExtentCounter++)
{
cfork.cf_extents[iExtentCounter].startBlock = SWAP_BE32 (vhp->allocationFile.extents[iExtentCounter].startBlock);
cfork.cf_extents[iExtentCounter].blockCount = SWAP_BE32 (vhp->allocationFile.extents[iExtentCounter].blockCount);
}
retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &hfsmp->hfs_allocation_vp, &newvnode_flags);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_getnewvnode returned (%d) getting bitmap\n", retval);
goto ErrorExit;
}
hfsmp->hfs_allocation_cp = VTOC(hfsmp->hfs_allocation_vp);
hfs_unlock(hfsmp->hfs_allocation_cp);
if (vhp->attributesFile.totalBlocks != 0) {
cndesc.cd_nameptr = hfs_attrname;
cndesc.cd_namelen = strlen((char *)hfs_attrname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSAttributesFileID;
cfork.cf_size = SWAP_BE64 (vhp->attributesFile.logicalSize);
cfork.cf_clump = SWAP_BE32 (vhp->attributesFile.clumpSize);
cfork.cf_blocks = SWAP_BE32 (vhp->attributesFile.totalBlocks);
cfork.cf_vblocks = 0;
cnattr.ca_blocks = cfork.cf_blocks;
for (int iExtentCounter = 0; iExtentCounter < kHFSPlusExtentDensity; iExtentCounter++)
{
cfork.cf_extents[iExtentCounter].startBlock = SWAP_BE32 (vhp->attributesFile.extents[iExtentCounter].startBlock);
cfork.cf_extents[iExtentCounter].blockCount = SWAP_BE32 (vhp->attributesFile.extents[iExtentCounter].blockCount);
}
retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &hfsmp->hfs_attribute_vp, &newvnode_flags);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_getnewvnode returned (%d) getting EA BT\n", retval);
goto ErrorExit;
}
hfsmp->hfs_attribute_cp = VTOC(hfsmp->hfs_attribute_vp);
retval = MacToVFSError(BTOpenPath(VTOF(hfsmp->hfs_attribute_vp),(KeyCompareProcPtr) hfs_attrkeycompare));
hfs_unlock(hfsmp->hfs_attribute_cp);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: BTOpenPath returned (%d) getting EA BT\n", retval);
goto ErrorExit;
}
retval = init_attrdata_vnode(hfsmp);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: init_attrdata_vnode returned (%d) for virtual EA file\n", retval);
goto ErrorExit;
}
}
if (vhp->startupFile.totalBlocks != 0) {
cndesc.cd_nameptr = hfs_startupname;
cndesc.cd_namelen = strlen((char *)hfs_startupname);
cndesc.cd_cnid = cnattr.ca_fileid = kHFSStartupFileID;
cfork.cf_size = SWAP_BE64 (vhp->startupFile.logicalSize);
cfork.cf_clump = SWAP_BE32 (vhp->startupFile.clumpSize);
cfork.cf_blocks = SWAP_BE32 (vhp->startupFile.totalBlocks);
cfork.cf_vblocks = 0;
cnattr.ca_blocks = cfork.cf_blocks;
for (int iExtentCounter = 0; iExtentCounter < kHFSPlusExtentDensity; iExtentCounter++)
{
cfork.cf_extents[iExtentCounter].startBlock = SWAP_BE32 (vhp->startupFile.extents[iExtentCounter].startBlock);
cfork.cf_extents[iExtentCounter].blockCount = SWAP_BE32 (vhp->startupFile.extents[iExtentCounter].blockCount);
}
retval = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &hfsmp->hfs_startup_vp, &newvnode_flags);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: hfs_getnewvnode returned (%d) getting startup file\n", retval);
goto ErrorExit;
}
hfsmp->hfs_startup_cp = VTOC(hfsmp->hfs_startup_vp);
hfs_unlock(hfsmp->hfs_startup_cp);
}
retval = cat_idlookup(hfsmp, kHFSRootFolderID, 0, 0, &cndesc, &cnattr, NULL);
if (retval)
{
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: cat_idlookup returned (%d) getting rootfolder \n", retval);
goto ErrorExit;
}
vcb->hfs_itime = cnattr.ca_itime;
vcb->volumeNameEncodingHint = cndesc.cd_encoding;
bcopy(cndesc.cd_nameptr, vcb->vcbVN, min(255, cndesc.cd_namelen));
cat_releasedesc(&cndesc);
return (0);
ErrorExit:
hfsUnmount(hfsmp);
LFHFS_LOG(LEVEL_DEBUG, "hfs_MountHFSPlusVolume: encountered error (%d)\n", retval);
return (retval);
}
u_int32_t BestBlockSizeFit(u_int32_t allocationBlockSize, u_int32_t blockSizeLimit, u_int32_t baseMultiple) {
int baseBlockCount, blockCount;
u_int32_t trialBlockSize;
if (allocationBlockSize % baseMultiple != 0) {
return 512;
};
if (allocationBlockSize % PAGE_SIZE == 0) return (u_int32_t)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;
}
int
hfs_lock_global (struct hfsmount *hfsmp, enum hfs_locktype locktype)
{
pthread_t thread = pthread_self();
if (hfsmp->hfs_global_lockowner == thread) {
LFHFS_LOG(LEVEL_ERROR, "hfs_lock_global: locking against myself!");
hfs_assert(0);
}
if (locktype == HFS_SHARED_LOCK) {
lf_lck_rw_lock_shared (&hfsmp->hfs_global_lock);
hfsmp->hfs_global_lockowner = HFS_SHARED_OWNER;
}
else {
lf_lck_rw_lock_exclusive (&hfsmp->hfs_global_lock);
hfsmp->hfs_global_lockowner = thread;
}
return 0;
}
void
hfs_unlock_global (struct hfsmount *hfsmp)
{
pthread_t thread = pthread_self();
if (hfsmp->hfs_global_lockowner == thread) {
hfsmp->hfs_global_lockowner = NULL;
lf_lck_rw_unlock_exclusive(&hfsmp->hfs_global_lock);
}
else {
lf_lck_rw_unlock_shared(&hfsmp->hfs_global_lock);
}
}
int
hfs_start_transaction(struct hfsmount *hfsmp)
{
int ret = 0, unlock_on_err = 0;
pthread_t thread = pthread_self();
#ifdef HFS_CHECK_LOCK_ORDER
if (hfsmp->jnl && journal_owner(hfsmp->jnl) != thread) {
if (hfsmp->hfs_catalog_cp && hfsmp->hfs_catalog_cp->c_lockowner == thread) {
LFHFS_LOG(LEVEL_ERROR, "hfs_start_transaction: bad lock order (cat before jnl)\n");
hfs_assert(0);
}
if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == thread) {
LFHFS_LOG(LEVEL_ERROR, "hfs_start_transaction: bad lock order (attr before jnl)\n");
hfs_assert(0);
}
if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == thread) {
LFHFS_LOG(LEVEL_ERROR, "hfs_start_transaction: bad lock order (ext before jnl)\n");
hfs_assert(0);
}
}
#endif
again:
if (hfsmp->jnl) {
if (journal_owner(hfsmp->jnl) != thread)
{
if (hfsmp->hfs_global_lockowner == thread) {
ret = EBUSY;
goto out;
}
hfs_lock_global (hfsmp, HFS_SHARED_LOCK);
if (!hfsmp->jnl) {
hfs_unlock_global(hfsmp);
goto again;
}
unlock_on_err = 1;
}
}
else
{
if (hfsmp->hfs_global_lockowner != thread) {
hfs_lock_global(hfsmp, HFS_EXCLUSIVE_LOCK);
if (hfsmp->jnl) {
hfs_unlock_global(hfsmp);
goto again;
}
ExtendedVCB * vcb = HFSTOVCB(hfsmp);
if (vcb->vcbAtrb & kHFSVolumeUnmountedMask) {
hfs_flushvolumeheader(hfsmp, HFS_FVH_SKIP_TRANSACTION);
}
unlock_on_err = 1;
}
}
if (hfsmp->jnl)
{
ret = journal_start_transaction(hfsmp->jnl);
}
else
{
ret = 0;
}
if (ret == 0)
++hfsmp->hfs_transaction_nesting;
goto out;
out:
if (ret != 0 && unlock_on_err) {
hfs_unlock_global (hfsmp);
}
return ret;
}
int
hfs_end_transaction(struct hfsmount *hfsmp)
{
int ret;
hfs_assert(!hfsmp->jnl || journal_owner(hfsmp->jnl) == pthread_self());
hfs_assert(hfsmp->hfs_transaction_nesting > 0);
if (hfsmp->jnl && hfsmp->hfs_transaction_nesting == 1)
hfs_flushvolumeheader(hfsmp, HFS_FVH_FLUSH_IF_DIRTY);
bool need_unlock = !--hfsmp->hfs_transaction_nesting;
if (hfsmp->jnl)
{
ret = journal_end_transaction(hfsmp->jnl);
}
else
{
ret = 0;
}
if (need_unlock) {
hfs_unlock_global (hfsmp);
}
return ret;
}
errno_t hfs_flush(struct hfsmount *hfsmp, hfs_flush_mode_t mode) {
errno_t error = 0;
int options = 0;
dk_synchronize_t sync_req = { .options = DK_SYNCHRONIZE_OPTION_BARRIER };
switch (mode) {
case HFS_FLUSH_JOURNAL_META:
SET(options, JOURNAL_WAIT_FOR_IO);
case HFS_FLUSH_JOURNAL:
case HFS_FLUSH_JOURNAL_BARRIER:
case HFS_FLUSH_FULL:
if (mode == HFS_FLUSH_JOURNAL_BARRIER &&
!(hfsmp->hfs_flags & HFS_FEATURE_BARRIER))
mode = HFS_FLUSH_FULL;
if (mode == HFS_FLUSH_FULL)
SET(options, JOURNAL_FLUSH_FULL);
hfs_lock_global (hfsmp, HFS_SHARED_LOCK);
if (hfsmp->jnl) {
ExtendedVCB * vcb = HFSTOVCB(hfsmp);
if (!(vcb->vcbAtrb & kHFSVolumeUnmountedMask)) {
hfs_flushvolumeheader(hfsmp, HFS_FVH_MARK_UNMOUNT);
}
error = journal_flush(hfsmp->jnl, options);
}
hfs_unlock_global (hfsmp);
if (mode == HFS_FLUSH_JOURNAL_BARRIER)
error = ioctl(hfsmp->hfs_devvp->psFSRecord->iFD, DKIOCSYNCHRONIZE, (caddr_t)&sync_req);
break;
case HFS_FLUSH_CACHE:
sync_req.options = 0;
case HFS_FLUSH_BARRIER:
if (!(hfsmp->hfs_flags & HFS_FEATURE_BARRIER))
sync_req.options = 0;
error = ioctl(hfsmp->hfs_devvp->psFSRecord->iFD, DKIOCSYNCHRONIZE, (caddr_t)&sync_req);
break;
default:
error = EINVAL;
}
return error;
}
#define MALLOC_TRACER 0
#if MALLOC_TRACER
#define MALLOC_TRACER_SIZE 100000
typedef struct {
void *pv;
size_t uSize;
} MallocTracer_S;
MallocTracer_S gpsMallocTracer[MALLOC_TRACER_SIZE];
MallocTracer_S gpsFreeTracer[MALLOC_TRACER_SIZE];
uint32_t guIndex = 0, guOutdex = 0, guSize=0, guTotal = 0;
uint64_t guTotalConsumption = 0;
#endif
void*
hfs_malloc(size_t size)
{
if (!size) {
panic("Malloc size is 0");
}
void *pv = malloc(size);
#if MALLOC_TRACER
gpsMallocTracer[guIndex].pv = pv;
gpsMallocTracer[guIndex].uSize = (uint32_t)size;
guIndex = (guIndex+1) % MALLOC_TRACER_SIZE;
guTotal++;
guSize++;
guTotalConsumption += size;
#endif
return pv;
}
void
hfs_free(void *ptr)
{
if (!ptr)
return;
free(ptr);
#if MALLOC_TRACER
gpsFreeTracer[guOutdex].pv = ptr;
bool bCont = true;
uint32_t u=guIndex;
do {
u = (u)?(u-1):(MALLOC_TRACER_SIZE-1);
if (gpsMallocTracer[u].pv == ptr) {
break;
}
bCont = (guTotal<MALLOC_TRACER_SIZE)?(u):(u != guIndex);
} while( bCont );
if (!bCont) {
panic("undetectable free");
assert(0);
}
gpsFreeTracer[guOutdex].uSize = guIndex;
guOutdex = (guOutdex+1) % MALLOC_TRACER_SIZE;
guSize--;
guTotalConsumption -= gpsMallocTracer[u].uSize;
#endif
}
void*
hfs_mallocz(size_t size)
{
void *ptr = hfs_malloc(size);
if ( ptr == NULL )
return ptr;
bzero(ptr, size);
return ptr;
}
void
hfs_lock_mount (struct hfsmount *hfsmp)
{
lf_lck_mtx_lock (&(hfsmp->hfs_mutex));
}
void hfs_unlock_mount (struct hfsmount *hfsmp)
{
lf_lck_mtx_unlock (&(hfsmp->hfs_mutex));
}
static void ReleaseMetaFileVNode(struct vnode *vp)
{
struct filefork *fp;
if (vp && (fp = VTOF(vp)))
{
if (fp->fcbBTCBPtr != NULL)
{
(void)hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);
(void) BTClosePath(fp);
hfs_unlock(VTOC(vp));
}
hfs_vnop_reclaim(vp);
}
}
int
hfsUnmount( register struct hfsmount *hfsmp)
{
if (hfsmp->hfs_attrdata_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_attrdata_vp);
hfsmp->hfs_attrdata_vp = NULL;
}
if (hfsmp->hfs_startup_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_startup_vp);
hfsmp->hfs_startup_cp = NULL;
hfsmp->hfs_startup_vp = NULL;
}
if (hfsmp->hfs_attribute_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_attribute_vp);
hfsmp->hfs_attribute_cp = NULL;
hfsmp->hfs_attribute_vp = NULL;
}
if (hfsmp->hfs_catalog_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_catalog_vp);
hfsmp->hfs_catalog_cp = NULL;
hfsmp->hfs_catalog_vp = NULL;
}
if (hfsmp->hfs_extents_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_extents_vp);
hfsmp->hfs_extents_cp = NULL;
hfsmp->hfs_extents_vp = NULL;
}
if (hfsmp->hfs_allocation_vp) {
ReleaseMetaFileVNode(hfsmp->hfs_allocation_vp);
hfsmp->hfs_allocation_cp = NULL;
hfsmp->hfs_allocation_vp = NULL;
}
return (0);
}
void RequireFileLock(FileReference vp, int shareable)
{
int locked;
if (VTOC(vp)->c_fileid == kHFSExtentsFileID ||
VTOC(vp)->c_fileid == kHFSAllocationFileID) {
shareable = 0;
}
locked = VTOC(vp)->c_lockowner == pthread_self();
if (!locked && !shareable)
{
switch (VTOC(vp)->c_fileid) {
case kHFSExtentsFileID:
LFHFS_LOG(LEVEL_ERROR, "RequireFileLock: extents btree not locked! v: 0x%08X\n #\n", (u_int)vp);
break;
case kHFSCatalogFileID:
LFHFS_LOG(LEVEL_ERROR, "RequireFileLock: catalog btree not locked! v: 0x%08X\n #\n", (u_int)vp);
break;
case kHFSAllocationFileID:
if (VTOHFS(vp)->jnl == NULL)
{
LFHFS_LOG(LEVEL_ERROR, "RequireFileLock: allocation file not locked! v: 0x%08X\n #\n", (u_int)vp);
}
return;
case kHFSStartupFileID:
LFHFS_LOG(LEVEL_ERROR, "RequireFileLock: startup file not locked! v: 0x%08X\n #\n", (u_int)vp);
break;
case kHFSAttributesFileID:
LFHFS_LOG(LEVEL_ERROR, "RequireFileLock: attributes btree not locked! v: 0x%08X\n #\n", (u_int)vp);
break;
default:
return;
}
hfs_assert(0);
}
}
bool overflow_extents(struct filefork *fp)
{
u_int32_t blocks;
if (fp->ff_extents[7].blockCount == 0)
return false;
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;
return fp->ff_blocks > blocks;
}
int
hfs_systemfile_lock(struct hfsmount *hfsmp, int flags, enum hfs_locktype locktype)
{
pthread_t thread = pthread_self();
if (flags & SFL_CATALOG) {
if (hfsmp->hfs_catalog_cp
&& hfsmp->hfs_catalog_cp->c_lockowner != thread) {
#ifdef HFS_CHECK_LOCK_ORDER
if (hfsmp->hfs_attribute_cp && hfsmp->hfs_attribute_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Attributes before Catalog)");
hfs_assert(0);
}
if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Startup before Catalog)");
hfs_assert(0);
}
if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Extents before Catalog)");
hfs_assert(0);
}
#endif
(void) hfs_lock(hfsmp->hfs_catalog_cp, locktype, HFS_LOCK_DEFAULT);
if (((flags & SFL_EXTENTS) == 0) &&
(hfsmp->hfs_catalog_vp != NULL) &&
(overflow_extents(VTOF(hfsmp->hfs_catalog_vp)))) {
flags |= SFL_EXTENTS;
}
} else {
flags &= ~SFL_CATALOG;
}
}
if (flags & SFL_ATTRIBUTE) {
if (hfsmp->hfs_attribute_cp
&& hfsmp->hfs_attribute_cp->c_lockowner != thread) {
#ifdef HFS_CHECK_LOCK_ORDER
if (hfsmp->hfs_startup_cp && hfsmp->hfs_startup_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Startup before Attributes)");
hfs_assert(0);
}
if (hfsmp->hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Extents before Attributes)");
hfs_assert(0);
}
#endif
(void) hfs_lock(hfsmp->hfs_attribute_cp, locktype, HFS_LOCK_DEFAULT);
if (((flags & SFL_EXTENTS) == 0) &&
(hfsmp->hfs_attribute_vp != NULL) &&
(overflow_extents(VTOF(hfsmp->hfs_attribute_vp)))) {
flags |= SFL_EXTENTS;
}
} else {
flags &= ~SFL_ATTRIBUTE;
}
}
if (flags & SFL_STARTUP) {
if (hfsmp->hfs_startup_cp
&& hfsmp->hfs_startup_cp->c_lockowner != thread) {
#ifdef HFS_CHECK_LOCK_ORDER
if (hfsmp-> hfs_extents_cp && hfsmp->hfs_extents_cp->c_lockowner == current_thread()) {
LFHFS_LOG(LEVEL_ERROR, "hfs_systemfile_lock: bad lock order (Extents before Startup)");
hfs_assert(0);
}
#endif
(void) hfs_lock(hfsmp->hfs_startup_cp, locktype, HFS_LOCK_DEFAULT);
if (((flags & SFL_EXTENTS) == 0) &&
(hfsmp->hfs_startup_vp != NULL) &&
(overflow_extents(VTOF(hfsmp->hfs_startup_vp)))) {
flags |= SFL_EXTENTS;
}
} else {
flags &= ~SFL_STARTUP;
}
}
if (flags & (SFL_BITMAP | SFL_EXTENTS)) {
if (hfsmp->hfs_allocation_cp) {
(void) hfs_lock(hfsmp->hfs_allocation_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);
flags |= SFL_BITMAP;
} else {
flags &= ~SFL_BITMAP;
}
}
if (flags & SFL_EXTENTS) {
if (hfsmp->hfs_extents_cp) {
(void) hfs_lock(hfsmp->hfs_extents_cp, HFS_EXCLUSIVE_LOCK, HFS_LOCK_DEFAULT);
} else {
flags &= ~SFL_EXTENTS;
}
}
return (flags);
}
void
hfs_systemfile_unlock(struct hfsmount *hfsmp, int flags)
{
if (!flags)
return;
if (flags & SFL_STARTUP && hfsmp->hfs_startup_cp) {
hfs_unlock(hfsmp->hfs_startup_cp);
}
if (flags & SFL_ATTRIBUTE && hfsmp->hfs_attribute_cp) {
hfs_unlock(hfsmp->hfs_attribute_cp);
}
if (flags & SFL_CATALOG && hfsmp->hfs_catalog_cp) {
hfs_unlock(hfsmp->hfs_catalog_cp);
}
if (flags & SFL_BITMAP && hfsmp->hfs_allocation_cp) {
hfs_unlock(hfsmp->hfs_allocation_cp);
}
if (flags & SFL_EXTENTS && hfsmp->hfs_extents_cp) {
hfs_unlock(hfsmp->hfs_extents_cp);
}
}
u_int32_t
hfs_freeblks(struct hfsmount * hfsmp, int wantreserve)
{
u_int32_t freeblks;
u_int32_t rsrvblks;
u_int32_t loanblks;
freeblks = hfsmp->freeBlocks;
rsrvblks = hfsmp->reserveBlocks;
loanblks = hfsmp->loanedBlocks + hfsmp->lockedBlocks;
if (wantreserve) {
if (freeblks > rsrvblks)
freeblks -= rsrvblks;
else
freeblks = 0;
}
if (freeblks > loanblks)
freeblks -= loanblks;
else
freeblks = 0;
return (freeblks);
}
short MacToVFSError(OSErr err)
{
if (err >= 0)
return err;
switch (err) {
case HFS_ERESERVEDNAME:
return err;
}
switch (err) {
case dskFulErr:
case btNoSpaceAvail:
return ENOSPC;
case fxOvFlErr:
return EOVERFLOW;
case btBadNode:
return EIO;
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;
}
}
directoryhint_t*
hfs_getdirhint(struct cnode *dcp, int index, int detach)
{
directoryhint_t *hint;
boolean_t need_remove, need_init;
const u_int8_t* name;
struct timeval tv;
microtime(&tv);
TAILQ_FOREACH(hint, &dcp->c_hintlist, dh_link)
{
if (hint->dh_index == index)
break;
}
if (hint != NULL)
{
need_init = false;
need_remove = true;
}
else
{
need_init = true;
if (dcp->c_dirhintcnt < HFS_MAXDIRHINTS)
{
hint = hfs_malloc(sizeof(struct directoryhint));
++dcp->c_dirhintcnt;
need_remove = false;
}
else
{
hint = TAILQ_LAST(&dcp->c_hintlist, hfs_hinthead);
if ((hint->dh_desc.cd_flags & CD_HASBUF) && (name = hint->dh_desc.cd_nameptr))
{
hint->dh_desc.cd_nameptr = NULL;
hint->dh_desc.cd_namelen = 0;
hint->dh_desc.cd_flags &= ~CD_HASBUF;
hfs_free((void*)name);
}
need_remove = true;
}
}
if (need_remove)
TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);
if (detach)
--dcp->c_dirhintcnt;
else
TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);
if (need_init)
{
hint->dh_index = index;
hint->dh_desc.cd_flags = 0;
hint->dh_desc.cd_encoding = 0;
hint->dh_desc.cd_namelen = 0;
hint->dh_desc.cd_nameptr = NULL;
hint->dh_desc.cd_parentcnid = dcp->c_fileid;
hint->dh_desc.cd_hint = dcp->c_childhint;
hint->dh_desc.cd_cnid = 0;
}
hint->dh_time = (uint32_t) tv.tv_sec;
return (hint);
}
void
hfs_insertdirhint(struct cnode *dcp, directoryhint_t * hint)
{
directoryhint_t *test;
TAILQ_FOREACH(test, &dcp->c_hintlist, dh_link)
{
if (test == hint)
{
LFHFS_LOG(LEVEL_ERROR, "hfs_insertdirhint: hint %p already on list!", hint);
hfs_assert(0);
}
}
TAILQ_INSERT_HEAD(&dcp->c_hintlist, hint, dh_link);
++dcp->c_dirhintcnt;
}
void
hfs_reldirhint(struct cnode *dcp, directoryhint_t * relhint)
{
const u_int8_t * name;
directoryhint_t *hint;
TAILQ_FOREACH(hint, &dcp->c_hintlist, dh_link)
{
if (hint == relhint)
{
TAILQ_REMOVE(&dcp->c_hintlist, relhint, dh_link);
--dcp->c_dirhintcnt;
break;
}
}
name = relhint->dh_desc.cd_nameptr;
if ((relhint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL))
{
relhint->dh_desc.cd_nameptr = NULL;
relhint->dh_desc.cd_namelen = 0;
relhint->dh_desc.cd_flags &= ~CD_HASBUF;
hfs_free((void*)name);
}
hfs_free(relhint);
}
int
hfs_namecmp(const u_int8_t *str1, size_t len1, const u_int8_t *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;
ustr1 = hfs_malloc(maxbytes << 1);
ustr2 = ustr1 + (maxbytes >> 1);
if (utf8_decodestr(str1, len1, ustr1, &ulen1, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
goto out;
if (utf8_decodestr(str2, len2, ustr2, &ulen2, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
goto out;
ulen1 = ulen1 / sizeof(UniChar);
ulen2 = ulen2 / sizeof(UniChar);
cmp = FastUnicodeCompare(ustr1, ulen1, ustr2, ulen2);
out:
hfs_free(ustr1);
return (cmp);
}
int
hfs_apendixcmp(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2)
{
u_int16_t *ustr1, *ustr2, *original_allocation;
size_t ulen1, ulen2;
size_t maxbytes;
int cmp = -1;
maxbytes = kHFSPlusMaxFileNameChars << 1;
ustr1 = hfs_malloc(maxbytes << 1);
ustr2 = ustr1 + (maxbytes >> 1);
original_allocation = ustr1;
if (utf8_decodestr(str1, len1, ustr1, &ulen1, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
goto out;
if (utf8_decodestr(str2, len2, ustr2, &ulen2, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
goto out;
ulen1 = ulen1 / sizeof(UniChar);
ulen2 = ulen2 / sizeof(UniChar);
ustr1+= ulen1 - ulen2;
cmp = FastUnicodeCompare(ustr1, ulen2, ustr2, ulen2);
out:
hfs_free(original_allocation);
return (cmp);
}
int
hfs_strstr(const u_int8_t *str1, size_t len1, const u_int8_t *str2, size_t len2)
{
u_int16_t *ustr1, *ustr2, *original_allocation;
size_t ulen1, ulen2;
size_t maxbytes;
int cmp = 0;
maxbytes = kHFSPlusMaxFileNameChars << 1;
ustr1 = hfs_malloc(maxbytes << 1);
ustr2 = ustr1 + (maxbytes >> 1);
original_allocation = ustr1;
if (utf8_decodestr(str1, len1, ustr1, &ulen1, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
{
goto out;
}
if (utf8_decodestr(str2, len2, ustr2, &ulen2, maxbytes, ':', UTF_DECOMPOSED | UTF_ESCAPE_ILLEGAL) != 0)
{
goto out;
}
ulen1 = ulen1 / sizeof(UniChar);
ulen2 = ulen2 / sizeof(UniChar);
do {
if (ulen1-- < ulen2)
{
cmp = 1;
break;
}
} while (FastUnicodeCompare(ustr1++, ulen2, ustr2, ulen2) != 0);
out:
hfs_free(original_allocation);
return cmp;
}
void
hfs_reldirhints(struct cnode *dcp, int stale_hints_only)
{
struct timeval tv;
directoryhint_t *hint, *prev;
const u_int8_t * name;
if (stale_hints_only)
microuptime(&tv);
TAILQ_FOREACH_REVERSE_SAFE(hint, &dcp->c_hintlist, hfs_hinthead, dh_link, prev) {
if (stale_hints_only && (tv.tv_sec - hint->dh_time) < HFS_DIRHINT_TTL)
break;
name = hint->dh_desc.cd_nameptr;
if ((hint->dh_desc.cd_flags & CD_HASBUF) && (name != NULL)) {
hint->dh_desc.cd_nameptr = NULL;
hint->dh_desc.cd_namelen = 0;
hint->dh_desc.cd_flags &= ~CD_HASBUF;
hfs_free((void *)name);
}
TAILQ_REMOVE(&dcp->c_hintlist, hint, dh_link);
hfs_free(hint);
--dcp->c_dirhintcnt;
}
}
int hfs_erase_unused_nodes(struct hfsmount *hfsmp)
{
int result;
struct filefork *catalog;
int lockflags;
if (hfsmp->vcbAtrb & kHFSUnusedNodeFixMask)
{
return 0;
}
if ((hfsmp->localCreateDate < kHFSUnusedNodesFixDate))
{
hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
return 0;
}
catalog = hfsmp->hfs_catalog_cp->c_datafork;
if (catalog->ff_size > catalog->ff_clumpsize)
{
hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
return 0;
}
LFHFS_LOG(LEVEL_DEBUG, "hfs_erase_unused_nodes: updating volume %s.\n", hfsmp->vcbVN);
result = hfs_start_transaction(hfsmp);
if (result)
goto done;
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
result = BTZeroUnusedNodes(catalog);
hfs_systemfile_unlock(hfsmp, lockflags);
hfs_end_transaction(hfsmp);
if (result == 0)
hfsmp->vcbAtrb |= kHFSUnusedNodeFixMask;
LFHFS_LOG(LEVEL_DEBUG, "hfs_erase_unused_nodes: done updating volume %s.\n", hfsmp->vcbVN);
done:
return result;
}
void
hfs_remove_orphans(struct hfsmount * hfsmp)
{
BTreeIterator * iterator = NULL;
FSBufferDescriptor btdata;
struct HFSPlusCatalogFile filerec;
struct HFSPlusCatalogKey * keyp;
FCB *fcb;
ExtendedVCB *vcb;
char filename[32];
char tempname[32];
size_t namelen;
cat_cookie_t cookie;
int catlock = 0;
int catreserve = 0;
bool started_tr = false;
int lockflags;
int result;
int orphaned_files = 0;
int orphaned_dirs = 0;
bzero(&cookie, sizeof(cookie));
if (hfsmp->hfs_flags & HFS_CLEANED_ORPHANS)
return;
vcb = HFSTOVCB(hfsmp);
fcb = VTOF(hfsmp->hfs_catalog_vp);
btdata.bufferAddress = &filerec;
btdata.itemSize = sizeof(filerec);
btdata.itemCount = 1;
iterator = hfs_mallocz(sizeof(BTreeIterator));
if (iterator == NULL)
return;
keyp = (HFSPlusCatalogKey*)&iterator->key;
keyp->parentID = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;
keyp->nodeName.length = 4;
keyp->keyLength = kHFSPlusCatalogKeyMinimumLength + keyp->nodeName.length * 2;
keyp->nodeName.unicode[0] = 't';
keyp->nodeName.unicode[1] = 'e';
keyp->nodeName.unicode[2] = 'm';
keyp->nodeName.unicode[3] = 'p';
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
(void) BTSearchRecord(fcb, iterator, NULL, NULL, iterator);
hfs_systemfile_unlock(hfsmp, lockflags);
for (;;) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
result = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
if (result)
break;
if (keyp->parentID != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid)
break;
(void) utf8_encodestr(keyp->nodeName.unicode, keyp->nodeName.length * 2,
(u_int8_t *)filename, &namelen, sizeof(filename), 0, UTF_ADD_NULL_TERM);
(void) snprintf(tempname, sizeof(tempname), "%s%d", HFS_DELETE_PREFIX, filerec.fileID);
if (bcmp(tempname, filename, namelen + 1) != 0)
continue;
struct filefork dfork;
struct filefork rfork;
struct cnode cnode;
int mode = 0;
bzero(&dfork, sizeof(dfork));
bzero(&rfork, sizeof(rfork));
bzero(&cnode, sizeof(cnode));
if (hfs_start_transaction(hfsmp) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: failed to start transaction\n");
goto exit;
}
started_tr = true;
if (cat_preflight(hfsmp, CAT_DELETE, &cookie) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: cat_preflight failed\n");
goto exit;
}
catreserve = 1;
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
catlock = 1;
cat_convertattr(hfsmp, (CatalogRecord *)&filerec, &cnode.c_attr, &dfork.ff_data, &rfork.ff_data);
cnode.c_desc.cd_parentcnid = hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid;
cnode.c_desc.cd_nameptr = (const u_int8_t *)filename;
cnode.c_desc.cd_namelen = namelen;
cnode.c_desc.cd_cnid = cnode.c_attr.ca_fileid;
cnode.c_blocks = dfork.ff_blocks + rfork.ff_blocks;
if (BTIterateRecord(fcb, kBTreePrevRecord, iterator,
NULL, NULL) != 0) {
break;
}
if (dfork.ff_blocks > 0) {
u_int64_t fsize;
dfork.ff_cp = &cnode;
cnode.c_datafork = &dfork;
cnode.c_rsrcfork = NULL;
fsize = (u_int64_t)dfork.ff_blocks * (u_int64_t)HFSTOVCB(hfsmp)->blockSize;
while (fsize > 0) {
if (fsize > HFS_BIGFILE_SIZE) {
fsize -= HFS_BIGFILE_SIZE;
} else {
fsize = 0;
}
if (TruncateFileC(vcb, (FCB*)&dfork, fsize, 1, 0, cnode.c_attr.ca_fileid, false) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: error truncating data fork!\n");
break;
}
if (fsize > 0) {
hfs_systemfile_unlock(hfsmp, lockflags);
catlock = 0;
hfs_end_transaction(hfsmp);
if (hfs_start_transaction(hfsmp) != 0) {
started_tr = false;
goto exit;
}
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
catlock = 1;
}
}
}
if (rfork.ff_blocks > 0) {
rfork.ff_cp = &cnode;
cnode.c_datafork = NULL;
cnode.c_rsrcfork = &rfork;
if (TruncateFileC(vcb, (FCB*)&rfork, 0, 1, 1, cnode.c_attr.ca_fileid, false) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: error truncating rsrc fork!\n");
break;
}
}
if (ISSET(cnode.c_attr.ca_recflags, kHFSHasAttributesMask)) {
hfs_systemfile_unlock(hfsmp, lockflags);
catlock = false;
hfs_end_transaction(hfsmp);
hfs_removeallattr(hfsmp, cnode.c_attr.ca_fileid, &started_tr);
if (!started_tr) {
if (hfs_start_transaction(hfsmp) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans:: failed to start transaction\n");
goto exit;
}
started_tr = true;
}
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
}
if (cat_delete(hfsmp, &cnode.c_desc, &cnode.c_attr) != 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: error deleting cat rec for id %d!\n", cnode.c_desc.cd_cnid);
hfs_systemfile_unlock(hfsmp, lockflags);
catlock = 0;
hfs_volupdate(hfsmp, VOL_UPDATE, 0);
break;
}
mode = cnode.c_attr.ca_mode & S_IFMT;
if (mode == S_IFDIR) {
orphaned_dirs++;
}
else {
orphaned_files++;
}
hfsmp->hfs_private_attr[FILE_HARDLINKS].ca_entries--;
if (mode == S_IFDIR) {
DEC_FOLDERCOUNT(hfsmp, hfsmp->hfs_private_attr[FILE_HARDLINKS]);
}
(void)cat_update(hfsmp, &hfsmp->hfs_private_desc[FILE_HARDLINKS],
&hfsmp->hfs_private_attr[FILE_HARDLINKS], NULL, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
cat_postflight(hfsmp, &cookie);
catlock = catreserve = 0;
if (mode == S_IFDIR) {
hfs_volupdate(hfsmp, VOL_RMDIR, 0);
}
else{
hfs_volupdate(hfsmp, VOL_RMFILE, 0);
}
hfs_end_transaction(hfsmp);
started_tr = false;
}
exit:
if (orphaned_files > 0 || orphaned_dirs > 0)
LFHFS_LOG(LEVEL_ERROR, "hfs_remove_orphans: Removed %d orphaned / unlinked files and %d directories \n", orphaned_files, orphaned_dirs);
if (catlock) {
hfs_systemfile_unlock(hfsmp, lockflags);
}
if (catreserve) {
cat_postflight(hfsmp, &cookie);
}
if (started_tr) {
hfs_end_transaction(hfsmp);
}
hfs_free(iterator);
hfsmp->hfs_flags |= HFS_CLEANED_ORPHANS;
}
u_int32_t GetFileInfo(ExtendedVCB *vcb, const char *name,
struct cat_attr *fattr, struct cat_fork *forkinfo) {
struct hfsmount * hfsmp;
struct cat_desc jdesc;
int lockflags;
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 = (const u_int8_t *)name;
jdesc.cd_namelen = strlen(name);
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = cat_lookup(hfsmp, &jdesc, 0, NULL, fattr, forkinfo, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error == 0) {
return (fattr->ca_fileid);
} else if (hfsmp->hfs_flags & HFS_READ_ONLY) {
return (0);
}
return (0);
}
int hfs_early_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp,
void *_args, off_t embeddedOffset, daddr64_t mdb_offset,
HFSMasterDirectoryBlock *mdbp) {
JournalInfoBlock *jibp;
void *bp = NULL;
void *jinfo_bp = NULL;
int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
int retval = 0;
uint32_t blksize = hfsmp->hfs_logical_block_size;
struct vnode *devvp;
struct hfs_mount_args *args = _args;
u_int32_t jib_flags;
u_int64_t jib_offset;
u_int64_t jib_size;
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;
jinfo_bp = hfs_malloc(hfsmp->hfs_physical_block_size);
if (!jinfo_bp) {
goto cleanup_dev_name;
}
uint32_t ujournalInfoBlock = SWAP_BE32(vhp->journalInfoBlock);
uint64_t u64JournalOffset =
(daddr64_t)((embeddedOffset/blksize) + ((u_int64_t)ujournalInfoBlock*sectors_per_fsblock));
retval = raw_readwrite_read_mount(devvp, u64JournalOffset, hfsmp->hfs_physical_block_size,
jinfo_bp, hfsmp->hfs_physical_block_size, NULL, NULL);
if (retval) {
goto cleanup_dev_name;
}
jibp = jinfo_bp;
jib_flags = SWAP_BE32(jibp->flags);
jib_size = SWAP_BE64(jibp->size);
if (!(jib_flags & kJIJournalInFSMask)) {
goto cleanup_dev_name;
}
hfsmp->jvp = hfsmp->hfs_devvp;
jib_offset = SWAP_BE64(jibp->offset);
hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);
hfsmp->jnl_size = jib_size;
if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (hfsmp->hfs_mp->mnt_flag & MNT_ROOTFS) == 0) {
retval = journal_is_clean(hfsmp->jvp,
jib_offset + embeddedOffset,
jib_size,
devvp,
hfsmp->hfs_logical_block_size,
hfsmp->hfs_mp);
hfsmp->jnl = NULL;
hfs_free(jinfo_bp);
jinfo_bp = NULL;
if (retval) {
LFHFS_LOG(LEVEL_ERROR, "hfs: early journal init: the volume is read-only and journal is dirty. Can not mount volume.\n");
}
goto cleanup_dev_name;
}
if (jib_flags & kJIJournalNeedInitMask) {
LFHFS_LOG(LEVEL_ERROR, "hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
jib_offset + embeddedOffset, jib_size);
hfsmp->jnl = journal_create(hfsmp->jvp,
jib_offset + embeddedOffset,
jib_size,
devvp,
blksize,
arg_flags,
arg_tbufsz,
NULL,
hfsmp->hfs_mp,
hfsmp->hfs_mp);
jib_flags &= ~kJIJournalNeedInitMask;
jibp->flags = SWAP_BE32(jib_flags);
raw_readwrite_write_mount(devvp, u64JournalOffset, hfsmp->hfs_physical_block_size,
jinfo_bp, hfsmp->hfs_physical_block_size, NULL, NULL);
jinfo_bp = NULL;
jibp = NULL;
} else {
LFHFS_LOG(LEVEL_DEFAULT, "hfs: Opening the journal (jib_offset 0x%llx size 0x%llx vhp_blksize %d)...\n",
jib_offset + embeddedOffset,
jib_size, SWAP_BE32(vhp->blockSize));
hfsmp->jnl = journal_open(hfsmp->jvp,
jib_offset + embeddedOffset,
jib_size,
devvp,
blksize,
arg_flags,
arg_tbufsz,
NULL,
hfsmp->hfs_mp,
hfsmp->hfs_mp);
if (hfsmp->jnl && mdbp) {
if (mdb_offset == 0) {
mdb_offset = (daddr64_t)((embeddedOffset / blksize) + HFS_PRI_SECTOR(blksize));
}
bp = hfs_malloc(hfsmp->hfs_physical_block_size);
if (!bp) {
goto cleanup_dev_name;
}
uint64_t u64MDBOffset = HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys);
retval = raw_readwrite_read_mount(devvp, u64MDBOffset, hfsmp->hfs_physical_block_size, bp, hfsmp->hfs_physical_block_size, NULL, NULL);
if (retval) {
LFHFS_LOG(LEVEL_ERROR, "hfs: failed to reload the mdb after opening the journal (retval %d)!\n", retval);
goto cleanup_dev_name;
}
bcopy(bp + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size), mdbp, 512);
}
}
if (hfsmp->jnl == NULL) {
LFHFS_LOG(LEVEL_ERROR, "hfs: early jnl init: failed to open/create the journal (retval %d).\n", retval);
retval = EINVAL;
goto cleanup_dev_name;
}
cleanup_dev_name:
if (bp)
hfs_free(bp);
if (jinfo_bp)
hfs_free(jinfo_bp);
return retval;
}
static int hfs_late_journal_init(struct hfsmount *hfsmp, HFSPlusVolumeHeader *vhp, void *_args) {
JournalInfoBlock *jibp;
void *jinfo_bp = NULL;
int sectors_per_fsblock, arg_flags=0, arg_tbufsz=0;
int retval, write_jibp = 0, recreate_journal = 0;
struct vnode *devvp;
struct cat_attr jib_attr, jattr;
struct cat_fork jib_fork, jfork;
ExtendedVCB *vcb;
u_int32_t fid;
struct hfs_mount_args *args = _args;
u_int32_t jib_flags;
u_int64_t jib_offset;
u_int64_t jib_size;
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, ".journal_info_block", &jib_attr, &jib_fork);
if (fid == 0 || jib_fork.cf_extents[0].startBlock == 0 || jib_fork.cf_size == 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs: can't find the .journal_info_block! disabling journaling (start: %d).\n",
fid ? jib_fork.cf_extents[0].startBlock : 0);
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
hfsmp->hfs_jnlinfoblkid = fid;
if (SWAP_BE32(vhp->journalInfoBlock) != jib_fork.cf_extents[0].startBlock) {
LFHFS_LOG(LEVEL_ERROR, "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);
recreate_journal = 1;
}
sectors_per_fsblock = SWAP_BE32(vhp->blockSize) / hfsmp->hfs_logical_block_size;
jinfo_bp = hfs_malloc(hfsmp->hfs_physical_block_size);
if (!jinfo_bp) {
LFHFS_LOG(LEVEL_ERROR, "hfs: can't alloc memory.\n");
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
uint64_t u64JournalOffset =
(vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size +
((u_int64_t)SWAP_BE32(vhp->journalInfoBlock)*sectors_per_fsblock));
retval = raw_readwrite_read_mount(devvp, u64JournalOffset, hfsmp->hfs_physical_block_size, jinfo_bp, hfsmp->hfs_physical_block_size, NULL, NULL);
if (retval) {
if (jinfo_bp) {
hfs_free(jinfo_bp);
}
LFHFS_LOG(LEVEL_ERROR, "hfs: can't read journal info block. disabling journaling.\n");
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
jibp = jinfo_bp;
jib_flags = SWAP_BE32(jibp->flags);
jib_offset = SWAP_BE64(jibp->offset);
jib_size = SWAP_BE64(jibp->size);
fid = GetFileInfo(vcb, ".journal", &jattr, &jfork);
if (fid == 0 || jfork.cf_extents[0].startBlock == 0 || jfork.cf_size == 0) {
LFHFS_LOG(LEVEL_ERROR, "hfs: can't find the journal file! disabling journaling (start: %d)\n",
fid ? jfork.cf_extents[0].startBlock : 0);
hfs_free(jinfo_bp);
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
hfsmp->hfs_jnlfileid = fid;
if ((jib_flags & kJIJournalInFSMask) && (jib_offset / (u_int64_t)vcb->blockSize) != jfork.cf_extents[0].startBlock) {
LFHFS_LOG(LEVEL_ERROR, "hfs: The journal file moved (was: %lld; is: %d). Fixing up\n",
(jib_offset / (u_int64_t)vcb->blockSize), jfork.cf_extents[0].startBlock);
jib_offset = (u_int64_t)jfork.cf_extents[0].startBlock * (u_int64_t)vcb->blockSize;
write_jibp = 1;
recreate_journal = 1;
}
if (jib_size != (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize) {
LFHFS_LOG(LEVEL_ERROR, "hfs: The journal file changed size! (was %lld; is %lld). Fixing up.\n",
jib_size, (u_int64_t)jfork.cf_extents[0].blockCount*vcb->blockSize);
jib_size = (u_int64_t)jfork.cf_extents[0].blockCount * vcb->blockSize;
write_jibp = 1;
recreate_journal = 1;
}
if (!(jib_flags & kJIJournalInFSMask)) {
LFHFS_LOG(LEVEL_ERROR, "hfs: No support for journal on a different volume\n");
hfs_free(jinfo_bp);
vcb->vcbAtrb &= ~kHFSVolumeJournaledMask;
return 0;
}
hfsmp->jvp = hfsmp->hfs_devvp;
jib_offset += (off_t)vcb->hfsPlusIOPosOffset;
hfsmp->jnl_start = jib_offset / SWAP_BE32(vhp->blockSize);
hfsmp->jnl_size = jib_size;
if ((hfsmp->hfs_flags & HFS_READ_ONLY) && (hfsmp->hfs_mp->mnt_flag & MNT_ROOTFS) == 0) {
retval = journal_is_clean(hfsmp->jvp,
jib_offset,
jib_size,
devvp,
hfsmp->hfs_logical_block_size,
hfsmp->hfs_mp);
hfsmp->jnl = NULL;
hfs_free(jinfo_bp);
if (retval) {
LFHFS_LOG(LEVEL_ERROR, "hfs_late_journal_init: volume on is read-only and journal is dirty. Can not mount volume.\n");
}
return retval;
}
if ((jib_flags & kJIJournalNeedInitMask) || recreate_journal) {
LFHFS_LOG(LEVEL_ERROR, "hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
jib_offset, jib_size);
hfsmp->jnl = journal_create(hfsmp->jvp,
jib_offset,
jib_size,
devvp,
hfsmp->hfs_logical_block_size,
arg_flags,
arg_tbufsz,
NULL,
hfsmp->hfs_mp,
hfsmp->hfs_mp);
jib_flags &= ~kJIJournalNeedInitMask;
write_jibp = 1;
} else {
arg_flags |= JOURNAL_RESET;
hfsmp->jnl = journal_open(hfsmp->jvp,
jib_offset,
jib_size,
devvp,
hfsmp->hfs_logical_block_size,
arg_flags,
arg_tbufsz,
NULL,
hfsmp->hfs_mp,
hfsmp->hfs_mp);
}
if (write_jibp) {
jibp->flags = SWAP_BE32(jib_flags);
jibp->offset = SWAP_BE64(jib_offset);
jibp->size = SWAP_BE64(jib_size);
uint64_t uActualWrite = 0;
retval = raw_readwrite_write_mount(devvp, u64JournalOffset, hfsmp->hfs_physical_block_size, jinfo_bp, hfsmp->hfs_physical_block_size, &uActualWrite, NULL);
}
if (jinfo_bp) {
hfs_free(jinfo_bp);
}
if (hfsmp->jnl == NULL) {
LFHFS_LOG(LEVEL_ERROR, "hfs: late jnl init: failed to open/create the journal (retval %d).\n", retval);
return EINVAL;
}
return 0;
}