xfs_dir2_data.c 30.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
3
 * Copyright (c) 2013 Red Hat, Inc.
4
 * All Rights Reserved.
L
Linus Torvalds 已提交
5
 *
6 7
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
8 9
 * published by the Free Software Foundation.
 *
10 11 12 13
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
14
 *
15 16 17
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
18 19
 */
#include "xfs.h"
20
#include "xfs_fs.h"
21
#include "xfs_format.h"
22 23
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
L
Linus Torvalds 已提交
24
#include "xfs_mount.h"
25
#include "xfs_da_format.h"
26
#include "xfs_da_btree.h"
L
Linus Torvalds 已提交
27
#include "xfs_inode.h"
28
#include "xfs_dir2.h"
C
Christoph Hellwig 已提交
29
#include "xfs_dir2_priv.h"
L
Linus Torvalds 已提交
30
#include "xfs_error.h"
31
#include "xfs_trans.h"
32 33
#include "xfs_buf_item.h"
#include "xfs_cksum.h"
34
#include "xfs_log.h"
L
Linus Torvalds 已提交
35 36 37 38

/*
 * Check the consistency of the data block.
 * The input can also be a block-format directory.
39
 * Return 0 is the buffer is good, otherwise an error.
L
Linus Torvalds 已提交
40
 */
41
int
42
__xfs_dir3_data_check(
43 44
	struct xfs_inode	*dp,		/* incore inode pointer */
	struct xfs_buf		*bp)		/* data block's buffer */
L
Linus Torvalds 已提交
45 46 47 48 49
{
	xfs_dir2_dataptr_t	addr;		/* addr for leaf lookup */
	xfs_dir2_data_free_t	*bf;		/* bestfree table */
	xfs_dir2_block_tail_t	*btp=NULL;	/* block tail */
	int			count;		/* count of entries found */
50
	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
L
Linus Torvalds 已提交
51 52 53 54 55 56 57 58 59 60 61 62
	xfs_dir2_data_entry_t	*dep;		/* data entry */
	xfs_dir2_data_free_t	*dfp;		/* bestfree entry */
	xfs_dir2_data_unused_t	*dup;		/* unused entry */
	char			*endp;		/* end of useful data */
	int			freeseen;	/* mask of bestfrees seen */
	xfs_dahash_t		hash;		/* hash of current name */
	int			i;		/* leaf index */
	int			lastfree;	/* last entry was unused */
	xfs_dir2_leaf_entry_t	*lep=NULL;	/* block leaf entries */
	xfs_mount_t		*mp;		/* filesystem mount point */
	char			*p;		/* current data position */
	int			stale;		/* count of stale leaves */
63
	struct xfs_name		name;
64
	const struct xfs_dir_ops *ops;
65
	struct xfs_da_geometry	*geo;
L
Linus Torvalds 已提交
66

67
	mp = bp->b_target->bt_mount;
68
	geo = mp->m_dir_geo;
69

70
	/*
71 72
	 * We can be passed a null dp here from a verifier, so we need to go the
	 * hard way to get them.
73
	 */
74
	ops = xfs_dir_get_ops(mp, dp);
75

76 77 78
	hdr = bp->b_addr;
	p = (char *)ops->data_entry_p(hdr);

79
	switch (hdr->magic) {
80
	case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
81
	case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
82
		btp = xfs_dir2_block_tail_p(geo, hdr);
83
		lep = xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
84
		endp = (char *)lep;
85 86 87 88 89 90 91 92

		/*
		 * The number of leaf entries is limited by the size of the
		 * block and the amount of space used by the data entries.
		 * We don't know how much space is used by the data entries yet,
		 * so just ensure that the count falls somewhere inside the
		 * block right now.
		 */
93
		XFS_WANT_CORRUPTED_RETURN(mp, be32_to_cpu(btp->count) <
94
			((char *)btp - p) / sizeof(struct xfs_dir2_leaf_entry));
95
		break;
96
	case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
97
	case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
98
		endp = (char *)hdr + geo->blksize;
99 100 101
		break;
	default:
		XFS_ERROR_REPORT("Bad Magic", XFS_ERRLEVEL_LOW, mp);
D
Dave Chinner 已提交
102
		return -EFSCORRUPTED;
103 104
	}

L
Linus Torvalds 已提交
105 106 107
	/*
	 * Account for zero bestfree entries.
	 */
108 109
	bf = ops->data_bestfree_p(hdr);
	count = lastfree = freeseen = 0;
L
Linus Torvalds 已提交
110
	if (!bf[0].length) {
111
		XFS_WANT_CORRUPTED_RETURN(mp, !bf[0].offset);
L
Linus Torvalds 已提交
112 113 114
		freeseen |= 1 << 0;
	}
	if (!bf[1].length) {
115
		XFS_WANT_CORRUPTED_RETURN(mp, !bf[1].offset);
L
Linus Torvalds 已提交
116 117 118
		freeseen |= 1 << 1;
	}
	if (!bf[2].length) {
119
		XFS_WANT_CORRUPTED_RETURN(mp, !bf[2].offset);
L
Linus Torvalds 已提交
120 121
		freeseen |= 1 << 2;
	}
122

123
	XFS_WANT_CORRUPTED_RETURN(mp, be16_to_cpu(bf[0].length) >=
124
						be16_to_cpu(bf[1].length));
125
	XFS_WANT_CORRUPTED_RETURN(mp, be16_to_cpu(bf[1].length) >=
126
						be16_to_cpu(bf[2].length));
L
Linus Torvalds 已提交
127 128 129 130 131 132 133 134 135 136
	/*
	 * Loop over the data/unused entries.
	 */
	while (p < endp) {
		dup = (xfs_dir2_data_unused_t *)p;
		/*
		 * If it's unused, look for the space in the bestfree table.
		 * If we find it, account for that, else make sure it
		 * doesn't need to be there.
		 */
137
		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
138 139
			XFS_WANT_CORRUPTED_RETURN(mp, lastfree == 0);
			XFS_WANT_CORRUPTED_RETURN(mp,
140 141
				be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) ==
					       (char *)dup - (char *)hdr);
142
			dfp = xfs_dir2_data_freefind(hdr, bf, dup);
L
Linus Torvalds 已提交
143 144
			if (dfp) {
				i = (int)(dfp - bf);
145
				XFS_WANT_CORRUPTED_RETURN(mp,
146
					(freeseen & (1 << i)) == 0);
L
Linus Torvalds 已提交
147
				freeseen |= 1 << i;
148
			} else {
149
				XFS_WANT_CORRUPTED_RETURN(mp,
150 151
					be16_to_cpu(dup->length) <=
						be16_to_cpu(bf[2].length));
152
			}
153
			p += be16_to_cpu(dup->length);
L
Linus Torvalds 已提交
154 155 156 157 158 159 160 161 162 163
			lastfree = 1;
			continue;
		}
		/*
		 * It's a real entry.  Validate the fields.
		 * If this is a block directory then make sure it's
		 * in the leaf section of the block.
		 * The linear search is crude but this is DEBUG code.
		 */
		dep = (xfs_dir2_data_entry_t *)p;
164 165
		XFS_WANT_CORRUPTED_RETURN(mp, dep->namelen != 0);
		XFS_WANT_CORRUPTED_RETURN(mp,
166
			!xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)));
167
		XFS_WANT_CORRUPTED_RETURN(mp,
168
			be16_to_cpu(*ops->data_entry_tag_p(dep)) ==
169
					       (char *)dep - (char *)hdr);
170
		XFS_WANT_CORRUPTED_RETURN(mp,
171
				ops->data_get_ftype(dep) < XFS_DIR3_FT_MAX);
L
Linus Torvalds 已提交
172 173
		count++;
		lastfree = 0;
174 175
		if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
		    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
176 177 178
			addr = xfs_dir2_db_off_to_dataptr(geo, geo->datablk,
						(xfs_dir2_data_aoff_t)
						((char *)dep - (char *)hdr));
179 180 181
			name.name = dep->name;
			name.len = dep->namelen;
			hash = mp->m_dirnameops->hashname(&name);
182
			for (i = 0; i < be32_to_cpu(btp->count); i++) {
183 184
				if (be32_to_cpu(lep[i].address) == addr &&
				    be32_to_cpu(lep[i].hashval) == hash)
L
Linus Torvalds 已提交
185 186
					break;
			}
187 188
			XFS_WANT_CORRUPTED_RETURN(mp,
						  i < be32_to_cpu(btp->count));
L
Linus Torvalds 已提交
189
		}
190
		p += ops->data_entsize(dep->namelen);
L
Linus Torvalds 已提交
191 192 193 194
	}
	/*
	 * Need to have seen all the entries and all the bestfree slots.
	 */
195
	XFS_WANT_CORRUPTED_RETURN(mp, freeseen == 7);
196 197
	if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
198
		for (i = stale = 0; i < be32_to_cpu(btp->count); i++) {
199 200
			if (lep[i].address ==
			    cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
L
Linus Torvalds 已提交
201 202
				stale++;
			if (i > 0)
203
				XFS_WANT_CORRUPTED_RETURN(mp,
204 205
					be32_to_cpu(lep[i].hashval) >=
						be32_to_cpu(lep[i - 1].hashval));
L
Linus Torvalds 已提交
206
		}
207
		XFS_WANT_CORRUPTED_RETURN(mp, count ==
208
			be32_to_cpu(btp->count) - be32_to_cpu(btp->stale));
209
		XFS_WANT_CORRUPTED_RETURN(mp, stale == be32_to_cpu(btp->stale));
L
Linus Torvalds 已提交
210
	}
211
	return 0;
L
Linus Torvalds 已提交
212 213
}

214 215
static bool
xfs_dir3_data_verify(
216 217 218
	struct xfs_buf		*bp)
{
	struct xfs_mount	*mp = bp->b_target->bt_mount;
219
	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;
220

221 222 223
	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		if (hdr3->magic != cpu_to_be32(XFS_DIR3_DATA_MAGIC))
			return false;
224
		if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_meta_uuid))
225 226 227
			return false;
		if (be64_to_cpu(hdr3->blkno) != bp->b_bn)
			return false;
228 229
		if (!xfs_log_check_lsn(mp, be64_to_cpu(hdr3->lsn)))
			return false;
230 231 232
	} else {
		if (hdr3->magic != cpu_to_be32(XFS_DIR2_DATA_MAGIC))
			return false;
233
	}
234 235 236
	if (__xfs_dir3_data_check(NULL, bp))
		return false;
	return true;
237 238
}

239 240 241 242 243 244
/*
 * Readahead of the first block of the directory when it is opened is completely
 * oblivious to the format of the directory. Hence we can either get a block
 * format buffer or a data format buffer on readahead.
 */
static void
245
xfs_dir3_data_reada_verify(
246 247 248 249 250 251
	struct xfs_buf		*bp)
{
	struct xfs_dir2_data_hdr *hdr = bp->b_addr;

	switch (hdr->magic) {
	case cpu_to_be32(XFS_DIR2_BLOCK_MAGIC):
252 253
	case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
		bp->b_ops = &xfs_dir3_block_buf_ops;
254 255 256
		bp->b_ops->verify_read(bp);
		return;
	case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
257
	case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
258 259
		bp->b_ops = &xfs_dir3_data_buf_ops;
		bp->b_ops->verify_read(bp);
260 261
		return;
	default:
D
Dave Chinner 已提交
262
		xfs_buf_ioerror(bp, -EFSCORRUPTED);
263
		xfs_verifier_error(bp);
264 265 266 267 268
		break;
	}
}

static void
269
xfs_dir3_data_read_verify(
270 271
	struct xfs_buf	*bp)
{
272 273
	struct xfs_mount	*mp = bp->b_target->bt_mount;

274 275
	if (xfs_sb_version_hascrc(&mp->m_sb) &&
	     !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))
D
Dave Chinner 已提交
276
		 xfs_buf_ioerror(bp, -EFSBADCRC);
277
	else if (!xfs_dir3_data_verify(bp))
D
Dave Chinner 已提交
278
		xfs_buf_ioerror(bp, -EFSCORRUPTED);
279 280 281

	if (bp->b_error)
		xfs_verifier_error(bp);
282
}
283

284
static void
285
xfs_dir3_data_write_verify(
286 287
	struct xfs_buf	*bp)
{
288 289 290 291 292
	struct xfs_mount	*mp = bp->b_target->bt_mount;
	struct xfs_buf_log_item	*bip = bp->b_fspriv;
	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;

	if (!xfs_dir3_data_verify(bp)) {
D
Dave Chinner 已提交
293
		xfs_buf_ioerror(bp, -EFSCORRUPTED);
294
		xfs_verifier_error(bp);
295 296 297 298 299 300 301 302 303
		return;
	}

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

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

304
	xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);
305 306
}

307
const struct xfs_buf_ops xfs_dir3_data_buf_ops = {
308
	.name = "xfs_dir3_data",
309 310
	.verify_read = xfs_dir3_data_read_verify,
	.verify_write = xfs_dir3_data_write_verify,
311 312
};

313
static const struct xfs_buf_ops xfs_dir3_data_reada_buf_ops = {
314
	.name = "xfs_dir3_data_reada",
315 316
	.verify_read = xfs_dir3_data_reada_verify,
	.verify_write = xfs_dir3_data_write_verify,
317 318
};

319

320
int
321
xfs_dir3_data_read(
322 323 324 325 326 327
	struct xfs_trans	*tp,
	struct xfs_inode	*dp,
	xfs_dablk_t		bno,
	xfs_daddr_t		mapped_bno,
	struct xfs_buf		**bpp)
{
328 329 330
	int			err;

	err = xfs_da_read_buf(tp, dp, bno, mapped_bno, bpp,
331
				XFS_DATA_FORK, &xfs_dir3_data_buf_ops);
332
	if (!err && tp)
333
		xfs_trans_buf_set_type(tp, *bpp, XFS_BLFT_DIR_DATA_BUF);
334
	return err;
335 336
}

337
int
338
xfs_dir3_data_readahead(
339 340 341 342
	struct xfs_inode	*dp,
	xfs_dablk_t		bno,
	xfs_daddr_t		mapped_bno)
{
343
	return xfs_da_reada_buf(dp, bno, mapped_bno,
344
				XFS_DATA_FORK, &xfs_dir3_data_reada_buf_ops);
345 346
}

L
Linus Torvalds 已提交
347 348 349 350
/*
 * Given a data block and an unused entry from that block,
 * return the bestfree entry if any that corresponds to it.
 */
351
xfs_dir2_data_free_t *
L
Linus Torvalds 已提交
352
xfs_dir2_data_freefind(
353 354 355
	struct xfs_dir2_data_hdr *hdr,		/* data block header */
	struct xfs_dir2_data_free *bf,		/* bestfree table pointer */
	struct xfs_dir2_data_unused *dup)	/* unused space */
L
Linus Torvalds 已提交
356 357 358
{
	xfs_dir2_data_free_t	*dfp;		/* bestfree entry */
	xfs_dir2_data_aoff_t	off;		/* offset value needed */
359
#ifdef DEBUG
L
Linus Torvalds 已提交
360 361 362 363
	int			matched;	/* matched the value */
	int			seenzero;	/* saw a 0 bestfree entry */
#endif

364
	off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
365

366
#ifdef DEBUG
L
Linus Torvalds 已提交
367 368 369 370 371
	/*
	 * Validate some consistency in the bestfree table.
	 * Check order, non-overlapping entries, and if we find the
	 * one we're looking for it has to be exact.
	 */
372
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
373
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
374 375 376 377
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
	for (dfp = &bf[0], seenzero = matched = 0;
	     dfp < &bf[XFS_DIR2_DATA_FD_COUNT];
L
Linus Torvalds 已提交
378 379 380 381 382 383 384
	     dfp++) {
		if (!dfp->offset) {
			ASSERT(!dfp->length);
			seenzero = 1;
			continue;
		}
		ASSERT(seenzero == 0);
385
		if (be16_to_cpu(dfp->offset) == off) {
L
Linus Torvalds 已提交
386
			matched = 1;
387
			ASSERT(dfp->length == dup->length);
388
		} else if (off < be16_to_cpu(dfp->offset))
389
			ASSERT(off + be16_to_cpu(dup->length) <= be16_to_cpu(dfp->offset));
L
Linus Torvalds 已提交
390
		else
391
			ASSERT(be16_to_cpu(dfp->offset) + be16_to_cpu(dfp->length) <= off);
392
		ASSERT(matched || be16_to_cpu(dfp->length) >= be16_to_cpu(dup->length));
393
		if (dfp > &bf[0])
394
			ASSERT(be16_to_cpu(dfp[-1].length) >= be16_to_cpu(dfp[0].length));
L
Linus Torvalds 已提交
395 396 397 398 399 400
	}
#endif
	/*
	 * If this is smaller than the smallest bestfree entry,
	 * it can't be there since they're sorted.
	 */
401
	if (be16_to_cpu(dup->length) <
402
	    be16_to_cpu(bf[XFS_DIR2_DATA_FD_COUNT - 1].length))
L
Linus Torvalds 已提交
403 404 405 406
		return NULL;
	/*
	 * Look at the three bestfree entries for our guy.
	 */
407
	for (dfp = &bf[0]; dfp < &bf[XFS_DIR2_DATA_FD_COUNT]; dfp++) {
L
Linus Torvalds 已提交
408 409
		if (!dfp->offset)
			return NULL;
410
		if (be16_to_cpu(dfp->offset) == off)
L
Linus Torvalds 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423
			return dfp;
	}
	/*
	 * Didn't find it.  This only happens if there are duplicate lengths.
	 */
	return NULL;
}

/*
 * Insert an unused-space entry into the bestfree table.
 */
xfs_dir2_data_free_t *				/* entry inserted */
xfs_dir2_data_freeinsert(
424 425 426
	struct xfs_dir2_data_hdr *hdr,		/* data block pointer */
	struct xfs_dir2_data_free *dfp,		/* bestfree table pointer */
	struct xfs_dir2_data_unused *dup,	/* unused space */
L
Linus Torvalds 已提交
427 428 429 430
	int			*loghead)	/* log the data header (out) */
{
	xfs_dir2_data_free_t	new;		/* new bestfree entry */

431
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
432 433 434 435
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));

436
	new.length = dup->length;
437 438
	new.offset = cpu_to_be16((char *)dup - (char *)hdr);

L
Linus Torvalds 已提交
439 440 441
	/*
	 * Insert at position 0, 1, or 2; or not at all.
	 */
442
	if (be16_to_cpu(new.length) > be16_to_cpu(dfp[0].length)) {
L
Linus Torvalds 已提交
443 444 445 446 447 448
		dfp[2] = dfp[1];
		dfp[1] = dfp[0];
		dfp[0] = new;
		*loghead = 1;
		return &dfp[0];
	}
449
	if (be16_to_cpu(new.length) > be16_to_cpu(dfp[1].length)) {
L
Linus Torvalds 已提交
450 451 452 453 454
		dfp[2] = dfp[1];
		dfp[1] = new;
		*loghead = 1;
		return &dfp[1];
	}
455
	if (be16_to_cpu(new.length) > be16_to_cpu(dfp[2].length)) {
L
Linus Torvalds 已提交
456 457 458 459 460 461 462 463 464 465
		dfp[2] = new;
		*loghead = 1;
		return &dfp[2];
	}
	return NULL;
}

/*
 * Remove a bestfree entry from the table.
 */
466
STATIC void
L
Linus Torvalds 已提交
467
xfs_dir2_data_freeremove(
468 469 470
	struct xfs_dir2_data_hdr *hdr,		/* data block header */
	struct xfs_dir2_data_free *bf,		/* bestfree table pointer */
	struct xfs_dir2_data_free *dfp,		/* bestfree entry pointer */
L
Linus Torvalds 已提交
471 472
	int			*loghead)	/* out: log data header */
{
473

474
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
475 476 477 478
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));

L
Linus Torvalds 已提交
479 480 481
	/*
	 * It's the first entry, slide the next 2 up.
	 */
482 483 484
	if (dfp == &bf[0]) {
		bf[0] = bf[1];
		bf[1] = bf[2];
L
Linus Torvalds 已提交
485 486 487 488
	}
	/*
	 * It's the second entry, slide the 3rd entry up.
	 */
489 490
	else if (dfp == &bf[1])
		bf[1] = bf[2];
L
Linus Torvalds 已提交
491 492 493 494
	/*
	 * Must be the last entry.
	 */
	else
495
		ASSERT(dfp == &bf[2]);
L
Linus Torvalds 已提交
496 497 498
	/*
	 * Clear the 3rd entry, must be zero now.
	 */
499 500
	bf[2].length = 0;
	bf[2].offset = 0;
L
Linus Torvalds 已提交
501 502 503 504 505 506 507 508
	*loghead = 1;
}

/*
 * Given a data block, reconstruct its bestfree map.
 */
void
xfs_dir2_data_freescan(
509 510 511
	struct xfs_inode	*dp,
	struct xfs_dir2_data_hdr *hdr,
	int			*loghead)
L
Linus Torvalds 已提交
512 513 514 515
{
	xfs_dir2_block_tail_t	*btp;		/* block tail */
	xfs_dir2_data_entry_t	*dep;		/* active data entry */
	xfs_dir2_data_unused_t	*dup;		/* unused data entry */
516
	struct xfs_dir2_data_free *bf;
L
Linus Torvalds 已提交
517 518
	char			*endp;		/* end of block's data */
	char			*p;		/* current entry pointer */
519
	struct xfs_da_geometry	*geo = dp->i_mount->m_dir_geo;
L
Linus Torvalds 已提交
520

521
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
522
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
523 524 525
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));

L
Linus Torvalds 已提交
526 527 528
	/*
	 * Start by clearing the table.
	 */
529
	bf = dp->d_ops->data_bestfree_p(hdr);
530
	memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
L
Linus Torvalds 已提交
531 532 533 534
	*loghead = 1;
	/*
	 * Set up pointers.
	 */
535
	p = (char *)dp->d_ops->data_entry_p(hdr);
536 537
	if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
538
		btp = xfs_dir2_block_tail_p(geo, hdr);
539
		endp = (char *)xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
540
	} else
541
		endp = (char *)hdr + geo->blksize;
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549
	/*
	 * Loop over the block's entries.
	 */
	while (p < endp) {
		dup = (xfs_dir2_data_unused_t *)p;
		/*
		 * If it's a free entry, insert it.
		 */
550
		if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
551
			ASSERT((char *)dup - (char *)hdr ==
552
			       be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
553
			xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
554
			p += be16_to_cpu(dup->length);
L
Linus Torvalds 已提交
555 556 557 558 559 560
		}
		/*
		 * For active entries, check their tags and skip them.
		 */
		else {
			dep = (xfs_dir2_data_entry_t *)p;
561
			ASSERT((char *)dep - (char *)hdr ==
562 563
			       be16_to_cpu(*dp->d_ops->data_entry_tag_p(dep)));
			p += dp->d_ops->data_entsize(dep->namelen);
L
Linus Torvalds 已提交
564 565 566 567 568 569 570 571 572
		}
	}
}

/*
 * Initialize a data block at the given block number in the directory.
 * Give back the buffer for the created block.
 */
int						/* error */
573
xfs_dir3_data_init(
L
Linus Torvalds 已提交
574 575
	xfs_da_args_t		*args,		/* directory operation args */
	xfs_dir2_db_t		blkno,		/* logical dir block number */
576
	struct xfs_buf		**bpp)		/* output block buffer */
L
Linus Torvalds 已提交
577
{
578
	struct xfs_buf		*bp;		/* block buffer */
579
	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
L
Linus Torvalds 已提交
580 581
	xfs_inode_t		*dp;		/* incore directory inode */
	xfs_dir2_data_unused_t	*dup;		/* unused entry pointer */
582
	struct xfs_dir2_data_free *bf;
L
Linus Torvalds 已提交
583 584 585 586 587 588 589 590 591 592 593 594
	int			error;		/* error return value */
	int			i;		/* bestfree index */
	xfs_mount_t		*mp;		/* filesystem mount point */
	xfs_trans_t		*tp;		/* transaction pointer */
	int                     t;              /* temp */

	dp = args->dp;
	mp = dp->i_mount;
	tp = args->trans;
	/*
	 * Get the buffer set up for the block.
	 */
595 596
	error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(args->geo, blkno),
			       -1, &bp, XFS_DATA_FORK);
597
	if (error)
L
Linus Torvalds 已提交
598
		return error;
599
	bp->b_ops = &xfs_dir3_data_buf_ops;
600
	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_DATA_BUF);
601

L
Linus Torvalds 已提交
602 603 604
	/*
	 * Initialize the header.
	 */
605
	hdr = bp->b_addr;
606 607 608 609 610 611 612
	if (xfs_sb_version_hascrc(&mp->m_sb)) {
		struct xfs_dir3_blk_hdr *hdr3 = bp->b_addr;

		memset(hdr3, 0, sizeof(*hdr3));
		hdr3->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
		hdr3->blkno = cpu_to_be64(bp->b_bn);
		hdr3->owner = cpu_to_be64(dp->i_ino);
613
		uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);
614 615 616 617

	} else
		hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);

618
	bf = dp->d_ops->data_bestfree_p(hdr);
619
	bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset);
L
Linus Torvalds 已提交
620
	for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
621 622
		bf[i].length = 0;
		bf[i].offset = 0;
L
Linus Torvalds 已提交
623
	}
624

L
Linus Torvalds 已提交
625 626 627
	/*
	 * Set up an unused entry for the block's body.
	 */
628
	dup = dp->d_ops->data_unused_p(hdr);
629
	dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
L
Linus Torvalds 已提交
630

631
	t = args->geo->blksize - (uint)dp->d_ops->data_entry_offset;
632
	bf[0].length = cpu_to_be16(t);
633
	dup->length = cpu_to_be16(t);
634
	*xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
L
Linus Torvalds 已提交
635 636 637
	/*
	 * Log it and return it.
	 */
638 639
	xfs_dir2_data_log_header(args, bp);
	xfs_dir2_data_log_unused(args, bp, dup);
L
Linus Torvalds 已提交
640 641 642 643 644 645 646 647 648
	*bpp = bp;
	return 0;
}

/*
 * Log an active data entry from the block.
 */
void
xfs_dir2_data_log_entry(
649
	struct xfs_da_args	*args,
650
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
651 652
	xfs_dir2_data_entry_t	*dep)		/* data entry pointer */
{
653
	struct xfs_dir2_data_hdr *hdr = bp->b_addr;
L
Linus Torvalds 已提交
654

655
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
656
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
657 658
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
659

660 661
	xfs_trans_log_buf(args->trans, bp, (uint)((char *)dep - (char *)hdr),
		(uint)((char *)(args->dp->d_ops->data_entry_tag_p(dep) + 1) -
662
		       (char *)hdr - 1));
L
Linus Torvalds 已提交
663 664 665 666 667 668 669
}

/*
 * Log a data block header.
 */
void
xfs_dir2_data_log_header(
670
	struct xfs_da_args	*args,
671
	struct xfs_buf		*bp)
L
Linus Torvalds 已提交
672
{
673 674
#ifdef DEBUG
	struct xfs_dir2_data_hdr *hdr = bp->b_addr;
L
Linus Torvalds 已提交
675

676
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
677
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
678 679
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
680
#endif
681

682 683
	xfs_trans_log_buf(args->trans, bp, 0,
			  args->dp->d_ops->data_entry_offset - 1);
L
Linus Torvalds 已提交
684 685 686 687 688 689 690
}

/*
 * Log a data unused entry.
 */
void
xfs_dir2_data_log_unused(
691
	struct xfs_da_args	*args,
692
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
693 694
	xfs_dir2_data_unused_t	*dup)		/* data unused pointer */
{
695
	xfs_dir2_data_hdr_t	*hdr = bp->b_addr;
696

697
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
698
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
699 700
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
L
Linus Torvalds 已提交
701 702 703 704

	/*
	 * Log the first part of the unused entry.
	 */
705
	xfs_trans_log_buf(args->trans, bp, (uint)((char *)dup - (char *)hdr),
L
Linus Torvalds 已提交
706
		(uint)((char *)&dup->length + sizeof(dup->length) -
707
		       1 - (char *)hdr));
L
Linus Torvalds 已提交
708 709 710
	/*
	 * Log the end (tag) of the unused entry.
	 */
711
	xfs_trans_log_buf(args->trans, bp,
712 713
		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr),
		(uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)hdr +
L
Linus Torvalds 已提交
714 715 716 717 718 719 720 721 722
		       sizeof(xfs_dir2_data_off_t) - 1));
}

/*
 * Make a byte range in the data block unused.
 * Its current contents are unimportant.
 */
void
xfs_dir2_data_make_free(
723
	struct xfs_da_args	*args,
724
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
725 726 727 728 729
	xfs_dir2_data_aoff_t	offset,		/* starting byte offset */
	xfs_dir2_data_aoff_t	len,		/* length in bytes */
	int			*needlogp,	/* out: log header */
	int			*needscanp)	/* out: regen bestfree */
{
730
	xfs_dir2_data_hdr_t	*hdr;		/* data block pointer */
L
Linus Torvalds 已提交
731 732 733 734 735 736
	xfs_dir2_data_free_t	*dfp;		/* bestfree pointer */
	char			*endptr;	/* end of data area */
	int			needscan;	/* need to regen bestfree */
	xfs_dir2_data_unused_t	*newdup;	/* new unused entry */
	xfs_dir2_data_unused_t	*postdup;	/* unused entry after us */
	xfs_dir2_data_unused_t	*prevdup;	/* unused entry before us */
737
	struct xfs_dir2_data_free *bf;
L
Linus Torvalds 已提交
738

739
	hdr = bp->b_addr;
740

L
Linus Torvalds 已提交
741 742 743
	/*
	 * Figure out where the end of the data area is.
	 */
744 745
	if (hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
	    hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC))
746
		endptr = (char *)hdr + args->geo->blksize;
L
Linus Torvalds 已提交
747 748 749
	else {
		xfs_dir2_block_tail_t	*btp;	/* block tail */

750 751
		ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
			hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
752
		btp = xfs_dir2_block_tail_p(args->geo, hdr);
753
		endptr = (char *)xfs_dir2_block_leaf_p(btp);
L
Linus Torvalds 已提交
754 755 756 757 758
	}
	/*
	 * If this isn't the start of the block, then back up to
	 * the previous entry and see if it's free.
	 */
759
	if (offset > args->dp->d_ops->data_entry_offset) {
760
		__be16			*tagp;	/* tag just before us */
L
Linus Torvalds 已提交
761

762 763
		tagp = (__be16 *)((char *)hdr + offset) - 1;
		prevdup = (xfs_dir2_data_unused_t *)((char *)hdr + be16_to_cpu(*tagp));
764
		if (be16_to_cpu(prevdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
L
Linus Torvalds 已提交
765 766 767 768 769 770 771
			prevdup = NULL;
	} else
		prevdup = NULL;
	/*
	 * If this isn't the end of the block, see if the entry after
	 * us is free.
	 */
772
	if ((char *)hdr + offset + len < endptr) {
L
Linus Torvalds 已提交
773
		postdup =
774
			(xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
775
		if (be16_to_cpu(postdup->freetag) != XFS_DIR2_DATA_FREE_TAG)
L
Linus Torvalds 已提交
776 777 778 779 780 781 782 783 784
			postdup = NULL;
	} else
		postdup = NULL;
	ASSERT(*needscanp == 0);
	needscan = 0;
	/*
	 * Previous and following entries are both free,
	 * merge everything into a single free entry.
	 */
785
	bf = args->dp->d_ops->data_bestfree_p(hdr);
L
Linus Torvalds 已提交
786 787 788 789 790 791
	if (prevdup && postdup) {
		xfs_dir2_data_free_t	*dfp2;	/* another bestfree pointer */

		/*
		 * See if prevdup and/or postdup are in bestfree table.
		 */
792 793
		dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
		dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
L
Linus Torvalds 已提交
794 795 796 797 798 799
		/*
		 * We need a rescan unless there are exactly 2 free entries
		 * namely our two.  Then we know what's happening, otherwise
		 * since the third bestfree is there, there might be more
		 * entries.
		 */
800
		needscan = (bf[2].length != 0);
L
Linus Torvalds 已提交
801 802 803
		/*
		 * Fix up the new big freespace.
		 */
804
		be16_add_cpu(&prevdup->length, len + be16_to_cpu(postdup->length));
805
		*xfs_dir2_data_unused_tag_p(prevdup) =
806
			cpu_to_be16((char *)prevdup - (char *)hdr);
807
		xfs_dir2_data_log_unused(args, bp, prevdup);
L
Linus Torvalds 已提交
808 809 810 811 812 813 814 815
		if (!needscan) {
			/*
			 * Has to be the case that entries 0 and 1 are
			 * dfp and dfp2 (don't know which is which), and
			 * entry 2 is empty.
			 * Remove entry 1 first then entry 0.
			 */
			ASSERT(dfp && dfp2);
816 817
			if (dfp == &bf[1]) {
				dfp = &bf[0];
L
Linus Torvalds 已提交
818
				ASSERT(dfp2 == dfp);
819
				dfp2 = &bf[1];
L
Linus Torvalds 已提交
820
			}
821 822
			xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
			xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
L
Linus Torvalds 已提交
823 824 825
			/*
			 * Now insert the new entry.
			 */
826 827
			dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
						       needlogp);
828
			ASSERT(dfp == &bf[0]);
829
			ASSERT(dfp->length == prevdup->length);
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837
			ASSERT(!dfp[1].length);
			ASSERT(!dfp[2].length);
		}
	}
	/*
	 * The entry before us is free, merge with it.
	 */
	else if (prevdup) {
838
		dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
839
		be16_add_cpu(&prevdup->length, len);
840
		*xfs_dir2_data_unused_tag_p(prevdup) =
841
			cpu_to_be16((char *)prevdup - (char *)hdr);
842
		xfs_dir2_data_log_unused(args, bp, prevdup);
L
Linus Torvalds 已提交
843 844 845 846 847 848
		/*
		 * If the previous entry was in the table, the new entry
		 * is longer, so it will be in the table too.  Remove
		 * the old one and add the new one.
		 */
		if (dfp) {
849 850
			xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
			xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
L
Linus Torvalds 已提交
851 852 853 854
		}
		/*
		 * Otherwise we need a scan if the new entry is big enough.
		 */
855
		else {
856
			needscan = be16_to_cpu(prevdup->length) >
857
				   be16_to_cpu(bf[2].length);
858
		}
L
Linus Torvalds 已提交
859 860 861 862 863
	}
	/*
	 * The following entry is free, merge with it.
	 */
	else if (postdup) {
864
		dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
865
		newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
866 867
		newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
		newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
868
		*xfs_dir2_data_unused_tag_p(newdup) =
869
			cpu_to_be16((char *)newdup - (char *)hdr);
870
		xfs_dir2_data_log_unused(args, bp, newdup);
L
Linus Torvalds 已提交
871 872 873 874 875 876
		/*
		 * If the following entry was in the table, the new entry
		 * is longer, so it will be in the table too.  Remove
		 * the old one and add the new one.
		 */
		if (dfp) {
877 878
			xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
			xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
L
Linus Torvalds 已提交
879 880 881 882
		}
		/*
		 * Otherwise we need a scan if the new entry is big enough.
		 */
883
		else {
884
			needscan = be16_to_cpu(newdup->length) >
885
				   be16_to_cpu(bf[2].length);
886
		}
L
Linus Torvalds 已提交
887 888 889 890 891
	}
	/*
	 * Neither neighbor is free.  Make a new entry.
	 */
	else {
892
		newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
893 894
		newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
		newdup->length = cpu_to_be16(len);
895
		*xfs_dir2_data_unused_tag_p(newdup) =
896
			cpu_to_be16((char *)newdup - (char *)hdr);
897
		xfs_dir2_data_log_unused(args, bp, newdup);
898
		xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
L
Linus Torvalds 已提交
899 900 901 902 903 904 905 906 907
	}
	*needscanp = needscan;
}

/*
 * Take a byte range out of an existing unused space and make it un-free.
 */
void
xfs_dir2_data_use_free(
908
	struct xfs_da_args	*args,
909
	struct xfs_buf		*bp,
L
Linus Torvalds 已提交
910 911 912 913 914 915
	xfs_dir2_data_unused_t	*dup,		/* unused entry */
	xfs_dir2_data_aoff_t	offset,		/* starting offset to use */
	xfs_dir2_data_aoff_t	len,		/* length to use */
	int			*needlogp,	/* out: need to log header */
	int			*needscanp)	/* out: need regen bestfree */
{
916
	xfs_dir2_data_hdr_t	*hdr;		/* data block header */
L
Linus Torvalds 已提交
917 918 919 920 921 922 923
	xfs_dir2_data_free_t	*dfp;		/* bestfree pointer */
	int			matchback;	/* matches end of freespace */
	int			matchfront;	/* matches start of freespace */
	int			needscan;	/* need to regen bestfree */
	xfs_dir2_data_unused_t	*newdup;	/* new unused entry */
	xfs_dir2_data_unused_t	*newdup2;	/* another new unused entry */
	int			oldlen;		/* old unused entry's length */
924
	struct xfs_dir2_data_free *bf;
L
Linus Torvalds 已提交
925

926
	hdr = bp->b_addr;
927
	ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
928
	       hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
929 930
	       hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
	       hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
931
	ASSERT(be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG);
932 933 934
	ASSERT(offset >= (char *)dup - (char *)hdr);
	ASSERT(offset + len <= (char *)dup + be16_to_cpu(dup->length) - (char *)hdr);
	ASSERT((char *)dup - (char *)hdr == be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
L
Linus Torvalds 已提交
935 936 937
	/*
	 * Look up the entry in the bestfree table.
	 */
938
	oldlen = be16_to_cpu(dup->length);
939
	bf = args->dp->d_ops->data_bestfree_p(hdr);
940
	dfp = xfs_dir2_data_freefind(hdr, bf, dup);
941
	ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
L
Linus Torvalds 已提交
942 943 944
	/*
	 * Check for alignment with front and back of the entry.
	 */
945 946
	matchfront = (char *)dup - (char *)hdr == offset;
	matchback = (char *)dup + oldlen - (char *)hdr == offset + len;
L
Linus Torvalds 已提交
947 948 949 950 951 952 953 954
	ASSERT(*needscanp == 0);
	needscan = 0;
	/*
	 * If we matched it exactly we just need to get rid of it from
	 * the bestfree table.
	 */
	if (matchfront && matchback) {
		if (dfp) {
955
			needscan = (bf[2].offset != 0);
L
Linus Torvalds 已提交
956
			if (!needscan)
957 958
				xfs_dir2_data_freeremove(hdr, bf, dfp,
							 needlogp);
L
Linus Torvalds 已提交
959 960 961 962 963 964 965
		}
	}
	/*
	 * We match the first part of the entry.
	 * Make a new entry with the remaining freespace.
	 */
	else if (matchfront) {
966
		newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
967 968
		newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
		newdup->length = cpu_to_be16(oldlen - len);
969
		*xfs_dir2_data_unused_tag_p(newdup) =
970
			cpu_to_be16((char *)newdup - (char *)hdr);
971
		xfs_dir2_data_log_unused(args, bp, newdup);
L
Linus Torvalds 已提交
972 973 974 975
		/*
		 * If it was in the table, remove it and add the new one.
		 */
		if (dfp) {
976 977 978
			xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
			dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
						       needlogp);
L
Linus Torvalds 已提交
979
			ASSERT(dfp != NULL);
980
			ASSERT(dfp->length == newdup->length);
981
			ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
L
Linus Torvalds 已提交
982 983 984 985 986
			/*
			 * If we got inserted at the last slot,
			 * that means we don't know if there was a better
			 * choice for the last slot, or not.  Rescan.
			 */
987
			needscan = dfp == &bf[2];
L
Linus Torvalds 已提交
988 989 990 991 992 993 994 995
		}
	}
	/*
	 * We match the last part of the entry.
	 * Trim the allocated space off the tail of the entry.
	 */
	else if (matchback) {
		newdup = dup;
996
		newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
997
		*xfs_dir2_data_unused_tag_p(newdup) =
998
			cpu_to_be16((char *)newdup - (char *)hdr);
999
		xfs_dir2_data_log_unused(args, bp, newdup);
L
Linus Torvalds 已提交
1000 1001 1002 1003
		/*
		 * If it was in the table, remove it and add the new one.
		 */
		if (dfp) {
1004 1005 1006
			xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
			dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
						       needlogp);
L
Linus Torvalds 已提交
1007
			ASSERT(dfp != NULL);
1008
			ASSERT(dfp->length == newdup->length);
1009
			ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
L
Linus Torvalds 已提交
1010 1011 1012 1013 1014
			/*
			 * If we got inserted at the last slot,
			 * that means we don't know if there was a better
			 * choice for the last slot, or not.  Rescan.
			 */
1015
			needscan = dfp == &bf[2];
L
Linus Torvalds 已提交
1016 1017 1018 1019 1020 1021 1022 1023
		}
	}
	/*
	 * Poking out the middle of an entry.
	 * Make two new entries.
	 */
	else {
		newdup = dup;
1024
		newdup->length = cpu_to_be16(((char *)hdr + offset) - (char *)newdup);
1025
		*xfs_dir2_data_unused_tag_p(newdup) =
1026
			cpu_to_be16((char *)newdup - (char *)hdr);
1027
		xfs_dir2_data_log_unused(args, bp, newdup);
1028
		newdup2 = (xfs_dir2_data_unused_t *)((char *)hdr + offset + len);
1029 1030
		newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
		newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));
1031
		*xfs_dir2_data_unused_tag_p(newdup2) =
1032
			cpu_to_be16((char *)newdup2 - (char *)hdr);
1033
		xfs_dir2_data_log_unused(args, bp, newdup2);
L
Linus Torvalds 已提交
1034 1035 1036 1037 1038 1039 1040 1041 1042
		/*
		 * If the old entry was in the table, we need to scan
		 * if the 3rd entry was valid, since these entries
		 * are smaller than the old one.
		 * If we don't need to scan that means there were 1 or 2
		 * entries in the table, and removing the old and adding
		 * the 2 new will work.
		 */
		if (dfp) {
1043
			needscan = (bf[2].length != 0);
L
Linus Torvalds 已提交
1044
			if (!needscan) {
1045 1046 1047 1048 1049
				xfs_dir2_data_freeremove(hdr, bf, dfp,
							 needlogp);
				xfs_dir2_data_freeinsert(hdr, bf, newdup,
							 needlogp);
				xfs_dir2_data_freeinsert(hdr, bf, newdup2,
1050
							 needlogp);
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055
			}
		}
	}
	*needscanp = needscan;
}