xfs: replace attr LBSIZE with xfs_da_geometry (c2c4c477) · Commits · EulixOS / Software / Kernel

fs/xfs/xfs_attr.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -863,7 +863,7 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
		}

		/*========================================================================
		* External routines when attribute list size > XFS_LBSIZE(mp).
		* External routines when attribute list size > geo->blksize
		========================================================================/

		/*

fs/xfs/xfs_attr_leaf.c

+59 −55

Original line number	Diff line number	Diff line
		@@ -80,11 +80,12 @@ STATIC int xfs_attr3_leaf_figure_balance(xfs_da_state_t *state,
		/*
		* Utility routines.
		*/
		STATIC void xfs_attr3_leaf_moveents(struct xfs_attr_leafblock *src_leaf,
		STATIC void xfs_attr3_leaf_moveents(struct xfs_da_args *args,
		struct xfs_attr_leafblock *src_leaf,
		struct xfs_attr3_icleaf_hdr *src_ichdr, int src_start,
		struct xfs_attr_leafblock *dst_leaf,
		struct xfs_attr3_icleaf_hdr *dst_ichdr, int dst_start,
		int move_count, struct xfs_mount *mp);
		int move_count);
		STATIC int xfs_attr_leaf_entsize(xfs_attr_leafblock_t *leaf, int index);

		void
		@@ -806,18 +807,18 @@ xfs_attr3_leaf_to_shortform(

		trace_xfs_attr_leaf_to_sf(args);

		tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
		tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
		if (!tmpbuffer)
		return ENOMEM;

		memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(dp->i_mount));
		memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);

		leaf = (xfs_attr_leafblock_t *)tmpbuffer;
		xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);
		entry = xfs_attr3_leaf_entryp(leaf);

		/* XXX (dgc): buffer is about to be marked stale - why zero it? */
		memset(bp->b_addr, 0, XFS_LBSIZE(dp->i_mount));
		memset(bp->b_addr, 0, args->geo->blksize);

		/*
		* Clean out the prior contents of the attribute list.
		@@ -906,12 +907,12 @@ xfs_attr3_leaf_to_node(
		/* copy leaf to new buffer, update identifiers */
		xfs_trans_buf_set_type(args->trans, bp2, XFS_BLFT_ATTR_LEAF_BUF);
		bp2->b_ops = bp1->b_ops;
		memcpy(bp2->b_addr, bp1->b_addr, XFS_LBSIZE(mp));
		memcpy(bp2->b_addr, bp1->b_addr, args->geo->blksize);
		if (xfs_sb_version_hascrc(&mp->m_sb)) {
		struct xfs_da3_blkinfo *hdr3 = bp2->b_addr;
		hdr3->blkno = cpu_to_be64(bp2->b_bn);
		}
		xfs_trans_log_buf(args->trans, bp2, 0, XFS_LBSIZE(mp) - 1);
		xfs_trans_log_buf(args->trans, bp2, 0, args->geo->blksize - 1);

		/*
		* Set up the new root node.
		@@ -932,7 +933,7 @@ xfs_attr3_leaf_to_node(
		btree[0].before = cpu_to_be32(blkno);
		icnodehdr.count = 1;
		dp->d_ops->node_hdr_to_disk(node, &icnodehdr);
		xfs_trans_log_buf(args->trans, bp1, 0, XFS_LBSIZE(mp) - 1);
		xfs_trans_log_buf(args->trans, bp1, 0, args->geo->blksize - 1);
		error = 0;
		out:
		return error;
		@@ -968,10 +969,10 @@ xfs_attr3_leaf_create(
		bp->b_ops = &xfs_attr3_leaf_buf_ops;
		xfs_trans_buf_set_type(args->trans, bp, XFS_BLFT_ATTR_LEAF_BUF);
		leaf = bp->b_addr;
		memset(leaf, 0, XFS_LBSIZE(mp));
		memset(leaf, 0, args->geo->blksize);

		memset(&ichdr, 0, sizeof(ichdr));
		ichdr.firstused = XFS_LBSIZE(mp);
		ichdr.firstused = args->geo->blksize;

		if (xfs_sb_version_hascrc(&mp->m_sb)) {
		struct xfs_da3_blkinfo *hdr3 = bp->b_addr;
		@@ -990,7 +991,7 @@ xfs_attr3_leaf_create(
		ichdr.freemap[0].size = ichdr.firstused - ichdr.freemap[0].base;

		xfs_attr3_leaf_hdr_to_disk(leaf, &ichdr);
		xfs_trans_log_buf(args->trans, bp, 0, XFS_LBSIZE(mp) - 1);
		xfs_trans_log_buf(args->trans, bp, 0, args->geo->blksize - 1);

		*bpp = bp;
		return 0;
		@@ -1175,11 +1176,11 @@ xfs_attr3_leaf_add_work(
		* Allocate space for the new string (at the end of the run).
		*/
		mp = args->trans->t_mountp;
		ASSERT(ichdr->freemap[mapindex].base < XFS_LBSIZE(mp));
		ASSERT(ichdr->freemap[mapindex].base < args->geo->blksize);
		ASSERT((ichdr->freemap[mapindex].base & 0x3) == 0);
		ASSERT(ichdr->freemap[mapindex].size >=
		xfs_attr_leaf_newentsize(args, NULL));
		ASSERT(ichdr->freemap[mapindex].size < XFS_LBSIZE(mp));
		ASSERT(ichdr->freemap[mapindex].size < args->geo->blksize);
		ASSERT((ichdr->freemap[mapindex].size & 0x3) == 0);

		ichdr->freemap[mapindex].size -= xfs_attr_leaf_newentsize(args, &tmp);
		@@ -1267,14 +1268,13 @@ xfs_attr3_leaf_compact(
		struct xfs_attr_leafblock *leaf_dst;
		struct xfs_attr3_icleaf_hdr ichdr_src;
		struct xfs_trans *trans = args->trans;
		struct xfs_mount *mp = trans->t_mountp;
		char *tmpbuffer;

		trace_xfs_attr_leaf_compact(args);

		tmpbuffer = kmem_alloc(XFS_LBSIZE(mp), KM_SLEEP);
		memcpy(tmpbuffer, bp->b_addr, XFS_LBSIZE(mp));
		memset(bp->b_addr, 0, XFS_LBSIZE(mp));
		tmpbuffer = kmem_alloc(args->geo->blksize, KM_SLEEP);
		memcpy(tmpbuffer, bp->b_addr, args->geo->blksize);
		memset(bp->b_addr, 0, args->geo->blksize);
		leaf_src = (xfs_attr_leafblock_t *)tmpbuffer;
		leaf_dst = bp->b_addr;

		@@ -1287,7 +1287,7 @@ xfs_attr3_leaf_compact(

		/* Initialise the incore headers */
		ichdr_src = ichdr_dst; / struct copy */
		ichdr_dst->firstused = XFS_LBSIZE(mp);
		ichdr_dst->firstused = args->geo->blksize;
		ichdr_dst->usedbytes = 0;
		ichdr_dst->count = 0;
		ichdr_dst->holes = 0;
		@@ -1302,13 +1302,13 @@ xfs_attr3_leaf_compact(
		* Copy all entry's in the same (sorted) order,
		* but allocate name/value pairs packed and in sequence.
		*/
		xfs_attr3_leaf_moveents(leaf_src, &ichdr_src, 0, leaf_dst, ichdr_dst, 0,
		ichdr_src.count, mp);
		xfs_attr3_leaf_moveents(args, leaf_src, &ichdr_src, 0,
		leaf_dst, ichdr_dst, 0, ichdr_src.count);
		/*
		* this logs the entire buffer, but the caller must write the header
		* back to the buffer when it is finished modifying it.
		*/
		xfs_trans_log_buf(trans, bp, 0, XFS_LBSIZE(mp) - 1);
		xfs_trans_log_buf(trans, bp, 0, args->geo->blksize - 1);

		kmem_free(tmpbuffer);
		}
		@@ -1459,8 +1459,8 @@ xfs_attr3_leaf_rebalance(
		/*
		* Move high entries from leaf1 to low end of leaf2.
		*/
		xfs_attr3_leaf_moveents(leaf1, &ichdr1, ichdr1.count - count,
		leaf2, &ichdr2, 0, count, state->mp);
		xfs_attr3_leaf_moveents(args, leaf1, &ichdr1,
		ichdr1.count - count, leaf2, &ichdr2, 0, count);

		} else if (count > ichdr1.count) {
		/*
		@@ -1488,8 +1488,8 @@ xfs_attr3_leaf_rebalance(
		/*
		* Move low entries from leaf2 to high end of leaf1.
		*/
		xfs_attr3_leaf_moveents(leaf2, &ichdr2, 0, leaf1, &ichdr1,
		ichdr1.count, count, state->mp);
		xfs_attr3_leaf_moveents(args, leaf2, &ichdr2, 0, leaf1, &ichdr1,
		ichdr1.count, count);
		}

		xfs_attr3_leaf_hdr_to_disk(leaf1, &ichdr1);
		@@ -1795,7 +1795,6 @@ xfs_attr3_leaf_remove(
		struct xfs_attr_leafblock *leaf;
		struct xfs_attr3_icleaf_hdr ichdr;
		struct xfs_attr_leaf_entry *entry;
		struct xfs_mount *mp = args->trans->t_mountp;
		int before;
		int after;
		int smallest;
		@@ -1809,7 +1808,7 @@ xfs_attr3_leaf_remove(
		leaf = bp->b_addr;
		xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);

		ASSERT(ichdr.count > 0 && ichdr.count < XFS_LBSIZE(mp) / 8);
		ASSERT(ichdr.count > 0 && ichdr.count < args->geo->blksize / 8);
		ASSERT(args->index >= 0 && args->index < ichdr.count);
		ASSERT(ichdr.firstused >= ichdr.count * sizeof(*entry) +
		xfs_attr3_leaf_hdr_size(leaf));
		@@ -1817,7 +1816,7 @@ xfs_attr3_leaf_remove(
		entry = &xfs_attr3_leaf_entryp(leaf)[args->index];

		ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
		ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
		ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);

		/*
		* Scan through free region table:
		@@ -1832,8 +1831,8 @@ xfs_attr3_leaf_remove(
		smallest = XFS_ATTR_LEAF_MAPSIZE - 1;
		entsize = xfs_attr_leaf_entsize(leaf, args->index);
		for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
		ASSERT(ichdr.freemap[i].base < XFS_LBSIZE(mp));
		ASSERT(ichdr.freemap[i].size < XFS_LBSIZE(mp));
		ASSERT(ichdr.freemap[i].base < args->geo->blksize);
		ASSERT(ichdr.freemap[i].size < args->geo->blksize);
		if (ichdr.freemap[i].base == tablesize) {
		ichdr.freemap[i].base -= sizeof(xfs_attr_leaf_entry_t);
		ichdr.freemap[i].size += sizeof(xfs_attr_leaf_entry_t);
		@@ -1910,11 +1909,11 @@ xfs_attr3_leaf_remove(
		* removing the name.
		*/
		if (smallest) {
		tmp = XFS_LBSIZE(mp);
		tmp = args->geo->blksize;
		entry = xfs_attr3_leaf_entryp(leaf);
		for (i = ichdr.count - 1; i >= 0; entry++, i--) {
		ASSERT(be16_to_cpu(entry->nameidx) >= ichdr.firstused);
		ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
		ASSERT(be16_to_cpu(entry->nameidx) < args->geo->blksize);

		if (be16_to_cpu(entry->nameidx) < tmp)
		tmp = be16_to_cpu(entry->nameidx);
		@@ -1954,7 +1953,6 @@ xfs_attr3_leaf_unbalance(
		struct xfs_attr3_icleaf_hdr drophdr;
		struct xfs_attr3_icleaf_hdr savehdr;
		struct xfs_attr_leaf_entry *entry;
		struct xfs_mount *mp = state->mp;

		trace_xfs_attr_leaf_unbalance(state->args);

		@@ -1981,13 +1979,15 @@ xfs_attr3_leaf_unbalance(
		*/
		if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
		drop_blk->bp, &drophdr)) {
		xfs_attr3_leaf_moveents(drop_leaf, &drophdr, 0,
		xfs_attr3_leaf_moveents(state->args,
		drop_leaf, &drophdr, 0,
		save_leaf, &savehdr, 0,
		drophdr.count, mp);
		drophdr.count);
		} else {
		xfs_attr3_leaf_moveents(drop_leaf, &drophdr, 0,
		xfs_attr3_leaf_moveents(state->args,
		drop_leaf, &drophdr, 0,
		save_leaf, &savehdr,
		savehdr.count, drophdr.count, mp);
		savehdr.count, drophdr.count);
		}
		} else {
		/*
		@@ -2017,19 +2017,23 @@ xfs_attr3_leaf_unbalance(

		if (xfs_attr3_leaf_order(save_blk->bp, &savehdr,
		drop_blk->bp, &drophdr)) {
		xfs_attr3_leaf_moveents(drop_leaf, &drophdr, 0,
		xfs_attr3_leaf_moveents(state->args,
		drop_leaf, &drophdr, 0,
		tmp_leaf, &tmphdr, 0,
		drophdr.count, mp);
		xfs_attr3_leaf_moveents(save_leaf, &savehdr, 0,
		drophdr.count);
		xfs_attr3_leaf_moveents(state->args,
		save_leaf, &savehdr, 0,
		tmp_leaf, &tmphdr, tmphdr.count,
		savehdr.count, mp);
		savehdr.count);
		} else {
		xfs_attr3_leaf_moveents(save_leaf, &savehdr, 0,
		xfs_attr3_leaf_moveents(state->args,
		save_leaf, &savehdr, 0,
		tmp_leaf, &tmphdr, 0,
		savehdr.count, mp);
		xfs_attr3_leaf_moveents(drop_leaf, &drophdr, 0,
		savehdr.count);
		xfs_attr3_leaf_moveents(state->args,
		drop_leaf, &drophdr, 0,
		tmp_leaf, &tmphdr, tmphdr.count,
		drophdr.count, mp);
		drophdr.count);
		}
		memcpy(save_leaf, tmp_leaf, state->blocksize);
		savehdr = tmphdr; /* struct copy */
		@@ -2084,7 +2088,7 @@ xfs_attr3_leaf_lookup_int(
		leaf = bp->b_addr;
		xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);
		entries = xfs_attr3_leaf_entryp(leaf);
		ASSERT(ichdr.count < XFS_LBSIZE(args->dp->i_mount) / 8);
		ASSERT(ichdr.count < args->geo->blksize / 8);

		/*
		* Binary search. (note: small blocks will skip this loop)
		@@ -2188,7 +2192,7 @@ xfs_attr3_leaf_getvalue(

		leaf = bp->b_addr;
		xfs_attr3_leaf_hdr_from_disk(&ichdr, leaf);
		ASSERT(ichdr.count < XFS_LBSIZE(args->dp->i_mount) / 8);
		ASSERT(ichdr.count < args->geo->blksize / 8);
		ASSERT(args->index < ichdr.count);

		entry = &xfs_attr3_leaf_entryp(leaf)[args->index];
		@@ -2239,14 +2243,14 @@ xfs_attr3_leaf_getvalue(
		/ARGSUSED/
		STATIC void
		xfs_attr3_leaf_moveents(
		struct xfs_da_args *args,
		struct xfs_attr_leafblock *leaf_s,
		struct xfs_attr3_icleaf_hdr *ichdr_s,
		int start_s,
		struct xfs_attr_leafblock *leaf_d,
		struct xfs_attr3_icleaf_hdr *ichdr_d,
		int start_d,
		int count,
		struct xfs_mount *mp)
		int count)
		{
		struct xfs_attr_leaf_entry *entry_s;
		struct xfs_attr_leaf_entry *entry_d;
		@@ -2266,10 +2270,10 @@ xfs_attr3_leaf_moveents(
		ASSERT(ichdr_s->magic == XFS_ATTR_LEAF_MAGIC \|\|
		ichdr_s->magic == XFS_ATTR3_LEAF_MAGIC);
		ASSERT(ichdr_s->magic == ichdr_d->magic);
		ASSERT(ichdr_s->count > 0 && ichdr_s->count < XFS_LBSIZE(mp) / 8);
		ASSERT(ichdr_s->count > 0 && ichdr_s->count < args->geo->blksize / 8);
		ASSERT(ichdr_s->firstused >= (ichdr_s->count * sizeof(*entry_s))
		+ xfs_attr3_leaf_hdr_size(leaf_s));
		ASSERT(ichdr_d->count < XFS_LBSIZE(mp) / 8);
		ASSERT(ichdr_d->count < args->geo->blksize / 8);
		ASSERT(ichdr_d->firstused >= (ichdr_d->count * sizeof(*entry_d))
		+ xfs_attr3_leaf_hdr_size(leaf_d));

		@@ -2321,11 +2325,11 @@ xfs_attr3_leaf_moveents(
		entry_d->nameidx = cpu_to_be16(ichdr_d->firstused);
		entry_d->flags = entry_s->flags;
		ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
		<= XFS_LBSIZE(mp));
		<= args->geo->blksize);
		memmove(xfs_attr3_leaf_name(leaf_d, desti),
		xfs_attr3_leaf_name(leaf_s, start_s + i), tmp);
		ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
		<= XFS_LBSIZE(mp));
		<= args->geo->blksize);
		memset(xfs_attr3_leaf_name(leaf_s, start_s + i), 0, tmp);
		ichdr_s->usedbytes -= tmp;
		ichdr_d->usedbytes += tmp;
		@@ -2346,7 +2350,7 @@ xfs_attr3_leaf_moveents(
		tmp = count * sizeof(xfs_attr_leaf_entry_t);
		entry_s = &xfs_attr3_leaf_entryp(leaf_s)[start_s];
		ASSERT(((char *)entry_s + tmp) <=
		((char *)leaf_s + XFS_LBSIZE(mp)));
		((char *)leaf_s + args->geo->blksize));
		memset(entry_s, 0, tmp);
		} else {
		/*
		@@ -2361,7 +2365,7 @@ xfs_attr3_leaf_moveents(
		tmp = count * sizeof(xfs_attr_leaf_entry_t);
		entry_s = &xfs_attr3_leaf_entryp(leaf_s)[ichdr_s->count];
		ASSERT(((char *)entry_s + tmp) <=
		((char *)leaf_s + XFS_LBSIZE(mp)));
		((char *)leaf_s + args->geo->blksize));
		memset(entry_s, 0, tmp);
		}

fs/xfs/xfs_attr_remote.c

+29 −26

Original line number	Diff line number	Diff line
		@@ -125,6 +125,7 @@ xfs_attr3_rmt_read_verify(
		char *ptr;
		int len;
		xfs_daddr_t bno;
		int blksize = mp->m_attr_geo->blksize;

		/* no verification of non-crc buffers */
		if (!xfs_sb_version_hascrc(&mp->m_sb))
		@@ -133,21 +134,20 @@ xfs_attr3_rmt_read_verify(
		ptr = bp->b_addr;
		bno = bp->b_bn;
		len = BBTOB(bp->b_length);
		ASSERT(len >= XFS_LBSIZE(mp));
		ASSERT(len >= blksize);

		while (len > 0) {
		if (!xfs_verify_cksum(ptr, XFS_LBSIZE(mp),
		XFS_ATTR3_RMT_CRC_OFF)) {
		if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {
		xfs_buf_ioerror(bp, EFSBADCRC);
		break;
		}
		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {
		if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		break;
		}
		len -= XFS_LBSIZE(mp);
		ptr += XFS_LBSIZE(mp);
		bno += mp->m_bsize;
		len -= blksize;
		ptr += blksize;
		bno += BTOBB(blksize);
		}

		if (bp->b_error)
		@@ -165,6 +165,7 @@ xfs_attr3_rmt_write_verify(
		char *ptr;
		int len;
		xfs_daddr_t bno;
		int blksize = mp->m_attr_geo->blksize;

		/* no verification of non-crc buffers */
		if (!xfs_sb_version_hascrc(&mp->m_sb))
		@@ -173,10 +174,10 @@ xfs_attr3_rmt_write_verify(
		ptr = bp->b_addr;
		bno = bp->b_bn;
		len = BBTOB(bp->b_length);
		ASSERT(len >= XFS_LBSIZE(mp));
		ASSERT(len >= blksize);

		while (len > 0) {
		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {
		if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {
		xfs_buf_ioerror(bp, EFSCORRUPTED);
		xfs_verifier_error(bp);
		return;
		@@ -187,11 +188,11 @@ xfs_attr3_rmt_write_verify(
		rmt = (struct xfs_attr3_rmt_hdr *)ptr;
		rmt->rm_lsn = cpu_to_be64(bip->bli_item.li_lsn);
		}
		xfs_update_cksum(ptr, XFS_LBSIZE(mp), XFS_ATTR3_RMT_CRC_OFF);
		xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);

		len -= XFS_LBSIZE(mp);
		ptr += XFS_LBSIZE(mp);
		bno += mp->m_bsize;
		len -= blksize;
		ptr += blksize;
		bno += BTOBB(blksize);
		}
		ASSERT(len == 0);
		}
		@@ -240,12 +241,13 @@ xfs_attr_rmtval_copyout(
		char *src = bp->b_addr;
		xfs_daddr_t bno = bp->b_bn;
		int len = BBTOB(bp->b_length);
		int blksize = mp->m_attr_geo->blksize;

		ASSERT(len >= XFS_LBSIZE(mp));
		ASSERT(len >= blksize);

		while (len > 0 && *valuelen > 0) {
		int hdr_size = 0;
		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, XFS_LBSIZE(mp));
		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, blksize);

		byte_cnt = min(*valuelen, byte_cnt);

		@@ -263,9 +265,9 @@ xfs_attr_rmtval_copyout(
		memcpy(*dst, src + hdr_size, byte_cnt);

		/* roll buffer forwards */
		len -= XFS_LBSIZE(mp);
		src += XFS_LBSIZE(mp);
		bno += mp->m_bsize;
		len -= blksize;
		src += blksize;
		bno += BTOBB(blksize);

		/* roll attribute data forwards */
		*valuelen -= byte_cnt;
		@@ -287,12 +289,13 @@ xfs_attr_rmtval_copyin(
		char *dst = bp->b_addr;
		xfs_daddr_t bno = bp->b_bn;
		int len = BBTOB(bp->b_length);
		int blksize = mp->m_attr_geo->blksize;

		ASSERT(len >= XFS_LBSIZE(mp));
		ASSERT(len >= blksize);

		while (len > 0 && *valuelen > 0) {
		int hdr_size;
		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, XFS_LBSIZE(mp));
		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, blksize);

		byte_cnt = min(*valuelen, byte_cnt);
		hdr_size = xfs_attr3_rmt_hdr_set(mp, dst, ino, *offset,
		@@ -304,17 +307,17 @@ xfs_attr_rmtval_copyin(
		* If this is the last block, zero the remainder of it.
		* Check that we are actually the last block, too.
		*/
		if (byte_cnt + hdr_size < XFS_LBSIZE(mp)) {
		if (byte_cnt + hdr_size < blksize) {
		ASSERT(*valuelen - byte_cnt == 0);
		ASSERT(len == XFS_LBSIZE(mp));
		ASSERT(len == blksize);
		memset(dst + hdr_size + byte_cnt, 0,
		XFS_LBSIZE(mp) - hdr_size - byte_cnt);
		blksize - hdr_size - byte_cnt);
		}

		/* roll buffer forwards */
		len -= XFS_LBSIZE(mp);
		dst += XFS_LBSIZE(mp);
		bno += mp->m_bsize;
		len -= blksize;
		dst += blksize;
		bno += BTOBB(blksize);

		/* roll attribute data forwards */
		*valuelen -= byte_cnt;

fs/xfs/xfs_da_format.h

+0 −10

Original line number	Diff line number	Diff line
		@@ -19,10 +19,6 @@
		#ifndef __XFS_DA_FORMAT_H__
		#define __XFS_DA_FORMAT_H__

		/*========================================================================
		* Directory Structure when greater than XFS_LBSIZE(mp) bytes.
		========================================================================/

		/*
		* This structure is common to both leaf nodes and non-leaf nodes in the Btree.
		*
		@@ -122,8 +118,6 @@ struct xfs_da3_icnode_hdr {
		__uint16_t level;
		};

		#define XFS_LBSIZE(mp) (mp)->m_sb.sb_blocksize

		/*
		* Directory version 2.
		*
		@@ -620,10 +614,6 @@ xfs_dir2_block_leaf_p(struct xfs_dir2_block_tail *btp)
		* of an attribute name may not be unique, we may have duplicate keys. The
		* internal links in the Btree are logical block offsets into the file.
		*
		*========================================================================
		* Attribute structure when equal to XFS_LBSIZE(mp) bytes.
		*========================================================================
		*
		* Struct leaf_entry's are packed from the top. Name/values grow from the
		* bottom but are not packed. The freemap contains run-length-encoded entries
		* for the free bytes after the leaf_entry's, but only the N largest such,