// SPDX-License-Identifier: GPL-2.0 /* * Copyright (c) 2000-2005 Silicon Graphics, Inc. * Copyright (c) 2013 Red Hat, Inc. * All Rights Reserved. */ #include "xfs.h" #include "xfs_fs.h" #include "xfs_shared.h" #include "xfs_format.h" #include "xfs_log_format.h" #include "xfs_trans_resv.h" #include "xfs_bit.h" #include "xfs_mount.h" #include "xfs_inode.h" #include "xfs_dir2.h" #include "xfs_dir2_priv.h" #include "xfs_trans.h" #include "xfs_bmap.h" #include "xfs_attr_leaf.h" #include "xfs_error.h" #include "xfs_trace.h" #include "xfs_buf_item.h" #include "xfs_log.h" /* * xfs_da_btree.c * * Routines to implement directories as Btrees of hashed names. */ /*======================================================================== * Function prototypes for the kernel. *========================================================================*/ /* * Routines used for growing the Btree. */ STATIC int xfs_da3_root_split(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *existing_root, <------><------><------><------><------> xfs_da_state_blk_t *new_child); STATIC int xfs_da3_node_split(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *existing_blk, <------><------><------><------><------> xfs_da_state_blk_t *split_blk, <------><------><------><------><------> xfs_da_state_blk_t *blk_to_add, <------><------><------><------><------> int treelevel, <------><------><------><------><------> int *result); STATIC void xfs_da3_node_rebalance(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *node_blk_1, <------><------><------><------><------> xfs_da_state_blk_t *node_blk_2); STATIC void xfs_da3_node_add(xfs_da_state_t *state, <------><------><------><------> xfs_da_state_blk_t *old_node_blk, <------><------><------><------> xfs_da_state_blk_t *new_node_blk); /* * Routines used for shrinking the Btree. */ STATIC int xfs_da3_root_join(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *root_blk); STATIC int xfs_da3_node_toosmall(xfs_da_state_t *state, int *retval); STATIC void xfs_da3_node_remove(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *drop_blk); STATIC void xfs_da3_node_unbalance(xfs_da_state_t *state, <------><------><------><------><------> xfs_da_state_blk_t *src_node_blk, <------><------><------><------><------> xfs_da_state_blk_t *dst_node_blk); /* * Utility routines. */ STATIC int xfs_da3_blk_unlink(xfs_da_state_t *state, <------><------><------><------> xfs_da_state_blk_t *drop_blk, <------><------><------><------> xfs_da_state_blk_t *save_blk); kmem_zone_t *xfs_da_state_zone; /* anchor for state struct zone */ /* * Allocate a dir-state structure. * We don't put them on the stack since they're large. */ struct xfs_da_state * xfs_da_state_alloc( <------>struct xfs_da_args *args) { <------>struct xfs_da_state *state; <------>state = kmem_cache_zalloc(xfs_da_state_zone, GFP_NOFS | __GFP_NOFAIL); <------>state->args = args; <------>state->mp = args->dp->i_mount; <------>return state; } /* * Kill the altpath contents of a da-state structure. */ STATIC void xfs_da_state_kill_altpath(xfs_da_state_t *state) { <------>int i; <------>for (i = 0; i < state->altpath.active; i++) <------><------>state->altpath.blk[i].bp = NULL; <------>state->altpath.active = 0; } /* * Free a da-state structure. */ void xfs_da_state_free(xfs_da_state_t *state) { <------>xfs_da_state_kill_altpath(state); #ifdef DEBUG <------>memset((char *)state, 0, sizeof(*state)); #endif /* DEBUG */ <------>kmem_cache_free(xfs_da_state_zone, state); } static inline int xfs_dabuf_nfsb(struct xfs_mount *mp, int whichfork) { <------>if (whichfork == XFS_DATA_FORK) <------><------>return mp->m_dir_geo->fsbcount; <------>return mp->m_attr_geo->fsbcount; } void xfs_da3_node_hdr_from_disk( <------>struct xfs_mount *mp, <------>struct xfs_da3_icnode_hdr *to, <------>struct xfs_da_intnode *from) { <------>if (xfs_sb_version_hascrc(&mp->m_sb)) { <------><------>struct xfs_da3_intnode *from3 = (struct xfs_da3_intnode *)from; <------><------>to->forw = be32_to_cpu(from3->hdr.info.hdr.forw); <------><------>to->back = be32_to_cpu(from3->hdr.info.hdr.back); <------><------>to->magic = be16_to_cpu(from3->hdr.info.hdr.magic); <------><------>to->count = be16_to_cpu(from3->hdr.__count); <------><------>to->level = be16_to_cpu(from3->hdr.__level); <------><------>to->btree = from3->__btree; <------><------>ASSERT(to->magic == XFS_DA3_NODE_MAGIC); <------>} else { <------><------>to->forw = be32_to_cpu(from->hdr.info.forw); <------><------>to->back = be32_to_cpu(from->hdr.info.back); <------><------>to->magic = be16_to_cpu(from->hdr.info.magic); <------><------>to->count = be16_to_cpu(from->hdr.__count); <------><------>to->level = be16_to_cpu(from->hdr.__level); <------><------>to->btree = from->__btree; <------><------>ASSERT(to->magic == XFS_DA_NODE_MAGIC); <------>} } void xfs_da3_node_hdr_to_disk( <------>struct xfs_mount *mp, <------>struct xfs_da_intnode *to, <------>struct xfs_da3_icnode_hdr *from) { <------>if (xfs_sb_version_hascrc(&mp->m_sb)) { <------><------>struct xfs_da3_intnode *to3 = (struct xfs_da3_intnode *)to; <------><------>ASSERT(from->magic == XFS_DA3_NODE_MAGIC); <------><------>to3->hdr.info.hdr.forw = cpu_to_be32(from->forw); <------><------>to3->hdr.info.hdr.back = cpu_to_be32(from->back); <------><------>to3->hdr.info.hdr.magic = cpu_to_be16(from->magic); <------><------>to3->hdr.__count = cpu_to_be16(from->count); <------><------>to3->hdr.__level = cpu_to_be16(from->level); <------>} else { <------><------>ASSERT(from->magic == XFS_DA_NODE_MAGIC); <------><------>to->hdr.info.forw = cpu_to_be32(from->forw); <------><------>to->hdr.info.back = cpu_to_be32(from->back); <------><------>to->hdr.info.magic = cpu_to_be16(from->magic); <------><------>to->hdr.__count = cpu_to_be16(from->count); <------><------>to->hdr.__level = cpu_to_be16(from->level); <------>} } /* * Verify an xfs_da3_blkinfo structure. Note that the da3 fields are only * accessible on v5 filesystems. This header format is common across da node, * attr leaf and dir leaf blocks. */ xfs_failaddr_t xfs_da3_blkinfo_verify( <------>struct xfs_buf *bp, <------>struct xfs_da3_blkinfo *hdr3) { <------>struct xfs_mount *mp = bp->b_mount; <------>struct xfs_da_blkinfo *hdr = &hdr3->hdr; <------>if (!xfs_verify_magic16(bp, hdr->magic)) <------><------>return __this_address; <------>if (xfs_sb_version_hascrc(&mp->m_sb)) { <------><------>if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid)) <------><------><------>return __this_address; <------><------>if (be64_to_cpu(hdr3->blkno) != bp->b_bn) <------><------><------>return __this_address; <------><------>if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn))) <------><------><------>return __this_address; <------>} <------>return NULL; } static xfs_failaddr_t xfs_da3_node_verify( <------>struct xfs_buf *bp) { <------>struct xfs_mount *mp = bp->b_mount; <------>struct xfs_da_intnode *hdr = bp->b_addr; <------>struct xfs_da3_icnode_hdr ichdr; <------>xfs_failaddr_t fa; <------>xfs_da3_node_hdr_from_disk(mp, &ichdr, hdr); <------>fa = xfs_da3_blkinfo_verify(bp, bp->b_addr); <------>if (fa) <------><------>return fa; <------>if (ichdr.level == 0) <------><------>return __this_address; <------>if (ichdr.level > XFS_DA_NODE_MAXDEPTH) <------><------>return __this_address; <------>if (ichdr.count == 0) <------><------>return __this_address; <------>/* <------> * we don't know if the node is for and attribute or directory tree, <------> * so only fail if the count is outside both bounds <------> */ <------>if (ichdr.count > mp->m_dir_geo->node_ents && <------> ichdr.count > mp->m_attr_geo->node_ents) <------><------>return __this_address; <------>/* XXX: hash order check? */ <------>return NULL; } static void xfs_da3_node_write_verify( <------>struct xfs_buf *bp) { <------>struct xfs_mount *mp = bp->b_mount; <------>struct xfs_buf_log_item *bip = bp->b_log_item; <------>struct xfs_da3_node_hdr *hdr3 = bp->b_addr; <------>xfs_failaddr_t fa; <------>fa = xfs_da3_node_verify(bp); <------>if (fa) { <------><------>xfs_verifier_error(bp, -EFSCORRUPTED, fa); <------><------>return; <------>} <------>if (!xfs_sb_version_hascrc(&mp->m_sb)) <------><------>return; <------>if (bip) <------><------>hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn); <------>xfs_buf_update_cksum(bp, XFS_DA3_NODE_CRC_OFF); } /* * leaf/node format detection on trees is sketchy, so a node read can be done on * leaf level blocks when detection identifies the tree as a node format tree * incorrectly. In this case, we need to swap the verifier to match the correct * format of the block being read. */ static void xfs_da3_node_read_verify( <------>struct xfs_buf *bp) { <------>struct xfs_da_blkinfo *info = bp->b_addr; <------>xfs_failaddr_t fa; <------>switch (be16_to_cpu(info->magic)) { <------><------>case XFS_DA3_NODE_MAGIC: <------><------><------>if (!xfs_buf_verify_cksum(bp, XFS_DA3_NODE_CRC_OFF)) { <------><------><------><------>xfs_verifier_error(bp, -EFSBADCRC, <------><------><------><------><------><------>__this_address); <------><------><------><------>break; <------><------><------>} <------><------><------>/* fall through */ <------><------>case XFS_DA_NODE_MAGIC: <------><------><------>fa = xfs_da3_node_verify(bp); <------><------><------>if (fa) <------><------><------><------>xfs_verifier_error(bp, -EFSCORRUPTED, fa); <------><------><------>return; <------><------>case XFS_ATTR_LEAF_MAGIC: <------><------>case XFS_ATTR3_LEAF_MAGIC: <------><------><------>bp->b_ops = &xfs_attr3_leaf_buf_ops; <------><------><------>bp->b_ops->verify_read(bp); <------><------><------>return; <------><------>case XFS_DIR2_LEAFN_MAGIC: <------><------>case XFS_DIR3_LEAFN_MAGIC: <------><------><------>bp->b_ops = &xfs_dir3_leafn_buf_ops; <------><------><------>bp->b_ops->verify_read(bp); <------><------><------>return; <------><------>default: <------><------><------>xfs_verifier_error(bp, -EFSCORRUPTED, __this_address); <------><------><------>break; <------>} } /* Verify the structure of a da3 block. */ static xfs_failaddr_t xfs_da3_node_verify_struct( <------>struct xfs_buf *bp) { <------>struct xfs_da_blkinfo *info = bp->b_addr; <------>switch (be16_to_cpu(info->magic)) { <------>case XFS_DA3_NODE_MAGIC: <------>case XFS_DA_NODE_MAGIC: <------><------>return xfs_da3_node_verify(bp); <------>case XFS_ATTR_LEAF_MAGIC: <------>case XFS_ATTR3_LEAF_MAGIC: <------><------>bp->b_ops = &xfs_attr3_leaf_buf_ops; <------><------>return bp->b_ops->verify_struct(bp); <------>case XFS_DIR2_LEAFN_MAGIC: <------>case XFS_DIR3_LEAFN_MAGIC: <------><------>bp->b_ops = &xfs_dir3_leafn_buf_ops; <------><------>return bp->b_ops->verify_struct(bp); <------>default: <------><------>return __this_address; <------>} } const struct xfs_buf_ops xfs_da3_node_buf_ops = { <------>.name = "xfs_da3_node", <------>.magic16 = { cpu_to_be16(XFS_DA_NODE_MAGIC), <------><------> cpu_to_be16(XFS_DA3_NODE_MAGIC) }, <------>.verify_read = xfs_da3_node_read_verify, <------>.verify_write = xfs_da3_node_write_verify, <------>.verify_struct = xfs_da3_node_verify_struct, }; static int xfs_da3_node_set_type( <------>struct xfs_trans *tp, <------>struct xfs_buf *bp) { <------>struct xfs_da_blkinfo *info = bp->b_addr; <------>switch (be16_to_cpu(info->magic)) { <------>case XFS_DA_NODE_MAGIC: <------>case XFS_DA3_NODE_MAGIC: <------><------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF); <------><------>return 0; <------>case XFS_ATTR_LEAF_MAGIC: <------>case XFS_ATTR3_LEAF_MAGIC: <------><------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_ATTR_LEAF_BUF); <------><------>return 0; <------>case XFS_DIR2_LEAFN_MAGIC: <------>case XFS_DIR3_LEAFN_MAGIC: <------><------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF); <------><------>return 0; <------>default: <------><------>XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, tp->t_mountp, <------><------><------><------>info, sizeof(*info)); <------><------>xfs_trans_brelse(tp, bp); <------><------>return -EFSCORRUPTED; <------>} } int xfs_da3_node_read( <------>struct xfs_trans *tp, <------>struct xfs_inode *dp, <------>xfs_dablk_t bno, <------>struct xfs_buf **bpp, <------>int whichfork) { <------>int error; <------>error = xfs_da_read_buf(tp, dp, bno, 0, bpp, whichfork, <------><------><------>&xfs_da3_node_buf_ops); <------>if (error || !*bpp || !tp) <------><------>return error; <------>return xfs_da3_node_set_type(tp, *bpp); } int xfs_da3_node_read_mapped( <------>struct xfs_trans *tp, <------>struct xfs_inode *dp, <------>xfs_daddr_t mappedbno, <------>struct xfs_buf **bpp, <------>int whichfork) { <------>struct xfs_mount *mp = dp->i_mount; <------>int error; <------>error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, mappedbno, <------><------><------>XFS_FSB_TO_BB(mp, xfs_dabuf_nfsb(mp, whichfork)), 0, <------><------><------>bpp, &xfs_da3_node_buf_ops); <------>if (error || !*bpp) <------><------>return error; <------>if (whichfork == XFS_ATTR_FORK) <------><------>xfs_buf_set_ref(*bpp, XFS_ATTR_BTREE_REF); <------>else <------><------>xfs_buf_set_ref(*bpp, XFS_DIR_BTREE_REF); <------>if (!tp) <------><------>return 0; <------>return xfs_da3_node_set_type(tp, *bpp); } /*======================================================================== * Routines used for growing the Btree. *========================================================================*/ /* * Create the initial contents of an intermediate node. */ int xfs_da3_node_create( <------>struct xfs_da_args *args, <------>xfs_dablk_t blkno, <------>int level, <------>struct xfs_buf **bpp, <------>int whichfork) { <------>struct xfs_da_intnode *node; <------>struct xfs_trans *tp = args->trans; <------>struct xfs_mount *mp = tp->t_mountp; <------>struct xfs_da3_icnode_hdr ichdr = {0}; <------>struct xfs_buf *bp; <------>int error; <------>struct xfs_inode *dp = args->dp; <------>trace_xfs_da_node_create(args); <------>ASSERT(level <= XFS_DA_NODE_MAXDEPTH); <------>error = xfs_da_get_buf(tp, dp, blkno, &bp, whichfork); <------>if (error) <------><------>return error; <------>bp->b_ops = &xfs_da3_node_buf_ops; <------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF); <------>node = bp->b_addr; <------>if (xfs_sb_version_hascrc(&mp->m_sb)) { <------><------>struct xfs_da3_node_hdr *hdr3 = bp->b_addr; <------><------>memset(hdr3, 0, sizeof(struct xfs_da3_node_hdr)); <------><------>ichdr.magic = XFS_DA3_NODE_MAGIC; <------><------>hdr3->info.blkno = cpu_to_be64(bp->b_bn); <------><------>hdr3->info.owner = cpu_to_be64(args->dp->i_ino); <------><------>uuid_copy(&hdr3->info.uuid, &mp->m_sb.sb_meta_uuid); <------>} else { <------><------>ichdr.magic = XFS_DA_NODE_MAGIC; <------>} <------>ichdr.level = level; <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node, &ichdr); <------>xfs_trans_log_buf(tp, bp, <------><------>XFS_DA_LOGRANGE(node, &node->hdr, args->geo->node_hdr_size)); <------>*bpp = bp; <------>return 0; } /* * Split a leaf node, rebalance, then possibly split * intermediate nodes, rebalance, etc. */ int /* error */ xfs_da3_split( <------>struct xfs_da_state *state) { <------>struct xfs_da_state_blk *oldblk; <------>struct xfs_da_state_blk *newblk; <------>struct xfs_da_state_blk *addblk; <------>struct xfs_da_intnode *node; <------>int max; <------>int action = 0; <------>int error; <------>int i; <------>trace_xfs_da_split(state->args); <------>/* <------> * Walk back up the tree splitting/inserting/adjusting as necessary. <------> * If we need to insert and there isn't room, split the node, then <------> * decide which fragment to insert the new block from below into. <------> * Note that we may split the root this way, but we need more fixup. <------> */ <------>max = state->path.active - 1; <------>ASSERT((max >= 0) && (max < XFS_DA_NODE_MAXDEPTH)); <------>ASSERT(state->path.blk[max].magic == XFS_ATTR_LEAF_MAGIC || <------> state->path.blk[max].magic == XFS_DIR2_LEAFN_MAGIC); <------>addblk = &state->path.blk[max]; /* initial dummy value */ <------>for (i = max; (i >= 0) && addblk; state->path.active--, i--) { <------><------>oldblk = &state->path.blk[i]; <------><------>newblk = &state->altpath.blk[i]; <------><------>/* <------><------> * If a leaf node then <------><------> * Allocate a new leaf node, then rebalance across them. <------><------> * else if an intermediate node then <------><------> * We split on the last layer, must we split the node? <------><------> */ <------><------>switch (oldblk->magic) { <------><------>case XFS_ATTR_LEAF_MAGIC: <------><------><------>error = xfs_attr3_leaf_split(state, oldblk, newblk); <------><------><------>if ((error != 0) && (error != -ENOSPC)) { <------><------><------><------>return error; /* GROT: attr is inconsistent */ <------><------><------>} <------><------><------>if (!error) { <------><------><------><------>addblk = newblk; <------><------><------><------>break; <------><------><------>} <------><------><------>/* <------><------><------> * Entry wouldn't fit, split the leaf again. The new <------><------><------> * extrablk will be consumed by xfs_da3_node_split if <------><------><------> * the node is split. <------><------><------> */ <------><------><------>state->extravalid = 1; <------><------><------>if (state->inleaf) { <------><------><------><------>state->extraafter = 0; /* before newblk */ <------><------><------><------>trace_xfs_attr_leaf_split_before(state->args); <------><------><------><------>error = xfs_attr3_leaf_split(state, oldblk, <------><------><------><------><------><------><------> &state->extrablk); <------><------><------>} else { <------><------><------><------>state->extraafter = 1; /* after newblk */ <------><------><------><------>trace_xfs_attr_leaf_split_after(state->args); <------><------><------><------>error = xfs_attr3_leaf_split(state, newblk, <------><------><------><------><------><------><------> &state->extrablk); <------><------><------>} <------><------><------>if (error) <------><------><------><------>return error; /* GROT: attr inconsistent */ <------><------><------>addblk = newblk; <------><------><------>break; <------><------>case XFS_DIR2_LEAFN_MAGIC: <------><------><------>error = xfs_dir2_leafn_split(state, oldblk, newblk); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>addblk = newblk; <------><------><------>break; <------><------>case XFS_DA_NODE_MAGIC: <------><------><------>error = xfs_da3_node_split(state, oldblk, newblk, addblk, <------><------><------><------><------><------><------> max - i, &action); <------><------><------>addblk->bp = NULL; <------><------><------>if (error) <------><------><------><------>return error; /* GROT: dir is inconsistent */ <------><------><------>/* <------><------><------> * Record the newly split block for the next time thru? <------><------><------> */ <------><------><------>if (action) <------><------><------><------>addblk = newblk; <------><------><------>else <------><------><------><------>addblk = NULL; <------><------><------>break; <------><------>} <------><------>/* <------><------> * Update the btree to show the new hashval for this child. <------><------> */ <------><------>xfs_da3_fixhashpath(state, &state->path); <------>} <------>if (!addblk) <------><------>return 0; <------>/* <------> * xfs_da3_node_split() should have consumed any extra blocks we added <------> * during a double leaf split in the attr fork. This is guaranteed as <------> * we can't be here if the attr fork only has a single leaf block. <------> */ <------>ASSERT(state->extravalid == 0 || <------> state->path.blk[max].magic == XFS_DIR2_LEAFN_MAGIC); <------>/* <------> * Split the root node. <------> */ <------>ASSERT(state->path.active == 0); <------>oldblk = &state->path.blk[0]; <------>error = xfs_da3_root_split(state, oldblk, addblk); <------>if (error) <------><------>goto out; <------>/* <------> * Update pointers to the node which used to be block 0 and just got <------> * bumped because of the addition of a new root node. Note that the <------> * original block 0 could be at any position in the list of blocks in <------> * the tree. <------> * <------> * Note: the magic numbers and sibling pointers are in the same physical <------> * place for both v2 and v3 headers (by design). Hence it doesn't matter <------> * which version of the xfs_da_intnode structure we use here as the <------> * result will be the same using either structure. <------> */ <------>node = oldblk->bp->b_addr; <------>if (node->hdr.info.forw) { <------><------>if (be32_to_cpu(node->hdr.info.forw) != addblk->blkno) { <------><------><------>xfs_buf_mark_corrupt(oldblk->bp); <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto out; <------><------>} <------><------>node = addblk->bp->b_addr; <------><------>node->hdr.info.back = cpu_to_be32(oldblk->blkno); <------><------>xfs_trans_log_buf(state->args->trans, addblk->bp, <------><------><------><------> XFS_DA_LOGRANGE(node, &node->hdr.info, <------><------><------><------> sizeof(node->hdr.info))); <------>} <------>node = oldblk->bp->b_addr; <------>if (node->hdr.info.back) { <------><------>if (be32_to_cpu(node->hdr.info.back) != addblk->blkno) { <------><------><------>xfs_buf_mark_corrupt(oldblk->bp); <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto out; <------><------>} <------><------>node = addblk->bp->b_addr; <------><------>node->hdr.info.forw = cpu_to_be32(oldblk->blkno); <------><------>xfs_trans_log_buf(state->args->trans, addblk->bp, <------><------><------><------> XFS_DA_LOGRANGE(node, &node->hdr.info, <------><------><------><------> sizeof(node->hdr.info))); <------>} out: <------>addblk->bp = NULL; <------>return error; } /* * Split the root. We have to create a new root and point to the two * parts (the split old root) that we just created. Copy block zero to * the EOF, extending the inode in process. */ STATIC int /* error */ xfs_da3_root_split( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *blk1, <------>struct xfs_da_state_blk *blk2) { <------>struct xfs_da_intnode *node; <------>struct xfs_da_intnode *oldroot; <------>struct xfs_da_node_entry *btree; <------>struct xfs_da3_icnode_hdr nodehdr; <------>struct xfs_da_args *args; <------>struct xfs_buf *bp; <------>struct xfs_inode *dp; <------>struct xfs_trans *tp; <------>struct xfs_dir2_leaf *leaf; <------>xfs_dablk_t blkno; <------>int level; <------>int error; <------>int size; <------>trace_xfs_da_root_split(state->args); <------>/* <------> * Copy the existing (incorrect) block from the root node position <------> * to a free space somewhere. <------> */ <------>args = state->args; <------>error = xfs_da_grow_inode(args, &blkno); <------>if (error) <------><------>return error; <------>dp = args->dp; <------>tp = args->trans; <------>error = xfs_da_get_buf(tp, dp, blkno, &bp, args->whichfork); <------>if (error) <------><------>return error; <------>node = bp->b_addr; <------>oldroot = blk1->bp->b_addr; <------>if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) || <------> oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) { <------><------>struct xfs_da3_icnode_hdr icnodehdr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &icnodehdr, oldroot); <------><------>btree = icnodehdr.btree; <------><------>size = (int)((char *)&btree[icnodehdr.count] - (char *)oldroot); <------><------>level = icnodehdr.level; <------><------>/* <------><------> * we are about to copy oldroot to bp, so set up the type <------><------> * of bp while we know exactly what it will be. <------><------> */ <------><------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DA_NODE_BUF); <------>} else { <------><------>struct xfs_dir3_icleaf_hdr leafhdr; <------><------>leaf = (xfs_dir2_leaf_t *)oldroot; <------><------>xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, leaf); <------><------>ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC || <------><------> leafhdr.magic == XFS_DIR3_LEAFN_MAGIC); <------><------>size = (int)((char *)&leafhdr.ents[leafhdr.count] - <------><------><------>(char *)leaf); <------><------>level = 0; <------><------>/* <------><------> * we are about to copy oldroot to bp, so set up the type <------><------> * of bp while we know exactly what it will be. <------><------> */ <------><------>xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF); <------>} <------>/* <------> * we can copy most of the information in the node from one block to <------> * another, but for CRC enabled headers we have to make sure that the <------> * block specific identifiers are kept intact. We update the buffer <------> * directly for this. <------> */ <------>memcpy(node, oldroot, size); <------>if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) || <------> oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) { <------><------>struct xfs_da3_intnode *node3 = (struct xfs_da3_intnode *)node; <------><------>node3->hdr.info.blkno = cpu_to_be64(bp->b_bn); <------>} <------>xfs_trans_log_buf(tp, bp, 0, size - 1); <------>bp->b_ops = blk1->bp->b_ops; <------>xfs_trans_buf_copy_type(bp, blk1->bp); <------>blk1->bp = bp; <------>blk1->blkno = blkno; <------>/* <------> * Set up the new root node. <------> */ <------>error = xfs_da3_node_create(args, <------><------>(args->whichfork == XFS_DATA_FORK) ? args->geo->leafblk : 0, <------><------>level + 1, &bp, args->whichfork); <------>if (error) <------><------>return error; <------>node = bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>btree = nodehdr.btree; <------>btree[0].hashval = cpu_to_be32(blk1->hashval); <------>btree[0].before = cpu_to_be32(blk1->blkno); <------>btree[1].hashval = cpu_to_be32(blk2->hashval); <------>btree[1].before = cpu_to_be32(blk2->blkno); <------>nodehdr.count = 2; <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node, &nodehdr); #ifdef DEBUG <------>if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) || <------> oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) { <------><------>ASSERT(blk1->blkno >= args->geo->leafblk && <------><------> blk1->blkno < args->geo->freeblk); <------><------>ASSERT(blk2->blkno >= args->geo->leafblk && <------><------> blk2->blkno < args->geo->freeblk); <------>} #endif <------>/* Header is already logged by xfs_da_node_create */ <------>xfs_trans_log_buf(tp, bp, <------><------>XFS_DA_LOGRANGE(node, btree, sizeof(xfs_da_node_entry_t) * 2)); <------>return 0; } /* * Split the node, rebalance, then add the new entry. */ STATIC int /* error */ xfs_da3_node_split( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *oldblk, <------>struct xfs_da_state_blk *newblk, <------>struct xfs_da_state_blk *addblk, <------>int treelevel, <------>int *result) { <------>struct xfs_da_intnode *node; <------>struct xfs_da3_icnode_hdr nodehdr; <------>xfs_dablk_t blkno; <------>int newcount; <------>int error; <------>int useextra; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_split(state->args); <------>node = oldblk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>/* <------> * With V2 dirs the extra block is data or freespace. <------> */ <------>useextra = state->extravalid && state->args->whichfork == XFS_ATTR_FORK; <------>newcount = 1 + useextra; <------>/* <------> * Do we have to split the node? <------> */ <------>if (nodehdr.count + newcount > state->args->geo->node_ents) { <------><------>/* <------><------> * Allocate a new node, add to the doubly linked chain of <------><------> * nodes, then move some of our excess entries into it. <------><------> */ <------><------>error = xfs_da_grow_inode(state->args, &blkno); <------><------>if (error) <------><------><------>return error; /* GROT: dir is inconsistent */ <------><------>error = xfs_da3_node_create(state->args, blkno, treelevel, <------><------><------><------><------> &newblk->bp, state->args->whichfork); <------><------>if (error) <------><------><------>return error; /* GROT: dir is inconsistent */ <------><------>newblk->blkno = blkno; <------><------>newblk->magic = XFS_DA_NODE_MAGIC; <------><------>xfs_da3_node_rebalance(state, oldblk, newblk); <------><------>error = xfs_da3_blk_link(state, oldblk, newblk); <------><------>if (error) <------><------><------>return error; <------><------>*result = 1; <------>} else { <------><------>*result = 0; <------>} <------>/* <------> * Insert the new entry(s) into the correct block <------> * (updating last hashval in the process). <------> * <------> * xfs_da3_node_add() inserts BEFORE the given index, <------> * and as a result of using node_lookup_int() we always <------> * point to a valid entry (not after one), but a split <------> * operation always results in a new block whose hashvals <------> * FOLLOW the current block. <------> * <------> * If we had double-split op below us, then add the extra block too. <------> */ <------>node = oldblk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>if (oldblk->index <= nodehdr.count) { <------><------>oldblk->index++; <------><------>xfs_da3_node_add(state, oldblk, addblk); <------><------>if (useextra) { <------><------><------>if (state->extraafter) <------><------><------><------>oldblk->index++; <------><------><------>xfs_da3_node_add(state, oldblk, &state->extrablk); <------><------><------>state->extravalid = 0; <------><------>} <------>} else { <------><------>newblk->index++; <------><------>xfs_da3_node_add(state, newblk, addblk); <------><------>if (useextra) { <------><------><------>if (state->extraafter) <------><------><------><------>newblk->index++; <------><------><------>xfs_da3_node_add(state, newblk, &state->extrablk); <------><------><------>state->extravalid = 0; <------><------>} <------>} <------>return 0; } /* * Balance the btree elements between two intermediate nodes, * usually one full and one empty. * * NOTE: if blk2 is empty, then it will get the upper half of blk1. */ STATIC void xfs_da3_node_rebalance( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *blk1, <------>struct xfs_da_state_blk *blk2) { <------>struct xfs_da_intnode *node1; <------>struct xfs_da_intnode *node2; <------>struct xfs_da_intnode *tmpnode; <------>struct xfs_da_node_entry *btree1; <------>struct xfs_da_node_entry *btree2; <------>struct xfs_da_node_entry *btree_s; <------>struct xfs_da_node_entry *btree_d; <------>struct xfs_da3_icnode_hdr nodehdr1; <------>struct xfs_da3_icnode_hdr nodehdr2; <------>struct xfs_trans *tp; <------>int count; <------>int tmp; <------>int swap = 0; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_rebalance(state->args); <------>node1 = blk1->bp->b_addr; <------>node2 = blk2->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr1, node1); <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr2, node2); <------>btree1 = nodehdr1.btree; <------>btree2 = nodehdr2.btree; <------>/* <------> * Figure out how many entries need to move, and in which direction. <------> * Swap the nodes around if that makes it simpler. <------> */ <------>if (nodehdr1.count > 0 && nodehdr2.count > 0 && <------> ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) || <------> (be32_to_cpu(btree2[nodehdr2.count - 1].hashval) < <------><------><------>be32_to_cpu(btree1[nodehdr1.count - 1].hashval)))) { <------><------>tmpnode = node1; <------><------>node1 = node2; <------><------>node2 = tmpnode; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr1, node1); <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr2, node2); <------><------>btree1 = nodehdr1.btree; <------><------>btree2 = nodehdr2.btree; <------><------>swap = 1; <------>} <------>count = (nodehdr1.count - nodehdr2.count) / 2; <------>if (count == 0) <------><------>return; <------>tp = state->args->trans; <------>/* <------> * Two cases: high-to-low and low-to-high. <------> */ <------>if (count > 0) { <------><------>/* <------><------> * Move elements in node2 up to make a hole. <------><------> */ <------><------>tmp = nodehdr2.count; <------><------>if (tmp > 0) { <------><------><------>tmp *= (uint)sizeof(xfs_da_node_entry_t); <------><------><------>btree_s = &btree2[0]; <------><------><------>btree_d = &btree2[count]; <------><------><------>memmove(btree_d, btree_s, tmp); <------><------>} <------><------>/* <------><------> * Move the req'd B-tree elements from high in node1 to <------><------> * low in node2. <------><------> */ <------><------>nodehdr2.count += count; <------><------>tmp = count * (uint)sizeof(xfs_da_node_entry_t); <------><------>btree_s = &btree1[nodehdr1.count - count]; <------><------>btree_d = &btree2[0]; <------><------>memcpy(btree_d, btree_s, tmp); <------><------>nodehdr1.count -= count; <------>} else { <------><------>/* <------><------> * Move the req'd B-tree elements from low in node2 to <------><------> * high in node1. <------><------> */ <------><------>count = -count; <------><------>tmp = count * (uint)sizeof(xfs_da_node_entry_t); <------><------>btree_s = &btree2[0]; <------><------>btree_d = &btree1[nodehdr1.count]; <------><------>memcpy(btree_d, btree_s, tmp); <------><------>nodehdr1.count += count; <------><------>xfs_trans_log_buf(tp, blk1->bp, <------><------><------>XFS_DA_LOGRANGE(node1, btree_d, tmp)); <------><------>/* <------><------> * Move elements in node2 down to fill the hole. <------><------> */ <------><------>tmp = nodehdr2.count - count; <------><------>tmp *= (uint)sizeof(xfs_da_node_entry_t); <------><------>btree_s = &btree2[count]; <------><------>btree_d = &btree2[0]; <------><------>memmove(btree_d, btree_s, tmp); <------><------>nodehdr2.count -= count; <------>} <------>/* <------> * Log header of node 1 and all current bits of node 2. <------> */ <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node1, &nodehdr1); <------>xfs_trans_log_buf(tp, blk1->bp, <------><------>XFS_DA_LOGRANGE(node1, &node1->hdr, <------><------><------><------>state->args->geo->node_hdr_size)); <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node2, &nodehdr2); <------>xfs_trans_log_buf(tp, blk2->bp, <------><------>XFS_DA_LOGRANGE(node2, &node2->hdr, <------><------><------><------>state->args->geo->node_hdr_size + <------><------><------><------>(sizeof(btree2[0]) * nodehdr2.count))); <------>/* <------> * Record the last hashval from each block for upward propagation. <------> * (note: don't use the swapped node pointers) <------> */ <------>if (swap) { <------><------>node1 = blk1->bp->b_addr; <------><------>node2 = blk2->bp->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr1, node1); <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr2, node2); <------><------>btree1 = nodehdr1.btree; <------><------>btree2 = nodehdr2.btree; <------>} <------>blk1->hashval = be32_to_cpu(btree1[nodehdr1.count - 1].hashval); <------>blk2->hashval = be32_to_cpu(btree2[nodehdr2.count - 1].hashval); <------>/* <------> * Adjust the expected index for insertion. <------> */ <------>if (blk1->index >= nodehdr1.count) { <------><------>blk2->index = blk1->index - nodehdr1.count; <------><------>blk1->index = nodehdr1.count + 1; /* make it invalid */ <------>} } /* * Add a new entry to an intermediate node. */ STATIC void xfs_da3_node_add( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *oldblk, <------>struct xfs_da_state_blk *newblk) { <------>struct xfs_da_intnode *node; <------>struct xfs_da3_icnode_hdr nodehdr; <------>struct xfs_da_node_entry *btree; <------>int tmp; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_add(state->args); <------>node = oldblk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>btree = nodehdr.btree; <------>ASSERT(oldblk->index >= 0 && oldblk->index <= nodehdr.count); <------>ASSERT(newblk->blkno != 0); <------>if (state->args->whichfork == XFS_DATA_FORK) <------><------>ASSERT(newblk->blkno >= state->args->geo->leafblk && <------><------> newblk->blkno < state->args->geo->freeblk); <------>/* <------> * We may need to make some room before we insert the new node. <------> */ <------>tmp = 0; <------>if (oldblk->index < nodehdr.count) { <------><------>tmp = (nodehdr.count - oldblk->index) * (uint)sizeof(*btree); <------><------>memmove(&btree[oldblk->index + 1], &btree[oldblk->index], tmp); <------>} <------>btree[oldblk->index].hashval = cpu_to_be32(newblk->hashval); <------>btree[oldblk->index].before = cpu_to_be32(newblk->blkno); <------>xfs_trans_log_buf(state->args->trans, oldblk->bp, <------><------>XFS_DA_LOGRANGE(node, &btree[oldblk->index], <------><------><------><------>tmp + sizeof(*btree))); <------>nodehdr.count += 1; <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node, &nodehdr); <------>xfs_trans_log_buf(state->args->trans, oldblk->bp, <------><------>XFS_DA_LOGRANGE(node, &node->hdr, <------><------><------><------>state->args->geo->node_hdr_size)); <------>/* <------> * Copy the last hash value from the oldblk to propagate upwards. <------> */ <------>oldblk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval); } /*======================================================================== * Routines used for shrinking the Btree. *========================================================================*/ /* * Deallocate an empty leaf node, remove it from its parent, * possibly deallocating that block, etc... */ int xfs_da3_join( <------>struct xfs_da_state *state) { <------>struct xfs_da_state_blk *drop_blk; <------>struct xfs_da_state_blk *save_blk; <------>int action = 0; <------>int error; <------>trace_xfs_da_join(state->args); <------>drop_blk = &state->path.blk[ state->path.active-1 ]; <------>save_blk = &state->altpath.blk[ state->path.active-1 ]; <------>ASSERT(state->path.blk[0].magic == XFS_DA_NODE_MAGIC); <------>ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC || <------> drop_blk->magic == XFS_DIR2_LEAFN_MAGIC); <------>/* <------> * Walk back up the tree joining/deallocating as necessary. <------> * When we stop dropping blocks, break out. <------> */ <------>for ( ; state->path.active >= 2; drop_blk--, save_blk--, <------><------> state->path.active--) { <------><------>/* <------><------> * See if we can combine the block with a neighbor. <------><------> * (action == 0) => no options, just leave <------><------> * (action == 1) => coalesce, then unlink <------><------> * (action == 2) => block empty, unlink it <------><------> */ <------><------>switch (drop_blk->magic) { <------><------>case XFS_ATTR_LEAF_MAGIC: <------><------><------>error = xfs_attr3_leaf_toosmall(state, &action); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>if (action == 0) <------><------><------><------>return 0; <------><------><------>xfs_attr3_leaf_unbalance(state, drop_blk, save_blk); <------><------><------>break; <------><------>case XFS_DIR2_LEAFN_MAGIC: <------><------><------>error = xfs_dir2_leafn_toosmall(state, &action); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>if (action == 0) <------><------><------><------>return 0; <------><------><------>xfs_dir2_leafn_unbalance(state, drop_blk, save_blk); <------><------><------>break; <------><------>case XFS_DA_NODE_MAGIC: <------><------><------>/* <------><------><------> * Remove the offending node, fixup hashvals, <------><------><------> * check for a toosmall neighbor. <------><------><------> */ <------><------><------>xfs_da3_node_remove(state, drop_blk); <------><------><------>xfs_da3_fixhashpath(state, &state->path); <------><------><------>error = xfs_da3_node_toosmall(state, &action); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>if (action == 0) <------><------><------><------>return 0; <------><------><------>xfs_da3_node_unbalance(state, drop_blk, save_blk); <------><------><------>break; <------><------>} <------><------>xfs_da3_fixhashpath(state, &state->altpath); <------><------>error = xfs_da3_blk_unlink(state, drop_blk, save_blk); <------><------>xfs_da_state_kill_altpath(state); <------><------>if (error) <------><------><------>return error; <------><------>error = xfs_da_shrink_inode(state->args, drop_blk->blkno, <------><------><------><------><------><------><------> drop_blk->bp); <------><------>drop_blk->bp = NULL; <------><------>if (error) <------><------><------>return error; <------>} <------>/* <------> * We joined all the way to the top. If it turns out that <------> * we only have one entry in the root, make the child block <------> * the new root. <------> */ <------>xfs_da3_node_remove(state, drop_blk); <------>xfs_da3_fixhashpath(state, &state->path); <------>error = xfs_da3_root_join(state, &state->path.blk[0]); <------>return error; } #ifdef DEBUG static void xfs_da_blkinfo_onlychild_validate(struct xfs_da_blkinfo *blkinfo, __u16 level) { <------>__be16 magic = blkinfo->magic; <------>if (level == 1) { <------><------>ASSERT(magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) || <------><------> magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) || <------><------> magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) || <------><------> magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)); <------>} else { <------><------>ASSERT(magic == cpu_to_be16(XFS_DA_NODE_MAGIC) || <------><------> magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)); <------>} <------>ASSERT(!blkinfo->forw); <------>ASSERT(!blkinfo->back); } #else /* !DEBUG */ #define xfs_da_blkinfo_onlychild_validate(blkinfo, level) #endif /* !DEBUG */ /* * We have only one entry in the root. Copy the only remaining child of * the old root to block 0 as the new root node. */ STATIC int xfs_da3_root_join( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *root_blk) { <------>struct xfs_da_intnode *oldroot; <------>struct xfs_da_args *args; <------>xfs_dablk_t child; <------>struct xfs_buf *bp; <------>struct xfs_da3_icnode_hdr oldroothdr; <------>int error; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_root_join(state->args); <------>ASSERT(root_blk->magic == XFS_DA_NODE_MAGIC); <------>args = state->args; <------>oldroot = root_blk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &oldroothdr, oldroot); <------>ASSERT(oldroothdr.forw == 0); <------>ASSERT(oldroothdr.back == 0); <------>/* <------> * If the root has more than one child, then don't do anything. <------> */ <------>if (oldroothdr.count > 1) <------><------>return 0; <------>/* <------> * Read in the (only) child block, then copy those bytes into <------> * the root block's buffer and free the original child block. <------> */ <------>child = be32_to_cpu(oldroothdr.btree[0].before); <------>ASSERT(child != 0); <------>error = xfs_da3_node_read(args->trans, dp, child, &bp, args->whichfork); <------>if (error) <------><------>return error; <------>xfs_da_blkinfo_onlychild_validate(bp->b_addr, oldroothdr.level); <------>/* <------> * This could be copying a leaf back into the root block in the case of <------> * there only being a single leaf block left in the tree. Hence we have <------> * to update the b_ops pointer as well to match the buffer type change <------> * that could occur. For dir3 blocks we also need to update the block <------> * number in the buffer header. <------> */ <------>memcpy(root_blk->bp->b_addr, bp->b_addr, args->geo->blksize); <------>root_blk->bp->b_ops = bp->b_ops; <------>xfs_trans_buf_copy_type(root_blk->bp, bp); <------>if (oldroothdr.magic == XFS_DA3_NODE_MAGIC) { <------><------>struct xfs_da3_blkinfo *da3 = root_blk->bp->b_addr; <------><------>da3->blkno = cpu_to_be64(root_blk->bp->b_bn); <------>} <------>xfs_trans_log_buf(args->trans, root_blk->bp, 0, <------><------><------> args->geo->blksize - 1); <------>error = xfs_da_shrink_inode(args, child, bp); <------>return error; } /* * Check a node block and its neighbors to see if the block should be * collapsed into one or the other neighbor. Always keep the block * with the smaller block number. * If the current block is over 50% full, don't try to join it, return 0. * If the block is empty, fill in the state structure and return 2. * If it can be collapsed, fill in the state structure and return 1. * If nothing can be done, return 0. */ STATIC int xfs_da3_node_toosmall( <------>struct xfs_da_state *state, <------>int *action) { <------>struct xfs_da_intnode *node; <------>struct xfs_da_state_blk *blk; <------>struct xfs_da_blkinfo *info; <------>xfs_dablk_t blkno; <------>struct xfs_buf *bp; <------>struct xfs_da3_icnode_hdr nodehdr; <------>int count; <------>int forward; <------>int error; <------>int retval; <------>int i; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_toosmall(state->args); <------>/* <------> * Check for the degenerate case of the block being over 50% full. <------> * If so, it's not worth even looking to see if we might be able <------> * to coalesce with a sibling. <------> */ <------>blk = &state->path.blk[ state->path.active-1 ]; <------>info = blk->bp->b_addr; <------>node = (xfs_da_intnode_t *)info; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>if (nodehdr.count > (state->args->geo->node_ents >> 1)) { <------><------>*action = 0; /* blk over 50%, don't try to join */ <------><------>return 0; /* blk over 50%, don't try to join */ <------>} <------>/* <------> * Check for the degenerate case of the block being empty. <------> * If the block is empty, we'll simply delete it, no need to <------> * coalesce it with a sibling block. We choose (arbitrarily) <------> * to merge with the forward block unless it is NULL. <------> */ <------>if (nodehdr.count == 0) { <------><------>/* <------><------> * Make altpath point to the block we want to keep and <------><------> * path point to the block we want to drop (this one). <------><------> */ <------><------>forward = (info->forw != 0); <------><------>memcpy(&state->altpath, &state->path, sizeof(state->path)); <------><------>error = xfs_da3_path_shift(state, &state->altpath, forward, <------><------><------><------><------><------> 0, &retval); <------><------>if (error) <------><------><------>return error; <------><------>if (retval) { <------><------><------>*action = 0; <------><------>} else { <------><------><------>*action = 2; <------><------>} <------><------>return 0; <------>} <------>/* <------> * Examine each sibling block to see if we can coalesce with <------> * at least 25% free space to spare. We need to figure out <------> * whether to merge with the forward or the backward block. <------> * We prefer coalescing with the lower numbered sibling so as <------> * to shrink a directory over time. <------> */ <------>count = state->args->geo->node_ents; <------>count -= state->args->geo->node_ents >> 2; <------>count -= nodehdr.count; <------>/* start with smaller blk num */ <------>forward = nodehdr.forw < nodehdr.back; <------>for (i = 0; i < 2; forward = !forward, i++) { <------><------>struct xfs_da3_icnode_hdr thdr; <------><------>if (forward) <------><------><------>blkno = nodehdr.forw; <------><------>else <------><------><------>blkno = nodehdr.back; <------><------>if (blkno == 0) <------><------><------>continue; <------><------>error = xfs_da3_node_read(state->args->trans, dp, blkno, &bp, <------><------><------><------>state->args->whichfork); <------><------>if (error) <------><------><------>return error; <------><------>node = bp->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &thdr, node); <------><------>xfs_trans_brelse(state->args->trans, bp); <------><------>if (count - thdr.count >= 0) <------><------><------>break; /* fits with at least 25% to spare */ <------>} <------>if (i >= 2) { <------><------>*action = 0; <------><------>return 0; <------>} <------>/* <------> * Make altpath point to the block we want to keep (the lower <------> * numbered block) and path point to the block we want to drop. <------> */ <------>memcpy(&state->altpath, &state->path, sizeof(state->path)); <------>if (blkno < blk->blkno) { <------><------>error = xfs_da3_path_shift(state, &state->altpath, forward, <------><------><------><------><------><------> 0, &retval); <------>} else { <------><------>error = xfs_da3_path_shift(state, &state->path, forward, <------><------><------><------><------><------> 0, &retval); <------>} <------>if (error) <------><------>return error; <------>if (retval) { <------><------>*action = 0; <------><------>return 0; <------>} <------>*action = 1; <------>return 0; } /* * Pick up the last hashvalue from an intermediate node. */ STATIC uint xfs_da3_node_lasthash( <------>struct xfs_inode *dp, <------>struct xfs_buf *bp, <------>int *count) { <------>struct xfs_da3_icnode_hdr nodehdr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, bp->b_addr); <------>if (count) <------><------>*count = nodehdr.count; <------>if (!nodehdr.count) <------><------>return 0; <------>return be32_to_cpu(nodehdr.btree[nodehdr.count - 1].hashval); } /* * Walk back up the tree adjusting hash values as necessary, * when we stop making changes, return. */ void xfs_da3_fixhashpath( <------>struct xfs_da_state *state, <------>struct xfs_da_state_path *path) { <------>struct xfs_da_state_blk *blk; <------>struct xfs_da_intnode *node; <------>struct xfs_da_node_entry *btree; <------>xfs_dahash_t lasthash=0; <------>int level; <------>int count; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_fixhashpath(state->args); <------>level = path->active-1; <------>blk = &path->blk[ level ]; <------>switch (blk->magic) { <------>case XFS_ATTR_LEAF_MAGIC: <------><------>lasthash = xfs_attr_leaf_lasthash(blk->bp, &count); <------><------>if (count == 0) <------><------><------>return; <------><------>break; <------>case XFS_DIR2_LEAFN_MAGIC: <------><------>lasthash = xfs_dir2_leaf_lasthash(dp, blk->bp, &count); <------><------>if (count == 0) <------><------><------>return; <------><------>break; <------>case XFS_DA_NODE_MAGIC: <------><------>lasthash = xfs_da3_node_lasthash(dp, blk->bp, &count); <------><------>if (count == 0) <------><------><------>return; <------><------>break; <------>} <------>for (blk--, level--; level >= 0; blk--, level--) { <------><------>struct xfs_da3_icnode_hdr nodehdr; <------><------>node = blk->bp->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------><------>btree = nodehdr.btree; <------><------>if (be32_to_cpu(btree[blk->index].hashval) == lasthash) <------><------><------>break; <------><------>blk->hashval = lasthash; <------><------>btree[blk->index].hashval = cpu_to_be32(lasthash); <------><------>xfs_trans_log_buf(state->args->trans, blk->bp, <------><------><------><------> XFS_DA_LOGRANGE(node, &btree[blk->index], <------><------><------><------><------><------> sizeof(*btree))); <------><------>lasthash = be32_to_cpu(btree[nodehdr.count - 1].hashval); <------>} } /* * Remove an entry from an intermediate node. */ STATIC void xfs_da3_node_remove( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *drop_blk) { <------>struct xfs_da_intnode *node; <------>struct xfs_da3_icnode_hdr nodehdr; <------>struct xfs_da_node_entry *btree; <------>int index; <------>int tmp; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_remove(state->args); <------>node = drop_blk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------>ASSERT(drop_blk->index < nodehdr.count); <------>ASSERT(drop_blk->index >= 0); <------>/* <------> * Copy over the offending entry, or just zero it out. <------> */ <------>index = drop_blk->index; <------>btree = nodehdr.btree; <------>if (index < nodehdr.count - 1) { <------><------>tmp = nodehdr.count - index - 1; <------><------>tmp *= (uint)sizeof(xfs_da_node_entry_t); <------><------>memmove(&btree[index], &btree[index + 1], tmp); <------><------>xfs_trans_log_buf(state->args->trans, drop_blk->bp, <------><------> XFS_DA_LOGRANGE(node, &btree[index], tmp)); <------><------>index = nodehdr.count - 1; <------>} <------>memset(&btree[index], 0, sizeof(xfs_da_node_entry_t)); <------>xfs_trans_log_buf(state->args->trans, drop_blk->bp, <------> XFS_DA_LOGRANGE(node, &btree[index], sizeof(btree[index]))); <------>nodehdr.count -= 1; <------>xfs_da3_node_hdr_to_disk(dp->i_mount, node, &nodehdr); <------>xfs_trans_log_buf(state->args->trans, drop_blk->bp, <------> XFS_DA_LOGRANGE(node, &node->hdr, state->args->geo->node_hdr_size)); <------>/* <------> * Copy the last hash value from the block to propagate upwards. <------> */ <------>drop_blk->hashval = be32_to_cpu(btree[index - 1].hashval); } /* * Unbalance the elements between two intermediate nodes, * move all Btree elements from one node into another. */ STATIC void xfs_da3_node_unbalance( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *drop_blk, <------>struct xfs_da_state_blk *save_blk) { <------>struct xfs_da_intnode *drop_node; <------>struct xfs_da_intnode *save_node; <------>struct xfs_da_node_entry *drop_btree; <------>struct xfs_da_node_entry *save_btree; <------>struct xfs_da3_icnode_hdr drop_hdr; <------>struct xfs_da3_icnode_hdr save_hdr; <------>struct xfs_trans *tp; <------>int sindex; <------>int tmp; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_node_unbalance(state->args); <------>drop_node = drop_blk->bp->b_addr; <------>save_node = save_blk->bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &drop_hdr, drop_node); <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &save_hdr, save_node); <------>drop_btree = drop_hdr.btree; <------>save_btree = save_hdr.btree; <------>tp = state->args->trans; <------>/* <------> * If the dying block has lower hashvals, then move all the <------> * elements in the remaining block up to make a hole. <------> */ <------>if ((be32_to_cpu(drop_btree[0].hashval) < <------><------><------>be32_to_cpu(save_btree[0].hashval)) || <------> (be32_to_cpu(drop_btree[drop_hdr.count - 1].hashval) < <------><------><------>be32_to_cpu(save_btree[save_hdr.count - 1].hashval))) { <------><------>/* XXX: check this - is memmove dst correct? */ <------><------>tmp = save_hdr.count * sizeof(xfs_da_node_entry_t); <------><------>memmove(&save_btree[drop_hdr.count], &save_btree[0], tmp); <------><------>sindex = 0; <------><------>xfs_trans_log_buf(tp, save_blk->bp, <------><------><------>XFS_DA_LOGRANGE(save_node, &save_btree[0], <------><------><------><------>(save_hdr.count + drop_hdr.count) * <------><------><------><------><------><------>sizeof(xfs_da_node_entry_t))); <------>} else { <------><------>sindex = save_hdr.count; <------><------>xfs_trans_log_buf(tp, save_blk->bp, <------><------><------>XFS_DA_LOGRANGE(save_node, &save_btree[sindex], <------><------><------><------>drop_hdr.count * sizeof(xfs_da_node_entry_t))); <------>} <------>/* <------> * Move all the B-tree elements from drop_blk to save_blk. <------> */ <------>tmp = drop_hdr.count * (uint)sizeof(xfs_da_node_entry_t); <------>memcpy(&save_btree[sindex], &drop_btree[0], tmp); <------>save_hdr.count += drop_hdr.count; <------>xfs_da3_node_hdr_to_disk(dp->i_mount, save_node, &save_hdr); <------>xfs_trans_log_buf(tp, save_blk->bp, <------><------>XFS_DA_LOGRANGE(save_node, &save_node->hdr, <------><------><------><------>state->args->geo->node_hdr_size)); <------>/* <------> * Save the last hashval in the remaining block for upward propagation. <------> */ <------>save_blk->hashval = be32_to_cpu(save_btree[save_hdr.count - 1].hashval); } /*======================================================================== * Routines used for finding things in the Btree. *========================================================================*/ /* * Walk down the Btree looking for a particular filename, filling * in the state structure as we go. * * We will set the state structure to point to each of the elements * in each of the nodes where either the hashval is or should be. * * We support duplicate hashval's so for each entry in the current * node that could contain the desired hashval, descend. This is a * pruned depth-first tree search. */ int /* error */ xfs_da3_node_lookup_int( <------>struct xfs_da_state *state, <------>int *result) { <------>struct xfs_da_state_blk *blk; <------>struct xfs_da_blkinfo *curr; <------>struct xfs_da_intnode *node; <------>struct xfs_da_node_entry *btree; <------>struct xfs_da3_icnode_hdr nodehdr; <------>struct xfs_da_args *args; <------>xfs_dablk_t blkno; <------>xfs_dahash_t hashval; <------>xfs_dahash_t btreehashval; <------>int probe; <------>int span; <------>int max; <------>int error; <------>int retval; <------>unsigned int expected_level = 0; <------>uint16_t magic; <------>struct xfs_inode *dp = state->args->dp; <------>args = state->args; <------>/* <------> * Descend thru the B-tree searching each level for the right <------> * node to use, until the right hashval is found. <------> */ <------>blkno = args->geo->leafblk; <------>for (blk = &state->path.blk[0], state->path.active = 1; <------><------><------> state->path.active <= XFS_DA_NODE_MAXDEPTH; <------><------><------> blk++, state->path.active++) { <------><------>/* <------><------> * Read the next node down in the tree. <------><------> */ <------><------>blk->blkno = blkno; <------><------>error = xfs_da3_node_read(args->trans, args->dp, blkno, <------><------><------><------><------>&blk->bp, args->whichfork); <------><------>if (error) { <------><------><------>blk->blkno = 0; <------><------><------>state->path.active--; <------><------><------>return error; <------><------>} <------><------>curr = blk->bp->b_addr; <------><------>magic = be16_to_cpu(curr->magic); <------><------>if (magic == XFS_ATTR_LEAF_MAGIC || <------><------> magic == XFS_ATTR3_LEAF_MAGIC) { <------><------><------>blk->magic = XFS_ATTR_LEAF_MAGIC; <------><------><------>blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL); <------><------><------>break; <------><------>} <------><------>if (magic == XFS_DIR2_LEAFN_MAGIC || <------><------> magic == XFS_DIR3_LEAFN_MAGIC) { <------><------><------>blk->magic = XFS_DIR2_LEAFN_MAGIC; <------><------><------>blk->hashval = xfs_dir2_leaf_lasthash(args->dp, <------><------><------><------><------><------><------> blk->bp, NULL); <------><------><------>break; <------><------>} <------><------>if (magic != XFS_DA_NODE_MAGIC && magic != XFS_DA3_NODE_MAGIC) { <------><------><------>xfs_buf_mark_corrupt(blk->bp); <------><------><------>return -EFSCORRUPTED; <------><------>} <------><------>blk->magic = XFS_DA_NODE_MAGIC; <------><------>/* <------><------> * Search an intermediate node for a match. <------><------> */ <------><------>node = blk->bp->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, node); <------><------>btree = nodehdr.btree; <------><------>/* Tree taller than we can handle; bail out! */ <------><------>if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) { <------><------><------>xfs_buf_mark_corrupt(blk->bp); <------><------><------>return -EFSCORRUPTED; <------><------>} <------><------>/* Check the level from the root. */ <------><------>if (blkno == args->geo->leafblk) <------><------><------>expected_level = nodehdr.level - 1; <------><------>else if (expected_level != nodehdr.level) { <------><------><------>xfs_buf_mark_corrupt(blk->bp); <------><------><------>return -EFSCORRUPTED; <------><------>} else <------><------><------>expected_level--; <------><------>max = nodehdr.count; <------><------>blk->hashval = be32_to_cpu(btree[max - 1].hashval); <------><------>/* <------><------> * Binary search. (note: small blocks will skip loop) <------><------> */ <------><------>probe = span = max / 2; <------><------>hashval = args->hashval; <------><------>while (span > 4) { <------><------><------>span /= 2; <------><------><------>btreehashval = be32_to_cpu(btree[probe].hashval); <------><------><------>if (btreehashval < hashval) <------><------><------><------>probe += span; <------><------><------>else if (btreehashval > hashval) <------><------><------><------>probe -= span; <------><------><------>else <------><------><------><------>break; <------><------>} <------><------>ASSERT((probe >= 0) && (probe < max)); <------><------>ASSERT((span <= 4) || <------><------><------>(be32_to_cpu(btree[probe].hashval) == hashval)); <------><------>/* <------><------> * Since we may have duplicate hashval's, find the first <------><------> * matching hashval in the node. <------><------> */ <------><------>while (probe > 0 && <------><------> be32_to_cpu(btree[probe].hashval) >= hashval) { <------><------><------>probe--; <------><------>} <------><------>while (probe < max && <------><------> be32_to_cpu(btree[probe].hashval) < hashval) { <------><------><------>probe++; <------><------>} <------><------>/* <------><------> * Pick the right block to descend on. <------><------> */ <------><------>if (probe == max) { <------><------><------>blk->index = max - 1; <------><------><------>blkno = be32_to_cpu(btree[max - 1].before); <------><------>} else { <------><------><------>blk->index = probe; <------><------><------>blkno = be32_to_cpu(btree[probe].before); <------><------>} <------><------>/* We can't point back to the root. */ <------><------>if (XFS_IS_CORRUPT(dp->i_mount, blkno == args->geo->leafblk)) <------><------><------>return -EFSCORRUPTED; <------>} <------>if (XFS_IS_CORRUPT(dp->i_mount, expected_level != 0)) <------><------>return -EFSCORRUPTED; <------>/* <------> * A leaf block that ends in the hashval that we are interested in <------> * (final hashval == search hashval) means that the next block may <------> * contain more entries with the same hashval, shift upward to the <------> * next leaf and keep searching. <------> */ <------>for (;;) { <------><------>if (blk->magic == XFS_DIR2_LEAFN_MAGIC) { <------><------><------>retval = xfs_dir2_leafn_lookup_int(blk->bp, args, <------><------><------><------><------><------><------>&blk->index, state); <------><------>} else if (blk->magic == XFS_ATTR_LEAF_MAGIC) { <------><------><------>retval = xfs_attr3_leaf_lookup_int(blk->bp, args); <------><------><------>blk->index = args->index; <------><------><------>args->blkno = blk->blkno; <------><------>} else { <------><------><------>ASSERT(0); <------><------><------>return -EFSCORRUPTED; <------><------>} <------><------>if (((retval == -ENOENT) || (retval == -ENOATTR)) && <------><------> (blk->hashval == args->hashval)) { <------><------><------>error = xfs_da3_path_shift(state, &state->path, 1, 1, <------><------><------><------><------><------><------> &retval); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>if (retval == 0) { <------><------><------><------>continue; <------><------><------>} else if (blk->magic == XFS_ATTR_LEAF_MAGIC) { <------><------><------><------>/* path_shift() gives ENOENT */ <------><------><------><------>retval = -ENOATTR; <------><------><------>} <------><------>} <------><------>break; <------>} <------>*result = retval; <------>return 0; } /*======================================================================== * Utility routines. *========================================================================*/ /* * Compare two intermediate nodes for "order". */ STATIC int xfs_da3_node_order( <------>struct xfs_inode *dp, <------>struct xfs_buf *node1_bp, <------>struct xfs_buf *node2_bp) { <------>struct xfs_da_intnode *node1; <------>struct xfs_da_intnode *node2; <------>struct xfs_da_node_entry *btree1; <------>struct xfs_da_node_entry *btree2; <------>struct xfs_da3_icnode_hdr node1hdr; <------>struct xfs_da3_icnode_hdr node2hdr; <------>node1 = node1_bp->b_addr; <------>node2 = node2_bp->b_addr; <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &node1hdr, node1); <------>xfs_da3_node_hdr_from_disk(dp->i_mount, &node2hdr, node2); <------>btree1 = node1hdr.btree; <------>btree2 = node2hdr.btree; <------>if (node1hdr.count > 0 && node2hdr.count > 0 && <------> ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) || <------> (be32_to_cpu(btree2[node2hdr.count - 1].hashval) < <------> be32_to_cpu(btree1[node1hdr.count - 1].hashval)))) { <------><------>return 1; <------>} <------>return 0; } /* * Link a new block into a doubly linked list of blocks (of whatever type). */ int /* error */ xfs_da3_blk_link( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *old_blk, <------>struct xfs_da_state_blk *new_blk) { <------>struct xfs_da_blkinfo *old_info; <------>struct xfs_da_blkinfo *new_info; <------>struct xfs_da_blkinfo *tmp_info; <------>struct xfs_da_args *args; <------>struct xfs_buf *bp; <------>int before = 0; <------>int error; <------>struct xfs_inode *dp = state->args->dp; <------>/* <------> * Set up environment. <------> */ <------>args = state->args; <------>ASSERT(args != NULL); <------>old_info = old_blk->bp->b_addr; <------>new_info = new_blk->bp->b_addr; <------>ASSERT(old_blk->magic == XFS_DA_NODE_MAGIC || <------> old_blk->magic == XFS_DIR2_LEAFN_MAGIC || <------> old_blk->magic == XFS_ATTR_LEAF_MAGIC); <------>switch (old_blk->magic) { <------>case XFS_ATTR_LEAF_MAGIC: <------><------>before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp); <------><------>break; <------>case XFS_DIR2_LEAFN_MAGIC: <------><------>before = xfs_dir2_leafn_order(dp, old_blk->bp, new_blk->bp); <------><------>break; <------>case XFS_DA_NODE_MAGIC: <------><------>before = xfs_da3_node_order(dp, old_blk->bp, new_blk->bp); <------><------>break; <------>} <------>/* <------> * Link blocks in appropriate order. <------> */ <------>if (before) { <------><------>/* <------><------> * Link new block in before existing block. <------><------> */ <------><------>trace_xfs_da_link_before(args); <------><------>new_info->forw = cpu_to_be32(old_blk->blkno); <------><------>new_info->back = old_info->back; <------><------>if (old_info->back) { <------><------><------>error = xfs_da3_node_read(args->trans, dp, <------><------><------><------><------><------>be32_to_cpu(old_info->back), <------><------><------><------><------><------>&bp, args->whichfork); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>ASSERT(bp != NULL); <------><------><------>tmp_info = bp->b_addr; <------><------><------>ASSERT(tmp_info->magic == old_info->magic); <------><------><------>ASSERT(be32_to_cpu(tmp_info->forw) == old_blk->blkno); <------><------><------>tmp_info->forw = cpu_to_be32(new_blk->blkno); <------><------><------>xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1); <------><------>} <------><------>old_info->back = cpu_to_be32(new_blk->blkno); <------>} else { <------><------>/* <------><------> * Link new block in after existing block. <------><------> */ <------><------>trace_xfs_da_link_after(args); <------><------>new_info->forw = old_info->forw; <------><------>new_info->back = cpu_to_be32(old_blk->blkno); <------><------>if (old_info->forw) { <------><------><------>error = xfs_da3_node_read(args->trans, dp, <------><------><------><------><------><------>be32_to_cpu(old_info->forw), <------><------><------><------><------><------>&bp, args->whichfork); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>ASSERT(bp != NULL); <------><------><------>tmp_info = bp->b_addr; <------><------><------>ASSERT(tmp_info->magic == old_info->magic); <------><------><------>ASSERT(be32_to_cpu(tmp_info->back) == old_blk->blkno); <------><------><------>tmp_info->back = cpu_to_be32(new_blk->blkno); <------><------><------>xfs_trans_log_buf(args->trans, bp, 0, sizeof(*tmp_info)-1); <------><------>} <------><------>old_info->forw = cpu_to_be32(new_blk->blkno); <------>} <------>xfs_trans_log_buf(args->trans, old_blk->bp, 0, sizeof(*tmp_info) - 1); <------>xfs_trans_log_buf(args->trans, new_blk->bp, 0, sizeof(*tmp_info) - 1); <------>return 0; } /* * Unlink a block from a doubly linked list of blocks. */ STATIC int /* error */ xfs_da3_blk_unlink( <------>struct xfs_da_state *state, <------>struct xfs_da_state_blk *drop_blk, <------>struct xfs_da_state_blk *save_blk) { <------>struct xfs_da_blkinfo *drop_info; <------>struct xfs_da_blkinfo *save_info; <------>struct xfs_da_blkinfo *tmp_info; <------>struct xfs_da_args *args; <------>struct xfs_buf *bp; <------>int error; <------>/* <------> * Set up environment. <------> */ <------>args = state->args; <------>ASSERT(args != NULL); <------>save_info = save_blk->bp->b_addr; <------>drop_info = drop_blk->bp->b_addr; <------>ASSERT(save_blk->magic == XFS_DA_NODE_MAGIC || <------> save_blk->magic == XFS_DIR2_LEAFN_MAGIC || <------> save_blk->magic == XFS_ATTR_LEAF_MAGIC); <------>ASSERT(save_blk->magic == drop_blk->magic); <------>ASSERT((be32_to_cpu(save_info->forw) == drop_blk->blkno) || <------> (be32_to_cpu(save_info->back) == drop_blk->blkno)); <------>ASSERT((be32_to_cpu(drop_info->forw) == save_blk->blkno) || <------> (be32_to_cpu(drop_info->back) == save_blk->blkno)); <------>/* <------> * Unlink the leaf block from the doubly linked chain of leaves. <------> */ <------>if (be32_to_cpu(save_info->back) == drop_blk->blkno) { <------><------>trace_xfs_da_unlink_back(args); <------><------>save_info->back = drop_info->back; <------><------>if (drop_info->back) { <------><------><------>error = xfs_da3_node_read(args->trans, args->dp, <------><------><------><------><------><------>be32_to_cpu(drop_info->back), <------><------><------><------><------><------>&bp, args->whichfork); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>ASSERT(bp != NULL); <------><------><------>tmp_info = bp->b_addr; <------><------><------>ASSERT(tmp_info->magic == save_info->magic); <------><------><------>ASSERT(be32_to_cpu(tmp_info->forw) == drop_blk->blkno); <------><------><------>tmp_info->forw = cpu_to_be32(save_blk->blkno); <------><------><------>xfs_trans_log_buf(args->trans, bp, 0, <------><------><------><------><------><------> sizeof(*tmp_info) - 1); <------><------>} <------>} else { <------><------>trace_xfs_da_unlink_forward(args); <------><------>save_info->forw = drop_info->forw; <------><------>if (drop_info->forw) { <------><------><------>error = xfs_da3_node_read(args->trans, args->dp, <------><------><------><------><------><------>be32_to_cpu(drop_info->forw), <------><------><------><------><------><------>&bp, args->whichfork); <------><------><------>if (error) <------><------><------><------>return error; <------><------><------>ASSERT(bp != NULL); <------><------><------>tmp_info = bp->b_addr; <------><------><------>ASSERT(tmp_info->magic == save_info->magic); <------><------><------>ASSERT(be32_to_cpu(tmp_info->back) == drop_blk->blkno); <------><------><------>tmp_info->back = cpu_to_be32(save_blk->blkno); <------><------><------>xfs_trans_log_buf(args->trans, bp, 0, <------><------><------><------><------><------> sizeof(*tmp_info) - 1); <------><------>} <------>} <------>xfs_trans_log_buf(args->trans, save_blk->bp, 0, sizeof(*save_info) - 1); <------>return 0; } /* * Move a path "forward" or "!forward" one block at the current level. * * This routine will adjust a "path" to point to the next block * "forward" (higher hashvalues) or "!forward" (lower hashvals) in the * Btree, including updating pointers to the intermediate nodes between * the new bottom and the root. */ int /* error */ xfs_da3_path_shift( <------>struct xfs_da_state *state, <------>struct xfs_da_state_path *path, <------>int forward, <------>int release, <------>int *result) { <------>struct xfs_da_state_blk *blk; <------>struct xfs_da_blkinfo *info; <------>struct xfs_da_args *args; <------>struct xfs_da_node_entry *btree; <------>struct xfs_da3_icnode_hdr nodehdr; <------>struct xfs_buf *bp; <------>xfs_dablk_t blkno = 0; <------>int level; <------>int error; <------>struct xfs_inode *dp = state->args->dp; <------>trace_xfs_da_path_shift(state->args); <------>/* <------> * Roll up the Btree looking for the first block where our <------> * current index is not at the edge of the block. Note that <------> * we skip the bottom layer because we want the sibling block. <------> */ <------>args = state->args; <------>ASSERT(args != NULL); <------>ASSERT(path != NULL); <------>ASSERT((path->active > 0) && (path->active < XFS_DA_NODE_MAXDEPTH)); <------>level = (path->active-1) - 1; /* skip bottom layer in path */ <------>for (; level >= 0; level--) { <------><------>blk = &path->blk[level]; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, <------><------><------><------><------> blk->bp->b_addr); <------><------>if (forward && (blk->index < nodehdr.count - 1)) { <------><------><------>blk->index++; <------><------><------>blkno = be32_to_cpu(nodehdr.btree[blk->index].before); <------><------><------>break; <------><------>} else if (!forward && (blk->index > 0)) { <------><------><------>blk->index--; <------><------><------>blkno = be32_to_cpu(nodehdr.btree[blk->index].before); <------><------><------>break; <------><------>} <------>} <------>if (level < 0) { <------><------>*result = -ENOENT; /* we're out of our tree */ <------><------>ASSERT(args->op_flags & XFS_DA_OP_OKNOENT); <------><------>return 0; <------>} <------>/* <------> * Roll down the edge of the subtree until we reach the <------> * same depth we were at originally. <------> */ <------>for (blk++, level++; level < path->active; blk++, level++) { <------><------>/* <------><------> * Read the next child block into a local buffer. <------><------> */ <------><------>error = xfs_da3_node_read(args->trans, dp, blkno, &bp, <------><------><------><------><------> args->whichfork); <------><------>if (error) <------><------><------>return error; <------><------>/* <------><------> * Release the old block (if it's dirty, the trans doesn't <------><------> * actually let go) and swap the local buffer into the path <------><------> * structure. This ensures failure of the above read doesn't set <------><------> * a NULL buffer in an active slot in the path. <------><------> */ <------><------>if (release) <------><------><------>xfs_trans_brelse(args->trans, blk->bp); <------><------>blk->blkno = blkno; <------><------>blk->bp = bp; <------><------>info = blk->bp->b_addr; <------><------>ASSERT(info->magic == cpu_to_be16(XFS_DA_NODE_MAGIC) || <------><------> info->magic == cpu_to_be16(XFS_DA3_NODE_MAGIC) || <------><------> info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) || <------><------> info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC) || <------><------> info->magic == cpu_to_be16(XFS_ATTR_LEAF_MAGIC) || <------><------> info->magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC)); <------><------>/* <------><------> * Note: we flatten the magic number to a single type so we <------><------> * don't have to compare against crc/non-crc types elsewhere. <------><------> */ <------><------>switch (be16_to_cpu(info->magic)) { <------><------>case XFS_DA_NODE_MAGIC: <------><------>case XFS_DA3_NODE_MAGIC: <------><------><------>blk->magic = XFS_DA_NODE_MAGIC; <------><------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &nodehdr, <------><------><------><------><------><------> bp->b_addr); <------><------><------>btree = nodehdr.btree; <------><------><------>blk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval); <------><------><------>if (forward) <------><------><------><------>blk->index = 0; <------><------><------>else <------><------><------><------>blk->index = nodehdr.count - 1; <------><------><------>blkno = be32_to_cpu(btree[blk->index].before); <------><------><------>break; <------><------>case XFS_ATTR_LEAF_MAGIC: <------><------>case XFS_ATTR3_LEAF_MAGIC: <------><------><------>blk->magic = XFS_ATTR_LEAF_MAGIC; <------><------><------>ASSERT(level == path->active-1); <------><------><------>blk->index = 0; <------><------><------>blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL); <------><------><------>break; <------><------>case XFS_DIR2_LEAFN_MAGIC: <------><------>case XFS_DIR3_LEAFN_MAGIC: <------><------><------>blk->magic = XFS_DIR2_LEAFN_MAGIC; <------><------><------>ASSERT(level == path->active-1); <------><------><------>blk->index = 0; <------><------><------>blk->hashval = xfs_dir2_leaf_lasthash(args->dp, <------><------><------><------><------><------><------> blk->bp, NULL); <------><------><------>break; <------><------>default: <------><------><------>ASSERT(0); <------><------><------>break; <------><------>} <------>} <------>*result = 0; <------>return 0; } /*======================================================================== * Utility routines. *========================================================================*/ /* * Implement a simple hash on a character string. * Rotate the hash value by 7 bits, then XOR each character in. * This is implemented with some source-level loop unrolling. */ xfs_dahash_t xfs_da_hashname(const uint8_t *name, int namelen) { <------>xfs_dahash_t hash; <------>/* <------> * Do four characters at a time as long as we can. <------> */ <------>for (hash = 0; namelen >= 4; namelen -= 4, name += 4) <------><------>hash = (name[0] << 21) ^ (name[1] << 14) ^ (name[2] << 7) ^ <------><------> (name[3] << 0) ^ rol32(hash, 7 * 4); <------>/* <------> * Now do the rest of the characters. <------> */ <------>switch (namelen) { <------>case 3: <------><------>return (name[0] << 14) ^ (name[1] << 7) ^ (name[2] << 0) ^ <------><------> rol32(hash, 7 * 3); <------>case 2: <------><------>return (name[0] << 7) ^ (name[1] << 0) ^ rol32(hash, 7 * 2); <------>case 1: <------><------>return (name[0] << 0) ^ rol32(hash, 7 * 1); <------>default: /* case 0: */ <------><------>return hash; <------>} } enum xfs_dacmp xfs_da_compname( <------>struct xfs_da_args *args, <------>const unsigned char *name, <------>int len) { <------>return (args->namelen == len && memcmp(args->name, name, len) == 0) ? <------><------><------><------><------>XFS_CMP_EXACT : XFS_CMP_DIFFERENT; } int xfs_da_grow_inode_int( <------>struct xfs_da_args *args, <------>xfs_fileoff_t *bno, <------>int count) { <------>struct xfs_trans *tp = args->trans; <------>struct xfs_inode *dp = args->dp; <------>int w = args->whichfork; <------>xfs_rfsblock_t nblks = dp->i_d.di_nblocks; <------>struct xfs_bmbt_irec map, *mapp; <------>int nmap, error, got, i, mapi; <------>/* <------> * Find a spot in the file space to put the new block. <------> */ <------>error = xfs_bmap_first_unused(tp, dp, count, bno, w); <------>if (error) <------><------>return error; <------>/* <------> * Try mapping it in one filesystem block. <------> */ <------>nmap = 1; <------>error = xfs_bmapi_write(tp, dp, *bno, count, <------><------><------>xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG, <------><------><------>args->total, &map, &nmap); <------>if (error) <------><------>return error; <------>ASSERT(nmap <= 1); <------>if (nmap == 1) { <------><------>mapp = ↦ <------><------>mapi = 1; <------>} else if (nmap == 0 && count > 1) { <------><------>xfs_fileoff_t b; <------><------>int c; <------><------>/* <------><------> * If we didn't get it and the block might work if fragmented, <------><------> * try without the CONTIG flag. Loop until we get it all. <------><------> */ <------><------>mapp = kmem_alloc(sizeof(*mapp) * count, 0); <------><------>for (b = *bno, mapi = 0; b < *bno + count; ) { <------><------><------>nmap = min(XFS_BMAP_MAX_NMAP, count); <------><------><------>c = (int)(*bno + count - b); <------><------><------>error = xfs_bmapi_write(tp, dp, b, c, <------><------><------><------><------>xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA, <------><------><------><------><------>args->total, &mapp[mapi], &nmap); <------><------><------>if (error) <------><------><------><------>goto out_free_map; <------><------><------>if (nmap < 1) <------><------><------><------>break; <------><------><------>mapi += nmap; <------><------><------>b = mapp[mapi - 1].br_startoff + <------><------><------> mapp[mapi - 1].br_blockcount; <------><------>} <------>} else { <------><------>mapi = 0; <------><------>mapp = NULL; <------>} <------>/* <------> * Count the blocks we got, make sure it matches the total. <------> */ <------>for (i = 0, got = 0; i < mapi; i++) <------><------>got += mapp[i].br_blockcount; <------>if (got != count || mapp[0].br_startoff != *bno || <------> mapp[mapi - 1].br_startoff + mapp[mapi - 1].br_blockcount != <------> *bno + count) { <------><------>error = -ENOSPC; <------><------>goto out_free_map; <------>} <------>/* account for newly allocated blocks in reserved blocks total */ <------>args->total -= dp->i_d.di_nblocks - nblks; out_free_map: <------>if (mapp != &map) <------><------>kmem_free(mapp); <------>return error; } /* * Add a block to the btree ahead of the file. * Return the new block number to the caller. */ int xfs_da_grow_inode( <------>struct xfs_da_args *args, <------>xfs_dablk_t *new_blkno) { <------>xfs_fileoff_t bno; <------>int error; <------>trace_xfs_da_grow_inode(args); <------>bno = args->geo->leafblk; <------>error = xfs_da_grow_inode_int(args, &bno, args->geo->fsbcount); <------>if (!error) <------><------>*new_blkno = (xfs_dablk_t)bno; <------>return error; } /* * Ick. We need to always be able to remove a btree block, even * if there's no space reservation because the filesystem is full. * This is called if xfs_bunmapi on a btree block fails due to ENOSPC. * It swaps the target block with the last block in the file. The * last block in the file can always be removed since it can't cause * a bmap btree split to do that. */ STATIC int xfs_da3_swap_lastblock( <------>struct xfs_da_args *args, <------>xfs_dablk_t *dead_blknop, <------>struct xfs_buf **dead_bufp) { <------>struct xfs_da_blkinfo *dead_info; <------>struct xfs_da_blkinfo *sib_info; <------>struct xfs_da_intnode *par_node; <------>struct xfs_da_intnode *dead_node; <------>struct xfs_dir2_leaf *dead_leaf2; <------>struct xfs_da_node_entry *btree; <------>struct xfs_da3_icnode_hdr par_hdr; <------>struct xfs_inode *dp; <------>struct xfs_trans *tp; <------>struct xfs_mount *mp; <------>struct xfs_buf *dead_buf; <------>struct xfs_buf *last_buf; <------>struct xfs_buf *sib_buf; <------>struct xfs_buf *par_buf; <------>xfs_dahash_t dead_hash; <------>xfs_fileoff_t lastoff; <------>xfs_dablk_t dead_blkno; <------>xfs_dablk_t last_blkno; <------>xfs_dablk_t sib_blkno; <------>xfs_dablk_t par_blkno; <------>int error; <------>int w; <------>int entno; <------>int level; <------>int dead_level; <------>trace_xfs_da_swap_lastblock(args); <------>dead_buf = *dead_bufp; <------>dead_blkno = *dead_blknop; <------>tp = args->trans; <------>dp = args->dp; <------>w = args->whichfork; <------>ASSERT(w == XFS_DATA_FORK); <------>mp = dp->i_mount; <------>lastoff = args->geo->freeblk; <------>error = xfs_bmap_last_before(tp, dp, &lastoff, w); <------>if (error) <------><------>return error; <------>if (XFS_IS_CORRUPT(mp, lastoff == 0)) <------><------>return -EFSCORRUPTED; <------>/* <------> * Read the last block in the btree space. <------> */ <------>last_blkno = (xfs_dablk_t)lastoff - args->geo->fsbcount; <------>error = xfs_da3_node_read(tp, dp, last_blkno, &last_buf, w); <------>if (error) <------><------>return error; <------>/* <------> * Copy the last block into the dead buffer and log it. <------> */ <------>memcpy(dead_buf->b_addr, last_buf->b_addr, args->geo->blksize); <------>xfs_trans_log_buf(tp, dead_buf, 0, args->geo->blksize - 1); <------>dead_info = dead_buf->b_addr; <------>/* <------> * Get values from the moved block. <------> */ <------>if (dead_info->magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) || <------> dead_info->magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) { <------><------>struct xfs_dir3_icleaf_hdr leafhdr; <------><------>struct xfs_dir2_leaf_entry *ents; <------><------>dead_leaf2 = (xfs_dir2_leaf_t *)dead_info; <------><------>xfs_dir2_leaf_hdr_from_disk(dp->i_mount, &leafhdr, <------><------><------><------><------> dead_leaf2); <------><------>ents = leafhdr.ents; <------><------>dead_level = 0; <------><------>dead_hash = be32_to_cpu(ents[leafhdr.count - 1].hashval); <------>} else { <------><------>struct xfs_da3_icnode_hdr deadhdr; <------><------>dead_node = (xfs_da_intnode_t *)dead_info; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &deadhdr, dead_node); <------><------>btree = deadhdr.btree; <------><------>dead_level = deadhdr.level; <------><------>dead_hash = be32_to_cpu(btree[deadhdr.count - 1].hashval); <------>} <------>sib_buf = par_buf = NULL; <------>/* <------> * If the moved block has a left sibling, fix up the pointers. <------> */ <------>if ((sib_blkno = be32_to_cpu(dead_info->back))) { <------><------>error = xfs_da3_node_read(tp, dp, sib_blkno, &sib_buf, w); <------><------>if (error) <------><------><------>goto done; <------><------>sib_info = sib_buf->b_addr; <------><------>if (XFS_IS_CORRUPT(mp, <------><------><------><------> be32_to_cpu(sib_info->forw) != last_blkno || <------><------><------><------> sib_info->magic != dead_info->magic)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>sib_info->forw = cpu_to_be32(dead_blkno); <------><------>xfs_trans_log_buf(tp, sib_buf, <------><------><------>XFS_DA_LOGRANGE(sib_info, &sib_info->forw, <------><------><------><------><------>sizeof(sib_info->forw))); <------><------>sib_buf = NULL; <------>} <------>/* <------> * If the moved block has a right sibling, fix up the pointers. <------> */ <------>if ((sib_blkno = be32_to_cpu(dead_info->forw))) { <------><------>error = xfs_da3_node_read(tp, dp, sib_blkno, &sib_buf, w); <------><------>if (error) <------><------><------>goto done; <------><------>sib_info = sib_buf->b_addr; <------><------>if (XFS_IS_CORRUPT(mp, <------><------><------><------> be32_to_cpu(sib_info->back) != last_blkno || <------><------><------><------> sib_info->magic != dead_info->magic)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>sib_info->back = cpu_to_be32(dead_blkno); <------><------>xfs_trans_log_buf(tp, sib_buf, <------><------><------>XFS_DA_LOGRANGE(sib_info, &sib_info->back, <------><------><------><------><------>sizeof(sib_info->back))); <------><------>sib_buf = NULL; <------>} <------>par_blkno = args->geo->leafblk; <------>level = -1; <------>/* <------> * Walk down the tree looking for the parent of the moved block. <------> */ <------>for (;;) { <------><------>error = xfs_da3_node_read(tp, dp, par_blkno, &par_buf, w); <------><------>if (error) <------><------><------>goto done; <------><------>par_node = par_buf->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &par_hdr, par_node); <------><------>if (XFS_IS_CORRUPT(mp, <------><------><------><------> level >= 0 && level != par_hdr.level + 1)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>level = par_hdr.level; <------><------>btree = par_hdr.btree; <------><------>for (entno = 0; <------><------> entno < par_hdr.count && <------><------> be32_to_cpu(btree[entno].hashval) < dead_hash; <------><------> entno++) <------><------><------>continue; <------><------>if (XFS_IS_CORRUPT(mp, entno == par_hdr.count)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>par_blkno = be32_to_cpu(btree[entno].before); <------><------>if (level == dead_level + 1) <------><------><------>break; <------><------>xfs_trans_brelse(tp, par_buf); <------><------>par_buf = NULL; <------>} <------>/* <------> * We're in the right parent block. <------> * Look for the right entry. <------> */ <------>for (;;) { <------><------>for (; <------><------> entno < par_hdr.count && <------><------> be32_to_cpu(btree[entno].before) != last_blkno; <------><------> entno++) <------><------><------>continue; <------><------>if (entno < par_hdr.count) <------><------><------>break; <------><------>par_blkno = par_hdr.forw; <------><------>xfs_trans_brelse(tp, par_buf); <------><------>par_buf = NULL; <------><------>if (XFS_IS_CORRUPT(mp, par_blkno == 0)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>error = xfs_da3_node_read(tp, dp, par_blkno, &par_buf, w); <------><------>if (error) <------><------><------>goto done; <------><------>par_node = par_buf->b_addr; <------><------>xfs_da3_node_hdr_from_disk(dp->i_mount, &par_hdr, par_node); <------><------>if (XFS_IS_CORRUPT(mp, par_hdr.level != level)) { <------><------><------>error = -EFSCORRUPTED; <------><------><------>goto done; <------><------>} <------><------>btree = par_hdr.btree; <------><------>entno = 0; <------>} <------>/* <------> * Update the parent entry pointing to the moved block. <------> */ <------>btree[entno].before = cpu_to_be32(dead_blkno); <------>xfs_trans_log_buf(tp, par_buf, <------><------>XFS_DA_LOGRANGE(par_node, &btree[entno].before, <------><------><------><------>sizeof(btree[entno].before))); <------>*dead_blknop = last_blkno; <------>*dead_bufp = last_buf; <------>return 0; done: <------>if (par_buf) <------><------>xfs_trans_brelse(tp, par_buf); <------>if (sib_buf) <------><------>xfs_trans_brelse(tp, sib_buf); <------>xfs_trans_brelse(tp, last_buf); <------>return error; } /* * Remove a btree block from a directory or attribute. */ int xfs_da_shrink_inode( <------>struct xfs_da_args *args, <------>xfs_dablk_t dead_blkno, <------>struct xfs_buf *dead_buf) { <------>struct xfs_inode *dp; <------>int done, error, w, count; <------>struct xfs_trans *tp; <------>trace_xfs_da_shrink_inode(args); <------>dp = args->dp; <------>w = args->whichfork; <------>tp = args->trans; <------>count = args->geo->fsbcount; <------>for (;;) { <------><------>/* <------><------> * Remove extents. If we get ENOSPC for a dir we have to move <------><------> * the last block to the place we want to kill. <------><------> */ <------><------>error = xfs_bunmapi(tp, dp, dead_blkno, count, <------><------><------><------> xfs_bmapi_aflag(w), 0, &done); <------><------>if (error == -ENOSPC) { <------><------><------>if (w != XFS_DATA_FORK) <------><------><------><------>break; <------><------><------>error = xfs_da3_swap_lastblock(args, &dead_blkno, <------><------><------><------><------><------> &dead_buf); <------><------><------>if (error) <------><------><------><------>break; <------><------>} else { <------><------><------>break; <------><------>} <------>} <------>xfs_trans_binval(tp, dead_buf); <------>return error; } static int xfs_dabuf_map( <------>struct xfs_inode *dp, <------>xfs_dablk_t bno, <------>unsigned int flags, <------>int whichfork, <------>struct xfs_buf_map **mapp, <------>int *nmaps) { <------>struct xfs_mount *mp = dp->i_mount; <------>int nfsb = xfs_dabuf_nfsb(mp, whichfork); <------>struct xfs_bmbt_irec irec, *irecs = &irec; <------>struct xfs_buf_map *map = *mapp; <------>xfs_fileoff_t off = bno; <------>int error = 0, nirecs, i; <------>if (nfsb > 1) <------><------>irecs = kmem_zalloc(sizeof(irec) * nfsb, KM_NOFS); <------>nirecs = nfsb; <------>error = xfs_bmapi_read(dp, bno, nfsb, irecs, &nirecs, <------><------><------>xfs_bmapi_aflag(whichfork)); <------>if (error) <------><------>goto out_free_irecs; <------>/* <------> * Use the caller provided map for the single map case, else allocate a <------> * larger one that needs to be free by the caller. <------> */ <------>if (nirecs > 1) { <------><------>map = kmem_zalloc(nirecs * sizeof(struct xfs_buf_map), KM_NOFS); <------><------>if (!map) { <------><------><------>error = -ENOMEM; <------><------><------>goto out_free_irecs; <------><------>} <------><------>*mapp = map; <------>} <------>for (i = 0; i < nirecs; i++) { <------><------>if (irecs[i].br_startblock == HOLESTARTBLOCK || <------><------> irecs[i].br_startblock == DELAYSTARTBLOCK) <------><------><------>goto invalid_mapping; <------><------>if (off != irecs[i].br_startoff) <------><------><------>goto invalid_mapping; <------><------>map[i].bm_bn = XFS_FSB_TO_DADDR(mp, irecs[i].br_startblock); <------><------>map[i].bm_len = XFS_FSB_TO_BB(mp, irecs[i].br_blockcount); <------><------>off += irecs[i].br_blockcount; <------>} <------>if (off != bno + nfsb) <------><------>goto invalid_mapping; <------>*nmaps = nirecs; out_free_irecs: <------>if (irecs != &irec) <------><------>kmem_free(irecs); <------>return error; invalid_mapping: <------>/* Caller ok with no mapping. */ <------>if (XFS_IS_CORRUPT(mp, !(flags & XFS_DABUF_MAP_HOLE_OK))) { <------><------>error = -EFSCORRUPTED; <------><------>if (xfs_error_level >= XFS_ERRLEVEL_LOW) { <------><------><------>xfs_alert(mp, "%s: bno %u inode %llu", <------><------><------><------><------>__func__, bno, dp->i_ino); <------><------><------>for (i = 0; i < nirecs; i++) { <------><------><------><------>xfs_alert(mp, "[%02d] br_startoff %lld br_startblock %lld br_blockcount %lld br_state %d", <------><------><------><------><------>i, irecs[i].br_startoff, <------><------><------><------><------>irecs[i].br_startblock, <------><------><------><------><------>irecs[i].br_blockcount, <------><------><------><------><------>irecs[i].br_state); <------><------><------>} <------><------>} <------>} else { <------><------>*nmaps = 0; <------>} <------>goto out_free_irecs; } /* * Get a buffer for the dir/attr block. */ int xfs_da_get_buf( <------>struct xfs_trans *tp, <------>struct xfs_inode *dp, <------>xfs_dablk_t bno, <------>struct xfs_buf **bpp, <------>int whichfork) { <------>struct xfs_mount *mp = dp->i_mount; <------>struct xfs_buf *bp; <------>struct xfs_buf_map map, *mapp = ↦ <------>int nmap = 1; <------>int error; <------>*bpp = NULL; <------>error = xfs_dabuf_map(dp, bno, 0, whichfork, &mapp, &nmap); <------>if (error || nmap == 0) <------><------>goto out_free; <------>error = xfs_trans_get_buf_map(tp, mp->m_ddev_targp, mapp, nmap, 0, &bp); <------>if (error) <------><------>goto out_free; <------>*bpp = bp; out_free: <------>if (mapp != &map) <------><------>kmem_free(mapp); <------>return error; } /* * Get a buffer for the dir/attr block, fill in the contents. */ int xfs_da_read_buf( <------>struct xfs_trans *tp, <------>struct xfs_inode *dp, <------>xfs_dablk_t bno, <------>unsigned int flags, <------>struct xfs_buf **bpp, <------>int whichfork, <------>const struct xfs_buf_ops *ops) { <------>struct xfs_mount *mp = dp->i_mount; <------>struct xfs_buf *bp; <------>struct xfs_buf_map map, *mapp = ↦ <------>int nmap = 1; <------>int error; <------>*bpp = NULL; <------>error = xfs_dabuf_map(dp, bno, flags, whichfork, &mapp, &nmap); <------>if (error || !nmap) <------><------>goto out_free; <------>error = xfs_trans_read_buf_map(mp, tp, mp->m_ddev_targp, mapp, nmap, 0, <------><------><------>&bp, ops); <------>if (error) <------><------>goto out_free; <------>if (whichfork == XFS_ATTR_FORK) <------><------>xfs_buf_set_ref(bp, XFS_ATTR_BTREE_REF); <------>else <------><------>xfs_buf_set_ref(bp, XFS_DIR_BTREE_REF); <------>*bpp = bp; out_free: <------>if (mapp != &map) <------><------>kmem_free(mapp); <------>return error; } /* * Readahead the dir/attr block. */ int xfs_da_reada_buf( <------>struct xfs_inode *dp, <------>xfs_dablk_t bno, <------>unsigned int flags, <------>int whichfork, <------>const struct xfs_buf_ops *ops) { <------>struct xfs_buf_map map; <------>struct xfs_buf_map *mapp; <------>int nmap; <------>int error; <------>mapp = ↦ <------>nmap = 1; <------>error = xfs_dabuf_map(dp, bno, flags, whichfork, &mapp, &nmap); <------>if (error || !nmap) <------><------>goto out_free; <------>xfs_buf_readahead_map(dp->i_mount->m_ddev_targp, mapp, nmap, ops); out_free: <------>if (mapp != &map) <------><------>kmem_free(mapp); <------>return error; }
Orange Pi5 kernel
Deprecated Linux kernel 5.10.110 for OrangePi 5/5B/5+ boards
3 Commits
0 Branches
0 Tags
| Donate