diff options
Diffstat (limited to 'fs/xfs/xfs_dir2_node.c')
| -rw-r--r-- | fs/xfs/xfs_dir2_node.c | 2284 |
1 files changed, 0 insertions, 2284 deletions
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c deleted file mode 100644 index 4cf8b99d09a4..000000000000 --- a/fs/xfs/xfs_dir2_node.c +++ /dev/null @@ -1,2284 +0,0 @@ -/* - * Copyright (c) 2000-2005 Silicon Graphics, Inc. - * Copyright (c) 2013 Red Hat, Inc. - * All Rights Reserved. - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation. - * - * This program is distributed in the hope that it would be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - */ -#include "xfs.h" -#include "xfs_fs.h" -#include "xfs_format.h" -#include "xfs_log_format.h" -#include "xfs_trans_resv.h" -#include "xfs_sb.h" -#include "xfs_ag.h" -#include "xfs_mount.h" -#include "xfs_da_format.h" -#include "xfs_da_btree.h" -#include "xfs_inode.h" -#include "xfs_bmap.h" -#include "xfs_dir2.h" -#include "xfs_dir2_priv.h" -#include "xfs_error.h" -#include "xfs_trace.h" -#include "xfs_trans.h" -#include "xfs_buf_item.h" -#include "xfs_cksum.h" - -/* - * Function declarations. - */ -static int xfs_dir2_leafn_add(struct xfs_buf *bp, xfs_da_args_t *args, - int index); -static void xfs_dir2_leafn_rebalance(xfs_da_state_t *state, - xfs_da_state_blk_t *blk1, - xfs_da_state_blk_t *blk2); -static int xfs_dir2_leafn_remove(xfs_da_args_t *args, struct xfs_buf *bp, - int index, xfs_da_state_blk_t *dblk, - int *rval); -static int xfs_dir2_node_addname_int(xfs_da_args_t *args, - xfs_da_state_blk_t *fblk); - -/* - * Check internal consistency of a leafn block. - */ -#ifdef DEBUG -#define xfs_dir3_leaf_check(dp, bp) \ -do { \ - if (!xfs_dir3_leafn_check((dp), (bp))) \ - ASSERT(0); \ -} while (0); - -static bool -xfs_dir3_leafn_check( - struct xfs_inode *dp, - struct xfs_buf *bp) -{ - struct xfs_dir2_leaf *leaf = bp->b_addr; - struct xfs_dir3_icleaf_hdr leafhdr; - - dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf); - - if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) { - struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr; - if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn) - return false; - } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC) - return false; - - return xfs_dir3_leaf_check_int(dp->i_mount, dp, &leafhdr, leaf); -} -#else -#define xfs_dir3_leaf_check(dp, bp) -#endif - -static bool -xfs_dir3_free_verify( - struct xfs_buf *bp) -{ - struct xfs_mount *mp = bp->b_target->bt_mount; - struct xfs_dir2_free_hdr *hdr = bp->b_addr; - - if (xfs_sb_version_hascrc(&mp->m_sb)) { - struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; - - if (hdr3->magic != cpu_to_be32(XFS_DIR3_FREE_MAGIC)) - return false; - if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid)) - return false; - if (be64_to_cpu(hdr3->blkno) != bp->b_bn) - return false; - } else { - if (hdr->magic != cpu_to_be32(XFS_DIR2_FREE_MAGIC)) - return false; - } - - /* XXX: should bounds check the xfs_dir3_icfree_hdr here */ - - return true; -} - -static void -xfs_dir3_free_read_verify( - struct xfs_buf *bp) -{ - struct xfs_mount *mp = bp->b_target->bt_mount; - - if (xfs_sb_version_hascrc(&mp->m_sb) && - !xfs_buf_verify_cksum(bp, XFS_DIR3_FREE_CRC_OFF)) - xfs_buf_ioerror(bp, EFSBADCRC); - else if (!xfs_dir3_free_verify(bp)) - xfs_buf_ioerror(bp, EFSCORRUPTED); - - if (bp->b_error) - xfs_verifier_error(bp); -} - -static void -xfs_dir3_free_write_verify( - struct xfs_buf *bp) -{ - struct xfs_mount *mp = bp->b_target->bt_mount; - struct xfs_buf_log_item *bip = bp->b_fspriv; - struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr; - - if (!xfs_dir3_free_verify(bp)) { - xfs_buf_ioerror(bp, EFSCORRUPTED); - xfs_verifier_error(bp); - return; - } - - if (!xfs_sb_version_hascrc(&mp->m_sb)) - return; - - if (bip) - hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn); - - xfs_buf_update_cksum(bp, XFS_DIR3_FREE_CRC_OFF); -} - -const struct xfs_buf_ops xfs_dir3_free_buf_ops = { - .verify_read = xfs_dir3_free_read_verify, - .verify_write = xfs_dir3_free_write_verify, -}; - - -static int -__xfs_dir3_free_read( - struct xfs_trans *tp, - struct xfs_inode *dp, - xfs_dablk_t fbno, - xfs_daddr_t mappedbno, - struct xfs_buf **bpp) -{ - int err; - - err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp, - XFS_DATA_FORK, &xfs_dir3_free_buf_ops); - - /* try read returns without an error or *bpp if it lands in a hole */ - if (!err && tp && *bpp) - xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_FREE_BUF); - return err; -} - -int -xfs_dir2_free_read( - struct xfs_trans *tp, - struct xfs_inode *dp, - xfs_dablk_t fbno, - struct xfs_buf **bpp) -{ - return __xfs_dir3_free_read(tp, dp, fbno, -1, bpp); -} - -static int -xfs_dir2_free_try_read( - struct xfs_trans *tp, - struct xfs_inode *dp, - xfs_dablk_t fbno, - struct xfs_buf **bpp) -{ - return __xfs_dir3_free_read(tp, dp, fbno, -2, bpp); -} - -static int -xfs_dir3_free_get_buf( - xfs_da_args_t *args, - xfs_dir2_db_t fbno, - struct xfs_buf **bpp) -{ - struct xfs_trans *tp = args->trans; - struct xfs_inode *dp = args->dp; - struct xfs_mount *mp = dp->i_mount; - struct xfs_buf *bp; - int error; - struct xfs_dir3_icfree_hdr hdr; - - error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, fbno), - -1, &bp, XFS_DATA_FORK); - if (error) - return error; - - xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_FREE_BUF); - bp->b_ops = &xfs_dir3_free_buf_ops; - - /* - * Initialize the new block to be empty, and remember - * its first slot as our empty slot. - */ - memset(bp->b_addr, 0, sizeof(struct xfs_dir3_free_hdr)); - memset(&hdr, 0, sizeof(hdr)); - - if (xfs_sb_version_hascrc(&mp->m_sb)) { - struct xfs_dir3_free_hdr *hdr3 = bp->b_addr; - - hdr.magic = XFS_DIR3_FREE_MAGIC; - - hdr3->hdr.blkno = cpu_to_be64(bp->b_bn); - hdr3->hdr.owner = cpu_to_be64(dp->i_ino); - uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_uuid); - } else - hdr.magic = XFS_DIR2_FREE_MAGIC; - dp->d_ops->free_hdr_to_disk(bp->b_addr, &hdr); - *bpp = bp; - return 0; -} - -/* - * Log entries from a freespace block. - */ -STATIC void -xfs_dir2_free_log_bests( - struct xfs_da_args *args, - struct xfs_buf *bp, - int first, /* first entry to log */ - int last) /* last entry to log */ -{ - xfs_dir2_free_t *free; /* freespace structure */ - __be16 *bests; - - free = bp->b_addr; - bests = args->dp->d_ops->free_bests_p(free); - ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) || - free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC)); - xfs_trans_log_buf(args->trans, bp, - (uint)((char *)&bests[first] - (char *)free), - (uint)((char *)&bests[last] - (char *)free + - sizeof(bests[0]) - 1)); -} - -/* - * Log header from a freespace block. - */ -static void -xfs_dir2_free_log_header( - struct xfs_da_args *args, - struct xfs_buf *bp) -{ -#ifdef DEBUG - xfs_dir2_free_t *free; /* freespace structure */ - - free = bp->b_addr; - ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) || - free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC)); -#endif - xfs_trans_log_buf(args->trans, bp, 0, - args->dp->d_ops->free_hdr_size - 1); -} - -/* - * Convert a leaf-format directory to a node-format directory. - * We need to change the magic number of the leaf block, and copy - * the freespace table out of the leaf block into its own block. - */ -int /* error */ -xfs_dir2_leaf_to_node( - xfs_da_args_t *args, /* operation arguments */ - struct xfs_buf *lbp) /* leaf buffer */ -{ - xfs_inode_t *dp; /* incore directory inode */ - int error; /* error return value */ - struct xfs_buf *fbp; /* freespace buffer */ - xfs_dir2_db_t fdb; /* freespace block number */ - xfs_dir2_free_t *free; /* freespace structure */ - __be16 *from; /* pointer to freespace entry */ - int i; /* leaf freespace index */ - xfs_dir2_leaf_t *leaf; /* leaf structure */ - xfs_dir2_leaf_tail_t *ltp; /* leaf tail structure */ - xfs_mount_t *mp; /* filesystem mount point */ - int n; /* count of live freespc ents */ - xfs_dir2_data_off_t off; /* freespace entry value */ - __be16 *to; /* pointer to freespace entry */ - xfs_trans_t *tp; /* transaction pointer */ - struct xfs_dir3_icfree_hdr freehdr; - - trace_xfs_dir2_leaf_to_node(args); - - dp = args->dp; - mp = dp->i_mount; - tp = args->trans; - /* - * Add a freespace block to the directory. - */ - if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_FREE_SPACE, &fdb))) { - return error; - } - ASSERT(fdb == xfs_dir2_byte_to_db(args->geo, XFS_DIR2_FREE_OFFSET)); - /* - * Get the buffer for the new freespace block. - */ - error = xfs_dir3_free_get_buf(args, fdb, &fbp); - if (error) - return error; - - free = fbp->b_addr; - dp->d_ops->free_hdr_from_disk(&freehdr, free); - leaf = lbp->b_addr; - ltp = xfs_dir2_leaf_tail_p(args->geo, leaf); - ASSERT(be32_to_cpu(ltp->bestcount) <= - (uint)dp->i_d.di_size / args->geo->blksize); - - /* - * Copy freespace entries from the leaf block to the new block. - * Count active entries. - */ - from = xfs_dir2_leaf_bests_p(ltp); - to = dp->d_ops->free_bests_p(free); - for (i = n = 0; i < be32_to_cpu(ltp->bestcount); i++, from++, to++) { - if ((off = be16_to_cpu(*from)) != NULLDATAOFF) - n++; - *to = cpu_to_be16(off); - } - - /* - * Now initialize the freespace block header. - */ - freehdr.nused = n; - freehdr.nvalid = be32_to_cpu(ltp->bestcount); - - dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr); - xfs_dir2_free_log_bests(args, fbp, 0, freehdr.nvalid - 1); - xfs_dir2_free_log_header(args, fbp); - - /* - * Converting the leaf to a leafnode is just a matter of changing the - * magic number and the ops. Do the change directly to the buffer as - * it's less work (and less code) than decoding the header to host - * format and back again. - */ - if (leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC)) - leaf->hdr.info.magic = cpu_to_be16(XFS_DIR2_LEAFN_MAGIC); - else - leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC); - lbp->b_ops = &xfs_dir3_leafn_buf_ops; - xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAFN_BUF); - xfs_dir3_leaf_log_header(args, lbp); - xfs_dir3_leaf_check(dp, lbp); - return 0; -} - -/* - * Add a leaf entry to a leaf block in a node-form directory. - * The other work necessary is done from the caller. - */ -static int /* error */ -xfs_dir2_leafn_add( - struct xfs_buf *bp, /* leaf buffer */ - xfs_da_args_t *args, /* operation arguments */ - int index) /* insertion pt for new entry */ -{ - int compact; /* compacting stale leaves */ - xfs_inode_t *dp; /* incore directory inode */ - int highstale; /* next stale entry */ - xfs_dir2_leaf_t *leaf; /* leaf structure */ - xfs_dir2_leaf_entry_t *lep; /* leaf entry */ - int lfloghigh; /* high leaf entry logging */ - int lfloglow; /* low leaf entry logging */ - int lowstale; /* previous stale entry */ - xfs_mount_t *mp; /* filesystem mount point */ - xfs_trans_t *tp; /* transaction pointer */ - struct xfs_dir3_icleaf_hdr leafhdr; - struct xfs_dir2_leaf_entry *ents; - - trace_xfs_dir2_leafn_add(args, index); - - dp = args->dp; - mp = dp->i_mount; - tp = args->trans; - leaf = bp->b_addr; - dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf); - ents = dp->d_ops->leaf_ents_p(leaf); - - /* - * Quick check just to make sure we are not going to index - * into other peoples memory - */ - if (index < 0) - return EFSCORRUPTED; - - /* - * If there are already the maximum number of leaf entries in - * the block, if there are no stale entries it won't fit. - * Caller will do a split. If there are stale entries we'll do - * a compact. - */ - - if (leafhdr.count == dp->d_ops->leaf_max_ents(args->geo)) { - if (!leafhdr.stale) - return ENOSPC; - compact = leafhdr.stale > 1; - } else - compact = 0; - ASSERT(index == 0 || be32_to_cpu(ents[index - 1].hashval) <= args->hashval); - ASSERT(index == leafhdr.count || - be32_to_cpu(ents[index].hashval) >= args->hashval); - - if (args->op_flags & XFS_DA_OP_JUSTCHECK) - return 0; - - /* - * Compact out all but one stale leaf entry. Leaves behind - * the entry closest to index. - */ - if (compact) - xfs_dir3_leaf_compact_x1(&leafhdr, ents, &index, &lowstale, - &highstale, &lfloglow, &lfloghigh); - else if (leafhdr.stale) { - /* - * Set impossible logging indices for this case. - */ - lfloglow = leafhdr.count; - lfloghigh = -1; - } - - /* - * Insert the new entry, log everything. - */ - lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale, - highstale, &lfloglow, &lfloghigh); - - lep->hashval = cpu_to_be32(args->hashval); - lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(args->geo, - args->blkno, args->index)); - - dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr); - xfs_dir3_leaf_log_header(args, bp); - xfs_dir3_leaf_log_ents(args, bp, lfloglow, lfloghigh); - xfs_dir3_leaf_check(dp, bp); - return 0; -} - -#ifdef DEBUG -static void -xfs_dir2_free_hdr_check( - struct xfs_inode *dp, - struct xfs_buf *bp, - xfs_dir2_db_t db) -{ - struct xfs_dir3_icfree_hdr hdr; - - dp->d_ops->free_hdr_from_disk(&hdr, bp->b_addr); - - ASSERT((hdr.firstdb % - dp->d_ops->free_max_bests(dp->i_mount->m_dir_geo)) == 0); - ASSERT(hdr.firstdb <= db); - ASSERT(db < hdr.firstdb + hdr.nvalid); -} -#else -#define xfs_dir2_free_hdr_check(dp, bp, db) -#endif /* DEBUG */ - -/* - * Return the last hash value in the leaf. - * Stale entries are ok. - */ -xfs_dahash_t /* hash value */ -xfs_dir2_leafn_lasthash( - struct xfs_inode *dp, - struct xfs_buf *bp, /* leaf buffer */ - int *count) /* count of entries in leaf */ -{ - struct xfs_dir2_leaf *leaf = bp->b_addr; - struct xfs_dir2_leaf_entry *ents; - struct xfs_dir3_icleaf_hdr leafhdr; - - dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf); - - ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC || - leafhdr.magic == XFS_DIR3_LEAFN_MAGIC); - - if (count) - *count = leafhdr.count; - if (!leafhdr.count) - return 0; - - ents = dp->d_ops->leaf_ents_p(leaf); - return be32_to_cpu(ents[leafhdr.count - 1].hashval); -} - -/* - * Look up a leaf entry for space to add a name in a node-format leaf block. - * The extrablk in state is a freespace block. - */ -STATIC int -xfs_dir2_leafn_lookup_for_addname( - struct xfs_buf *bp, /* leaf buffer */ - xfs_da_args_t *args, /* operation arguments */ - int *indexp, /* out: leaf entry index */ - xfs_da_state_t *state) /* state to fill in */ -{ - struct xfs_buf *curbp = NULL; /* current data/free buffer */ - xfs_dir2_db_t curdb = -1; /* current data block number */ - xfs_dir2_db_t curfdb = -1; /* current free block number */ - xfs_inode_t *dp; /* incore directory inode */ - int error; /* error return value */ - int fi; /* free entry index */ - xfs_dir2_free_t *free = NULL; /* free block structure */ - int index; /* leaf entry index */ - xfs_dir2_leaf_t *leaf; /* leaf structure */ - int length; /* length of new data entry */ - xfs_dir2_leaf_entry_t *lep; /* leaf entry */ - xfs_mount_t *mp; /* filesystem mount point */ - xfs_dir2_db_t newdb; /* new data block number */ - xfs_dir2_db_t newfdb; /* new free block number */ - xfs_trans_t *tp; /* transaction pointer */ - struct xfs_dir2_leaf_entry *ents; - struct xfs_dir3_icleaf_hdr leafhdr; - - dp = args->dp; - tp = args->trans; - mp = dp->i_mount; - leaf = bp->b_addr; - dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf); - ents = dp->d_ops->leaf_ents_p(leaf); - - xfs_dir3_leaf_check(dp, bp); - ASSERT(leafhdr.count > 0); - - /* - * Look up the hash value in the leaf entries. - */ - index = xfs_dir2_leaf_search_hash(args, bp); - /* - * Do we have a buffer coming in? - */ - if (state->extravalid) { - /* If so, it's a free block buffer, get the block number. */ - curbp = state->extrablk.bp; - curfdb = state->extrablk.blkno; - free = curbp->b_addr; - ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) || - free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC)); - } - length = dp->d_ops->data_entsize(args->namelen); - /* - * Loop over leaf entries with the right hash value. - */ - for (lep = &ents[index]; - index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval; - lep++, index++) { - /* - * Skip stale leaf entries. - */ - if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR) - continue; - /* - * Pull the data block number from the entry. - */ - newdb = xfs_dir2_dataptr_to_db(args->geo, - be32_to_cpu(lep->address)); - /* - * For addname, we're looking for a place to put the new entry. - * We want to use a data block with an entry of equal - * hash value to ours if there is one with room. - * - * If this block isn't the data block we already have - * in hand, take a look at it. - */ - if (newdb != curdb) { - __be16 *bests; - - curdb = newdb; - /* - * Convert the data block to the free block - * holding its freespace information. - */ - newfdb = dp->d_ops->db_to_fdb(args->geo, newdb); - /* - * If it's not the one we have in hand, read it in. - */ - if (newfdb != curfdb) { - /* - * If we had one before, drop it. - */ - if (curbp) - xfs_trans_brelse(tp, curbp); - - error = xfs_dir2_free_read(tp, dp, - xfs_dir2_db_to_da(args->geo, - newfdb), - &curbp); - if (error) - return error; - free = curbp->b_addr; - - xfs_dir2_free_hdr_check(dp, curbp, curdb); - } - /* - * Get the index for our entry. - */ - fi = dp->d_ops->db_to_fdindex(args->geo, curdb); - /* - * If it has room, return it. - */ - bests = dp->d_ops->free_bests_p(free); - if (unlikely(bests[fi] == cpu_to_be16(NULLDATAOFF))) { - XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int", - XFS_ERRLEVEL_LOW, mp); - if (curfdb != newfdb) - xfs_trans_brelse(tp, curbp); - return EFSCORRUPTED; - } - curfdb = newfdb; - if (be16_to_cpu(bests[fi]) >= length) - goto out; - } - } - /* Didn't find any space */ - fi = -1; -out: - ASSERT(args->op_flags & XFS_DA_OP_OKNOENT); - if (curbp) { - /* Giving back a free block. */ - state->extravalid = 1; - state->extrablk.bp = curbp; - state->extrablk.index = fi; - state->extrablk.blkno = curfdb; - - /* - * Important: this magic number is not in the buffer - it's for - * buffer type information and therefore only the free/data type - * matters here, not whether CRCs are enabled or not. - */ - state->extrablk.magic = XFS_DIR2_FREE_MAGIC; - } else { - state->extravalid = 0; - } - /* - * Return the index, that will be the insertion point. - */ - *indexp = index; - return ENOENT; -} - -/* - * Look up a leaf entry in a node-format leaf block. - * The extrablk in state a data block. - */ -STATIC int -xfs_dir2_leafn_lookup_for_entry( - struct xfs_buf *bp, /* leaf buffer */ - xfs_da_args_t *args, /* operation arguments */ - int *indexp, /* out: leaf entry index */ - xfs_da_state_t *state) /* state to fill in */ -{ - struct xfs_buf *curbp = NULL; /* current data/free buffer */ - xfs_dir2_db_t curdb = -1; /* current data block number */ - xfs_dir2_data_entry_t *dep; /* data block entry */ - xfs_inode_t *dp; /* incore directory inode */ - int error; /* error return value */ - int index; /* leaf entry index */ - xfs_dir2_leaf_t *leaf; /* leaf structure */ - xfs_dir2_leaf_entry_t *lep; /* leaf entry */ - xfs_mount_t *mp; /* filesystem mount point */ - xfs_dir2_db_t newdb; /* new data block number */ - xfs_trans_t *tp; /* transaction pointer */ - enum xfs_dacmp cmp; /* comparison result */ - struct xfs_dir2_leaf_entry *ents; - struct xfs_dir3_icleaf_hdr leafhdr; - - dp = args->dp; - tp = args->trans; - mp = dp->i_mount; - leaf = bp->b_addr; - dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf); - ents = dp->d_ops->leaf_ents_p(leaf); - - xfs_dir3_leaf_check(dp, bp); - ASSERT(leafhdr.count > 0); - - /* - * Look up the hash value in the leaf entries. - */ - index = xfs_dir2_leaf_search_hash(args, bp); - /* - * Do we have a buffer coming in? - */ - if (state->extravalid) { - curbp = state->extrablk.bp; - curdb = state->extrablk.blkno; - } - /* - * Loop over leaf entries with the right hash value. - */ - for (lep = &ents[index]; - index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval; - lep++, index++) { - /* - * Skip stale leaf entries. - */ - if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR) - continue; - /* - * Pull the data block number from the entry. - */ - newdb = xfs_dir2_dataptr_to_db(args->geo, - be32_to_cpu(lep->address)); - /* - * Not adding a new entry, so we really want to find - * the name given to us. - * - * If it's a different data block, go get it. - */ - if (newdb != curdb) { - /* - * If we had a block before that we aren't saving - * for a CI name, drop it - */ - if (curbp && (args->cmpresult == XFS_CMP_DIFFERENT || - curdb != state->extrablk.blkno)) - xfs_trans_brelse(tp, curbp); - /* - * If needing the block that is saved with a CI match, - * use it otherwise read in the new data block. - */ - if (args->cmpresult != XFS_CMP_DIFFERENT && - newdb == state->extrablk.blkno) { - ASSERT(state->extravalid); - curbp = state->extrablk.bp; - } else { - error = xfs_dir3_data_read(tp, dp, - xfs_dir2_db_to_da(args->geo, - newdb), - -1, &curbp); - if (error) - return error; - } - xfs_dir3_data_check(dp, curbp); - curdb = newdb; - } - /* - * Point to the data entry. - */ - dep = (xfs_dir2_data_entry_t *)((char *)curbp->b_addr + - xfs_dir2_dataptr_to_off(args->geo, - be32_to_cpu(lep->address))); - /* - * Compare the entry and if it's an exact match, return - * EEXIST immediately. If it's the first case-insensitive - * match, store the block & inode number and continue looking. - */ - cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen); - if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) { - /* If there is a CI match block, drop it */ - if (args->cmpresult != XFS_CMP_DIFFERENT && - curdb != state->extrablk.blkno) - xfs_trans_brelse(tp, state->extrablk.bp); - args->cmpresult = cmp; - args->inumber = be64_to_cpu(dep->inumber); - args->filetype = dp->d_ops->data_get_ftype(dep); - *indexp = index; - state->extravalid = 1; - state->extrablk.bp = curbp; - state->extrablk.blkno = curdb; - state->extrablk.index = (int)((char *)dep - - (char *)curbp->b_addr); - state->extrablk.magic = XFS_DIR2_DATA_MAGIC; - curbp->b_ops = &xfs_dir3_data_buf_ops; - xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF); - if (cmp == XFS_CMP_EXACT) - return EEXIST; - } - } - ASSERT(index == leafhdr.count || (args->op_flags & XFS_DA_OP_OKNOENT)); - if (curbp) { - if (args->cmpresult == XFS_CMP_DIFFERENT) { - /* Giving back last used data block. */ - state->extravalid = 1; - state->extrablk.bp = curbp; - state->extrablk.index = -1; - state->extrablk.blkno = curdb; - state->extrablk.magic = XFS_DIR2_DATA_MAGIC; - curbp->b_ops = &xfs_dir3_data_buf_ops; - xfs_trans_buf_set_type(tp, curbp, XFS_BLFT_DIR_DATA_BUF); - } else { - /* If the curbp is not the CI match block, drop it */ - if (state->extrablk.bp != curbp) - xfs_trans_brelse(tp, curbp); - } - } else { - state->extravalid = 0; - } - *indexp = index; - return ENOENT; -} - -/* - * Look up a leaf entry in a node-format leaf block. - * If this is an addname then the extrablk in state is a freespace block, - * otherwise it's a data block. - */ -int -xfs_dir2_leafn_lookup_int( - struct xfs_buf *bp, /* leaf buffer */ - xfs_da_args_t *args, /* operation arguments */ - int *indexp, /* out: leaf entry index */ - xfs_da_state_t *state) /* state to fill in */ -{ - if (args->op_flags & XFS_DA_OP_ADDNAME) - return xfs_dir2_leafn_lookup_for_addname(bp, args, indexp, - state); - return xfs_dir2_leafn_lookup_for_entry(bp, args, indexp, state); -} - -/* - * Move count leaf entries from source to destination leaf. - * Log entries and headers. Stale entries are preserved. - */ -static void -xfs_dir3_leafn_moveents( - xfs_da_args_t *args, /* operation arguments */ - struct xfs_buf *bp_s, /* source */ - struct xfs_dir3_icleaf_hdr *shdr, - struct xfs_dir2_leaf_entry *sents, - int start_s,/* source leaf index */ - struct xfs_buf *bp_d, /* destination */ - struct xfs_dir3_icleaf_hdr *dhdr, - struct xfs_dir2_leaf_entry *dents, - int start_d,/* destination leaf index */ - int count) /* count of leaves to copy */ -{ - int stale; /* count stale leaves copied */ - - trace_xfs_dir2_leafn_moveents(args, start_s, start_d, count); - - /* - * Silently return if nothing to do. - */ - if (count == 0) - return; - - /* - * If the destination index is not the end of the current - * destination leaf entries, open up a hole in the destination - * to hold the new entries. - */ - if (start_d < dhdr->count) { - memmove(&dents[start_d + count], &dents[start_d], - (dhdr->count - start_d) * sizeof(xfs_dir2_leaf_entry_t)); - xfs_dir3_leaf_log_ents(args, bp_d, start_d + count, - count + dhdr->count - 1); - } - /* - * If the source has stale leaves, count the ones in the copy range - * so we can update the header correctly. - */ - if (shdr->stale) { - int i; /* temp leaf index */ - - for (i = start_s, stale = 0; i < start_s + count; i++) { - if (sents[i].address == - cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) - stale++; - } - } else - stale = 0; - /* - * Copy the leaf entries from source to destination. - */ - memcpy(&dents[start_d], &sents[start_s], - count * sizeof(xfs_dir2_leaf_entry_t)); - xfs_dir3_leaf_log_ents(args, bp_d, start_d, start_d + count - 1); - - /* - * If there are source entries after the ones we copied, - * delete the ones we copied by sliding the next ones down. - */ - if (start_s + count < shdr->count) { - memmove(&sents[start_s], &sents[start_s + count], - count * sizeof(xfs_dir2_leaf_entry_t)); - xfs_dir3_leaf_log_ents(args, bp_s, start_s, start_s + count - 1); - } - - /* - * Update the headers and log them. - */ - shdr->count -= count; - shdr->stale -= stale; - dhdr->count += count; - dhdr->stale += stale; -} - -/* - * Determine the sort order of two leaf blocks. - * Returns 1 if both are valid and leaf2 should be before leaf1, else 0. - */ -int /* sort order */ -xfs_dir2_leafn_order( - struct xfs_inode *dp, - struct xfs_buf *leaf1_bp, /* leaf1 buffer */ - struct xfs_buf *leaf2_bp) /* leaf2 buffer */ -{ - struct xfs_dir2_leaf *leaf1 = leaf1_bp->b_addr; - struct xfs_dir2_leaf *leaf2 = leaf2_bp->b_addr; - struct xfs_dir2_leaf_entry *ents1; - struct xfs_dir2_leaf_entry *ents2; - struct xfs_dir3_icleaf_hdr hdr1; - struct xfs_dir3_icleaf_hdr hdr2; - - dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1); - dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2); - ents1 = dp->d_ops->leaf_ents_p(leaf1); - ents2 = dp->d_ops->leaf_ents_p(leaf2); - - if (hdr1.count > 0 && hdr2.count > 0 && - (be32_to_cpu(ents2[0].hashval) < be32_to_cpu(ents1[0].hashval) || - be32_to_cpu(ents2[hdr2.count - 1].hashval) < - be32_to_cpu(ents1[hdr1.count - 1].hashval))) - return 1; - return 0; -} - -/* - * Rebalance leaf entries between two leaf blocks. - * This is actually only called when the second block is new, - * though the code deals with the general case. - * A new entry will be inserted in one of the blocks, and that - * entry is taken into account when balancing. - */ -static void -xfs_dir2_leafn_rebalance( - xfs_da_state_t *state, /* btree cursor */ - xfs_da_state_blk_t *blk1, /* first btree block */ - xfs_da_state_blk_t *blk2) /* second btree block */ -{ - xfs_da_args_t *args; /* operation arguments */ - int count; /* count (& direction) leaves */ - int isleft; /* new goes in left leaf */ - xfs_dir2_leaf_t *leaf1; /* first leaf structure */ - xfs_dir2_leaf_t *leaf2; /* second leaf structure */ - int mid; /* midpoint leaf index */ -#if defined(DEBUG) || defined(XFS_WARN) - int oldstale; /* old count of stale leaves */ -#endif - int oldsum; /* old total leaf count */ - int swap; /* swapped leaf blocks */ - struct xfs_dir2_leaf_entry *ents1; - struct xfs_dir2_leaf_entry *ents2; - struct xfs_dir3_icleaf_hdr hdr1; - struct xfs_dir3_icleaf_hdr hdr2; - struct xfs_inode *dp = state->args->dp; - - args = state->args; - /* - * If the block order is wrong, swap the arguments. - */ - if ((swap = xfs_dir2_leafn_order(dp, blk1->bp, blk2->bp))) { - xfs_da_state_blk_t *tmp; /* temp for block swap */ - - tmp = blk1; - blk1 = blk2; - blk2 = tmp; - } - leaf1 = blk1->bp->b_addr; - leaf2 = blk2->bp->b_addr; - dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1); - dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2); - ents1 = dp->d_ops->leaf_ents_p(leaf1); - ents2 = dp->d_ops->leaf_ents_p(leaf2); - - oldsum = hdr1.count + hdr2.count; -#if defined(DEBUG) || defined(XFS_WARN) - oldstale = hdr1.stale + hdr2.stale; -#endif - mid = oldsum >> 1; - - /* - * If the old leaf count was odd then the new one will be even, - * so we need to divide the new count evenly. - */ - if (oldsum & 1) { - xfs_dahash_t midhash; /* middle entry hash value */ - - if (mid >= hdr1.count) - midhash = be32_to_cpu(ents2[mid - hdr1.count].hashval); - else - midhash = be32_to_cpu(ents1[mid].hashval); - isleft = args->hashval <= midhash; - } - /* - * If the old count is even then the new count is odd, so there's - * no preferred side for the new entry. - * Pick the left one. - */ - else - isleft = 1; - /* - * Calculate moved entry count. Positive means left-to-right, - * negative means right-to-left. Then move the entries. - */ - count = hdr1.count - mid + (isleft == 0); - if (count > 0) - xfs_dir3_leafn_moveents(args, blk1->bp, &hdr1, ents1, - hdr1.count - count, blk2->bp, - &hdr2, ents2, 0, count); - else if (count < 0) - xfs_dir3_leafn_moveents(args, blk2->bp, &hdr2, ents2, 0, - blk1->bp, &hdr1, ents1, - hdr1.count, count); - - ASSERT(hdr1.count + hdr2.count == oldsum); - ASSERT(hdr1.stale + hdr2.stale == oldstale); - - /* log the changes made when moving the entries */ - dp->d_ops->leaf_hdr_to_disk(leaf1, &hdr1); - dp->d_ops->leaf_hdr_to_disk(leaf2, &hdr2); - xfs_dir3_leaf_log_header(args, blk1->bp); - xfs_dir3_leaf_log_header(args, blk2->bp); - - xfs_dir3_leaf_check(dp, blk1->bp); - xfs_dir3_leaf_check(dp, blk2->bp); - - /* - * Mark whether we're inserting into the old or new leaf. - */ - if (hdr1.count < hdr2.count) - state->inleaf = swap; - else if (hdr1.count > hdr2.count) - state->inleaf = !swap; - else - state->inleaf = swap ^ (blk1->index <= hdr1.count); - /* - * Adjust the expected index for insertion. - */ - if (!state->inleaf) - blk2->index = blk1->index - hdr1.count; - - /* - * Finally sanity check just to make sure we are not returning a - * negative index - */ - if (blk2->index < 0) { - state->inleaf = 1; - blk2->index = 0; - xfs_alert(dp->i_mount, - "%s: picked the wrong leaf? reverting original leaf: blk1->index %d", - __func__, blk1->index); - } -} - -static int -xfs_dir3_data_block_free( - xfs_da_args_t *args, - struct xfs_dir2_data_hdr *hdr, - struct xfs_dir2_free *free, - xfs_dir2_db_t fdb, - int findex, - struct xfs_buf *fbp, - int longest) -{ - int logfree = 0; - __be16 *bests; - struct xfs_dir3_icfree_hdr freehdr; - struct xfs_inode *dp = args->dp; - - dp->d_ops->free_hdr_from_disk(&freehdr, free); - bests = dp->d_ops->free_bests_p(free); - if (hdr) { - /* - * Data block is not empty, just set the free entry to the new - * value. - */ - bests[findex] = cpu_to_be16(longest); - xfs_dir2_free_log_bests(args, fbp, findex, findex); - return 0; - } - - /* One less used entry in the free table. */ - freehdr.nused--; - - /* - * If this was the last entry in the table, we can trim the table size - * back. There might be other entries at the end referring to - * non-existent data blocks, get those too. - */ - if (findex == freehdr.nvalid - 1) { - int i; /* free entry index */ - - for (i = findex - 1; i >= 0; i--) { - if (bests[i] != cpu_to_be16(NULLDATAOFF)) - break; - } - freehdr.nvalid = i + 1; - logfree = 0; - } else { - /* Not the last entry, just punch it out. */ - bests[findex] = cpu_to_be16(NULLDATAOFF); - logfree = 1; - } - - dp->d_ops->free_hdr_to_disk(free, &freehdr); - xfs_ |