#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kauth.h>
#include <sys/ubc.h>
#include <sys/ubc_internal.h>
#include <sys/vnode_internal.h>
#include <sys/mount_internal.h>
#include <sys/sysctl.h>
#include <sys/malloc.h>
#include <sys/stat.h>
#include <sys/quota.h>
#include <sys/disk.h>
#include <sys/paths.h>
#include <sys/utfconv.h>
#include <sys/kdebug.h>
#include <sys/fslog.h>
#include <sys/ubc.h>
#include <kern/locks.h>
#include <vfs/vfs_journal.h>
#include <miscfs/specfs/specdev.h>
#include <hfs/hfs_mount.h>
#include <libkern/crypto/md5.h>
#include <uuid/uuid.h>
#include "hfs.h"
#include "hfs_catalog.h"
#include "hfs_cnode.h"
#include "hfs_dbg.h"
#include "hfs_endian.h"
#include "hfs_hotfiles.h"
#include "hfs_quota.h"
#include "hfscommon/headers/FileMgrInternal.h"
#include "hfscommon/headers/BTreesInternal.h"
#if CONFIG_PROTECT
#include <sys/cprotect.h>
#endif
#if CONFIG_HFS_ALLOC_RBTREE
#include "hfscommon/headers/HybridAllocator.h"
#endif
#define HFS_MOUNT_DEBUG 1
#if HFS_DIAGNOSTIC
int hfs_dbg_all = 0;
int hfs_dbg_err = 0;
#endif
int hfs_resize_debug = 0;
lck_grp_attr_t * hfs_group_attr;
lck_attr_t * hfs_lock_attr;
lck_grp_t * hfs_mutex_group;
lck_grp_t * hfs_rwlock_group;
lck_grp_t * hfs_spinlock_group;
extern struct vnodeopv_desc hfs_vnodeop_opv_desc;
extern struct vnodeopv_desc hfs_std_vnodeop_opv_desc;
int hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);
static int hfs_changefs(struct mount *mp, struct hfs_mount_args *args);
static int hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp, vfs_context_t context);
static int hfs_flushfiles(struct mount *, int, struct proc *);
static int hfs_flushMDB(struct hfsmount *hfsmp, int waitfor, int altflush);
static int hfs_getmountpoint(struct vnode *vp, struct hfsmount **hfsmpp);
static int hfs_init(struct vfsconf *vfsp);
static int hfs_vfs_root(struct mount *mp, struct vnode **vpp, vfs_context_t context);
static int hfs_quotactl(struct mount *, int, uid_t, caddr_t, vfs_context_t context);
static int hfs_start(struct mount *mp, int flags, vfs_context_t context);
static int hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t context);
static int hfs_file_extent_overlaps(struct hfsmount *hfsmp, u_int32_t allocLimit, struct HFSPlusCatalogFile *filerec);
static int hfs_journal_replay(vnode_t devvp, vfs_context_t context);
static int hfs_reclaimspace(struct hfsmount *hfsmp, u_int32_t allocLimit, u_int32_t reclaimblks, vfs_context_t context);
void hfs_initialize_allocator (struct hfsmount *hfsmp);
int hfs_teardown_allocator (struct hfsmount *hfsmp);
int hfs_mount(struct mount *mp, vnode_t devvp, user_addr_t data, vfs_context_t context);
int hfs_mountfs(struct vnode *devvp, struct mount *mp, struct hfs_mount_args *args, int journal_replay_only, vfs_context_t context);
int hfs_reload(struct mount *mp);
int hfs_statfs(struct mount *mp, register struct vfsstatfs *sbp, vfs_context_t context);
int hfs_sync(struct mount *mp, int waitfor, vfs_context_t context);
int hfs_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp,
user_addr_t newp, size_t newlen, vfs_context_t context);
int hfs_unmount(struct mount *mp, int mntflags, vfs_context_t context);
int
hfs_mountroot(mount_t mp, vnode_t rvp, vfs_context_t context)
{
struct hfsmount *hfsmp;
ExtendedVCB *vcb;
struct vfsstatfs *vfsp;
int error;
if ((error = hfs_mountfs(rvp, mp, NULL, 0, context))) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountroot: hfs_mountfs returned %d, rvp (%p) name (%s) \n",
error, rvp, (rvp->v_name ? rvp->v_name : "unknown device"));
}
return (error);
}
hfsmp = VFSTOHFS(mp);
hfsmp->hfs_uid = UNKNOWNUID;
hfsmp->hfs_gid = UNKNOWNGID;
hfsmp->hfs_dir_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH);
hfsmp->hfs_file_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH);
vcb = HFSTOVCB(hfsmp);
vcb->reserveBlocks = ((u_int64_t)vcb->totalBlocks * HFS_MINFREE) / 100;
vcb->reserveBlocks = MIN(vcb->reserveBlocks, HFS_MAXRESERVE / vcb->blockSize);
vfsp = vfs_statfs(mp);
(void)hfs_statfs(mp, vfsp, NULL);
return (0);
}
int
hfs_mount(struct mount *mp, vnode_t devvp, user_addr_t data, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
struct hfsmount *hfsmp = NULL;
struct hfs_mount_args args;
int retval = E_NONE;
u_int32_t cmdflags;
if ((retval = copyin(data, (caddr_t)&args, sizeof(args)))) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: copyin returned %d for fs\n", retval);
}
return (retval);
}
cmdflags = (u_int32_t)vfs_flags(mp) & MNT_CMDFLAGS;
if (cmdflags & MNT_UPDATE) {
hfsmp = VFSTOHFS(mp);
if (cmdflags & MNT_RELOAD) {
if (vfs_isrdonly(mp)) {
int error = hfs_reload(mp);
if (error && HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_reload returned %d on %s \n", error, hfsmp->vcbVN);
}
return error;
}
else {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: MNT_RELOAD not supported on rdwr filesystem %s\n", hfsmp->vcbVN);
}
return (EINVAL);
}
}
if (((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) &&
vfs_isrdonly(mp)) {
int flags;
hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);
hfsmp->hfs_flags |= HFS_RDONLY_DOWNGRADE;
hfsmp->hfs_downgrading_proc = current_thread();
hfs_unlock_global (hfsmp);
retval = VFS_SYNC(mp, MNT_WAIT, context);
if (retval && ((cmdflags & MNT_FORCE) == 0)) {
hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
hfsmp->hfs_downgrading_proc = NULL;
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: VFS_SYNC returned %d during b-tree sync of %s \n", retval, hfsmp->vcbVN);
}
goto out;
}
flags = WRITECLOSE;
if (cmdflags & MNT_FORCE)
flags |= FORCECLOSE;
if ((retval = hfs_flushfiles(mp, flags, p))) {
hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
hfsmp->hfs_downgrading_proc = NULL;
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_flushfiles returned %d on %s \n", retval, hfsmp->vcbVN);
}
goto out;
}
hfsmp->vcbAtrb |= kHFSVolumeUnmountedMask;
retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
hfsmp->hfs_flags |= HFS_READ_ONLY;
if (!retval) {
if (vnode_mount(hfsmp->hfs_devvp) == mp) {
retval = hfs_fsync(hfsmp->hfs_devvp, MNT_WAIT, 0, p);
} else {
vnode_get(hfsmp->hfs_devvp);
retval = VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);
vnode_put(hfsmp->hfs_devvp);
}
}
if (retval) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: FSYNC on devvp returned %d for fs %s\n", retval, hfsmp->vcbVN);
}
hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
hfsmp->hfs_downgrading_proc = NULL;
hfsmp->hfs_flags &= ~HFS_READ_ONLY;
goto out;
}
if (hfsmp->jnl) {
hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);
journal_close(hfsmp->jnl);
hfsmp->jnl = NULL;
hfs_unlock_global (hfsmp);
}
#if CONFIG_HFS_ALLOC_RBTREE
(void) hfs_teardown_allocator(hfsmp);
#endif
hfsmp->hfs_downgrading_proc = NULL;
}
if (vfs_iswriteupgrade(mp)) {
#if CONFIG_HFS_ALLOC_RBTREE
thread_t allocator_thread;
#endif
if (!(vfs_flags(mp) & MNT_ROOTFS) &&
(hfsmp->vcbAtrb & kHFSVolumeInconsistentMask)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: attempting to mount inconsistent non-root volume %s\n", (hfsmp->vcbVN));
}
retval = EINVAL;
goto out;
}
if ( (HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask)
&& hfsmp->jnl == NULL
&& hfsmp->jvp != NULL) {
int jflags;
if (hfsmp->hfs_flags & HFS_NEED_JNL_RESET) {
jflags = JOURNAL_RESET;
} else {
jflags = 0;
}
hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);
hfsmp->jnl = journal_open(hfsmp->jvp,
(hfsmp->jnl_start * HFSTOVCB(hfsmp)->blockSize) + (off_t)HFSTOVCB(hfsmp)->hfsPlusIOPosOffset,
hfsmp->jnl_size,
hfsmp->hfs_devvp,
hfsmp->hfs_logical_block_size,
jflags,
0,
hfs_sync_metadata, hfsmp->hfs_mp);
if (hfsmp->jnl)
journal_trim_set_callback(hfsmp->jnl, hfs_trim_callback, hfsmp);
hfs_unlock_global (hfsmp);
if (hfsmp->jnl == NULL) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: journal_open == NULL; couldn't be opened on %s \n", (hfsmp->vcbVN));
}
retval = EINVAL;
goto out;
} else {
hfsmp->hfs_flags &= ~HFS_NEED_JNL_RESET;
}
}
retval = hfs_erase_unused_nodes(hfsmp);
if (retval != E_NONE) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_erase_unused_nodes returned %d for fs %s\n", retval, hfsmp->vcbVN);
}
goto out;
}
hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
hfsmp->hfs_downgrading_proc = NULL;
hfsmp->vcbAtrb &= ~kHFSVolumeUnmountedMask;
retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
if (retval != E_NONE) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_flushvolumeheader returned %d for fs %s\n", retval, hfsmp->vcbVN);
}
goto out;
}
hfsmp->hfs_flags &= ~HFS_READ_ONLY;
if (!(hfsmp->hfs_flags & (HFS_READ_ONLY | HFS_STANDARD))) {
hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
hfs_privatedir_init(hfsmp, DIR_HARDLINKS);
hfs_remove_orphans(hfsmp);
if ((hfsmp->hfs_flags & HFS_METADATA_ZONE) &&
((hfsmp->hfs_flags & HFS_SSD) == 0)) {
(void) hfs_recording_init(hfsmp);
}
if (vfs_extendedsecurity(HFSTOVFS(hfsmp)) == 0) {
vfs_setextendedsecurity(HFSTOVFS(hfsmp));
}
}
#if CONFIG_HFS_ALLOC_RBTREE
if (hfsmp->extent_tree_flags == 0) {
hfsmp->extent_tree_flags |= (HFS_ALLOC_TREEBUILD_INFLIGHT | HFS_ALLOC_RB_ENABLED);
hfsmp->offset_block_end = 0;
InitTree(hfsmp);
kernel_thread_start ((thread_continue_t) hfs_initialize_allocator , hfsmp, &allocator_thread);
thread_deallocate(allocator_thread);
}
#endif
}
retval = hfs_changefs(mp, &args);
if (retval && HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_changefs returned %d for %s\n", retval, hfsmp->vcbVN);
}
} else {
vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_DOVOLFS));
retval = hfs_mountfs(devvp, mp, &args, 0, context);
if (retval && HFS_MOUNT_DEBUG) {
printf("hfs_mount: hfs_mountfs returned %d\n", retval);
}
#if CONFIG_PROTECT
if ((retval == 0) && (cp_fs_protected (mp))) {
int err = 0;
struct cp_root_xattr xattr;
bzero (&xattr, sizeof(struct cp_root_xattr));
hfsmp = vfs_fsprivate(mp);
err = cp_getrootxattr (hfsmp, &xattr);
if (err == ENOATTR) {
bzero(&xattr, sizeof(struct cp_root_xattr));
xattr.major_version = CP_CURRENT_MAJOR_VERS;
xattr.minor_version = CP_CURRENT_MINOR_VERS;
xattr.flags = 0;
err = cp_setrootxattr (hfsmp, &xattr);
}
if (err || xattr.major_version != CP_CURRENT_MAJOR_VERS) {
retval = EPERM;
(void) hfs_unmount (mp, MNT_FORCE, context);
}
}
#endif
}
out:
if (retval == 0) {
(void)hfs_statfs(mp, vfs_statfs(mp), context);
}
return (retval);
}
struct hfs_changefs_cargs {
struct hfsmount *hfsmp;
int namefix;
int permfix;
int permswitch;
};
static int
hfs_changefs_callback(struct vnode *vp, void *cargs)
{
ExtendedVCB *vcb;
struct cnode *cp;
struct cat_desc cndesc;
struct cat_attr cnattr;
struct hfs_changefs_cargs *args;
int lockflags;
int error;
args = (struct hfs_changefs_cargs *)cargs;
cp = VTOC(vp);
vcb = HFSTOVCB(args->hfsmp);
lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = cat_lookup(args->hfsmp, &cp->c_desc, 0, &cndesc, &cnattr, NULL, NULL);
hfs_systemfile_unlock(args->hfsmp, lockflags);
if (error) {
if (args->namefix)
cache_purge(vp);
return (VNODE_RETURNED);
}
if (args->permswitch || args->permfix) {
cp->c_uid = cnattr.ca_uid;
cp->c_gid = cnattr.ca_gid;
cp->c_mode = cnattr.ca_mode;
}
if (args->namefix) {
cache_purge(vp);
replace_desc(cp, &cndesc);
if (cndesc.cd_cnid == kHFSRootFolderID) {
strlcpy((char *)vcb->vcbVN, (const char *)cp->c_desc.cd_nameptr, NAME_MAX+1);
cp->c_desc.cd_encoding = args->hfsmp->hfs_encoding;
}
} else {
cat_releasedesc(&cndesc);
}
return (VNODE_RETURNED);
}
static int
hfs_changefs(struct mount *mp, struct hfs_mount_args *args)
{
int retval = 0;
int namefix, permfix, permswitch;
struct hfsmount *hfsmp;
ExtendedVCB *vcb;
hfs_to_unicode_func_t get_unicode_func;
unicode_to_hfs_func_t get_hfsname_func;
u_int32_t old_encoding = 0;
struct hfs_changefs_cargs cargs;
u_int32_t mount_flags;
hfsmp = VFSTOHFS(mp);
vcb = HFSTOVCB(hfsmp);
mount_flags = (unsigned int)vfs_flags(mp);
hfsmp->hfs_flags |= HFS_IN_CHANGEFS;
permswitch = (((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) &&
((mount_flags & MNT_UNKNOWNPERMISSIONS) == 0)) ||
(((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) == 0) &&
(mount_flags & MNT_UNKNOWNPERMISSIONS)));
if (permswitch && (mount_flags & MNT_ROOTFS) && (mount_flags & MNT_UNKNOWNPERMISSIONS)) {
vfs_clearflags(mp, (u_int64_t)((unsigned int)MNT_UNKNOWNPERMISSIONS));
retval = EINVAL;
goto exit;
}
if (mount_flags & MNT_UNKNOWNPERMISSIONS)
hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;
else
hfsmp->hfs_flags &= ~HFS_UNKNOWN_PERMS;
namefix = permfix = 0;
if (mount_flags & MNT_NOATIME) {
(void) hfs_recording_suspend(hfsmp);
}
if (args->hfs_timezone.tz_minuteswest != VNOVAL) {
gTimeZone = args->hfs_timezone;
}
if ((args->hfs_uid != (uid_t)VNOVAL) && (hfsmp->hfs_uid != args->hfs_uid)) {
hfsmp->hfs_uid = args->hfs_uid;
if (vcb->vcbSigWord == kHFSPlusSigWord)
++permfix;
}
if ((args->hfs_gid != (gid_t)VNOVAL) && (hfsmp->hfs_gid != args->hfs_gid)) {
hfsmp->hfs_gid = args->hfs_gid;
if (vcb->vcbSigWord == kHFSPlusSigWord)
++permfix;
}
if (args->hfs_mask != (mode_t)VNOVAL) {
if (hfsmp->hfs_dir_mask != (args->hfs_mask & ALLPERMS)) {
hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;
hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;
if ((args->flags != VNOVAL) && (args->flags & HFSFSMNT_NOXONFILES))
hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);
if (vcb->vcbSigWord == kHFSPlusSigWord)
++permfix;
}
}
if ((vcb->vcbSigWord == kHFSSigWord) &&
(args->hfs_encoding != (u_int32_t)VNOVAL) &&
(hfsmp->hfs_encoding != args->hfs_encoding)) {
retval = hfs_getconverter(args->hfs_encoding, &get_unicode_func, &get_hfsname_func);
if (retval)
goto exit;
hfsmp->hfs_get_unicode = get_unicode_func;
old_encoding = hfsmp->hfs_encoding;
hfsmp->hfs_encoding = args->hfs_encoding;
++namefix;
}
if (!(namefix || permfix || permswitch))
goto exit;
if (permfix)
vfs_setowner(mp,
hfsmp->hfs_uid == UNKNOWNUID ? KAUTH_UID_NONE : hfsmp->hfs_uid,
hfsmp->hfs_gid == UNKNOWNGID ? KAUTH_GID_NONE : hfsmp->hfs_gid);
cargs.hfsmp = hfsmp;
cargs.namefix = namefix;
cargs.permfix = permfix;
cargs.permswitch = permswitch;
vnode_iterate(mp, 0, hfs_changefs_callback, (void *)&cargs);
if (namefix) {
hfsmp->hfs_get_hfsname = get_hfsname_func;
vcb->volumeNameEncodingHint = args->hfs_encoding;
(void) hfs_relconverter(old_encoding);
}
exit:
hfsmp->hfs_flags &= ~HFS_IN_CHANGEFS;
return (retval);
}
struct hfs_reload_cargs {
struct hfsmount *hfsmp;
int error;
};
static int
hfs_reload_callback(struct vnode *vp, void *cargs)
{
struct cnode *cp;
struct hfs_reload_cargs *args;
int lockflags;
args = (struct hfs_reload_cargs *)cargs;
(void) buf_invalidateblks(vp, 0, 0, 0);
cp = VTOC(vp);
if (vnode_isdir(vp))
hfs_reldirhints(cp, 0);
if (!vnode_issystem(vp) && !VNODE_IS_RSRC(vp) && (cp->c_fileid >= kHFSFirstUserCatalogNodeID)) {
struct cat_fork *datafork;
struct cat_desc desc;
datafork = cp->c_datafork ? &cp->c_datafork->ff_data : NULL;
lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
args->error = cat_idlookup(args->hfsmp, cp->c_fileid, 0, &desc, &cp->c_attr, datafork);
hfs_systemfile_unlock(args->hfsmp, lockflags);
if (args->error) {
return (VNODE_RETURNED_DONE);
}
(void) replace_desc(cp, &desc);
}
return (VNODE_RETURNED);
}
int
hfs_reload(struct mount *mountp)
{
register struct vnode *devvp;
struct buf *bp;
int error, i;
struct hfsmount *hfsmp;
struct HFSPlusVolumeHeader *vhp;
ExtendedVCB *vcb;
struct filefork *forkp;
struct cat_desc cndesc;
struct hfs_reload_cargs args;
daddr64_t priIDSector;
hfsmp = VFSTOHFS(mountp);
vcb = HFSTOVCB(hfsmp);
if (vcb->vcbSigWord == kHFSSigWord)
return (EINVAL);
devvp = hfsmp->hfs_devvp;
if (buf_invalidateblks(devvp, 0, 0, 0))
panic("hfs_reload: dirty1");
args.hfsmp = hfsmp;
args.error = 0;
vnode_iterate(mountp, VNODE_RELOAD | VNODE_WAIT, hfs_reload_callback, (void *)&args);
if (args.error)
return (args.error);
priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
error = (int)buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp);
if (error) {
if (bp != NULL)
buf_brelse(bp);
return (error);
}
vhp = (HFSPlusVolumeHeader *) (buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
if ((SWAP_BE16(vhp->signature) != kHFSPlusSigWord &&
SWAP_BE16(vhp->signature) != kHFSXSigWord) ||
(SWAP_BE16(vhp->version) != kHFSPlusVersion &&
SWAP_BE16(vhp->version) != kHFSXVersion) ||
SWAP_BE32(vhp->blockSize) != vcb->blockSize) {
buf_brelse(bp);
return (EIO);
}
vcb->vcbLsMod = to_bsd_time(SWAP_BE32(vhp->modifyDate));
vcb->vcbAtrb = SWAP_BE32 (vhp->attributes);
vcb->vcbJinfoBlock = SWAP_BE32(vhp->journalInfoBlock);
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);
HFS_UPDATE_NEXT_ALLOCATION(vcb, SWAP_BE32 (vhp->nextAllocation));
vcb->totalBlocks = SWAP_BE32 (vhp->totalBlocks);
vcb->freeBlocks = SWAP_BE32 (vhp->freeBlocks);
vcb->encodingsBitmap = SWAP_BE64 (vhp->encodingsBitmap);
bcopy(vhp->finderInfo, vcb->vcbFndrInfo, sizeof(vhp->finderInfo));
vcb->localCreateDate = SWAP_BE32 (vhp->createDate);
forkp = VTOF((struct vnode *)vcb->extentsRefNum);
for (i = 0; i < kHFSPlusExtentDensity; i++) {
forkp->ff_extents[i].startBlock =
SWAP_BE32 (vhp->extentsFile.extents[i].startBlock);
forkp->ff_extents[i].blockCount =
SWAP_BE32 (vhp->extentsFile.extents[i].blockCount);
}
forkp->ff_size = SWAP_BE64 (vhp->extentsFile.logicalSize);
forkp->ff_blocks = SWAP_BE32 (vhp->extentsFile.totalBlocks);
forkp->ff_clumpsize = SWAP_BE32 (vhp->extentsFile.clumpSize);
forkp = VTOF((struct vnode *)vcb->catalogRefNum);
for (i = 0; i < kHFSPlusExtentDensity; i++) {
forkp->ff_extents[i].startBlock =
SWAP_BE32 (vhp->catalogFile.extents[i].startBlock);
forkp->ff_extents[i].blockCount =
SWAP_BE32 (vhp->catalogFile.extents[i].blockCount);
}
forkp->ff_size = SWAP_BE64 (vhp->catalogFile.logicalSize);
forkp->ff_blocks = SWAP_BE32 (vhp->catalogFile.totalBlocks);
forkp->ff_clumpsize = SWAP_BE32 (vhp->catalogFile.clumpSize);
if (hfsmp->hfs_attribute_vp) {
forkp = VTOF(hfsmp->hfs_attribute_vp);
for (i = 0; i < kHFSPlusExtentDensity; i++) {
forkp->ff_extents[i].startBlock =
SWAP_BE32 (vhp->attributesFile.extents[i].startBlock);
forkp->ff_extents[i].blockCount =
SWAP_BE32 (vhp->attributesFile.extents[i].blockCount);
}
forkp->ff_size = SWAP_BE64 (vhp->attributesFile.logicalSize);
forkp->ff_blocks = SWAP_BE32 (vhp->attributesFile.totalBlocks);
forkp->ff_clumpsize = SWAP_BE32 (vhp->attributesFile.clumpSize);
}
forkp = VTOF((struct vnode *)vcb->allocationsRefNum);
for (i = 0; i < kHFSPlusExtentDensity; i++) {
forkp->ff_extents[i].startBlock =
SWAP_BE32 (vhp->allocationFile.extents[i].startBlock);
forkp->ff_extents[i].blockCount =
SWAP_BE32 (vhp->allocationFile.extents[i].blockCount);
}
forkp->ff_size = SWAP_BE64 (vhp->allocationFile.logicalSize);
forkp->ff_blocks = SWAP_BE32 (vhp->allocationFile.totalBlocks);
forkp->ff_clumpsize = SWAP_BE32 (vhp->allocationFile.clumpSize);
buf_brelse(bp);
vhp = NULL;
forkp = VTOF((struct vnode *)vcb->extentsRefNum);
if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )
return (error);
forkp = VTOF((struct vnode *)vcb->catalogRefNum);
if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )
return (error);
if (hfsmp->hfs_attribute_vp) {
forkp = VTOF(hfsmp->hfs_attribute_vp);
if ( (error = MacToVFSError( BTReloadData((FCB*)forkp) )) )
return (error);
}
if ((error = cat_idlookup(hfsmp, kHFSRootFolderID, 0, &cndesc, NULL, NULL)))
return (error);
vcb->volumeNameEncodingHint = cndesc.cd_encoding;
bcopy(cndesc.cd_nameptr, vcb->vcbVN, min(255, cndesc.cd_namelen));
cat_releasedesc(&cndesc);
hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
hfs_privatedir_init(hfsmp, DIR_HARDLINKS);
hfs_generate_volume_notifications(hfsmp);
return (0);
}
static void
hfs_syncer(void *arg0, void *unused)
{
#pragma unused(unused)
struct hfsmount *hfsmp = arg0;
clock_sec_t secs;
clock_usec_t usecs;
uint32_t delay = HFS_META_DELAY;
uint64_t now;
static int no_max=1;
clock_get_calendar_microtime(&secs, &usecs);
now = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
if (hfsmp->hfs_mp->mnt_pending_write_size > hfsmp->hfs_max_pending_io) {
int counter=0;
uint64_t pending_io, start, rate = 0;
no_max = 0;
hfs_start_transaction(hfsmp);
pending_io = hfsmp->hfs_mp->mnt_pending_write_size;
clock_get_calendar_microtime(&secs, &usecs);
start = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
while(hfsmp->hfs_mp->mnt_pending_write_size > (pending_io/3) && counter++ < 500) {
tsleep((caddr_t)hfsmp, PRIBIO, "hfs-wait-for-io-to-drain", 10);
}
if (counter >= 500) {
printf("hfs: timed out waiting for io to drain (%lld)\n", (int64_t)hfsmp->hfs_mp->mnt_pending_write_size);
}
if (hfsmp->jnl) {
journal_flush(hfsmp->jnl, FALSE);
} else {
hfs_sync(hfsmp->hfs_mp, MNT_WAIT, vfs_context_kernel());
}
clock_get_calendar_microtime(&secs, &usecs);
now = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
hfsmp->hfs_last_sync_time = now;
if (now != start) {
rate = ((pending_io * 1000000ULL) / (now - start)); }
hfs_end_transaction(hfsmp);
if (((now - start) >= 300000) && (rate != 0)) {
uint64_t scale = (pending_io * 100) / rate;
if (scale < 100 || scale > 200) {
hfsmp->hfs_max_pending_io = (rate * 150ULL) / 100ULL;
}
}
} else if ( ((now - hfsmp->hfs_last_sync_time) >= 5000000ULL)
|| (((now - hfsmp->hfs_last_sync_time) >= 100000LL)
&& ((now - hfsmp->hfs_last_sync_request_time) >= 100000LL)
&& (hfsmp->hfs_active_threads == 0)
&& (hfsmp->hfs_global_lock_nesting == 0))) {
if (hfsmp->jnl) {
hfs_lock_global (hfsmp, HFS_SHARED_LOCK);
journal_flush(hfsmp->jnl, FALSE);
hfs_unlock_global (hfsmp);
} else {
hfs_sync(hfsmp->hfs_mp, MNT_WAIT, vfs_context_kernel());
}
clock_get_calendar_microtime(&secs, &usecs);
now = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
hfsmp->hfs_last_sync_time = now;
} else if (hfsmp->hfs_active_threads == 0) {
uint64_t deadline;
clock_interval_to_deadline(delay, HFS_MILLISEC_SCALE, &deadline);
thread_call_enter_delayed(hfsmp->hfs_syncer, deadline);
return;
}
OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_scheduled);
OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_incomplete);
wakeup((caddr_t)&hfsmp->hfs_sync_incomplete);
}
extern int IOBSDIsMediaEjectable( const char *cdev_name );
void
hfs_initialize_allocator (struct hfsmount *hfsmp) {
#if CONFIG_HFS_ALLOC_RBTREE
u_int32_t err;
int flags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
err = GenerateTree(hfsmp, hfsmp->totalBlocks, &flags, 1);
if (err) {
goto bailout;
}
hfsmp->extent_tree_flags |= HFS_ALLOC_RB_ACTIVE;
bailout:
hfsmp->extent_tree_flags &= ~HFS_ALLOC_TREEBUILD_INFLIGHT;
if (err != 0) {
wakeup((caddr_t)&hfsmp->extent_tree_flags);
}
hfs_systemfile_unlock(hfsmp, flags);
#else
#pragma unused (hfsmp)
#endif
}
int
hfs_teardown_allocator (struct hfsmount *hfsmp) {
int rb_used = 0;
#if CONFIG_HFS_ALLOC_RBTREE
int flags = 0;
flags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
while (hfsmp->extent_tree_flags & HFS_ALLOC_TREEBUILD_INFLIGHT) {
hfsmp->extent_tree_flags |= HFS_ALLOC_TEARDOWN_INFLIGHT;
lck_rw_sleep(&(VTOC(hfsmp->hfs_allocation_vp))->c_rwlock, LCK_SLEEP_EXCLUSIVE,
&hfsmp->extent_tree_flags, THREAD_UNINT);
}
if (hfs_isrbtree_active (hfsmp)) {
rb_used = 1;
DestroyTrees(hfsmp);
}
hfs_systemfile_unlock(hfsmp, flags);
#else
#pragma unused (hfsmp)
#endif
return rb_used;
}
static int hfs_root_unmounted_cleanly = 0;
SYSCTL_DECL(_vfs_generic);
SYSCTL_INT(_vfs_generic, OID_AUTO, root_unmounted_cleanly, CTLFLAG_RD, &hfs_root_unmounted_cleanly, 0, "Root filesystem was unmounted cleanly");
int
hfs_mountfs(struct vnode *devvp, struct mount *mp, struct hfs_mount_args *args,
int journal_replay_only, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
int retval = E_NONE;
struct hfsmount *hfsmp = NULL;
struct buf *bp;
dev_t dev;
HFSMasterDirectoryBlock *mdbp = NULL;
int ronly;
#if QUOTA
int i;
#endif
int mntwrapper;
kauth_cred_t cred;
u_int64_t disksize;
daddr64_t log_blkcnt;
u_int32_t log_blksize;
u_int32_t phys_blksize;
u_int32_t minblksize;
u_int32_t iswritable;
daddr64_t mdb_offset;
int isvirtual = 0;
int isroot = 0;
int isssd;
#if CONFIG_HFS_ALLOC_RBTREE
thread_t allocator_thread;
#endif
if (args == NULL) {
isroot = 1;
}
ronly = vfs_isrdonly(mp);
dev = vnode_specrdev(devvp);
cred = p ? vfs_context_ucred(context) : NOCRED;
mntwrapper = 0;
bp = NULL;
hfsmp = NULL;
mdbp = NULL;
minblksize = kHFSBlockSize;
vfs_setlocklocal(mp);
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKSIZE, (caddr_t)&log_blksize, 0, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETBLOCKSIZE failed\n");
}
retval = ENXIO;
goto error_exit;
}
if (log_blksize == 0 || log_blksize > 1024*1024*1024) {
printf("hfs: logical block size 0x%x looks bad. Not mounting.\n", log_blksize);
retval = ENXIO;
goto error_exit;
}
retval = VNOP_IOCTL(devvp, DKIOCGETPHYSICALBLOCKSIZE, (caddr_t)&phys_blksize, 0, context);
if (retval) {
if ((retval != ENOTSUP) && (retval != ENOTTY)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETPHYSICALBLOCKSIZE failed\n");
}
retval = ENXIO;
goto error_exit;
}
phys_blksize = log_blksize;
}
if (phys_blksize == 0 || phys_blksize > 1024*1024*1024) {
printf("hfs: physical block size 0x%x looks bad. Not mounting.\n", phys_blksize);
retval = ENXIO;
goto error_exit;
}
if (log_blksize > 512) {
u_int32_t size512 = 512;
if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&size512, FWRITE, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCSETBLOCKSIZE failed \n");
}
retval = ENXIO;
goto error_exit;
}
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {
(void)VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context);
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETBLOCKCOUNT failed\n");
}
retval = ENXIO;
goto error_exit;
}
disksize = (u_int64_t)log_blkcnt * (u_int64_t)512;
if (log_blkcnt > 0x000000007fffffff && (log_blkcnt & 7) == 0) {
minblksize = log_blksize = 4096;
if (phys_blksize < log_blksize)
phys_blksize = log_blksize;
}
if (log_blksize > PAGE_SIZE)
log_blksize = PAGE_SIZE;
if (log_blksize > 512) {
if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCSETBLOCKSIZE (2) failed\n");
}
retval = ENXIO;
goto error_exit;
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (2) failed\n");
}
retval = ENXIO;
goto error_exit;
}
}
mdb_offset = (daddr64_t)HFS_PRI_SECTOR(log_blksize);
if ((retval = (int)buf_meta_bread(devvp,
HFS_PHYSBLK_ROUNDDOWN(mdb_offset, (phys_blksize/log_blksize)),
phys_blksize, cred, &bp))) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: buf_meta_bread failed with %d\n", retval);
}
goto error_exit;
}
MALLOC(mdbp, HFSMasterDirectoryBlock *, kMDBSize, M_TEMP, M_WAITOK);
if (mdbp == NULL) {
retval = ENOMEM;
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: MALLOC failed\n");
}
goto error_exit;
}
bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize), mdbp, kMDBSize);
buf_brelse(bp);
bp = NULL;
MALLOC(hfsmp, struct hfsmount *, sizeof(struct hfsmount), M_HFSMNT, M_WAITOK);
if (hfsmp == NULL) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: MALLOC (2) failed\n");
}
retval = ENOMEM;
goto error_exit;
}
bzero(hfsmp, sizeof(struct hfsmount));
hfs_chashinit_finish(hfsmp);
if (VNOP_IOCTL(devvp, DKIOCISSOLIDSTATE, (caddr_t)&isssd, 0, context) == 0) {
if (isssd) {
hfsmp->hfs_flags |= HFS_SSD;
}
}
lck_mtx_init(&hfsmp->hfs_mutex, hfs_mutex_group, hfs_lock_attr);
lck_mtx_init(&hfsmp->hfc_mutex, hfs_mutex_group, hfs_lock_attr);
lck_rw_init(&hfsmp->hfs_global_lock, hfs_rwlock_group, hfs_lock_attr);
lck_rw_init(&hfsmp->hfs_insync, hfs_rwlock_group, hfs_lock_attr);
lck_spin_init(&hfsmp->vcbFreeExtLock, hfs_spinlock_group, hfs_lock_attr);
vfs_setfsprivate(mp, hfsmp);
hfsmp->hfs_mp = mp;
hfsmp->hfs_raw_dev = vnode_specrdev(devvp);
hfsmp->hfs_devvp = devvp;
vnode_ref(devvp);
hfsmp->hfs_logical_block_size = log_blksize;
hfsmp->hfs_logical_block_count = log_blkcnt;
hfsmp->hfs_physical_block_size = phys_blksize;
hfsmp->hfs_log_per_phys = (phys_blksize / log_blksize);
hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;
if (ronly)
hfsmp->hfs_flags |= HFS_READ_ONLY;
if (((unsigned int)vfs_flags(mp)) & MNT_UNKNOWNPERMISSIONS)
hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;
#if QUOTA
for (i = 0; i < MAXQUOTAS; i++)
dqfileinit(&hfsmp->hfs_qfiles[i]);
#endif
if (args) {
hfsmp->hfs_uid = (args->hfs_uid == (uid_t)VNOVAL) ? UNKNOWNUID : args->hfs_uid;
if (hfsmp->hfs_uid == 0xfffffffd) hfsmp->hfs_uid = UNKNOWNUID;
hfsmp->hfs_gid = (args->hfs_gid == (gid_t)VNOVAL) ? UNKNOWNGID : args->hfs_gid;
if (hfsmp->hfs_gid == 0xfffffffd) hfsmp->hfs_gid = UNKNOWNGID;
vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid);
if (args->hfs_mask != (mode_t)VNOVAL) {
hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;
if (args->flags & HFSFSMNT_NOXONFILES) {
hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);
} else {
hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;
}
} else {
hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS;
hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE;
}
if ((args->flags != (int)VNOVAL) && (args->flags & HFSFSMNT_WRAPPER))
mntwrapper = 1;
} else {
if (((unsigned int)vfs_flags(mp)) & MNT_UNKNOWNPERMISSIONS) {
hfsmp->hfs_uid = UNKNOWNUID;
hfsmp->hfs_gid = UNKNOWNGID;
vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid);
hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS;
hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE;
}
}
if (VNOP_IOCTL(devvp, DKIOCISWRITABLE, (caddr_t)&iswritable, 0, context) == 0) {
if (iswritable)
hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;
else
hfsmp->hfs_flags &= ~HFS_WRITEABLE_MEDIA;
}
struct timeval tv;
microtime(&tv);
hfsmp->hfs_mount_time = tv.tv_sec;
if ((SWAP_BE16(mdbp->drSigWord) == kHFSSigWord) &&
(mntwrapper || (SWAP_BE16(mdbp->drEmbedSigWord) != kHFSPlusSigWord))) {
if (vfs_isrdwr(mp)) {
retval = EROFS;
goto error_exit;
}
printf("hfs_mountfs: Mounting HFS Standard volumes was deprecated in Mac OS 10.7 \n");
hfsmp->hfs_flags |= HFS_READ_ONLY;
hfsmp->hfs_flags &= ~HFS_WRITEABLE_MEDIA;
if (journal_replay_only) {
retval = 0;
goto error_exit;
}
if ((vfs_flags(mp) & MNT_ROOTFS)) {
retval = EINVAL;
goto error_exit;
}
if (log_blksize > kHFSBlockSize) {
log_blksize = kHFSBlockSize;
if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context)) {
retval = ENXIO;
goto error_exit;
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {
retval = ENXIO;
goto error_exit;
}
hfsmp->hfs_logical_block_size = log_blksize;
hfsmp->hfs_logical_block_count = log_blkcnt;
hfsmp->hfs_physical_block_size = log_blksize;
hfsmp->hfs_log_per_phys = 1;
}
if (args) {
hfsmp->hfs_encoding = args->hfs_encoding;
HFSTOVCB(hfsmp)->volumeNameEncodingHint = args->hfs_encoding;
gTimeZone = args->hfs_timezone;
}
retval = hfs_getconverter(hfsmp->hfs_encoding, &hfsmp->hfs_get_unicode,
&hfsmp->hfs_get_hfsname);
if (retval)
goto error_exit;
retval = hfs_MountHFSVolume(hfsmp, mdbp, p);
if (retval)
(void) hfs_relconverter(hfsmp->hfs_encoding);
} else {
HFSPlusVolumeHeader *vhp;
off_t embeddedOffset;
int jnl_disable = 0;
if (SWAP_BE16(mdbp->drEmbedSigWord) == kHFSPlusSigWord) {
embeddedOffset = SWAP_BE16(mdbp->drAlBlSt) * kHFSBlockSize;
embeddedOffset += (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.startBlock) *
(u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);
if ((embeddedOffset % log_blksize) != 0) {
printf("hfs_mountfs: embedded volume offset not"
" a multiple of physical block size (%d);"
" switching to 512\n", log_blksize);
log_blksize = 512;
if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE,
(caddr_t)&log_blksize, FWRITE, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCSETBLOCKSIZE (3) failed\n");
}
retval = ENXIO;
goto error_exit;
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT,
(caddr_t)&log_blkcnt, 0, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (3) failed\n");
}
retval = ENXIO;
goto error_exit;
}
hfsmp->hfs_logical_block_count *=
hfsmp->hfs_logical_block_size / log_blksize;
hfsmp->hfs_logical_block_size = log_blksize;
hfsmp->hfs_physical_block_size = log_blksize;
phys_blksize = log_blksize;
hfsmp->hfs_log_per_phys = 1;
}
disksize = (u_int64_t)SWAP_BE16(mdbp->drEmbedExtent.blockCount) *
(u_int64_t)SWAP_BE32(mdbp->drAlBlkSiz);
hfsmp->hfs_logical_block_count = disksize / log_blksize;
mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));
retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
phys_blksize, cred, &bp);
if (retval) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: buf_meta_bread (2) failed with %d\n", retval);
}
goto error_exit;
}
bcopy((char *)buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize), mdbp, 512);
buf_brelse(bp);
bp = NULL;
vhp = (HFSPlusVolumeHeader*) mdbp;
} else {
embeddedOffset = 0;
vhp = (HFSPlusVolumeHeader*) mdbp;
}
if (isroot) {
hfs_root_unmounted_cleanly = (SWAP_BE32(vhp->attributes) & kHFSVolumeUnmountedMask) != 0;
}
if ( !(vfs_flags(mp) & MNT_ROOTFS)
&& (SWAP_BE32(vhp->attributes) & kHFSVolumeInconsistentMask)
&& !journal_replay_only
&& !(hfsmp->hfs_flags & HFS_READ_ONLY)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: failed to mount non-root inconsistent disk\n");
}
retval = EINVAL;
goto error_exit;
}
hfsmp->jnl = NULL;
hfsmp->jvp = NULL;
if (args != NULL && (args->flags & HFSFSMNT_EXTENDED_ARGS) &&
args->journal_disable) {
jnl_disable = 1;
}
if ( (SWAP_BE32(vhp->lastMountedVersion) == kHFSJMountVersion)
&& (SWAP_BE32(vhp->attributes) & kHFSVolumeJournaledMask)
&& !jnl_disable) {
if ((retval = hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred)) == 0) {
vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
} else {
if (retval == EROFS) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: hfs_early_journal_init indicated external jnl \n");
}
retval = EINVAL;
goto error_exit;
}
if (!ronly) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: hfs_early_journal_init failed, setting to FSK \n");
}
HFSPlusVolumeHeader *jvhp;
hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;
if (mdb_offset == 0) {
mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));
}
bp = NULL;
retval = (int)buf_meta_bread(devvp,
HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
phys_blksize, cred, &bp);
if (retval == 0) {
jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize));
if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {
printf ("hfs(1): Journal replay fail. Writing lastMountVersion as FSK!\n");
jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);
buf_bwrite(bp);
} else {
buf_brelse(bp);
}
bp = NULL;
} else if (bp) {
buf_brelse(bp);
bp = NULL;
}
}
if ( !(vfs_flags(mp) & MNT_ROOTFS)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: hfs_early_journal_init failed, erroring out \n");
}
retval = EINVAL;
goto error_exit;
}
}
}
if (journal_replay_only) {
retval = 0;
goto error_exit;
}
(void) hfs_getconverter(0, &hfsmp->hfs_get_unicode, &hfsmp->hfs_get_hfsname);
retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);
if ((retval == ENXIO) && (log_blksize > 512) && (log_blksize != minblksize)) {
printf("hfs_mountfs: could not use physical block size "
"(%d) switching to 512\n", log_blksize);
log_blksize = 512;
if (VNOP_IOCTL(devvp, DKIOCSETBLOCKSIZE, (caddr_t)&log_blksize, FWRITE, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCSETBLOCKSIZE (4) failed \n");
}
retval = ENXIO;
goto error_exit;
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)&log_blkcnt, 0, context)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: DKIOCGETBLOCKCOUNT (4) failed \n");
}
retval = ENXIO;
goto error_exit;
}
devvp->v_specsize = log_blksize;
hfsmp->hfs_logical_block_count *= hfsmp->hfs_logical_block_size / log_blksize;
hfsmp->hfs_logical_block_size = log_blksize;
hfsmp->hfs_log_per_phys = hfsmp->hfs_physical_block_size / log_blksize;
if (hfsmp->jnl && hfsmp->jvp == devvp) {
journal_close(hfsmp->jnl);
hfsmp->jnl = NULL;
if (hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred) == 0) {
vfs_setflags(mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
} else {
if (!ronly) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: hfs_early_journal_init (2) resetting.. \n");
}
HFSPlusVolumeHeader *jvhp;
hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;
if (mdb_offset == 0) {
mdb_offset = (daddr64_t)((embeddedOffset / log_blksize) + HFS_PRI_SECTOR(log_blksize));
}
bp = NULL;
retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
phys_blksize, cred, &bp);
if (retval == 0) {
jvhp = (HFSPlusVolumeHeader *)(buf_dataptr(bp) + HFS_PRI_OFFSET(phys_blksize));
if (SWAP_BE16(jvhp->signature) == kHFSPlusSigWord || SWAP_BE16(jvhp->signature) == kHFSXSigWord) {
printf ("hfs(2): Journal replay fail. Writing lastMountVersion as FSK!\n");
jvhp->lastMountedVersion = SWAP_BE32(kFSKMountVersion);
buf_bwrite(bp);
} else {
buf_brelse(bp);
}
bp = NULL;
} else if (bp) {
buf_brelse(bp);
bp = NULL;
}
}
if ( !(vfs_flags(mp) & MNT_ROOTFS)) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: hfs_early_journal_init (2) failed \n");
}
retval = EINVAL;
goto error_exit;
}
}
}
retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);
if (retval && HFS_MOUNT_DEBUG) {
printf("hfs_MountHFSPlusVolume (late) returned %d\n",retval);
}
}
if (retval)
(void) hfs_relconverter(0);
}
hfsmp->hfs_last_mounted_mtime = hfsmp->hfs_mtime;
if ( retval ) {
if (HFS_MOUNT_DEBUG) {
printf("hfs_mountfs: encountered failure %d \n", retval);
}
goto error_exit;
}
mp->mnt_vfsstat.f_fsid.val[0] = (long)dev;
mp->mnt_vfsstat.f_fsid.val[1] = vfs_typenum(mp);
vfs_setmaxsymlen(mp, 0);
mp->mnt_vtable->vfc_vfsflags |= VFC_VFSNATIVEXATTR;
#if NAMEDSTREAMS
mp->mnt_kern_flag |= MNTK_NAMED_STREAMS;
#endif
if (!(hfsmp->hfs_flags & HFS_STANDARD)) {
mp->mnt_vtable->vfc_vfsflags |= VFC_VFSDIRLINKS;
} else {
mount_set_noreaddirext (mp);
}
if (args) {
hfsmp->hfs_freespace_notify_dangerlimit =
MIN(HFS_VERYLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_VERYLOWDISKTRIGGERFRACTION);
hfsmp->hfs_freespace_notify_warninglimit =
MIN(HFS_LOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKTRIGGERFRACTION);
hfsmp->hfs_freespace_notify_desiredlevel =
MIN(HFS_LOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKSHUTOFFFRACTION);
} else {
hfsmp->hfs_freespace_notify_dangerlimit =
MIN(HFS_ROOTVERYLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTVERYLOWDISKTRIGGERFRACTION);
hfsmp->hfs_freespace_notify_warninglimit =
MIN(HFS_ROOTLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKTRIGGERFRACTION);
hfsmp->hfs_freespace_notify_desiredlevel =
MIN(HFS_ROOTLOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,
(HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKSHUTOFFFRACTION);
};
if (VNOP_IOCTL(devvp, DKIOCISVIRTUAL, (caddr_t)&isvirtual, 0, context) == 0) {
if (isvirtual) {
hfsmp->hfs_flags |= HFS_VIRTUAL_DEVICE;
}
}
if (isroot == 0) {
if ((hfsmp->hfs_flags & HFS_VIRTUAL_DEVICE) == 0 &&
IOBSDIsMediaEjectable(mp->mnt_vfsstat.f_mntfromname)) {
hfsmp->hfs_max_pending_io = 4096*1024; hfsmp->hfs_syncer = thread_call_allocate(hfs_syncer, hfsmp);
if (hfsmp->hfs_syncer == NULL) {
printf("hfs: failed to allocate syncer thread callback for %s (%s)\n",
mp->mnt_vfsstat.f_mntfromname, mp->mnt_vfsstat.f_mntonname);
}
}
}
#if CONFIG_HFS_ALLOC_RBTREE
if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {
hfsmp->extent_tree_flags |= (HFS_ALLOC_TREEBUILD_INFLIGHT | HFS_ALLOC_RB_ENABLED);
hfsmp->offset_block_end = 0;
InitTree(hfsmp);
kernel_thread_start ((thread_continue_t) hfs_initialize_allocator , hfsmp, &allocator_thread);
thread_deallocate(allocator_thread);
}
#endif
hfsmp->hfs_notification_conditions = 0;
hfs_generate_volume_notifications(hfsmp);
if (ronly == 0) {
(void) hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
}
FREE(mdbp, M_TEMP);
return (0);
error_exit:
if (bp)
buf_brelse(bp);
if (mdbp)
FREE(mdbp, M_TEMP);
if (hfsmp && hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
vnode_clearmountedon(hfsmp->jvp);
(void)VNOP_CLOSE(hfsmp->jvp, ronly ? FREAD : FREAD|FWRITE, vfs_context_kernel());
hfsmp->jvp = NULL;
}
if (hfsmp) {
if (hfsmp->hfs_devvp) {
vnode_rele(hfsmp->hfs_devvp);
}
hfs_delete_chash(hfsmp);
FREE(hfsmp, M_HFSMNT);
vfs_setfsprivate(mp, NULL);
}
return (retval);
}
static int
hfs_start(__unused struct mount *mp, __unused int flags, __unused vfs_context_t context)
{
return (0);
}
int
hfs_unmount(struct mount *mp, int mntflags, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
struct hfsmount *hfsmp = VFSTOHFS(mp);
int retval = E_NONE;
int flags;
int force;
int started_tr = 0;
int rb_used = 0;
flags = 0;
force = 0;
if (mntflags & MNT_FORCE) {
flags |= FORCECLOSE;
force = 1;
}
if ((retval = hfs_flushfiles(mp, flags, p)) && !force)
return (retval);
if (hfsmp->hfs_flags & HFS_METADATA_ZONE)
(void) hfs_recording_suspend(hfsmp);
if (hfsmp->hfs_syncer)
{
struct timespec ts = {0, 100000000};
if (thread_call_cancel(hfsmp->hfs_syncer))
OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_incomplete);
thread_call_free(hfsmp->hfs_syncer);
hfsmp->hfs_syncer = NULL;
while(hfsmp->hfs_sync_incomplete > 0)
{
msleep((caddr_t)&hfsmp->hfs_sync_incomplete, NULL, PWAIT, "hfs_unmount", &ts);
}
if (hfsmp->hfs_sync_incomplete < 0)
panic("hfs_unmount: pm_sync_incomplete underflow!\n");
}
#if CONFIG_HFS_ALLOC_RBTREE
rb_used = hfs_teardown_allocator(hfsmp);
#endif
if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {
retval = hfs_start_transaction(hfsmp);
if (retval == 0) {
started_tr = 1;
} else if (!force) {
goto err_exit;
}
if (hfsmp->hfs_startup_vp) {
(void) hfs_lock(VTOC(hfsmp->hfs_startup_vp), HFS_EXCLUSIVE_LOCK);
retval = hfs_fsync(hfsmp->hfs_startup_vp, MNT_WAIT, 0, p);
hfs_unlock(VTOC(hfsmp->hfs_startup_vp));
if (retval && !force)
goto err_exit;
}
if (hfsmp->hfs_attribute_vp) {
(void) hfs_lock(VTOC(hfsmp->hfs_attribute_vp), HFS_EXCLUSIVE_LOCK);
retval = hfs_fsync(hfsmp->hfs_attribute_vp, MNT_WAIT, 0, p);
hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));
if (retval && !force)
goto err_exit;
}
(void) hfs_lock(VTOC(hfsmp->hfs_catalog_vp), HFS_EXCLUSIVE_LOCK);
retval = hfs_fsync(hfsmp->hfs_catalog_vp, MNT_WAIT, 0, p);
hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
if (retval && !force)
goto err_exit;
(void) hfs_lock(VTOC(hfsmp->hfs_extents_vp), HFS_EXCLUSIVE_LOCK);
retval = hfs_fsync(hfsmp->hfs_extents_vp, MNT_WAIT, 0, p);
hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
if (retval && !force)
goto err_exit;
if (hfsmp->hfs_allocation_vp) {
(void) hfs_lock(VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK);
retval = hfs_fsync(hfsmp->hfs_allocation_vp, MNT_WAIT, 0, p);
hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
if (retval && !force)
goto err_exit;
}
if (hfsmp->hfc_filevp && vnode_issystem(hfsmp->hfc_filevp)) {
retval = hfs_fsync(hfsmp->hfc_filevp, MNT_WAIT, 0, p);
if (retval && !force)
goto err_exit;
}
if (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) {
HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;
} else {
HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeUnmountedMask;
}
if (rb_used) {
hfsmp->nextAllocation = 0;
}
else {
if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {
int i;
u_int32_t min_start = hfsmp->totalBlocks;
lck_spin_lock(&hfsmp->vcbFreeExtLock);
for(i=0; i < (int)hfsmp->vcbFreeExtCnt; i++) {
if (hfsmp->vcbFreeExt[i].startBlock < min_start) {
min_start = hfsmp->vcbFreeExt[i].startBlock;
}
}
lck_spin_unlock(&hfsmp->vcbFreeExtLock);
if (min_start < hfsmp->nextAllocation) {
hfsmp->nextAllocation = min_start;
}
}
}
retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
if (retval) {
HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;
if (!force)
goto err_exit;
}
if (started_tr) {
hfs_end_transaction(hfsmp);
started_tr = 0;
}
}
if (hfsmp->jnl) {
hfs_journal_flush(hfsmp, FALSE);
}
(void) hfsUnmount(hfsmp, p);
if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord)
(void) hfs_relconverter(hfsmp->hfs_encoding);
if (hfsmp->jnl) {
journal_close(hfsmp->jnl);
hfsmp->jnl = NULL;
}
VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);
if (hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
vnode_clearmountedon(hfsmp->jvp);
retval = VNOP_CLOSE(hfsmp->jvp,
hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE,
vfs_context_kernel());
vnode_put(hfsmp->jvp);
hfsmp->jvp = NULL;
}
(void) vflush(mp, NULLVP, FORCECLOSE);
#if HFS_SPARSE_DEV
if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) && hfsmp->hfs_backingfs_rootvp) {
struct vnode * tmpvp;
hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;
tmpvp = hfsmp->hfs_backingfs_rootvp;
hfsmp->hfs_backingfs_rootvp = NULLVP;
vnode_rele(tmpvp);
}
#endif
lck_mtx_destroy(&hfsmp->hfc_mutex, hfs_mutex_group);
lck_spin_destroy(&hfsmp->vcbFreeExtLock, hfs_spinlock_group);
vnode_rele(hfsmp->hfs_devvp);
hfs_delete_chash(hfsmp);
FREE(hfsmp, M_HFSMNT);
return (0);
err_exit:
if (started_tr) {
hfs_end_transaction(hfsmp);
}
return retval;
}
static int
hfs_vfs_root(struct mount *mp, struct vnode **vpp, __unused vfs_context_t context)
{
return hfs_vget(VFSTOHFS(mp), (cnid_t)kHFSRootFolderID, vpp, 1, 0);
}
#if !QUOTA
static int
hfs_quotactl(__unused struct mount *mp, __unused int cmds, __unused uid_t uid, __unused caddr_t datap, __unused vfs_context_t context)
{
return (ENOTSUP);
}
#else
static int
hfs_quotactl(struct mount *mp, int cmds, uid_t uid, caddr_t datap, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
int cmd, type, error;
if (uid == ~0U)
uid = kauth_cred_getuid(vfs_context_ucred(context));
cmd = cmds >> SUBCMDSHIFT;
switch (cmd) {
case Q_SYNC:
case Q_QUOTASTAT:
break;
case Q_GETQUOTA:
if (uid == kauth_cred_getuid(vfs_context_ucred(context)))
break;
default:
if ( (error = vfs_context_suser(context)) )
return (error);
}
type = cmds & SUBCMDMASK;
if ((u_int)type >= MAXQUOTAS)
return (EINVAL);
if (vfs_busy(mp, LK_NOWAIT))
return (0);
switch (cmd) {
case Q_QUOTAON:
error = hfs_quotaon(p, mp, type, datap);
break;
case Q_QUOTAOFF:
error = hfs_quotaoff(p, mp, type);
break;
case Q_SETQUOTA:
error = hfs_setquota(mp, uid, type, datap);
break;
case Q_SETUSE:
error = hfs_setuse(mp, uid, type, datap);
break;
case Q_GETQUOTA:
error = hfs_getquota(mp, uid, type, datap);
break;
case Q_SYNC:
error = hfs_qsync(mp);
break;
case Q_QUOTASTAT:
error = hfs_quotastat(mp, type, datap);
break;
default:
error = EINVAL;
break;
}
vfs_unbusy(mp);
return (error);
}
#endif
#define HFS_SUBTYPE_JOURNALED 0x01
#define HFS_SUBTYPE_CASESENSITIVE 0x02
#define HFS_SUBTYPE_STANDARDHFS 0x80
int
hfs_statfs(struct mount *mp, register struct vfsstatfs *sbp, __unused vfs_context_t context)
{
ExtendedVCB *vcb = VFSTOVCB(mp);
struct hfsmount *hfsmp = VFSTOHFS(mp);
u_int32_t freeCNIDs;
u_int16_t subtype = 0;
freeCNIDs = (u_int32_t)0xFFFFFFFF - (u_int32_t)vcb->vcbNxtCNID;
sbp->f_bsize = (u_int32_t)vcb->blockSize;
sbp->f_iosize = (size_t)cluster_max_io_size(mp, 0);
sbp->f_blocks = (u_int64_t)((u_int32_t)vcb->totalBlocks);
sbp->f_bfree = (u_int64_t)((u_int32_t )hfs_freeblks(hfsmp, 0));
sbp->f_bavail = (u_int64_t)((u_int32_t )hfs_freeblks(hfsmp, 1));
sbp->f_files = (u_int64_t)((u_int32_t )(vcb->totalBlocks - 2));
sbp->f_ffree = (u_int64_t)((u_int32_t )(MIN(freeCNIDs, sbp->f_bavail)));
if (hfsmp->hfs_flags & HFS_STANDARD) {
subtype = HFS_SUBTYPE_STANDARDHFS;
} else {
if (hfsmp->jnl)
subtype |= HFS_SUBTYPE_JOURNALED;
if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
subtype |= HFS_SUBTYPE_CASESENSITIVE;
}
sbp->f_fssubtype = subtype;
return (0);
}
__private_extern__
void
hfs_sync_metadata(void *arg)
{
struct mount *mp = (struct mount *)arg;
struct hfsmount *hfsmp;
ExtendedVCB *vcb;
buf_t bp;
int retval;
daddr64_t priIDSector;
hfsmp = VFSTOHFS(mp);
vcb = HFSTOVCB(hfsmp);
priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp);
if ((retval != 0 ) && (retval != ENXIO)) {
printf("hfs_sync_metadata: can't read volume header at %d! (retval 0x%x)\n",
(int)priIDSector, retval);
}
if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {
buf_bwrite(bp);
} else if (bp) {
buf_brelse(bp);
}
if (hfsmp->hfs_alt_id_sector) {
retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp);
if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {
buf_bwrite(bp);
} else if (bp) {
buf_brelse(bp);
}
}
}
struct hfs_sync_cargs {
kauth_cred_t cred;
struct proc *p;
int waitfor;
int error;
};
static int
hfs_sync_callback(struct vnode *vp, void *cargs)
{
struct cnode *cp;
struct hfs_sync_cargs *args;
int error;
args = (struct hfs_sync_cargs *)cargs;
if (hfs_lock(VTOC(vp), HFS_EXCLUSIVE_LOCK) != 0) {
return (VNODE_RETURNED);
}
cp = VTOC(vp);
if ((cp->c_flag & C_MODIFIED) ||
(cp->c_touch_acctime | cp->c_touch_chgtime | cp->c_touch_modtime) ||
vnode_hasdirtyblks(vp)) {
error = hfs_fsync(vp, args->waitfor, 0, args->p);
if (error)
args->error = error;
}
hfs_unlock(cp);
return (VNODE_RETURNED);
}
int
hfs_sync(struct mount *mp, int waitfor, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
struct cnode *cp;
struct hfsmount *hfsmp;
ExtendedVCB *vcb;
struct vnode *meta_vp[4];
int i;
int error, allerror = 0;
struct hfs_sync_cargs args;
hfsmp = VFSTOHFS(mp);
if (hfsmp->hfs_flags & HFS_IN_CHANGEFS)
return (0);
if (hfsmp->hfs_flags & HFS_READ_ONLY)
return (EROFS);
if (!lck_rw_try_lock_shared(&hfsmp->hfs_insync))
return 0;
args.cred = kauth_cred_get();
args.waitfor = waitfor;
args.p = p;
args.error = 0;
vnode_iterate(mp, 0, hfs_sync_callback, (void *)&args);
if (args.error)
allerror = args.error;
vcb = HFSTOVCB(hfsmp);
meta_vp[0] = vcb->extentsRefNum;
meta_vp[1] = vcb->catalogRefNum;
meta_vp[2] = vcb->allocationsRefNum;
meta_vp[3] = hfsmp->hfs_attribute_vp;
for (i = 0; i < 4; ++i) {
struct vnode *btvp;
btvp = meta_vp[i];;
if ((btvp==0) || (vnode_mount(btvp) != mp))
continue;
(void) hfs_lock(VTOC(btvp), HFS_EXCLUSIVE_LOCK);
cp = VTOC(btvp);
if (((cp->c_flag & C_MODIFIED) == 0) &&
(cp->c_touch_acctime == 0) &&
(cp->c_touch_chgtime == 0) &&
(cp->c_touch_modtime == 0) &&
vnode_hasdirtyblks(btvp) == 0) {
hfs_unlock(VTOC(btvp));
continue;
}
error = vnode_get(btvp);
if (error) {
hfs_unlock(VTOC(btvp));
continue;
}
if ((error = hfs_fsync(btvp, waitfor, 0, p)))
allerror = error;
hfs_unlock(cp);
vnode_put(btvp);
};
if (vcb->vcbSigWord == kHFSSigWord) {
if ((error = VNOP_FSYNC(hfsmp->hfs_devvp, waitfor, context))) {
allerror = error;
}
}
#if QUOTA
hfs_qsync(mp);
#endif
hfs_hotfilesync(hfsmp, vfs_context_kernel());
if (IsVCBDirty(vcb)) {
error = hfs_flushvolumeheader(hfsmp, waitfor, 0);
if (error)
allerror = error;
}
if (hfsmp->jnl) {
hfs_journal_flush(hfsmp, FALSE);
}
{
clock_sec_t secs;
clock_usec_t usecs;
uint64_t now;
clock_get_calendar_microtime(&secs, &usecs);
now = ((uint64_t)secs * 1000000ULL) + (uint64_t)usecs;
hfsmp->hfs_last_sync_time = now;
}
lck_rw_unlock_shared(&hfsmp->hfs_insync);
return (allerror);
}
static int
hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp, __unused vfs_context_t context)
{
struct hfsfid *hfsfhp;
struct vnode *nvp;
int result;
*vpp = NULL;
hfsfhp = (struct hfsfid *)fhp;
if (fhlen < (int)sizeof(struct hfsfid))
return (EINVAL);
result = hfs_vget(VFSTOHFS(mp), ntohl(hfsfhp->hfsfid_cnid), &nvp, 0, 0);
if (result) {
if (result == ENOENT)
result = ESTALE;
return result;
}
*vpp = nvp;
hfs_unlock(VTOC(nvp));
return (0);
}
static int
hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, __unused vfs_context_t context)
{
struct cnode *cp;
struct hfsfid *hfsfhp;
if (ISHFS(VTOVCB(vp)))
return (ENOTSUP);
if (*fhlenp < (int)sizeof(struct hfsfid))
return (EOVERFLOW);
cp = VTOC(vp);
hfsfhp = (struct hfsfid *)fhp;
hfsfhp->hfsfid_cnid = htonl(cp->c_fileid);
hfsfhp->hfsfid_gen = htonl(cp->c_fileid);
*fhlenp = sizeof(struct hfsfid);
return (0);
}
static int
hfs_init(__unused struct vfsconf *vfsp)
{
static int done = 0;
if (done)
return (0);
done = 1;
hfs_chashinit();
hfs_converterinit();
BTReserveSetup();
hfs_lock_attr = lck_attr_alloc_init();
hfs_group_attr = lck_grp_attr_alloc_init();
hfs_mutex_group = lck_grp_alloc_init("hfs-mutex", hfs_group_attr);
hfs_rwlock_group = lck_grp_alloc_init("hfs-rwlock", hfs_group_attr);
hfs_spinlock_group = lck_grp_alloc_init("hfs-spinlock", hfs_group_attr);
#if HFS_COMPRESSION
decmpfs_init();
#endif
return (0);
}
static int
hfs_getmountpoint(struct vnode *vp, struct hfsmount **hfsmpp)
{
struct hfsmount * hfsmp;
char fstypename[MFSNAMELEN];
if (vp == NULL)
return (EINVAL);
if (!vnode_isvroot(vp))
return (EINVAL);
vnode_vfsname(vp, fstypename);
if (strncmp(fstypename, "hfs", sizeof(fstypename)) != 0)
return (EINVAL);
hfsmp = VTOHFS(vp);
if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord)
return (EINVAL);
*hfsmpp = hfsmp;
return (0);
}
#include <sys/filedesc.h>
int
hfs_sysctl(int *name, __unused u_int namelen, user_addr_t oldp, size_t *oldlenp,
user_addr_t newp, size_t newlen, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
int error;
struct hfsmount *hfsmp;
if (name[0] == HFS_ENCODINGBIAS) {
int bias;
bias = hfs_getencodingbias();
error = sysctl_int(oldp, oldlenp, newp, newlen, &bias);
if (error == 0 && newp)
hfs_setencodingbias(bias);
return (error);
} else if (name[0] == HFS_EXTEND_FS) {
u_int64_t newsize;
vnode_t vp = vfs_context_cwd(context);
if (newp == USER_ADDR_NULL || vp == NULLVP)
return (EINVAL);
if ((error = hfs_getmountpoint(vp, &hfsmp)))
return (error);
error = sysctl_quad(oldp, oldlenp, newp, newlen, (quad_t *)&newsize);
if (error)
return (error);
error = hfs_extendfs(hfsmp, newsize, context);
return (error);
} else if (name[0] == HFS_ENCODINGHINT) {
size_t bufsize;
size_t bytes;
u_int32_t hint;
u_int16_t *unicode_name = NULL;
char *filename = NULL;
if ((newlen <= 0) || (newlen > MAXPATHLEN))
return (EINVAL);
bufsize = MAX(newlen * 3, MAXPATHLEN);
MALLOC(filename, char *, newlen, M_TEMP, M_WAITOK);
if (filename == NULL) {
error = ENOMEM;
goto encodinghint_exit;
}
MALLOC(unicode_name, u_int16_t *, bufsize, M_TEMP, M_WAITOK);
if (filename == NULL) {
error = ENOMEM;
goto encodinghint_exit;
}
error = copyin(newp, (caddr_t)filename, newlen);
if (error == 0) {
error = utf8_decodestr((u_int8_t *)filename, newlen - 1, unicode_name,
&bytes, bufsize, 0, UTF_DECOMPOSED);
if (error == 0) {
hint = hfs_pickencoding(unicode_name, bytes / 2);
error = sysctl_int(oldp, oldlenp, USER_ADDR_NULL, 0, (int32_t *)&hint);
}
}
encodinghint_exit:
if (unicode_name)
FREE(unicode_name, M_TEMP);
if (filename)
FREE(filename, M_TEMP);
return (error);
} else if (name[0] == HFS_ENABLE_JOURNALING) {
vnode_t vp = vfs_context_cwd(context);
vnode_t jvp;
ExtendedVCB *vcb;
struct cat_attr jnl_attr, jinfo_attr;
struct cat_fork jnl_fork, jinfo_fork;
void *jnl = NULL;
int lockflags;
if (!is_suser()) {
return (EPERM);
}
if (vp == NULLVP)
return EINVAL;
hfsmp = VTOHFS(vp);
if (hfsmp->hfs_flags & HFS_READ_ONLY) {
return EROFS;
}
if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord) {
printf("hfs: can't make a plain hfs volume journaled.\n");
return EINVAL;
}
if (hfsmp->jnl) {
printf("hfs: volume @ mp %p is already journaled!\n", vnode_mount(vp));
return EAGAIN;
}
vcb = HFSTOVCB(hfsmp);
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);
if (BTHasContiguousNodes(VTOF(vcb->catalogRefNum)) == 0 ||
BTHasContiguousNodes(VTOF(vcb->extentsRefNum)) == 0) {
printf("hfs: volume has a btree w/non-contiguous nodes. can not enable journaling.\n");
hfs_systemfile_unlock(hfsmp, lockflags);
return EINVAL;
}
hfs_systemfile_unlock(hfsmp, lockflags);
if ( GetFileInfo(vcb, kHFSRootFolderID, ".journal_info_block", &jinfo_attr, &jinfo_fork) == 0
|| GetFileInfo(vcb, kHFSRootFolderID, ".journal", &jnl_attr, &jnl_fork) == 0) {
return EINVAL;
}
hfs_sync(hfsmp->hfs_mp, MNT_WAIT, context);
printf("hfs: Initializing the journal (joffset 0x%llx sz 0x%llx)...\n",
(off_t)name[2], (off_t)name[3]);
jvp = hfsmp->hfs_devvp;
jnl = journal_create(jvp,
(off_t)name[2] * (off_t)HFSTOVCB(hfsmp)->blockSize
+ HFSTOVCB(hfsmp)->hfsPlusIOPosOffset,
(off_t)((unsigned)name[3]),
hfsmp->hfs_devvp,
hfsmp->hfs_logical_block_size,
0,
0,
hfs_sync_metadata, hfsmp->hfs_mp);
if (jnl)
journal_trim_set_callback(jnl, hfs_trim_callback, hfsmp);
if (jnl == NULL) {
printf("hfs: FAILED to create the journal!\n");
if (jvp && jvp != hfsmp->hfs_devvp) {
vnode_clearmountedon(jvp);
VNOP_CLOSE(jvp, hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE, vfs_context_kernel());
}
jvp = NULL;
return EINVAL;
}
hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);
buf_flushdirtyblks(hfsmp->hfs_devvp, TRUE, 0, "hfs_sysctl");
buf_flushdirtyblks(hfsmp->hfs_extents_vp, TRUE, 0, "hfs_sysctl");
buf_flushdirtyblks(hfsmp->hfs_catalog_vp, TRUE, 0, "hfs_sysctl");
buf_flushdirtyblks(hfsmp->hfs_allocation_vp, TRUE, 0, "hfs_sysctl");
if (hfsmp->hfs_attribute_vp)
buf_flushdirtyblks(hfsmp->hfs_attribute_vp, TRUE, 0, "hfs_sysctl");
HFSTOVCB(hfsmp)->vcbJinfoBlock = name[1];
HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeJournaledMask;
hfsmp->jvp = jvp;
hfsmp->jnl = jnl;
hfsmp->jnl_start = (u_int32_t)name[2];
hfsmp->jnl_size = (off_t)((unsigned)name[3]);
hfsmp->hfs_jnlinfoblkid = jinfo_attr.ca_fileid;
hfsmp->hfs_jnlfileid = jnl_attr.ca_fileid;
vfs_setflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
hfs_unlock_global (hfsmp);
hfs_flushvolumeheader(hfsmp, MNT_WAIT, 1);
{
fsid_t fsid;
fsid.val[0] = (int32_t)hfsmp->hfs_raw_dev;
fsid.val[1] = (int32_t)vfs_typenum(HFSTOVFS(hfsmp));
vfs_event_signal(&fsid, VQ_UPDATE, (intptr_t)NULL);
}
return 0;
} else if (name[0] == HFS_DISABLE_JOURNALING) {
vnode_t vp = vfs_context_cwd(context);
if (!is_suser()) {
return (EPERM);
}
if (vp == NULLVP)
return EINVAL;
hfsmp = VTOHFS(vp);
if (hfsmp->hfs_private_attr[DIR_HARDLINKS].ca_entries != 0){
printf("hfs: cannot disable journaling on volumes with directory hardlinks\n");
return EPERM;
}
printf("hfs: disabling journaling for mount @ %p\n", vnode_mount(vp));
hfs_lock_global (hfsmp, HFS_EXCLUSIVE_LOCK);
journal_close(hfsmp->jnl);
hfsmp->jnl = NULL;
if (hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
vnode_clearmountedon(hfsmp->jvp);
VNOP_CLOSE(hfsmp->jvp, hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE, vfs_context_kernel());
vnode_put(hfsmp->jvp);
}
hfsmp->jvp = NULL;
vfs_clearflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
hfsmp->jnl_start = 0;
hfsmp->hfs_jnlinfoblkid = 0;
hfsmp->hfs_jnlfileid = 0;
HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeJournaledMask;
hfs_unlock_global (hfsmp);
hfs_flushvolumeheader(hfsmp, MNT_WAIT, 1);
{
fsid_t fsid;
fsid.val[0] = (int32_t)hfsmp->hfs_raw_dev;
fsid.val[1] = (int32_t)vfs_typenum(HFSTOVFS(hfsmp));
vfs_event_signal(&fsid, VQ_UPDATE, (intptr_t)NULL);
}
return 0;
} else if (name[0] == HFS_GET_JOURNAL_INFO) {
vnode_t vp = vfs_context_cwd(context);
off_t jnl_start, jnl_size;
if (vp == NULLVP)
return EINVAL;
if (proc_is64bit(current_proc()))
return EINVAL;
hfsmp = VTOHFS(vp);
if (hfsmp->jnl == NULL) {
jnl_start = 0;
jnl_size = 0;
} else {
jnl_start = (off_t)(hfsmp->jnl_start * HFSTOVCB(hfsmp)->blockSize) + (off_t)HFSTOVCB(hfsmp)->hfsPlusIOPosOffset;
jnl_size = (off_t)hfsmp->jnl_size;
}
if ((error = copyout((caddr_t)&jnl_start, CAST_USER_ADDR_T(name[1]), sizeof(off_t))) != 0) {
return error;
}
if ((error = copyout((caddr_t)&jnl_size, CAST_USER_ADDR_T(name[2]), sizeof(off_t))) != 0) {
return error;
}
return 0;
} else if (name[0] == HFS_SET_PKG_EXTENSIONS) {
return set_package_extensions_table((user_addr_t)((unsigned)name[1]), name[2], name[3]);
} else if (name[0] == VFS_CTL_QUERY) {
struct sysctl_req *req;
union union_vfsidctl vc;
struct mount *mp;
struct vfsquery vq;
req = CAST_DOWN(struct sysctl_req *, oldp);
error = SYSCTL_IN(req, &vc, proc_is64bit(p)? sizeof(vc.vc64):sizeof(vc.vc32));
if (error) return (error);
mp = vfs_getvfs(&vc.vc32.vc_fsid);
if (mp == NULL) return (ENOENT);
hfsmp = VFSTOHFS(mp);
bzero(&vq, sizeof(vq));
vq.vq_flags = hfsmp->hfs_notification_conditions;
return SYSCTL_OUT(req, &vq, sizeof(vq));;
} else if (name[0] == HFS_REPLAY_JOURNAL) {
vnode_t devvp = NULL;
int device_fd;
if (namelen != 2) {
return (EINVAL);
}
device_fd = name[1];
error = file_vnode(device_fd, &devvp);
if (error) {
return error;
}
error = vnode_getwithref(devvp);
if (error) {
file_drop(device_fd);
return error;
}
error = hfs_journal_replay(devvp, context);
file_drop(device_fd);
vnode_put(devvp);
return error;
} else if (name[0] == HFS_ENABLE_RESIZE_DEBUG) {
hfs_resize_debug = 1;
printf ("hfs_sysctl: Enabled volume resize debugging.\n");
return 0;
}
return (ENOTSUP);
}
int
hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, __unused vfs_context_t context)
{
int error;
int lockflags;
struct hfsmount *hfsmp;
hfsmp = VFSTOHFS(mp);
error = hfs_vget(hfsmp, (cnid_t)ino, vpp, 1, 0);
if (error)
return (error);
if ((VTOC(*vpp)->c_flag & C_HARDLINK) &&
(hfs_lock(VTOC(*vpp), HFS_EXCLUSIVE_LOCK) == 0)) {
cnode_t *cp = VTOC(*vpp);
struct cat_desc cdesc;
if (!hfs_haslinkorigin(cp)) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = cat_findname(hfsmp, (cnid_t)ino, &cdesc);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error == 0) {
if ((cdesc.cd_parentcnid != hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) &&
(cdesc.cd_parentcnid != hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid)) {
hfs_savelinkorigin(cp, cdesc.cd_parentcnid);
}
cat_releasedesc(&cdesc);
}
}
hfs_unlock(cp);
}
return (0);
}
int
hfs_vget(struct hfsmount *hfsmp, cnid_t cnid, struct vnode **vpp, int skiplock, int allow_deleted)
{
struct vnode *vp = NULLVP;
struct cat_desc cndesc;
struct cat_attr cnattr;
struct cat_fork cnfork;
u_int32_t linkref = 0;
int error;
if ((cnid < kHFSFirstUserCatalogNodeID) &&
(cnid != kHFSRootFolderID && cnid != kHFSRootParentID)) {
return (ENOENT);
}
if (cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||
cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
return (ENOENT);
}
vp = hfs_chash_getvnode(hfsmp, cnid, 0, skiplock, allow_deleted);
if (vp) {
*vpp = vp;
return(0);
}
bzero(&cndesc, sizeof(cndesc));
bzero(&cnattr, sizeof(cnattr));
bzero(&cnfork, sizeof(cnfork));
if (cnid == kHFSRootParentID) {
static char hfs_rootname[] = "/";
cndesc.cd_nameptr = (const u_int8_t *)&hfs_rootname[0];
cndesc.cd_namelen = 1;
cndesc.cd_parentcnid = kHFSRootParentID;
cndesc.cd_cnid = kHFSRootFolderID;
cndesc.cd_flags = CD_ISDIR;
cnattr.ca_fileid = kHFSRootFolderID;
cnattr.ca_linkcount = 1;
cnattr.ca_entries = 1;
cnattr.ca_dircount = 1;
cnattr.ca_mode = (S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO);
} else {
int lockflags;
cnid_t pid;
const char *nameptr;
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = cat_idlookup(hfsmp, cnid, 0, &cndesc, &cnattr, &cnfork);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
*vpp = NULL;
return (error);
}
pid = cndesc.cd_parentcnid;
nameptr = (const char *)cndesc.cd_nameptr;
if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&
(bcmp(nameptr, HFS_INODE_PREFIX, HFS_INODE_PREFIX_LEN) == 0)) {
linkref = strtoul(&nameptr[HFS_INODE_PREFIX_LEN], NULL, 10);
} else if ((pid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) &&
(bcmp(nameptr, HFS_DIRINODE_PREFIX, HFS_DIRINODE_PREFIX_LEN) == 0)) {
linkref = strtoul(&nameptr[HFS_DIRINODE_PREFIX_LEN], NULL, 10);
} else if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&
(bcmp(nameptr, HFS_DELETE_PREFIX, HFS_DELETE_PREFIX_LEN) == 0)) {
*vpp = NULL;
cat_releasedesc(&cndesc);
return (ENOENT);
}
}
if (linkref) {
cnid_t nextlinkid;
cnid_t prevlinkid;
struct cat_desc linkdesc;
int lockflags;
cnattr.ca_linkref = linkref;
if ((hfs_lookup_siblinglinks(hfsmp, linkref, &prevlinkid, &nextlinkid) == 0) &&
(nextlinkid != 0)) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = cat_findname(hfsmp, nextlinkid, &linkdesc);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error == 0) {
cat_releasedesc(&cndesc);
bcopy(&linkdesc, &cndesc, sizeof(linkdesc));
}
}
}
if (linkref) {
int newvnode_flags = 0;
error = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr,
&cnfork, &vp, &newvnode_flags);
if (error == 0) {
VTOC(vp)->c_flag |= C_HARDLINK;
vnode_setmultipath(vp);
}
} else {
struct componentname cn;
int newvnode_flags = 0;
MALLOC_ZONE(cn.cn_pnbuf, caddr_t, MAXPATHLEN, M_NAMEI, M_WAITOK);
cn.cn_nameiop = LOOKUP;
cn.cn_flags = ISLASTCN | HASBUF;
cn.cn_context = NULL;
cn.cn_pnlen = MAXPATHLEN;
cn.cn_nameptr = cn.cn_pnbuf;
cn.cn_namelen = cndesc.cd_namelen;
cn.cn_hash = 0;
cn.cn_consume = 0;
bcopy(cndesc.cd_nameptr, cn.cn_nameptr, cndesc.cd_namelen + 1);
error = hfs_getnewvnode(hfsmp, NULLVP, &cn, &cndesc, 0, &cnattr,
&cnfork, &vp, &newvnode_flags);
if (error == 0 && (VTOC(vp)->c_flag & C_HARDLINK)) {
hfs_savelinkorigin(VTOC(vp), cndesc.cd_parentcnid);
}
FREE_ZONE(cn.cn_pnbuf, cn.cn_pnlen, M_NAMEI);
}
cat_releasedesc(&cndesc);
*vpp = vp;
if (vp && skiplock) {
hfs_unlock(VTOC(vp));
}
return (error);
}
static int
#if QUOTA
hfs_flushfiles(struct mount *mp, int flags, struct proc *p)
#else
hfs_flushfiles(struct mount *mp, int flags, __unused struct proc *p)
#endif
{
struct hfsmount *hfsmp;
struct vnode *skipvp = NULLVP;
int error;
#if QUOTA
int quotafilecnt;
int i;
#endif
hfsmp = VFSTOHFS(mp);
#if QUOTA
quotafilecnt = 0;
if (((unsigned int)vfs_flags(mp)) & MNT_QUOTA) {
for (i = 0; i < MAXQUOTAS; i++) {
if (hfsmp->hfs_qfiles[i].qf_vp != NULLVP)
++quotafilecnt;
}
skipvp = hfs_chash_getvnode(hfsmp, kHFSRootFolderID, 0, 0, 0);
}
#endif
error = vflush(mp, skipvp, SKIPSYSTEM | SKIPSWAP | flags);
if (error != 0)
return(error);
error = vflush(mp, skipvp, SKIPSYSTEM | flags);
#if QUOTA
if (((unsigned int)vfs_flags(mp)) & MNT_QUOTA) {
if (skipvp) {
if ((error == 0) &&
(vnode_isinuse(skipvp, quotafilecnt))) {
error = EBUSY;
}
hfs_unlock(VTOC(skipvp));
vnode_put(skipvp);
}
if (error && (flags & FORCECLOSE) == 0)
return (error);
for (i = 0; i < MAXQUOTAS; i++) {
if (hfsmp->hfs_qfiles[i].qf_vp == NULLVP)
continue;
hfs_quotaoff(p, mp, i);
}
error = vflush(mp, NULLVP, SKIPSYSTEM | flags);
}
#endif
return (error);
}
__private_extern__
void
hfs_setencodingbits(struct hfsmount *hfsmp, u_int32_t encoding)
{
#define kIndexMacUkrainian 48
#define kIndexMacFarsi 49
u_int32_t index;
switch (encoding) {
case kTextEncodingMacUkrainian:
index = kIndexMacUkrainian;
break;
case kTextEncodingMacFarsi:
index = kIndexMacFarsi;
break;
default:
index = encoding;
break;
}
if (index < 64 && (hfsmp->encodingsBitmap & (u_int64_t)(1ULL << index)) == 0) {
HFS_MOUNT_LOCK(hfsmp, TRUE)
hfsmp->encodingsBitmap |= (u_int64_t)(1ULL << index);
MarkVCBDirty(hfsmp);
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
}
}
int
hfs_volupdate(struct hfsmount *hfsmp, enum volop op, int inroot)
{
struct timeval tv;
microtime(&tv);
lck_mtx_lock(&hfsmp->hfs_mutex);
MarkVCBDirty(hfsmp);
hfsmp->hfs_mtime = tv.tv_sec;
switch (op) {
case VOL_UPDATE:
break;
case VOL_MKDIR:
if (hfsmp->hfs_dircount != 0xFFFFFFFF)
++hfsmp->hfs_dircount;
if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)
++hfsmp->vcbNmRtDirs;
break;
case VOL_RMDIR:
if (hfsmp->hfs_dircount != 0)
--hfsmp->hfs_dircount;
if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)
--hfsmp->vcbNmRtDirs;
break;
case VOL_MKFILE:
if (hfsmp->hfs_filecount != 0xFFFFFFFF)
++hfsmp->hfs_filecount;
if (inroot && hfsmp->vcbNmFls != 0xFFFF)
++hfsmp->vcbNmFls;
break;
case VOL_RMFILE:
if (hfsmp->hfs_filecount != 0)
--hfsmp->hfs_filecount;
if (inroot && hfsmp->vcbNmFls != 0xFFFF)
--hfsmp->vcbNmFls;
break;
}
lck_mtx_unlock(&hfsmp->hfs_mutex);
if (hfsmp->jnl) {
hfs_flushvolumeheader(hfsmp, 0, 0);
}
return (0);
}
static int
hfs_flushMDB(struct hfsmount *hfsmp, int waitfor, int altflush)
{
ExtendedVCB *vcb = HFSTOVCB(hfsmp);
struct filefork *fp;
HFSMasterDirectoryBlock *mdb;
struct buf *bp = NULL;
int retval;
int sectorsize;
ByteCount namelen;
sectorsize = hfsmp->hfs_logical_block_size;
retval = (int)buf_bread(hfsmp->hfs_devvp, (daddr64_t)HFS_PRI_SECTOR(sectorsize), sectorsize, NOCRED, &bp);
if (retval) {
if (bp)
buf_brelse(bp);
return retval;
}
lck_mtx_lock(&hfsmp->hfs_mutex);
mdb = (HFSMasterDirectoryBlock *)(buf_dataptr(bp) + HFS_PRI_OFFSET(sectorsize));
mdb->drCrDate = SWAP_BE32 (UTCToLocal(to_hfs_time(vcb->hfs_itime)));
mdb->drLsMod = SWAP_BE32 (UTCToLocal(to_hfs_time(vcb->vcbLsMod)));
mdb->drAtrb = SWAP_BE16 (vcb->vcbAtrb);
mdb->drNmFls = SWAP_BE16 (vcb->vcbNmFls);
mdb->drAllocPtr = SWAP_BE16 (vcb->nextAllocation);
mdb->drClpSiz = SWAP_BE32 (vcb->vcbClpSiz);
mdb->drNxtCNID = SWAP_BE32 (vcb->vcbNxtCNID);
mdb->drFreeBks = SWAP_BE16 (vcb->freeBlocks);
namelen = strlen((char *)vcb->vcbVN);
retval = utf8_to_hfs(vcb, namelen, vcb->vcbVN, mdb->drVN);
if (retval)
retval = utf8_to_mac_roman(namelen, vcb->vcbVN, mdb->drVN);
mdb->drVolBkUp = SWAP_BE32 (UTCToLocal(to_hfs_time(vcb->vcbVolBkUp)));
mdb->drWrCnt = SWAP_BE32 (vcb->vcbWrCnt);
mdb->drNmRtDirs = SWAP_BE16 (vcb->vcbNmRtDirs);
mdb->drFilCnt = SWAP_BE32 (vcb->vcbFilCnt);
mdb->drDirCnt = SWAP_BE32 (vcb->vcbDirCnt);
bcopy(vcb->vcbFndrInfo, mdb->drFndrInfo, sizeof(mdb->drFndrInfo));
fp = VTOF(vcb->extentsRefNum);
mdb->drXTExtRec[0].startBlock = SWAP_BE16 (fp->ff_extents[0].startBlock);
mdb->drXTExtRec[0].blockCount = SWAP_BE16 (fp->ff_extents[0].blockCount);
mdb->drXTExtRec[1].startBlock = SWAP_BE16 (fp->ff_extents[1].startBlock);
mdb->drXTExtRec[1].blockCount = SWAP_BE16 (fp->ff_extents[1].blockCount);
mdb->drXTExtRec[2].startBlock = SWAP_BE16 (fp->ff_extents[2].startBlock);
mdb->drXTExtRec[2].blockCount = SWAP_BE16 (fp->ff_extents[2].blockCount);
mdb->drXTFlSize = SWAP_BE32 (fp->ff_blocks * vcb->blockSize);
mdb->drXTClpSiz = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
fp = VTOF(vcb->catalogRefNum);
mdb->drCTExtRec[0].startBlock = SWAP_BE16 (fp->ff_extents[0].startBlock);
mdb->drCTExtRec[0].blockCount = SWAP_BE16 (fp->ff_extents[0].blockCount);
mdb->drCTExtRec[1].startBlock = SWAP_BE16 (fp->ff_extents[1].startBlock);
mdb->drCTExtRec[1].blockCount = SWAP_BE16 (fp->ff_extents[1].blockCount);
mdb->drCTExtRec[2].startBlock = SWAP_BE16 (fp->ff_extents[2].startBlock);
mdb->drCTExtRec[2].blockCount = SWAP_BE16 (fp->ff_extents[2].blockCount);
mdb->drCTFlSize = SWAP_BE32 (fp->ff_blocks * vcb->blockSize);
mdb->drCTClpSiz = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
MarkVCBClean( vcb );
lck_mtx_unlock(&hfsmp->hfs_mutex);
if (altflush) {
struct buf *alt_bp = NULL;
if (buf_meta_bread(hfsmp->hfs_devvp, hfsmp->hfs_alt_id_sector, sectorsize, NOCRED, &alt_bp) == 0) {
bcopy(mdb, (char *)buf_dataptr(alt_bp) + HFS_ALT_OFFSET(sectorsize), kMDBSize);
(void) VNOP_BWRITE(alt_bp);
} else if (alt_bp)
buf_brelse(alt_bp);
}
if (waitfor != MNT_WAIT)
buf_bawrite(bp);
else
retval = VNOP_BWRITE(bp);
return (retval);
}
int
hfs_flushvolumeheader(struct hfsmount *hfsmp, int waitfor, int altflush)
{
ExtendedVCB *vcb = HFSTOVCB(hfsmp);
struct filefork *fp;
HFSPlusVolumeHeader *volumeHeader, *altVH;
int retval;
struct buf *bp, *alt_bp;
int i;
daddr64_t priIDSector;
int critical;
u_int16_t signature;
u_int16_t hfsversion;
if (hfsmp->hfs_flags & HFS_READ_ONLY) {
return(0);
}
if (hfsmp->hfs_flags & HFS_STANDARD) {
return hfs_flushMDB(hfsmp, waitfor, altflush);
}
critical = altflush;
priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
if (hfs_start_transaction(hfsmp) != 0) {
return EINVAL;
}
bp = NULL;
alt_bp = NULL;
retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp);
if (retval) {
printf("hfs: err %d reading VH blk (%s)\n", retval, vcb->vcbVN);
goto err_exit;
}
volumeHeader = (HFSPlusVolumeHeader *)((char *)buf_dataptr(bp) +
HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
signature = SWAP_BE16 (volumeHeader->signature);
hfsversion = SWAP_BE16 (volumeHeader->version);
if ((signature != kHFSPlusSigWord && signature != kHFSXSigWord) ||
(hfsversion < kHFSPlusVersion) || (hfsversion > 100) ||
(SWAP_BE32 (volumeHeader->blockSize) != vcb->blockSize)) {
printf("hfs: corrupt VH on %s, sig 0x%04x, ver %d, blksize %d%s\n",
vcb->vcbVN, signature, hfsversion,
SWAP_BE32 (volumeHeader->blockSize),
hfsmp->hfs_alt_id_sector ? "; trying alternate" : "");
hfs_mark_volume_inconsistent(hfsmp);
if (hfsmp->hfs_alt_id_sector) {
retval = buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &alt_bp);
if (retval) {
printf("hfs: err %d reading alternate VH (%s)\n", retval, vcb->vcbVN);
goto err_exit;
}
altVH = (HFSPlusVolumeHeader *)((char *)buf_dataptr(alt_bp) +
HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size));
signature = SWAP_BE16(altVH->signature);
hfsversion = SWAP_BE16(altVH->version);
if ((signature != kHFSPlusSigWord && signature != kHFSXSigWord) ||
(hfsversion < kHFSPlusVersion) || (kHFSPlusVersion > 100) ||
(SWAP_BE32(altVH->blockSize) != vcb->blockSize)) {
printf("hfs: corrupt alternate VH on %s, sig 0x%04x, ver %d, blksize %d\n",
vcb->vcbVN, signature, hfsversion,
SWAP_BE32(altVH->blockSize));
retval = EIO;
goto err_exit;
}
bcopy(altVH, volumeHeader, kMDBSize);
buf_brelse(alt_bp);
alt_bp = NULL;
} else {
retval = EIO;
goto err_exit;
}
}
if (hfsmp->jnl) {
journal_modify_block_start(hfsmp->jnl, bp);
}
if ((vcb->hfsPlusIOPosOffset != 0) &&
(SWAP_BE32 (volumeHeader->createDate) != vcb->localCreateDate)) {
struct buf *bp2;
HFSMasterDirectoryBlock *mdb;
retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size), hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp2);
if (retval) {
if (bp2)
buf_brelse(bp2);
retval = 0;
} else {
mdb = (HFSMasterDirectoryBlock *)(buf_dataptr(bp2) +
HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
if ( SWAP_BE32 (mdb->drCrDate) != vcb->localCreateDate )
{
if (hfsmp->jnl) {
journal_modify_block_start(hfsmp->jnl, bp2);
}
mdb->drCrDate = SWAP_BE32 (vcb->localCreateDate);
if (hfsmp->jnl) {
journal_modify_block_end(hfsmp->jnl, bp2, NULL, NULL);
} else {
(void) VNOP_BWRITE(bp2);
}
}
else
{
buf_brelse(bp2);
}
}
}
lck_mtx_lock(&hfsmp->hfs_mutex);
volumeHeader->attributes = SWAP_BE32 (vcb->vcbAtrb);
volumeHeader->journalInfoBlock = SWAP_BE32 (vcb->vcbJinfoBlock);
if (hfsmp->jnl) {
volumeHeader->lastMountedVersion = SWAP_BE32 (kHFSJMountVersion);
} else {
volumeHeader->lastMountedVersion = SWAP_BE32 (kHFSPlusMountVersion);
}
volumeHeader->createDate = SWAP_BE32 (vcb->localCreateDate);
volumeHeader->modifyDate = SWAP_BE32 (to_hfs_time(vcb->vcbLsMod));
volumeHeader->backupDate = SWAP_BE32 (to_hfs_time(vcb->vcbVolBkUp));
volumeHeader->fileCount = SWAP_BE32 (vcb->vcbFilCnt);
volumeHeader->folderCount = SWAP_BE32 (vcb->vcbDirCnt);
volumeHeader->totalBlocks = SWAP_BE32 (vcb->totalBlocks);
volumeHeader->freeBlocks = SWAP_BE32 (vcb->freeBlocks);
volumeHeader->nextAllocation = SWAP_BE32 (vcb->nextAllocation);
volumeHeader->rsrcClumpSize = SWAP_BE32 (vcb->vcbClpSiz);
volumeHeader->dataClumpSize = SWAP_BE32 (vcb->vcbClpSiz);
volumeHeader->nextCatalogID = SWAP_BE32 (vcb->vcbNxtCNID);
volumeHeader->writeCount = SWAP_BE32 (vcb->vcbWrCnt);
volumeHeader->encodingsBitmap = SWAP_BE64 (vcb->encodingsBitmap);
if (bcmp(vcb->vcbFndrInfo, volumeHeader->finderInfo, sizeof(volumeHeader->finderInfo)) != 0) {
bcopy(vcb->vcbFndrInfo, volumeHeader->finderInfo, sizeof(volumeHeader->finderInfo));
critical = 1;
}
if (altflush == 0) {
goto done;
}
fp = VTOF(vcb->extentsRefNum);
if (FTOC(fp)->c_flag & C_MODIFIED) {
for (i = 0; i < kHFSPlusExtentDensity; i++) {
volumeHeader->extentsFile.extents[i].startBlock =
SWAP_BE32 (fp->ff_extents[i].startBlock);
volumeHeader->extentsFile.extents[i].blockCount =
SWAP_BE32 (fp->ff_extents[i].blockCount);
}
volumeHeader->extentsFile.logicalSize = SWAP_BE64 (fp->ff_size);
volumeHeader->extentsFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);
volumeHeader->extentsFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
}
fp = VTOF(vcb->catalogRefNum);
if (FTOC(fp)->c_flag & C_MODIFIED) {
for (i = 0; i < kHFSPlusExtentDensity; i++) {
volumeHeader->catalogFile.extents[i].startBlock =
SWAP_BE32 (fp->ff_extents[i].startBlock);
volumeHeader->catalogFile.extents[i].blockCount =
SWAP_BE32 (fp->ff_extents[i].blockCount);
}
volumeHeader->catalogFile.logicalSize = SWAP_BE64 (fp->ff_size);
volumeHeader->catalogFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);
volumeHeader->catalogFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
}
fp = VTOF(vcb->allocationsRefNum);
if (FTOC(fp)->c_flag & C_MODIFIED) {
for (i = 0; i < kHFSPlusExtentDensity; i++) {
volumeHeader->allocationFile.extents[i].startBlock =
SWAP_BE32 (fp->ff_extents[i].startBlock);
volumeHeader->allocationFile.extents[i].blockCount =
SWAP_BE32 (fp->ff_extents[i].blockCount);
}
volumeHeader->allocationFile.logicalSize = SWAP_BE64 (fp->ff_size);
volumeHeader->allocationFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);
volumeHeader->allocationFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
}
if (hfsmp->hfs_attribute_vp) {
fp = VTOF(hfsmp->hfs_attribute_vp);
for (i = 0; i < kHFSPlusExtentDensity; i++) {
volumeHeader->attributesFile.extents[i].startBlock =
SWAP_BE32 (fp->ff_extents[i].startBlock);
volumeHeader->attributesFile.extents[i].blockCount =
SWAP_BE32 (fp->ff_extents[i].blockCount);
}
FTOC(fp)->c_flag &= ~C_MODIFIED;
volumeHeader->attributesFile.logicalSize = SWAP_BE64 (fp->ff_size);
volumeHeader->attributesFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);
volumeHeader->attributesFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);
}
if (hfsmp->hfs_startup_vp) {
fp = VTOF(hfsmp->hfs_startup_vp);
if (FTOC(fp)->c_flag & C_MODIFIED) {
for (i = 0; i < kHFSPlusExtentDensity; i++) {
volumeHeader->startupFile.extents[i].startBlock =
SWAP_BE32 (fp->ff_extents[i].startBlock);
volumeHeader->startupFile.extents[i].blockCount =
SWAP_BE32 (fp->ff_extents[i].blockCount);
}
volumeHeader->startupFile.logicalSize = SWAP_BE64 (fp->ff_size);
volumeHeader->startupFile.totalBlocks = SWAP_BE32 (fp->ff_blocks);
volumeHeader->startupFile.clumpSize = SWAP_BE32 (fp->ff_clumpsize);
FTOC(fp)->c_flag &= ~C_MODIFIED;
}
}
done:
MarkVCBClean(hfsmp);
lck_mtx_unlock(&hfsmp->hfs_mutex);
if (altflush && hfsmp->hfs_alt_id_sector) {
if (buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &alt_bp) == 0) {
if (hfsmp->jnl) {
journal_modify_block_start(hfsmp->jnl, alt_bp);
}
bcopy(volumeHeader, (char *)buf_dataptr(alt_bp) +
HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size),
kMDBSize);
if (hfsmp->jnl) {
journal_modify_block_end(hfsmp->jnl, alt_bp, NULL, NULL);
} else {
(void) VNOP_BWRITE(alt_bp);
}
} else if (alt_bp)
buf_brelse(alt_bp);
}
if (hfsmp->jnl) {
journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);
} else {
if (waitfor != MNT_WAIT)
buf_bawrite(bp);
else {
retval = VNOP_BWRITE(bp);
if (critical && (retval == 0)) {
(void) VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE,
NULL, FWRITE, NULL);
}
}
}
hfs_end_transaction(hfsmp);
return (retval);
err_exit:
if (alt_bp)
buf_brelse(alt_bp);
if (bp)
buf_brelse(bp);
hfs_end_transaction(hfsmp);
return retval;
}
int
hfs_extendfs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)
{
struct proc *p = vfs_context_proc(context);
kauth_cred_t cred = vfs_context_ucred(context);
struct vnode *vp;
struct vnode *devvp;
struct buf *bp;
struct filefork *fp = NULL;
ExtendedVCB *vcb;
struct cat_fork forkdata;
u_int64_t oldsize;
u_int64_t newblkcnt;
u_int64_t prev_phys_block_count;
u_int32_t addblks;
u_int64_t sectorcnt;
u_int32_t sectorsize;
u_int32_t phys_sectorsize;
daddr64_t prev_alt_sector;
daddr_t bitmapblks;
int lockflags = 0;
int error;
int64_t oldBitmapSize;
Boolean usedExtendFileC = false;
int transaction_begun = 0;
devvp = hfsmp->hfs_devvp;
vcb = HFSTOVCB(hfsmp);
if ((vcb->vcbSigWord == kHFSSigWord) ||
(hfsmp->jnl == NULL) ||
(vcb->hfsPlusIOPosOffset != 0)) {
return (EPERM);
}
if (suser(cred, NULL)) {
error = hfs_vget(hfsmp, kHFSRootFolderID, &vp, 0, 0);
if (error)
return (error);
error = hfs_owner_rights(hfsmp, VTOC(vp)->c_uid, cred, p, 0);
if (error == 0) {
error = hfs_write_access(vp, cred, p, false);
}
hfs_unlock(VTOC(vp));
vnode_put(vp);
if (error)
return (error);
error = vnode_authorize(devvp, NULL, KAUTH_VNODE_READ_DATA | KAUTH_VNODE_WRITE_DATA, context);
if (error)
return (error);
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKSIZE, (caddr_t)§orsize, 0, context)) {
return (ENXIO);
}
if (sectorsize != hfsmp->hfs_logical_block_size) {
return (ENXIO);
}
if (VNOP_IOCTL(devvp, DKIOCGETBLOCKCOUNT, (caddr_t)§orcnt, 0, context)) {
return (ENXIO);
}
if ((sectorsize * sectorcnt) < newsize) {
printf("hfs_extendfs: not enough space on device\n");
return (ENOSPC);
}
error = VNOP_IOCTL(devvp, DKIOCGETPHYSICALBLOCKSIZE, (caddr_t)&phys_sectorsize, 0, context);
if (error) {
if ((error != ENOTSUP) && (error != ENOTTY)) {
return (ENXIO);
}
phys_sectorsize = sectorsize;
}
oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;
if ((newsize <= oldsize) || (newsize % sectorsize) || (newsize % phys_sectorsize)) {
printf("hfs_extendfs: invalid size\n");
return (EINVAL);
}
newblkcnt = newsize / vcb->blockSize;
if (newblkcnt > (u_int64_t)0xFFFFFFFF)
return (EOVERFLOW);
addblks = newblkcnt - vcb->totalBlocks;
if (hfs_resize_debug) {
printf ("hfs_extendfs: old: size=%qu, blkcnt=%u\n", oldsize, hfsmp->totalBlocks);
printf ("hfs_extendfs: new: size=%qu, blkcnt=%u, addblks=%u\n", newsize, (u_int32_t)newblkcnt, addblks);
}
printf("hfs_extendfs: will extend \"%s\" by %d blocks\n", vcb->vcbVN, addblks);
HFS_MOUNT_LOCK(hfsmp, TRUE);
if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
error = EALREADY;
goto out;
}
hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
hfs_journal_flush(hfsmp, TRUE);
if (hfs_start_transaction(hfsmp) != 0) {
error = EINVAL;
goto out;
}
transaction_begun = 1;
lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
vp = vcb->allocationsRefNum;
fp = VTOF(vp);
bcopy(&fp->ff_data, &forkdata, sizeof(forkdata));
oldBitmapSize = fp->ff_size;
bitmapblks = roundup((newblkcnt+7) / 8, vcb->vcbVBMIOSize) / vcb->blockSize;
if (bitmapblks > (daddr_t)fp->ff_blocks)
bitmapblks -= fp->ff_blocks;
else
bitmapblks = 0;
BlockMarkFreeUnused(vcb, vcb->totalBlocks,
(fp->ff_blocks * vcb->blockSize * 8) - vcb->totalBlocks);
if (bitmapblks > 0) {
daddr64_t blkno;
daddr_t blkcnt;
off_t bytesAdded;
blkno = (daddr64_t)fp->ff_blocks;
error = ExtendFileC(vcb, fp, bitmapblks * vcb->blockSize, 0,
kEFAllMask | kEFNoClumpMask | kEFReserveMask
| kEFMetadataMask | kEFContigMask, &bytesAdded);
if (error == 0) {
usedExtendFileC = true;
} else {
bytesAdded = 0;
error = AddFileExtent(vcb, fp, vcb->totalBlocks, bitmapblks);
if (error) {
printf("hfs_extendfs: error %d adding extents\n", error);
goto out;
}
fp->ff_blocks += bitmapblks;
VTOC(vp)->c_blocks = fp->ff_blocks;
VTOC(vp)->c_flag |= C_MODIFIED;
}
fp->ff_size += (u_int64_t)bitmapblks * (u_int64_t)vcb->blockSize;
{
bp = NULL;
blkcnt = bitmapblks;
while (blkcnt > 0) {
error = (int)buf_meta_bread(vp, blkno, vcb->blockSize, NOCRED, &bp);
if (error) {
if (bp) {
buf_brelse(bp);
}
break;
}
bzero((char *)buf_dataptr(bp), vcb->blockSize);
buf_markaged(bp);
error = (int)buf_bwrite(bp);
if (error)
break;
--blkcnt;
++blkno;
}
}
if (error) {
printf("hfs_extendfs: error %d clearing blocks\n", error);
goto out;
}
if (!usedExtendFileC) {
error = BlockMarkAllocated(vcb, vcb->totalBlocks, bitmapblks);
if (error) {
printf("hfs_extendfs: error %d setting bitmap\n", error);
goto out;
}
vcb->freeBlocks -= bitmapblks;
}
}
if (vcb->blockSize == 512)
error = BlockMarkAllocated(vcb, vcb->totalBlocks + addblks - 2, 2);
else
error = BlockMarkAllocated(vcb, vcb->totalBlocks + addblks - 1, 1);
if (error) {
printf("hfs_extendfs: error %d setting bitmap (VH)\n", error);
goto out;
}
if (vcb->blockSize == 512)
(void) BlockMarkFree(vcb, vcb->totalBlocks - 2, 2);
else
(void) BlockMarkFree(vcb, vcb->totalBlocks - 1, 1);
prev_phys_block_count = hfsmp->hfs_logical_block_count;
prev_alt_sector = hfsmp->hfs_alt_id_sector;
vcb->totalBlocks += addblks;
vcb->freeBlocks += addblks;
hfsmp->hfs_logical_block_count = newsize / sectorsize;
hfsmp->hfs_alt_id_sector = (hfsmp->hfsPlusIOPosOffset / sectorsize) +
HFS_ALT_SECTOR(sectorsize, hfsmp->hfs_logical_block_count);
MarkVCBDirty(vcb);
error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
if (error) {
printf("hfs_extendfs: couldn't flush volume headers (%d)", error);
if (usedExtendFileC) {
(void) TruncateFileC(vcb, fp, oldBitmapSize, 0, FORK_IS_RSRC(fp),
FTOC(fp)->c_fileid, false);
} else {
fp->ff_blocks -= bitmapblks;
fp->ff_size -= (u_int64_t)bitmapblks * (u_int64_t)vcb->blockSize;
vcb->freeBlocks += bitmapblks;
}
vcb->totalBlocks -= addblks;
vcb->freeBlocks -= addblks;
hfsmp->hfs_logical_block_count = prev_phys_block_count;
hfsmp->hfs_alt_id_sector = prev_alt_sector;
MarkVCBDirty(vcb);
if (vcb->blockSize == 512) {
if (BlockMarkAllocated(vcb, vcb->totalBlocks - 2, 2)) {
hfs_mark_volume_inconsistent(hfsmp);
}
} else {
if (BlockMarkAllocated(vcb, vcb->totalBlocks - 1, 1)) {
hfs_mark_volume_inconsistent(hfsmp);
}
}
goto out;
}
bp = NULL;
if (prev_alt_sector) {
if (buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(prev_alt_sector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp) == 0) {
journal_modify_block_start(hfsmp->jnl, bp);
bzero((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size), kMDBSize);
journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);
} else if (bp) {
buf_brelse(bp);
}
}
hfs_metadatazone_init(hfsmp, false);
if (hfsmp->hfs_attrdata_vp) {
struct cnode *attr_cp;
struct filefork *attr_fp;
if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {
attr_cp = VTOC(hfsmp->hfs_attrdata_vp);
attr_fp = VTOF(hfsmp->hfs_attrdata_vp);
attr_cp->c_blocks = newblkcnt;
attr_fp->ff_blocks = newblkcnt;
attr_fp->ff_extents[0].blockCount = newblkcnt;
attr_fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;
ubc_setsize(hfsmp->hfs_attrdata_vp, attr_fp->ff_size);
vnode_put(hfsmp->hfs_attrdata_vp);
}
}
if (error == 0) {
UpdateAllocLimit(hfsmp, hfsmp->totalBlocks);
}
printf("hfs_extendfs: extended \"%s\" to %d blocks (was %d blocks)\n",
hfsmp->vcbVN, hfsmp->totalBlocks, (u_int32_t)(oldsize/hfsmp->blockSize));
out:
if (error && fp) {
bcopy(&forkdata, &fp->ff_data, sizeof(forkdata));
VTOC(vp)->c_blocks = fp->ff_blocks;
}
HFS_MOUNT_LOCK(hfsmp, TRUE);
hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
if (lockflags) {
hfs_systemfile_unlock(hfsmp, lockflags);
}
if (transaction_begun) {
hfs_end_transaction(hfsmp);
hfs_journal_flush(hfsmp, FALSE);
(void) VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
}
return MacToVFSError(error);
}
#define HFS_MIN_SIZE (32LL * 1024LL * 1024LL)
int
hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)
{
struct buf *bp = NULL;
u_int64_t oldsize;
u_int32_t newblkcnt;
u_int32_t reclaimblks = 0;
int lockflags = 0;
int transaction_begun = 0;
Boolean updateFreeBlocks = false;
Boolean disable_sparse = false;
int error = 0;
lck_mtx_lock(&hfsmp->hfs_mutex);
if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {
lck_mtx_unlock(&hfsmp->hfs_mutex);
return (EALREADY);
}
hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;
hfsmp->hfs_resize_blocksmoved = 0;
hfsmp->hfs_resize_totalblocks = 0;
hfsmp->hfs_resize_progress = 0;
lck_mtx_unlock(&hfsmp->hfs_mutex);
if ((hfsmp->jnl == NULL) ||
(hfsmp->hfsPlusIOPosOffset != 0)) {
error = EPERM;
goto out;
}
oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;
newblkcnt = newsize / hfsmp->blockSize;
reclaimblks = hfsmp->totalBlocks - newblkcnt;
if (hfs_resize_debug) {
printf ("hfs_truncatefs: old: size=%qu, blkcnt=%u, freeblks=%u\n", oldsize, hfsmp->totalBlocks, hfs_freeblks(hfsmp, 1));
printf ("hfs_truncatefs: new: size=%qu, blkcnt=%u, reclaimblks=%u\n", newsize, newblkcnt, reclaimblks);
}
if ((newsize < HFS_MIN_SIZE) ||
(newsize >= oldsize) ||
(newsize % hfsmp->hfs_logical_block_size) ||
(newsize % hfsmp->hfs_physical_block_size)) {
printf ("hfs_truncatefs: invalid size (newsize=%qu, oldsize=%qu)\n", newsize, oldsize);
error = EINVAL;
goto out;
}
if (reclaimblks >= hfs_freeblks(hfsmp, 1)) {
printf("hfs_truncatefs: insufficient space (need %u blocks; have %u free blocks)\n", reclaimblks, hfs_freeblks(hfsmp, 1));
error = ENOSPC;
goto out;
}
hfs_journal_flush(hfsmp, TRUE);
if (hfs_start_transaction(hfsmp) != 0) {
error = EINVAL;
goto out;
}
transaction_begun = 1;
lockflags = hfs_systemfile_lock(hfsmp, SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
if (hfsmp->blockSize == 512) {
error = UpdateAllocLimit (hfsmp, newblkcnt - 2);
}
else {
error = UpdateAllocLimit (hfsmp, newblkcnt - 1);
}
HFS_MOUNT_LOCK(hfsmp, TRUE);
if (hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) {
hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;
ResetVCBFreeExtCache(hfsmp);
disable_sparse = true;
}
hfsmp->freeBlocks -= reclaimblks;
updateFreeBlocks = true;
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
if (lockflags) {
hfs_systemfile_unlock(hfsmp, lockflags);
lockflags = 0;
}
hfs_metadatazone_init(hfsmp, false);
if (hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks)) {
hfs_end_transaction(hfsmp);
transaction_begun = 0;
error = hfs_reclaimspace(hfsmp, hfsmp->allocLimit, reclaimblks, context);
if (error != 0) {
printf("hfs_truncatefs: couldn't reclaim space on %s (error=%d)\n", hfsmp->vcbVN, error);
error = ENOSPC;
goto out;
}
if (hfs_start_transaction(hfsmp) != 0) {
error = EINVAL;
goto out;
}
transaction_begun = 1;
error = hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks);
if (error != 0) {
printf("hfs_truncatefs: didn't reclaim enough space on %s (error=%d)\n", hfsmp->vcbVN, error);
error = EAGAIN;
goto out;
}
}
lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
error = BlockMarkAllocated(hfsmp, hfsmp->allocLimit, (hfsmp->blockSize == 512) ? 2 : 1);
if (error) {
printf("hfs_truncatefs: Error %d allocating new alternate volume header\n", error);
goto out;
}
if (hfsmp->blockSize == 512)
(void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 2, 2);
else
(void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 1, 1);
if (hfsmp->hfs_alt_id_sector) {
error = buf_meta_bread(hfsmp->hfs_devvp,
HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
hfsmp->hfs_physical_block_size, NOCRED, &bp);
if (error == 0) {
bzero((void*)((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size)), kMDBSize);
(void) VNOP_BWRITE(bp);
} else {
if (bp) {
buf_brelse(bp);
}
}
bp = NULL;
}
printf("hfs_truncatefs: shrank \"%s\" to %d blocks (was %d blocks)\n",
hfsmp->vcbVN, newblkcnt, hfsmp->totalBlocks);
hfsmp->totalBlocks = newblkcnt;
hfsmp->hfs_logical_block_count = newsize / hfsmp->hfs_logical_block_size;
hfsmp->hfs_alt_id_sector = HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);
MarkVCBDirty(hfsmp);
error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
if (error)
panic("hfs_truncatefs: unexpected error flushing volume header (%d)\n", error);
if (hfsmp->hfs_attrdata_vp) {
struct cnode *cp;
struct filefork *fp;
if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {
cp = VTOC(hfsmp->hfs_attrdata_vp);
fp = VTOF(hfsmp->hfs_attrdata_vp);
cp->c_blocks = newblkcnt;
fp->ff_blocks = newblkcnt;
fp->ff_extents[0].blockCount = newblkcnt;
fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;
ubc_setsize(hfsmp->hfs_attrdata_vp, fp->ff_size);
vnode_put(hfsmp->hfs_attrdata_vp);
}
}
out:
UpdateAllocLimit (hfsmp, hfsmp->totalBlocks);
HFS_MOUNT_LOCK(hfsmp, TRUE);
if (disable_sparse == true) {
hfsmp->hfs_flags |= HFS_HAS_SPARSE_DEVICE;
ResetVCBFreeExtCache(hfsmp);
}
if (error && (updateFreeBlocks == true)) {
hfsmp->freeBlocks += reclaimblks;
}
if (hfsmp->nextAllocation >= hfsmp->allocLimit) {
hfsmp->nextAllocation = hfsmp->hfs_metazone_end + 1;
}
hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
if (error && (updateFreeBlocks == true)) {
hfs_metadatazone_init(hfsmp, false);
}
if (lockflags) {
hfs_systemfile_unlock(hfsmp, lockflags);
}
if (transaction_begun) {
hfs_end_transaction(hfsmp);
hfs_journal_flush(hfsmp, FALSE);
(void) VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
}
return MacToVFSError(error);
}
struct hfs_inval_blk_no {
daddr64_t sectorStart;
daddr64_t sectorCount;
};
static int
hfs_invalidate_block_numbers_callback(buf_t bp, void *args_in)
{
daddr64_t blkno;
struct hfs_inval_blk_no *args;
blkno = buf_blkno(bp);
args = args_in;
if (blkno >= args->sectorStart && blkno < args->sectorStart+args->sectorCount)
buf_setblkno(bp, buf_lblkno(bp));
return BUF_RETURNED;
}
static void
hfs_invalidate_sectors(struct vnode *vp, daddr64_t sectorStart, daddr64_t sectorCount)
{
struct hfs_inval_blk_no args;
args.sectorStart = sectorStart;
args.sectorCount = sectorCount;
buf_iterate(vp, hfs_invalidate_block_numbers_callback, BUF_SCAN_DIRTY|BUF_SCAN_CLEAN, &args);
}
static int
hfs_copy_extent(
struct hfsmount *hfsmp,
struct vnode *vp,
u_int32_t oldStart,
u_int32_t newStart,
u_int32_t blockCount,
vfs_context_t context)
{
int err = 0;
size_t bufferSize;
void *buffer = NULL;
struct vfsioattr ioattr;
buf_t bp = NULL;
off_t resid;
size_t ioSize;
u_int32_t ioSizeSectors;
daddr64_t srcSector, destSector;
u_int32_t sectorsPerBlock = hfsmp->blockSize / hfsmp->hfs_logical_block_size;
#if CONFIG_PROTECT
int cpenabled = 0;
#endif
struct cnode *cp = VTOC(vp);
if (cp != hfsmp->hfs_allocation_cp && cp->c_lockowner != current_thread())
panic("hfs_copy_extent: vp=%p (cp=%p) not owned?\n", vp, cp);
#if CONFIG_PROTECT
if (!vnode_issystem (vp) && vnode_isreg(vp) &&
cp_fs_protected (hfsmp->hfs_mp)) {
int cp_err = 0;
cp_err = cp_handle_relocate (cp);
if (cp_err) {
return cp_err;
}
else {
cpenabled = 1;
}
}
#endif
vfs_ioattr(hfsmp->hfs_mp, &ioattr);
bufferSize = MIN(ioattr.io_maxreadcnt, ioattr.io_maxwritecnt);
if (kmem_alloc(kernel_map, (vm_offset_t*) &buffer, bufferSize))
return ENOMEM;
bp = buf_alloc(hfsmp->hfs_devvp);
buf_setdataptr(bp, (uintptr_t)buffer);
resid = (off_t) blockCount * (off_t) hfsmp->blockSize;
srcSector = (daddr64_t) oldStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;
destSector = (daddr64_t) newStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;
while (resid > 0) {
ioSize = MIN(bufferSize, (size_t) resid);
ioSizeSectors = ioSize / hfsmp->hfs_logical_block_size;
buf_reset(bp, B_READ);
buf_setsize(bp, ioSize);
buf_setcount(bp, ioSize);
buf_setblkno(bp, srcSector);
buf_setlblkno(bp, srcSector);
#if CONFIG_PROTECT
if (cpenabled) {
buf_setcpaddr (bp, cp->c_cpentry);
}
#endif
err = VNOP_STRATEGY(bp);
if (!err)
err = buf_biowait(bp);
if (err) {
printf("hfs_copy_extent: Error %d from VNOP_STRATEGY (read)\n", err);
break;
}
buf_reset(bp, B_WRITE);
buf_setsize(bp, ioSize);
buf_setcount(bp, ioSize);
buf_setblkno(bp, destSector);
buf_setlblkno(bp, destSector);
if (vnode_issystem(vp) && journal_uses_fua(hfsmp->jnl))
buf_markfua(bp);
#if CONFIG_PROTECT
if (cpenabled) {
buf_setcpaddr (bp, cp->c_cpentry);
}
#endif
vnode_startwrite(hfsmp->hfs_devvp);
err = VNOP_STRATEGY(bp);
if (!err)
err = buf_biowait(bp);
if (err) {
printf("hfs_copy_extent: Error %d from VNOP_STRATEGY (write)\n", err);
break;
}
resid -= ioSize;
srcSector += ioSizeSectors;
destSector += ioSizeSectors;
}
if (bp)
buf_free(bp);
if (buffer)
kmem_free(kernel_map, (vm_offset_t)buffer, bufferSize);
if (vnode_issystem(vp) && !journal_uses_fua(hfsmp->jnl)) {
err = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
if (err) {
printf("hfs_copy_extent: DKIOCSYNCHRONIZECACHE failed (%d)\n", err);
err = 0;
}
}
if (!err)
hfs_invalidate_sectors(vp, (daddr64_t)oldStart*sectorsPerBlock, (daddr64_t)blockCount*sectorsPerBlock);
return err;
}
struct hfs_reclaim_extent_info {
struct vnode *vp;
u_int32_t fileID;
u_int8_t forkType;
u_int8_t is_dirlink;
u_int8_t is_sysfile;
u_int8_t is_xattr;
u_int8_t extent_index;
int lockflags;
u_int32_t blocks_relocated;
u_int32_t recStartBlock;
u_int32_t cur_blockCount;
struct filefork *catalog_fp;
union record {
HFSPlusExtentRecord overflow;
HFSPlusAttrRecord xattr;
} record;
HFSPlusExtentDescriptor *extents;
struct cat_desc *dirlink_desc;
struct cat_attr *dirlink_attr;
struct filefork *dirlink_fork;
struct BTreeIterator *iterator;
struct FSBufferDescriptor btdata;
u_int16_t recordlen;
int overflow_count;
FCB *fcb;
};
static int
hfs_split_extent(struct hfs_reclaim_extent_info *extent_info, uint32_t newBlockCount)
{
int error = 0;
int index = extent_info->extent_index;
int i;
HFSPlusExtentDescriptor shift_extent;
HFSPlusExtentDescriptor last_extent;
HFSPlusExtentDescriptor *extents;
HFSPlusExtentRecord *extents_rec = NULL;
HFSPlusExtentKey *extents_key = NULL;
HFSPlusAttrRecord *xattr_rec = NULL;
HFSPlusAttrKey *xattr_key = NULL;
struct BTreeIterator iterator;
struct FSBufferDescriptor btdata;
uint16_t reclen;
uint32_t read_recStartBlock;
uint32_t write_recStartBlock;
Boolean create_record = false;
Boolean is_xattr;
is_xattr = extent_info->is_xattr;
extents = extent_info->extents;
if (hfs_resize_debug) {
printf ("hfs_split_extent: Split record:%u recStartBlock=%u %u:(%u,%u) for %u blocks\n", extent_info->overflow_count, extent_info->recStartBlock, index, extents[index].startBlock, extents[index].blockCount, newBlockCount);
}
read_recStartBlock = extent_info->recStartBlock;
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (extents[i].blockCount == 0) {
break;
}
read_recStartBlock += extents[i].blockCount;
}
if (index == kHFSPlusExtentDensity-1) {
shift_extent.startBlock = extents[index].startBlock + newBlockCount;
shift_extent.blockCount = extents[index].blockCount - newBlockCount;
} else {
shift_extent = extents[kHFSPlusExtentDensity-1];
for (i = kHFSPlusExtentDensity-2; i > index; i--) {
if (hfs_resize_debug) {
if (extents[i].blockCount) {
printf ("hfs_split_extent: Shift %u:(%u,%u) to %u:(%u,%u)\n", i, extents[i].startBlock, extents[i].blockCount, i+1, extents[i].startBlock, extents[i].blockCount);
}
}
extents[i+1] = extents[i];
}
}
if (index == kHFSPlusExtentDensity-1) {
} else {
extents[index+1].startBlock = extents[index].startBlock + newBlockCount;
extents[index+1].blockCount = extents[index].blockCount - newBlockCount;
}
extents[index].blockCount = newBlockCount;
if (hfs_resize_debug) {
printf ("hfs_split_extent: Split %u:(%u,%u) and ", index, extents[index].startBlock, extents[index].blockCount);
if (index != kHFSPlusExtentDensity-1) {
printf ("%u:(%u,%u)\n", index+1, extents[index+1].startBlock, extents[index+1].blockCount);
} else {
printf ("overflow:(%u,%u)\n", shift_extent.startBlock, shift_extent.blockCount);
}
}
if (extent_info->catalog_fp == NULL) {
error = BTReplaceRecord(extent_info->fcb, extent_info->iterator,
&(extent_info->btdata), extent_info->recordlen);
if (error) {
printf ("hfs_split_extent: fileID=%u BTReplaceRecord returned error=%d\n", extent_info->fileID, error);
goto out;
}
}
if (shift_extent.blockCount == 0) {
if (hfs_resize_debug) {
printf ("hfs_split_extent: No extent entry to be shifted into overflow records\n");
}
error = 0;
goto out;
}
bzero(&iterator, sizeof(iterator));
if (is_xattr) {
xattr_key = (HFSPlusAttrKey *)&(iterator.key);
bcopy((HFSPlusAttrKey *)&(extent_info->iterator->key), xattr_key, sizeof(HFSPlusAttrKey));
MALLOC(xattr_rec, HFSPlusAttrRecord *,
sizeof(HFSPlusAttrRecord), M_TEMP, M_WAITOK);
if (xattr_rec == NULL) {
error = ENOMEM;
goto out;
}
btdata.bufferAddress = xattr_rec;
btdata.itemSize = sizeof(HFSPlusAttrRecord);
btdata.itemCount = 1;
extents = xattr_rec->overflowExtents.extents;
} else {
extents_key = (HFSPlusExtentKey *) &(iterator.key);
extents_key->keyLength = kHFSPlusExtentKeyMaximumLength;
extents_key->forkType = extent_info->forkType;
extents_key->fileID = extent_info->fileID;
MALLOC(extents_rec, HFSPlusExtentRecord *,
sizeof(HFSPlusExtentRecord), M_TEMP, M_WAITOK);
if (extents_rec == NULL) {
error = ENOMEM;
goto out;
}
btdata.bufferAddress = extents_rec;
btdata.itemSize = sizeof(HFSPlusExtentRecord);
btdata.itemCount = 1;
extents = extents_rec[0];
}
while (shift_extent.blockCount) {
if (hfs_resize_debug) {
printf ("hfs_split_extent: Will shift (%u,%u) into record with startBlock=%u\n", shift_extent.startBlock, shift_extent.blockCount, read_recStartBlock);
}
if (is_xattr) {
xattr_key->startBlock = read_recStartBlock;
} else {
extents_key->startBlock = read_recStartBlock;
}
error = BTSearchRecord(extent_info->fcb, &iterator, &btdata, &reclen, &iterator);
if (error) {
if (error != btNotFound) {
printf ("hfs_split_extent: fileID=%u startBlock=%u BTSearchRecord error=%d\n", extent_info->fileID, read_recStartBlock, error);
goto out;
}
create_record = true;
}
write_recStartBlock = read_recStartBlock - shift_extent.blockCount;
if (hfs_resize_debug) {
if (create_record) {
printf ("hfs_split_extent: No records found for startBlock=%u, will create new with startBlock=%u\n", read_recStartBlock, write_recStartBlock);
}
}
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (extents[i].blockCount == 0) {
break;
}
read_recStartBlock += extents[i].blockCount;
}
if (create_record == true) {
bzero(extents, sizeof(HFSPlusExtentRecord));
extents[0] = shift_extent;
shift_extent.startBlock = shift_extent.blockCount = 0;
if (is_xattr) {
xattr_rec->recordType = kHFSPlusAttrExtents;
xattr_rec->overflowExtents.reserved = 0;
reclen = sizeof(HFSPlusAttrExtents);
} else {
reclen = sizeof(HFSPlusExtentRecord);
}
} else {
last_extent = extents[kHFSPlusExtentDensity-1];
for (i = kHFSPlusExtentDensity-2; i >= 0; i--) {
extents[i+1] = extents[i];
}
extents[0] = shift_extent;
if (hfs_resize_debug) {
printf ("hfs_split_extent: Shift overflow=(%u,%u) to record with updated startBlock=%u\n", shift_extent.startBlock, shift_extent.blockCount, write_recStartBlock);
}
shift_extent = last_extent;
error = BTDeleteRecord(extent_info->fcb, &iterator);
if (error) {
printf ("hfs_split_extent: fileID=%u startBlock=%u BTDeleteRecord error=%d\n", extent_info->fileID, read_recStartBlock, error);
goto out;
}
if (hfs_resize_debug) {
printf ("hfs_split_extent: Deleted record with startBlock=%u\n", (is_xattr ? xattr_key->startBlock : extents_key->startBlock));
}
}
bzero(&iterator.hint, sizeof(iterator.hint));
if (is_xattr) {
xattr_key->startBlock = write_recStartBlock;
} else {
extents_key->startBlock = write_recStartBlock;
}
error = BTInsertRecord(extent_info->fcb, &iterator, &btdata, reclen);
if (error) {
printf ("hfs_split_extent: fileID=%u, startBlock=%u BTInsertRecord error=%d\n", extent_info->fileID, write_recStartBlock, error);
goto out;
}
if (hfs_resize_debug) {
printf ("hfs_split_extent: Inserted extent record with startBlock=%u\n", write_recStartBlock);
}
}
BTFlushPath(extent_info->fcb);
out:
if (extents_rec) {
FREE (extents_rec, M_TEMP);
}
if (xattr_rec) {
FREE (xattr_rec, M_TEMP);
}
return error;
}
static int
hfs_reclaim_extent(struct hfsmount *hfsmp, const u_long allocLimit, struct hfs_reclaim_extent_info *extent_info, vfs_context_t context)
{
int error = 0;
int index;
struct cnode *cp;
u_int32_t oldStartBlock;
u_int32_t oldBlockCount;
u_int32_t newStartBlock;
u_int32_t newBlockCount;
u_int32_t alloc_flags;
int blocks_allocated = false;
index = extent_info->extent_index;
cp = VTOC(extent_info->vp);
oldStartBlock = extent_info->extents[index].startBlock;
oldBlockCount = extent_info->extents[index].blockCount;
if (0 && hfs_resize_debug) {
printf ("hfs_reclaim_extent: Examine record:%u recStartBlock=%u, %u:(%u,%u)\n", extent_info->overflow_count, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount);
}
if ((oldStartBlock + oldBlockCount) <= allocLimit) {
extent_info->cur_blockCount += oldBlockCount;
return error;
}
error = hfs_start_transaction(hfsmp);
if (error) {
return error;
}
extent_info->lockflags = hfs_systemfile_lock(hfsmp, extent_info->lockflags, HFS_EXCLUSIVE_LOCK);
if (oldStartBlock < allocLimit) {
newBlockCount = allocLimit - oldStartBlock;
error = hfs_split_extent(extent_info, newBlockCount);
if (error == 0) {
goto out;
}
}
alloc_flags = HFS_ALLOC_FORCECONTIG | HFS_ALLOC_SKIPFREEBLKS;
if (extent_info->is_sysfile) {
alloc_flags |= HFS_ALLOC_METAZONE;
}
error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount, alloc_flags,
&newStartBlock, &newBlockCount);
if ((extent_info->is_sysfile == false) &&
((error == dskFulErr) || (error == ENOSPC))) {
alloc_flags |= HFS_ALLOC_METAZONE;
error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount,
alloc_flags, &newStartBlock, &newBlockCount);
}
if ((error == dskFulErr) || (error == ENOSPC)) {
alloc_flags &= ~HFS_ALLOC_FORCECONTIG;
error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount,
alloc_flags, &newStartBlock, &newBlockCount);
if (error) {
printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) BlockAllocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);
goto out;
}
blocks_allocated = true;
error = hfs_split_extent(extent_info, newBlockCount);
if (error) {
printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) split error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);
goto out;
}
oldBlockCount = newBlockCount;
}
if (error) {
printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) contig BlockAllocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);
goto out;
}
blocks_allocated = true;
error = hfs_copy_extent(hfsmp, extent_info->vp, oldStartBlock,
newStartBlock, newBlockCount, context);
if (error) {
printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u)=>(%u,%u) hfs_copy_extent error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, newStartBlock, newBlockCount, error);
goto out;
}
extent_info->extents[index].startBlock = newStartBlock;
if (extent_info->catalog_fp) {
if (extent_info->is_dirlink) {
error = cat_update_dirlink(hfsmp, extent_info->forkType,
extent_info->dirlink_desc, extent_info->dirlink_attr,
&(extent_info->dirlink_fork->ff_data));
} else {
cp->c_flag |= C_MODIFIED;
if (extent_info->is_sysfile) {
error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
}
}
} else {
error = BTReplaceRecord(extent_info->fcb, extent_info->iterator,
&(extent_info->btdata), extent_info->recordlen);
}
if (error) {
printf ("hfs_reclaim_extent: fileID=%u, update record error=%u\n", extent_info->fileID, error);
goto out;
}
error = BlockDeallocate(hfsmp, oldStartBlock, oldBlockCount, HFS_ALLOC_SKIPFREEBLKS);
if (error) {
printf ("hfs_reclaim_extent: fileID=%u start=%u, %u:(%u,%u) BlockDeallocate error=%d\n", extent_info->fileID, extent_info->recStartBlock, index, oldStartBlock, oldBlockCount, error);
goto out;
}
extent_info->blocks_relocated += newBlockCount;
if (hfs_resize_debug) {
printf ("hfs_reclaim_extent: Relocated record:%u %u:(%u,%u) to (%u,%u)\n", extent_info->overflow_count, index, oldStartBlock, oldBlockCount, newStartBlock, newBlockCount);
}
out:
if (error != 0) {
if (blocks_allocated == true) {
BlockDeallocate(hfsmp, newStartBlock, newBlockCount, HFS_ALLOC_SKIPFREEBLKS);
}
} else {
extent_info->cur_blockCount += newBlockCount;
}
hfs_systemfile_unlock(hfsmp, extent_info->lockflags);
if ((error == 0) &&
(extent_info->overflow_count < kHFSPlusExtentDensity) &&
(extent_info->is_sysfile == false)) {
(void) hfs_update(extent_info->vp, MNT_WAIT);
}
hfs_end_transaction(hfsmp);
return error;
}
static void
hfs_truncatefs_progress(struct hfsmount *hfsmp)
{
u_int32_t cur_progress;
hfs_resize_progress(hfsmp, &cur_progress);
if (cur_progress > (hfsmp->hfs_resize_progress + 9)) {
printf("hfs_truncatefs: %d%% done...\n", cur_progress);
hfsmp->hfs_resize_progress = cur_progress;
}
return;
}
static int
hfs_reclaim_file(struct hfsmount *hfsmp, struct vnode *vp, u_int32_t fileID,
u_int8_t forktype, u_long allocLimit, vfs_context_t context)
{
int error = 0;
struct hfs_reclaim_extent_info *extent_info;
int i;
int lockflags = 0;
struct cnode *cp;
struct filefork *fp;
int took_truncate_lock = false;
int release_desc = false;
HFSPlusExtentKey *key;
if (vp == NULL) {
return 0;
}
cp = VTOC(vp);
MALLOC(extent_info, struct hfs_reclaim_extent_info *,
sizeof(struct hfs_reclaim_extent_info), M_TEMP, M_WAITOK);
if (extent_info == NULL) {
return ENOMEM;
}
bzero(extent_info, sizeof(struct hfs_reclaim_extent_info));
extent_info->vp = vp;
extent_info->fileID = fileID;
extent_info->forkType = forktype;
extent_info->is_sysfile = vnode_issystem(vp);
if (vnode_isdir(vp) && (cp->c_flag & C_HARDLINK)) {
extent_info->is_dirlink = true;
}
lockflags = SFL_BITMAP | SFL_EXTENTS;
if ((fileID == kHFSCatalogFileID) || (extent_info->is_dirlink == true)) {
lockflags |= SFL_CATALOG;
} else if (fileID == kHFSAttributesFileID) {
lockflags |= SFL_ATTRIBUTE;
} else if (fileID == kHFSStartupFileID) {
lockflags |= SFL_STARTUP;
}
extent_info->lockflags = lockflags;
extent_info->fcb = VTOF(hfsmp->hfs_extents_vp);
if (extent_info->is_sysfile) {
error = hfs_journal_flush(hfsmp, TRUE);
if (error) {
printf ("hfs_reclaim_file: journal_flush returned %d\n", error);
goto out;
}
} else if (extent_info->is_dirlink == false) {
buf_flushdirtyblks(vp, 0, BUF_SKIP_LOCKED, "hfs_reclaim_file");
hfs_unlock(cp);
hfs_lock_truncate(cp, HFS_EXCLUSIVE_LOCK);
took_truncate_lock = true;
(void) cluster_push(vp, 0);
error = hfs_lock(cp, HFS_FORCE_LOCK);
if (error) {
goto out;
}
if (cp->c_flag & C_NOEXISTS) {
error = 0;
goto out;
}
error = vnode_waitforwrites(vp, 0, 0, 0, "hfs_reclaim_file");
if (error) {
goto out;
}
}
if (hfs_resize_debug) {
printf("hfs_reclaim_file: === Start reclaiming %sfork for %sid=%u ===\n", (forktype ? "rsrc" : "data"), (extent_info->is_dirlink ? "dirlink" : "file"), fileID);
}
if (extent_info->is_dirlink) {
MALLOC(extent_info->dirlink_desc, struct cat_desc *,
sizeof(struct cat_desc), M_TEMP, M_WAITOK);
MALLOC(extent_info->dirlink_attr, struct cat_attr *,
sizeof(struct cat_attr), M_TEMP, M_WAITOK);
MALLOC(extent_info->dirlink_fork, struct filefork *,
sizeof(struct filefork), M_TEMP, M_WAITOK);
if ((extent_info->dirlink_desc == NULL) ||
(extent_info->dirlink_attr == NULL) ||
(extent_info->dirlink_fork == NULL)) {
error = ENOMEM;
goto out;
}
fp = extent_info->dirlink_fork;
bzero(extent_info->dirlink_fork, sizeof(struct filefork));
extent_info->dirlink_fork->ff_cp = cp;
lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);
error = cat_lookup_dirlink(hfsmp, fileID, forktype,
extent_info->dirlink_desc, extent_info->dirlink_attr,
&(extent_info->dirlink_fork->ff_data));
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
printf ("hfs_reclaim_file: cat_lookup_dirlink for fileID=%u returned error=%u\n", fileID, error);
goto out;
}
release_desc = true;
} else {
fp = VTOF(vp);
}
extent_info->catalog_fp = fp;
extent_info->recStartBlock = 0;
extent_info->extents = extent_info->catalog_fp->ff_extents;
for (i = 0; i < kHFSPlusExtentDensity; ++i) {
if (fp->ff_extents[i].blockCount == 0) {
break;
}
extent_info->extent_index = i;
error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);
if (error) {
printf ("hfs_reclaim_file: fileID=%u #%d %u:(%u,%u) hfs_reclaim_extent error=%d\n", fileID, extent_info->overflow_count, i, fp->ff_extents[i].startBlock, fp->ff_extents[i].blockCount, error);
goto out;
}
}
if (fp->ff_blocks <= extent_info->cur_blockCount) {
if (0 && hfs_resize_debug) {
printf ("hfs_reclaim_file: Nothing more to relocate, offset=%d, ff_blocks=%u, cur_blockCount=%u\n", i, fp->ff_blocks, extent_info->cur_blockCount);
}
goto out;
}
if (hfs_resize_debug) {
printf ("hfs_reclaim_file: Will check overflow records, offset=%d, ff_blocks=%u, cur_blockCount=%u\n", i, fp->ff_blocks, extent_info->cur_blockCount);
}
MALLOC(extent_info->iterator, struct BTreeIterator *, sizeof(struct BTreeIterator), M_TEMP, M_WAITOK);
if (extent_info->iterator == NULL) {
error = ENOMEM;
goto out;
}
bzero(extent_info->iterator, sizeof(struct BTreeIterator));
key = (HFSPlusExtentKey *) &(extent_info->iterator->key);
key->keyLength = kHFSPlusExtentKeyMaximumLength;
key->forkType = forktype;
key->fileID = fileID;
key->startBlock = extent_info->cur_blockCount;
extent_info->btdata.bufferAddress = extent_info->record.overflow;
extent_info->btdata.itemSize = sizeof(HFSPlusExtentRecord);
extent_info->btdata.itemCount = 1;
extent_info->catalog_fp = NULL;
lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);
error = BTSearchRecord(extent_info->fcb, extent_info->iterator,
&(extent_info->btdata), &(extent_info->recordlen),
extent_info->iterator);
hfs_systemfile_unlock(hfsmp, lockflags);
while (error == 0) {
extent_info->overflow_count++;
extent_info->recStartBlock = key->startBlock;
extent_info->extents = extent_info->record.overflow;
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (extent_info->record.overflow[i].blockCount == 0) {
goto out;
}
extent_info->extent_index = i;
error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);
if (error) {
printf ("hfs_reclaim_file: fileID=%u #%d %u:(%u,%u) hfs_reclaim_extent error=%d\n", fileID, extent_info->overflow_count, i, extent_info->record.overflow[i].startBlock, extent_info->record.overflow[i].blockCount, error);
goto out;
}
}
lockflags = hfs_systemfile_lock(hfsmp, lockflags, HFS_EXCLUSIVE_LOCK);
error = BTIterateRecord(extent_info->fcb, kBTreeNextRecord,
extent_info->iterator, &(extent_info->btdata),
&(extent_info->recordlen));
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
break;
}
if ((key->fileID != fileID) || (key->forkType != forktype)) {
break;
}
}
if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {
error = 0;
}
out:
if (extent_info->blocks_relocated) {
hfsmp->hfs_resize_blocksmoved += extent_info->blocks_relocated;
hfs_truncatefs_progress(hfsmp);
if (fileID < kHFSFirstUserCatalogNodeID) {
printf ("hfs_reclaim_file: Relocated %u blocks from fileID=%u on \"%s\"\n",
extent_info->blocks_relocated, fileID, hfsmp->vcbVN);
}
}
if (extent_info->iterator) {
FREE(extent_info->iterator, M_TEMP);
}
if (release_desc == true) {
cat_releasedesc(extent_info->dirlink_desc);
}
if (extent_info->dirlink_desc) {
FREE(extent_info->dirlink_desc, M_TEMP);
}
if (extent_info->dirlink_attr) {
FREE(extent_info->dirlink_attr, M_TEMP);
}
if (extent_info->dirlink_fork) {
FREE(extent_info->dirlink_fork, M_TEMP);
}
if ((extent_info->blocks_relocated != 0) && (extent_info->is_sysfile == false)) {
(void) hfs_update(vp, MNT_WAIT);
}
if (took_truncate_lock) {
hfs_unlock_truncate(cp, 0);
}
if (extent_info) {
FREE(extent_info, M_TEMP);
}
if (hfs_resize_debug) {
printf("hfs_reclaim_file: === Finished relocating %sfork for fileid=%u (error=%d) ===\n", (forktype ? "rsrc" : "data"), fileID, error);
}
return error;
}
struct hfs_journal_relocate_args {
struct hfsmount *hfsmp;
vfs_context_t context;
u_int32_t newStartBlock;
};
static errno_t
hfs_journal_relocate_callback(void *_args)
{
int error;
struct hfs_journal_relocate_args *args = _args;
struct hfsmount *hfsmp = args->hfsmp;
buf_t bp;
JournalInfoBlock *jibp;
error = buf_meta_bread(hfsmp->hfs_devvp,
hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
hfsmp->blockSize, vfs_context_ucred(args->context), &bp);
if (error) {
printf("hfs_reclaim_journal_file: failed to read JIB (%d)\n", error);
if (bp) {
buf_brelse(bp);
}
return error;
}
jibp = (JournalInfoBlock*) buf_dataptr(bp);
jibp->offset = SWAP_BE64((u_int64_t)args->newStartBlock * hfsmp->blockSize);
jibp->size = SWAP_BE64(hfsmp->jnl_size);
if (journal_uses_fua(hfsmp->jnl))
buf_markfua(bp);
error = buf_bwrite(bp);
if (error) {
printf("hfs_reclaim_journal_file: failed to write JIB (%d)\n", error);
return error;
}
if (!journal_uses_fua(hfsmp->jnl)) {
error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, args->context);
if (error) {
printf("hfs_reclaim_journal_file: DKIOCSYNCHRONIZECACHE failed (%d)\n", error);
error = 0;
}
}
return error;
}
static int
hfs_reclaim_journal_file(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)
{
int error;
int journal_err;
int lockflags;
u_int32_t oldStartBlock;
u_int32_t newStartBlock;
u_int32_t oldBlockCount;
u_int32_t newBlockCount;
struct cat_desc journal_desc;
struct cat_attr journal_attr;
struct cat_fork journal_fork;
struct hfs_journal_relocate_args callback_args;
if (hfsmp->jnl_start + (hfsmp->jnl_size / hfsmp->blockSize) <= allocLimit) {
return 0;
}
error = hfs_start_transaction(hfsmp);
if (error) {
printf("hfs_reclaim_journal_file: hfs_start_transaction returned %d\n", error);
return error;
}
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
oldBlockCount = hfsmp->jnl_size / hfsmp->blockSize;
error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount,
HFS_ALLOC_METAZONE | HFS_ALLOC_FORCECONTIG | HFS_ALLOC_SKIPFREEBLKS,
&newStartBlock, &newBlockCount);
if (error) {
printf("hfs_reclaim_journal_file: BlockAllocate returned %d\n", error);
goto fail;
}
if (newBlockCount != oldBlockCount) {
printf("hfs_reclaim_journal_file: newBlockCount != oldBlockCount (%u, %u)\n", newBlockCount, oldBlockCount);
goto free_fail;
}
error = BlockDeallocate(hfsmp, hfsmp->jnl_start, oldBlockCount, HFS_ALLOC_SKIPFREEBLKS);
if (error) {
printf("hfs_reclaim_journal_file: BlockDeallocate returned %d\n", error);
goto free_fail;
}
error = cat_idlookup(hfsmp, hfsmp->hfs_jnlfileid, 1, &journal_desc, &journal_attr, &journal_fork);
if (error) {
printf("hfs_reclaim_journal_file: cat_idlookup returned %d\n", error);
goto free_fail;
}
oldStartBlock = journal_fork.cf_extents[0].startBlock;
journal_fork.cf_size = newBlockCount * hfsmp->blockSize;
journal_fork.cf_extents[0].startBlock = newStartBlock;
journal_fork.cf_extents[0].blockCount = newBlockCount;
journal_fork.cf_blocks = newBlockCount;
error = cat_update(hfsmp, &journal_desc, &journal_attr, &journal_fork, NULL);
cat_releasedesc(&journal_desc);
if (error) {
printf("hfs_reclaim_journal_file: cat_update returned %d\n", error);
goto free_fail;
}
callback_args.hfsmp = hfsmp;
callback_args.context = context;
callback_args.newStartBlock = newStartBlock;
error = journal_relocate(hfsmp->jnl, (off_t)newStartBlock*hfsmp->blockSize,
(off_t)newBlockCount*hfsmp->blockSize, 0,
hfs_journal_relocate_callback, &callback_args);
if (error) {
printf("hfs_reclaim_journal_file: journal_relocate returned %d\n", error);
goto fail;
}
hfsmp->jnl_start = newStartBlock;
hfsmp->jnl_size = (off_t)newBlockCount * hfsmp->blockSize;
hfs_systemfile_unlock(hfsmp, lockflags);
error = hfs_end_transaction(hfsmp);
if (error) {
printf("hfs_reclaim_journal_file: hfs_end_transaction returned %d\n", error);
}
hfsmp->hfs_resize_blocksmoved += oldBlockCount;
hfs_truncatefs_progress(hfsmp);
if (!error) {
printf ("hfs_reclaim_journal_file: Relocated %u blocks from journal on \"%s\"\n",
oldBlockCount, hfsmp->vcbVN);
if (hfs_resize_debug) {
printf ("hfs_reclaim_journal_file: Successfully relocated journal from (%u,%u) to (%u,%u)\n", oldStartBlock, oldBlockCount, newStartBlock, newBlockCount);
}
}
return error;
free_fail:
journal_err = BlockDeallocate(hfsmp, newStartBlock, newBlockCount, HFS_ALLOC_SKIPFREEBLKS);
if (journal_err) {
printf("hfs_reclaim_journal_file: BlockDeallocate returned %d\n", error);
hfs_mark_volume_inconsistent(hfsmp);
}
fail:
hfs_systemfile_unlock(hfsmp, lockflags);
(void) hfs_end_transaction(hfsmp);
if (hfs_resize_debug) {
printf ("hfs_reclaim_journal_file: Error relocating journal file (error=%d)\n", error);
}
return error;
}
static int
hfs_reclaim_journal_info_block(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)
{
int error;
int journal_err;
int lockflags;
u_int32_t oldBlock;
u_int32_t newBlock;
u_int32_t blockCount;
struct cat_desc jib_desc;
struct cat_attr jib_attr;
struct cat_fork jib_fork;
buf_t old_bp, new_bp;
if (hfsmp->vcbJinfoBlock <= allocLimit) {
return 0;
}
error = hfs_start_transaction(hfsmp);
if (error) {
printf("hfs_reclaim_journal_info_block: hfs_start_transaction returned %d\n", error);
return error;
}
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
error = BlockAllocate(hfsmp, 1, 1, 1,
HFS_ALLOC_METAZONE | HFS_ALLOC_FORCECONTIG | HFS_ALLOC_SKIPFREEBLKS,
&newBlock, &blockCount);
if (error) {
printf("hfs_reclaim_journal_info_block: BlockAllocate returned %d\n", error);
goto fail;
}
if (blockCount != 1) {
printf("hfs_reclaim_journal_info_block: blockCount != 1 (%u)\n", blockCount);
goto free_fail;
}
error = BlockDeallocate(hfsmp, hfsmp->vcbJinfoBlock, 1, HFS_ALLOC_SKIPFREEBLKS);
if (error) {
printf("hfs_reclaim_journal_info_block: BlockDeallocate returned %d\n", error);
goto free_fail;
}
error = buf_meta_bread(hfsmp->hfs_devvp,
hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
hfsmp->blockSize, vfs_context_ucred(context), &old_bp);
if (error) {
printf("hfs_reclaim_journal_info_block: failed to read JIB (%d)\n", error);
if (old_bp) {
buf_brelse(old_bp);
}
goto free_fail;
}
new_bp = buf_getblk(hfsmp->hfs_devvp,
newBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
hfsmp->blockSize, 0, 0, BLK_META);
bcopy((char*)buf_dataptr(old_bp), (char*)buf_dataptr(new_bp), hfsmp->blockSize);
buf_brelse(old_bp);
if (journal_uses_fua(hfsmp->jnl))
buf_markfua(new_bp);
error = buf_bwrite(new_bp);
if (error) {
printf("hfs_reclaim_journal_info_block: failed to write new JIB (%d)\n", error);
goto free_fail;
}
if (!journal_uses_fua(hfsmp->jnl)) {
error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
if (error) {
printf("hfs_reclaim_journal_info_block: DKIOCSYNCHRONIZECACHE failed (%d)\n", error);
}
}
error = cat_idlookup(hfsmp, hfsmp->hfs_jnlinfoblkid, 1, &jib_desc, &jib_attr, &jib_fork);
if (error) {
printf("hfs_reclaim_journal_file: cat_idlookup returned %d\n", error);
goto fail;
}
oldBlock = jib_fork.cf_extents[0].startBlock;
jib_fork.cf_size = hfsmp->blockSize;
jib_fork.cf_extents[0].startBlock = newBlock;
jib_fork.cf_extents[0].blockCount = 1;
jib_fork.cf_blocks = 1;
error = cat_update(hfsmp, &jib_desc, &jib_attr, &jib_fork, NULL);
cat_releasedesc(&jib_desc);
if (error) {
printf("hfs_reclaim_journal_info_block: cat_update returned %d\n", error);
goto fail;
}
hfsmp->vcbJinfoBlock = newBlock;
error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
if (error) {
printf("hfs_reclaim_journal_info_block: hfs_flushvolumeheader returned %d\n", error);
goto fail;
}
hfs_systemfile_unlock(hfsmp, lockflags);
error = hfs_end_transaction(hfsmp);
if (error) {
printf("hfs_reclaim_journal_info_block: hfs_end_transaction returned %d\n", error);
}
error = hfs_journal_flush(hfsmp, FALSE);
if (error) {
printf("hfs_reclaim_journal_info_block: journal_flush returned %d\n", error);
}
hfsmp->hfs_resize_blocksmoved += 1;
hfs_truncatefs_progress(hfsmp);
if (!error) {
printf ("hfs_reclaim_journal_info: Relocated 1 block from journal info on \"%s\"\n",
hfsmp->vcbVN);
if (hfs_resize_debug) {
printf ("hfs_reclaim_journal_info_block: Successfully relocated journal info block from (%u,%u) to (%u,%u)\n", oldBlock, blockCount, newBlock, blockCount);
}
}
return error;
free_fail:
journal_err = BlockDeallocate(hfsmp, newBlock, blockCount, HFS_ALLOC_SKIPFREEBLKS);
if (journal_err) {
printf("hfs_reclaim_journal_info_block: BlockDeallocate returned %d\n", error);
hfs_mark_volume_inconsistent(hfsmp);
}
fail:
hfs_systemfile_unlock(hfsmp, lockflags);
(void) hfs_end_transaction(hfsmp);
if (hfs_resize_debug) {
printf ("hfs_reclaim_journal_info_block: Error relocating journal info block (error=%d)\n", error);
}
return error;
}
static int
hfs_reclaim_xattr(struct hfsmount *hfsmp, struct vnode *vp, u_int32_t fileID, u_int32_t allocLimit, vfs_context_t context)
{
int error = 0;
struct hfs_reclaim_extent_info *extent_info;
int i;
HFSPlusAttrKey *key;
int *lockflags;
if (hfs_resize_debug) {
printf("hfs_reclaim_xattr: === Start reclaiming xattr for id=%u ===\n", fileID);
}
MALLOC(extent_info, struct hfs_reclaim_extent_info *,
sizeof(struct hfs_reclaim_extent_info), M_TEMP, M_WAITOK);
if (extent_info == NULL) {
return ENOMEM;
}
bzero(extent_info, sizeof(struct hfs_reclaim_extent_info));
extent_info->vp = vp;
extent_info->fileID = fileID;
extent_info->is_xattr = true;
extent_info->is_sysfile = vnode_issystem(vp);
extent_info->fcb = VTOF(hfsmp->hfs_attribute_vp);
lockflags = &(extent_info->lockflags);
*lockflags = SFL_ATTRIBUTE | SFL_BITMAP;
MALLOC(extent_info->iterator, struct BTreeIterator *,
sizeof(struct BTreeIterator), M_TEMP, M_WAITOK);
if (extent_info->iterator == NULL) {
error = ENOMEM;
goto out;
}
bzero(extent_info->iterator, sizeof(struct BTreeIterator));
key = (HFSPlusAttrKey *)&(extent_info->iterator->key);
error = hfs_buildattrkey(fileID, NULL, key);
if (error) {
goto out;
}
extent_info->btdata.bufferAddress = &(extent_info->record.xattr);
extent_info->btdata.itemSize = sizeof(HFSPlusAttrRecord);
extent_info->btdata.itemCount = 1;
hfs_lock_truncate(VTOC(hfsmp->hfs_attrdata_vp), HFS_EXCLUSIVE_LOCK);
(void)cluster_push(hfsmp->hfs_attrdata_vp, 0);
error = vnode_waitforwrites(hfsmp->hfs_attrdata_vp, 0, 0, 0, "hfs_reclaim_xattr");
hfs_unlock_truncate(VTOC(hfsmp->hfs_attrdata_vp), 0);
if (error) {
goto out;
}
*lockflags = hfs_systemfile_lock(hfsmp, *lockflags, HFS_EXCLUSIVE_LOCK);
error = BTSearchRecord(extent_info->fcb, extent_info->iterator,
&(extent_info->btdata), &(extent_info->recordlen),
extent_info->iterator);
hfs_systemfile_unlock(hfsmp, *lockflags);
if (error) {
if (error != btNotFound) {
goto out;
}
error = 0;
}
while (1) {
*lockflags = hfs_systemfile_lock(hfsmp, *lockflags, HFS_EXCLUSIVE_LOCK);
error = BTIterateRecord(extent_info->fcb, kBTreeNextRecord,
extent_info->iterator, &(extent_info->btdata),
&(extent_info->recordlen));
hfs_systemfile_unlock(hfsmp, *lockflags);
if (error || key->fileID != fileID) {
if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {
error = 0;
}
break;
}
if ((extent_info->record.xattr.recordType != kHFSPlusAttrForkData) &&
(extent_info->record.xattr.recordType != kHFSPlusAttrExtents)) {
continue;
}
if (extent_info->record.xattr.recordType == kHFSPlusAttrForkData) {
extent_info->overflow_count = 0;
extent_info->extents = extent_info->record.xattr.forkData.theFork.extents;
} else if (extent_info->record.xattr.recordType == kHFSPlusAttrExtents) {
extent_info->overflow_count++;
extent_info->extents = extent_info->record.xattr.overflowExtents.extents;
}
extent_info->recStartBlock = key->startBlock;
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (extent_info->extents[i].blockCount == 0) {
break;
}
extent_info->extent_index = i;
error = hfs_reclaim_extent(hfsmp, allocLimit, extent_info, context);
if (error) {
printf ("hfs_reclaim_xattr: fileID=%u hfs_reclaim_extent error=%d\n", fileID, error);
goto out;
}
}
}
out:
if (extent_info->blocks_relocated) {
hfsmp->hfs_resize_blocksmoved += extent_info->blocks_relocated;
hfs_truncatefs_progress(hfsmp);
}
if (extent_info->iterator) {
FREE(extent_info->iterator, M_TEMP);
}
if (extent_info) {
FREE(extent_info, M_TEMP);
}
if (hfs_resize_debug) {
printf("hfs_reclaim_xattr: === Finished relocating xattr for fileid=%u (error=%d) ===\n", fileID, error);
}
return error;
}
static int
hfs_reclaim_xattrspace(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)
{
int error = 0;
FCB *fcb;
struct BTreeIterator *iterator = NULL;
struct FSBufferDescriptor btdata;
HFSPlusAttrKey *key;
HFSPlusAttrRecord rec;
int lockflags = 0;
cnid_t prev_fileid = 0;
struct vnode *vp;
int need_relocate;
int btree_operation;
u_int32_t files_moved = 0;
u_int32_t prev_blocksmoved;
int i;
fcb = VTOF(hfsmp->hfs_attribute_vp);
prev_blocksmoved = hfsmp->hfs_resize_blocksmoved;
if (kmem_alloc(kernel_map, (vm_offset_t *)&iterator, sizeof(*iterator))) {
return ENOMEM;
}
bzero(iterator, sizeof(*iterator));
key = (HFSPlusAttrKey *)&iterator->key;
btdata.bufferAddress = &rec;
btdata.itemSize = sizeof(rec);
btdata.itemCount = 1;
need_relocate = false;
btree_operation = kBTreeFirstRecord;
while (1) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE, HFS_SHARED_LOCK);
error = BTIterateRecord(fcb, btree_operation, iterator, &btdata, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {
error = 0;
}
break;
}
btree_operation = kBTreeNextRecord;
if (prev_fileid == key->fileID) {
continue;
}
need_relocate = false;
switch(rec.recordType) {
case kHFSPlusAttrForkData:
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (rec.forkData.theFork.extents[i].blockCount == 0) {
break;
}
if ((rec.forkData.theFork.extents[i].startBlock +
rec.forkData.theFork.extents[i].blockCount) > allocLimit) {
need_relocate = true;
break;
}
}
break;
case kHFSPlusAttrExtents:
for (i = 0; i < kHFSPlusExtentDensity; i++) {
if (rec.overflowExtents.extents[i].blockCount == 0) {
break;
}
if ((rec.overflowExtents.extents[i].startBlock +
rec.overflowExtents.extents[i].blockCount) > allocLimit) {
need_relocate = true;
break;
}
}
break;
};
if (need_relocate == false) {
continue;
}
if (hfs_vget(hfsmp, key->fileID, &vp, 0, 1) != 0) {
continue;
}
error = hfs_reclaim_xattr(hfsmp, vp, key->fileID, allocLimit, context);
hfs_unlock(VTOC(vp));
vnode_put(vp);
if (error) {
printf ("hfs_reclaim_xattrspace: Error relocating xattrs for fileid=%u (error=%d)\n", key->fileID, error);
break;
}
prev_fileid = key->fileID;
files_moved++;
}
if (files_moved) {
printf("hfs_reclaim_xattrspace: Relocated %u xattr blocks from %u files on \"%s\"\n",
(hfsmp->hfs_resize_blocksmoved - prev_blocksmoved),
files_moved, hfsmp->vcbVN);
}
kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
return error;
}
static int
hfs_reclaim_filespace(struct hfsmount *hfsmp, u_int32_t allocLimit, vfs_context_t context)
{
int error;
FCB *fcb;
struct BTreeIterator *iterator = NULL;
struct FSBufferDescriptor btdata;
int btree_operation;
int lockflags;
struct HFSPlusCatalogFile filerec;
struct vnode *vp;
struct vnode *rvp;
struct filefork *datafork;
u_int32_t files_moved = 0;
u_int32_t prev_blocksmoved;
fcb = VTOF(hfsmp->hfs_catalog_vp);
prev_blocksmoved = hfsmp->hfs_resize_blocksmoved;
if (kmem_alloc(kernel_map, (vm_offset_t *)&iterator, sizeof(*iterator))) {
return ENOMEM;
}
bzero(iterator, sizeof(*iterator));
btdata.bufferAddress = &filerec;
btdata.itemSize = sizeof(filerec);
btdata.itemCount = 1;
btree_operation = kBTreeFirstRecord;
while (1) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
error = BTIterateRecord(fcb, btree_operation, iterator, &btdata, NULL);
hfs_systemfile_unlock(hfsmp, lockflags);
if (error) {
if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {
error = 0;
}
break;
}
btree_operation = kBTreeNextRecord;
if (filerec.recordType != kHFSPlusFileRecord) {
continue;
}
if (hfs_file_extent_overlaps(hfsmp, allocLimit, &filerec) == false) {
continue;
}
if (hfs_vget(hfsmp, filerec.fileID, &vp, 0, 1) != 0) {
continue;
}
datafork = VTOF(vp);
if ((datafork && datafork->ff_blocks > 0) || vnode_isdir(vp)) {
error = hfs_reclaim_file(hfsmp, vp, filerec.fileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf ("hfs_reclaimspace: Error reclaiming datafork blocks of fileid=%u (error=%d)\n", filerec.fileID, error);
hfs_unlock(VTOC(vp));
vnode_put(vp);
break;
}
}
if (((VTOC(vp)->c_blocks - (datafork ? datafork->ff_blocks : 0)) > 0) || vnode_isdir(vp)) {
if (vnode_isdir(vp)) {
rvp = vp;
} else {
error = hfs_vgetrsrc(hfsmp, vp, &rvp, TRUE, FALSE);
if (error) {
printf ("hfs_reclaimspace: Error looking up rvp for fileid=%u (error=%d)\n", filerec.fileID, error);
hfs_unlock(VTOC(vp));
vnode_put(vp);
break;
}
VTOC(rvp)->c_flag |= C_NEED_RVNODE_PUT;
}
error = hfs_reclaim_file(hfsmp, rvp, filerec.fileID,
kHFSResourceForkType, allocLimit, context);
if (error) {
printf ("hfs_reclaimspace: Error reclaiming rsrcfork blocks of fileid=%u (error=%d)\n", filerec.fileID, error);
hfs_unlock(VTOC(vp));
vnode_put(vp);
break;
}
}
hfs_unlock(VTOC(vp));
vnode_put(vp);
files_moved++;
}
if (files_moved) {
printf("hfs_reclaim_filespace: Relocated %u blocks from %u files on \"%s\"\n",
(hfsmp->hfs_resize_blocksmoved - prev_blocksmoved),
files_moved, hfsmp->vcbVN);
}
kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
return error;
}
static int
hfs_reclaimspace(struct hfsmount *hfsmp, u_int32_t allocLimit, u_int32_t reclaimblks, vfs_context_t context)
{
int error = 0;
error = hfs_count_allocated(hfsmp, allocLimit, reclaimblks, &(hfsmp->hfs_resize_totalblocks));
if (error) {
printf ("hfs_reclaimspace: Unable to determine total blocks to reclaim error=%d\n", error);
return error;
}
if (hfs_resize_debug) {
printf ("hfs_reclaimspace: Total number of blocks to reclaim = %u\n", hfsmp->hfs_resize_totalblocks);
}
error = hfs_reclaim_file(hfsmp, hfsmp->hfs_allocation_vp, kHFSAllocationFileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: reclaim allocation file returned %d\n", error);
return error;
}
error = hfs_reclaim_file(hfsmp, hfsmp->hfs_extents_vp, kHFSExtentsFileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: reclaim extents b-tree returned %d\n", error);
return error;
}
error = hfs_reclaim_file(hfsmp, hfsmp->hfs_catalog_vp, kHFSCatalogFileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: reclaim catalog b-tree returned %d\n", error);
return error;
}
error = hfs_reclaim_file(hfsmp, hfsmp->hfs_attribute_vp, kHFSAttributesFileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: reclaim attribute b-tree returned %d\n", error);
return error;
}
error = hfs_reclaim_file(hfsmp, hfsmp->hfs_startup_vp, kHFSStartupFileID,
kHFSDataForkType, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: reclaim startup file returned %d\n", error);
return error;
}
if (hfsmp->hfs_resize_blocksmoved) {
hfs_journal_flush(hfsmp, FALSE);
}
error = hfs_reclaim_journal_file(hfsmp, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: hfs_reclaim_journal_file failed (%d)\n", error);
return error;
}
error = hfs_reclaim_journal_info_block(hfsmp, allocLimit, context);
if (error) {
printf("hfs_reclaimspace: hfs_reclaim_journal_info_block failed (%d)\n", error);
return error;
}
error = hfs_reclaim_filespace(hfsmp, allocLimit, context);
if (error) {
printf ("hfs_reclaimspace: hfs_reclaim_filespace returned error=%d\n", error);
return error;
}
error = hfs_reclaim_xattrspace(hfsmp, allocLimit, context);
if (error) {
printf ("hfs_reclaimspace: hfs_reclaim_xattrspace returned error=%d\n", error);
return error;
}
return error;
}
static int
hfs_file_extent_overlaps(struct hfsmount *hfsmp, u_int32_t allocLimit, struct HFSPlusCatalogFile *filerec)
{
struct BTreeIterator * iterator = NULL;
struct FSBufferDescriptor btdata;
HFSPlusExtentRecord extrec;
HFSPlusExtentKey *extkeyptr;
FCB *fcb;
int overlapped = false;
int i, j;
int error;
int lockflags = 0;
u_int32_t endblock;
for (i = 0; i < kHFSPlusExtentDensity; ++i) {
if (filerec->dataFork.extents[i].blockCount == 0) {
break;
}
endblock = filerec->dataFork.extents[i].startBlock +
filerec->dataFork.extents[i].blockCount;
if (endblock > allocLimit) {
overlapped = true;
goto out;
}
}
for (j = 0; j < kHFSPlusExtentDensity; ++j) {
if (filerec->resourceFork.extents[j].blockCount == 0) {
break;
}
endblock = filerec->resourceFork.extents[j].startBlock +
filerec->resourceFork.extents[j].blockCount;
if (endblock > allocLimit) {
overlapped = true;
goto out;
}
}
if ((i < kHFSPlusExtentDensity) && (j < kHFSPlusExtentDensity)) {
goto out;
}
if (kmem_alloc(kernel_map, (vm_offset_t *)&iterator, sizeof(*iterator))) {
return 0;
}
bzero(iterator, sizeof(*iterator));
extkeyptr = (HFSPlusExtentKey *)&iterator->key;
extkeyptr->keyLength = kHFSPlusExtentKeyMaximumLength;
extkeyptr->forkType = 0;
extkeyptr->fileID = filerec->fileID;
extkeyptr->startBlock = 0;
btdata.bufferAddress = &extrec;
btdata.itemSize = sizeof(extrec);
btdata.itemCount = 1;
fcb = VTOF(hfsmp->hfs_extents_vp);
lockflags = hfs_systemfile_lock(hfsmp, SFL_EXTENTS, HFS_SHARED_LOCK);
error = BTSearchRecord(fcb, iterator, &btdata, NULL, iterator);
if (error && (error != btNotFound)) {
goto out;
}
error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
while (error == 0) {
if (extkeyptr->fileID != filerec->fileID) {
break;
}
for (i = 0; i < kHFSPlusExtentDensity; ++i) {
if (extrec[i].blockCount == 0) {
break;
}
endblock = extrec[i].startBlock + extrec[i].blockCount;
if (endblock > allocLimit) {
overlapped = true;
goto out;
}
}
error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
}
out:
if (lockflags) {
hfs_systemfile_unlock(hfsmp, lockflags);
}
if (iterator) {
kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
}
return overlapped;
}
__private_extern__
int
hfs_resize_progress(struct hfsmount *hfsmp, u_int32_t *progress)
{
if ((hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) == 0) {
return (ENXIO);
}
if (hfsmp->hfs_resize_totalblocks > 0) {
*progress = (u_int32_t)((hfsmp->hfs_resize_blocksmoved * 100ULL) / hfsmp->hfs_resize_totalblocks);
} else {
*progress = 0;
}
return (0);
}
static void
hfs_getvoluuid(struct hfsmount *hfsmp, uuid_t result)
{
MD5_CTX md5c;
uint8_t rawUUID[8];
((uint32_t *)rawUUID)[0] = hfsmp->vcbFndrInfo[6];
((uint32_t *)rawUUID)[1] = hfsmp->vcbFndrInfo[7];
MD5Init( &md5c );
MD5Update( &md5c, HFS_UUID_NAMESPACE_ID, sizeof( uuid_t ) );
MD5Update( &md5c, rawUUID, sizeof (rawUUID) );
MD5Final( result, &md5c );
result[6] = 0x30 | ( result[6] & 0x0F );
result[8] = 0x80 | ( result[8] & 0x3F );
}
static int
hfs_vfs_getattr(struct mount *mp, struct vfs_attr *fsap, __unused vfs_context_t context)
{
#define HFS_ATTR_CMN_VALIDMASK (ATTR_CMN_VALIDMASK & ~(ATTR_CMN_NAMEDATTRCOUNT | ATTR_CMN_NAMEDATTRLIST))
#define HFS_ATTR_FILE_VALIDMASK (ATTR_FILE_VALIDMASK & ~(ATTR_FILE_FILETYPE | ATTR_FILE_FORKCOUNT | ATTR_FILE_FORKLIST))
#define HFS_ATTR_CMN_VOL_VALIDMASK (ATTR_CMN_VALIDMASK & ~(ATTR_CMN_NAMEDATTRCOUNT | ATTR_CMN_NAMEDATTRLIST | ATTR_CMN_ACCTIME))
ExtendedVCB *vcb = VFSTOVCB(mp);
struct hfsmount *hfsmp = VFSTOHFS(mp);
u_int32_t freeCNIDs;
freeCNIDs = (u_int32_t)0xFFFFFFFF - (u_int32_t)hfsmp->vcbNxtCNID;
VFSATTR_RETURN(fsap, f_objcount, (u_int64_t)hfsmp->vcbFilCnt + (u_int64_t)hfsmp->vcbDirCnt);
VFSATTR_RETURN(fsap, f_filecount, (u_int64_t)hfsmp->vcbFilCnt);
VFSATTR_RETURN(fsap, f_dircount, (u_int64_t)hfsmp->vcbDirCnt);
VFSATTR_RETURN(fsap, f_maxobjcount, (u_int64_t)0xFFFFFFFF);
VFSATTR_RETURN(fsap, f_iosize, (size_t)cluster_max_io_size(mp, 0));
VFSATTR_RETURN(fsap, f_blocks, (u_int64_t)hfsmp->totalBlocks);
VFSATTR_RETURN(fsap, f_bfree, (u_int64_t)hfs_freeblks(hfsmp, 0));
VFSATTR_RETURN(fsap, f_bavail, (u_int64_t)hfs_freeblks(hfsmp, 1));
VFSATTR_RETURN(fsap, f_bsize, (u_int32_t)vcb->blockSize);
VFSATTR_RETURN(fsap, f_bused, hfsmp->totalBlocks - hfs_freeblks(hfsmp, 1));
VFSATTR_RETURN(fsap, f_files, (u_int64_t)(hfsmp->totalBlocks - 2));
VFSATTR_RETURN(fsap, f_ffree, MIN((u_int64_t)freeCNIDs, (u_int64_t)hfs_freeblks(hfsmp, 1)));
fsap->f_fsid.val[0] = hfsmp->hfs_raw_dev;
fsap->f_fsid.val[1] = vfs_typenum(mp);
VFSATTR_SET_SUPPORTED(fsap, f_fsid);
VFSATTR_RETURN(fsap, f_signature, vcb->vcbSigWord);
VFSATTR_RETURN(fsap, f_carbon_fsid, 0);
if (VFSATTR_IS_ACTIVE(fsap, f_capabilities)) {
vol_capabilities_attr_t *cap;
cap = &fsap->f_capabilities;
if (hfsmp->hfs_flags & HFS_STANDARD) {
cap->capabilities[VOL_CAPABILITIES_FORMAT] =
VOL_CAP_FMT_PERSISTENTOBJECTIDS |
VOL_CAP_FMT_CASE_PRESERVING |
VOL_CAP_FMT_FAST_STATFS |
VOL_CAP_FMT_HIDDEN_FILES |
VOL_CAP_FMT_PATH_FROM_ID;
} else {
cap->capabilities[VOL_CAPABILITIES_FORMAT] =
VOL_CAP_FMT_PERSISTENTOBJECTIDS |
VOL_CAP_FMT_SYMBOLICLINKS |
VOL_CAP_FMT_HARDLINKS |
VOL_CAP_FMT_JOURNAL |
VOL_CAP_FMT_ZERO_RUNS |
(hfsmp->jnl ? VOL_CAP_FMT_JOURNAL_ACTIVE : 0) |
(hfsmp->hfs_flags & HFS_CASE_SENSITIVE ? VOL_CAP_FMT_CASE_SENSITIVE : 0) |
VOL_CAP_FMT_CASE_PRESERVING |
VOL_CAP_FMT_FAST_STATFS |
VOL_CAP_FMT_2TB_FILESIZE |
VOL_CAP_FMT_HIDDEN_FILES |
#if HFS_COMPRESSION
VOL_CAP_FMT_PATH_FROM_ID |
VOL_CAP_FMT_DECMPFS_COMPRESSION;
#else
VOL_CAP_FMT_PATH_FROM_ID;
#endif
}
cap->capabilities[VOL_CAPABILITIES_INTERFACES] =
VOL_CAP_INT_SEARCHFS |
VOL_CAP_INT_ATTRLIST |
VOL_CAP_INT_NFSEXPORT |
VOL_CAP_INT_READDIRATTR |
VOL_CAP_INT_EXCHANGEDATA |
VOL_CAP_INT_ALLOCATE |
VOL_CAP_INT_VOL_RENAME |
VOL_CAP_INT_ADVLOCK |
VOL_CAP_INT_FLOCK |
#if NAMEDSTREAMS
VOL_CAP_INT_EXTENDED_ATTR |
VOL_CAP_INT_NAMEDSTREAMS;
#else
VOL_CAP_INT_EXTENDED_ATTR;
#endif
cap->capabilities[VOL_CAPABILITIES_RESERVED1] = 0;
cap->capabilities[VOL_CAPABILITIES_RESERVED2] = 0;
cap->valid[VOL_CAPABILITIES_FORMAT] =
VOL_CAP_FMT_PERSISTENTOBJECTIDS |
VOL_CAP_FMT_SYMBOLICLINKS |
VOL_CAP_FMT_HARDLINKS |
VOL_CAP_FMT_JOURNAL |
VOL_CAP_FMT_JOURNAL_ACTIVE |
VOL_CAP_FMT_NO_ROOT_TIMES |
VOL_CAP_FMT_SPARSE_FILES |
VOL_CAP_FMT_ZERO_RUNS |
VOL_CAP_FMT_CASE_SENSITIVE |
VOL_CAP_FMT_CASE_PRESERVING |
VOL_CAP_FMT_FAST_STATFS |
VOL_CAP_FMT_2TB_FILESIZE |
VOL_CAP_FMT_OPENDENYMODES |
VOL_CAP_FMT_HIDDEN_FILES |
#if HFS_COMPRESSION
VOL_CAP_FMT_PATH_FROM_ID |
VOL_CAP_FMT_DECMPFS_COMPRESSION;
#else
VOL_CAP_FMT_PATH_FROM_ID;
#endif
cap->valid[VOL_CAPABILITIES_INTERFACES] =
VOL_CAP_INT_SEARCHFS |
VOL_CAP_INT_ATTRLIST |
VOL_CAP_INT_NFSEXPORT |
VOL_CAP_INT_READDIRATTR |
VOL_CAP_INT_EXCHANGEDATA |
VOL_CAP_INT_COPYFILE |
VOL_CAP_INT_ALLOCATE |
VOL_CAP_INT_VOL_RENAME |
VOL_CAP_INT_ADVLOCK |
VOL_CAP_INT_FLOCK |
VOL_CAP_INT_MANLOCK |
#if NAMEDSTREAMS
VOL_CAP_INT_EXTENDED_ATTR |
VOL_CAP_INT_NAMEDSTREAMS;
#else
VOL_CAP_INT_EXTENDED_ATTR;
#endif
cap->valid[VOL_CAPABILITIES_RESERVED1] = 0;
cap->valid[VOL_CAPABILITIES_RESERVED2] = 0;
VFSATTR_SET_SUPPORTED(fsap, f_capabilities);
}
if (VFSATTR_IS_ACTIVE(fsap, f_attributes)) {
vol_attributes_attr_t *attrp = &fsap->f_attributes;
attrp->validattr.commonattr = HFS_ATTR_CMN_VOL_VALIDMASK;
attrp->validattr.volattr = ATTR_VOL_VALIDMASK & ~ATTR_VOL_INFO;
attrp->validattr.dirattr = ATTR_DIR_VALIDMASK;
attrp->validattr.fileattr = HFS_ATTR_FILE_VALIDMASK;
attrp->validattr.forkattr = 0;
attrp->nativeattr.commonattr = HFS_ATTR_CMN_VOL_VALIDMASK;
attrp->nativeattr.volattr = ATTR_VOL_VALIDMASK & ~ATTR_VOL_INFO;
attrp->nativeattr.dirattr = ATTR_DIR_VALIDMASK;
attrp->nativeattr.fileattr = HFS_ATTR_FILE_VALIDMASK;
attrp->nativeattr.forkattr = 0;
VFSATTR_SET_SUPPORTED(fsap, f_attributes);
}
fsap->f_create_time.tv_sec = hfsmp->hfs_itime;
fsap->f_create_time.tv_nsec = 0;
VFSATTR_SET_SUPPORTED(fsap, f_create_time);
fsap->f_modify_time.tv_sec = hfsmp->vcbLsMod;
fsap->f_modify_time.tv_nsec = 0;
VFSATTR_SET_SUPPORTED(fsap, f_modify_time);
fsap->f_backup_time.tv_sec = hfsmp->vcbVolBkUp;
fsap->f_backup_time.tv_nsec = 0;
VFSATTR_SET_SUPPORTED(fsap, f_backup_time);
if (VFSATTR_IS_ACTIVE(fsap, f_fssubtype)) {
u_int16_t subtype = 0;
if (hfsmp->hfs_flags & HFS_STANDARD) {
subtype = HFS_SUBTYPE_STANDARDHFS;
} else {
if (hfsmp->jnl)
subtype |= HFS_SUBTYPE_JOURNALED;
if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
subtype |= HFS_SUBTYPE_CASESENSITIVE;
}
fsap->f_fssubtype = subtype;
VFSATTR_SET_SUPPORTED(fsap, f_fssubtype);
}
if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {
strlcpy(fsap->f_vol_name, (char *) hfsmp->vcbVN, MAXPATHLEN);
VFSATTR_SET_SUPPORTED(fsap, f_vol_name);
}
if (VFSATTR_IS_ACTIVE(fsap, f_uuid)) {
hfs_getvoluuid(hfsmp, fsap->f_uuid);
VFSATTR_SET_SUPPORTED(fsap, f_uuid);
}
return (0);
}
static int
hfs_rename_volume(struct vnode *vp, const char *name, proc_t p)
{
ExtendedVCB *vcb = VTOVCB(vp);
struct cnode *cp = VTOC(vp);
struct hfsmount *hfsmp = VTOHFS(vp);
struct cat_desc to_desc;
struct cat_desc todir_desc;
struct cat_desc new_desc;
cat_cookie_t cookie;
int lockflags;
int error = 0;
char converted_volname[256];
size_t volname_length = 0;
size_t conv_volname_length = 0;
if (name[0] == 0)
return(0);
bzero(&to_desc, sizeof(to_desc));
bzero(&todir_desc, sizeof(todir_desc));
bzero(&new_desc, sizeof(new_desc));
bzero(&cookie, sizeof(cookie));
todir_desc.cd_parentcnid = kHFSRootParentID;
todir_desc.cd_cnid = kHFSRootFolderID;
todir_desc.cd_flags = CD_ISDIR;
to_desc.cd_nameptr = (const u_int8_t *)name;
to_desc.cd_namelen = strlen(name);
to_desc.cd_parentcnid = kHFSRootParentID;
to_desc.cd_cnid = cp->c_cnid;
to_desc.cd_flags = CD_ISDIR;
if ((error = hfs_lock(cp, HFS_EXCLUSIVE_LOCK)) == 0) {
if ((error = hfs_start_transaction(hfsmp)) == 0) {
if ((error = cat_preflight(hfsmp, CAT_RENAME, &cookie, p)) == 0) {
lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
error = cat_rename(hfsmp, &cp->c_desc, &todir_desc, &to_desc, &new_desc);
if (!error) {
strlcpy((char *)vcb->vcbVN, name, sizeof(vcb->vcbVN));
volname_length = strlen ((const char*)vcb->vcbVN);
#define DKIOCCSSETLVNAME _IOW('d', 198, char[1024])
error = utf8_normalizestr(vcb->vcbVN, volname_length, (u_int8_t*)converted_volname, &conv_volname_length, 256, UTF_PRECOMPOSED);
if (error == 0) {
(void) VNOP_IOCTL (hfsmp->hfs_devvp, DKIOCCSSETLVNAME, converted_volname, 0, vfs_context_current());
}
error = 0;
}
hfs_systemfile_unlock(hfsmp, lockflags);
cat_postflight(hfsmp, &cookie, p);
if (error)
MarkVCBDirty(vcb);
(void) hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
}
hfs_end_transaction(hfsmp);
}
if (!error) {
if (cp->c_desc.cd_flags & CD_HASBUF) {
const char *tmp_name = (const char *)cp->c_desc.cd_nameptr;
cp->c_desc.cd_nameptr = 0;
cp->c_desc.cd_namelen = 0;
cp->c_desc.cd_flags &= ~CD_HASBUF;
vfs_removename(tmp_name);
}
replace_desc(cp, &new_desc);
vcb->volumeNameEncodingHint = new_desc.cd_encoding;
cp->c_touch_chgtime = TRUE;
}
hfs_unlock(cp);
}
return(error);
}
static int
hfs_vfs_setattr(struct mount *mp, struct vfs_attr *fsap, __unused vfs_context_t context)
{
kauth_cred_t cred = vfs_context_ucred(context);
int error = 0;
if (!kauth_cred_issuser(cred) && (kauth_cred_getuid(cred) != vfs_statfs(mp)->f_owner))
return(EACCES);
if (VFSATTR_IS_ACTIVE(fsap, f_vol_name)) {
vnode_t root_vp;
error = hfs_vfs_root(mp, &root_vp, context);
if (error)
goto out;
error = hfs_rename_volume(root_vp, fsap->f_vol_name, vfs_context_proc(context));
(void) vnode_put(root_vp);
if (error)
goto out;
VFSATTR_SET_SUPPORTED(fsap, f_vol_name);
}
out:
return error;
}
void hfs_mark_volume_inconsistent(struct hfsmount *hfsmp)
{
HFS_MOUNT_LOCK(hfsmp, TRUE);
if ((hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) == 0) {
hfsmp->vcbAtrb |= kHFSVolumeInconsistentMask;
MarkVCBDirty(hfsmp);
}
if ((hfsmp->hfs_flags & HFS_READ_ONLY)==0) {
fslog_fs_corrupt(hfsmp->hfs_mp);
printf("hfs: Runtime corruption detected on %s, fsck will be forced on next mount.\n", hfsmp->vcbVN);
}
HFS_MOUNT_UNLOCK(hfsmp, TRUE);
}
static int hfs_journal_replay(vnode_t devvp, vfs_context_t context)
{
int retval = 0;
struct mount *mp = NULL;
struct hfs_mount_args *args = NULL;
if (!vnode_ischr(devvp) && !vnode_isblk(devvp)) {
retval = EINVAL;
goto out;
}
MALLOC(mp, struct mount *, sizeof(struct mount), M_TEMP, M_WAITOK);
if (mp == NULL) {
retval = ENOMEM;
goto out;
}
bzero(mp, sizeof(struct mount));
mount_lock_init(mp);
MALLOC(args, struct hfs_mount_args *, sizeof(struct hfs_mount_args), M_TEMP, M_WAITOK);
if (args == NULL) {
retval = ENOMEM;
goto out;
}
bzero(args, sizeof(struct hfs_mount_args));
retval = hfs_mountfs(devvp, mp, args, 1, context);
buf_flushdirtyblks(devvp, TRUE, 0, "hfs_journal_replay");
retval = VNOP_FSYNC(devvp, MNT_WAIT, context);
out:
if (mp) {
mount_lock_destroy(mp);
FREE(mp, M_TEMP);
}
if (args) {
FREE(args, M_TEMP);
}
return retval;
}
struct vfsops hfs_vfsops = {
hfs_mount,
hfs_start,
hfs_unmount,
hfs_vfs_root,
hfs_quotactl,
hfs_vfs_getattr,
hfs_sync,
hfs_vfs_vget,
hfs_fhtovp,
hfs_vptofh,
hfs_init,
hfs_sysctl,
hfs_vfs_setattr,
{NULL}
};