自学教程：C++ xfs_sb_version_hascrc函数代码示例

STATIC voidxfs_qm_reset_dqcounts(	xfs_mount_t	*mp,	xfs_buf_t	*bp,	xfs_dqid_t	id,	uint		type){	struct xfs_dqblk	*dqb;	int			j;	trace_xfs_reset_dqcounts(bp, _RET_IP_);	/*	 * Reset all counters and timers. They'll be	 * started afresh by xfs_qm_quotacheck.	 */#ifdef DEBUG	j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);	do_div(j, sizeof(xfs_dqblk_t));	ASSERT(mp->m_quotainfo->qi_dqperchunk == j);#endif	dqb = bp->b_addr;	for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {		struct xfs_disk_dquot	*ddq;		ddq = (struct xfs_disk_dquot *)&dqb[j];		/*		 * Do a sanity check, and if needed, repair the dqblk. Don't		 * output any warnings because it's perfectly possible to		 * find uninitialised dquot blks. See comment in xfs_dqcheck.		 */		xfs_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,			    "xfs_quotacheck");		/*		 * Reset type in case we are reusing group quota file for		 * project quotas or vice versa		 */		ddq->d_flags = type;		ddq->d_bcount = 0;		ddq->d_icount = 0;		ddq->d_rtbcount = 0;		ddq->d_btimer = 0;		ddq->d_itimer = 0;		ddq->d_rtbtimer = 0;		ddq->d_bwarns = 0;		ddq->d_iwarns = 0;		ddq->d_rtbwarns = 0;		if (xfs_sb_version_hascrc(&mp->m_sb)) {			xfs_update_cksum((char *)&dqb[j],					 sizeof(struct xfs_dqblk),					 XFS_DQUOT_CRC_OFF);		}	}}

boolxfs_dinode_good_version(	struct xfs_mount *mp,	__u8		version){	if (xfs_sb_version_hascrc(&mp->m_sb))		return version == 3;	return version == 1 || version == 2;}

/* * Each contiguous block has a header, so it is not just a simple attribute * length to FSB conversion. */intxfs_attr3_rmt_blocks(	struct xfs_mount *mp,	int		attrlen){	if (xfs_sb_version_hascrc(&mp->m_sb)) {		int buflen = XFS_ATTR3_RMT_BUF_SPACE(mp, mp->m_sb.sb_blocksize);		return (attrlen + buflen - 1) / buflen;	}	return XFS_B_TO_FSB(mp, attrlen);}

const struct xfs_dir_ops *xfs_nondir_get_ops(	struct xfs_mount	*mp,	struct xfs_inode	*dp){	if (dp)		return dp->d_ops;	if (mp->m_nondir_inode_ops)		return mp->m_nondir_inode_ops;	if (xfs_sb_version_hascrc(&mp->m_sb))		return &xfs_dir3_nondir_ops;	return &xfs_dir2_nondir_ops;}

STATIC uintxfs_calc_create_tmpfile_reservation(	struct xfs_mount        *mp){	uint	res = XFS_DQUOT_LOGRES(mp);	if (xfs_sb_version_hascrc(&mp->m_sb))		res += xfs_calc_icreate_resv_alloc(mp);	else		res += xfs_calc_create_resv_alloc(mp);	return res + xfs_calc_iunlink_add_reservation(mp);}

/* This routine brings in blocks from disk one by one and assembles them * in the value buffer. If get_bmapi gets smarter later to return an extent * or list of extents, that would be great. For now, we don't expect too * many blocks per remote value, so one by one is sufficient. */static intrmtval_get(xfs_mount_t *mp, xfs_ino_t ino, blkmap_t *blkmap,		xfs_dablk_t blocknum, int valuelen, char* value){	xfs_fsblock_t	bno;	xfs_buf_t	*bp;	int		clearit = 0, i = 0, length = 0, amountdone = 0;	int		hdrsize = 0;	if (xfs_sb_version_hascrc(&mp->m_sb))		hdrsize = sizeof(struct xfs_attr3_rmt_hdr);	/* ASSUMPTION: valuelen is a valid number, so use it for looping */	/* Note that valuelen is not a multiple of blocksize */	while (amountdone < valuelen) {		bno = blkmap_get(blkmap, blocknum + i);		if (bno == NULLFSBLOCK) {			do_warn(	_("remote block for attributes of inode %" PRIu64 " is missing/n"), ino);			clearit = 1;			break;		}		bp = libxfs_readbuf(mp->m_dev, XFS_FSB_TO_DADDR(mp, bno),				    XFS_FSB_TO_BB(mp, 1), 0,				    &xfs_attr3_rmt_buf_ops);		if (!bp) {			do_warn(	_("can't read remote block for attributes of inode %" PRIu64 "/n"), ino);			clearit = 1;			break;		}		if (bp->b_error == -EFSBADCRC || bp->b_error == -EFSCORRUPTED) {			do_warn(	_("Corrupt remote block for attributes of inode %" PRIu64 "/n"), ino);			clearit = 1;			break;		}		ASSERT(mp->m_sb.sb_blocksize == XFS_BUF_COUNT(bp));		length = MIN(XFS_BUF_COUNT(bp) - hdrsize, valuelen - amountdone);		memmove(value, bp->b_addr + hdrsize, length);		amountdone += length;		value += length;		i++;		libxfs_putbuf(bp);	}	return (clearit);}

static voidxfs_dir3_block_read_verify(	struct xfs_buf	*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	if ((xfs_sb_version_hascrc(&mp->m_sb) &&	     !xfs_verify_cksum(bp->b_addr, BBTOB(bp->b_length),					  XFS_DIR3_DATA_CRC_OFF)) ||	    !xfs_dir3_block_verify(bp)) {		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);		xfs_buf_ioerror(bp, EFSCORRUPTED);	}}

voidxfs_dinode_calc_crc(	struct xfs_mount	*mp,	struct xfs_dinode	*dip){	uint32_t		crc;	if (dip->di_version < 3)		return;	ASSERT(xfs_sb_version_hascrc(&mp->m_sb));	crc = xfs_start_cksum_update((char *)dip, mp->m_sb.sb_inodesize,			      XFS_DINODE_CRC_OFF);	dip->di_crc = xfs_end_cksum(crc);}

static voidxfs_dir3_block_read_verify(	struct xfs_buf	*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	if (xfs_sb_version_hascrc(&mp->m_sb) &&	     !xfs_buf_verify_cksum(bp, XFS_DIR3_DATA_CRC_OFF))		xfs_buf_ioerror(bp, -EFSBADCRC);	else if (!xfs_dir3_block_verify(bp))		xfs_buf_ioerror(bp, -EFSCORRUPTED);	if (bp->b_error)		xfs_verifier_error(bp);}

static voidxfs_attr3_rmt_write_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	xfs_failaddr_t	fa;	int		blksize = mp->m_attr_geo->blksize;	char		*ptr;	int		len;	xfs_daddr_t	bno;	/* no verification of non-crc buffers */	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= blksize);	while (len > 0) {		struct xfs_attr3_rmt_hdr *rmt = (struct xfs_attr3_rmt_hdr *)ptr;		fa = xfs_attr3_rmt_verify(mp, ptr, blksize, bno);		if (fa) {			xfs_verifier_error(bp, -EFSCORRUPTED, fa);			return;		}		/*		 * Ensure we aren't writing bogus LSNs to disk. See		 * xfs_attr3_rmt_hdr_set() for the explanation.		 */		if (rmt->rm_lsn != cpu_to_be64(NULLCOMMITLSN)) {			xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);			return;		}		xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);		len -= blksize;		ptr += blksize;		bno += BTOBB(blksize);	}	if (len != 0)		xfs_verifier_error(bp, -EFSCORRUPTED, __this_address);}

/* * Helper functions to copy attribute data in and out of the one disk extents */STATIC intxfs_attr_rmtval_copyout(	struct xfs_mount *mp,	struct xfs_buf	*bp,	xfs_ino_t	ino,	int		*offset,	int		*valuelen,	__uint8_t	**dst){	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 >= blksize);	while (len > 0 && *valuelen > 0) {		int hdr_size = 0;		int byte_cnt = XFS_ATTR3_RMT_BUF_SPACE(mp, blksize);		byte_cnt = min(*valuelen, byte_cnt);		if (xfs_sb_version_hascrc(&mp->m_sb)) {			if (!xfs_attr3_rmt_hdr_ok(src, ino, *offset,						  byte_cnt, bno)) {				xfs_alert(mp,"remote attribute header mismatch bno/off/len/owner (0x%llx/0x%x/Ox%x/0x%llx)",					bno, *offset, byte_cnt, ino);				return -EFSCORRUPTED;			}			hdr_size = sizeof(struct xfs_attr3_rmt_hdr);		}		memcpy(*dst, src + hdr_size, byte_cnt);		/* roll buffer forwards */		len -= blksize;		src += blksize;		bno += BTOBB(blksize);		/* roll attribute data forwards */		*valuelen -= byte_cnt;		*dst += byte_cnt;		*offset += byte_cnt;	}	return 0;}

static uuid_t *do_uuid(xfs_agnumber_t agno, uuid_t *uuid){	xfs_sb_t	tsb;	static uuid_t	uu;	if (!get_sb(agno, &tsb))		return NULL;	if (!uuid) {	/* get uuid */		memcpy(&uu, &tsb.sb_uuid, sizeof(uuid_t));		pop_cur();		return &uu;	}	/* set uuid */	if (!xfs_sb_version_hascrc(&tsb))		goto write;	/*	 * If we have CRCs, and this UUID differs from that stamped in the	 * metadata, set the incompat flag and copy the old one to the	 * metadata-specific location.	 *	 * If we are setting the user-visible UUID back to match the metadata	 * UUID, clear the metadata-specific location and the incompat flag.	 */	if (!xfs_sb_version_hasmetauuid(&tsb) &&	    !uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {		mp->m_sb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;		tsb.sb_features_incompat |= XFS_SB_FEAT_INCOMPAT_META_UUID;		memcpy(&tsb.sb_meta_uuid, &tsb.sb_uuid, sizeof(uuid_t));	} else if (xfs_sb_version_hasmetauuid(&tsb) &&		   uuid_equal(uuid, &mp->m_sb.sb_meta_uuid)) {		memset(&tsb.sb_meta_uuid, 0, sizeof(uuid_t));		/* Write those zeros now; it's ignored once we clear the flag */		libxfs_sb_to_disk(iocur_top->data, &tsb);		mp->m_sb.sb_features_incompat &=						~XFS_SB_FEAT_INCOMPAT_META_UUID;		tsb.sb_features_incompat &= ~XFS_SB_FEAT_INCOMPAT_META_UUID;	}write:	memcpy(&tsb.sb_uuid, uuid, sizeof(uuid_t));	libxfs_sb_to_disk(iocur_top->data, &tsb);	write_cur();	return uuid;}

/* * Calculate the reservation required to allocate or free an inode chunk. This * includes: * * the allocation btrees: 2 trees * (max depth - 1) * block size * the inode chunk: m_ialloc_blks * N * * The size N of the inode chunk reservation depends on whether it is for * allocation or free and which type of create transaction is in use. An inode * chunk free always invalidates the buffers and only requires reservation for * headers (N == 0). An inode chunk allocation requires a chunk sized * reservation on v4 and older superblocks to initialize the chunk. No chunk * reservation is required for allocation on v5 supers, which use ordered * buffers to initialize. */STATIC uintxfs_calc_inode_chunk_res(	struct xfs_mount	*mp,	bool			alloc){	uint			res, size = 0;	res = xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),			       XFS_FSB_TO_B(mp, 1));	if (alloc) {		/* icreate tx uses ordered buffers */		if (xfs_sb_version_hascrc(&mp->m_sb))			return res;		size = XFS_FSB_TO_B(mp, 1);	}	res += xfs_calc_buf_res(mp->m_ialloc_blks, size);	return res;}

/* * XXX: yet more code that can be shared with mkfs, growfs. */static voidbuild_agi(xfs_mount_t *mp, xfs_agnumber_t agno, bt_status_t *btree_curs,		bt_status_t *finobt_curs, struct agi_stat *agi_stat){	xfs_buf_t	*agi_buf;	xfs_agi_t	*agi;	int		i;	agi_buf = libxfs_getbuf(mp->m_dev,			XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),			mp->m_sb.sb_sectsize/BBSIZE);	agi_buf->b_ops = &xfs_agi_buf_ops;	agi = XFS_BUF_TO_AGI(agi_buf);	memset(agi, 0, mp->m_sb.sb_sectsize);	agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);	agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);	agi->agi_seqno = cpu_to_be32(agno);	if (agno < mp->m_sb.sb_agcount - 1)		agi->agi_length = cpu_to_be32(mp->m_sb.sb_agblocks);	else		agi->agi_length = cpu_to_be32(mp->m_sb.sb_dblocks -			(xfs_rfsblock_t) mp->m_sb.sb_agblocks * agno);	agi->agi_count = cpu_to_be32(agi_stat->count);	agi->agi_root = cpu_to_be32(btree_curs->root);	agi->agi_level = cpu_to_be32(btree_curs->num_levels);	agi->agi_freecount = cpu_to_be32(agi_stat->freecount);	agi->agi_newino = cpu_to_be32(agi_stat->first_agino);	agi->agi_dirino = cpu_to_be32(NULLAGINO);	for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++)  		agi->agi_unlinked[i] = cpu_to_be32(NULLAGINO);	if (xfs_sb_version_hascrc(&mp->m_sb))		platform_uuid_copy(&agi->agi_uuid, &mp->m_sb.sb_meta_uuid);	if (xfs_sb_version_hasfinobt(&mp->m_sb)) {		agi->agi_free_root = cpu_to_be32(finobt_curs->root);		agi->agi_free_level = cpu_to_be32(finobt_curs->num_levels);	}	libxfs_writebuf(agi_buf, 0);}

static voidxfs_symlink_read_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	xfs_failaddr_t	fa;	/* no verification of non-crc buffers */	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	if (!xfs_buf_verify_cksum(bp, XFS_SYMLINK_CRC_OFF))		xfs_verifier_error(bp, -EFSBADCRC, __this_address);	else {		fa = xfs_symlink_verify(bp);		if (fa)			xfs_verifier_error(bp, -EFSCORRUPTED, fa);	}}

static int__xfs_attr3_rmt_read_verify(	struct xfs_buf	*bp,	bool		check_crc,	xfs_failaddr_t	*failaddr){	struct xfs_mount *mp = bp->b_target->bt_mount;	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))		return 0;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= blksize);	while (len > 0) {		if (check_crc &&		    !xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {			*failaddr = __this_address;			return -EFSBADCRC;		}		*failaddr = xfs_attr3_rmt_verify(mp, ptr, blksize, bno);		if (*failaddr)			return -EFSCORRUPTED;		len -= blksize;		ptr += blksize;		bno += BTOBB(blksize);	}	if (len != 0) {		*failaddr = __this_address;		return -EFSCORRUPTED;	}	return 0;}

static voidxfs_agflblock_init(	struct xfs_mount	*mp,	struct xfs_buf		*bp,	struct aghdr_init_data	*id){	struct xfs_agfl		*agfl = XFS_BUF_TO_AGFL(bp);	__be32			*agfl_bno;	int			bucket;	if (xfs_sb_version_hascrc(&mp->m_sb)) {		agfl->agfl_magicnum = cpu_to_be32(XFS_AGFL_MAGIC);		agfl->agfl_seqno = cpu_to_be32(id->agno);		uuid_copy(&agfl->agfl_uuid, &mp->m_sb.sb_meta_uuid);	}	agfl_bno = XFS_BUF_TO_AGFL_BNO(mp, bp);	for (bucket = 0; bucket < xfs_agfl_size(mp); bucket++)		agfl_bno[bucket] = cpu_to_be32(NULLAGBLOCK);}

/* * initialize a buffer full of dquots and log the whole thing */STATIC voidxfs_qm_init_dquot_blk(	xfs_trans_t	*tp,	xfs_mount_t	*mp,	xfs_dqid_t	id,	uint		type,	xfs_buf_t	*bp){	struct xfs_quotainfo	*q = mp->m_quotainfo;	xfs_dqblk_t	*d;	int		curid, i;	ASSERT(tp);	ASSERT(xfs_buf_islocked(bp));	d = bp->b_addr;	/*	 * ID of the first dquot in the block - id's are zero based.	 */	curid = id - (id % q->qi_dqperchunk);	ASSERT(curid >= 0);	memset(d, 0, BBTOB(q->qi_dqchunklen));	for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {		d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);		d->dd_diskdq.d_version = XFS_DQUOT_VERSION;		d->dd_diskdq.d_id = cpu_to_be32(curid);		d->dd_diskdq.d_flags = type;		if (xfs_sb_version_hascrc(&mp->m_sb)) {			uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);			xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),					 XFS_DQUOT_CRC_OFF);		}	}	xfs_trans_dquot_buf(tp, bp,			    (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :			    ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :			     XFS_BLF_GDQUOT_BUF)));	xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);}

static voidxfs_attr3_rmt_read_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	char		*ptr;	int		len;	bool		corrupt = false;	xfs_daddr_t	bno;	/* no verification of non-crc buffers */	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= XFS_LBSIZE(mp));	while (len > 0) {		if (!xfs_verify_cksum(ptr, XFS_LBSIZE(mp),				      XFS_ATTR3_RMT_CRC_OFF)) {			corrupt = true;			break;		}		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {			corrupt = true;			break;		}		len -= XFS_LBSIZE(mp);		ptr += XFS_LBSIZE(mp);		bno += mp->m_bsize;	}	if (corrupt) {		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);		xfs_buf_ioerror(bp, EFSCORRUPTED);	} else		ASSERT(len == 0);}

static voidxfs_attr3_rmt_write_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	struct xfs_buf_log_item	*bip = bp->b_fspriv;	char		*ptr;	int		len;	xfs_daddr_t	bno;	/* no verification of non-crc buffers */	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= XFS_LBSIZE(mp));	while (len > 0) {		if (!xfs_attr3_rmt_verify(mp, ptr, XFS_LBSIZE(mp), bno)) {			XFS_CORRUPTION_ERROR(__func__,					    XFS_ERRLEVEL_LOW, mp, bp->b_addr);			xfs_buf_ioerror(bp, EFSCORRUPTED);			return;		}		if (bip) {			struct xfs_attr3_rmt_hdr *rmt;			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);		len -= XFS_LBSIZE(mp);		ptr += XFS_LBSIZE(mp);		bno += mp->m_bsize;	}	ASSERT(len == 0);}

static voidxfs_attr3_rmt_write_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	struct xfs_buf_log_item	*bip = bp->b_fspriv;	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))		return;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= blksize);	while (len > 0) {		if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {			xfs_buf_ioerror(bp, -EFSCORRUPTED);			xfs_verifier_error(bp);			return;		}		if (bip) {			struct xfs_attr3_rmt_hdr *rmt;			rmt = (struct xfs_attr3_rmt_hdr *)ptr;			rmt->rm_lsn = cpu_to_be64(bip->bli_item.li_lsn);		}		xfs_update_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF);		len -= blksize;		ptr += blksize;		bno += BTOBB(blksize);	}	ASSERT(len == 0);}

static voidxfs_dir3_block_write_verify(	struct xfs_buf	*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	struct xfs_buf_log_item	*bip = bp->b_fspriv;	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;	if (!xfs_dir3_block_verify(bp)) {		XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);		xfs_buf_ioerror(bp, EFSCORRUPTED);		return;	}	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	if (bip)		hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);	xfs_update_cksum(bp->b_addr, BBTOB(bp->b_length), XFS_DIR3_DATA_CRC_OFF);}

static voidxfs_dir3_block_write_verify(	struct xfs_buf	*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	struct xfs_buf_log_item	*bip = bp->b_fspriv;	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;	if (!xfs_dir3_block_verify(bp)) {		xfs_buf_ioerror(bp, -EFSCORRUPTED);		xfs_verifier_error(bp);		return;	}	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	if (bip)		hdr3->lsn = cpu_to_be64(bip->bli_item.li_lsn);	xfs_buf_update_cksum(bp, XFS_DIR3_DATA_CRC_OFF);}

static voidxfs_agfblock_init(	struct xfs_mount	*mp,	struct xfs_buf		*bp,	struct aghdr_init_data	*id){	struct xfs_agf		*agf = XFS_BUF_TO_AGF(bp);	xfs_extlen_t		tmpsize;	agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);	agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);	agf->agf_seqno = cpu_to_be32(id->agno);	agf->agf_length = cpu_to_be32(id->agsize);	agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));	agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));	agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);	agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);	if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {		agf->agf_roots[XFS_BTNUM_RMAPi] =					cpu_to_be32(XFS_RMAP_BLOCK(mp));		agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);		agf->agf_rmap_blocks = cpu_to_be32(1);	}	agf->agf_flfirst = cpu_to_be32(1);	agf->agf_fllast = 0;	agf->agf_flcount = 0;	tmpsize = id->agsize - mp->m_ag_prealloc_blocks;	agf->agf_freeblks = cpu_to_be32(tmpsize);	agf->agf_longest = cpu_to_be32(tmpsize);	if (xfs_sb_version_hascrc(&mp->m_sb))		uuid_copy(&agf->agf_uuid, &mp->m_sb.sb_meta_uuid);	if (xfs_sb_version_hasreflink(&mp->m_sb)) {		agf->agf_refcount_root = cpu_to_be32(				xfs_refc_block(mp));		agf->agf_refcount_level = cpu_to_be32(1);		agf->agf_refcount_blocks = cpu_to_be32(1);	}}

static boolxfs_dir3_block_verify(	struct xfs_buf		*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	struct xfs_dir3_blk_hdr	*hdr3 = bp->b_addr;	if (xfs_sb_version_hascrc(&mp->m_sb)) {		if (hdr3->magic != cpu_to_be32(XFS_DIR3_BLOCK_MAGIC))			return false;		if (!uuid_equal(&hdr3->uuid, &mp->m_sb.sb_uuid))			return false;		if (be64_to_cpu(hdr3->blkno) != bp->b_bn)			return false;	} else {		if (hdr3->magic != cpu_to_be32(XFS_DIR2_BLOCK_MAGIC))			return false;	}	if (__xfs_dir3_data_check(NULL, bp))		return false;	return true;}

static voidxfs_attr3_rmt_read_verify(	struct xfs_buf	*bp){	struct xfs_mount *mp = bp->b_target->bt_mount;	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))		return;	ptr = bp->b_addr;	bno = bp->b_bn;	len = BBTOB(bp->b_length);	ASSERT(len >= blksize);	while (len > 0) {		if (!xfs_verify_cksum(ptr, blksize, XFS_ATTR3_RMT_CRC_OFF)) {			xfs_buf_ioerror(bp, -EFSBADCRC);			break;		}		if (!xfs_attr3_rmt_verify(mp, ptr, blksize, bno)) {			xfs_buf_ioerror(bp, -EFSCORRUPTED);			break;		}		len -= blksize;		ptr += blksize;		bno += BTOBB(blksize);	}	if (bp->b_error)		xfs_verifier_error(bp);	else		ASSERT(len == 0);}

static voidxfs_sb_write_verify(	struct xfs_buf		*bp){	struct xfs_mount	*mp = bp->b_target->bt_mount;	struct xfs_buf_log_item	*bip = bp->b_fspriv;	int			error;	error = xfs_sb_verify(bp, false);	if (error) {		xfs_buf_ioerror(bp, error);		xfs_verifier_error(bp);		return;	}	if (!xfs_sb_version_hascrc(&mp->m_sb))		return;	if (bip)		XFS_BUF_TO_SBP(bp)->sb_lsn = cpu_to_be64(bip->bli_item.li_lsn);	xfs_buf_update_cksum(bp, XFS_SB_CRC_OFF);}

static voidxfs_dir3_block_init(	struct xfs_mount	*mp,	struct xfs_trans	*tp,	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;	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_DIR_BLOCK_BUF);	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);		uuid_copy(&hdr3->uuid, &mp->m_sb.sb_meta_uuid);		return;	}	hdr3->magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);}

STATIC intxfs_attr3_rmt_hdr_set(	struct xfs_mount	*mp,	void			*ptr,	xfs_ino_t		ino,	uint32_t		offset,	uint32_t		size,	xfs_daddr_t		bno){	struct xfs_attr3_rmt_hdr *rmt = ptr;	if (!xfs_sb_version_hascrc(&mp->m_sb))		return 0;	rmt->rm_magic = cpu_to_be32(XFS_ATTR3_RMT_MAGIC);	rmt->rm_offset = cpu_to_be32(offset);	rmt->rm_bytes = cpu_to_be32(size);	uuid_copy(&rmt->rm_uuid, &mp->m_sb.sb_uuid);	rmt->rm_owner = cpu_to_be64(ino);	rmt->rm_blkno = cpu_to_be64(bno);	return sizeof(struct xfs_attr3_rmt_hdr);}