Lines Matching defs:hfsmp
128 static int hfs_flushMDB(struct hfsmount *hfsmp, int waitfor, int altflush);
144 static int hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks, vfs_context_t context);
145 static int hfs_overlapped_overflow_extents(struct hfsmount *hfsmp, u_int32_t startblk,
158 struct hfsmount *hfsmp;
168 /* Init hfsmp */
169 hfsmp = VFSTOHFS(mp);
171 hfsmp->hfs_uid = UNKNOWNUID;
172 hfsmp->hfs_gid = UNKNOWNGID;
173 hfsmp->hfs_dir_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH); /* 0755 */
174 hfsmp->hfs_file_mask = (S_IRWXU | S_IRGRP|S_IXGRP | S_IROTH|S_IXOTH); /* 0755 */
177 vcb = HFSTOVCB(hfsmp);
198 struct hfsmount *hfsmp = NULL;
208 hfsmp = VFSTOHFS(mp);
219 if (((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) &&
227 hfs_global_exclusive_lock_acquire(hfsmp);
228 hfsmp->hfs_flags |= HFS_RDONLY_DOWNGRADE;
229 hfsmp->hfs_downgrading_proc = current_thread();
230 hfs_global_exclusive_lock_release(hfsmp);
235 hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
236 hfsmp->hfs_downgrading_proc = NULL;
245 hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
246 hfsmp->hfs_downgrading_proc = NULL;
251 hfsmp->vcbAtrb |= kHFSVolumeUnmountedMask;
252 retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
253 hfsmp->hfs_flags |= HFS_READ_ONLY;
257 if (vnode_mount(hfsmp->hfs_devvp) == mp) {
258 retval = hfs_fsync(hfsmp->hfs_devvp, MNT_WAIT, 0, p);
260 vnode_get(hfsmp->hfs_devvp);
261 retval = VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);
262 vnode_put(hfsmp->hfs_devvp);
266 hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
267 hfsmp->hfs_downgrading_proc = NULL;
268 hfsmp->hfs_flags &= ~HFS_READ_ONLY;
271 if (hfsmp->jnl) {
272 hfs_global_exclusive_lock_acquire(hfsmp);
274 journal_close(hfsmp->jnl);
275 hfsmp->jnl = NULL;
281 hfs_global_exclusive_lock_release(hfsmp);
284 hfsmp->hfs_downgrading_proc = NULL;
295 (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask)) {
303 if ( (HFSTOVCB(hfsmp)->vcbAtrb & kHFSVolumeJournaledMask)
304 && hfsmp->jnl == NULL
305 && hfsmp->jvp != NULL) {
308 if (hfsmp->hfs_flags & HFS_NEED_JNL_RESET) {
314 hfs_global_exclusive_lock_acquire(hfsmp);
316 hfsmp->jnl = journal_open(hfsmp->jvp,
317 (hfsmp->jnl_start * HFSTOVCB(hfsmp)->blockSize) + (off_t)HFSTOVCB(hfsmp)->hfsPlusIOPosOffset,
318 hfsmp->jnl_size,
319 hfsmp->hfs_devvp,
320 hfsmp->hfs_logical_block_size,
323 hfs_sync_metadata, hfsmp->hfs_mp);
325 hfs_global_exclusive_lock_release(hfsmp);
327 if (hfsmp->jnl == NULL) {
331 hfsmp->hfs_flags &= ~HFS_NEED_JNL_RESET;
337 hfsmp->hfs_flags &= ~HFS_READ_ONLY;
343 hfsmp->hfs_flags &= ~HFS_RDONLY_DOWNGRADE;
344 hfsmp->hfs_downgrading_proc = NULL;
347 hfsmp->vcbAtrb &= ~kHFSVolumeUnmountedMask;
349 retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
353 if (!(hfsmp->hfs_flags & (HFS_READ_ONLY | HFS_STANDARD))) {
355 hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
356 hfs_privatedir_init(hfsmp, DIR_HARDLINKS);
358 hfs_remove_orphans(hfsmp);
363 if (hfsmp->hfs_flags & HFS_METADATA_ZONE) {
364 (void) hfs_recording_init(hfsmp);
367 if (vfs_extendedsecurity(HFSTOVFS(hfsmp)) == 0) {
368 vfs_setextendedsecurity(HFSTOVFS(hfsmp));
394 struct hfsmount *hfsmp;
414 vcb = HFSTOVCB(args->hfsmp);
416 lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
417 error = cat_lookup(args->hfsmp, &cp->c_desc, 0, &cndesc, &cnattr, NULL, NULL);
418 hfs_systemfile_unlock(args->hfsmp, lockflags);
447 cp->c_desc.cd_encoding = args->hfsmp->hfs_encoding;
461 struct hfsmount *hfsmp;
469 hfsmp = VFSTOHFS(mp);
470 vcb = HFSTOVCB(hfsmp);
473 hfsmp->hfs_flags |= HFS_IN_CHANGEFS;
475 permswitch = (((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) &&
477 (((hfsmp->hfs_flags & HFS_UNKNOWN_PERMS) == 0) &&
487 hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;
489 hfsmp->hfs_flags &= ~HFS_UNKNOWN_PERMS;
498 (void) hfs_recording_suspend(hfsmp);
507 if ((args->hfs_uid != (uid_t)VNOVAL) && (hfsmp->hfs_uid != args->hfs_uid)) {
508 hfsmp->hfs_uid = args->hfs_uid;
512 if ((args->hfs_gid != (gid_t)VNOVAL) && (hfsmp->hfs_gid != args->hfs_gid)) {
513 hfsmp->hfs_gid = args->hfs_gid;
518 if (hfsmp->hfs_dir_mask != (args->hfs_mask & ALLPERMS)) {
519 hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;
520 hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;
522 hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);
531 (hfsmp->hfs_encoding != args->hfs_encoding)) {
547 hfsmp->hfs_get_unicode = get_unicode_func;
548 old_encoding = hfsmp->hfs_encoding;
549 hfsmp->hfs_encoding = args->hfs_encoding;
559 hfsmp->hfs_uid == UNKNOWNUID ? KAUTH_UID_NONE : hfsmp->hfs_uid,
560 hfsmp->hfs_gid == UNKNOWNGID ? KAUTH_GID_NONE : hfsmp->hfs_gid);
574 cargs.hfsmp = hfsmp;
587 hfsmp->hfs_get_hfsname = get_hfsname_func;
592 hfsmp->hfs_flags &= ~HFS_IN_CHANGEFS;
598 struct hfsmount *hfsmp;
632 lockflags = hfs_systemfile_lock(args->hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
633 args->error = cat_idlookup(args->hfsmp, cp->c_fileid, 0, &desc, &cp->c_attr, datafork);
634 hfs_systemfile_unlock(args->hfsmp, lockflags);
665 struct hfsmount *hfsmp;
673 hfsmp = VFSTOHFS(mountp);
674 vcb = HFSTOVCB(hfsmp);
682 devvp = hfsmp->hfs_devvp;
686 args.hfsmp = hfsmp;
703 priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
704 HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
706 error = (int)buf_meta_bread(hfsmp->hfs_devvp,
707 HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
708 hfsmp->hfs_physical_block_size, NOCRED, &bp);
715 vhp = (HFSPlusVolumeHeader *) (buf_dataptr(bp) + HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
769 if (hfsmp->hfs_attribute_vp) {
770 forkp = VTOF(hfsmp->hfs_attribute_vp);
807 if (hfsmp->hfs_attribute_vp) {
808 forkp = VTOF(hfsmp->hfs_attribute_vp);
814 if ((error = cat_idlookup(hfsmp, kHFSRootFolderID, 0, &cndesc, NULL, NULL)))
821 hfs_privatedir_init(hfsmp, FILE_HARDLINKS);
822 hfs_privatedir_init(hfsmp, DIR_HARDLINKS);
825 hfs_generate_volume_notifications(hfsmp);
838 struct hfsmount *hfsmp = arg0;
851 if ((now - hfsmp->hfs_last_sync_time) >= 5000000LL) {
858 throttle_info_get_last_io_time(hfsmp->hfs_mp, &last_io);
876 if (hfsmp->hfs_devvp && hfsmp->hfs_devvp->v_numoutput > 0) {
888 if ( ((now - hfsmp->hfs_last_sync_time) >= 100000LL)
889 && ((now - hfsmp->hfs_last_sync_request_time) >= 100000LL)
890 && (hfsmp->hfs_active_threads == 0)
891 && (hfsmp->hfs_global_lock_nesting == 0)) {
894 OSAddAtomic(1, (SInt32 *)&hfsmp->hfs_active_threads);
895 if (hfsmp->jnl) {
896 journal_flush(hfsmp->jnl);
898 OSAddAtomic(-1, (SInt32 *)&hfsmp->hfs_active_threads);
901 hfsmp->hfs_last_sync_time = ((int64_t)secs * 1000000) + usecs;
903 } else if (hfsmp->hfs_active_threads == 0) {
908 thread_call_enter_delayed(hfsmp->hfs_syncer, deadline);
917 OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_scheduled);
918 OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_incomplete);
919 wakeup((caddr_t)&hfsmp->hfs_sync_incomplete);
933 struct hfsmount *hfsmp;
964 hfsmp = NULL;
1055 MALLOC(hfsmp, struct hfsmount *, sizeof(struct hfsmount), M_HFSMNT, M_WAITOK);
1056 bzero(hfsmp, sizeof(struct hfsmount));
1062 lck_mtx_init(&hfsmp->hfs_mutex, hfs_mutex_group, hfs_lock_attr);
1063 lck_mtx_init(&hfsmp->hfc_mutex, hfs_mutex_group, hfs_lock_attr);
1064 lck_rw_init(&hfsmp->hfs_global_lock, hfs_rwlock_group, hfs_lock_attr);
1065 lck_rw_init(&hfsmp->hfs_insync, hfs_rwlock_group, hfs_lock_attr);
1067 vfs_setfsprivate(mp, hfsmp);
1068 hfsmp->hfs_mp = mp; /* Make VFSTOHFS work */
1069 hfsmp->hfs_raw_dev = vnode_specrdev(devvp);
1070 hfsmp->hfs_devvp = devvp;
1071 vnode_ref(devvp); /* Hold a ref on the device, dropped when hfsmp is freed. */
1072 hfsmp->hfs_logical_block_size = log_blksize;
1073 hfsmp->hfs_logical_block_count = log_blkcnt;
1074 hfsmp->hfs_physical_block_size = phys_blksize;
1075 hfsmp->hfs_log_per_phys = (phys_blksize / log_blksize);
1076 hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;
1078 hfsmp->hfs_flags |= HFS_READ_ONLY;
1080 hfsmp->hfs_flags |= HFS_UNKNOWN_PERMS;
1084 dqfileinit(&hfsmp->hfs_qfiles[i]);
1088 hfsmp->hfs_uid = (args->hfs_uid == (uid_t)VNOVAL) ? UNKNOWNUID : args->hfs_uid;
1089 if (hfsmp->hfs_uid == 0xfffffffd) hfsmp->hfs_uid = UNKNOWNUID;
1090 hfsmp->hfs_gid = (args->hfs_gid == (gid_t)VNOVAL) ? UNKNOWNGID : args->hfs_gid;
1091 if (hfsmp->hfs_gid == 0xfffffffd) hfsmp->hfs_gid = UNKNOWNGID;
1092 vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid); /* tell the VFS */
1094 hfsmp->hfs_dir_mask = args->hfs_mask & ALLPERMS;
1096 hfsmp->hfs_file_mask = (args->hfs_mask & DEFFILEMODE);
1098 hfsmp->hfs_file_mask = args->hfs_mask & ALLPERMS;
1101 hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS; /* 0777: rwx---rwx */
1102 hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE; /* 0666: no --x by default? */
1109 hfsmp->hfs_uid = UNKNOWNUID;
1110 hfsmp->hfs_gid = UNKNOWNGID;
1111 vfs_setowner(mp, hfsmp->hfs_uid, hfsmp->hfs_gid); /* tell the VFS */
1112 hfsmp->hfs_dir_mask = UNKNOWNPERMISSIONS & ALLPERMS; /* 0777: rwx---rwx */
1113 hfsmp->hfs_file_mask = UNKNOWNPERMISSIONS & DEFFILEMODE; /* 0666: no --x by default? */
1120 hfsmp->hfs_flags |= HFS_WRITEABLE_MEDIA;
1122 hfsmp->hfs_flags &= ~HFS_WRITEABLE_MEDIA;
1128 hfsmp->hfs_mount_time = tv.tv_sec;
1155 hfsmp->hfs_logical_block_size = log_blksize;
1156 hfsmp->hfs_logical_block_count = log_blkcnt;
1157 hfsmp->hfs_physical_block_size = log_blksize;
1158 hfsmp->hfs_log_per_phys = 1;
1161 hfsmp->hfs_encoding = args->hfs_encoding;
1162 HFSTOVCB(hfsmp)->volumeNameEncodingHint = args->hfs_encoding;
1168 retval = hfs_getconverter(hfsmp->hfs_encoding, &hfsmp->hfs_get_unicode,
1169 &hfsmp->hfs_get_hfsname);
1173 retval = hfs_MountHFSVolume(hfsmp, mdbp, p);
1175 (void) hfs_relconverter(hfsmp->hfs_encoding);
1210 hfsmp->hfs_logical_block_count *=
1211 hfsmp->hfs_logical_block_size / log_blksize;
1212 hfsmp->hfs_logical_block_size = log_blksize;
1215 hfsmp->hfs_physical_block_size = log_blksize;
1217 hfsmp->hfs_log_per_phys = 1;
1223 hfsmp->hfs_logical_block_count = disksize / log_blksize;
1226 retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
1246 !(hfsmp->hfs_flags & HFS_READ_ONLY)) {
1254 hfsmp->jnl = NULL;
1255 hfsmp->jvp = NULL;
1277 if (hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred) == 0) {
1286 hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;
1294 HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
1335 (void) hfs_getconverter(0, &hfsmp->hfs_get_unicode, &hfsmp->hfs_get_hfsname);
1337 retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);
1356 hfsmp->hfs_logical_block_count *= hfsmp->hfs_logical_block_size / log_blksize;
1357 hfsmp->hfs_logical_block_size = log_blksize;
1358 hfsmp->hfs_log_per_phys = hfsmp->hfs_physical_block_size / log_blksize;
1360 if (hfsmp->jnl) {
1362 journal_close(hfsmp->jnl);
1363 hfsmp->jnl = NULL;
1364 if (hfs_early_journal_init(hfsmp, vhp, args, embeddedOffset, mdb_offset, mdbp, cred) == 0) {
1373 hfsmp->hfs_flags |= HFS_NEED_JNL_RESET;
1380 retval = (int)buf_meta_bread(devvp, HFS_PHYSBLK_ROUNDDOWN(mdb_offset, hfsmp->hfs_log_per_phys),
1412 retval = hfs_MountHFSPlusVolume(hfsmp, vhp, embeddedOffset, disksize, p, args, cred);
1420 hfsmp->hfs_last_mounted_mtime = hfsmp->hfs_mtime;
1434 if (!(hfsmp->hfs_flags & HFS_STANDARD)) {
1452 hfsmp->hfs_freespace_notify_warninglimit =
1453 MIN(HFS_LOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
1454 (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKTRIGGERFRACTION);
1455 hfsmp->hfs_freespace_notify_desiredlevel =
1456 MIN(HFS_LOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,
1457 (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_LOWDISKSHUTOFFFRACTION);
1466 hfsmp->hfs_freespace_notify_warninglimit =
1467 MIN(HFS_ROOTLOWDISKTRIGGERLEVEL / HFSTOVCB(hfsmp)->blockSize,
1468 (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKTRIGGERFRACTION);
1469 hfsmp->hfs_freespace_notify_desiredlevel =
1470 MIN(HFS_ROOTLOWDISKSHUTOFFLEVEL / HFSTOVCB(hfsmp)->blockSize,
1471 (HFSTOVCB(hfsmp)->totalBlocks / 100) * HFS_ROOTLOWDISKSHUTOFFFRACTION);
1477 hfsmp->hfs_flags |= HFS_VIRTUAL_DEVICE;
1483 if ((hfsmp->hfs_flags & HFS_VIRTUAL_DEVICE) == 0 &&
1485 hfsmp->hfs_syncer = thread_call_allocate(hfs_syncer, hfsmp);
1486 if (hfsmp->hfs_syncer == NULL) {
1497 hfsmp->hfs_notification_conditions = 0;
1498 hfs_generate_volume_notifications(hfsmp);
1501 (void) hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
1512 if (hfsmp && hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
1513 (void)VNOP_CLOSE(hfsmp->jvp, ronly ? FREAD : FREAD|FWRITE, context);
1514 hfsmp->jvp = NULL;
1516 if (hfsmp) {
1517 if (hfsmp->hfs_devvp) {
1518 vnode_rele(hfsmp->hfs_devvp);
1520 FREE(hfsmp, M_HFSMNT);
1546 struct hfsmount *hfsmp = VFSTOHFS(mp);
1562 if (hfsmp->hfs_flags & HFS_METADATA_ZONE)
1563 (void) hfs_recording_suspend(hfsmp);
1569 if (hfsmp->hfs_syncer)
1579 if (thread_call_cancel(hfsmp->hfs_syncer))
1580 OSDecrementAtomic((volatile SInt32 *)&hfsmp->hfs_sync_incomplete);
1581 thread_call_free(hfsmp->hfs_syncer);
1582 hfsmp->hfs_syncer = NULL;
1588 while(hfsmp->hfs_sync_incomplete > 0)
1590 msleep((caddr_t)&hfsmp->hfs_sync_incomplete, NULL, PWAIT, "hfs_unmount", &ts);
1593 if (hfsmp->hfs_sync_incomplete < 0)
1594 printf("hfs_unmount: pm_sync_incomplete underflow (%d)!\n", hfsmp->hfs_sync_incomplete);
1600 if ((hfsmp->hfs_flags & HFS_READ_ONLY) == 0) {
1601 retval = hfs_start_transaction(hfsmp);
1608 if (hfsmp->hfs_startup_vp) {
1609 (void) hfs_lock(VTOC(hfsmp->hfs_startup_vp), HFS_EXCLUSIVE_LOCK);
1610 retval = hfs_fsync(hfsmp->hfs_startup_vp, MNT_WAIT, 0, p);
1611 hfs_unlock(VTOC(hfsmp->hfs_startup_vp));
1616 if (hfsmp->hfs_attribute_vp) {
1617 (void) hfs_lock(VTOC(hfsmp->hfs_attribute_vp), HFS_EXCLUSIVE_LOCK);
1618 retval = hfs_fsync(hfsmp->hfs_attribute_vp, MNT_WAIT, 0, p);
1619 hfs_unlock(VTOC(hfsmp->hfs_attribute_vp));
1624 (void) hfs_lock(VTOC(hfsmp->hfs_catalog_vp), HFS_EXCLUSIVE_LOCK);
1625 retval = hfs_fsync(hfsmp->hfs_catalog_vp, MNT_WAIT, 0, p);
1626 hfs_unlock(VTOC(hfsmp->hfs_catalog_vp));
1630 (void) hfs_lock(VTOC(hfsmp->hfs_extents_vp), HFS_EXCLUSIVE_LOCK);
1631 retval = hfs_fsync(hfsmp->hfs_extents_vp, MNT_WAIT, 0, p);
1632 hfs_unlock(VTOC(hfsmp->hfs_extents_vp));
1636 if (hfsmp->hfs_allocation_vp) {
1637 (void) hfs_lock(VTOC(hfsmp->hfs_allocation_vp), HFS_EXCLUSIVE_LOCK);
1638 retval = hfs_fsync(hfsmp->hfs_allocation_vp, MNT_WAIT, 0, p);
1639 hfs_unlock(VTOC(hfsmp->hfs_allocation_vp));
1644 if (hfsmp->hfc_filevp && vnode_issystem(hfsmp->hfc_filevp)) {
1645 retval = hfs_fsync(hfsmp->hfc_filevp, MNT_WAIT, 0, p);
1653 if (hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) {
1654 HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;
1656 HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeUnmountedMask;
1659 retval = hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
1661 HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeUnmountedMask;
1667 hfs_end_transaction(hfsmp);
1672 if (hfsmp->jnl) {
1673 journal_flush(hfsmp->jnl);
1679 (void) hfsUnmount(hfsmp, p);
1686 if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord)
1687 (void) hfs_relconverter(hfsmp->hfs_encoding);
1690 if (hfsmp->jnl) {
1691 journal_close(hfsmp->jnl);
1692 hfsmp->jnl = NULL;
1695 VNOP_FSYNC(hfsmp->hfs_devvp, MNT_WAIT, context);
1697 if (hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
1698 retval = VNOP_CLOSE(hfsmp->jvp,
1699 hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE,
1701 vnode_put(hfsmp->jvp);
1702 hfsmp->jvp = NULL;
1708 if ((hfsmp->hfs_flags & HFS_HAS_SPARSE_DEVICE) && hfsmp->hfs_backingfs_rootvp) {
1711 hfsmp->hfs_flags &= ~HFS_HAS_SPARSE_DEVICE;
1712 tmpvp = hfsmp->hfs_backingfs_rootvp;
1713 hfsmp->hfs_backingfs_rootvp = NULLVP;
1717 lck_mtx_destroy(&hfsmp->hfc_mutex, hfs_mutex_group);
1718 vnode_rele(hfsmp->hfs_devvp);
1719 FREE(hfsmp, M_HFSMNT);
1725 hfs_end_transaction(hfsmp);
1833 struct hfsmount *hfsmp = VFSTOHFS(mp);
1842 sbp->f_bfree = (u_int64_t)((unsigned long )hfs_freeblks(hfsmp, 0));
1843 sbp->f_bavail = (u_int64_t)((unsigned long )hfs_freeblks(hfsmp, 1));
1857 if (hfsmp->hfs_flags & HFS_STANDARD) {
1860 if (hfsmp->jnl)
1862 if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
1884 struct hfsmount *hfsmp;
1889 hfsmp = VFSTOHFS(mp);
1890 vcb = HFSTOVCB(hfsmp);
1893 priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
1894 HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
1896 retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
1897 HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
1898 hfsmp->hfs_physical_block_size, NOCRED, &bp);
1914 if (hfsmp->hfs_alt_id_sector) {
1915 retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
1916 HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
1917 hfsmp->hfs_physical_block_size, NOCRED, &bp);
1975 struct hfsmount *hfsmp;
1982 hfsmp = VFSTOHFS(mp);
1987 if (hfsmp->hfs_flags & HFS_IN_CHANGEFS)
1990 if (hfsmp->hfs_flags & HFS_READ_ONLY)
1994 if (!lck_rw_try_lock_shared(&hfsmp->hfs_insync))
2011 vcb = HFSTOVCB(hfsmp);
2016 meta_vp[3] = hfsmp->hfs_attribute_vp; /* Optional file */
2054 if ((error = VNOP_FSYNC(hfsmp->hfs_devvp, waitfor, context))) {
2062 hfs_hotfilesync(hfsmp, vfs_context_kernel());
2068 error = hfs_flushvolumeheader(hfsmp, waitfor, 0);
2073 if (hfsmp->jnl) {
2074 journal_flush(hfsmp->jnl);
2083 hfsmp->hfs_last_sync_time = now;
2086 lck_rw_unlock_shared(&hfsmp->hfs_insync);
2199 struct hfsmount * hfsmp;
2212 hfsmp = VTOHFS(vp);
2214 if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord)
2217 *hfsmpp = hfsmp;
2234 struct hfsmount *hfsmp;
2253 if ((error = hfs_getmountpoint(vp, &hfsmp)))
2259 error = hfs_extendfs(hfsmp, newsize, context);
2306 hfsmp = VTOHFS(vp);
2307 if (hfsmp->hfs_flags & HFS_READ_ONLY) {
2310 if (HFSTOVCB(hfsmp)->vcbSigWord == kHFSSigWord) {
2315 if (hfsmp->jnl) {
2320 vcb = HFSTOVCB(hfsmp);
2321 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS, HFS_EXCLUSIVE_LOCK);
2326 hfs_systemfile_unlock(hfsmp, lockflags);
2329 hfs_systemfile_unlock(hfsmp, lockflags);
2338 hfs_sync(hfsmp->hfs_mp, MNT_WAIT, context);
2343 jvp = hfsmp->hfs_devvp;
2345 (off_t)name[2] * (off_t)HFSTOVCB(hfsmp)->blockSize
2346 + HFSTOVCB(hfsmp)->hfsPlusIOPosOffset,
2348 hfsmp->hfs_devvp,
2349 hfsmp->hfs_logical_block_size,
2352 hfs_sync_metadata, hfsmp->hfs_mp);
2356 if (jvp && jvp != hfsmp->hfs_devvp) {
2357 VNOP_CLOSE(jvp, hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE, context);
2364 hfs_global_exclusive_lock_acquire(hfsmp);
2369 buf_flushdirtyblks(hfsmp->hfs_devvp, MNT_WAIT, 0, "hfs_sysctl");
2370 buf_flushdirtyblks(hfsmp->hfs_extents_vp, MNT_WAIT, 0, "hfs_sysctl");
2371 buf_flushdirtyblks(hfsmp->hfs_catalog_vp, MNT_WAIT, 0, "hfs_sysctl");
2372 buf_flushdirtyblks(hfsmp->hfs_allocation_vp, MNT_WAIT, 0, "hfs_sysctl");
2373 if (hfsmp->hfs_attribute_vp)
2374 buf_flushdirtyblks(hfsmp->hfs_attribute_vp, MNT_WAIT, 0, "hfs_sysctl");
2376 HFSTOVCB(hfsmp)->vcbJinfoBlock = name[1];
2377 HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeJournaledMask;
2378 hfsmp->jvp = jvp;
2379 hfsmp->jnl = jnl;
2382 hfsmp->jnl_start = (u_int32_t)name[2];
2383 hfsmp->jnl_size = (off_t)((unsigned)name[3]);
2384 hfsmp->hfs_jnlinfoblkid = jinfo_attr.ca_fileid;
2385 hfsmp->hfs_jnlfileid = jnl_attr.ca_fileid;
2387 vfs_setflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
2389 hfs_global_exclusive_lock_release(hfsmp);
2390 hfs_flushvolumeheader(hfsmp, MNT_WAIT, 1);
2404 hfsmp = VTOHFS(vp);
2410 if (hfsmp->hfs_private_attr[DIR_HARDLINKS].ca_entries != 0){
2417 hfs_global_exclusive_lock_acquire(hfsmp);
2420 journal_close(hfsmp->jnl);
2421 hfsmp->jnl = NULL;
2423 if (hfsmp->jvp && hfsmp->jvp != hfsmp->hfs_devvp) {
2424 VNOP_CLOSE(hfsmp->jvp, hfsmp->hfs_flags & HFS_READ_ONLY ? FREAD : FREAD|FWRITE, context);
2426 hfsmp->jvp = NULL;
2427 vfs_clearflags(hfsmp->hfs_mp, (u_int64_t)((unsigned int)MNT_JOURNALED));
2428 hfsmp->jnl_start = 0;
2429 hfsmp->hfs_jnlinfoblkid = 0;
2430 hfsmp->hfs_jnlfileid = 0;
2432 HFSTOVCB(hfsmp)->vcbAtrb &= ~kHFSVolumeJournaledMask;
2434 hfs_global_exclusive_lock_release(hfsmp);
2435 hfs_flushvolumeheader(hfsmp, MNT_WAIT, 1);
2445 hfsmp = VTOHFS(vp);
2446 if (hfsmp->jnl == NULL) {
2450 jnl_start = (off_t)(hfsmp->jnl_start * HFSTOVCB(hfsmp)->blockSize) + (off_t)HFSTOVCB(hfsmp)->hfsPlusIOPosOffset;
2451 jnl_size = (off_t)hfsmp->jnl_size;
2491 hfsmp = VFSTOHFS(mp);
2493 vq.vq_flags = hfsmp->hfs_notification_conditions;
2529 struct hfsmount *hfsmp;
2531 hfsmp = VFSTOHFS(mp);
2533 error = hfs_vget(hfsmp, (cnid_t)ino, vpp, 1);
2550 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
2551 error = cat_findname(hfsmp, (cnid_t)ino, &cdesc);
2552 hfs_systemfile_unlock(hfsmp, lockflags);
2555 hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) &&
2557 hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid)) {
2578 hfs_vget(struct hfsmount *hfsmp, cnid_t cnid, struct vnode **vpp, int skiplock)
2593 if (cnid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid ||
2594 cnid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) {
2600 vp = hfs_chash_getvnode(hfsmp->hfs_raw_dev, cnid, 0, skiplock);
2632 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
2633 error = cat_idlookup(hfsmp, cnid, 0, &cndesc, &cnattr, &cnfork);
2634 hfs_systemfile_unlock(hfsmp, lockflags);
2647 if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&
2651 } else if ((pid == hfsmp->hfs_private_desc[DIR_HARDLINKS].cd_cnid) &&
2655 } else if ((pid == hfsmp->hfs_private_desc[FILE_HARDLINKS].cd_cnid) &&
2680 if ((hfs_lookuplink(hfsmp, linkref, &prevlinkid, &nextlinkid) == 0) &&
2682 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);
2683 error = cat_findname(hfsmp, nextlinkid, &linkdesc);
2684 hfs_systemfile_unlock(hfsmp, lockflags);
2693 error = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cnfork, &vp);
2713 error = hfs_getnewvnode(hfsmp, NULLVP, &cn, &cndesc, 0, &cnattr, &cnfork, &vp);
2740 struct hfsmount *hfsmp;
2748 hfsmp = VFSTOHFS(mp);
2761 if (hfsmp->hfs_qfiles[i].qf_vp != NULLVP)
2766 skipvp = hfs_chash_getvnode(hfsmp->hfs_raw_dev, kHFSRootFolderID, 0, 0);
2795 if (hfsmp->hfs_qfiles[i].qf_vp == NULLVP)
2811 hfs_setencodingbits(struct hfsmount *hfsmp, u_int32_t encoding)
2830 if (index < 64 && (hfsmp->encodingsBitmap & (u_int64_t)(1ULL << index)) == 0) {
2831 HFS_MOUNT_LOCK(hfsmp, TRUE)
2832 hfsmp->encodingsBitmap |= (u_int64_t)(1ULL << index);
2833 MarkVCBDirty(hfsmp);
2834 HFS_MOUNT_UNLOCK(hfsmp, TRUE);
2845 hfs_volupdate(struct hfsmount *hfsmp, enum volop op, int inroot)
2851 lck_mtx_lock(&hfsmp->hfs_mutex);
2853 MarkVCBDirty(hfsmp);
2854 hfsmp->hfs_mtime = tv.tv_sec;
2860 if (hfsmp->hfs_dircount != 0xFFFFFFFF)
2861 ++hfsmp->hfs_dircount;
2862 if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)
2863 ++hfsmp->vcbNmRtDirs;
2866 if (hfsmp->hfs_dircount != 0)
2867 --hfsmp->hfs_dircount;
2868 if (inroot && hfsmp->vcbNmRtDirs != 0xFFFF)
2869 --hfsmp->vcbNmRtDirs;
2872 if (hfsmp->hfs_filecount != 0xFFFFFFFF)
2873 ++hfsmp->hfs_filecount;
2874 if (inroot && hfsmp->vcbNmFls != 0xFFFF)
2875 ++hfsmp->vcbNmFls;
2878 if (hfsmp->hfs_filecount != 0)
2879 --hfsmp->hfs_filecount;
2880 if (inroot && hfsmp->vcbNmFls != 0xFFFF)
2881 --hfsmp->vcbNmFls;
2885 lck_mtx_unlock(&hfsmp->hfs_mutex);
2887 if (hfsmp->jnl) {
2888 hfs_flushvolumeheader(hfsmp, 0, 0);
2896 hfs_flushMDB(struct hfsmount *hfsmp, int waitfor, int altflush)
2898 ExtendedVCB *vcb = HFSTOVCB(hfsmp);
2906 sectorsize = hfsmp->hfs_logical_block_size;
2907 retval = (int)buf_bread(hfsmp->hfs_devvp, (daddr64_t)HFS_PRI_SECTOR(sectorsize), sectorsize, NOCRED, &bp);
2914 lck_mtx_lock(&hfsmp->hfs_mutex);
2965 lck_mtx_unlock(&hfsmp->hfs_mutex);
2971 if (buf_meta_bread(hfsmp->hfs_devvp, hfsmp->hfs_alt_id_sector, sectorsize, NOCRED, &alt_bp) == 0) {
2997 hfs_flushvolumeheader(struct hfsmount *hfsmp, int waitfor, int altflush)
2999 ExtendedVCB *vcb = HFSTOVCB(hfsmp);
3010 if (hfsmp->hfs_flags & HFS_READ_ONLY) {
3013 if (hfsmp->hfs_flags & HFS_STANDARD) {
3014 return hfs_flushMDB(hfsmp, waitfor, altflush);
3017 priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / hfsmp->hfs_logical_block_size) +
3018 HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size));
3020 if (hfs_start_transaction(hfsmp) != 0) {
3024 retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
3025 HFS_PHYSBLK_ROUNDDOWN(priIDSector, hfsmp->hfs_log_per_phys),
3026 hfsmp->hfs_physical_block_size, NOCRED, &bp);
3031 hfs_end_transaction(hfsmp);
3037 if (hfsmp->jnl) {
3038 journal_modify_block_start(hfsmp->jnl, bp);
3042 HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
3071 retval = (int)buf_meta_bread(hfsmp->hfs_devvp,
3072 HFS_PHYSBLK_ROUNDDOWN(HFS_PRI_SECTOR(hfsmp->hfs_logical_block_size), hfsmp->hfs_log_per_phys),
3073 hfsmp->hfs_physical_block_size, NOCRED, &bp2);
3080 HFS_PRI_OFFSET(hfsmp->hfs_physical_block_size));
3084 if (hfsmp->jnl) {
3085 journal_modify_block_start(hfsmp->jnl, bp2);
3090 if (hfsmp->jnl) {
3091 journal_modify_block_end(hfsmp->jnl, bp2, NULL, NULL);
3103 lck_mtx_lock(&hfsmp->hfs_mutex);
3108 if (hfsmp->jnl) {
3185 if (hfsmp->hfs_attribute_vp) {
3186 fp = VTOF(hfsmp->hfs_attribute_vp);
3200 if (hfsmp->hfs_startup_vp) {
3201 fp = VTOF(hfsmp->hfs_startup_vp);
3217 MarkVCBClean(hfsmp);
3218 lck_mtx_unlock(&hfsmp->hfs_mutex);
3221 if (altflush && hfsmp->hfs_alt_id_sector) {
3224 if (buf_meta_bread(hfsmp->hfs_devvp,
3225 HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
3226 hfsmp->hfs_physical_block_size, NOCRED, &alt_bp) == 0) {
3227 if (hfsmp->jnl) {
3228 journal_modify_block_start(hfsmp->jnl, alt_bp);
3232 HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size),
3235 if (hfsmp->jnl) {
3236 journal_modify_block_end(hfsmp->jnl, alt_bp, NULL, NULL);
3244 if (hfsmp->jnl) {
3245 journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);
3253 (void) VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE,
3258 hfs_end_transaction(hfsmp);
3269 hfs_extendfs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)
3293 devvp = hfsmp->hfs_devvp;
3294 vcb = HFSTOVCB(hfsmp);
3302 (hfsmp->jnl == NULL) ||
3311 error = hfs_vget(hfsmp, kHFSRootFolderID, &vp, 0);
3315 error = hfs_owner_rights(hfsmp, VTOC(vp)->c_uid, cred, p, 0);
3331 if (sectorsize != hfsmp->hfs_logical_block_size) {
3349 oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;
3368 if (hfs_start_transaction(hfsmp) != 0) {
3376 lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
3507 prev_phys_block_count = hfsmp->hfs_logical_block_count;
3508 prev_alt_sector = hfsmp->hfs_alt_id_sector;
3512 hfsmp->hfs_logical_block_count = newsize / sectorsize;
3513 hfsmp->hfs_alt_id_sector = (hfsmp->hfsPlusIOPosOffset / sectorsize) +
3514 HFS_ALT_SECTOR(sectorsize, hfsmp->hfs_logical_block_count);
3516 error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
3536 hfsmp->hfs_logical_block_count = prev_phys_block_count;
3537 hfsmp->hfs_alt_id_sector = prev_alt_sector;
3550 if (buf_meta_bread(hfsmp->hfs_devvp,
3551 HFS_PHYSBLK_ROUNDDOWN(prev_alt_sector, hfsmp->hfs_log_per_phys),
3552 hfsmp->hfs_physical_block_size, NOCRED, &bp) == 0) {
3553 journal_modify_block_start(hfsmp->jnl, bp);
3555 bzero((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size), kMDBSize);
3557 journal_modify_block_end(hfsmp->jnl, bp, NULL, NULL);
3568 * Adjust the size of hfsmp->hfs_attrdata_vp
3570 if (hfsmp->hfs_attrdata_vp) {
3574 if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {
3575 attr_cp = VTOC(hfsmp->hfs_attrdata_vp);
3576 attr_fp = VTOF(hfsmp->hfs_attrdata_vp);
3581 attr_fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;
3582 ubc_setsize(hfsmp->hfs_attrdata_vp, attr_fp->ff_size);
3583 vnode_put(hfsmp->hfs_attrdata_vp);
3599 hfsmp->allocLimit = vcb->totalBlocks;
3600 hfs_systemfile_unlock(hfsmp, lockflags);
3601 hfs_end_transaction(hfsmp);
3613 hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, vfs_context_t context)
3623 lck_mtx_lock(&hfsmp->hfs_mutex);
3624 if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {
3625 lck_mtx_unlock(&hfsmp->hfs_mutex);
3628 hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;
3629 hfsmp->hfs_resize_filesmoved = 0;
3630 hfsmp->hfs_resize_totalfiles = 0;
3631 lck_mtx_unlock(&hfsmp->hfs_mutex);
3637 if ((hfsmp->jnl == NULL) ||
3638 (hfsmp->hfsPlusIOPosOffset != 0)) {
3642 oldsize = (u_int64_t)hfsmp->totalBlocks * (u_int64_t)hfsmp->blockSize;
3643 newblkcnt = newsize / hfsmp->blockSize;
3644 reclaimblks = hfsmp->totalBlocks - newblkcnt;
3649 (newsize % hfsmp->hfs_logical_block_size) ||
3650 (newsize % hfsmp->hfs_physical_block_size)) {
3656 if (reclaimblks >= hfs_freeblks(hfsmp, 1)) {
3657 printf("hfs_truncatefs: insufficient space (need %u blocks; have %u blocks)\n", reclaimblks, hfs_freeblks(hfsmp, 1));
3663 journal_flush(hfsmp->jnl);
3665 if (hfs_start_transaction(hfsmp) != 0) {
3680 lck_mtx_lock(&hfsmp->hfs_mutex);
3681 if (hfsmp->blockSize == 512)
3682 hfsmp->allocLimit = newblkcnt - 2;
3684 hfsmp->allocLimit = newblkcnt - 1;
3685 hfsmp->freeBlocks -= reclaimblks;
3686 lck_mtx_unlock(&hfsmp->hfs_mutex);
3692 if (hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks)) {
3697 hfs_end_transaction(hfsmp);
3701 if (hfs_reclaimspace(hfsmp, hfsmp->allocLimit, reclaimblks, context) != 0) {
3702 printf("hfs_truncatefs: couldn't reclaim space on %s\n", hfsmp->vcbVN);
3706 if (hfs_start_transaction(hfsmp) != 0) {
3713 if (hfs_isallocated(hfsmp, hfsmp->allocLimit, reclaimblks)) {
3714 printf("hfs_truncatefs: didn't reclaim enough space on %s\n", hfsmp->vcbVN);
3724 lockflags = hfs_systemfile_lock(hfsmp, SFL_ATTRIBUTE | SFL_EXTENTS | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
3730 if (hfsmp->blockSize == 512)
3731 (void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 2, 2);
3733 (void) BlockMarkFree(hfsmp, hfsmp->totalBlocks - 1, 1);
3738 error = BlockMarkAllocated(hfsmp, hfsmp->allocLimit, (hfsmp->blockSize == 512) ? 2 : 1);
3750 if (hfsmp->hfs_alt_id_sector) {
3751 if (buf_meta_bread(hfsmp->hfs_devvp,
3752 HFS_PHYSBLK_ROUNDDOWN(hfsmp->hfs_alt_id_sector, hfsmp->hfs_log_per_phys),
3753 hfsmp->hfs_physical_block_size, NOCRED, &bp) == 0) {
3755 bzero((void*)((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_physical_block_size)), kMDBSize);
3765 hfsmp->vcbVN, newblkcnt, hfsmp->totalBlocks);
3770 hfsmp->totalBlocks = newblkcnt;
3771 hfsmp->hfs_logical_block_count = newsize / hfsmp->hfs_logical_block_size;
3772 hfsmp->hfs_alt_id_sector = HFS_ALT_SECTOR(hfsmp->hfs_logical_block_size, hfsmp->hfs_logical_block_count);
3773 MarkVCBDirty(hfsmp);
3774 error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
3783 * Adjust the size of hfsmp->hfs_attrdata_vp
3785 if (hfsmp->hfs_attrdata_vp) {
3789 if (vnode_get(hfsmp->hfs_attrdata_vp) == 0) {
3790 cp = VTOC(hfsmp->hfs_attrdata_vp);
3791 fp = VTOF(hfsmp->hfs_attrdata_vp);
3796 fp->ff_size = (off_t) newblkcnt * hfsmp->blockSize;
3797 ubc_setsize(hfsmp->hfs_attrdata_vp, fp->ff_size);
3798 vnode_put(hfsmp->hfs_attrdata_vp);
3804 hfsmp->freeBlocks += reclaimblks;
3806 lck_mtx_lock(&hfsmp->hfs_mutex);
3807 hfsmp->allocLimit = hfsmp->totalBlocks;
3808 if (hfsmp->nextAllocation >= hfsmp->allocLimit)
3809 hfsmp->nextAllocation = hfsmp->hfs_metazone_end + 1;
3810 hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;
3811 lck_mtx_unlock(&hfsmp->hfs_mutex);
3814 hfs_systemfile_unlock(hfsmp, lockflags);
3817 hfs_end_transaction(hfsmp);
3818 journal_flush(hfsmp->jnl);
3866 struct hfsmount *hfsmp,
3882 u_int32_t sectorsPerBlock = hfsmp->blockSize / hfsmp->hfs_logical_block_size;
3892 if (cp != hfsmp->hfs_allocation_cp && cp->c_lockowner != current_thread())
3914 vfs_ioattr(hfsmp->hfs_mp, &ioattr);
3920 bp = buf_alloc(hfsmp->hfs_devvp);
3923 resid = (off_t) blockCount * (off_t) hfsmp->blockSize;
3924 srcSector = (daddr64_t) oldStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;
3925 destSector = (daddr64_t) newStart * hfsmp->blockSize / hfsmp->hfs_logical_block_size;
3928 ioSizeSectors = ioSize / hfsmp->hfs_logical_block_size;
3952 if (journal_uses_fua(hfsmp->jnl))
3956 vnode_startwrite(hfsmp->hfs_devvp);
3975 if (!journal_uses_fua(hfsmp->jnl)) {
3976 err = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
4003 * hfsmp The volume being resized.
4018 hfs_reclaim_sys_file(struct hfsmount *hfsmp, struct vnode *vp, u_long startblk, int locks, Boolean *moved, vfs_context_t context)
4039 error = hfs_start_transaction(hfsmp);
4044 lockflags = hfs_systemfile_lock(hfsmp, locks, HFS_EXCLUSIVE_LOCK);
4057 error = BlockAllocate(hfsmp, 1, blockCount, blockCount, true, true, &newStartBlock, &blockCount);
4066 error = hfs_copy_extent(hfsmp, vp, oldStartBlock, newStartBlock, blockCount, context);
4074 error = BlockDeallocate(hfsmp, oldStartBlock, blockCount);
4080 error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
4118 fcb = VTOF(hfsmp->hfs_extents_vp);
4138 error = BlockAllocate(hfsmp, 1, blockCount, blockCount, true, true, &newStartBlock, &blockCount);
4148 error = hfs_copy_extent(hfsmp, vp, oldStartBlock, newStartBlock, blockCount, context);
4171 error = BlockDeallocate(hfsmp, oldStartBlock, blockCount);
4193 hfs_systemfile_unlock(hfsmp, lockflags);
4194 error = hfs_end_transaction(hfsmp);
4202 (void) BlockDeallocate(hfsmp, newStartBlock, blockCount);
4204 (void) hfs_systemfile_unlock(hfsmp, lockflags);
4205 (void) hfs_end_transaction(hfsmp);
4223 struct hfsmount *hfsmp;
4233 struct hfsmount *hfsmp = args->hfsmp;
4237 error = buf_meta_bread(hfsmp->hfs_devvp,
4238 hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
4239 hfsmp->blockSize, vfs_context_ucred(args->context), &bp);
4245 jibp->offset = SWAP_BE64((u_int64_t)args->newStartBlock * hfsmp->blockSize);
4246 jibp->size = SWAP_BE64(hfsmp->jnl_size);
4247 if (journal_uses_fua(hfsmp->jnl))
4254 if (!journal_uses_fua(hfsmp->jnl)) {
4255 error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, args->context);
4267 hfs_reclaim_journal_file(struct hfsmount *hfsmp, vfs_context_t context)
4279 error = hfs_start_transaction(hfsmp);
4284 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
4286 oldBlockCount = hfsmp->jnl_size / hfsmp->blockSize;
4289 error = BlockAllocate(hfsmp, 1, oldBlockCount, oldBlockCount, true, true, &newStartBlock, &newBlockCount);
4299 error = BlockDeallocate(hfsmp, hfsmp->jnl_start, oldBlockCount);
4306 error = cat_idlookup(hfsmp, hfsmp->hfs_jnlfileid, 1, &journal_desc, &journal_attr, &journal_fork);
4311 journal_fork.cf_size = newBlockCount * hfsmp->blockSize;
4315 error = cat_update(hfsmp, &journal_desc, &journal_attr, &journal_fork, NULL);
4321 callback_args.hfsmp = hfsmp;
4325 error = journal_relocate(hfsmp->jnl, (off_t)newStartBlock*hfsmp->blockSize,
4326 (off_t)newBlockCount*hfsmp->blockSize, 0,
4333 hfsmp->jnl_start = newStartBlock;
4334 hfsmp->jnl_size = (off_t)newBlockCount * hfsmp->blockSize;
4336 hfs_systemfile_unlock(hfsmp, lockflags);
4337 error = hfs_end_transaction(hfsmp);
4345 (void) BlockDeallocate(hfsmp, newStartBlock, newBlockCount);
4347 hfs_systemfile_unlock(hfsmp, lockflags);
4348 (void) hfs_end_transaction(hfsmp);
4359 hfs_reclaim_journal_info_block(struct hfsmount *hfsmp, vfs_context_t context)
4370 error = hfs_start_transaction(hfsmp);
4375 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_BITMAP, HFS_EXCLUSIVE_LOCK);
4377 error = BlockAllocate(hfsmp, 1, 1, 1, true, true, &newBlock, &blockCount);
4386 error = BlockDeallocate(hfsmp, hfsmp->vcbJinfoBlock, 1);
4393 error = buf_meta_bread(hfsmp->hfs_devvp,
4394 hfsmp->vcbJinfoBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
4395 hfsmp->blockSize, vfs_context_ucred(context), &old_bp);
4400 new_bp = buf_getblk(hfsmp->hfs_devvp,
4401 newBlock * (hfsmp->blockSize/hfsmp->hfs_logical_block_size),
4402 hfsmp->blockSize, 0, 0, BLK_META);
4403 bcopy((char*)buf_dataptr(old_bp), (char*)buf_dataptr(new_bp), hfsmp->blockSize);
4405 if (journal_uses_fua(hfsmp->jnl))
4412 if (!journal_uses_fua(hfsmp->jnl)) {
4413 error = VNOP_IOCTL(hfsmp->hfs_devvp, DKIOCSYNCHRONIZECACHE, NULL, FWRITE, context);
4421 error = cat_idlookup(hfsmp, hfsmp->hfs_jnlinfoblkid, 1, &jib_desc, &jib_attr, &jib_fork);
4426 jib_fork.cf_size = hfsmp->blockSize;
4430 error = cat_update(hfsmp, &jib_desc, &jib_attr, &jib_fork, NULL);
4438 hfsmp->vcbJinfoBlock = newBlock;
4439 error = hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
4444 hfs_systemfile_unlock(hfsmp, lockflags);
4445 error = hfs_end_transaction(hfsmp);
4449 error = journal_flush(hfsmp->jnl);
4456 (void) BlockDeallocate(hfsmp, newBlock, blockCount);
4458 hfs_systemfile_unlock(hfsmp, lockflags);
4459 (void) hfs_end_transaction(hfsmp);
4468 hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks, vfs_context_t context)
4491 error = hfs_reclaim_sys_file(hfsmp, hfsmp->hfs_allocation_vp, startblk, SFL_BITMAP, &system_file_moved, context);
4497 error = hfs_reclaim_sys_file(hfsmp, hfsmp->hfs_extents_vp, startblk, SFL_EXTENTS, &system_file_moved, context);
4503 error = hfs_reclaim_sys_file(hfsmp, hfsmp->hfs_catalog_vp, startblk, SFL_CATALOG, &system_file_moved, context);
4509 error = hfs_reclaim_sys_file(hfsmp, hfsmp->hfs_attribute_vp, startblk, SFL_ATTRIBUTE, &system_file_moved, context);
4515 error = hfs_reclaim_sys_file(hfsmp, hfsmp->hfs_startup_vp, startblk, SFL_STARTUP, &system_file_moved, context);
4532 journal_flush(hfsmp->jnl);
4534 if (hfsmp->jnl_start + (hfsmp->jnl_size / hfsmp->blockSize) > startblk) {
4535 error = hfs_reclaim_journal_file(hfsmp, context);
4542 if (hfsmp->vcbJinfoBlock >= startblk) {
4543 error = hfs_reclaim_journal_info_block(hfsmp, context);
4551 maxfilecnt = MIN(hfsmp->hfs_filecount, 250000);
4562 saved_next_allocation = hfsmp->nextAllocation;
4563 HFS_UPDATE_NEXT_ALLOCATION(hfsmp, hfsmp->hfs_metazone_start);
4565 fcb = VTOF(hfsmp->hfs_catalog_vp);
4573 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS, HFS_SHARED_LOCK);
4604 if ((filerec.fileID == hfsmp->hfs_jnlfileid) ||
4605 (filerec.fileID == hfsmp->hfs_jnlinfoblkid)) {
4631 if (hfs_overlapped_overflow_extents(hfsmp, startblk, datablks, filerec.fileID, 0)) {
4636 if (hfs_overlapped_overflow_extents(hfsmp, startblk, rsrcblks, filerec.fileID, 1)) {
4650 hfs_systemfile_unlock(hfsmp, lockflags);
4673 if (blkstomove >= hfs_freeblks(hfsmp, 1)) {
4674 printf("hfs_truncatefs: insufficient space (need %lu blocks; have %u blocks)\n", blkstomove, hfs_freeblks(hfsmp, 1));
4678 hfsmp->hfs_resize_filesmoved = 0;
4679 hfsmp->hfs_resize_totalfiles = filecnt;
4686 if (hfs_vget(hfsmp, cnidbufp[i], &vp, 0) != 0)
4700 error = hfs_relocate(vp, hfsmp->hfs_metazone_end + 1, kauth_cred_get(), current_proc());
4707 error = hfs_vgetrsrc(hfsmp, vp, &rvp, TRUE);
4710 error = hfs_relocate(rvp, hfsmp->hfs_metazone_end + 1, kauth_cred_get(), current_proc());
4719 ++hfsmp->hfs_resize_filesmoved;
4737 if (hfsmp->hfs_resize_filesmoved != 0) {
4739 (int)hfsmp->hfs_resize_filesmoved, hfsmp->vcbVN);
4749 if (error && hfsmp->hfs_resize_filesmoved == 0) {
4750 HFS_UPDATE_NEXT_ALLOCATION(hfsmp, saved_next_allocation);
4760 hfs_overlapped_overflow_extents(struct hfsmount *hfsmp, u_int32_t startblk, u_int32_t catblks, u_int32_t fileID, int rsrcfork)
4788 fcb = VTOF(hfsmp->hfs_extents_vp);
4824 hfs_resize_progress(struct hfsmount *hfsmp, u_int32_t *progress)
4826 if ((hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) == 0) {
4830 if (hfsmp->hfs_resize_totalfiles > 0)
4831 *progress = (hfsmp->hfs_resize_filesmoved * 100) / hfsmp->hfs_resize_totalfiles;
4849 struct hfsmount *hfsmp = VFSTOHFS(mp);
4852 freeCNIDs = (u_long)0xFFFFFFFF - (u_long)hfsmp->vcbNxtCNID;
4854 VFSATTR_RETURN(fsap, f_objcount, (u_int64_t)hfsmp->vcbFilCnt + (u_int64_t)hfsmp->vcbDirCnt);
4855 VFSATTR_RETURN(fsap, f_filecount, (u_int64_t)hfsmp->vcbFilCnt);
4856 VFSATTR_RETURN(fsap, f_dircount, (u_int64_t)hfsmp->vcbDirCnt);
4859 VFSATTR_RETURN(fsap, f_blocks, (u_int64_t)hfsmp->totalBlocks);
4860 VFSATTR_RETURN(fsap, f_bfree, (u_int64_t)hfs_freeblks(hfsmp, 0));
4861 VFSATTR_RETURN(fsap, f_bavail, (u_int64_t)hfs_freeblks(hfsmp, 1));
4864 VFSATTR_RETURN(fsap, f_bused, hfsmp->totalBlocks - hfs_freeblks(hfsmp, 1));
4866 VFSATTR_RETURN(fsap, f_files, (u_int64_t)(hfsmp->totalBlocks - 2));
4867 VFSATTR_RETURN(fsap, f_ffree, MIN((u_int64_t)freeCNIDs, (u_int64_t)hfs_freeblks(hfsmp, 1)));
4869 fsap->f_fsid.val[0] = hfsmp->hfs_raw_dev;
4881 if (hfsmp->hfs_flags & HFS_STANDARD) {
4895 (hfsmp->jnl ? VOL_CAP_FMT_JOURNAL_ACTIVE : 0) |
4896 (hfsmp->hfs_flags & HFS_CASE_SENSITIVE ? VOL_CAP_FMT_CASE_SENSITIVE : 0) |
4976 fsap->f_create_time.tv_sec = hfsmp->vcbCrDate;
4979 fsap->f_modify_time.tv_sec = hfsmp->vcbLsMod;
4983 fsap->f_backup_time.tv_sec = hfsmp->vcbVolBkUp;
4999 if (hfsmp->hfs_flags & HFS_STANDARD) {
5002 if (hfsmp->jnl)
5004 if (hfsmp->hfs_flags & HFS_CASE_SENSITIVE)
5012 strlcpy(fsap->f_vol_name, (char *) hfsmp->vcbVN, MAXPATHLEN);
5026 struct hfsmount *hfsmp = VTOHFS(vp);
5056 if ((error = hfs_start_transaction(hfsmp)) == 0) {
5057 if ((error = cat_preflight(hfsmp, CAT_RENAME, &cookie, p)) == 0) {
5058 lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_EXCLUSIVE_LOCK);
5060 error = cat_rename(hfsmp, &cp->c_desc, &todir_desc, &to_desc, &new_desc);
5069 hfs_systemfile_unlock(hfsmp, lockflags);
5070 cat_postflight(hfsmp, &cookie, p);
5074 (void) hfs_flushvolumeheader(hfsmp, MNT_WAIT, 0);
5076 hfs_end_transaction(hfsmp);
5142 void hfs_mark_volume_inconsistent(struct hfsmount *hfsmp)
5144 HFS_MOUNT_LOCK(hfsmp, TRUE);
5145 if ((hfsmp->vcbAtrb & kHFSVolumeInconsistentMask) == 0) {
5146 hfsmp->vcbAtrb |= kHFSVolumeInconsistentMask;
5147 MarkVCBDirty(hfsmp);
5150 fslog_fs_corrupt(hfsmp->hfs_mp);
5151 printf("HFS: Runtime corruption detected on %s, fsck will be forced on next mount.\n", hfsmp->vcbVN);
5152 HFS_MOUNT_UNLOCK(hfsmp, TRUE);