xnu-792.21.3.tar.gz

[apple/xnu.git] / bsd / hfs / hfs_vfsops.c

diff --git a/bsd/hfs/hfs_vfsops.c b/bsd/hfs/hfs_vfsops.c
index 7d7094a78cc85c98a5c9a2efb8bd3fdf23d62b6f..ada09a3d135a00297911d068d6769c41d7ed7a0e 100644 (file)
--- a/bsd/hfs/hfs_vfsops.c
+++ b/bsd/hfs/hfs_vfsops.c
@@ -146,9 +146,7 @@ static int hfs_unmount(struct mount *mp, int mntflags, vfs_context_t context);
 static int hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);
 static int hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t context);
 
 static int hfs_vfs_vget(struct mount *mp, ino64_t ino, struct vnode **vpp, vfs_context_t context);
 static int hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t context);
 

-static int hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks);
-static int hfs_overlapped_overflow_extents(struct hfsmount *hfsmp, u_int32_t startblk,
-                                           u_int32_t catblks, u_int32_t fileID, int rsrcfork);
+static int hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk);

 
 
 /*
 
 
 /*


@@ -1569,9 +1567,9 @@ hfs_sync_metadata(void *arg)
        priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / sectorsize) +
                                  HFS_PRI_SECTOR(sectorsize));
        retval = (int)buf_meta_bread(hfsmp->hfs_devvp, priIDSector, sectorsize, NOCRED, &bp);
        priIDSector = (daddr64_t)((vcb->hfsPlusIOPosOffset / sectorsize) +
                                  HFS_PRI_SECTOR(sectorsize));
        retval = (int)buf_meta_bread(hfsmp->hfs_devvp, priIDSector, sectorsize, NOCRED, &bp);

-       if ((retval != 0) && (retval != ENXIO)) {
-               printf("hfs_sync_metadata: can't read volume header at %d! (retval 0x%x)\n",
-                       priIDSector, retval);
+       if (retval != 0) {
+               panic("hfs: sync_metadata: can't read super-block?! (retval 0x%x, priIDSector)\n",
+                         retval, priIDSector);

        }
 
        if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {
        }
 
        if (retval == 0 && ((buf_flags(bp) & (B_DELWRI | B_LOCKED)) == B_DELWRI)) {


@@ -1773,7 +1771,7 @@ hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp,
        if (fhlen < sizeof(struct hfsfid))
                return (EINVAL);
 
        if (fhlen < sizeof(struct hfsfid))
                return (EINVAL);
 

-       result = hfs_vget(VFSTOHFS(mp), ntohl(hfsfhp->hfsfid_cnid), &nvp, 0);
+       result = hfs_vget(VFSTOHFS(mp), hfsfhp->hfsfid_cnid, &nvp, 0);

        if (result) {
                if (result == ENOENT)
                        result = ESTALE;
        if (result) {
                if (result == ENOENT)
                        result = ESTALE;


@@ -1791,7 +1789,7 @@ hfs_fhtovp(struct mount *mp, int fhlen, unsigned char *fhp, struct vnode **vpp,
         * error prone. Future, would be change the "wrap bit" to a unique
         * wrap number and use that for generation number. For now do this.
         */  
         * error prone. Future, would be change the "wrap bit" to a unique
         * wrap number and use that for generation number. For now do this.
         */  

-       if ((ntohl(hfsfhp->hfsfid_gen) < VTOC(nvp)->c_itime)) {
+       if ((hfsfhp->hfsfid_gen < VTOC(nvp)->c_itime)) {

                hfs_unlock(VTOC(nvp));
                vnode_put(nvp);
                return (ESTALE);
                hfs_unlock(VTOC(nvp));
                vnode_put(nvp);
                return (ESTALE);


@@ -1821,8 +1819,8 @@ hfs_vptofh(struct vnode *vp, int *fhlenp, unsigned char *fhp, vfs_context_t cont
 
        cp = VTOC(vp);
        hfsfhp = (struct hfsfid *)fhp;
 
        cp = VTOC(vp);
        hfsfhp = (struct hfsfid *)fhp;

-       hfsfhp->hfsfid_cnid = htonl(cp->c_fileid);
-       hfsfhp->hfsfid_gen = htonl(cp->c_itime);
+       hfsfhp->hfsfid_cnid = cp->c_fileid;
+       hfsfhp->hfsfid_gen = cp->c_itime;

        *fhlenp = sizeof(struct hfsfid);
        
        return (0);
        *fhlenp = sizeof(struct hfsfid);
        
        return (0);


@@ -1853,7 +1851,10 @@ hfs_init(__unused struct vfsconf *vfsp)
        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_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);

-       
+
+       /* Turn on lock debugging */
+       //lck_attr_setdebug(hfs_lock_attr);
+

 
        return (0);
 }
 
        return (0);
 }


@@ -2026,16 +2027,6 @@ hfs_sysctl(int *name, __unused u_int namelen, user_addr_t oldp, size_t *oldlenp,
 
                hfs_global_exclusive_lock_acquire(hfsmp);
                
 
                hfs_global_exclusive_lock_acquire(hfsmp);
                

-               /*
-                * Flush all dirty metadata buffers.
-                */
-               buf_flushdirtyblks(hfsmp->hfs_devvp, MNT_WAIT, 0, "hfs_sysctl");
-               buf_flushdirtyblks(hfsmp->hfs_extents_vp, MNT_WAIT, 0, "hfs_sysctl");
-               buf_flushdirtyblks(hfsmp->hfs_catalog_vp, MNT_WAIT, 0, "hfs_sysctl");
-               buf_flushdirtyblks(hfsmp->hfs_allocation_vp, MNT_WAIT, 0, "hfs_sysctl");
-               if (hfsmp->hfs_attribute_vp)
-                       buf_flushdirtyblks(hfsmp->hfs_attribute_vp, MNT_WAIT, 0, "hfs_sysctl");
-

                HFSTOVCB(hfsmp)->vcbJinfoBlock = name[1];
                HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeJournaledMask;
                hfsmp->jvp = jvp;
                HFSTOVCB(hfsmp)->vcbJinfoBlock = name[1];
                HFSTOVCB(hfsmp)->vcbAtrb |= kHFSVolumeJournaledMask;
                hfsmp->jvp = jvp;


@@ -2236,6 +2227,11 @@ hfs_vget(struct hfsmount *hfsmp, cnid_t cnid, struct vnode **vpp, int skiplock)
                    (bcmp(cndesc.cd_nameptr, HFS_INODE_PREFIX, HFS_INODE_PREFIX_LEN) == 0)) {
                        linkref = strtoul((const char*)&cndesc.cd_nameptr[HFS_INODE_PREFIX_LEN], NULL, 10);
                        cnattr.ca_rdev = linkref;
                    (bcmp(cndesc.cd_nameptr, HFS_INODE_PREFIX, HFS_INODE_PREFIX_LEN) == 0)) {
                        linkref = strtoul((const char*)&cndesc.cd_nameptr[HFS_INODE_PREFIX_LEN], NULL, 10);
                        cnattr.ca_rdev = linkref;

+
+                       // patch up the parentcnid
+                       if (cnattr.ca_attrblks != 0) {
+                           cndesc.cd_parentcnid = cnattr.ca_attrblks;
+                       }

                }
        }
 
                }
        }
 


@@ -3022,6 +3018,7 @@ __private_extern__
 int
 hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t context)
 {
 int
 hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t context)
 {

+       struct vnode* rvp = NULL;

        struct  buf *bp = NULL;
        u_int64_t oldsize;
        u_int32_t newblkcnt;
        struct  buf *bp = NULL;
        u_int64_t oldsize;
        u_int32_t newblkcnt;


@@ -3030,22 +3027,20 @@ hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t
        int transaction_begun = 0;
        int error;
 
        int transaction_begun = 0;
        int error;
 

-       
-       lck_mtx_lock(&hfsmp->hfs_mutex);
-       if (hfsmp->hfs_flags & HFS_RESIZE_IN_PROGRESS) {
-               lck_mtx_unlock(&hfsmp->hfs_mutex);
-               return (EALREADY);
+       /*
+        * Grab the root vnode to serialize with another hfs_truncatefs call.
+        */
+       error = hfs_vget(hfsmp, kHFSRootFolderID, &rvp, 0);
+       if (error) {
+               return (error);

        }
        }

-       hfsmp->hfs_flags |= HFS_RESIZE_IN_PROGRESS;
-       hfsmp->hfs_resize_filesmoved = 0;
-       hfsmp->hfs_resize_totalfiles = 0;
-       lck_mtx_unlock(&hfsmp->hfs_mutex);
-

        /*
        /*

-        * - Journaled HFS Plus volumes only.
+        * - HFS Plus file systems only. 
+        * - Journaling must be enabled.

         * - No embedded volumes.
         */
         * - No embedded volumes.
         */

-       if ((hfsmp->jnl == NULL) ||
+       if ((hfsmp->hfs_flags & HFS_STANDARD) ||
+           (hfsmp->jnl == NULL) ||

            (hfsmp->hfsPlusIOPosOffset != 0)) {
                error = EPERM;
                goto out;
            (hfsmp->hfsPlusIOPosOffset != 0)) {
                error = EPERM;
                goto out;


@@ -3062,12 +3057,13 @@ hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t
                goto out;
        }
        /* Make sure there's enough space to work with. */
                goto out;
        }
        /* Make sure there's enough space to work with. */

-       if (reclaimblks >= hfs_freeblks(hfsmp, 1)) {
+       if (reclaimblks > (hfsmp->freeBlocks / 4)) {

                error = ENOSPC;
                goto out;
        }
                error = ENOSPC;
                goto out;
        }

-       /* Start with a clean journal. */
-       journal_flush(hfsmp->jnl);
+
+       printf("hfs_truncatefs: shrinking %s by %d blocks out of %d\n",
+              hfsmp->vcbVN, reclaimblks, hfsmp->totalBlocks);

 
        if (hfs_start_transaction(hfsmp) != 0) {
                error = EINVAL;
 
        if (hfs_start_transaction(hfsmp) != 0) {
                error = EINVAL;


@@ -3087,7 +3083,7 @@ hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t
                transaction_begun = 0;
 
                /* Attempt to reclaim some space. */ 
                transaction_begun = 0;
 
                /* Attempt to reclaim some space. */ 

-               if (hfs_reclaimspace(hfsmp, newblkcnt, reclaimblks) != 0) {
+               if (hfs_reclaimspace(hfsmp, newblkcnt) != 0) {

                        printf("hfs_truncatefs: couldn't reclaim space on %s\n", hfsmp->vcbVN);
                        error = ENOSPC;
                        goto out;
                        printf("hfs_truncatefs: couldn't reclaim space on %s\n", hfsmp->vcbVN);
                        error = ENOSPC;
                        goto out;


@@ -3101,7 +3097,7 @@ hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t
                /* Check if we're clear now. */
                if (hfs_isallocated(hfsmp, newblkcnt, reclaimblks - 1)) {
                        printf("hfs_truncatefs: didn't reclaim enough space on %s\n", hfsmp->vcbVN);
                /* Check if we're clear now. */
                if (hfs_isallocated(hfsmp, newblkcnt, reclaimblks - 1)) {
                        printf("hfs_truncatefs: didn't reclaim enough space on %s\n", hfsmp->vcbVN);

-                       error = EAGAIN;  /* tell client to try again */
+                       error = ENOSPC;

                        goto out;
                }
        }
                        goto out;
                }
        }


@@ -3130,26 +3126,21 @@ hfs_truncatefs(struct hfsmount *hfsmp, u_int64_t newsize, __unused vfs_context_t
 
        /*
         * Invalidate the existing alternate volume header.
 
        /*
         * Invalidate the existing alternate volume header.

-        *
-        * Don't do this as a transaction (don't call journal_modify_block)
-        * since this block will be outside of the truncated file system!

         */
        if (hfsmp->hfs_alt_id_sector) {
                if (buf_meta_bread(hfsmp->hfs_devvp, hfsmp->hfs_alt_id_sector,
                                   hfsmp->hfs_phys_block_size, NOCRED, &bp) == 0) {
         */
        if (hfsmp->hfs_alt_id_sector) {
                if (buf_meta_bread(hfsmp->hfs_devvp, hfsmp->hfs_alt_id_sector,
                                   hfsmp->hfs_phys_block_size, NOCRED, &bp) == 0) {

+                       journal_modify_block_start(hfsmp->jnl, bp);

        
                        bzero((void*)((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_phys_block_size)), kMDBSize);
        
                        bzero((void*)((char *)buf_dataptr(bp) + HFS_ALT_OFFSET(hfsmp->hfs_phys_block_size)), kMDBSize);

-                       (void) VNOP_BWRITE(bp);
+       
+                       journal_modify_block_end(hfsmp->jnl, bp);

                } else if (bp) {
                        buf_brelse(bp);
                }
                bp = NULL;
        }
 
                } else if (bp) {
                        buf_brelse(bp);
                }
                bp = NULL;
        }
 

-       /* Log successful shrinking. */
-       printf("hfs_truncatefs: shrank \"%s\" to %d blocks (was %d blocks)\n",
-              hfsmp->vcbVN, newblkcnt, hfsmp->totalBlocks);
-

        /*
         * Adjust file system variables and flush them to disk.
         */
        /*
         * Adjust file system variables and flush them to disk.
         */


@@ -3167,90 +3158,54 @@ out:
        }
        if (transaction_begun) {
                hfs_end_transaction(hfsmp);
        }
        if (transaction_begun) {
                hfs_end_transaction(hfsmp);

-               journal_flush(hfsmp->jnl);

        }
        }

-
-       lck_mtx_lock(&hfsmp->hfs_mutex);
-       hfsmp->hfs_flags &= ~HFS_RESIZE_IN_PROGRESS;
-       lck_mtx_unlock(&hfsmp->hfs_mutex);
-
+       if (rvp) {
+               hfs_unlock(VTOC(rvp));
+               vnode_put(rvp);
+       }

        return (error);
 }
 
        return (error);
 }
 

-

 /*
  * Reclaim space at the end of a file system.
  */
 static int
 /*
  * Reclaim space at the end of a file system.
  */
 static int

-hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks)
+hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk)

 {
        struct vnode *vp = NULL;
        FCB *fcb;
        struct BTreeIterator * iterator = NULL;
        struct FSBufferDescriptor btdata;
        struct HFSPlusCatalogFile filerec;
 {
        struct vnode *vp = NULL;
        FCB *fcb;
        struct BTreeIterator * iterator = NULL;
        struct FSBufferDescriptor btdata;
        struct HFSPlusCatalogFile filerec;

-       struct filefork *fp;

        u_int32_t  saved_next_allocation;
        cnid_t * cnidbufp;
        size_t cnidbufsize;
        u_int32_t  saved_next_allocation;
        cnid_t * cnidbufp;
        size_t cnidbufsize;

-       int filecnt = 0;
+       int filecnt;

        int maxfilecnt;
        u_long block;
        int maxfilecnt;
        u_long block;

-       u_long datablks;
-       u_long rsrcblks;
-       u_long blkstomove = 0;

        int lockflags;
        int i;
        int error;
        int lockflags;
        int i;
        int error;

-       int lastprogress = 0;
-

 
 

-       /* Check if Attributes file overlaps reclaim area. */
+       /* 
+        * Check if Attributes file overlaps.
+        */

        if (hfsmp->hfs_attribute_vp) {
        if (hfsmp->hfs_attribute_vp) {

+               struct filefork *fp;
+       

                fp = VTOF(hfsmp->hfs_attribute_vp);
                fp = VTOF(hfsmp->hfs_attribute_vp);

-               datablks = 0;

                for (i = 0; i < kHFSPlusExtentDensity; ++i) {
                for (i = 0; i < kHFSPlusExtentDensity; ++i) {

-                       if (fp->ff_extents[i].blockCount == 0) {
-                               break;
-                       }
-                       datablks += fp->ff_extents[i].blockCount;
-                       block = fp->ff_extents[i].startBlock + fp->ff_extents[i].blockCount;
+                       block = fp->ff_extents[i].startBlock +
+                               fp->ff_extents[i].blockCount;

                        if (block >= startblk) {
                                printf("hfs_reclaimspace: Attributes file can't move\n");
                                return (EPERM);
                        }
                }
                        if (block >= startblk) {
                                printf("hfs_reclaimspace: Attributes file can't move\n");
                                return (EPERM);
                        }
                }

-               if ((i == kHFSPlusExtentDensity) && (fp->ff_blocks > datablks)) {
-                       if (hfs_overlapped_overflow_extents(hfsmp, startblk, datablks, kHFSAttributesFileID, 0)) {
-                               printf("hfs_reclaimspace: Attributes file can't move\n");
-                               return (EPERM);
-                       }
-               }
-       }
-       /* Check if Catalog file overlaps reclaim area. */
-       fp = VTOF(hfsmp->hfs_catalog_vp);
-       datablks = 0;
-       for (i = 0; i < kHFSPlusExtentDensity; ++i) {
-               if (fp->ff_extents[i].blockCount == 0) {
-                       break;
-               }
-               datablks += fp->ff_extents[i].blockCount;
-               block = fp->ff_extents[i].startBlock + fp->ff_extents[i].blockCount;
-               if (block >= startblk) {
-                       printf("hfs_reclaimspace: Catalog file can't move\n");
-                       return (EPERM);
-               }
-       }
-       if ((i == kHFSPlusExtentDensity) && (fp->ff_blocks > datablks)) {
-               if (hfs_overlapped_overflow_extents(hfsmp, startblk, datablks, kHFSCatalogFileID, 0)) {
-                       printf("hfs_reclaimspace: Catalog file can't move\n");
-                       return (EPERM);
-               }

        }
 
        }
 

-       /* For now move a maximum of 250,000 files. */
-       maxfilecnt = MIN(hfsmp->hfs_filecount, 250000);
-       maxfilecnt = MIN((u_long)maxfilecnt, reclaimblks);
+       /* For now we'll move a maximum of 16,384 files. */
+       maxfilecnt = MIN(hfsmp->hfs_filecount, 16384);

        cnidbufsize = maxfilecnt * sizeof(cnid_t);
        if (kmem_alloc(kernel_map, (vm_offset_t *)&cnidbufp, cnidbufsize)) {
                return (ENOMEM);
        cnidbufsize = maxfilecnt * sizeof(cnid_t);
        if (kmem_alloc(kernel_map, (vm_offset_t *)&cnidbufp, cnidbufsize)) {
                return (ENOMEM);


@@ -3270,13 +3225,14 @@ hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks)
        btdata.itemSize = sizeof(filerec);
        btdata.itemCount = 1;
 
        btdata.itemSize = sizeof(filerec);
        btdata.itemCount = 1;
 

-       /* Keep the Catalog and extents files locked during iteration. */
-       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG | SFL_EXTENTS, HFS_SHARED_LOCK);
-
+       /* Keep the Catalog file locked during iteration. */
+       lockflags = hfs_systemfile_lock(hfsmp, SFL_CATALOG, HFS_SHARED_LOCK);

        error = BTIterateRecord(fcb, kBTreeFirstRecord, iterator, NULL, NULL);
        if (error) {
        error = BTIterateRecord(fcb, kBTreeFirstRecord, iterator, NULL, NULL);
        if (error) {

-               goto end_iteration;
+               hfs_systemfile_unlock(hfsmp, lockflags);
+               goto out;

        }
        }

+

        /*
         * Iterate over all the catalog records looking for files
         * that overlap into the space we're trying to free up.
        /*
         * Iterate over all the catalog records looking for files
         * that overlap into the space we're trying to free up.


@@ -3284,99 +3240,41 @@ hfs_reclaimspace(struct hfsmount *hfsmp, u_long startblk, u_long reclaimblks)
        for (filecnt = 0; filecnt < maxfilecnt; ) {
                error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
                if (error) {
        for (filecnt = 0; filecnt < maxfilecnt; ) {
                error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
                if (error) {

-                       if (error == fsBTRecordNotFoundErr || error == fsBTEndOfIterationErr) {
-                               error = 0;                              
-                       }
+                       if (error == btNotFound)
+                               error = 0;

                        break;
                }
                        break;
                }

-               if (filerec.recordType != kHFSPlusFileRecord) {
+               if (filerec.recordType != kHFSPlusFileRecord ||
+                   filerec.fileID == hfsmp->hfs_jnlfileid)

                        continue;
                        continue;

-               }
-               datablks = rsrcblks = 0;

                /* 
                 * Check if either fork overlaps target space.
                 */
                for (i = 0; i < kHFSPlusExtentDensity; ++i) {
                /* 
                 * Check if either fork overlaps target space.
                 */
                for (i = 0; i < kHFSPlusExtentDensity; ++i) {

-                       if (filerec.dataFork.extents[i].blockCount != 0) {
-                               datablks += filerec.dataFork.extents[i].blockCount;
-                               block = filerec.dataFork.extents[i].startBlock +
-                                               filerec.dataFork.extents[i].blockCount;
-                               if (block >= startblk) {
-                                       if ((filerec.fileID == hfsmp->hfs_jnlfileid) ||
-                                               (filerec.fileID == hfsmp->hfs_jnlinfoblkid)) {
-                                               printf("hfs_reclaimspace: cannot move active journal\n");
-                                               error = EPERM;
-                                               goto end_iteration;
-                                       }
-                                       cnidbufp[filecnt++] = filerec.fileID;
-                                       blkstomove += filerec.dataFork.totalBlocks;
-                                       break;
-                               }
-                       }
-                       if (filerec.resourceFork.extents[i].blockCount != 0) {
-                               rsrcblks += filerec.resourceFork.extents[i].blockCount;
-                               block = filerec.resourceFork.extents[i].startBlock +
-                                               filerec.resourceFork.extents[i].blockCount;
-                               if (block >= startblk) {
-                                       cnidbufp[filecnt++] = filerec.fileID;
-                                       blkstomove += filerec.resourceFork.totalBlocks;
+                       block = filerec.dataFork.extents[i].startBlock +
+                               filerec.dataFork.extents[i].blockCount;
+                       if (block >= startblk) {
+                               if (filerec.fileID == hfsmp->hfs_jnlfileid) {
+                                       printf("hfs_reclaimspace: cannot move active journal\n");
+                                       error = EPERM;

                                        break;
                                }
                                        break;
                                }

+                               cnidbufp[filecnt++] = filerec.fileID;
+                               break;

                        }
                        }

-               }
-               /*
-                * Check for any overflow extents that overlap.
-                */
-               if (i == kHFSPlusExtentDensity) {
-                       if (filerec.dataFork.totalBlocks > datablks) {
-                               if (hfs_overlapped_overflow_extents(hfsmp, startblk, datablks, filerec.fileID, 0)) {
-                                       cnidbufp[filecnt++] = filerec.fileID;
-                                       blkstomove += filerec.dataFork.totalBlocks;
-                               }
-                       } else if (filerec.resourceFork.totalBlocks > rsrcblks) {
-                               if (hfs_overlapped_overflow_extents(hfsmp, startblk, rsrcblks, filerec.fileID, 1)) {
-                                       cnidbufp[filecnt++] = filerec.fileID;
-                                       blkstomove += filerec.resourceFork.totalBlocks;
-                               }
+                       block = filerec.resourceFork.extents[i].startBlock +
+                               filerec.resourceFork.extents[i].blockCount;
+                       if (block >= startblk) {
+                               cnidbufp[filecnt++] = filerec.fileID;
+                               break;

                        }
                }
        }
                        }
                }
        }

-
-end_iteration:
-       if (filecnt == 0) {
-               error = ENOSPC;
-       }

        /* All done with catalog. */
        hfs_systemfile_unlock(hfsmp, lockflags);
        if (error)
                goto out;
 
        /* All done with catalog. */
        hfs_systemfile_unlock(hfsmp, lockflags);
        if (error)
                goto out;
 

-       /*
-        * Double check space requirements to make sure
-        * there is enough space to relocate any files
-        * that reside in the reclaim area.
-        *
-        *                                          Blocks To Move --------------
-        *                                                            |    |    |
-        *                                                            V    V    V
-        * ------------------------------------------------------------------------
-        * |                                                        | /   ///  // |
-        * |                                                        | /   ///  // |
-        * |                                                        | /   ///  // |
-        * ------------------------------------------------------------------------
-        *
-        * <------------------- New Total Blocks ------------------><-- Reclaim -->
-        *
-        * <------------------------ Original Total Blocks ----------------------->
-        *
-        */
-       if ((reclaimblks + blkstomove) >= hfs_freeblks(hfsmp, 1)) {
-               error = ENOSPC;
-               goto out;
-       }
-       hfsmp->hfs_resize_filesmoved = 0;
-       hfsmp->hfs_resize_totalfiles = filecnt;
-       

        /* Now move any files that are in the way. */
        for (i = 0; i < filecnt; ++i) {
                struct vnode * rvp;
        /* Now move any files that are in the way. */
        for (i = 0; i < filecnt; ++i) {
                struct vnode * rvp;


@@ -3404,127 +3302,28 @@ end_iteration:
                hfs_unlock(VTOC(vp));
                vnode_put(vp);
                vp = NULL;
                hfs_unlock(VTOC(vp));
                vnode_put(vp);
                vp = NULL;

-
-               ++hfsmp->hfs_resize_filesmoved;
-
-               /* Report intermediate progress. */
-               if (filecnt > 100) {
-                       int progress;
-
-                       progress = (i * 100) / filecnt;
-                       if (progress > (lastprogress + 9)) {
-                               printf("hfs_reclaimspace: %d%% done...\n", progress);
-                               lastprogress = progress;
-                       }
-               }

        }
        if (vp) {
                hfs_unlock(VTOC(vp));
                vnode_put(vp);
                vp = NULL;
        }
        }
        if (vp) {
                hfs_unlock(VTOC(vp));
                vnode_put(vp);
                vp = NULL;
        }

-       if (hfsmp->hfs_resize_filesmoved != 0) {
-               printf("hfs_reclaimspace: relocated %d files on \"%s\"\n",
-                      (int)hfsmp->hfs_resize_filesmoved, hfsmp->vcbVN);
-       }
+
+       /*
+        * Note: this implementation doesn't handle overflow extents.
+        */

 out:
        kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
        kmem_free(kernel_map, (vm_offset_t)cnidbufp, cnidbufsize);
 
 out:
        kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
        kmem_free(kernel_map, (vm_offset_t)cnidbufp, cnidbufsize);
 

-       /*
-        * Restore the roving allocation pointer on errors.
-        * (but only if we didn't move any files)
-        */
-       if (error && hfsmp->hfs_resize_filesmoved == 0) {
+       /* On errors restore the roving allocation pointer. */
+       if (error) {

                hfsmp->nextAllocation = saved_next_allocation;
        }
        return (error);
 }
 
 
                hfsmp->nextAllocation = saved_next_allocation;
        }
        return (error);
 }
 
 

-/*
- * Check if there are any overflow extents that overlap.
- */
-static int
-hfs_overlapped_overflow_extents(struct hfsmount *hfsmp, u_int32_t startblk, u_int32_t catblks, u_int32_t fileID, int rsrcfork)
-{
-       struct BTreeIterator * iterator = NULL;
-       struct FSBufferDescriptor btdata;
-       HFSPlusExtentRecord extrec;
-       HFSPlusExtentKey *extkeyptr;
-       FCB *fcb;
-       u_int32_t block;
-       u_int8_t forktype;
-       int overlapped = 0;
-       int i;
-       int error;
-
-       forktype = rsrcfork ? 0xFF : 0;
-       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 = forktype;
-       extkeyptr->fileID = fileID;
-       extkeyptr->startBlock = catblks;
-
-       btdata.bufferAddress = &extrec;
-       btdata.itemSize = sizeof(extrec);
-       btdata.itemCount = 1;
-       
-       fcb = VTOF(hfsmp->hfs_extents_vp);
-
-       error = BTSearchRecord(fcb, iterator, &btdata, NULL, iterator);
-       while (error == 0) {
-               /* Stop when we encounter a different file. */
-               if ((extkeyptr->fileID != fileID) ||
-                   (extkeyptr->forkType != forktype)) {
-                       break;
-               }
-               /* 
-                * Check if the file overlaps target space.
-                */
-               for (i = 0; i < kHFSPlusExtentDensity; ++i) {
-                       if (extrec[i].blockCount == 0) {
-                               break;
-                       }
-                       block = extrec[i].startBlock + extrec[i].blockCount;
-                       if (block >= startblk) {
-                               overlapped = 1;
-                               break;
-                       }
-               }
-               /* Look for more records. */
-               error = BTIterateRecord(fcb, kBTreeNextRecord, iterator, &btdata, NULL);
-       }
-
-       kmem_free(kernel_map, (vm_offset_t)iterator, sizeof(*iterator));
-       return (overlapped);
-}
-
-
-/*
- * Calculate the progress of a file system resize operation.
- */
-__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_totalfiles > 0)
-               *progress = (hfsmp->hfs_resize_filesmoved * 100) / hfsmp->hfs_resize_totalfiles;
-       else
-               *progress = 0;
-
-       return (0);
-}
-
-

 /*
  * Get file system attributes.
  */
 /*
  * Get file system attributes.
  */