Lines Matching defs:vcb
289 ExtendedVCB *vcb,
295 ExtendedVCB *vcb,
300 ExtendedVCB *vcb,
309 ExtendedVCB *vcb,
318 ExtendedVCB *vcb,
327 ExtendedVCB *vcb,
336 ExtendedVCB *vcb,
346 ExtendedVCB *vcb,
352 ExtendedVCB *vcb,
357 ExtendedVCB *vcb,
382 ExtendedVCB *vcb,
390 ExtendedVCB *vcb,
400 ExtendedVCB *vcb,
405 ExtendedVCB *vcb,
795 ; vcb - Pointer to ExtendedVCB for the volume to allocate space on
817 ExtendedVCB *vcb, /* which volume to allocate space on */
866 hfsmp = VCBTOHFS (vcb);
909 HFS_MOUNT_LOCK(vcb, TRUE);
912 if (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE) {
913 startingBlock = vcb->sparseAllocation;
916 startingBlock = vcb->nextAllocation;
918 HFS_MOUNT_UNLOCK(vcb, TRUE);
923 if (startingBlock >= vcb->allocLimit) {
932 err = BlockAllocateContig(vcb, startingBlock, minBlocks, maxBlocks,
943 ((*actualStartBlock < VCBTOHFS(vcb)->hfs_metazone_start) ||
944 (*actualStartBlock > VCBTOHFS(vcb)->hfs_metazone_end))) {
954 if (hfs_isrbtree_active(VCBTOHFS(vcb))) {
956 err = BlockAllocateAny(vcb, startingBlock, vcb->allocLimit,
999 err = BlockAllocateKnown(vcb, maxBlocks, actualStartBlock, actualNumBlocks);
1007 err = BlockAllocateAny(vcb, startingBlock, vcb->allocLimit,
1016 err = BlockAllocateAny(vcb, 1, startingBlock, maxBlocks,
1037 HFS_MOUNT_LOCK(vcb, TRUE);
1040 if (vcb->vcbFreeExtCnt == 0 && vcb->hfs_freed_block_count == 0) {
1041 vcb->sparseAllocation = *actualStartBlock;
1044 if (*actualNumBlocks < vcb->hfs_freed_block_count) {
1045 vcb->hfs_freed_block_count -= *actualNumBlocks;
1047 vcb->hfs_freed_block_count = 0;
1051 ((*actualStartBlock < VCBTOHFS(vcb)->hfs_metazone_start) ||
1052 (*actualStartBlock > VCBTOHFS(vcb)->hfs_metazone_end))) {
1053 HFS_UPDATE_NEXT_ALLOCATION(vcb, *actualStartBlock);
1065 vcb->freeBlocks -= *actualNumBlocks;
1067 MarkVCBDirty(vcb);
1068 HFS_MOUNT_UNLOCK(vcb, TRUE);
1070 hfs_generate_volume_notifications(VCBTOHFS(vcb));
1107 ; vcb - Pointer to ExtendedVCB for the volume to free space on
1121 ExtendedVCB *vcb, // Which volume to deallocate space on
1128 hfsmp = VCBTOHFS(vcb);
1167 if (hfs_isrbtree_active(VCBTOHFS(vcb))) {
1175 err = BlockMarkFreeRBTree(vcb, firstBlock, numBlocks);
1179 err = BlockMarkFreeInternal(vcb, firstBlock, numBlocks, true);
1183 err = BlockMarkFreeInternal(vcb, firstBlock, numBlocks, true);
1191 HFS_MOUNT_LOCK(vcb, TRUE);
1198 vcb->freeBlocks += numBlocks;
1201 vcb->hfs_freed_block_count += numBlocks;
1203 if (vcb->nextAllocation == (firstBlock + numBlocks)) {
1204 HFS_UPDATE_NEXT_ALLOCATION(vcb, (vcb->nextAllocation - numBlocks));
1212 (void) add_free_extent_cache(vcb, firstBlock, numBlocks);
1221 if (firstBlock < vcb->sparseAllocation) {
1222 vcb->sparseAllocation = firstBlock;
1226 MarkVCBDirty(vcb);
1227 HFS_MOUNT_UNLOCK(vcb, TRUE);
1229 hfs_generate_volume_notifications(VCBTOHFS(vcb));
1245 MetaZoneFreeBlocks(ExtendedVCB *vcb)
1260 bit = VCBTOHFS(vcb)->hfs_metazone_start;
1264 lastbit = VCBTOHFS(vcb)->hfs_metazone_end;
1265 bytesperblock = vcb->vcbVBMIOSize;
1276 (void) ReleaseBitmapBlock(vcb, blockRef, false);
1279 if (ReadBitmapBlock(vcb, bit, &currCache, &blockRef) != 0) {
1292 (void) ReleaseBitmapBlock(vcb, blockRef, false);
1303 ExtendedVCB *vcb,
1306 struct hfsmount *hfsmp = VCBTOHFS(vcb);
1330 ; vcb -- Pointer to ExtendedVCB
1339 ExtendedVCB *vcb,
1356 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
1358 blockSize = (u_int32_t)vcb->vcbVBMIOSize;
1361 if (vcb->vcbSigWord == kHFSPlusSigWord) {
1362 vp = vcb->hfs_allocation_vp; /* use allocation file vnode */
1365 vp = VCBTOHFS(vcb)->hfs_devvp; /* use device I/O vnode */
1366 block += vcb->vcbVBMSt; /* map to physical block */
1397 ; vcb
1403 ExtendedVCB *vcb,
1421 struct hfsmount *hfsmp = VCBTOHFS(vcb);
1477 vcb Pointer to volume where space is to be allocated
1489 ExtendedVCB *vcb,
1499 if (hfs_isrbtree_active(VCBTOHFS(vcb))) {
1500 return BlockAllocateContigRBTree(vcb, startingBlock, minBlocks, maxBlocks, useMetaZone,
1504 return BlockAllocateContigBitmap(vcb, startingBlock, minBlocks,
1513 ExtendedVCB *vcb,
1540 err = BlockFindContiguous(vcb, startingBlock, vcb->allocLimit, minBlocks,
1547 err = BlockFindContiguous(vcb, 1, startingBlock, minBlocks, maxBlocks,
1554 err = BlockMarkAllocatedInternal(vcb, *actualStartBlock, *actualNumBlocks);
1574 ExtendedVCB *vcb,
1584 struct hfsmount *hfsmp = VCBTOHFS(vcb);
1619 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
1631 err = BlockMarkAllocatedRBTree(vcb, *actualStartBlock, *actualNumBlocks);
1635 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
1640 check_rbtree_extents (VCBTOHFS(vcb), *actualStartBlock, *actualNumBlocks, ASSERT_ALLOC);
1662 if ((vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE) && (forceContig == 0)) {
1724 err = BlockMarkAllocatedRBTree(vcb, *actualStartBlock, *actualNumBlocks);
1728 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
1733 check_rbtree_extents (VCBTOHFS(vcb), *actualStartBlock, *actualNumBlocks, ASSERT_ALLOC);
1744 DestroyTrees(VCBTOHFS(vcb));
1746 ResetVCBFreeExtCache(VCBTOHFS(vcb));
1767 if ((*actualStartBlock + *actualNumBlocks) > vcb->allocLimit)
1768 panic("hfs: BlockAllocateAny: allocation overflow on \"%s\"", vcb->vcbVN);
1794 vcb Pointer to volume where space is to be allocated
1812 ExtendedVCB *vcb,
1822 if (hfs_isrbtree_active(VCBTOHFS(vcb))) {
1823 return BlockAllocateAnyRBTree(vcb, startingBlock, maxBlocks, useMetaZone, actualStartBlock, actualNumBlocks);
1826 return BlockAllocateAnyBitmap(vcb, startingBlock, endingBlock, maxBlocks, useMetaZone, actualStartBlock, actualNumBlocks);
1839 ExtendedVCB *vcb,
1852 err = BlockAllocateContigRBTree(vcb, startingBlock, 1, maxBlocks, useMetaZone,
1866 ExtendedVCB *vcb,
1885 struct hfsmount *hfsmp = VCBTOHFS(vcb);
1897 if (!useMetaZone && (vcb->hfs_flags & HFS_METADATA_ZONE)) {
1898 if (startingBlock <= vcb->hfs_metazone_end) {
1899 if (endingBlock > (vcb->hfs_metazone_end + 2))
1900 startingBlock = vcb->hfs_metazone_end + 1;
1916 err = ReadBitmapBlock(vcb, startingBlock, &currCache, &blockRef);
1926 bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;
1927 wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;
1955 err = ReleaseBitmapBlock(vcb, blockRef, false);
1962 block = NextBitmapBlock(vcb, block);
1969 err = ReadBitmapBlock(vcb, block, &currCache, &blockRef);
2027 err = ReleaseBitmapBlock(vcb, blockRef, true);
2036 nextBlock = NextBitmapBlock(vcb, block);
2042 err = ReadBitmapBlock(vcb, block, &currCache, &blockRef);
2064 if ((*actualStartBlock + *actualNumBlocks) > vcb->allocLimit) {
2065 panic("hfs: BlockAllocateAny: allocation overflow on \"%s\"", vcb->vcbVN);
2079 hfs_unmap_alloc_extent (vcb, *actualStartBlock, *actualNumBlocks);
2087 (void) ReleaseBitmapBlock(vcb, blockRef, dirty);
2105 vcb Pointer to volume where space is to be allocated
2118 ExtendedVCB *vcb,
2129 HFS_MOUNT_LOCK(vcb, TRUE);
2130 lck_spin_lock(&vcb->vcbFreeExtLock);
2131 if ((hfs_isrbtree_active(vcb) == true) ||
2132 vcb->vcbFreeExtCnt == 0 ||
2133 vcb->vcbFreeExt[0].blockCount == 0) {
2134 lck_spin_unlock(&vcb->vcbFreeExtLock);
2135 HFS_MOUNT_UNLOCK(vcb, TRUE);
2140 lck_spin_unlock(&vcb->vcbFreeExtLock);
2141 HFS_MOUNT_UNLOCK(vcb, TRUE);
2143 lck_spin_lock(&vcb->vcbFreeExtLock);
2146 *actualStartBlock = vcb->vcbFreeExt[0].startBlock;
2147 foundBlocks = vcb->vcbFreeExt[0].blockCount;
2152 lck_spin_unlock(&vcb->vcbFreeExtLock);
2154 remove_free_extent_cache(vcb, *actualStartBlock, *actualNumBlocks);
2157 if ((*actualStartBlock + *actualNumBlocks) > vcb->allocLimit)
2159 printf ("hfs: BlockAllocateKnown() found allocation overflow on \"%s\"", vcb->vcbVN);
2160 hfs_mark_volume_inconsistent(vcb);
2170 err = BlockMarkAllocatedInternal(vcb, *actualStartBlock, *actualNumBlocks);
2173 sanity_check_free_ext(vcb, 0);
2192 ExtendedVCB *vcb,
2198 hfsmp = VCBTOHFS(vcb);
2212 err = BlockMarkAllocatedRBTree(vcb, startingBlock, numBlocks);
2229 return BlockMarkAllocatedInternal(vcb, startingBlock, numBlocks);
2249 vcb Pointer to volume where space is to be allocated
2256 ExtendedVCB *vcb,
2271 struct hfsmount *hfsmp = VCBTOHFS(vcb);
2276 hfs_unmap_alloc_extent(vcb, startingBlock, numBlocks);
2282 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2290 bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;
2291 wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;
2340 err = ReleaseBitmapBlock(vcb, blockRef, true);
2343 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2378 err = ReleaseBitmapBlock(vcb, blockRef, true);
2381 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2406 (void)ReleaseBitmapBlock(vcb, blockRef, true);
2425 ExtendedVCB *vcb,
2430 struct hfsmount *hfsmp = VCBTOHFS(vcb);
2435 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
2440 check_rbtree_extents (VCBTOHFS(vcb), startingBlock, numBlocks, ASSERT_FREE);
2443 err = BlockMarkAllocatedInternal (vcb, startingBlock, numBlocks);
2485 check_rbtree_extents (VCBTOHFS(vcb), startingBlock, numBlocks, ASSERT_ALLOC);
2521 ExtendedVCB *vcb,
2526 hfsmp = VCBTOHFS(vcb);
2540 err = BlockMarkFreeRBTree(vcb, startingBlock, numBlocks);
2555 return BlockMarkFreeInternal(vcb, startingBlock, numBlocks, true);
2584 OSErr BlockMarkFreeUnused(ExtendedVCB *vcb, u_int32_t startingBlock, register u_int32_t numBlocks)
2587 struct hfsmount *hfsmp = VCBTOHFS(vcb);
2609 error = BlockMarkFreeInternal(vcb, startingBlock, curNumBlocks, false);
2636 error = BlockMarkFreeInternal(vcb, startingBlock, curNumBlocks, false);
2658 vcb Pointer to volume where space is to be freed
2669 ExtendedVCB *vcb,
2690 struct hfsmount *hfsmp = VCBTOHFS(vcb);
2696 * NOTE: We use vcb->totalBlocks instead of vcb->allocLimit because we
2700 (startingBlock + numBlocks > vcb->totalBlocks)) {
2702 panic ("BlockMarkFreeInternal() free non-existent blocks at %u (numBlock=%u) on vol %s\n", startingBlock, numBlocks, vcb->vcbVN);
2705 printf ("hfs: BlockMarkFreeInternal() trying to free non-existent blocks starting at %u (numBlock=%u) on volume %s\n", startingBlock, numBlocks, vcb->vcbVN);
2706 hfs_mark_volume_inconsistent(vcb);
2715 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2725 bitsPerBlock = vcb->vcbVBMIOSize * kBitsPerByte;
2726 wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;
2789 err = ReleaseBitmapBlock(vcb, blockRef, true);
2792 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2826 err = ReleaseBitmapBlock(vcb, blockRef, true);
2829 err = ReadBitmapBlock(vcb, startingBlock, &buffer, &blockRef);
2877 (void)ReleaseBitmapBlock(vcb, blockRef, true);
2880 hfs_unmap_free_extent(vcb, unmapStart, unmapCount);
2892 printf ("hfs: BlockMarkFreeInternal() trying to free unallocated blocks on volume %s\n", vcb->vcbVN);
2893 hfs_mark_volume_inconsistent(vcb);
2911 ExtendedVCB *vcb,
2916 struct hfsmount *hfsmp = VCBTOHFS(vcb);
2920 REQUIRE_FILE_LOCK(vcb->hfs_allocation_vp, false);
2925 check_rbtree_extents (VCBTOHFS(vcb), startingBlock, numBlocks, ASSERT_ALLOC);
2928 err = BlockMarkFreeInternal(vcb, startingBlock, numBlocks, true);
2976 check_rbtree_extents (VCBTOHFS(vcb), startingBlock, numBlocks, ASSERT_FREE);
3016 vcb Pointer to volume where space is to be allocated
3034 ExtendedVCB *vcb,
3067 if (!useMetaZone && (vcb->hfs_flags & HFS_METADATA_ZONE)) {
3068 if (startingBlock <= vcb->hfs_metazone_end) {
3069 if (endingBlock > (vcb->hfs_metazone_end + 2))
3070 startingBlock = vcb->hfs_metazone_end + 1;
3091 currentBlock = NextBitmapBlock(vcb, currentBlock);
3096 err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef);
3102 wordsPerBlock = vcb->vcbVBMIOSize / kBytesPerWord;
3148 err = ReleaseBitmapBlock(vcb, blockRef, false);
3155 currentBlock = NextBitmapBlock(vcb, currentBlock);
3161 err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef);
3234 err = ReleaseBitmapBlock(vcb, blockRef, false);
3243 nextBlock = NextBitmapBlock(vcb, currentBlock);
3249 err = ReadBitmapBlock(vcb, currentBlock, &buffer, &blockRef);
3297 updated_free_extent = add_free_extent_cache(vcb, firstBlock, foundBlocks);
3319 if ((firstBlock + foundBlocks) > vcb->allocLimit) {
3321 vcb->vcbVN, startingBlock, endingBlock, currentBlock,
3326 if (updated_free_extent && (vcb->hfs_flags & HFS_HAS_SPARSE_DEVICE)) {
3328 u_int32_t min_start = vcb->totalBlocks;
3332 lck_spin_lock(&vcb->vcbFreeExtLock);
3333 for(i=0; i < (int)vcb->vcbFreeExtCnt; i++) {
3334 if (vcb->vcbFreeExt[i].startBlock < min_start) {
3335 min_start = vcb->vcbFreeExt[i].startBlock;
3338 lck_spin_unlock(&vcb->vcbFreeExtLock);
3339 if (min_start != vcb->totalBlocks) {
3340 if (min_start < vcb->nextAllocation) {
3341 vcb->nextAllocation = min_start;
3343 if (min_start < vcb->sparseAllocation) {
3344 vcb->sparseAllocation = min_start;
3350 (void) ReleaseBitmapBlock(vcb, blockRef, false);