--- /dev/null
+/*
+ * Copyright (c) 2014-2015 Apple Inc. All rights reserved.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
+ */
+
+#if HFS_EXTENTS_TEST
+
+#include "../tests/hfs_extents_test.h"
+#include "hfs_extents.h"
+
+#else
+
+#include "hfs_extents.h"
+
+// In this file, group refers to a set of 8 extents
+
+static uint32_t hfs_total_blocks(const HFSPlusExtentDescriptor *ext, int count);
+static errno_t hfs_ext_iter_next_group(struct hfs_ext_iter *iter);
+static errno_t hfs_ext_iter_update(struct hfs_ext_iter *iter,
+ HFSPlusExtentDescriptor *extents,
+ int count,
+ HFSPlusExtentRecord cat_extents);
+static errno_t hfs_ext_iter_check_group(hfs_ext_iter_t *iter);
+
+#endif
+
+#define CHECK(x, var, goto_label) \
+ do { \
+ var = (x); \
+ if (var) { \
+ printf("%s:%u error: %d\n", __func__, __LINE__, var); \
+ goto goto_label; \
+ } \
+ } while (0)
+
+#define min(a,b) \
+ ({ typeof (a) _a = (a); typeof (b) _b = (b); _a < _b ? _a : _b; })
+
+static __attribute__((pure))
+const HFSPlusExtentKey *hfs_ext_iter_key(const hfs_ext_iter_t *iter)
+{
+ return (const HFSPlusExtentKey *)&iter->bt_iter.key;
+}
+
+static __attribute__((pure))
+HFSPlusExtentKey *hfs_ext_iter_key_mut(hfs_ext_iter_t *iter)
+{
+ return (HFSPlusExtentKey *)&iter->bt_iter.key;
+}
+
+// Returns the total number of blocks for the @count extents provided
+uint32_t hfs_total_blocks(const HFSPlusExtentDescriptor *extents, int count)
+{
+ uint32_t block_count = 0;
+ for (int i = 0; i < count; ++i)
+ block_count += extents[i].blockCount;
+ return block_count;
+}
+
+/*
+ * Checks a group of extents: makes sure that if it's the last group
+ * for a fork, that all the remaining extents are properly zeroed and
+ * if it's not then checks that all extents are set. This also sets
+ * @group_block_count and @last_in_fork. Returns ESTALE if
+ * inconsistent.
+ */
+errno_t hfs_ext_iter_check_group(hfs_ext_iter_t *iter)
+{
+ filefork_t *ff = VTOF(iter->vp);
+ const HFSPlusExtentKey *key = hfs_ext_iter_key(iter);
+ uint32_t count = 0;
+ int i;
+
+ for (i = 0; i < kHFSPlusExtentDensity; ++i) {
+ if (!iter->group[i].blockCount)
+ break;
+ count += iter->group[i].blockCount;
+ }
+
+ if (i < kHFSPlusExtentDensity) {
+ iter->last_in_fork = true;
+ if (key->startBlock + count != ff_allocblocks(ff))
+ goto bad;
+
+ // Check remainder of extents
+ for (++i; i < kHFSPlusExtentDensity; ++i) {
+ if (iter->group[i].blockCount)
+ goto bad;
+ }
+ } else {
+ if (key->startBlock + count > ff_allocblocks(ff))
+ goto bad;
+
+ iter->last_in_fork = (key->startBlock + count == ff_allocblocks(ff));
+ }
+
+ iter->group_block_count = count;
+
+ return 0;
+
+bad:
+
+#if DEBUG
+ printf("hfs_ext_iter_check_group: bad group; start: %u, total blocks: %u\n",
+ key->startBlock, ff_allocblocks(ff));
+
+ for (int j = 0; j < kHFSPlusExtentDensity; ++j) {
+ printf("%s<%u, %u>", j ? ", " : "",
+ iter->group[j].startBlock, iter->group[j].blockCount);
+ }
+
+ printf("\n");
+#endif
+
+ return ESTALE;
+}
+
+// NOTE: doesn't copy group data
+static void hfs_ext_iter_copy(const hfs_ext_iter_t *src, hfs_ext_iter_t *dst)
+{
+ dst->vp = src->vp;
+ memcpy(&dst->bt_iter.key, &src->bt_iter.key, sizeof(HFSPlusExtentKey));
+
+ dst->file_block = src->file_block;
+ dst->ndx = src->ndx;
+
+ dst->bt_iter.hint = src->bt_iter.hint;
+ dst->bt_iter.version = 0;
+ dst->bt_iter.reserved = 0;
+ dst->bt_iter.hitCount = 0;
+ dst->bt_iter.maxLeafRecs = 0;
+}
+
+bool hfs_ext_iter_is_catalog_extents(hfs_ext_iter_t *iter)
+{
+ return hfs_ext_iter_key(iter)->startBlock == 0;
+}
+
+#if !HFS_EXTENTS_TEST
+
+/*
+ * Finds the extent for offset. It might be in the catalog or the extents
+ * file.
+ */
+errno_t hfs_ext_find(vnode_t vp, off_t offset, hfs_ext_iter_t *iter)
+{
+ errno_t ret;
+ hfsmount_t *hfsmp = VTOHFS(vp);
+
+ iter->vp = vp;
+
+ uint32_t end_block, index;
+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);
+
+ filefork_t *ff = VTOF(vp);
+
+ CHECK(SearchExtentFile(hfsmp, ff, offset,
+ key, iter->group, &index,
+ &iter->bt_iter.hint.nodeNum, &end_block), ret, exit);
+
+ iter->ndx = index;
+ iter->file_block = end_block - iter->group[index].blockCount;
+
+ if (!key->keyLength) {
+ // We're pointing at the catalog record extents so fix up the key
+ key->keyLength = kHFSPlusExtentKeyMaximumLength;
+ key->forkType = (VNODE_IS_RSRC(iter->vp)
+ ? kHFSResourceForkType : kHFSDataForkType);
+ key->pad = 0;
+ key->fileID = VTOC(iter->vp)->c_fileid;
+ key->startBlock = 0;
+ }
+
+ CHECK(hfs_ext_iter_check_group(iter), ret, exit);
+
+ ret = 0;
+
+exit:
+
+ return MacToVFSError(ret);
+}
+
+static uint32_t hfs_ext_iter_next_group_block(const hfs_ext_iter_t *iter)
+{
+ const HFSPlusExtentKey *key = hfs_ext_iter_key(iter);
+
+ return key->startBlock + iter->group_block_count;
+}
+
+/*
+ * Move the iterator to the next group. Don't call if there's a chance
+ * there is no entry; the caller should check last_in_fork instead.
+ */
+static errno_t hfs_ext_iter_next_group(hfs_ext_iter_t *iter)
+{
+ errno_t ret;
+ hfsmount_t *hfsmp = VTOHFS(iter->vp);
+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;
+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);
+ const bool catalog_extents = hfs_ext_iter_is_catalog_extents(iter);
+ const uint32_t next_block = hfs_ext_iter_next_group_block(iter);
+
+ FSBufferDescriptor fbd = {
+ .bufferAddress = &iter->group,
+ .itemCount = 1,
+ .itemSize = sizeof(iter->group)
+ };
+
+ if (catalog_extents) {
+ key->startBlock = next_block;
+
+ CHECK(BTSearchRecord(tree, &iter->bt_iter, &fbd, NULL,
+ &iter->bt_iter), ret, exit);
+ } else {
+ const uint32_t file_id = key->fileID;
+ const uint8_t fork_type = key->forkType;
+
+ CHECK(BTIterateRecord(tree, kBTreeNextRecord, &iter->bt_iter,
+ &fbd, NULL), ret, exit);
+
+ if (key->fileID != file_id
+ || key->forkType != fork_type
+ || key->startBlock != next_block) {
+ // This indicates an inconsistency
+ ret = ESTALE;
+ goto exit;
+ }
+ }
+
+ iter->file_block = key->startBlock;
+ iter->ndx = 0;
+
+ CHECK(hfs_ext_iter_check_group(iter), ret, exit);
+
+ ret = 0;
+
+exit:
+
+ return MacToVFSError(ret);
+}
+
+/*
+ * Updates with the extents provided and sets the key up for the next group.
+ * It is assumed that any previous record that might collide has been deleted.
+ * NOTE: @extents must point to a buffer that can be zero padded to multiple
+ * of 8 extents.
+ */
+errno_t hfs_ext_iter_update(hfs_ext_iter_t *iter,
+ HFSPlusExtentDescriptor *extents,
+ int count,
+ HFSPlusExtentRecord cat_extents)
+{
+ errno_t ret;
+ hfsmount_t *hfsmp = VTOHFS(iter->vp);
+ cnode_t *cp = VTOC(iter->vp);
+ HFSPlusExtentKey *key = hfs_ext_iter_key_mut(iter);
+ int ndx = 0;
+
+ if (!extents)
+ extents = iter->group;
+
+ if (count % kHFSPlusExtentDensity) {
+ // Zero out last group
+ bzero(&extents[count], (kHFSPlusExtentDensity
+ - (count % 8)) * sizeof(*extents));
+ }
+
+ if (hfs_ext_iter_is_catalog_extents(iter)) {
+ // Caller is responsible for in-memory updates
+
+ if (cat_extents)
+ hfs_ext_copy_rec(extents, cat_extents);
+
+ struct cat_fork fork;
+
+ hfs_fork_copy(&fork, &VTOF(iter->vp)->ff_data, extents);
+ hfs_prepare_fork_for_update(VTOF(iter->vp), &fork, &fork, hfsmp->blockSize);
+
+ bool is_rsrc = VNODE_IS_RSRC(iter->vp);
+ CHECK(cat_update(hfsmp, &cp->c_desc, &cp->c_attr,
+ is_rsrc ? NULL : &fork,
+ is_rsrc ? &fork : NULL), ret, exit);
+
+ // Set the key to the next group
+ key->startBlock = hfs_total_blocks(extents, kHFSPlusExtentDensity);
+
+ ndx += 8;
+ }
+
+ // Deal with the remainder which must be overflow extents
+ for (; ndx < count; ndx += 8) {
+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;
+
+ FSBufferDescriptor fbd = {
+ .bufferAddress = &extents[ndx],
+ .itemCount = 1,
+ .itemSize = sizeof(HFSPlusExtentRecord)
+ };
+
+ CHECK(BTInsertRecord(tree, &iter->bt_iter, &fbd,
+ sizeof(HFSPlusExtentRecord)), ret, exit);
+
+ // Set the key to the next group
+ key->startBlock += hfs_total_blocks(&extents[ndx], kHFSPlusExtentDensity);
+ }
+
+ ret = 0;
+
+exit:
+
+ return ret;
+}
+
+#endif // !HFS_EXTENTS_TEST
+
+static void push_ext(HFSPlusExtentDescriptor *extents, int *count,
+ const HFSPlusExtentDescriptor *ext)
+{
+ if (!ext->blockCount)
+ return;
+
+ if (*count && hfs_ext_end(&extents[*count - 1]) == ext->startBlock)
+ extents[*count - 1].blockCount += ext->blockCount;
+ else
+ extents[(*count)++] = *ext;
+}
+
+/*
+ * NOTE: Here we rely on the replacement extents not being too big as
+ * otherwise the number of BTree records that we have to delete could be
+ * too large.
+ */
+errno_t hfs_ext_replace(hfsmount_t *hfsmp, vnode_t vp,
+ uint32_t file_block,
+ const HFSPlusExtentDescriptor *repl,
+ int repl_count,
+ HFSPlusExtentRecord catalog_extents)
+{
+ errno_t ret;
+ filefork_t * const tree = hfsmp->hfs_extents_cp->c_datafork;
+ hfs_ext_iter_t *iter_in = NULL, *iter_out;
+ HFSPlusExtentDescriptor *extents = NULL;
+ int buffered_extents = 0;
+ const int max_roll_back_extents = 16384; // 128k
+ HFSPlusExtentDescriptor *roll_back_extents = NULL;
+ int roll_back_count = 0;
+ const uint32_t end_file_block = file_block + hfs_total_blocks(repl, repl_count);
+ filefork_t *ff = VTOF(vp);
+ uint32_t start_group_block = 0, block = 0;
+
+ // Indicate we haven't touched catalog extents
+ catalog_extents[0].blockCount = 0;
+
+ if (end_file_block > ff_allocblocks(ff))
+ return EINVAL;
+
+ iter_in = hfs_malloc(sizeof(*iter_in) * 2);
+ iter_out = iter_in + 1;
+ HFSPlusExtentKey *key_in = hfs_ext_iter_key_mut(iter_in);
+
+ // Get to where we want to start
+ off_t offset = hfs_blk_to_bytes(file_block, hfsmp->blockSize);
+
+ /*
+ * If the replacement is at the start of a group, we want to pull in the
+ * group before so that we tidy up any padding that we might have done
+ * in a prior hfs_ext_replace call.
+ */
+ if (offset > 0)
+ --offset;
+
+ CHECK(hfs_ext_find(vp, offset, iter_in), ret, exit);
+
+ start_group_block = key_in->startBlock;
+
+ roll_back_extents = hfs_malloc(max_roll_back_extents
+ * sizeof(HFSPlusExtentDescriptor));
+
+ // Move to the first extent in this group
+ iter_in->ndx = 0;
+
+ hfs_ext_iter_copy(iter_in, iter_out);
+
+ // Create a buffer for our extents
+ buffered_extents = roundup(3 * kHFSPlusExtentDensity + repl_count,
+ kHFSPlusExtentDensity);
+ extents = hfs_malloc(sizeof(*extents) * buffered_extents);
+ int count = 0;
+
+ /*
+ * Iterate through the extents that are affected by this replace operation.
+ * We cannot push more than 16 + repl_count extents here; 8 for the group
+ * containing the replacement start, repl_count for the replacements and 8
+ * for the group containing the end. If we went back a group due to
+ * decrementing the offset above, it's still the same because we know in
+ * that case the replacement starts at the beginning of the next group.
+ */
+ block = start_group_block;
+ for (;;) {
+ if (!iter_in->ndx) {
+ hfs_ext_copy_rec(iter_in->group, &roll_back_extents[roll_back_count]);
+ roll_back_count += kHFSPlusExtentDensity;
+
+ if (!hfs_ext_iter_is_catalog_extents(iter_in)) {
+ // Delete this extent group; we're going to replace it
+ CHECK(BTDeleteRecord(tree, &iter_in->bt_iter), ret, exit);
+ }
+ }
+
+ HFSPlusExtentDescriptor *ext = &iter_in->group[iter_in->ndx];
+ if (!ext->blockCount) {
+ /*
+ * We ran out of existing extents so we just write the
+ * extents and we're done.
+ */
+ goto finish;
+ }
+
+ // If the current extent does not overlap replacement...
+ if (block + ext->blockCount <= file_block || block >= end_file_block) {
+ // Keep the current extent exactly as it is
+ push_ext(extents, &count, ext);
+ } else {
+ HFSPlusExtentDescriptor dealloc_ext = *ext;
+
+ if (block <= file_block) {
+ /*
+ * The middle or tail of the current extent overlaps
+ * the replacement extents. Keep the non-overlapping
+ * head of the current extent.
+ */
+ uint32_t trimmed_len = file_block - block;
+
+ if (trimmed_len) {
+ // Push (keep) non-overlapping head of current extent
+ push_ext(extents, &count,
+ &(HFSPlusExtentDescriptor){ ext->startBlock,
+ trimmed_len });
+
+ /*
+ * Deallocate the part of the current extent that
+ * overlaps the replacement extents. That starts
+ * at @file_block. For now, assume it goes
+ * through the end of the current extent. (If the
+ * current extent extends beyond the end of the
+ * replacement extents, we'll update the
+ * blockCount below.)
+ */
+ dealloc_ext.startBlock += trimmed_len;
+ dealloc_ext.blockCount -= trimmed_len;
+ }
+
+ // Insert the replacements
+ for (int i = 0; i < repl_count; ++i)
+ push_ext(extents, &count, &repl[i]);
+ }
+
+ if (block + ext->blockCount > end_file_block) {
+ /*
+ * The head or middle of the current extent overlaps
+ * the replacement extents. Keep the non-overlapping
+ * tail of the current extent.
+ */
+ uint32_t overlap = end_file_block - block;
+
+ // Push (keep) non-overlapping tail of current extent
+ push_ext(extents, &count,
+ &(HFSPlusExtentDescriptor){ ext->startBlock + overlap,
+ ext->blockCount - overlap });
+
+ /*
+ * Deallocate the part of current extent that overlaps
+ * the replacements.
+ */
+ dealloc_ext.blockCount = (ext->startBlock + overlap
+ - dealloc_ext.startBlock);
+ }
+
+ CHECK(BlockDeallocate(hfsmp, dealloc_ext.startBlock,
+ dealloc_ext.blockCount, 0), ret, exit);
+ }
+
+ // Move to next (existing) extent from iterator
+ block += ext->blockCount;
+
+ if (++iter_in->ndx >= kHFSPlusExtentDensity) {
+ if (block >= end_file_block) {
+ if (iter_in->last_in_fork || !(count % kHFSPlusExtentDensity)) {
+ /*
+ * This is the easy case. We've hit the end or we have a
+ * multiple of 8, so we can just write out the extents we
+ * have and it should all fit within a transaction.
+ */
+
+ goto finish;
+ }
+
+ if (count + kHFSPlusExtentDensity > buffered_extents
+ || (roll_back_count
+ + kHFSPlusExtentDensity > max_roll_back_extents)) {
+ /*
+ * We've run out of room for the next group, so drop out
+ * and take a different strategy.
+ */
+ break;
+ }
+ }
+
+ CHECK(hfs_ext_iter_next_group(iter_in), ret, exit);
+ }
+ } // for (;;)
+
+ /*
+ * We're not at the end so we need to try and pad to a multiple of 8
+ * so that we don't have to touch all the subsequent records. We pad
+ * by stealing single blocks.
+ */
+
+ int stop_at = 0;
+
+ for (;;) {
+ // @in points to the record we're stealing from
+ int in = count - 1;
+
+ count = roundup(count, kHFSPlusExtentDensity);
+
+ // @out is where we put the stolen single blocks
+ int out = count - 1;
+
+ do {
+ if (out <= in) {
+ // We suceeded in padding; we're done
+ goto finish;
+ }
+
+ /*
+ * "Steal" a block, or move a one-block extent within the
+ * @extents array.
+ *
+ * If the extent we're "stealing" from (@in) is only one
+ * block long, we'll end up copying it to @out, setting
+ * @in's blockCount to zero, and decrementing @in. So, we
+ * either split a multi-block extent; or move it within
+ * the @extents array.
+ */
+ extents[out].blockCount = 1;
+ extents[out].startBlock = (extents[in].startBlock
+ + extents[in].blockCount - 1);
+ --out;
+ } while (--extents[in].blockCount || --in >= stop_at);
+
+ // We ran out of extents
+ if (roll_back_count + kHFSPlusExtentDensity > max_roll_back_extents) {
+ ret = ENOSPC;
+ goto exit;
+ }
+
+ // Need to shift extents starting at out + 1
+ ++out;
+ memmove(&extents[stop_at], &extents[out],
+ (count - out) * sizeof(*extents));
+ count -= out - stop_at;
+
+ // Pull in the next group
+ CHECK(hfs_ext_iter_next_group(iter_in), ret, exit);
+
+ // Take a copy of these extents for roll back purposes
+ hfs_ext_copy_rec(iter_in->group, &roll_back_extents[roll_back_count]);
+ roll_back_count += kHFSPlusExtentDensity;
+
+ // Delete this group; we're going to replace it
+ CHECK(BTDeleteRecord(tree, &iter_in->bt_iter), ret, exit);
+
+ if (iter_in->last_in_fork) {
+ // Great! We've hit the end. Coalesce and write out.
+ int old_count = count;
+ count = 0;
+
+ /*
+ * First coalesce the extents we already have. Takes
+ * advantage of push_ext coalescing the input extent with
+ * the last extent in @extents. If the extents are not
+ * contiguous, then this just copies the extents over
+ * themselves and sets @count back to @old_count.
+ */
+ for (int i = 0; i < old_count; ++i)
+ push_ext(extents, &count, &extents[i]);
+
+ // Make room if necessary
+ const int flush_count = buffered_extents - kHFSPlusExtentDensity;
+ if (count > flush_count) {
+ CHECK(hfs_ext_iter_update(iter_out, extents,
+ flush_count, catalog_extents), ret, exit);
+
+ memmove(&extents[0], &extents[flush_count],
+ (count - flush_count) * sizeof(*extents));
+
+ count -= flush_count;
+ }
+
+ // Add in the extents we just read in
+ for (int i = 0; i < kHFSPlusExtentDensity; ++i) {
+ HFSPlusExtentDescriptor *ext = &iter_in->group[i];
+ if (!ext->blockCount)
+ break;
+ push_ext(extents, &count, ext);
+ }
+
+ goto finish;
+ } // if (iter_in->last_in_fork)
+
+ /*
+ * Otherwise, we're not at the end, so we add these extents and then
+ * try and pad out again to a multiple of 8. We start by making room.
+ */
+ if (count > buffered_extents - kHFSPlusExtentDensity) {
+ // Only write out one group here
+ CHECK(hfs_ext_iter_update(iter_out, extents,
+ kHFSPlusExtentDensity,
+ catalog_extents), ret, exit);
+
+ memmove(&extents[0], &extents[kHFSPlusExtentDensity],
+ (count - kHFSPlusExtentDensity) * sizeof(*extents));
+
+ count -= kHFSPlusExtentDensity;
+ }
+
+ // Record where to stop when padding above
+ stop_at = count;
+
+ // Copy in the new extents
+ hfs_ext_copy_rec(iter_in->group, &extents[count]);
+ count += kHFSPlusExtentDensity;
+ } // for (;;)
+
+finish:
+
+ // Write the remaining extents
+ CHECK(hfs_ext_iter_update(iter_out, extents, count,
+ catalog_extents), ret, exit);
+
+ CHECK(BTFlushPath(hfsmp->hfs_catalog_cp->c_datafork), ret, exit);
+ CHECK(BTFlushPath(hfsmp->hfs_extents_cp->c_datafork), ret, exit);
+
+exit:
+
+ if (ret && roll_back_count) {
+
+#define RB_FAILED \
+ do { \
+ printf("hfs_ext_replace:%u: roll back failed\n", __LINE__); \
+ hfs_mark_inconsistent(hfsmp, HFS_ROLLBACK_FAILED); \
+ goto roll_back_failed; \
+ } while (0)
+
+ // First delete any groups we inserted
+ HFSPlusExtentKey *key_out = hfs_ext_iter_key_mut(iter_out);
+
+ key_in->startBlock = start_group_block;
+ if (!key_in->startBlock && key_out->startBlock > key_in->startBlock) {
+ key_in->startBlock += hfs_total_blocks(catalog_extents,
+ kHFSPlusExtentDensity);
+ }
+
+ if (key_out->startBlock > key_in->startBlock) {
+ FSBufferDescriptor fbd = {
+ .bufferAddress = &iter_in->group,
+ .itemCount = 1,
+ .itemSize = sizeof(iter_in->group)
+ };
+
+ if (BTSearchRecord(tree, &iter_in->bt_iter, &fbd, NULL,
+ &iter_in->bt_iter)) {
+ RB_FAILED;
+ }
+
+ for (;;) {
+ if (BTDeleteRecord(tree, &iter_in->bt_iter))
+ RB_FAILED;
+
+ key_in->startBlock += hfs_total_blocks(iter_in->group,
+ kHFSPlusExtentDensity);
+
+ if (key_in->startBlock >= key_out->startBlock)
+ break;
+
+ if (BTSearchRecord(tree, &iter_in->bt_iter, &fbd, NULL,
+ &iter_in->bt_iter)) {
+ RB_FAILED;
+ }
+ }
+ }
+
+ // Position iter_out
+ key_out->startBlock = start_group_block;
+
+ // Roll back all the extents
+ if (hfs_ext_iter_update(iter_out, roll_back_extents, roll_back_count,
+ catalog_extents)) {
+ RB_FAILED;
+ }
+
+ // And we need to reallocate the blocks we deallocated
+ const uint32_t end_block = min(block, end_file_block);
+ block = start_group_block;
+ for (int i = 0; i < roll_back_count && block < end_block; ++i) {
+ HFSPlusExtentDescriptor *ext = &roll_back_extents[i];
+
+ if (block + ext->blockCount <= file_block)
+ continue;
+
+ HFSPlusExtentDescriptor alloc_ext = *ext;
+
+ if (block <= file_block) {
+ uint32_t trimmed_len = file_block - block;
+
+ alloc_ext.startBlock += trimmed_len;
+ alloc_ext.blockCount -= trimmed_len;
+ }
+
+ if (block + ext->blockCount > end_file_block) {
+ uint32_t overlap = end_file_block - block;
+
+ alloc_ext.blockCount = (ext->startBlock + overlap
+ - alloc_ext.startBlock);
+ }
+
+ if (hfs_block_alloc(hfsmp, &alloc_ext, HFS_ALLOC_ROLL_BACK, NULL))
+ RB_FAILED;
+
+ block += ext->blockCount;
+ }
+
+ if (BTFlushPath(hfsmp->hfs_catalog_cp->c_datafork)
+ || BTFlushPath(hfsmp->hfs_extents_cp->c_datafork)) {
+ RB_FAILED;
+ }
+ } // if (ret && roll_back_count)
+
+roll_back_failed:
+
+ hfs_free(iter_in, sizeof(*iter_in) * 2);
+ hfs_free(extents, sizeof(*extents) * buffered_extents);
+ hfs_free(roll_back_extents, (max_roll_back_extents
+ * sizeof(HFSPlusExtentDescriptor)));
+
+ return MacToVFSError(ret);
+}
projects / apple / hfs.git / blobdiff