/*
- * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
+ * Copyright (c) 2000-2011 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
/* From bsd/vfs/vfs_bio.c */
extern int bdwrite_internal(struct buf *, int);
-static int ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount);
+static int ClearBTNodes(struct vnode *vp, int blksize, off_t offset, off_t amount);
static int btree_journal_modify_block_end(struct hfsmount *hfsmp, struct buf *bp);
+void btree_swap_node(struct buf *bp, __unused void *arg);
+
+/*
+ * Return btree node size for given vnode.
+ *
+ * Returns:
+ * For btree vnode, returns btree node size.
+ * For non-btree vnodes, returns 0.
+ */
+u_int16_t get_btree_nodesize(struct vnode *vp)
+{
+ BTreeControlBlockPtr btree;
+ u_int16_t node_size = 0;
+
+ if (vnode_issystem(vp)) {
+ btree = (BTreeControlBlockPtr) VTOF(vp)->fcbBTCBPtr;
+ if (btree) {
+ node_size = btree->nodeSize;
+ }
+ }
+
+ return node_size;
+}
-__private_extern__
OSStatus SetBTreeBlockSize(FileReference vp, ByteCount blockSize, __unused ItemCount minBlockCount)
{
BTreeControlBlockPtr bTreePtr;
}
-__private_extern__
OSStatus GetBTreeBlock(FileReference vp, u_int32_t blockNum, GetBlockOptions options, BlockDescriptor *block)
{
OSStatus retval = E_NONE;
// XXXdbg
block->isModified = 0;
- /* Check and endian swap B-Tree node (only if it's a valid block) */
- if (!(options & kGetEmptyBlock)) {
- /* This happens when we first open the b-tree, we might not have all the node data on hand */
- if ((((BTNodeDescriptor *)block->buffer)->kind == kBTHeaderNode) &&
- (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize != buf_count(bp)) &&
- (SWAP_BE16 (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize) != buf_count(bp))) {
+ /* Check and endian swap B-Tree node (only if it's a valid block) */
+ if (!(options & kGetEmptyBlock)) {
+
+ /* This happens when we first open the b-tree, we might not have all the node data on hand */
+ if ((((BTNodeDescriptor *)block->buffer)->kind == kBTHeaderNode) &&
+ (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize != buf_count(bp)) &&
+ (SWAP_BE16 (((BTHeaderRec *)((char *)block->buffer + 14))->nodeSize) != buf_count(bp))) {
- /*
- * Don't swap the node descriptor, record offsets, or other records.
- * This record will be invalidated and re-read with the correct node
- * size once the B-tree control block is set up with the node size
- * from the header record.
- */
- retval = hfs_swap_BTNode (block, vp, kSwapBTNodeHeaderRecordOnly, allow_empty_node);
-
- } else if (block->blockReadFromDisk) {
- /*
- * The node was just read from disk, so always swap/check it.
- * This is necessary on big endian since the test below won't trigger.
- */
- retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);
- } else if (*((u_int16_t *)((char *)block->buffer + (block->blockSize - sizeof (u_int16_t)))) == 0x0e00) {
/*
- * The node was left in the cache in non-native order, so swap it.
- * This only happens on little endian, after the node is written
- * back to disk.
+ * Don't swap the node descriptor, record offsets, or other records.
+ * This record will be invalidated and re-read with the correct node
+ * size once the B-tree control block is set up with the node size
+ * from the header record.
*/
- retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);
- }
-
- /*
- * If we got an error, then the node is only partially swapped.
- * We mark the buffer invalid so that the next attempt to get the
- * node will read it and attempt to swap again, and will notice
- * the error again. If we didn't do this, the next attempt to get
- * the node might use the partially swapped node as-is.
- */
- if (retval)
+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeHeaderRecordOnly, allow_empty_node);
+
+ } else {
+ /*
+ * In this case, we have enough data in-hand to do basic validation
+ * on the B-Tree node.
+ */
+ if (block->blockReadFromDisk) {
+ /*
+ * The node was just read from disk, so always swap/check it.
+ * This is necessary on big endian since the test below won't trigger.
+ */
+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);
+ }
+ else {
+ /*
+ * Block wasn't read from disk; it was found in the cache.
+ */
+ if (*((u_int16_t *)((char *)block->buffer + (block->blockSize - sizeof (u_int16_t)))) == 0x0e00) {
+ /*
+ * The node was left in the cache in non-native order, so swap it.
+ * This only happens on little endian, after the node is written
+ * back to disk.
+ */
+ retval = hfs_swap_BTNode (block, vp, kSwapBTNodeBigToHost, allow_empty_node);
+ }
+ else if (*((u_int16_t *)((char *)block->buffer + (block->blockSize - sizeof (u_int16_t)))) == 0x000e) {
+ /*
+ * The node was in-cache in native-endianness. We don't need to do
+ * anything here, because the node is ready to use. Set retval == 0.
+ */
+ retval = 0;
+ }
+ /*
+ * If the node doesn't have hex 14 (0xe) in the last two bytes of the buffer,
+ * it doesn't necessarily mean that this is a bad node. Zeroed nodes that are
+ * marked as unused in the b-tree map node would be OK and not have valid content.
+ */
+ }
+ }
+
+ /*
+ * If we got an error, then the node is only partially swapped.
+ * We mark the buffer invalid so that the next attempt to get the
+ * node will read it and attempt to swap again, and will notice
+ * the error again. If we didn't do this, the next attempt to get
+ * the node might use the partially swapped node as-is.
+ */
+ if (retval)
buf_markinvalid(bp);
- }
- }
+ }
+ }
if (retval) {
if (bp)
}
-__private_extern__
void ModifyBlockStart(FileReference vp, BlockDescPtr blockPtr)
{
struct hfsmount *hfsmp = VTOHFS(vp);
blockPtr->isModified = 1;
}
-static void
+void
btree_swap_node(struct buf *bp, __unused void *arg)
{
// struct hfsmount *hfsmp = (struct hfsmount *)arg;
}
-__private_extern__
OSStatus ReleaseBTreeBlock(FileReference vp, BlockDescPtr blockPtr, ReleaseBlockOptions options)
{
struct hfsmount *hfsmp = VTOHFS(vp);
} else {
buf_brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
}
+
+ /* Don't let anyone else try to use this bp, it's been consumed */
+ blockPtr->blockHeader = NULL;
+
} else {
if (options & kForceWriteBlock) {
if (hfsmp->jnl) {
} else {
retval = VNOP_BWRITE(bp);
}
+
+ /* Don't let anyone else try to use this bp, it's been consumed */
+ blockPtr->blockHeader = NULL;
+
} else if (options & kMarkBlockDirty) {
struct timeval tv;
microuptime(&tv);
buf_clearflags(bp, B_LOCKED);
buf_bawrite(bp);
}
+
+ /* Don't let anyone else try to use this bp, it's been consumed */
+ blockPtr->blockHeader = NULL;
+
} else {
// check if we had previously called journal_modify_block_start()
// on this block and if so, abort it (which will call buf_brelse()).
} else {
buf_brelse(bp); /* note: B-tree code will clear blockPtr->blockHeader and blockPtr->buffer */
}
- };
- };
+
+ /* Don't let anyone else try to use this bp, it's been consumed */
+ blockPtr->blockHeader = NULL;
+ }
+ }
exit:
return (retval);
}
-__private_extern__
OSStatus ExtendBTreeFile(FileReference vp, FSSize minEOF, FSSize maxEOF)
{
#pragma unused (maxEOF)
trim = ((filePtr->fcbEOF - origSize) % btInfo.nodeSize);
}
- ret = TruncateFileC(vcb, filePtr, filePtr->fcbEOF - trim, 0);
+ ret = TruncateFileC(vcb, filePtr, filePtr->fcbEOF - trim, 0, 0, FTOC(filePtr)->c_fileid, 0);
filePtr->fcbEOF = (u_int64_t)filePtr->ff_blocks * (u_int64_t)vcb->blockSize;
// XXXdbg - panic if the file didn't get trimmed back properly
/*
* Update the Alternate MDB or Alternate VolumeHeader
*/
+ VTOC(vp)->c_flag |= C_MODIFIED;
if ((VTOC(vp)->c_fileid == kHFSExtentsFileID) ||
(VTOC(vp)->c_fileid == kHFSCatalogFileID) ||
(VTOC(vp)->c_fileid == kHFSAttributesFileID)
) {
- VTOC(vp)->c_flag |= C_MODIFIED;
MarkVCBDirty( vcb );
- ret = hfs_flushvolumeheader(VCBTOHFS(vcb), MNT_WAIT, HFS_ALTFLUSH);
+ ret = hfs_flushvolumeheader(VCBTOHFS(vcb), HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);
} else {
VTOC(vp)->c_touch_chgtime = TRUE;
VTOC(vp)->c_touch_modtime = TRUE;
- (void) hfs_update(vp, TRUE);
+ (void) hfs_update(vp, 0);
}
ret = ClearBTNodes(vp, btInfo.nodeSize, origSize, (filePtr->fcbEOF - origSize));
* Clear out (zero) new b-tree nodes on disk.
*/
static int
-ClearBTNodes(struct vnode *vp, long blksize, off_t offset, off_t amount)
+ClearBTNodes(struct vnode *vp, int blksize, off_t offset, off_t amount)
{
struct hfsmount *hfsmp = VTOHFS(vp);
struct buf *bp = NULL;
u_int16_t offset;
int intrans = 0;
int result;
+ int newvnode_flags = 0;
+
again:
/*
* Serialize creation using HFS_CREATING_BTREE flag.
*/
- lck_mtx_lock(&hfsmp->hfs_mutex);
+ hfs_lock_mount (hfsmp);
if (hfsmp->hfs_flags & HFS_CREATING_BTREE) {
/* Someone else beat us, wait for them to finish. */
- (void) msleep(hfsmp->hfs_attribute_cp, &hfsmp->hfs_mutex,
+ (void) msleep(&hfsmp->hfs_attribute_cp, &hfsmp->hfs_mutex,
PDROP | PINOD, "hfs_create_attr_btree", 0);
if (hfsmp->hfs_attribute_vp) {
return (0);
goto again;
}
hfsmp->hfs_flags |= HFS_CREATING_BTREE;
- lck_mtx_unlock(&hfsmp->hfs_mutex);
+ hfs_unlock_mount (hfsmp);
/* Check if were out of usable disk space. */
if ((hfs_freeblks(hfsmp, 1) == 0)) {
bzero(&cfork, sizeof(cfork));
cfork.cf_clump = nodesize * nodecnt;
- result = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr, &cfork, &vp);
+ result = hfs_getnewvnode(hfsmp, NULL, NULL, &cndesc, 0, &cnattr,
+ &cfork, &vp, &newvnode_flags);
if (result) {
goto exit;
}
}
/* Update vp/cp for attribute btree */
- lck_mtx_lock(&hfsmp->hfs_mutex);
+ hfs_lock_mount (hfsmp);
hfsmp->hfs_attribute_cp = VTOC(vp);
hfsmp->hfs_attribute_vp = vp;
- lck_mtx_unlock(&hfsmp->hfs_mutex);
+ hfs_unlock_mount (hfsmp);
+
+ (void) hfs_flushvolumeheader(hfsmp, HFS_FVH_WAIT | HFS_FVH_WRITE_ALT);
+
+ if (intrans) {
+ hfs_end_transaction(hfsmp);
+ intrans = 0;
+ }
+
+ /* Initialize the vnode for virtual attribute data file */
+ result = init_attrdata_vnode(hfsmp);
+ if (result) {
+ printf("hfs_create_attr_btree: vol=%s init_attrdata_vnode() error=%d\n", hfsmp->vcbVN, result);
+ }
- (void) hfs_flushvolumeheader(hfsmp, MNT_WAIT, HFS_ALTFLUSH);
exit:
if (vp) {
hfs_unlock(VTOC(vp));
/*
* All done, clear HFS_CREATING_BTREE, and wake up any sleepers.
*/
- lck_mtx_lock(&hfsmp->hfs_mutex);
+ hfs_lock_mount (hfsmp);
hfsmp->hfs_flags &= ~HFS_CREATING_BTREE;
- wakeup((caddr_t)hfsmp->hfs_attribute_cp);
- lck_mtx_unlock(&hfsmp->hfs_mutex);
+ wakeup((caddr_t)&hfsmp->hfs_attribute_cp);
+ hfs_unlock_mount (hfsmp);
return (result);
}
projects / apple / xnu.git / blobdiff