![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hfs_btreeio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / hfs|
Return to hfs_btreeio.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / hfs |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* @(#)hfs_btreeio.c ! 26: * ! 27: * (c) 1998 Apple Computer, Inc. All Rights Reserved ! 28: * ! 29: * hfs_btreeio.c -- I/O Routines for the HFS B-tree files. ! 30: * ! 31: * HISTORY ! 32: * 16-Jul-1998 Don Brady In ExtendBtreeFile force all b-tree nodes to be contiguous on disk. ! 33: * 4-Jun-1998 Pat Dirks Changed to do all B*-Tree writes synchronously (FORCESYNCBTREEWRITES = 1) ! 34: * 18-apr-1998 Don Brady Call brelse on bread failure. ! 35: * 17-Apr-1998 Pat Dirks Fixed ReleaseBTreeBlock to not call brelse when bwrite or bdwrite is called. ! 36: * 13-apr-1998 Don Brady Add ExtendBTreeFile routine (from BTreeWrapper.c). ! 37: * 26-mar-1998 Don Brady SetBTreeBlockSize was incorrectly excluding 512 byte blockSize. ! 38: * 18-feb-1998 Don Brady Initially created file. ! 39: * ! 40: */ ! 41: ! 42: #include <sys/types.h> ! 43: #include <sys/buf.h> ! 44: #include <sys/systm.h> ! 45: #include <machine/spl.h> ! 46: ! 47: #include "hfs.h" ! 48: #include "hfs_dbg.h" ! 49: #include "hfscommon/headers/system/MacOSTypes.h" ! 50: #include "hfscommon/headers/FileMgrInternal.h" ! 51: #include "hfscommon/headers/BTreesInternal.h" ! 52: ! 53: #define FORCESYNCBTREEWRITES 0 ! 54: ! 55: OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, ItemCount minBlockCount) ! 56: { ! 57: if (blockSize > MAXBSIZE ) ! 58: return (fsBTBadNodeSize); ! 59: ! 60: DBG_TREE(("SetBlockSizeProc: blockSize=%ld for file %ld\n", blockSize, VTOFCB(vp)->fcbFlNm)); ! 61: ! 62: VTOH(vp)->h_meta->h_logBlockSize = blockSize; ! 63: VTOH(vp)->h_meta->h_physBlkPerLogBlk = blockSize / kHFSBlockSize; ! 64: ! 65: return (E_NONE); ! 66: } ! 67: ! 68: ! 69: OSStatus GetBTreeBlock(FileReference vp, UInt32 blockNum, GetBlockOptions options, BlockDescriptor *block) ! 70: { ! 71: OSStatus retval = E_NONE; ! 72: struct buf *bp = NULL; ! 73: ! 74: //XXX DJB - what about kForceReadBlock option? ! 75: ! 76: // DBG_TREE(("GetBlockProc: block=%ld, blockSize=%ld\n", blockNum, block->blockSize)); ! 77: ! 78: if (options & kGetEmptyBlock) ! 79: bp = getblk (vp, ! 80: IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size), ! 81: IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size), ! 82: 0, ! 83: 0); ! 84: else ! 85: retval = bread (vp, ! 86: IOBLKNOFORBLK(blockNum, VTOHFS(vp)->hfs_phys_block_size), ! 87: IOBYTECCNTFORBLK(blockNum, block->blockSize, VTOHFS(vp)->hfs_phys_block_size), ! 88: NOCRED, ! 89: &bp); ! 90: ! 91: // DBG_TREE(("GetBlockProc: bp->b_bufsize=%ld, bp->b_bcount=%ld, bp->b_lblkno=%ld\n", bp->b_bufsize, bp->b_bcount, bp->b_lblkno)); ! 92: ! 93: DBG_ASSERT(bp != NULL); ! 94: DBG_ASSERT(bp->b_data != NULL); ! 95: DBG_ASSERT(bp->b_bcount == block->blockSize); ! 96: DBG_ASSERT(bp->b_lblkno == blockNum); ! 97: ! 98: if (bp == NULL) ! 99: retval = -1; //XXX need better error ! 100: ! 101: if (retval == E_NONE) { ! 102: block->blockHeader = bp; ! 103: block->buffer = bp->b_data + IOBYTEOFFSETFORBLK(bp->b_blkno, VTOHFS(vp)->hfs_phys_block_size); ! 104: block->blockReadFromDisk = (bp->b_flags & B_CACHE) == 0; /* not found in cache ==> came from disk */ ! 105: } else { ! 106: if (bp) ! 107: brelse(bp); ! 108: block->blockHeader = NULL; ! 109: block->buffer = NULL; ! 110: } ! 111: ! 112: return (retval); ! 113: } ! 114: ! 115: ! 116: OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options) ! 117: { ! 118: OSStatus retval = E_NONE; ! 119: struct buf *bp = NULL; ! 120: int s; ! 121: ! 122: bp = (struct buf *) blockPtr->blockHeader; ! 123: ! 124: if (bp == NULL) { ! 125: DBG_TREE(("ReleaseBlockProc: blockHeader is zero!\n")); ! 126: retval = -1; ! 127: goto exit; ! 128: } ! 129: ! 130: // DBG_TREE(("ReleaseBlockProc: bp->b_lblkno=%ld, bp->b_bcount=%ld\n\n", bp->b_lblkno, bp->b_bcount)); ! 131: ! 132: if (options & kTrashBlock) { ! 133: bp->b_flags |= B_INVAL; ! 134: brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */ ! 135: } else { ! 136: if (options & kForceWriteBlock) { ! 137: bp->b_flags |= B_DIRTY; ! 138: retval = bwrite(bp); ! 139: } else if (options & kMarkBlockDirty) { ! 140: bp->b_flags |= B_DIRTY; ! 141: #if FORCESYNCBTREEWRITES ! 142: bwrite(bp); ! 143: #else ! 144: ! 145: /* ! 146: * ! 147: * Set the B_LOCKED flag and unlock the buffer, causing brelse to move ! 148: * the buffer onto the LOCKED free list. This is necessary, otherwise ! 149: * getnewbuf() would try to reclaim the buffers using bawrite, which ! 150: * isn't going to work. ! 151: * ! 152: */ ! 153: bp->b_flags |= B_LOCKED; ! 154: bdwrite(bp); ! 155: ! 156: #endif ! 157: } else { ! 158: brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */ ! 159: }; ! 160: }; ! 161: ! 162: exit: ! 163: return (retval); ! 164: } ! 165: ! 166: ! 167: OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF) ! 168: { ! 169: #pragma unused (maxEOF) ! 170: ! 171: OSStatus retval; ! 172: UInt32 actualBytesAdded; ! 173: UInt32 bytesToAdd; ! 174: UInt32 extendFlags; ! 175: BTreeInfoRec btInfo; ! 176: ExtendedVCB *vcb; ! 177: FCB *filePtr; ! 178: struct proc *p = NULL; ! 179: ! 180: ! 181: filePtr = GetFileControlBlock(vp); ! 182: ! 183: if ( minEOF > filePtr->fcbEOF ) ! 184: { ! 185: bytesToAdd = minEOF - filePtr->fcbEOF; ! 186: ! 187: if (bytesToAdd < filePtr->fcbClmpSize) ! 188: bytesToAdd = filePtr->fcbClmpSize; //XXX why not always be a mutiple of clump size? ! 189: } ! 190: else ! 191: { ! 192: DBG_TREE((" ExtendBTreeFile: minEOF is smaller than current size!")); ! 193: return -1; ! 194: } ! 195: ! 196: vcb = filePtr->fcbVPtr; ! 197: ! 198: /* ! 199: * The Extents B-tree can't have overflow extents. ExtendFileC will ! 200: * return an error if an attempt is made to extend the Extents B-tree ! 201: * when the resident extents are exhausted. ! 202: */ ! 203: /* XXX warning - this can leave the volume bitmap unprotected during ExtendFileC call */ ! 204: if(filePtr->fcbFlNm != kHFSExtentsFileID) ! 205: { ! 206: p = CURRENT_PROC; ! 207: /* lock extents b-tree (also protects volume bitmap) */ ! 208: retval = hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_EXCLUSIVE, p); ! 209: if (retval) ! 210: return (retval); ! 211: } ! 212: ! 213: (void) BTGetInformation(filePtr, 0, &btInfo); ! 214: ! 215: /* ! 216: * The b-tree code expects nodes to be contiguous. So when ! 217: * the allocation block size is less than the b-tree node ! 218: * size, we need to force disk allocations to be contiguous. ! 219: */ ! 220: if (vcb->blockSize >= btInfo.nodeSize) { ! 221: extendFlags = 0; ! 222: } else { ! 223: /* Ensure that all b-tree nodes are contiguous on disk */ ! 224: extendFlags = kEFAllMask | kEFContigMask; ! 225: } ! 226: ! 227: retval = ExtendFileC(vcb, filePtr, bytesToAdd, extendFlags, &actualBytesAdded ); ! 228: ! 229: if(filePtr->fcbFlNm != kHFSExtentsFileID) ! 230: (void) hfs_metafilelocking(VTOHFS(vp), kHFSExtentsFileID, LK_RELEASE, p); ! 231: ! 232: if (retval) ! 233: return (retval); ! 234: ! 235: if (actualBytesAdded < bytesToAdd) ! 236: DBG_TREE((" ExtendBTreeFile: actualBytesAdded < bytesToAdd!")); ! 237: ! 238: filePtr->fcbEOF = filePtr->fcbPLen; // new B-tree looks at fcbEOF ! 239: ! 240: /* ! 241: * Update the Alternate MDB or Alternate VolumeHeader ! 242: */ ! 243: if ( vcb->vcbSigWord == kHFSPlusSigWord ) ! 244: { ! 245: // If any of the HFS+ private files change size, flush them back to the Alternate volume header ! 246: if ( (filePtr->fcbFlNm == kHFSExtentsFileID) ! 247: || (filePtr->fcbFlNm == kHFSCatalogFileID) ! 248: || (filePtr->fcbFlNm == kHFSStartupFileID) ! 249: || (filePtr->fcbFlNm == kHFSAttributesFileID) ) ! 250: { ! 251: MarkVCBDirty( vcb ); ! 252: retval = FlushAlternateVolumeControlBlock( vcb, true ); ! 253: } ! 254: } ! 255: else if ( vcb->vcbSigWord == kHFSSigWord ) ! 256: { ! 257: if ( filePtr->fcbFlNm == kHFSExtentsFileID ) ! 258: { ! 259: vcb->vcbXTAlBlks = filePtr->fcbPLen / vcb->blockSize; ! 260: MarkVCBDirty( vcb ); ! 261: retval = FlushAlternateVolumeControlBlock( vcb, false ); ! 262: } ! 263: else if ( filePtr->fcbFlNm == kHFSCatalogFileID ) ! 264: { ! 265: vcb->vcbCTAlBlks = filePtr->fcbPLen / vcb->blockSize; ! 266: MarkVCBDirty( vcb ); ! 267: retval = FlushAlternateVolumeControlBlock( vcb, false ); ! 268: } ! 269: } ! 270: ! 271: return retval; ! 272: ! 273: } ! 274:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.