xfs_dir2_block.c 34.3 KB
Newer Older
D
Dave Chinner 已提交
1
// SPDX-License-Identifier: GPL-2.0
L
Linus Torvalds 已提交
2
/*
3
 * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
4
 * Copyright (c) 2013 Red Hat, Inc.
5
 * All Rights Reserved.
L
Linus Torvalds 已提交
6 7
 */
#include "xfs.h"
8
#include "xfs_fs.h"
9
#include "xfs_shared.h"
10
#include "xfs_format.h"
11 12
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
13 14
#include "xfs_mount.h"
#include "xfs_inode.h"
15
#include "xfs_trans.h"
16
#include "xfs_bmap.h"
17
#include "xfs_buf_item.h"
18
#include "xfs_dir2.h"
C
Christoph Hellwig 已提交
19
#include "xfs_dir2_priv.h"
L
Linus Torvalds 已提交
20
#include "xfs_error.h"
C
Christoph Hellwig 已提交
21
#include "xfs_trace.h"
22
#include "xfs_log.h"
L
Linus Torvalds 已提交
23 24 25 26

/*
 * Local function prototypes.
 */
27 28 29 30
static void xfs_dir2_block_log_leaf(xfs_trans_t *tp, struct xfs_buf *bp,
				    int first, int last);
static void xfs_dir2_block_log_tail(xfs_trans_t *tp, struct xfs_buf *bp);
static int xfs_dir2_block_lookup_int(xfs_da_args_t *args, struct xfs_buf **bpp,
L
Linus Torvalds 已提交
31 32 33
				     int *entno);
static int xfs_dir2_block_sort(const void *a, const void *b);

34 35 36 37 38 39 40 41
static xfs_dahash_t xfs_dir_hash_dot, xfs_dir_hash_dotdot;

/*
 * One-time startup routine called from xfs_init().
 */
void
xfs_dir_startup(void)
{
42 43
	xfs_dir_hash_dot = xfs_da_hashname((unsigned char *)".", 1);
	xfs_dir_hash_dotdot = xfs_da_hashname((unsigned char *)"..", 2);
44 45
}

46
static xfs_failaddr_t
47
xfs_dir3_block_verify(
48 49
	struct xfs_buf		*bp)
{
50
	struct xfs_mount	*mp = bp->b_mount;
51 52
	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;

53 54 55
	if (!xfs_verify_magic(bp, hdr3->magic))
		return __this_address;

56
	if (xfs_sb_version_hascrc(&mp->m_sb)) {
57
		if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
58
			return __this_address;
59
		if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
60
			return __this_address;
61
		if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
62
			return __this_address;
63
	}
64
	return __xfs_dir3_data_check(NULL, bp);
65
}
66

67
static void
68
xfs_dir3_block_read_verify(
69 70
	struct xfs_buf	*bp)
{
71
	struct xfs_mount	*mp = bp->b_mount;
72
	xfs_failaddr_t		fa;
73

74 75
	if (xfs_sb_version_hascrc(&mp->m_sb) &&
	     !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
76 77 78 79 80 81
		xfs_verifier_error(bp, -EFSBADCRC, __this_address);
	else {
		fa = xfs_dir3_block_verify(bp);
		if (fa)
			xfs_verifier_error(bp, -EFSCORRUPTED, fa);
	}
82 83
}

84
static void
85
xfs_dir3_block_write_verify(
86 87
	struct xfs_buf	*bp)
{
88
	struct xfs_mount	*mp = bp->b_mount;
C
Carlos Maiolino 已提交
89
	struct xfs_buf_log_item	*bip = bp->b_log_item;
90
	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;
91
	xfs_failaddr_t		fa;
92

93 94 95
	fa = xfs_dir3_block_verify(bp);
	if (fa) {
		xfs_verifier_error(bp, -EFSCORRUPTED, fa);
96 97 98 99 100 101 102 103 104
		return;
	}

	if (!xfs_sb_version_hascrc(&mp->m_sb))
		return;

	if (bip)
		hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);

105
	xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
106 107
}

108
const struct xfs_buf_ops xfs_dir3_block_buf_ops = {
109
	.name = "xfs_dir3_block",
110 111
	.magic = { cpu_to_be32(XFS_DIR2_BLOCK_MAGIC),
		   cpu_to_be32(XFS_DIR3_BLOCK_MAGIC) },
112 113
	.verify_read = xfs_dir3_block_read_verify,
	.verify_write = xfs_dir3_block_write_verify,
114
	.verify_struct = xfs_dir3_block_verify,
115 116
};

117
int
118
xfs_dir3_block_read(
119 120 121 122 123
	struct xfs_trans	*tp,
	struct xfs_inode	*dp,
	struct xfs_buf		**bpp)
{
	struct xfs_mount	*mp = dp->i_mount;
124
	int			err;
125

126
	err = xfs_da_read_buf(tp, dp, mp->m_dir_geo->datablk, -1, bpp,
127
				XFS_DATA_FORK, &xfs_dir3_block_buf_ops);
128
	if (!err && tp && *bpp)
129
		xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_BLOCK_BUF);
130
	return err;
131 132 133 134 135
}

static void
xfs_dir3_block_init(
	struct xfs_mount	*mp,
136
	struct xfs_trans	*tp,
137 138 139 140 141 142
	struct xfs_buf		*bp,
	struct xfs_inode	*dp)
{
	struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;

	bp->b_ops = &xfs_dir3_block_buf_ops;
143
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_BLOCK_BUF);
144 145 146 147 148 149

	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		memset(hdr3, 0, sizeof(*hdr3));
		hdr3->magic = cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
		hdr3->blkno = cpu_to_be64(bp->b_bn);
		hdr3->owner = cpu_to_be64(dp->i_ino);
150
		uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
151 152 153 154
		return;

	}
	hdr3->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
155 156 157 158
}

static void
xfs_dir2_block_need_space(
159
	struct xfs_inode		*dp,
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
	struct xfs_dir2_data_hdr	*hdr,
	struct xfs_dir2_block_tail	*btp,
	struct xfs_dir2_leaf_entry	*blp,
	__be16				**tagpp,
	struct xfs_dir2_data_unused	**dupp,
	struct xfs_dir2_data_unused	**enddupp,
	int				*compact,
	int				len)
{
	struct xfs_dir2_data_free	*bf;
	__be16				*tagp = NULL;
	struct xfs_dir2_data_unused	*dup = NULL;
	struct xfs_dir2_data_unused	*enddup = NULL;

	*compact = 0;
175
	bf = dp->d_ops->data_bestfree_p(hdr);
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270

	/*
	 * If there are stale entries we'll use one for the leaf.
	 */
	if (btp->stale) {
		if (be16_to_cpu(bf[0].length) >= len) {
			/*
			 * The biggest entry enough to avoid compaction.
			 */
			dup = (xfs_dir2_data_unused_t *)
			      ((char *)hdr + be16_to_cpu(bf[0].offset));
			goto out;
		}

		/*
		 * Will need to compact to make this work.
		 * Tag just before the first leaf entry.
		 */
		*compact = 1;
		tagp = (__be16 *)blp - 1;

		/* Data object just before the first leaf entry.  */
		dup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));

		/*
		 * If it's not free then the data will go where the
		 * leaf data starts now, if it works at all.
		 */
		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
			if (be16_to_cpu(dup->length) + (be32_to_cpu(btp->stale) - 1) *
			    (uint)sizeof(*blp) < len)
				dup = NULL;
		} else if ((be32_to_cpu(btp->stale) - 1) * (uint)sizeof(*blp) < len)
			dup = NULL;
		else
			dup = (xfs_dir2_data_unused_t *)blp;
		goto out;
	}

	/*
	 * no stale entries, so just use free space.
	 * Tag just before the first leaf entry.
	 */
	tagp = (__be16 *)blp - 1;

	/* Data object just before the first leaf entry.  */
	enddup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));

	/*
	 * If it's not free then can't do this add without cleaning up:
	 * the space before the first leaf entry needs to be free so it
	 * can be expanded to hold the pointer to the new entry.
	 */
	if (be16_to_cpu(enddup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
		/*
		 * Check out the biggest freespace and see if it's the same one.
		 */
		dup = (xfs_dir2_data_unused_t *)
		      ((char *)hdr + be16_to_cpu(bf[0].offset));
		if (dup != enddup) {
			/*
			 * Not the same free entry, just check its length.
			 */
			if (be16_to_cpu(dup->length) < len)
				dup = NULL;
			goto out;
		}

		/*
		 * It is the biggest freespace, can it hold the leaf too?
		 */
		if (be16_to_cpu(dup->length) < len + (uint)sizeof(*blp)) {
			/*
			 * Yes, use the second-largest entry instead if it works.
			 */
			if (be16_to_cpu(bf[1].length) >= len)
				dup = (xfs_dir2_data_unused_t *)
				      ((char *)hdr + be16_to_cpu(bf[1].offset));
			else
				dup = NULL;
		}
	}
out:
	*tagpp = tagp;
	*dupp = dup;
	*enddupp = enddup;
}

/*
 * compact the leaf entries.
 * Leave the highest-numbered stale entry stale.
 * XXX should be the one closest to mid but mid is not yet computed.
 */
static void
xfs_dir2_block_compact(
271
	struct xfs_da_args		*args,
272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303
	struct xfs_buf			*bp,
	struct xfs_dir2_data_hdr	*hdr,
	struct xfs_dir2_block_tail	*btp,
	struct xfs_dir2_leaf_entry	*blp,
	int				*needlog,
	int				*lfloghigh,
	int				*lfloglow)
{
	int			fromidx;	/* source leaf index */
	int			toidx;		/* target leaf index */
	int			needscan = 0;
	int			highstale;	/* high stale index */

	fromidx = toidx = be32_to_cpu(btp->count) - 1;
	highstale = *lfloghigh = -1;
	for (; fromidx >= 0; fromidx--) {
		if (blp[fromidx].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR)) {
			if (highstale == -1)
				highstale = toidx;
			else {
				if (*lfloghigh == -1)
					*lfloghigh = toidx;
				continue;
			}
		}
		if (fromidx < toidx)
			blp[toidx] = blp[fromidx];
		toidx--;
	}
	*lfloglow = toidx + 1 - (be32_to_cpu(btp->stale) - 1);
	*lfloghigh -= be32_to_cpu(btp->stale) - 1;
	be32_add_cpu(&btp->count, -(be32_to_cpu(btp->stale) - 1));
304
	xfs_dir2_data_make_free(args, bp,
305 306 307 308 309 310 311 312 313
		(xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
		(xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),
		needlog, &needscan);
	btp->stale = cpu_to_be32(1);
	/*
	 * If we now need to rebuild the bestfree map, do so.
	 * This needs to happen before the next call to use_free.
	 */
	if (needscan)
314
		xfs_dir2_data_freescan(args->dp, hdr, needlog);
315 316
}

L
Linus Torvalds 已提交
317 318 319 320 321 322 323
/*
 * Add an entry to a block directory.
 */
int						/* error */
xfs_dir2_block_addname(
	xfs_da_args_t		*args)		/* directory op arguments */
{
324
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
325
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
326
	struct xfs_buf		*bp;		/* buffer for block */
L
Linus Torvalds 已提交
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	int			compact;	/* need to compact leaf ents */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_inode_t		*dp;		/* directory inode */
	xfs_dir2_data_unused_t	*dup;		/* block unused entry */
	int			error;		/* error return value */
	xfs_dir2_data_unused_t	*enddup=NULL;	/* unused at end of data */
	xfs_dahash_t		hash;		/* hash value of found entry */
	int			high;		/* high index for binary srch */
	int			highstale;	/* high stale index */
	int			lfloghigh=0;	/* last final leaf to log */
	int			lfloglow=0;	/* first final leaf to log */
	int			len;		/* length of the new entry */
	int			low;		/* low index for binary srch */
	int			lowstale;	/* low stale index */
	int			mid=0;		/* midpoint for binary srch */
	int			needlog;	/* need to log header */
	int			needscan;	/* need to rescan freespace */
345
	__be16			*tagp;		/* pointer to tag value */
L
Linus Torvalds 已提交
346 347
	xfs_trans_t		*tp;		/* transaction structure */

C
Christoph Hellwig 已提交
348 349
	trace_xfs_dir2_block_addname(args);

L
Linus Torvalds 已提交
350 351
	dp = args->dp;
	tp = args->trans;
352 353

	/* Read the (one and only) directory block into bp. */
354
	error = xfs_dir3_block_read(tp, dp, &bp);
355
	if (error)
L
Linus Torvalds 已提交
356
		return error;
357

358
	len = xfs_dir2_data_entsize(dp->i_mount, args->namelen);
359

L
Linus Torvalds 已提交
360 361 362
	/*
	 * Set up pointers to parts of the block.
	 */
363
	hdr = bp->b_addr;
364
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
365
	blp = xfs_dir2_block_leaf_p(btp);
366

L
Linus Torvalds 已提交
367
	/*
368 369
	 * Find out if we can reuse stale entries or whether we need extra
	 * space for entry and new leaf.
L
Linus Torvalds 已提交
370
	 */
371
	xfs_dir2_block_need_space(dp, hdr, btp, blp, &tagp, &dup,
372 373
				  &enddup, &compact, len);

L
Linus Torvalds 已提交
374
	/*
375
	 * Done everything we need for a space check now.
L
Linus Torvalds 已提交
376
	 */
377
	if (args->op_flags & XFS_DA_OP_JUSTCHECK) {
378
		xfs_trans_brelse(tp, bp);
379
		if (!dup)
D
Dave Chinner 已提交
380
			return -ENOSPC;
381 382 383
		return 0;
	}

L
Linus Torvalds 已提交
384 385 386 387
	/*
	 * If we don't have space for the new entry & leaf ...
	 */
	if (!dup) {
388 389
		/* Don't have a space reservation: return no-space.  */
		if (args->total == 0)
D
Dave Chinner 已提交
390
			return -ENOSPC;
L
Linus Torvalds 已提交
391 392 393 394 395 396 397 398 399
		/*
		 * Convert to the next larger format.
		 * Then add the new entry in that format.
		 */
		error = xfs_dir2_block_to_leaf(args, bp);
		if (error)
			return error;
		return xfs_dir2_leaf_addname(args);
	}
400

L
Linus Torvalds 已提交
401
	needlog = needscan = 0;
402

L
Linus Torvalds 已提交
403 404 405
	/*
	 * If need to compact the leaf entries, do it now.
	 */
406
	if (compact) {
407
		xfs_dir2_block_compact(args, bp, hdr, btp, blp, &needlog,
408
				      &lfloghigh, &lfloglow);
409 410 411
		/* recalculate blp post-compaction */
		blp = xfs_dir2_block_leaf_p(btp);
	} else if (btp->stale) {
L
Linus Torvalds 已提交
412
		/*
413 414
		 * Set leaf logging boundaries to impossible state.
		 * For the no-stale case they're set explicitly.
L
Linus Torvalds 已提交
415
		 */
416
		lfloglow = be32_to_cpu(btp->count);
L
Linus Torvalds 已提交
417 418
		lfloghigh = -1;
	}
419

L
Linus Torvalds 已提交
420 421 422
	/*
	 * Find the slot that's first lower than our hash value, -1 if none.
	 */
423
	for (low = 0, high = be32_to_cpu(btp->count) - 1; low <= high; ) {
L
Linus Torvalds 已提交
424
		mid = (low + high) >> 1;
425
		if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
L
Linus Torvalds 已提交
426 427 428 429 430 431
			break;
		if (hash < args->hashval)
			low = mid + 1;
		else
			high = mid - 1;
	}
432
	while (mid >= 0 && be32_to_cpu(blp[mid].hashval) >= args->hashval) {
L
Linus Torvalds 已提交
433 434 435 436 437 438
		mid--;
	}
	/*
	 * No stale entries, will use enddup space to hold new leaf.
	 */
	if (!btp->stale) {
439 440
		xfs_dir2_data_aoff_t	aoff;

L
Linus Torvalds 已提交
441 442 443
		/*
		 * Mark the space needed for the new leaf entry, now in use.
		 */
444 445 446 447 448 449 450 451
		aoff = (xfs_dir2_data_aoff_t)((char *)enddup - (char *)hdr +
				be16_to_cpu(enddup->length) - sizeof(*blp));
		error = xfs_dir2_data_use_free(args, bp, enddup, aoff,
				(xfs_dir2_data_aoff_t)sizeof(*blp), &needlog,
				&needscan);
		if (error)
			return error;

L
Linus Torvalds 已提交
452 453 454
		/*
		 * Update the tail (entry count).
		 */
455
		be32_add_cpu(&btp->count, 1);
L
Linus Torvalds 已提交
456 457 458 459 460
		/*
		 * If we now need to rebuild the bestfree map, do so.
		 * This needs to happen before the next call to use_free.
		 */
		if (needscan) {
461
			xfs_dir2_data_freescan(dp, hdr, &needlog);
L
Linus Torvalds 已提交
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
			needscan = 0;
		}
		/*
		 * Adjust pointer to the first leaf entry, we're about to move
		 * the table up one to open up space for the new leaf entry.
		 * Then adjust our index to match.
		 */
		blp--;
		mid++;
		if (mid)
			memmove(blp, &blp[1], mid * sizeof(*blp));
		lfloglow = 0;
		lfloghigh = mid;
	}
	/*
	 * Use a stale leaf for our new entry.
	 */
	else {
		for (lowstale = mid;
		     lowstale >= 0 &&
482 483
			blp[lowstale].address !=
			cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
L
Linus Torvalds 已提交
484 485 486
		     lowstale--)
			continue;
		for (highstale = mid + 1;
487
		     highstale < be32_to_cpu(btp->count) &&
488 489
			blp[highstale].address !=
			cpu_to_be32(XFS_DIR2_NULL_DATAPTR) &&
L
Linus Torvalds 已提交
490 491 492 493 494 495 496
			(lowstale < 0 || mid - lowstale > highstale - mid);
		     highstale++)
			continue;
		/*
		 * Move entries toward the low-numbered stale entry.
		 */
		if (lowstale >= 0 &&
497
		    (highstale == be32_to_cpu(btp->count) ||
L
Linus Torvalds 已提交
498 499 500 501
		     mid - lowstale <= highstale - mid)) {
			if (mid - lowstale)
				memmove(&blp[lowstale], &blp[lowstale + 1],
					(mid - lowstale) * sizeof(*blp));
D
Dave Chinner 已提交
502 503
			lfloglow = min(lowstale, lfloglow);
			lfloghigh = max(mid, lfloghigh);
L
Linus Torvalds 已提交
504 505 506 507 508
		}
		/*
		 * Move entries toward the high-numbered stale entry.
		 */
		else {
509
			ASSERT(highstale < be32_to_cpu(btp->count));
L
Linus Torvalds 已提交
510 511 512 513
			mid++;
			if (highstale - mid)
				memmove(&blp[mid + 1], &blp[mid],
					(highstale - mid) * sizeof(*blp));
D
Dave Chinner 已提交
514 515
			lfloglow = min(mid, lfloglow);
			lfloghigh = max(highstale, lfloghigh);
L
Linus Torvalds 已提交
516
		}
517
		be32_add_cpu(&btp->stale, -1);
L
Linus Torvalds 已提交
518 519 520 521 522 523 524 525
	}
	/*
	 * Point to the new data entry.
	 */
	dep = (xfs_dir2_data_entry_t *)dup;
	/*
	 * Fill in the leaf entry.
	 */
526
	blp[mid].hashval = cpu_to_be32(args->hashval);
527
	blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(
528
				(char *)dep - (char *)hdr));
L
Linus Torvalds 已提交
529 530 531 532
	xfs_dir2_block_log_leaf(tp, bp, lfloglow, lfloghigh);
	/*
	 * Mark space for the data entry used.
	 */
533 534 535 536 537
	error = xfs_dir2_data_use_free(args, bp, dup,
			(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
			(xfs_dir2_data_aoff_t)len, &needlog, &needscan);
	if (error)
		return error;
L
Linus Torvalds 已提交
538 539 540
	/*
	 * Create the new data entry.
	 */
541
	dep->inumber = cpu_to_be64(args->inumber);
L
Linus Torvalds 已提交
542 543
	dep->namelen = args->namelen;
	memcpy(dep->name, args->name, args->namelen);
544 545
	dp->d_ops->data_put_ftype(dep, args->filetype);
	tagp = dp->d_ops->data_entry_tag_p(dep);
546
	*tagp = cpu_to_be16((char *)dep - (char *)hdr);
L
Linus Torvalds 已提交
547 548 549 550
	/*
	 * Clean up the bestfree array and log the header, tail, and entry.
	 */
	if (needscan)
551
		xfs_dir2_data_freescan(dp, hdr, &needlog);
L
Linus Torvalds 已提交
552
	if (needlog)
553
		xfs_dir2_data_log_header(args, bp);
L
Linus Torvalds 已提交
554
	xfs_dir2_block_log_tail(tp, bp);
555
	xfs_dir2_data_log_entry(args, bp, dep);
556
	xfs_dir3_data_check(dp, bp);
L
Linus Torvalds 已提交
557 558 559 560 561 562 563 564 565
	return 0;
}

/*
 * Log leaf entries from the block.
 */
static void
xfs_dir2_block_log_leaf(
	xfs_trans_t		*tp,		/* transaction structure */
566
	struct xfs_buf		*bp,		/* block buffer */
L
Linus Torvalds 已提交
567 568 569
	int			first,		/* index of first logged leaf */
	int			last)		/* index of last logged leaf */
{
570
	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
571 572
	xfs_dir2_leaf_entry_t	*blp;
	xfs_dir2_block_tail_t	*btp;
L
Linus Torvalds 已提交
573

574
	btp = xfs_dir2_block_tail_p(tp->t_mountp->m_dir_geo, hdr);
575
	blp = xfs_dir2_block_leaf_p(btp);
576
	xfs_trans_log_buf(tp, bp, (uint)((char *)&blp[first] - (char *)hdr),
577
		(uint)((char *)&blp[last + 1] - (char *)hdr - 1));
L
Linus Torvalds 已提交
578 579 580 581 582 583 584 585
}

/*
 * Log the block tail.
 */
static void
xfs_dir2_block_log_tail(
	xfs_trans_t		*tp,		/* transaction structure */
586
	struct xfs_buf		*bp)		/* block buffer */
L
Linus Torvalds 已提交
587
{
588
	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
589
	xfs_dir2_block_tail_t	*btp;
L
Linus Torvalds 已提交
590

591
	btp = xfs_dir2_block_tail_p(tp->t_mountp->m_dir_geo, hdr);
592
	xfs_trans_log_buf(tp, bp, (uint)((char *)btp - (char *)hdr),
593
		(uint)((char *)(btp + 1) - (char *)hdr - 1));
L
Linus Torvalds 已提交
594 595 596 597 598 599 600 601 602 603
}

/*
 * Look up an entry in the block.  This is the external routine,
 * xfs_dir2_block_lookup_int does the real work.
 */
int						/* error */
xfs_dir2_block_lookup(
	xfs_da_args_t		*args)		/* dir lookup arguments */
{
604
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
605
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
606
	struct xfs_buf		*bp;		/* block buffer */
L
Linus Torvalds 已提交
607 608 609 610 611 612
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_inode_t		*dp;		/* incore inode */
	int			ent;		/* entry index */
	int			error;		/* error return value */

C
Christoph Hellwig 已提交
613 614
	trace_xfs_dir2_block_lookup(args);

L
Linus Torvalds 已提交
615 616 617 618 619 620 621
	/*
	 * Get the buffer, look up the entry.
	 * If not found (ENOENT) then return, have no buffer.
	 */
	if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent)))
		return error;
	dp = args->dp;
622
	hdr = bp->b_addr;
623
	xfs_dir3_data_check(dp, bp);
624
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
625
	blp = xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
626 627 628
	/*
	 * Get the offset from the leaf entry, to point to the data.
	 */
629
	dep = (xfs_dir2_data_entry_t *)((char *)hdr +
630 631
			xfs_dir2_dataptr_to_off(args->geo,
						be32_to_cpu(blp[ent].address)));
L
Linus Torvalds 已提交
632
	/*
633
	 * Fill in inode number, CI name if appropriate, release the block.
L
Linus Torvalds 已提交
634
	 */
635
	args->inumber = be64_to_cpu(dep->inumber);
636
	args->filetype = dp->d_ops->data_get_ftype(dep);
637
	error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
638
	xfs_trans_brelse(args->trans, bp);
E
Eric Sandeen 已提交
639
	return error;
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647
}

/*
 * Internal block lookup routine.
 */
static int					/* error */
xfs_dir2_block_lookup_int(
	xfs_da_args_t		*args,		/* dir lookup arguments */
648
	struct xfs_buf		**bpp,		/* returned block buffer */
L
Linus Torvalds 已提交
649 650 651
	int			*entno)		/* returned entry number */
{
	xfs_dir2_dataptr_t	addr;		/* data entry address */
652
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
653
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
654
	struct xfs_buf		*bp;		/* block buffer */
L
Linus Torvalds 已提交
655 656 657 658 659 660 661 662 663 664
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_inode_t		*dp;		/* incore inode */
	int			error;		/* error return value */
	xfs_dahash_t		hash;		/* found hash value */
	int			high;		/* binary search high index */
	int			low;		/* binary search low index */
	int			mid;		/* binary search current idx */
	xfs_mount_t		*mp;		/* filesystem mount point */
	xfs_trans_t		*tp;		/* transaction pointer */
665
	enum xfs_dacmp		cmp;		/* comparison result */
L
Linus Torvalds 已提交
666 667 668 669

	dp = args->dp;
	tp = args->trans;
	mp = dp->i_mount;
670

671
	error = xfs_dir3_block_read(tp, dp, &bp);
672
	if (error)
L
Linus Torvalds 已提交
673
		return error;
674

675
	hdr = bp->b_addr;
676
	xfs_dir3_data_check(dp, bp);
677
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
678
	blp = xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
679 680 681 682
	/*
	 * Loop doing a binary search for our hash value.
	 * Find our entry, ENOENT if it's not there.
	 */
683
	for (low = 0, high = be32_to_cpu(btp->count) - 1; ; ) {
L
Linus Torvalds 已提交
684 685
		ASSERT(low <= high);
		mid = (low + high) >> 1;
686
		if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
L
Linus Torvalds 已提交
687 688 689 690 691 692
			break;
		if (hash < args->hashval)
			low = mid + 1;
		else
			high = mid - 1;
		if (low > high) {
693
			ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
694
			xfs_trans_brelse(tp, bp);
D
Dave Chinner 已提交
695
			return -ENOENT;
L
Linus Torvalds 已提交
696 697 698 699 700
		}
	}
	/*
	 * Back up to the first one with the right hash value.
	 */
701
	while (mid > 0 && be32_to_cpu(blp[mid - 1].hashval) == args->hashval) {
L
Linus Torvalds 已提交
702 703 704 705 706 707 708
		mid--;
	}
	/*
	 * Now loop forward through all the entries with the
	 * right hash value looking for our name.
	 */
	do {
709
		if ((addr = be32_to_cpu(blp[mid].address)) == XFS_DIR2_NULL_DATAPTR)
L
Linus Torvalds 已提交
710 711 712 713 714
			continue;
		/*
		 * Get pointer to the entry from the leaf.
		 */
		dep = (xfs_dir2_data_entry_t *)
715
			((char *)hdr + xfs_dir2_dataptr_to_off(args->geo, addr));
L
Linus Torvalds 已提交
716
		/*
717 718 719
		 * Compare name and if it's an exact match, return the index
		 * and buffer. If it's the first case-insensitive match, store
		 * the index and buffer and continue looking for an exact match.
L
Linus Torvalds 已提交
720
		 */
721 722 723
		cmp = mp->m_dirnameops->compname(args, dep->name, dep->namelen);
		if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
			args->cmpresult = cmp;
L
Linus Torvalds 已提交
724 725
			*bpp = bp;
			*entno = mid;
726 727
			if (cmp == XFS_CMP_EXACT)
				return 0;
L
Linus Torvalds 已提交
728
		}
729 730 731
	} while (++mid < be32_to_cpu(btp->count) &&
			be32_to_cpu(blp[mid].hashval) == hash);

732
	ASSERT(args->op_flags & XFS_DA_OP_OKNOENT);
733 734 735 736 737 738
	/*
	 * Here, we can only be doing a lookup (not a rename or replace).
	 * If a case-insensitive match was found earlier, return success.
	 */
	if (args->cmpresult == XFS_CMP_CASE)
		return 0;
L
Linus Torvalds 已提交
739 740 741
	/*
	 * No match, release the buffer and return ENOENT.
	 */
742
	xfs_trans_brelse(tp, bp);
D
Dave Chinner 已提交
743
	return -ENOENT;
L
Linus Torvalds 已提交
744 745 746 747 748 749 750 751 752 753
}

/*
 * Remove an entry from a block format directory.
 * If that makes the block small enough to fit in shortform, transform it.
 */
int						/* error */
xfs_dir2_block_removename(
	xfs_da_args_t		*args)		/* directory operation args */
{
754
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
755
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf pointer */
756
	struct xfs_buf		*bp;		/* block buffer */
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765 766 767
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_inode_t		*dp;		/* incore inode */
	int			ent;		/* block leaf entry index */
	int			error;		/* error return value */
	int			needlog;	/* need to log block header */
	int			needscan;	/* need to fixup bestfree */
	xfs_dir2_sf_hdr_t	sfh;		/* shortform header */
	int			size;		/* shortform size */
	xfs_trans_t		*tp;		/* transaction pointer */

C
Christoph Hellwig 已提交
768 769
	trace_xfs_dir2_block_removename(args);

L
Linus Torvalds 已提交
770 771 772 773 774 775 776 777 778
	/*
	 * Look up the entry in the block.  Gets the buffer and entry index.
	 * It will always be there, the vnodeops level does a lookup first.
	 */
	if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent))) {
		return error;
	}
	dp = args->dp;
	tp = args->trans;
779
	hdr = bp->b_addr;
780
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
781
	blp = xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
782 783 784
	/*
	 * Point to the data entry using the leaf entry.
	 */
785 786 787
	dep = (xfs_dir2_data_entry_t *)((char *)hdr +
			xfs_dir2_dataptr_to_off(args->geo,
						be32_to_cpu(blp[ent].address)));
L
Linus Torvalds 已提交
788 789 790 791
	/*
	 * Mark the data entry's space free.
	 */
	needlog = needscan = 0;
792
	xfs_dir2_data_make_free(args, bp,
793
		(xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
794 795
		xfs_dir2_data_entsize(dp->i_mount, dep->namelen), &needlog,
		&needscan);
L
Linus Torvalds 已提交
796 797 798
	/*
	 * Fix up the block tail.
	 */
799
	be32_add_cpu(&btp->stale, 1);
L
Linus Torvalds 已提交
800 801 802 803
	xfs_dir2_block_log_tail(tp, bp);
	/*
	 * Remove the leaf entry by marking it stale.
	 */
804
	blp[ent].address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
L
Linus Torvalds 已提交
805 806 807 808 809
	xfs_dir2_block_log_leaf(tp, bp, ent, ent);
	/*
	 * Fix up bestfree, log the header if necessary.
	 */
	if (needscan)
810
		xfs_dir2_data_freescan(dp, hdr, &needlog);
L
Linus Torvalds 已提交
811
	if (needlog)
812
		xfs_dir2_data_log_header(args, bp);
813
	xfs_dir3_data_check(dp, bp);
L
Linus Torvalds 已提交
814 815 816
	/*
	 * See if the size as a shortform is good enough.
	 */
817
	size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
818
	if (size > XFS_IFORK_DSIZE(dp))
L
Linus Torvalds 已提交
819
		return 0;
820

L
Linus Torvalds 已提交
821 822 823 824 825 826 827 828 829 830 831 832 833 834
	/*
	 * If it works, do the conversion.
	 */
	return xfs_dir2_block_to_sf(args, bp, size, &sfh);
}

/*
 * Replace an entry in a V2 block directory.
 * Change the inode number to the new value.
 */
int						/* error */
xfs_dir2_block_replace(
	xfs_da_args_t		*args)		/* directory operation args */
{
835
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
836
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
837
	struct xfs_buf		*bp;		/* block buffer */
L
Linus Torvalds 已提交
838 839 840 841 842 843
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* block data entry */
	xfs_inode_t		*dp;		/* incore inode */
	int			ent;		/* leaf entry index */
	int			error;		/* error return value */

C
Christoph Hellwig 已提交
844 845
	trace_xfs_dir2_block_replace(args);

L
Linus Torvalds 已提交
846 847 848 849 850 851 852 853
	/*
	 * Lookup the entry in the directory.  Get buffer and entry index.
	 * This will always succeed since the caller has already done a lookup.
	 */
	if ((error = xfs_dir2_block_lookup_int(args, &bp, &ent))) {
		return error;
	}
	dp = args->dp;
854
	hdr = bp->b_addr;
855
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
856
	blp = xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
857 858 859
	/*
	 * Point to the data entry we need to change.
	 */
860 861 862
	dep = (xfs_dir2_data_entry_t *)((char *)hdr +
			xfs_dir2_dataptr_to_off(args->geo,
						be32_to_cpu(blp[ent].address)));
863
	ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
L
Linus Torvalds 已提交
864 865 866
	/*
	 * Change the inode number to the new value.
	 */
867
	dep->inumber = cpu_to_be64(args->inumber);
868
	dp->d_ops->data_put_ftype(dep, args->filetype);
869
	xfs_dir2_data_log_entry(args, bp, dep);
870
	xfs_dir3_data_check(dp, bp);
L
Linus Torvalds 已提交
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
	return 0;
}

/*
 * Qsort comparison routine for the block leaf entries.
 */
static int					/* sort order */
xfs_dir2_block_sort(
	const void			*a,	/* first leaf entry */
	const void			*b)	/* second leaf entry */
{
	const xfs_dir2_leaf_entry_t	*la;	/* first leaf entry */
	const xfs_dir2_leaf_entry_t	*lb;	/* second leaf entry */

	la = a;
	lb = b;
887 888
	return be32_to_cpu(la->hashval) < be32_to_cpu(lb->hashval) ? -1 :
		(be32_to_cpu(la->hashval) > be32_to_cpu(lb->hashval) ? 1 : 0);
L
Linus Torvalds 已提交
889 890 891 892 893 894 895 896
}

/*
 * Convert a V2 leaf directory to a V2 block directory if possible.
 */
int						/* error */
xfs_dir2_leaf_to_block(
	xfs_da_args_t		*args,		/* operation arguments */
897 898
	struct xfs_buf		*lbp,		/* leaf buffer */
	struct xfs_buf		*dbp)		/* data buffer */
L
Linus Torvalds 已提交
899
{
900
	__be16			*bestsp;	/* leaf bests table */
901
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
902 903 904 905 906 907 908 909 910 911 912 913 914
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_inode_t		*dp;		/* incore directory inode */
	xfs_dir2_data_unused_t	*dup;		/* unused data entry */
	int			error;		/* error return value */
	int			from;		/* leaf from index */
	xfs_dir2_leaf_t		*leaf;		/* leaf structure */
	xfs_dir2_leaf_entry_t	*lep;		/* leaf entry */
	xfs_dir2_leaf_tail_t	*ltp;		/* leaf tail structure */
	xfs_mount_t		*mp;		/* file system mount point */
	int			needlog;	/* need to log data header */
	int			needscan;	/* need to scan for bestfree */
	xfs_dir2_sf_hdr_t	sfh;		/* shortform header */
	int			size;		/* bytes used */
915
	__be16			*tagp;		/* end of entry (tag) */
L
Linus Torvalds 已提交
916 917
	int			to;		/* block/leaf to index */
	xfs_trans_t		*tp;		/* transaction pointer */
918
	struct xfs_dir3_icleaf_hdr leafhdr;
L
Linus Torvalds 已提交
919

C
Christoph Hellwig 已提交
920 921
	trace_xfs_dir2_leaf_to_block(args);

L
Linus Torvalds 已提交
922 923 924
	dp = args->dp;
	tp = args->trans;
	mp = dp->i_mount;
925
	leaf = lbp->b_addr;
926
	xfs_dir2_leaf_hdr_from_disk(mp, &leafhdr, leaf);
927
	ltp = xfs_dir2_leaf_tail_p(args->geo, leaf);
928 929 930

	ASSERT(leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
	       leafhdr.magic == XFS_DIR3_LEAF1_MAGIC);
L
Linus Torvalds 已提交
931 932 933 934 935 936
	/*
	 * If there are data blocks other than the first one, take this
	 * opportunity to remove trailing empty data blocks that may have
	 * been left behind during no-space-reservation operations.
	 * These will show up in the leaf bests table.
	 */
937
	while (dp->i_d.di_size > args->geo->blksize) {
938 939
		int hdrsz;

940
		hdrsz = dp->d_ops->data_entry_offset;
941
		bestsp = xfs_dir2_leaf_bests_p(ltp);
942
		if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
943
					    args->geo->blksize - hdrsz) {
L
Linus Torvalds 已提交
944 945
			if ((error =
			    xfs_dir2_leaf_trim_data(args, lbp,
946
				    (xfs_dir2_db_t)(be32_to_cpu(ltp->bestcount) - 1))))
947 948 949
				return error;
		} else
			return 0;
L
Linus Torvalds 已提交
950 951 952 953
	}
	/*
	 * Read the data block if we don't already have it, give up if it fails.
	 */
954
	if (!dbp) {
955
		error = xfs_dir3_data_read(tp, dp, args->geo->datablk, -1, &dbp);
956 957
		if (error)
			return error;
L
Linus Torvalds 已提交
958
	}
959
	hdr = dbp->b_addr;
960 961 962
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));

L
Linus Torvalds 已提交
963 964 965
	/*
	 * Size of the "leaf" area in the block.
	 */
966
	size = (uint)sizeof(xfs_dir2_block_tail_t) +
967
	       (uint)sizeof(*lep) * (leafhdr.count - leafhdr.stale);
L
Linus Torvalds 已提交
968 969 970
	/*
	 * Look at the last data entry.
	 */
971
	tagp = (__be16 *)((char *)hdr + args->geo->blksize) - 1;
972
	dup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
L
Linus Torvalds 已提交
973 974 975
	/*
	 * If it's not free or is too short we can't do it.
	 */
976
	if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG ||
977 978 979
	    be16_to_cpu(dup->length) < size)
		return 0;

L
Linus Torvalds 已提交
980 981 982
	/*
	 * Start converting it to block form.
	 */
983
	xfs_dir3_block_init(mp, tp, dbp, dp);
984

L
Linus Torvalds 已提交
985 986 987 988 989
	needlog = 1;
	needscan = 0;
	/*
	 * Use up the space at the end of the block (blp/btp).
	 */
990 991 992 993
	error = xfs_dir2_data_use_free(args, dbp, dup,
			args->geo->blksize - size, size, &needlog, &needscan);
	if (error)
		return error;
L
Linus Torvalds 已提交
994 995 996
	/*
	 * Initialize the block tail.
	 */
997
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
998
	btp->count = cpu_to_be32(leafhdr.count - leafhdr.stale);
L
Linus Torvalds 已提交
999 1000 1001 1002 1003
	btp->stale = 0;
	xfs_dir2_block_log_tail(tp, dbp);
	/*
	 * Initialize the block leaf area.  We compact out stale entries.
	 */
1004
	lep = xfs_dir2_block_leaf_p(btp);
1005
	for (from = to = 0; from < leafhdr.count; from++) {
1006 1007
		if (leafhdr.ents[from].address ==
		    cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
L
Linus Torvalds 已提交
1008
			continue;
1009
		lep[to++] = leafhdr.ents[from];
L
Linus Torvalds 已提交
1010
	}
1011 1012
	ASSERT(to == be32_to_cpu(btp->count));
	xfs_dir2_block_log_leaf(tp, dbp, 0, be32_to_cpu(btp->count) - 1);
L
Linus Torvalds 已提交
1013 1014 1015 1016
	/*
	 * Scan the bestfree if we need it and log the data block header.
	 */
	if (needscan)
1017
		xfs_dir2_data_freescan(dp, hdr, &needlog);
L
Linus Torvalds 已提交
1018
	if (needlog)
1019
		xfs_dir2_data_log_header(args, dbp);
L
Linus Torvalds 已提交
1020 1021 1022
	/*
	 * Pitch the old leaf block.
	 */
1023
	error = xfs_da_shrink_inode(args, args->geo->leafblk, lbp);
1024 1025 1026
	if (error)
		return error;

L
Linus Torvalds 已提交
1027 1028 1029
	/*
	 * Now see if the resulting block can be shrunken to shortform.
	 */
1030
	size = xfs_dir2_block_sfsize(dp, hdr, &sfh);
1031 1032 1033
	if (size > XFS_IFORK_DSIZE(dp))
		return 0;

L
Linus Torvalds 已提交
1034 1035 1036 1037 1038 1039 1040 1041
	return xfs_dir2_block_to_sf(args, dbp, size, &sfh);
}

/*
 * Convert the shortform directory to block form.
 */
int						/* error */
xfs_dir2_sf_to_block(
1042
	struct xfs_da_args	*args)
L
Linus Torvalds 已提交
1043
{
1044 1045 1046 1047
	struct xfs_trans	*tp = args->trans;
	struct xfs_inode	*dp = args->dp;
	struct xfs_mount	*mp = dp->i_mount;
	struct xfs_ifork	*ifp = XFS_IFORK_PTR(dp, XFS_DATA_FORK);
L
Linus Torvalds 已提交
1048
	xfs_dir2_db_t		blkno;		/* dir-relative block # (0) */
1049
	xfs_dir2_data_hdr_t	*hdr;		/* block header */
L
Linus Torvalds 已提交
1050
	xfs_dir2_leaf_entry_t	*blp;		/* block leaf entries */
1051
	struct xfs_buf		*bp;		/* block buffer */
L
Linus Torvalds 已提交
1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
	xfs_dir2_block_tail_t	*btp;		/* block tail pointer */
	xfs_dir2_data_entry_t	*dep;		/* data entry pointer */
	int			dummy;		/* trash */
	xfs_dir2_data_unused_t	*dup;		/* unused entry pointer */
	int			endoffset;	/* end of data objects */
	int			error;		/* error return value */
	int			i;		/* index */
	int			needlog;	/* need to log block header */
	int			needscan;	/* need to scan block freespc */
	int			newoffset;	/* offset from current entry */
1062
	unsigned int		offset = dp->d_ops->data_entry_offset;
L
Linus Torvalds 已提交
1063
	xfs_dir2_sf_entry_t	*sfep;		/* sf entry pointer */
C
Christoph Hellwig 已提交
1064 1065
	xfs_dir2_sf_hdr_t	*oldsfp;	/* old shortform header  */
	xfs_dir2_sf_hdr_t	*sfp;		/* shortform header  */
1066
	__be16			*tagp;		/* end of data entry */
1067
	struct xfs_name		name;
L
Linus Torvalds 已提交
1068

C
Christoph Hellwig 已提交
1069 1070
	trace_xfs_dir2_sf_to_block(args);

1071
	ASSERT(ifp->if_flags & XFS_IFINLINE);
1072
	ASSERT(dp->i_d.di_size >= offsetof(struct xfs_dir2_sf_hdr, parent));
C
Christoph Hellwig 已提交
1073

1074
	oldsfp = (xfs_dir2_sf_hdr_t *)ifp->if_u1.if_data;
C
Christoph Hellwig 已提交
1075

1076 1077
	ASSERT(ifp->if_bytes == dp->i_d.di_size);
	ASSERT(ifp->if_u1.if_data != NULL);
C
Christoph Hellwig 已提交
1078
	ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(oldsfp->i8count));
1079
	ASSERT(dp->i_d.di_nextents == 0);
C
Christoph Hellwig 已提交
1080

L
Linus Torvalds 已提交
1081
	/*
C
Christoph Hellwig 已提交
1082
	 * Copy the directory into a temporary buffer.
L
Linus Torvalds 已提交
1083 1084
	 * Then pitch the incore inode data so we can make extents.
	 */
1085
	sfp = kmem_alloc(ifp->if_bytes, 0);
1086
	memcpy(sfp, oldsfp, ifp->if_bytes);
L
Linus Torvalds 已提交
1087

1088
	xfs_idata_realloc(dp, -ifp->if_bytes, XFS_DATA_FORK);
1089
	xfs_bmap_local_to_extents_empty(tp, dp, XFS_DATA_FORK);
L
Linus Torvalds 已提交
1090
	dp->i_d.di_size = 0;
C
Christoph Hellwig 已提交
1091

L
Linus Torvalds 已提交
1092 1093 1094 1095
	/*
	 * Add block 0 to the inode.
	 */
	error = xfs_dir2_grow_inode(args, XFS_DIR2_DATA_SPACE, &blkno);
1096 1097
	if (error)
		goto out_free;
L
Linus Torvalds 已提交
1098
	/*
1099
	 * Initialize the data block, then convert it to block format.
L
Linus Torvalds 已提交
1100
	 */
1101
	error = xfs_dir3_data_init(args, blkno, &bp);
1102 1103
	if (error)
		goto out_free;
1104
	xfs_dir3_block_init(mp, tp, bp, dp);
1105
	hdr = bp->b_addr;
1106

L
Linus Torvalds 已提交
1107 1108 1109 1110
	/*
	 * Compute size of block "tail" area.
	 */
	i = (uint)sizeof(*btp) +
C
Christoph Hellwig 已提交
1111
	    (sfp->count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t);
L
Linus Torvalds 已提交
1112 1113 1114 1115
	/*
	 * The whole thing is initialized to free by the init routine.
	 * Say we're using the leaf and tail area.
	 */
1116
	dup = bp->b_addr + offset;
L
Linus Torvalds 已提交
1117
	needlog = needscan = 0;
1118 1119 1120 1121
	error = xfs_dir2_data_use_free(args, bp, dup, args->geo->blksize - i,
			i, &needlog, &needscan);
	if (error)
		goto out_free;
L
Linus Torvalds 已提交
1122 1123 1124 1125
	ASSERT(needscan == 0);
	/*
	 * Fill in the tail.
	 */
1126
	btp = xfs_dir2_block_tail_p(args->geo, hdr);
C
Christoph Hellwig 已提交
1127
	btp->count = cpu_to_be32(sfp->count + 2);	/* ., .. */
L
Linus Torvalds 已提交
1128
	btp->stale = 0;
1129
	blp = xfs_dir2_block_leaf_p(btp);
1130
	endoffset = (uint)((char *)blp - (char *)hdr);
L
Linus Torvalds 已提交
1131 1132 1133
	/*
	 * Remove the freespace, we'll manage it.
	 */
1134 1135 1136 1137 1138
	error = xfs_dir2_data_use_free(args, bp, dup,
			(xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
			be16_to_cpu(dup->length), &needlog, &needscan);
	if (error)
		goto out_free;
1139

L
Linus Torvalds 已提交
1140 1141 1142
	/*
	 * Create entry for .
	 */
1143
	dep = bp->b_addr + offset;
1144
	dep->inumber = cpu_to_be64(dp->i_ino);
L
Linus Torvalds 已提交
1145 1146
	dep->namelen = 1;
	dep->name[0] = '.';
1147 1148
	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
	tagp = dp->d_ops->data_entry_tag_p(dep);
1149
	*tagp = cpu_to_be16(offset);
1150
	xfs_dir2_data_log_entry(args, bp, dep);
1151
	blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
1152
	blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(offset));
1153
	offset += xfs_dir2_data_entsize(mp, dep->namelen);
1154

L
Linus Torvalds 已提交
1155 1156 1157
	/*
	 * Create entry for ..
	 */
1158
	dep = bp->b_addr + offset;
1159
	dep->inumber = cpu_to_be64(xfs_dir2_sf_get_parent_ino(sfp));
L
Linus Torvalds 已提交
1160 1161
	dep->namelen = 2;
	dep->name[0] = dep->name[1] = '.';
1162 1163
	dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
	tagp = dp->d_ops->data_entry_tag_p(dep);
1164
	*tagp = cpu_to_be16(offset);
1165
	xfs_dir2_data_log_entry(args, bp, dep);
1166
	blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
1167
	blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(offset));
1168
	offset += xfs_dir2_data_entsize(mp, dep->namelen);
1169

L
Linus Torvalds 已提交
1170 1171 1172
	/*
	 * Loop over existing entries, stuff them in.
	 */
C
Christoph Hellwig 已提交
1173 1174
	i = 0;
	if (!sfp->count)
L
Linus Torvalds 已提交
1175 1176
		sfep = NULL;
	else
1177
		sfep = xfs_dir2_sf_firstentry(sfp);
1178

L
Linus Torvalds 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189
	/*
	 * Need to preserve the existing offset values in the sf directory.
	 * Insert holes (unused entries) where necessary.
	 */
	while (offset < endoffset) {
		/*
		 * sfep is null when we reach the end of the list.
		 */
		if (sfep == NULL)
			newoffset = endoffset;
		else
1190
			newoffset = xfs_dir2_sf_get_offset(sfep);
L
Linus Torvalds 已提交
1191 1192 1193 1194
		/*
		 * There should be a hole here, make one.
		 */
		if (offset < newoffset) {
1195
			dup = bp->b_addr + offset;
1196 1197
			dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
			dup->length = cpu_to_be16(newoffset - offset);
1198
			*xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(offset);
1199
			xfs_dir2_data_log_unused(args, bp, dup);
1200 1201 1202
			xfs_dir2_data_freeinsert(hdr,
						 dp->d_ops->data_bestfree_p(hdr),
						 dup, &dummy);
1203
			offset += be16_to_cpu(dup->length);
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208
			continue;
		}
		/*
		 * Copy a real entry.
		 */
1209
		dep = bp->b_addr + newoffset;
1210
		dep->inumber = cpu_to_be64(xfs_dir2_sf_get_ino(mp, sfp, sfep));
L
Linus Torvalds 已提交
1211
		dep->namelen = sfep->namelen;
1212
		dp->d_ops->data_put_ftype(dep, xfs_dir2_sf_get_ftype(mp, sfep));
L
Linus Torvalds 已提交
1213
		memcpy(dep->name, sfep->name, dep->namelen);
1214
		tagp = dp->d_ops->data_entry_tag_p(dep);
1215
		*tagp = cpu_to_be16(newoffset);
1216
		xfs_dir2_data_log_entry(args, bp, dep);
1217 1218
		name.name = sfep->name;
		name.len = sfep->namelen;
1219 1220 1221 1222
		blp[2 + i].hashval =
			cpu_to_be32(mp->m_dirnameops->hashname(&name));
		blp[2 + i].address =
			cpu_to_be32(xfs_dir2_byte_to_dataptr(newoffset));
1223
		offset = (int)((char *)(tagp + 1) - (char *)hdr);
C
Christoph Hellwig 已提交
1224
		if (++i == sfp->count)
L
Linus Torvalds 已提交
1225 1226
			sfep = NULL;
		else
1227
			sfep = xfs_dir2_sf_nextentry(mp, sfp, sfep);
L
Linus Torvalds 已提交
1228 1229
	}
	/* Done with the temporary buffer */
C
Christoph Hellwig 已提交
1230
	kmem_free(sfp);
L
Linus Torvalds 已提交
1231 1232 1233
	/*
	 * Sort the leaf entries by hash value.
	 */
1234
	xfs_sort(blp, be32_to_cpu(btp->count), sizeof(*blp), xfs_dir2_block_sort);
L
Linus Torvalds 已提交
1235 1236 1237 1238 1239
	/*
	 * Log the leaf entry area and tail.
	 * Already logged the header in data_init, ignore needlog.
	 */
	ASSERT(needscan == 0);
1240
	xfs_dir2_block_log_leaf(tp, bp, 0, be32_to_cpu(btp->count) - 1);
L
Linus Torvalds 已提交
1241
	xfs_dir2_block_log_tail(tp, bp);
1242
	xfs_dir3_data_check(dp, bp);
L
Linus Torvalds 已提交
1243
	return 0;
1244 1245 1246
out_free:
	kmem_free(sfp);
	return error;
L
Linus Torvalds 已提交
1247
}