Linux Audio

Check our new training course

Loading...
Note: File does not exist in v6.13.7.
   1/*
   2 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
   3 * Copyright (c) 2013 Red Hat, Inc.
   4 * All Rights Reserved.
   5 *
   6 * This program is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU General Public License as
   8 * published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope that it would be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public License
  16 * along with this program; if not, write the Free Software Foundation,
  17 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18 */
  19#include "xfs.h"
  20#include "xfs_fs.h"
  21#include "xfs_format.h"
  22#include "xfs_log_format.h"
  23#include "xfs_trans_resv.h"
  24#include "xfs_sb.h"
  25#include "xfs_ag.h"
  26#include "xfs_mount.h"
  27#include "xfs_da_format.h"
  28#include "xfs_da_btree.h"
  29#include "xfs_inode.h"
  30#include "xfs_bmap.h"
  31#include "xfs_dir2.h"
  32#include "xfs_dir2_priv.h"
  33#include "xfs_error.h"
  34#include "xfs_trace.h"
  35#include "xfs_trans.h"
  36#include "xfs_buf_item.h"
  37#include "xfs_cksum.h"
  38
  39/*
  40 * Local function declarations.
  41 */
  42static int xfs_dir2_leaf_lookup_int(xfs_da_args_t *args, struct xfs_buf **lbpp,
  43				    int *indexp, struct xfs_buf **dbpp);
  44static void xfs_dir3_leaf_log_bests(struct xfs_trans *tp, struct xfs_buf *bp,
  45				    int first, int last);
  46static void xfs_dir3_leaf_log_tail(struct xfs_trans *tp, struct xfs_buf *bp);
  47
  48/*
  49 * Check the internal consistency of a leaf1 block.
  50 * Pop an assert if something is wrong.
  51 */
  52#ifdef DEBUG
  53#define	xfs_dir3_leaf_check(dp, bp) \
  54do { \
  55	if (!xfs_dir3_leaf1_check((dp), (bp))) \
  56		ASSERT(0); \
  57} while (0);
  58
  59STATIC bool
  60xfs_dir3_leaf1_check(
  61	struct xfs_inode	*dp,
  62	struct xfs_buf		*bp)
  63{
  64	struct xfs_dir2_leaf	*leaf = bp->b_addr;
  65	struct xfs_dir3_icleaf_hdr leafhdr;
  66
  67	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
  68
  69	if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
  70		struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
  71		if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn)
  72			return false;
  73	} else if (leafhdr.magic != XFS_DIR2_LEAF1_MAGIC)
  74		return false;
  75
  76	return xfs_dir3_leaf_check_int(dp->i_mount, dp, &leafhdr, leaf);
  77}
  78#else
  79#define	xfs_dir3_leaf_check(dp, bp)
  80#endif
  81
  82bool
  83xfs_dir3_leaf_check_int(
  84	struct xfs_mount	*mp,
  85	struct xfs_inode	*dp,
  86	struct xfs_dir3_icleaf_hdr *hdr,
  87	struct xfs_dir2_leaf	*leaf)
  88{
  89	struct xfs_dir2_leaf_entry *ents;
  90	xfs_dir2_leaf_tail_t	*ltp;
  91	int			stale;
  92	int			i;
  93	const struct xfs_dir_ops *ops;
  94	struct xfs_dir3_icleaf_hdr leafhdr;
  95
  96	/*
  97	 * we can be passed a null dp here from a verifier, so we need to go the
  98	 * hard way to get them.
  99	 */
 100	ops = xfs_dir_get_ops(mp, dp);
 101
 102	if (!hdr) {
 103		ops->leaf_hdr_from_disk(&leafhdr, leaf);
 104		hdr = &leafhdr;
 105	}
 106
 107	ents = ops->leaf_ents_p(leaf);
 108	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 109
 110	/*
 111	 * XXX (dgc): This value is not restrictive enough.
 112	 * Should factor in the size of the bests table as well.
 113	 * We can deduce a value for that from di_size.
 114	 */
 115	if (hdr->count > ops->leaf_max_ents(mp))
 116		return false;
 117
 118	/* Leaves and bests don't overlap in leaf format. */
 119	if ((hdr->magic == XFS_DIR2_LEAF1_MAGIC ||
 120	     hdr->magic == XFS_DIR3_LEAF1_MAGIC) &&
 121	    (char *)&ents[hdr->count] > (char *)xfs_dir2_leaf_bests_p(ltp))
 122		return false;
 123
 124	/* Check hash value order, count stale entries.  */
 125	for (i = stale = 0; i < hdr->count; i++) {
 126		if (i + 1 < hdr->count) {
 127			if (be32_to_cpu(ents[i].hashval) >
 128					be32_to_cpu(ents[i + 1].hashval))
 129				return false;
 130		}
 131		if (ents[i].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
 132			stale++;
 133	}
 134	if (hdr->stale != stale)
 135		return false;
 136	return true;
 137}
 138
 139/*
 140 * We verify the magic numbers before decoding the leaf header so that on debug
 141 * kernels we don't get assertion failures in xfs_dir3_leaf_hdr_from_disk() due
 142 * to incorrect magic numbers.
 143 */
 144static bool
 145xfs_dir3_leaf_verify(
 146	struct xfs_buf		*bp,
 147	__uint16_t		magic)
 148{
 149	struct xfs_mount	*mp = bp->b_target->bt_mount;
 150	struct xfs_dir2_leaf	*leaf = bp->b_addr;
 151
 152	ASSERT(magic == XFS_DIR2_LEAF1_MAGIC || magic == XFS_DIR2_LEAFN_MAGIC);
 153
 154	if (xfs_sb_version_hascrc(&mp->m_sb)) {
 155		struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
 156		__uint16_t		magic3;
 157
 158		magic3 = (magic == XFS_DIR2_LEAF1_MAGIC) ? XFS_DIR3_LEAF1_MAGIC
 159							 : XFS_DIR3_LEAFN_MAGIC;
 160
 161		if (leaf3->info.hdr.magic != cpu_to_be16(magic3))
 162			return false;
 163		if (!uuid_equal(&leaf3->info.uuid, &mp->m_sb.sb_uuid))
 164			return false;
 165		if (be64_to_cpu(leaf3->info.blkno) != bp->b_bn)
 166			return false;
 167	} else {
 168		if (leaf->hdr.info.magic != cpu_to_be16(magic))
 169			return false;
 170	}
 171
 172	return xfs_dir3_leaf_check_int(mp, NULL, NULL, leaf);
 173}
 174
 175static void
 176__read_verify(
 177	struct xfs_buf  *bp,
 178	__uint16_t	magic)
 179{
 180	struct xfs_mount	*mp = bp->b_target->bt_mount;
 181
 182	if (xfs_sb_version_hascrc(&mp->m_sb) &&
 183	     !xfs_buf_verify_cksum(bp, XFS_DIR3_LEAF_CRC_OFF))
 184		xfs_buf_ioerror(bp, EFSBADCRC);
 185	else if (!xfs_dir3_leaf_verify(bp, magic))
 186		xfs_buf_ioerror(bp, EFSCORRUPTED);
 187
 188	if (bp->b_error)
 189		xfs_verifier_error(bp);
 190}
 191
 192static void
 193__write_verify(
 194	struct xfs_buf  *bp,
 195	__uint16_t	magic)
 196{
 197	struct xfs_mount	*mp = bp->b_target->bt_mount;
 198	struct xfs_buf_log_item	*bip = bp->b_fspriv;
 199	struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
 200
 201	if (!xfs_dir3_leaf_verify(bp, magic)) {
 202		xfs_buf_ioerror(bp, EFSCORRUPTED);
 203		xfs_verifier_error(bp);
 204		return;
 205	}
 206
 207	if (!xfs_sb_version_hascrc(&mp->m_sb))
 208		return;
 209
 210	if (bip)
 211		hdr3->info.lsn = cpu_to_be64(bip->bli_item.li_lsn);
 212
 213	xfs_buf_update_cksum(bp, XFS_DIR3_LEAF_CRC_OFF);
 214}
 215
 216static void
 217xfs_dir3_leaf1_read_verify(
 218	struct xfs_buf	*bp)
 219{
 220	__read_verify(bp, XFS_DIR2_LEAF1_MAGIC);
 221}
 222
 223static void
 224xfs_dir3_leaf1_write_verify(
 225	struct xfs_buf	*bp)
 226{
 227	__write_verify(bp, XFS_DIR2_LEAF1_MAGIC);
 228}
 229
 230static void
 231xfs_dir3_leafn_read_verify(
 232	struct xfs_buf	*bp)
 233{
 234	__read_verify(bp, XFS_DIR2_LEAFN_MAGIC);
 235}
 236
 237static void
 238xfs_dir3_leafn_write_verify(
 239	struct xfs_buf	*bp)
 240{
 241	__write_verify(bp, XFS_DIR2_LEAFN_MAGIC);
 242}
 243
 244const struct xfs_buf_ops xfs_dir3_leaf1_buf_ops = {
 245	.verify_read = xfs_dir3_leaf1_read_verify,
 246	.verify_write = xfs_dir3_leaf1_write_verify,
 247};
 248
 249const struct xfs_buf_ops xfs_dir3_leafn_buf_ops = {
 250	.verify_read = xfs_dir3_leafn_read_verify,
 251	.verify_write = xfs_dir3_leafn_write_verify,
 252};
 253
 254static int
 255xfs_dir3_leaf_read(
 256	struct xfs_trans	*tp,
 257	struct xfs_inode	*dp,
 258	xfs_dablk_t		fbno,
 259	xfs_daddr_t		mappedbno,
 260	struct xfs_buf		**bpp)
 261{
 262	int			err;
 263
 264	err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
 265				XFS_DATA_FORK, &xfs_dir3_leaf1_buf_ops);
 266	if (!err && tp)
 267		xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_LEAF1_BUF);
 268	return err;
 269}
 270
 271int
 272xfs_dir3_leafn_read(
 273	struct xfs_trans	*tp,
 274	struct xfs_inode	*dp,
 275	xfs_dablk_t		fbno,
 276	xfs_daddr_t		mappedbno,
 277	struct xfs_buf		**bpp)
 278{
 279	int			err;
 280
 281	err = xfs_da_read_buf(tp, dp, fbno, mappedbno, bpp,
 282				XFS_DATA_FORK, &xfs_dir3_leafn_buf_ops);
 283	if (!err && tp)
 284		xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_LEAFN_BUF);
 285	return err;
 286}
 287
 288/*
 289 * Initialize a new leaf block, leaf1 or leafn magic accepted.
 290 */
 291static void
 292xfs_dir3_leaf_init(
 293	struct xfs_mount	*mp,
 294	struct xfs_trans	*tp,
 295	struct xfs_buf		*bp,
 296	xfs_ino_t		owner,
 297	__uint16_t		type)
 298{
 299	struct xfs_dir2_leaf	*leaf = bp->b_addr;
 300
 301	ASSERT(type == XFS_DIR2_LEAF1_MAGIC || type == XFS_DIR2_LEAFN_MAGIC);
 302
 303	if (xfs_sb_version_hascrc(&mp->m_sb)) {
 304		struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
 305
 306		memset(leaf3, 0, sizeof(*leaf3));
 307
 308		leaf3->info.hdr.magic = (type == XFS_DIR2_LEAF1_MAGIC)
 309					 ? cpu_to_be16(XFS_DIR3_LEAF1_MAGIC)
 310					 : cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
 311		leaf3->info.blkno = cpu_to_be64(bp->b_bn);
 312		leaf3->info.owner = cpu_to_be64(owner);
 313		uuid_copy(&leaf3->info.uuid, &mp->m_sb.sb_uuid);
 314	} else {
 315		memset(leaf, 0, sizeof(*leaf));
 316		leaf->hdr.info.magic = cpu_to_be16(type);
 317	}
 318
 319	/*
 320	 * If it's a leaf-format directory initialize the tail.
 321	 * Caller is responsible for initialising the bests table.
 322	 */
 323	if (type == XFS_DIR2_LEAF1_MAGIC) {
 324		struct xfs_dir2_leaf_tail *ltp;
 325
 326		ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 327		ltp->bestcount = 0;
 328		bp->b_ops = &xfs_dir3_leaf1_buf_ops;
 329		xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAF1_BUF);
 330	} else {
 331		bp->b_ops = &xfs_dir3_leafn_buf_ops;
 332		xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_LEAFN_BUF);
 333	}
 334}
 335
 336int
 337xfs_dir3_leaf_get_buf(
 338	xfs_da_args_t		*args,
 339	xfs_dir2_db_t		bno,
 340	struct xfs_buf		**bpp,
 341	__uint16_t		magic)
 342{
 343	struct xfs_inode	*dp = args->dp;
 344	struct xfs_trans	*tp = args->trans;
 345	struct xfs_mount	*mp = dp->i_mount;
 346	struct xfs_buf		*bp;
 347	int			error;
 348
 349	ASSERT(magic == XFS_DIR2_LEAF1_MAGIC || magic == XFS_DIR2_LEAFN_MAGIC);
 350	ASSERT(bno >= XFS_DIR2_LEAF_FIRSTDB(mp) &&
 351	       bno < XFS_DIR2_FREE_FIRSTDB(mp));
 352
 353	error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, bno), -1, &bp,
 354			       XFS_DATA_FORK);
 355	if (error)
 356		return error;
 357
 358	xfs_dir3_leaf_init(mp, tp, bp, dp->i_ino, magic);
 359	xfs_dir3_leaf_log_header(tp, dp, bp);
 360	if (magic == XFS_DIR2_LEAF1_MAGIC)
 361		xfs_dir3_leaf_log_tail(tp, bp);
 362	*bpp = bp;
 363	return 0;
 364}
 365
 366/*
 367 * Convert a block form directory to a leaf form directory.
 368 */
 369int						/* error */
 370xfs_dir2_block_to_leaf(
 371	xfs_da_args_t		*args,		/* operation arguments */
 372	struct xfs_buf		*dbp)		/* input block's buffer */
 373{
 374	__be16			*bestsp;	/* leaf's bestsp entries */
 375	xfs_dablk_t		blkno;		/* leaf block's bno */
 376	xfs_dir2_data_hdr_t	*hdr;		/* block header */
 377	xfs_dir2_leaf_entry_t	*blp;		/* block's leaf entries */
 378	xfs_dir2_block_tail_t	*btp;		/* block's tail */
 379	xfs_inode_t		*dp;		/* incore directory inode */
 380	int			error;		/* error return code */
 381	struct xfs_buf		*lbp;		/* leaf block's buffer */
 382	xfs_dir2_db_t		ldb;		/* leaf block's bno */
 383	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 384	xfs_dir2_leaf_tail_t	*ltp;		/* leaf's tail */
 385	xfs_mount_t		*mp;		/* filesystem mount point */
 386	int			needlog;	/* need to log block header */
 387	int			needscan;	/* need to rescan bestfree */
 388	xfs_trans_t		*tp;		/* transaction pointer */
 389	struct xfs_dir2_data_free *bf;
 390	struct xfs_dir2_leaf_entry *ents;
 391	struct xfs_dir3_icleaf_hdr leafhdr;
 392
 393	trace_xfs_dir2_block_to_leaf(args);
 394
 395	dp = args->dp;
 396	mp = dp->i_mount;
 397	tp = args->trans;
 398	/*
 399	 * Add the leaf block to the inode.
 400	 * This interface will only put blocks in the leaf/node range.
 401	 * Since that's empty now, we'll get the root (block 0 in range).
 402	 */
 403	if ((error = xfs_da_grow_inode(args, &blkno))) {
 404		return error;
 405	}
 406	ldb = xfs_dir2_da_to_db(mp, blkno);
 407	ASSERT(ldb == XFS_DIR2_LEAF_FIRSTDB(mp));
 408	/*
 409	 * Initialize the leaf block, get a buffer for it.
 410	 */
 411	error = xfs_dir3_leaf_get_buf(args, ldb, &lbp, XFS_DIR2_LEAF1_MAGIC);
 412	if (error)
 413		return error;
 414
 415	leaf = lbp->b_addr;
 416	hdr = dbp->b_addr;
 417	xfs_dir3_data_check(dp, dbp);
 418	btp = xfs_dir2_block_tail_p(mp, hdr);
 419	blp = xfs_dir2_block_leaf_p(btp);
 420	bf = dp->d_ops->data_bestfree_p(hdr);
 421	ents = dp->d_ops->leaf_ents_p(leaf);
 422
 423	/*
 424	 * Set the counts in the leaf header.
 425	 */
 426	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 427	leafhdr.count = be32_to_cpu(btp->count);
 428	leafhdr.stale = be32_to_cpu(btp->stale);
 429	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
 430	xfs_dir3_leaf_log_header(tp, dp, lbp);
 431
 432	/*
 433	 * Could compact these but I think we always do the conversion
 434	 * after squeezing out stale entries.
 435	 */
 436	memcpy(ents, blp, be32_to_cpu(btp->count) * sizeof(xfs_dir2_leaf_entry_t));
 437	xfs_dir3_leaf_log_ents(tp, dp, lbp, 0, leafhdr.count - 1);
 438	needscan = 0;
 439	needlog = 1;
 440	/*
 441	 * Make the space formerly occupied by the leaf entries and block
 442	 * tail be free.
 443	 */
 444	xfs_dir2_data_make_free(tp, dp, dbp,
 445		(xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
 446		(xfs_dir2_data_aoff_t)((char *)hdr + mp->m_dirblksize -
 447				       (char *)blp),
 448		&needlog, &needscan);
 449	/*
 450	 * Fix up the block header, make it a data block.
 451	 */
 452	dbp->b_ops = &xfs_dir3_data_buf_ops;
 453	xfs_trans_buf_set_type(tp, dbp, XFS_BLFT_DIR_DATA_BUF);
 454	if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))
 455		hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 456	else
 457		hdr->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
 458
 459	if (needscan)
 460		xfs_dir2_data_freescan(dp, hdr, &needlog);
 461	/*
 462	 * Set up leaf tail and bests table.
 463	 */
 464	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 465	ltp->bestcount = cpu_to_be32(1);
 466	bestsp = xfs_dir2_leaf_bests_p(ltp);
 467	bestsp[0] =  bf[0].length;
 468	/*
 469	 * Log the data header and leaf bests table.
 470	 */
 471	if (needlog)
 472		xfs_dir2_data_log_header(tp, dp, dbp);
 473	xfs_dir3_leaf_check(dp, lbp);
 474	xfs_dir3_data_check(dp, dbp);
 475	xfs_dir3_leaf_log_bests(tp, lbp, 0, 0);
 476	return 0;
 477}
 478
 479STATIC void
 480xfs_dir3_leaf_find_stale(
 481	struct xfs_dir3_icleaf_hdr *leafhdr,
 482	struct xfs_dir2_leaf_entry *ents,
 483	int			index,
 484	int			*lowstale,
 485	int			*highstale)
 486{
 487	/*
 488	 * Find the first stale entry before our index, if any.
 489	 */
 490	for (*lowstale = index - 1; *lowstale >= 0; --*lowstale) {
 491		if (ents[*lowstale].address ==
 492		    cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
 493			break;
 494	}
 495
 496	/*
 497	 * Find the first stale entry at or after our index, if any.
 498	 * Stop if the result would require moving more entries than using
 499	 * lowstale.
 500	 */
 501	for (*highstale = index; *highstale < leafhdr->count; ++*highstale) {
 502		if (ents[*highstale].address ==
 503		    cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
 504			break;
 505		if (*lowstale >= 0 && index - *lowstale <= *highstale - index)
 506			break;
 507	}
 508}
 509
 510struct xfs_dir2_leaf_entry *
 511xfs_dir3_leaf_find_entry(
 512	struct xfs_dir3_icleaf_hdr *leafhdr,
 513	struct xfs_dir2_leaf_entry *ents,
 514	int			index,		/* leaf table position */
 515	int			compact,	/* need to compact leaves */
 516	int			lowstale,	/* index of prev stale leaf */
 517	int			highstale,	/* index of next stale leaf */
 518	int			*lfloglow,	/* low leaf logging index */
 519	int			*lfloghigh)	/* high leaf logging index */
 520{
 521	if (!leafhdr->stale) {
 522		xfs_dir2_leaf_entry_t	*lep;	/* leaf entry table pointer */
 523
 524		/*
 525		 * Now we need to make room to insert the leaf entry.
 526		 *
 527		 * If there are no stale entries, just insert a hole at index.
 528		 */
 529		lep = &ents[index];
 530		if (index < leafhdr->count)
 531			memmove(lep + 1, lep,
 532				(leafhdr->count - index) * sizeof(*lep));
 533
 534		/*
 535		 * Record low and high logging indices for the leaf.
 536		 */
 537		*lfloglow = index;
 538		*lfloghigh = leafhdr->count++;
 539		return lep;
 540	}
 541
 542	/*
 543	 * There are stale entries.
 544	 *
 545	 * We will use one of them for the new entry.  It's probably not at
 546	 * the right location, so we'll have to shift some up or down first.
 547	 *
 548	 * If we didn't compact before, we need to find the nearest stale
 549	 * entries before and after our insertion point.
 550	 */
 551	if (compact == 0)
 552		xfs_dir3_leaf_find_stale(leafhdr, ents, index,
 553					 &lowstale, &highstale);
 554
 555	/*
 556	 * If the low one is better, use it.
 557	 */
 558	if (lowstale >= 0 &&
 559	    (highstale == leafhdr->count ||
 560	     index - lowstale - 1 < highstale - index)) {
 561		ASSERT(index - lowstale - 1 >= 0);
 562		ASSERT(ents[lowstale].address ==
 563		       cpu_to_be32(XFS_DIR2_NULL_DATAPTR));
 564
 565		/*
 566		 * Copy entries up to cover the stale entry and make room
 567		 * for the new entry.
 568		 */
 569		if (index - lowstale - 1 > 0) {
 570			memmove(&ents[lowstale], &ents[lowstale + 1],
 571				(index - lowstale - 1) *
 572					sizeof(xfs_dir2_leaf_entry_t));
 573		}
 574		*lfloglow = MIN(lowstale, *lfloglow);
 575		*lfloghigh = MAX(index - 1, *lfloghigh);
 576		leafhdr->stale--;
 577		return &ents[index - 1];
 578	}
 579
 580	/*
 581	 * The high one is better, so use that one.
 582	 */
 583	ASSERT(highstale - index >= 0);
 584	ASSERT(ents[highstale].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR));
 585
 586	/*
 587	 * Copy entries down to cover the stale entry and make room for the
 588	 * new entry.
 589	 */
 590	if (highstale - index > 0) {
 591		memmove(&ents[index + 1], &ents[index],
 592			(highstale - index) * sizeof(xfs_dir2_leaf_entry_t));
 593	}
 594	*lfloglow = MIN(index, *lfloglow);
 595	*lfloghigh = MAX(highstale, *lfloghigh);
 596	leafhdr->stale--;
 597	return &ents[index];
 598}
 599
 600/*
 601 * Add an entry to a leaf form directory.
 602 */
 603int						/* error */
 604xfs_dir2_leaf_addname(
 605	xfs_da_args_t		*args)		/* operation arguments */
 606{
 607	__be16			*bestsp;	/* freespace table in leaf */
 608	int			compact;	/* need to compact leaves */
 609	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
 610	struct xfs_buf		*dbp;		/* data block buffer */
 611	xfs_dir2_data_entry_t	*dep;		/* data block entry */
 612	xfs_inode_t		*dp;		/* incore directory inode */
 613	xfs_dir2_data_unused_t	*dup;		/* data unused entry */
 614	int			error;		/* error return value */
 615	int			grown;		/* allocated new data block */
 616	int			highstale;	/* index of next stale leaf */
 617	int			i;		/* temporary, index */
 618	int			index;		/* leaf table position */
 619	struct xfs_buf		*lbp;		/* leaf's buffer */
 620	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
 621	int			length;		/* length of new entry */
 622	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry table pointer */
 623	int			lfloglow;	/* low leaf logging index */
 624	int			lfloghigh;	/* high leaf logging index */
 625	int			lowstale;	/* index of prev stale leaf */
 626	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail pointer */
 627	xfs_mount_t		*mp;		/* filesystem mount point */
 628	int			needbytes;	/* leaf block bytes needed */
 629	int			needlog;	/* need to log data header */
 630	int			needscan;	/* need to rescan data free */
 631	__be16			*tagp;		/* end of data entry */
 632	xfs_trans_t		*tp;		/* transaction pointer */
 633	xfs_dir2_db_t		use_block;	/* data block number */
 634	struct xfs_dir2_data_free *bf;		/* bestfree table */
 635	struct xfs_dir2_leaf_entry *ents;
 636	struct xfs_dir3_icleaf_hdr leafhdr;
 637
 638	trace_xfs_dir2_leaf_addname(args);
 639
 640	dp = args->dp;
 641	tp = args->trans;
 642	mp = dp->i_mount;
 643
 644	error = xfs_dir3_leaf_read(tp, dp, mp->m_dirleafblk, -1, &lbp);
 645	if (error)
 646		return error;
 647
 648	/*
 649	 * Look up the entry by hash value and name.
 650	 * We know it's not there, our caller has already done a lookup.
 651	 * So the index is of the entry to insert in front of.
 652	 * But if there are dup hash values the index is of the first of those.
 653	 */
 654	index = xfs_dir2_leaf_search_hash(args, lbp);
 655	leaf = lbp->b_addr;
 656	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 657	ents = dp->d_ops->leaf_ents_p(leaf);
 658	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 659	bestsp = xfs_dir2_leaf_bests_p(ltp);
 660	length = dp->d_ops->data_entsize(args->namelen);
 661
 662	/*
 663	 * See if there are any entries with the same hash value
 664	 * and space in their block for the new entry.
 665	 * This is good because it puts multiple same-hash value entries
 666	 * in a data block, improving the lookup of those entries.
 667	 */
 668	for (use_block = -1, lep = &ents[index];
 669	     index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
 670	     index++, lep++) {
 671		if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
 672			continue;
 673		i = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
 674		ASSERT(i < be32_to_cpu(ltp->bestcount));
 675		ASSERT(bestsp[i] != cpu_to_be16(NULLDATAOFF));
 676		if (be16_to_cpu(bestsp[i]) >= length) {
 677			use_block = i;
 678			break;
 679		}
 680	}
 681	/*
 682	 * Didn't find a block yet, linear search all the data blocks.
 683	 */
 684	if (use_block == -1) {
 685		for (i = 0; i < be32_to_cpu(ltp->bestcount); i++) {
 686			/*
 687			 * Remember a block we see that's missing.
 688			 */
 689			if (bestsp[i] == cpu_to_be16(NULLDATAOFF) &&
 690			    use_block == -1)
 691				use_block = i;
 692			else if (be16_to_cpu(bestsp[i]) >= length) {
 693				use_block = i;
 694				break;
 695			}
 696		}
 697	}
 698	/*
 699	 * How many bytes do we need in the leaf block?
 700	 */
 701	needbytes = 0;
 702	if (!leafhdr.stale)
 703		needbytes += sizeof(xfs_dir2_leaf_entry_t);
 704	if (use_block == -1)
 705		needbytes += sizeof(xfs_dir2_data_off_t);
 706
 707	/*
 708	 * Now kill use_block if it refers to a missing block, so we
 709	 * can use it as an indication of allocation needed.
 710	 */
 711	if (use_block != -1 && bestsp[use_block] == cpu_to_be16(NULLDATAOFF))
 712		use_block = -1;
 713	/*
 714	 * If we don't have enough free bytes but we can make enough
 715	 * by compacting out stale entries, we'll do that.
 716	 */
 717	if ((char *)bestsp - (char *)&ents[leafhdr.count] < needbytes &&
 718	    leafhdr.stale > 1)
 719		compact = 1;
 720
 721	/*
 722	 * Otherwise if we don't have enough free bytes we need to
 723	 * convert to node form.
 724	 */
 725	else if ((char *)bestsp - (char *)&ents[leafhdr.count] < needbytes) {
 726		/*
 727		 * Just checking or no space reservation, give up.
 728		 */
 729		if ((args->op_flags & XFS_DA_OP_JUSTCHECK) ||
 730							args->total == 0) {
 731			xfs_trans_brelse(tp, lbp);
 732			return XFS_ERROR(ENOSPC);
 733		}
 734		/*
 735		 * Convert to node form.
 736		 */
 737		error = xfs_dir2_leaf_to_node(args, lbp);
 738		if (error)
 739			return error;
 740		/*
 741		 * Then add the new entry.
 742		 */
 743		return xfs_dir2_node_addname(args);
 744	}
 745	/*
 746	 * Otherwise it will fit without compaction.
 747	 */
 748	else
 749		compact = 0;
 750	/*
 751	 * If just checking, then it will fit unless we needed to allocate
 752	 * a new data block.
 753	 */
 754	if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
 755		xfs_trans_brelse(tp, lbp);
 756		return use_block == -1 ? XFS_ERROR(ENOSPC) : 0;
 757	}
 758	/*
 759	 * If no allocations are allowed, return now before we've
 760	 * changed anything.
 761	 */
 762	if (args->total == 0 && use_block == -1) {
 763		xfs_trans_brelse(tp, lbp);
 764		return XFS_ERROR(ENOSPC);
 765	}
 766	/*
 767	 * Need to compact the leaf entries, removing stale ones.
 768	 * Leave one stale entry behind - the one closest to our
 769	 * insertion index - and we'll shift that one to our insertion
 770	 * point later.
 771	 */
 772	if (compact) {
 773		xfs_dir3_leaf_compact_x1(&leafhdr, ents, &index, &lowstale,
 774			&highstale, &lfloglow, &lfloghigh);
 775	}
 776	/*
 777	 * There are stale entries, so we'll need log-low and log-high
 778	 * impossibly bad values later.
 779	 */
 780	else if (leafhdr.stale) {
 781		lfloglow = leafhdr.count;
 782		lfloghigh = -1;
 783	}
 784	/*
 785	 * If there was no data block space found, we need to allocate
 786	 * a new one.
 787	 */
 788	if (use_block == -1) {
 789		/*
 790		 * Add the new data block.
 791		 */
 792		if ((error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE,
 793				&use_block))) {
 794			xfs_trans_brelse(tp, lbp);
 795			return error;
 796		}
 797		/*
 798		 * Initialize the block.
 799		 */
 800		if ((error = xfs_dir3_data_init(args, use_block, &dbp))) {
 801			xfs_trans_brelse(tp, lbp);
 802			return error;
 803		}
 804		/*
 805		 * If we're adding a new data block on the end we need to
 806		 * extend the bests table.  Copy it up one entry.
 807		 */
 808		if (use_block >= be32_to_cpu(ltp->bestcount)) {
 809			bestsp--;
 810			memmove(&bestsp[0], &bestsp[1],
 811				be32_to_cpu(ltp->bestcount) * sizeof(bestsp[0]));
 812			be32_add_cpu(&ltp->bestcount, 1);
 813			xfs_dir3_leaf_log_tail(tp, lbp);
 814			xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
 815		}
 816		/*
 817		 * If we're filling in a previously empty block just log it.
 818		 */
 819		else
 820			xfs_dir3_leaf_log_bests(tp, lbp, use_block, use_block);
 821		hdr = dbp->b_addr;
 822		bf = dp->d_ops->data_bestfree_p(hdr);
 823		bestsp[use_block] = bf[0].length;
 824		grown = 1;
 825	} else {
 826		/*
 827		 * Already had space in some data block.
 828		 * Just read that one in.
 829		 */
 830		error = xfs_dir3_data_read(tp, dp,
 831					   xfs_dir2_db_to_da(mp, use_block),
 832					   -1, &dbp);
 833		if (error) {
 834			xfs_trans_brelse(tp, lbp);
 835			return error;
 836		}
 837		hdr = dbp->b_addr;
 838		bf = dp->d_ops->data_bestfree_p(hdr);
 839		grown = 0;
 840	}
 841	/*
 842	 * Point to the biggest freespace in our data block.
 843	 */
 844	dup = (xfs_dir2_data_unused_t *)
 845	      ((char *)hdr + be16_to_cpu(bf[0].offset));
 846	ASSERT(be16_to_cpu(dup->length) >= length);
 847	needscan = needlog = 0;
 848	/*
 849	 * Mark the initial part of our freespace in use for the new entry.
 850	 */
 851	xfs_dir2_data_use_free(tp, dp, dbp, dup,
 852		(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
 853		&needlog, &needscan);
 854	/*
 855	 * Initialize our new entry (at last).
 856	 */
 857	dep = (xfs_dir2_data_entry_t *)dup;
 858	dep->inumber = cpu_to_be64(args->inumber);
 859	dep->namelen = args->namelen;
 860	memcpy(dep->name, args->name, dep->namelen);
 861	dp->d_ops->data_put_ftype(dep, args->filetype);
 862	tagp = dp->d_ops->data_entry_tag_p(dep);
 863	*tagp = cpu_to_be16((char *)dep - (char *)hdr);
 864	/*
 865	 * Need to scan fix up the bestfree table.
 866	 */
 867	if (needscan)
 868		xfs_dir2_data_freescan(dp, hdr, &needlog);
 869	/*
 870	 * Need to log the data block's header.
 871	 */
 872	if (needlog)
 873		xfs_dir2_data_log_header(tp, dp, dbp);
 874	xfs_dir2_data_log_entry(tp, dp, dbp, dep);
 875	/*
 876	 * If the bests table needs to be changed, do it.
 877	 * Log the change unless we've already done that.
 878	 */
 879	if (be16_to_cpu(bestsp[use_block]) != be16_to_cpu(bf[0].length)) {
 880		bestsp[use_block] = bf[0].length;
 881		if (!grown)
 882			xfs_dir3_leaf_log_bests(tp, lbp, use_block, use_block);
 883	}
 884
 885	lep = xfs_dir3_leaf_find_entry(&leafhdr, ents, index, compact, lowstale,
 886				       highstale, &lfloglow, &lfloghigh);
 887
 888	/*
 889	 * Fill in the new leaf entry.
 890	 */
 891	lep->hashval = cpu_to_be32(args->hashval);
 892	lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp, use_block,
 893				be16_to_cpu(*tagp)));
 894	/*
 895	 * Log the leaf fields and give up the buffers.
 896	 */
 897	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
 898	xfs_dir3_leaf_log_header(tp, dp, lbp);
 899	xfs_dir3_leaf_log_ents(tp, dp, lbp, lfloglow, lfloghigh);
 900	xfs_dir3_leaf_check(dp, lbp);
 901	xfs_dir3_data_check(dp, dbp);
 902	return 0;
 903}
 904
 905/*
 906 * Compact out any stale entries in the leaf.
 907 * Log the header and changed leaf entries, if any.
 908 */
 909void
 910xfs_dir3_leaf_compact(
 911	xfs_da_args_t	*args,		/* operation arguments */
 912	struct xfs_dir3_icleaf_hdr *leafhdr,
 913	struct xfs_buf	*bp)		/* leaf buffer */
 914{
 915	int		from;		/* source leaf index */
 916	xfs_dir2_leaf_t	*leaf;		/* leaf structure */
 917	int		loglow;		/* first leaf entry to log */
 918	int		to;		/* target leaf index */
 919	struct xfs_dir2_leaf_entry *ents;
 920	struct xfs_inode *dp = args->dp;
 921
 922	leaf = bp->b_addr;
 923	if (!leafhdr->stale)
 924		return;
 925
 926	/*
 927	 * Compress out the stale entries in place.
 928	 */
 929	ents = dp->d_ops->leaf_ents_p(leaf);
 930	for (from = to = 0, loglow = -1; from < leafhdr->count; from++) {
 931		if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
 932			continue;
 933		/*
 934		 * Only actually copy the entries that are different.
 935		 */
 936		if (from > to) {
 937			if (loglow == -1)
 938				loglow = to;
 939			ents[to] = ents[from];
 940		}
 941		to++;
 942	}
 943	/*
 944	 * Update and log the header, log the leaf entries.
 945	 */
 946	ASSERT(leafhdr->stale == from - to);
 947	leafhdr->count -= leafhdr->stale;
 948	leafhdr->stale = 0;
 949
 950	dp->d_ops->leaf_hdr_to_disk(leaf, leafhdr);
 951	xfs_dir3_leaf_log_header(args->trans, dp, bp);
 952	if (loglow != -1)
 953		xfs_dir3_leaf_log_ents(args->trans, dp, bp, loglow, to - 1);
 954}
 955
 956/*
 957 * Compact the leaf entries, removing stale ones.
 958 * Leave one stale entry behind - the one closest to our
 959 * insertion index - and the caller will shift that one to our insertion
 960 * point later.
 961 * Return new insertion index, where the remaining stale entry is,
 962 * and leaf logging indices.
 963 */
 964void
 965xfs_dir3_leaf_compact_x1(
 966	struct xfs_dir3_icleaf_hdr *leafhdr,
 967	struct xfs_dir2_leaf_entry *ents,
 968	int		*indexp,	/* insertion index */
 969	int		*lowstalep,	/* out: stale entry before us */
 970	int		*highstalep,	/* out: stale entry after us */
 971	int		*lowlogp,	/* out: low log index */
 972	int		*highlogp)	/* out: high log index */
 973{
 974	int		from;		/* source copy index */
 975	int		highstale;	/* stale entry at/after index */
 976	int		index;		/* insertion index */
 977	int		keepstale;	/* source index of kept stale */
 978	int		lowstale;	/* stale entry before index */
 979	int		newindex=0;	/* new insertion index */
 980	int		to;		/* destination copy index */
 981
 982	ASSERT(leafhdr->stale > 1);
 983	index = *indexp;
 984
 985	xfs_dir3_leaf_find_stale(leafhdr, ents, index, &lowstale, &highstale);
 986
 987	/*
 988	 * Pick the better of lowstale and highstale.
 989	 */
 990	if (lowstale >= 0 &&
 991	    (highstale == leafhdr->count ||
 992	     index - lowstale <= highstale - index))
 993		keepstale = lowstale;
 994	else
 995		keepstale = highstale;
 996	/*
 997	 * Copy the entries in place, removing all the stale entries
 998	 * except keepstale.
 999	 */
1000	for (from = to = 0; from < leafhdr->count; from++) {
1001		/*
1002		 * Notice the new value of index.
1003		 */
1004		if (index == from)
1005			newindex = to;
1006		if (from != keepstale &&
1007		    ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) {
1008			if (from == to)
1009				*lowlogp = to;
1010			continue;
1011		}
1012		/*
1013		 * Record the new keepstale value for the insertion.
1014		 */
1015		if (from == keepstale)
1016			lowstale = highstale = to;
1017		/*
1018		 * Copy only the entries that have moved.
1019		 */
1020		if (from > to)
1021			ents[to] = ents[from];
1022		to++;
1023	}
1024	ASSERT(from > to);
1025	/*
1026	 * If the insertion point was past the last entry,
1027	 * set the new insertion point accordingly.
1028	 */
1029	if (index == from)
1030		newindex = to;
1031	*indexp = newindex;
1032	/*
1033	 * Adjust the leaf header values.
1034	 */
1035	leafhdr->count -= from - to;
1036	leafhdr->stale = 1;
1037	/*
1038	 * Remember the low/high stale value only in the "right"
1039	 * direction.
1040	 */
1041	if (lowstale >= newindex)
1042		lowstale = -1;
1043	else
1044		highstale = leafhdr->count;
1045	*highlogp = leafhdr->count - 1;
1046	*lowstalep = lowstale;
1047	*highstalep = highstale;
1048}
1049
1050/*
1051 * Log the bests entries indicated from a leaf1 block.
1052 */
1053static void
1054xfs_dir3_leaf_log_bests(
1055	xfs_trans_t		*tp,		/* transaction pointer */
1056	struct xfs_buf		*bp,		/* leaf buffer */
1057	int			first,		/* first entry to log */
1058	int			last)		/* last entry to log */
1059{
1060	__be16			*firstb;	/* pointer to first entry */
1061	__be16			*lastb;		/* pointer to last entry */
1062	struct xfs_dir2_leaf	*leaf = bp->b_addr;
1063	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
1064
1065	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1066	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC));
1067
1068	ltp = xfs_dir2_leaf_tail_p(tp->t_mountp, leaf);
1069	firstb = xfs_dir2_leaf_bests_p(ltp) + first;
1070	lastb = xfs_dir2_leaf_bests_p(ltp) + last;
1071	xfs_trans_log_buf(tp, bp, (uint)((char *)firstb - (char *)leaf),
1072		(uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));
1073}
1074
1075/*
1076 * Log the leaf entries indicated from a leaf1 or leafn block.
1077 */
1078void
1079xfs_dir3_leaf_log_ents(
1080	struct xfs_trans	*tp,
1081	struct xfs_inode	*dp,
1082	struct xfs_buf		*bp,
1083	int			first,
1084	int			last)
1085{
1086	xfs_dir2_leaf_entry_t	*firstlep;	/* pointer to first entry */
1087	xfs_dir2_leaf_entry_t	*lastlep;	/* pointer to last entry */
1088	struct xfs_dir2_leaf	*leaf = bp->b_addr;
1089	struct xfs_dir2_leaf_entry *ents;
1090
1091	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1092	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1093	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1094	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1095
1096	ents = dp->d_ops->leaf_ents_p(leaf);
1097	firstlep = &ents[first];
1098	lastlep = &ents[last];
1099	xfs_trans_log_buf(tp, bp, (uint)((char *)firstlep - (char *)leaf),
1100		(uint)((char *)lastlep - (char *)leaf + sizeof(*lastlep) - 1));
1101}
1102
1103/*
1104 * Log the header of the leaf1 or leafn block.
1105 */
1106void
1107xfs_dir3_leaf_log_header(
1108	struct xfs_trans	*tp,
1109	struct xfs_inode	*dp,
1110	struct xfs_buf		*bp)
1111{
1112	struct xfs_dir2_leaf	*leaf = bp->b_addr;
1113
1114	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1115	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1116	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1117	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1118
1119	xfs_trans_log_buf(tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf),
1120			  dp->d_ops->leaf_hdr_size - 1);
1121}
1122
1123/*
1124 * Log the tail of the leaf1 block.
1125 */
1126STATIC void
1127xfs_dir3_leaf_log_tail(
1128	struct xfs_trans	*tp,
1129	struct xfs_buf		*bp)
1130{
1131	struct xfs_dir2_leaf	*leaf = bp->b_addr;
1132	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
1133	struct xfs_mount	*mp = tp->t_mountp;
1134
1135	ASSERT(leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
1136	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
1137	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
1138	       leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
1139
1140	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
1141	xfs_trans_log_buf(tp, bp, (uint)((char *)ltp - (char *)leaf),
1142		(uint)(mp->m_dirblksize - 1));
1143}
1144
1145/*
1146 * Look up the entry referred to by args in the leaf format directory.
1147 * Most of the work is done by the xfs_dir2_leaf_lookup_int routine which
1148 * is also used by the node-format code.
1149 */
1150int
1151xfs_dir2_leaf_lookup(
1152	xfs_da_args_t		*args)		/* operation arguments */
1153{
1154	struct xfs_buf		*dbp;		/* data block buffer */
1155	xfs_dir2_data_entry_t	*dep;		/* data block entry */
1156	xfs_inode_t		*dp;		/* incore directory inode */
1157	int			error;		/* error return code */
1158	int			index;		/* found entry index */
1159	struct xfs_buf		*lbp;		/* leaf buffer */
1160	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1161	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
1162	xfs_trans_t		*tp;		/* transaction pointer */
1163	struct xfs_dir2_leaf_entry *ents;
1164
1165	trace_xfs_dir2_leaf_lookup(args);
1166
1167	/*
1168	 * Look up name in the leaf block, returning both buffers and index.
1169	 */
1170	if ((error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp))) {
1171		return error;
1172	}
1173	tp = args->trans;
1174	dp = args->dp;
1175	xfs_dir3_leaf_check(dp, lbp);
1176	leaf = lbp->b_addr;
1177	ents = dp->d_ops->leaf_ents_p(leaf);
1178	/*
1179	 * Get to the leaf entry and contained data entry address.
1180	 */
1181	lep = &ents[index];
1182
1183	/*
1184	 * Point to the data entry.
1185	 */
1186	dep = (xfs_dir2_data_entry_t *)
1187	      ((char *)dbp->b_addr +
1188	       xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
1189	/*
1190	 * Return the found inode number & CI name if appropriate
1191	 */
1192	args->inumber = be64_to_cpu(dep->inumber);
1193	args->filetype = dp->d_ops->data_get_ftype(dep);
1194	error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
1195	xfs_trans_brelse(tp, dbp);
1196	xfs_trans_brelse(tp, lbp);
1197	return XFS_ERROR(error);
1198}
1199
1200/*
1201 * Look up name/hash in the leaf block.
1202 * Fill in indexp with the found index, and dbpp with the data buffer.
1203 * If not found dbpp will be NULL, and ENOENT comes back.
1204 * lbpp will always be filled in with the leaf buffer unless there's an error.
1205 */
1206static int					/* error */
1207xfs_dir2_leaf_lookup_int(
1208	xfs_da_args_t		*args,		/* operation arguments */
1209	struct xfs_buf		**lbpp,		/* out: leaf buffer */
1210	int			*indexp,	/* out: index in leaf block */
1211	struct xfs_buf		**dbpp)		/* out: data buffer */
1212{
1213	xfs_dir2_db_t		curdb = -1;	/* current data block number */
1214	struct xfs_buf		*dbp = NULL;	/* data buffer */
1215	xfs_dir2_data_entry_t	*dep;		/* data entry */
1216	xfs_inode_t		*dp;		/* incore directory inode */
1217	int			error;		/* error return code */
1218	int			index;		/* index in leaf block */
1219	struct xfs_buf		*lbp;		/* leaf buffer */
1220	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
1221	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1222	xfs_mount_t		*mp;		/* filesystem mount point */
1223	xfs_dir2_db_t		newdb;		/* new data block number */
1224	xfs_trans_t		*tp;		/* transaction pointer */
1225	xfs_dir2_db_t		cidb = -1;	/* case match data block no. */
1226	enum xfs_dacmp		cmp;		/* name compare result */
1227	struct xfs_dir2_leaf_entry *ents;
1228	struct xfs_dir3_icleaf_hdr leafhdr;
1229
1230	dp = args->dp;
1231	tp = args->trans;
1232	mp = dp->i_mount;
1233
1234	error = xfs_dir3_leaf_read(tp, dp, mp->m_dirleafblk, -1, &lbp);
1235	if (error)
1236		return error;
1237
1238	*lbpp = lbp;
1239	leaf = lbp->b_addr;
1240	xfs_dir3_leaf_check(dp, lbp);
1241	ents = dp->d_ops->leaf_ents_p(leaf);
1242	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
1243
1244	/*
1245	 * Look for the first leaf entry with our hash value.
1246	 */
1247	index = xfs_dir2_leaf_search_hash(args, lbp);
1248	/*
1249	 * Loop over all the entries with the right hash value
1250	 * looking to match the name.
1251	 */
1252	for (lep = &ents[index];
1253	     index < leafhdr.count && be32_to_cpu(lep->hashval) == args->hashval;
1254	     lep++, index++) {
1255		/*
1256		 * Skip over stale leaf entries.
1257		 */
1258		if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
1259			continue;
1260		/*
1261		 * Get the new data block number.
1262		 */
1263		newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
1264		/*
1265		 * If it's not the same as the old data block number,
1266		 * need to pitch the old one and read the new one.
1267		 */
1268		if (newdb != curdb) {
1269			if (dbp)
1270				xfs_trans_brelse(tp, dbp);
1271			error = xfs_dir3_data_read(tp, dp,
1272						   xfs_dir2_db_to_da(mp, newdb),
1273						   -1, &dbp);
1274			if (error) {
1275				xfs_trans_brelse(tp, lbp);
1276				return error;
1277			}
1278			curdb = newdb;
1279		}
1280		/*
1281		 * Point to the data entry.
1282		 */
1283		dep = (xfs_dir2_data_entry_t *)((char *)dbp->b_addr +
1284			xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
1285		/*
1286		 * Compare name and if it's an exact match, return the index
1287		 * and buffer. If it's the first case-insensitive match, store
1288		 * the index and buffer and continue looking for an exact match.
1289		 */
1290		cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen);
1291		if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
1292			args->cmpresult = cmp;
1293			*indexp = index;
1294			/* case exact match: return the current buffer. */
1295			if (cmp == XFS_CMP_EXACT) {
1296				*dbpp = dbp;
1297				return 0;
1298			}
1299			cidb = curdb;
1300		}
1301	}
1302	ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
1303	/*
1304	 * Here, we can only be doing a lookup (not a rename or remove).
1305	 * If a case-insensitive match was found earlier, re-read the
1306	 * appropriate data block if required and return it.
1307	 */
1308	if (args->cmpresult == XFS_CMP_CASE) {
1309		ASSERT(cidb != -1);
1310		if (cidb != curdb) {
1311			xfs_trans_brelse(tp, dbp);
1312			error = xfs_dir3_data_read(tp, dp,
1313						   xfs_dir2_db_to_da(mp, cidb),
1314						   -1, &dbp);
1315			if (error) {
1316				xfs_trans_brelse(tp, lbp);
1317				return error;
1318			}
1319		}
1320		*dbpp = dbp;
1321		return 0;
1322	}
1323	/*
1324	 * No match found, return ENOENT.
1325	 */
1326	ASSERT(cidb == -1);
1327	if (dbp)
1328		xfs_trans_brelse(tp, dbp);
1329	xfs_trans_brelse(tp, lbp);
1330	return XFS_ERROR(ENOENT);
1331}
1332
1333/*
1334 * Remove an entry from a leaf format directory.
1335 */
1336int						/* error */
1337xfs_dir2_leaf_removename(
1338	xfs_da_args_t		*args)		/* operation arguments */
1339{
1340	__be16			*bestsp;	/* leaf block best freespace */
1341	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
1342	xfs_dir2_db_t		db;		/* data block number */
1343	struct xfs_buf		*dbp;		/* data block buffer */
1344	xfs_dir2_data_entry_t	*dep;		/* data entry structure */
1345	xfs_inode_t		*dp;		/* incore directory inode */
1346	int			error;		/* error return code */
1347	xfs_dir2_db_t		i;		/* temporary data block # */
1348	int			index;		/* index into leaf entries */
1349	struct xfs_buf		*lbp;		/* leaf buffer */
1350	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1351	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
1352	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
1353	xfs_mount_t		*mp;		/* filesystem mount point */
1354	int			needlog;	/* need to log data header */
1355	int			needscan;	/* need to rescan data frees */
1356	xfs_dir2_data_off_t	oldbest;	/* old value of best free */
1357	xfs_trans_t		*tp;		/* transaction pointer */
1358	struct xfs_dir2_data_free *bf;		/* bestfree table */
1359	struct xfs_dir2_leaf_entry *ents;
1360	struct xfs_dir3_icleaf_hdr leafhdr;
1361
1362	trace_xfs_dir2_leaf_removename(args);
1363
1364	/*
1365	 * Lookup the leaf entry, get the leaf and data blocks read in.
1366	 */
1367	if ((error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp))) {
1368		return error;
1369	}
1370	dp = args->dp;
1371	tp = args->trans;
1372	mp = dp->i_mount;
1373	leaf = lbp->b_addr;
1374	hdr = dbp->b_addr;
1375	xfs_dir3_data_check(dp, dbp);
1376	bf = dp->d_ops->data_bestfree_p(hdr);
1377	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
1378	ents = dp->d_ops->leaf_ents_p(leaf);
1379	/*
1380	 * Point to the leaf entry, use that to point to the data entry.
1381	 */
1382	lep = &ents[index];
1383	db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
1384	dep = (xfs_dir2_data_entry_t *)
1385	      ((char *)hdr + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
1386	needscan = needlog = 0;
1387	oldbest = be16_to_cpu(bf[0].length);
1388	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
1389	bestsp = xfs_dir2_leaf_bests_p(ltp);
1390	ASSERT(be16_to_cpu(bestsp[db]) == oldbest);
1391	/*
1392	 * Mark the former data entry unused.
1393	 */
1394	xfs_dir2_data_make_free(tp, dp, dbp,
1395		(xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
1396		dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
1397	/*
1398	 * We just mark the leaf entry stale by putting a null in it.
1399	 */
1400	leafhdr.stale++;
1401	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
1402	xfs_dir3_leaf_log_header(tp, dp, lbp);
1403
1404	lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
1405	xfs_dir3_leaf_log_ents(tp, dp, lbp, index, index);
1406
1407	/*
1408	 * Scan the freespace in the data block again if necessary,
1409	 * log the data block header if necessary.
1410	 */
1411	if (needscan)
1412		xfs_dir2_data_freescan(dp, hdr, &needlog);
1413	if (needlog)
1414		xfs_dir2_data_log_header(tp, dp, dbp);
1415	/*
1416	 * If the longest freespace in the data block has changed,
1417	 * put the new value in the bests table and log that.
1418	 */
1419	if (be16_to_cpu(bf[0].length) != oldbest) {
1420		bestsp[db] = bf[0].length;
1421		xfs_dir3_leaf_log_bests(tp, lbp, db, db);
1422	}
1423	xfs_dir3_data_check(dp, dbp);
1424	/*
1425	 * If the data block is now empty then get rid of the data block.
1426	 */
1427	if (be16_to_cpu(bf[0].length) ==
1428			mp->m_dirblksize - dp->d_ops->data_entry_offset) {
1429		ASSERT(db != mp->m_dirdatablk);
1430		if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
1431			/*
1432			 * Nope, can't get rid of it because it caused
1433			 * allocation of a bmap btree block to do so.
1434			 * Just go on, returning success, leaving the
1435			 * empty block in place.
1436			 */
1437			if (error == ENOSPC && args->total == 0)
1438				error = 0;
1439			xfs_dir3_leaf_check(dp, lbp);
1440			return error;
1441		}
1442		dbp = NULL;
1443		/*
1444		 * If this is the last data block then compact the
1445		 * bests table by getting rid of entries.
1446		 */
1447		if (db == be32_to_cpu(ltp->bestcount) - 1) {
1448			/*
1449			 * Look for the last active entry (i).
1450			 */
1451			for (i = db - 1; i > 0; i--) {
1452				if (bestsp[i] != cpu_to_be16(NULLDATAOFF))
1453					break;
1454			}
1455			/*
1456			 * Copy the table down so inactive entries at the
1457			 * end are removed.
1458			 */
1459			memmove(&bestsp[db - i], bestsp,
1460				(be32_to_cpu(ltp->bestcount) - (db - i)) * sizeof(*bestsp));
1461			be32_add_cpu(&ltp->bestcount, -(db - i));
1462			xfs_dir3_leaf_log_tail(tp, lbp);
1463			xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
1464		} else
1465			bestsp[db] = cpu_to_be16(NULLDATAOFF);
1466	}
1467	/*
1468	 * If the data block was not the first one, drop it.
1469	 */
1470	else if (db != mp->m_dirdatablk)
1471		dbp = NULL;
1472
1473	xfs_dir3_leaf_check(dp, lbp);
1474	/*
1475	 * See if we can convert to block form.
1476	 */
1477	return xfs_dir2_leaf_to_block(args, lbp, dbp);
1478}
1479
1480/*
1481 * Replace the inode number in a leaf format directory entry.
1482 */
1483int						/* error */
1484xfs_dir2_leaf_replace(
1485	xfs_da_args_t		*args)		/* operation arguments */
1486{
1487	struct xfs_buf		*dbp;		/* data block buffer */
1488	xfs_dir2_data_entry_t	*dep;		/* data block entry */
1489	xfs_inode_t		*dp;		/* incore directory inode */
1490	int			error;		/* error return code */
1491	int			index;		/* index of leaf entry */
1492	struct xfs_buf		*lbp;		/* leaf buffer */
1493	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1494	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
1495	xfs_trans_t		*tp;		/* transaction pointer */
1496	struct xfs_dir2_leaf_entry *ents;
1497
1498	trace_xfs_dir2_leaf_replace(args);
1499
1500	/*
1501	 * Look up the entry.
1502	 */
1503	if ((error = xfs_dir2_leaf_lookup_int(args, &lbp, &index, &dbp))) {
1504		return error;
1505	}
1506	dp = args->dp;
1507	leaf = lbp->b_addr;
1508	ents = dp->d_ops->leaf_ents_p(leaf);
1509	/*
1510	 * Point to the leaf entry, get data address from it.
1511	 */
1512	lep = &ents[index];
1513	/*
1514	 * Point to the data entry.
1515	 */
1516	dep = (xfs_dir2_data_entry_t *)
1517	      ((char *)dbp->b_addr +
1518	       xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
1519	ASSERT(args->inumber != be64_to_cpu(dep->inumber));
1520	/*
1521	 * Put the new inode number in, log it.
1522	 */
1523	dep->inumber = cpu_to_be64(args->inumber);
1524	dp->d_ops->data_put_ftype(dep, args->filetype);
1525	tp = args->trans;
1526	xfs_dir2_data_log_entry(tp, dp, dbp, dep);
1527	xfs_dir3_leaf_check(dp, lbp);
1528	xfs_trans_brelse(tp, lbp);
1529	return 0;
1530}
1531
1532/*
1533 * Return index in the leaf block (lbp) which is either the first
1534 * one with this hash value, or if there are none, the insert point
1535 * for that hash value.
1536 */
1537int						/* index value */
1538xfs_dir2_leaf_search_hash(
1539	xfs_da_args_t		*args,		/* operation arguments */
1540	struct xfs_buf		*lbp)		/* leaf buffer */
1541{
1542	xfs_dahash_t		hash=0;		/* hash from this entry */
1543	xfs_dahash_t		hashwant;	/* hash value looking for */
1544	int			high;		/* high leaf index */
1545	int			low;		/* low leaf index */
1546	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1547	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
1548	int			mid=0;		/* current leaf index */
1549	struct xfs_dir2_leaf_entry *ents;
1550	struct xfs_dir3_icleaf_hdr leafhdr;
1551
1552	leaf = lbp->b_addr;
1553	ents = args->dp->d_ops->leaf_ents_p(leaf);
1554	args->dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
1555
1556	/*
1557	 * Note, the table cannot be empty, so we have to go through the loop.
1558	 * Binary search the leaf entries looking for our hash value.
1559	 */
1560	for (lep = ents, low = 0, high = leafhdr.count - 1,
1561		hashwant = args->hashval;
1562	     low <= high; ) {
1563		mid = (low + high) >> 1;
1564		if ((hash = be32_to_cpu(lep[mid].hashval)) == hashwant)
1565			break;
1566		if (hash < hashwant)
1567			low = mid + 1;
1568		else
1569			high = mid - 1;
1570	}
1571	/*
1572	 * Found one, back up through all the equal hash values.
1573	 */
1574	if (hash == hashwant) {
1575		while (mid > 0 && be32_to_cpu(lep[mid - 1].hashval) == hashwant) {
1576			mid--;
1577		}
1578	}
1579	/*
1580	 * Need to point to an entry higher than ours.
1581	 */
1582	else if (hash < hashwant)
1583		mid++;
1584	return mid;
1585}
1586
1587/*
1588 * Trim off a trailing data block.  We know it's empty since the leaf
1589 * freespace table says so.
1590 */
1591int						/* error */
1592xfs_dir2_leaf_trim_data(
1593	xfs_da_args_t		*args,		/* operation arguments */
1594	struct xfs_buf		*lbp,		/* leaf buffer */
1595	xfs_dir2_db_t		db)		/* data block number */
1596{
1597	__be16			*bestsp;	/* leaf bests table */
1598	struct xfs_buf		*dbp;		/* data block buffer */
1599	xfs_inode_t		*dp;		/* incore directory inode */
1600	int			error;		/* error return value */
1601	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1602	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
1603	xfs_mount_t		*mp;		/* filesystem mount point */
1604	xfs_trans_t		*tp;		/* transaction pointer */
1605
1606	dp = args->dp;
1607	mp = dp->i_mount;
1608	tp = args->trans;
1609	/*
1610	 * Read the offending data block.  We need its buffer.
1611	 */
1612	error = xfs_dir3_data_read(tp, dp, xfs_dir2_db_to_da(mp, db), -1, &dbp);
1613	if (error)
1614		return error;
1615
1616	leaf = lbp->b_addr;
1617	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
1618
1619#ifdef DEBUG
1620{
1621	struct xfs_dir2_data_hdr *hdr = dbp->b_addr;
1622	struct xfs_dir2_data_free *bf = dp->d_ops->data_bestfree_p(hdr);
1623
1624	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
1625	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
1626	ASSERT(be16_to_cpu(bf[0].length) ==
1627	       mp->m_dirblksize - dp->d_ops->data_entry_offset);
1628	ASSERT(db == be32_to_cpu(ltp->bestcount) - 1);
1629}
1630#endif
1631
1632	/*
1633	 * Get rid of the data block.
1634	 */
1635	if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
1636		ASSERT(error != ENOSPC);
1637		xfs_trans_brelse(tp, dbp);
1638		return error;
1639	}
1640	/*
1641	 * Eliminate the last bests entry from the table.
1642	 */
1643	bestsp = xfs_dir2_leaf_bests_p(ltp);
1644	be32_add_cpu(&ltp->bestcount, -1);
1645	memmove(&bestsp[1], &bestsp[0], be32_to_cpu(ltp->bestcount) * sizeof(*bestsp));
1646	xfs_dir3_leaf_log_tail(tp, lbp);
1647	xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
1648	return 0;
1649}
1650
1651static inline size_t
1652xfs_dir3_leaf_size(
1653	struct xfs_dir3_icleaf_hdr	*hdr,
1654	int				counts)
1655{
1656	int	entries;
1657	int	hdrsize;
1658
1659	entries = hdr->count - hdr->stale;
1660	if (hdr->magic == XFS_DIR2_LEAF1_MAGIC ||
1661	    hdr->magic == XFS_DIR2_LEAFN_MAGIC)
1662		hdrsize = sizeof(struct xfs_dir2_leaf_hdr);
1663	else
1664		hdrsize = sizeof(struct xfs_dir3_leaf_hdr);
1665
1666	return hdrsize + entries * sizeof(xfs_dir2_leaf_entry_t)
1667	               + counts * sizeof(xfs_dir2_data_off_t)
1668		       + sizeof(xfs_dir2_leaf_tail_t);
1669}
1670
1671/*
1672 * Convert node form directory to leaf form directory.
1673 * The root of the node form dir needs to already be a LEAFN block.
1674 * Just return if we can't do anything.
1675 */
1676int						/* error */
1677xfs_dir2_node_to_leaf(
1678	xfs_da_state_t		*state)		/* directory operation state */
1679{
1680	xfs_da_args_t		*args;		/* operation arguments */
1681	xfs_inode_t		*dp;		/* incore directory inode */
1682	int			error;		/* error return code */
1683	struct xfs_buf		*fbp;		/* buffer for freespace block */
1684	xfs_fileoff_t		fo;		/* freespace file offset */
1685	xfs_dir2_free_t		*free;		/* freespace structure */
1686	struct xfs_buf		*lbp;		/* buffer for leaf block */
1687	xfs_dir2_leaf_tail_t	*ltp;		/* tail of leaf structure */
1688	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
1689	xfs_mount_t		*mp;		/* filesystem mount point */
1690	int			rval;		/* successful free trim? */
1691	xfs_trans_t		*tp;		/* transaction pointer */
1692	struct xfs_dir3_icleaf_hdr leafhdr;
1693	struct xfs_dir3_icfree_hdr freehdr;
1694
1695	/*
1696	 * There's more than a leaf level in the btree, so there must
1697	 * be multiple leafn blocks.  Give up.
1698	 */
1699	if (state->path.active > 1)
1700		return 0;
1701	args = state->args;
1702
1703	trace_xfs_dir2_node_to_leaf(args);
1704
1705	mp = state->mp;
1706	dp = args->dp;
1707	tp = args->trans;
1708	/*
1709	 * Get the last offset in the file.
1710	 */
1711	if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK))) {
1712		return error;
1713	}
1714	fo -= mp->m_dirblkfsbs;
1715	/*
1716	 * If there are freespace blocks other than the first one,
1717	 * take this opportunity to remove trailing empty freespace blocks
1718	 * that may have been left behind during no-space-reservation
1719	 * operations.
1720	 */
1721	while (fo > mp->m_dirfreeblk) {
1722		if ((error = xfs_dir2_node_trim_free(args, fo, &rval))) {
1723			return error;
1724		}
1725		if (rval)
1726			fo -= mp->m_dirblkfsbs;
1727		else
1728			return 0;
1729	}
1730	/*
1731	 * Now find the block just before the freespace block.
1732	 */
1733	if ((error = xfs_bmap_last_before(tp, dp, &fo, XFS_DATA_FORK))) {
1734		return error;
1735	}
1736	/*
1737	 * If it's not the single leaf block, give up.
1738	 */
1739	if (XFS_FSB_TO_B(mp, fo) > XFS_DIR2_LEAF_OFFSET + mp->m_dirblksize)
1740		return 0;
1741	lbp = state->path.blk[0].bp;
1742	leaf = lbp->b_addr;
1743	dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
1744
1745	ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
1746	       leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
1747
1748	/*
1749	 * Read the freespace block.
1750	 */
1751	error = xfs_dir2_free_read(tp, dp,  mp->m_dirfreeblk, &fbp);
1752	if (error)
1753		return error;
1754	free = fbp->b_addr;
1755	dp->d_ops->free_hdr_from_disk(&freehdr, free);
1756
1757	ASSERT(!freehdr.firstdb);
1758
1759	/*
1760	 * Now see if the leafn and free data will fit in a leaf1.
1761	 * If not, release the buffer and give up.
1762	 */
1763	if (xfs_dir3_leaf_size(&leafhdr, freehdr.nvalid) > mp->m_dirblksize) {
1764		xfs_trans_brelse(tp, fbp);
1765		return 0;
1766	}
1767
1768	/*
1769	 * If the leaf has any stale entries in it, compress them out.
1770	 */
1771	if (leafhdr.stale)
1772		xfs_dir3_leaf_compact(args, &leafhdr, lbp);
1773
1774	lbp->b_ops = &xfs_dir3_leaf1_buf_ops;
1775	xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAF1_BUF);
1776	leafhdr.magic = (leafhdr.magic == XFS_DIR2_LEAFN_MAGIC)
1777					? XFS_DIR2_LEAF1_MAGIC
1778					: XFS_DIR3_LEAF1_MAGIC;
1779
1780	/*
1781	 * Set up the leaf tail from the freespace block.
1782	 */
1783	ltp = xfs_dir2_leaf_tail_p(mp, leaf);
1784	ltp->bestcount = cpu_to_be32(freehdr.nvalid);
1785
1786	/*
1787	 * Set up the leaf bests table.
1788	 */
1789	memcpy(xfs_dir2_leaf_bests_p(ltp), dp->d_ops->free_bests_p(free),
1790		freehdr.nvalid * sizeof(xfs_dir2_data_off_t));
1791
1792	dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
1793	xfs_dir3_leaf_log_header(tp, dp, lbp);
1794	xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
1795	xfs_dir3_leaf_log_tail(tp, lbp);
1796	xfs_dir3_leaf_check(dp, lbp);
1797
1798	/*
1799	 * Get rid of the freespace block.
1800	 */
1801	error = xfs_dir2_shrink_inode(args, XFS_DIR2_FREE_FIRSTDB(mp), fbp);
1802	if (error) {
1803		/*
1804		 * This can't fail here because it can only happen when
1805		 * punching out the middle of an extent, and this is an
1806		 * isolated block.
1807		 */
1808		ASSERT(error != ENOSPC);
1809		return error;
1810	}
1811	fbp = NULL;
1812	/*
1813	 * Now see if we can convert the single-leaf directory
1814	 * down to a block form directory.
1815	 * This routine always kills the dabuf for the leaf, so
1816	 * eliminate it from the path.
1817	 */
1818	error = xfs_dir2_leaf_to_block(args, lbp, NULL);
1819	state->path.blk[0].bp = NULL;
1820	return error;
1821}