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

/* * Mark bytes first through last inclusive as dirty in the buf * item's bitmap. */voidxfs_buf_item_log(	xfs_buf_log_item_t	*bip,	uint			first,	uint			last){	int			i;	uint			start;	uint			end;	struct xfs_buf		*bp = bip->bli_buf;	/*	 * walk each buffer segment and mark them dirty appropriately.	 */	start = 0;	for (i = 0; i < bip->bli_format_count; i++) {		if (start > last)			break;		end = start + BBTOB(bp->b_maps[i].bm_len);		if (first > end) {			start += BBTOB(bp->b_maps[i].bm_len);			continue;		}		if (first < start)			first = start;		if (end > last)			end = last;		xfs_buf_item_log_segment(first, end,					 &bip->bli_formats[i].blf_data_map[0]);		start += bp->b_maps[i].bm_len;	}}

/* * 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){	xfs_dqblk_t	*d;	int		curid, i;	ASSERT(tp);	ASSERT(XFS_BUF_ISBUSY(bp));	ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);	d = (xfs_dqblk_t *)XFS_BUF_PTR(bp);	/*	 * ID of the first dquot in the block - id's are zero based.	 */	curid = id - (id % XFS_QM_DQPERBLK(mp));	ASSERT(curid >= 0);	memset(d, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)));	for (i = 0; i < XFS_QM_DQPERBLK(mp); i++, d++, curid++)		xfs_qm_dqinit_core(curid, type, d);	xfs_trans_dquot_buf(tp, bp,			    (type & XFS_DQ_USER ? XFS_BLI_UDQUOT_BUF :			    ((type & XFS_DQ_PROJ) ? XFS_BLI_PDQUOT_BUF :			     XFS_BLI_GDQUOT_BUF)));	xfs_trans_log_buf(tp, bp, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1);}

/* Convert an xfs_fsmap to an fsmap. */voidxfs_fsmap_from_internal(	struct fsmap		*dest,	struct xfs_fsmap	*src){	dest->fmr_device = src->fmr_device;	dest->fmr_flags = src->fmr_flags;	dest->fmr_physical = BBTOB(src->fmr_physical);	dest->fmr_owner = src->fmr_owner;	dest->fmr_offset = BBTOB(src->fmr_offset);	dest->fmr_length = BBTOB(src->fmr_length);	dest->fmr_reserved[0] = 0;	dest->fmr_reserved[1] = 0;	dest->fmr_reserved[2] = 0;}

voidxfs_symlink_local_to_remote(	struct xfs_trans	*tp,	struct xfs_buf		*bp,	struct xfs_inode	*ip,	struct xfs_ifork	*ifp){	struct xfs_mount	*mp = ip->i_mount;	char			*buf;	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_SYMLINK_BUF);	if (!xfs_sb_version_hascrc(&mp->m_sb)) {		bp->b_ops = NULL;		memcpy(bp->b_addr, ifp->if_u1.if_data, ifp->if_bytes);		xfs_trans_log_buf(tp, bp, 0, ifp->if_bytes - 1);		return;	}	/*	 * As this symlink fits in an inode literal area, it must also fit in	 * the smallest buffer the filesystem supports.	 */	ASSERT(BBTOB(bp->b_length) >=			ifp->if_bytes + sizeof(struct xfs_dsymlink_hdr));	bp->b_ops = &xfs_symlink_buf_ops;	buf = bp->b_addr;	buf += xfs_symlink_hdr_set(mp, ip->i_ino, 0, ifp->if_bytes, bp);	memcpy(buf, ifp->if_u1.if_data, ifp->if_bytes);	xfs_trans_log_buf(tp, bp, 0, sizeof(struct xfs_dsymlink_hdr) +					ifp->if_bytes - 1);}

/* * This function is called to verify that our callers have logged * all the bytes that they changed. * * It does this by comparing the original copy of the buffer stored in * the buf log item's bli_orig array to the current copy of the buffer * and ensuring that all bytes which mismatch are set in the bli_logged * array of the buf log item. */STATIC voidxfs_buf_item_log_check(	xfs_buf_log_item_t	*bip){	char		*orig;	char		*buffer;	int		x;	xfs_buf_t	*bp;	ASSERT(bip->bli_orig != NULL);	ASSERT(bip->bli_logged != NULL);	bp = bip->bli_buf;	ASSERT(bp->b_length > 0);	ASSERT(bp->b_addr != NULL);	orig = bip->bli_orig;	buffer = bp->b_addr;	for (x = 0; x < BBTOB(bp->b_length); x++) {		if (orig[x] != buffer[x] && !btst(bip->bli_logged, x)) {			xfs_emerg(bp->b_mount,				"%s: bip %x buffer %x orig %x index %d",				__func__, bip, bp, orig, x);			ASSERT(0);		}	}}

/* Initialize a new AG btree root block with zero entries. */intxrep_init_btblock(	struct xfs_scrub		*sc,	xfs_fsblock_t			fsb,	struct xfs_buf			**bpp,	xfs_btnum_t			btnum,	const struct xfs_buf_ops	*ops){	struct xfs_trans		*tp = sc->tp;	struct xfs_mount		*mp = sc->mp;	struct xfs_buf			*bp;	trace_xrep_init_btblock(mp, XFS_FSB_TO_AGNO(mp, fsb),			XFS_FSB_TO_AGBNO(mp, fsb), btnum);	ASSERT(XFS_FSB_TO_AGNO(mp, fsb) == sc->sa.agno);	bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, XFS_FSB_TO_DADDR(mp, fsb),			XFS_FSB_TO_BB(mp, 1), 0);	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));	xfs_btree_init_block(mp, bp, btnum, 0, 0, sc->sa.agno, 0);	xfs_trans_buf_set_type(tp, bp, XFS_BLFT_BTREE_BUF);	xfs_trans_log_buf(tp, bp, 0, bp->b_length);	bp->b_ops = ops;	*bpp = bp;	return 0;}

/* * Warnings specifically for verifier errors.  Differentiate CRC vs. invalid * values, and omit the stack trace unless the error level is tuned high. */voidxfs_verifier_error(	struct xfs_buf		*bp){	xfs_alert(NULL, "Metadata %s detected at %s block 0x%llx/0x%x",		  bp->b_error == -EFSBADCRC ? "CRC error" : "corruption",		  bp->b_ops->name, bp->b_bn, BBTOB(bp->b_length));}

/* * Allocate a new buf log item to go with the given buffer. * Set the buffer's b_fsprivate field to point to the new * buf log item.  If there are other item's attached to the * buffer (see xfs_buf_attach_iodone() below), then put the * buf log item at the front. */voidxfs_buf_item_init(	xfs_buf_t	*bp,	xfs_mount_t	*mp){	xfs_log_item_t		*lip = bp->b_fspriv;	xfs_buf_log_item_t	*bip;	int			chunks;	int			map_size;	int			error;	int			i;	/*	 * Check to see if there is already a buf log item for	 * this buffer.  If there is, it is guaranteed to be	 * the first.  If we do already have one, there is	 * nothing to do here so return.	 */	ASSERT(bp->b_target->bt_mount == mp);	if (lip != NULL && lip->li_type == XFS_LI_BUF)		return;	bip = kmem_zone_zalloc(xfs_buf_item_zone, KM_SLEEP);	xfs_log_item_init(mp, &bip->bli_item, XFS_LI_BUF, &xfs_buf_item_ops);	bip->bli_buf = bp;	xfs_buf_hold(bp);	/*	 * chunks is the number of XFS_BLF_CHUNK size pieces the buffer	 * can be divided into. Make sure not to truncate any pieces.	 * map_size is the size of the bitmap needed to describe the	 * chunks of the buffer.	 *	 * Discontiguous buffer support follows the layout of the underlying	 * buffer. This makes the implementation as simple as possible.	 */	error = xfs_buf_item_get_format(bip, bp->b_map_count);	ASSERT(error == 0);	for (i = 0; i < bip->bli_format_count; i++) {		chunks = DIV_ROUND_UP(BBTOB(bp->b_maps[i].bm_len),				      XFS_BLF_CHUNK);		map_size = DIV_ROUND_UP(chunks, NBWORD);		bip->bli_formats[i].blf_type = XFS_LI_BUF;		bip->bli_formats[i].blf_blkno = bp->b_maps[i].bm_bn;		bip->bli_formats[i].blf_len = bp->b_maps[i].bm_len;		bip->bli_formats[i].blf_map_size = map_size;	}	/*	 * Put the buf item into the list of items attached to the	 * buffer at the front.	 */	if (bp->b_fspriv)		bip->bli_item.li_bio_list = bp->b_fspriv;	bp->b_fspriv = bip;}

xfs_buf_t *xfs_buf_get_flags(xfs_buftarg_t *target, xfs_daddr_t blkno, size_t len, int flags){	struct buf *bp = NULL;	KASSERT((target != NULL), ("got NULL buftarg_t"));	bp = getblk(target->specvp, blkno, BBTOB(len), 0, 0, 0);	if (bp != NULL)		xfs_buf_set_target(bp, target);	return (bp);}

/* * 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);}

xfs_buf_t *xfs_buf_read_flags(xfs_buftarg_t *target, xfs_daddr_t blkno, size_t len, int flags){	struct buf *bp;	KASSERT((target != NULL), ("got NULL buftarg_t"));	if (bread(target->specvp, blkno, BBTOB(len), NOCRED, &bp)) {		printf("bread failed specvp %p blkno %qd BBTOB(len) %ld/n",		       target->specvp, blkno, (long)BBTOB(len));		bp = NULL;	}	/* not really sure what B_MANAGED really does for us	 * maybe we should drop this and just stick with a locked buf	 */	if (flags & B_MANAGED)		bp->b_flags |= B_MANAGED;	xfs_buf_set_target(bp, target);	return (bp);}

intxfs_calc_dquots_per_chunk(	struct xfs_mount	*mp,	unsigned int		nbblks)	/* basic block units */{	unsigned int	ndquots;	ASSERT(nbblks > 0);	ndquots = BBTOB(nbblks);	do_div(ndquots, sizeof(xfs_dqblk_t));	return ndquots;}

/* * Call fiemap helper to fill in user data. * Returns positive errors to xfs_getbmap. */STATIC intxfs_fiemap_format(	void			**arg,	struct getbmapx		*bmv,	int			*full){	int			error;	struct fiemap_extent_info *fieinfo = *arg;	u32			fiemap_flags = 0;	u64			logical, physical, length;	/* Do nothing for a hole */	if (bmv->bmv_block == -1LL)		return 0;	logical = BBTOB(bmv->bmv_offset);	physical = BBTOB(bmv->bmv_block);	length = BBTOB(bmv->bmv_length);	if (bmv->bmv_oflags & BMV_OF_PREALLOC)		fiemap_flags |= FIEMAP_EXTENT_UNWRITTEN;	else if (bmv->bmv_oflags & BMV_OF_DELALLOC) {		fiemap_flags |= (FIEMAP_EXTENT_DELALLOC |				 FIEMAP_EXTENT_UNKNOWN);		physical = 0;   /* no block yet */	}	if (bmv->bmv_oflags & BMV_OF_LAST)		fiemap_flags |= FIEMAP_EXTENT_LAST;	error = fiemap_fill_next_extent(fieinfo, logical, physical,					length, fiemap_flags);	if (error > 0) {		error = 0;		*full = 1;	/* user array now full */	}	return -error;}

voidxfs_buf_readahead(		  xfs_buftarg_t		*target,		  xfs_daddr_t		ioff,		  size_t		isize,		  xfs_buf_flags_t	flags){	daddr_t rablkno;	int rabsize;	rablkno = ioff;	rabsize = BBTOB(isize);	breada(target->specvp, &rablkno, &rabsize, 1, NOCRED);}

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);	}}

STATIC voidxfs_attr_rmtval_copyin(	struct xfs_mount *mp,	struct xfs_buf	*bp,	xfs_ino_t	ino,	int		*offset,	int		*valuelen,	__uint8_t	**src){	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 >= blksize);	while (len > 0 && *valuelen > 0) {		int hdr_size;		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,						 byte_cnt, bno);		memcpy(dst + hdr_size, *src, byte_cnt);		/*		 * 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 < blksize) {			ASSERT(*valuelen - byte_cnt == 0);			ASSERT(len == blksize);			memset(dst + hdr_size + byte_cnt, 0,					blksize - hdr_size - byte_cnt);		}		/* roll buffer forwards */		len -= blksize;		dst += blksize;		bno += BTOBB(blksize);		/* roll attribute data forwards */		*valuelen -= byte_cnt;		*src += byte_cnt;		*offset += byte_cnt;	}}

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;}

/* XXX: (dgc) Propagate errors, only exit if fail-on-error flag set */intlibxfs_device_zero(struct xfs_buftarg *btp, xfs_daddr_t start, uint len){	xfs_off_t	start_offset, end_offset, offset;	ssize_t		zsize, bytes;	char		*z;	int		fd;	zsize = min(BDSTRAT_SIZE, BBTOB(len));	if ((z = memalign(libxfs_device_alignment(), zsize)) == NULL) {		fprintf(stderr,			_("%s: %s can't memalign %d bytes: %s/n"),			progname, __FUNCTION__, (int)zsize, strerror(errno));		exit(1);	}	memset(z, 0, zsize);	fd = libxfs_device_to_fd(btp->dev);	start_offset = LIBXFS_BBTOOFF64(start);	if ((lseek64(fd, start_offset, SEEK_SET)) < 0) {		fprintf(stderr, _("%s: %s seek to offset %llu failed: %s/n"),			progname, __FUNCTION__,			(unsigned long long)start_offset, strerror(errno));		exit(1);	}	end_offset = LIBXFS_BBTOOFF64(start + len) - start_offset;	for (offset = 0; offset < end_offset; ) {		bytes = min((ssize_t)(end_offset - offset), zsize);		if ((bytes = write(fd, z, bytes)) < 0) {			fprintf(stderr, _("%s: %s write failed: %s/n"),				progname, __FUNCTION__, strerror(errno));			exit(1);		} else if (bytes == 0) {			fprintf(stderr, _("%s: %s not progressing?/n"),				progname, __FUNCTION__);			exit(1);		}		offset += bytes;	}	free(z);	return 0;}

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 struct xfs_buf *xfs_get_aghdr_buf(	struct xfs_mount	*mp,	xfs_daddr_t		blkno,	size_t			numblks,	int			flags,	const struct xfs_buf_ops *ops){	struct xfs_buf		*bp;	bp = xfs_buf_get_uncached(mp->m_ddev_targp, numblks, flags);	if (!bp)		return NULL;	xfs_buf_zero(bp, 0, BBTOB(bp->b_length));	bp->b_bn = blkno;	bp->b_maps[0].bm_bn = blkno;	bp->b_ops = ops;	return bp;}

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_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);}

/* * Check that the holemask and freemask of a hypothetical inode cluster match * what's actually on disk.  If sparse inodes are enabled, the cluster does * not actually have to map to inodes if the corresponding holemask bit is set. * * @cluster_base is the first inode in the cluster within the @irec. */STATIC intxchk_iallocbt_check_cluster(	struct xchk_btree		*bs,	struct xfs_inobt_rec_incore	*irec,	unsigned int			cluster_base){	struct xfs_imap			imap;	struct xfs_mount		*mp = bs->cur->bc_mp;	struct xfs_dinode		*dip;	struct xfs_buf			*cluster_bp;	unsigned int			nr_inodes;	xfs_agnumber_t			agno = bs->cur->bc_private.a.agno;	xfs_agblock_t			agbno;	unsigned int			cluster_index;	uint16_t			cluster_mask = 0;	uint16_t			ir_holemask;	int				error = 0;	nr_inodes = min_t(unsigned int, XFS_INODES_PER_CHUNK,			mp->m_inodes_per_cluster);	/* Map this inode cluster */	agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino + cluster_base);	/* Compute a bitmask for this cluster that can be used for holemask. */	for (cluster_index = 0;	     cluster_index < nr_inodes;	     cluster_index += XFS_INODES_PER_HOLEMASK_BIT)		cluster_mask |= XFS_INOBT_MASK((cluster_base + cluster_index) /				XFS_INODES_PER_HOLEMASK_BIT);	/*	 * Map the first inode of this cluster to a buffer and offset.	 * Be careful about inobt records that don't align with the start of	 * the inode buffer when block sizes are large enough to hold multiple	 * inode chunks.  When this happens, cluster_base will be zero but	 * ir_startino can be large enough to make im_boffset nonzero.	 */	ir_holemask = (irec->ir_holemask & cluster_mask);	imap.im_blkno = XFS_AGB_TO_DADDR(mp, agno, agbno);	imap.im_len = XFS_FSB_TO_BB(mp, mp->m_blocks_per_cluster);	imap.im_boffset = XFS_INO_TO_OFFSET(mp, irec->ir_startino);	if (imap.im_boffset != 0 && cluster_base != 0) {		ASSERT(imap.im_boffset == 0 || cluster_base == 0);		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);		return 0;	}	trace_xchk_iallocbt_check_cluster(mp, agno, irec->ir_startino,			imap.im_blkno, imap.im_len, cluster_base, nr_inodes,			cluster_mask, ir_holemask,			XFS_INO_TO_OFFSET(mp, irec->ir_startino +					  cluster_base));	/* The whole cluster must be a hole or not a hole. */	if (ir_holemask != cluster_mask && ir_holemask != 0) {		xchk_btree_set_corrupt(bs->sc, bs->cur, 0);		return 0;	}	/* If any part of this is a hole, skip it. */	if (ir_holemask) {		xchk_xref_is_not_owned_by(bs->sc, agbno,				mp->m_blocks_per_cluster,				&XFS_RMAP_OINFO_INODES);		return 0;	}	xchk_xref_is_owned_by(bs->sc, agbno, mp->m_blocks_per_cluster,			&XFS_RMAP_OINFO_INODES);	/* Grab the inode cluster buffer. */	error = xfs_imap_to_bp(mp, bs->cur->bc_tp, &imap, &dip, &cluster_bp,			0, 0);	if (!xchk_btree_xref_process_error(bs->sc, bs->cur, 0, &error))		return error;	/* Check free status of each inode within this cluster. */	for (cluster_index = 0; cluster_index < nr_inodes; cluster_index++) {		struct xfs_dinode	*dip;		if (imap.im_boffset >= BBTOB(cluster_bp->b_length)) {			xchk_btree_set_corrupt(bs->sc, bs->cur, 0);			break;		}		dip = xfs_buf_offset(cluster_bp, imap.im_boffset);		error = xchk_iallocbt_check_cluster_ifree(bs, irec,				cluster_base + cluster_index, dip);		if (error)			break;		imap.im_boffset += mp->m_sb.sb_inodesize;//.........这里部分代码省略.........

/* * Allocate a new buf log item to go with the given buffer. * Set the buffer's b_fsprivate field to point to the new * buf log item.  If there are other item's attached to the * buffer (see xfs_buf_attach_iodone() below), then put the * buf log item at the front. */voidxfs_buf_item_init(	xfs_buf_t	*bp,	xfs_mount_t	*mp){	xfs_log_item_t		*lip = bp->b_fspriv;	xfs_buf_log_item_t	*bip;	int			chunks;	int			map_size;	int			error;	int			i;	/*	 * Check to see if there is already a buf log item for	 * this buffer.  If there is, it is guaranteed to be	 * the first.  If we do already have one, there is	 * nothing to do here so return.	 */	ASSERT(bp->b_target->bt_mount == mp);	if (lip != NULL && lip->li_type == XFS_LI_BUF)		return;	bip = kmem_zone_zalloc(xfs_buf_item_zone, KM_SLEEP);	xfs_log_item_init(mp, &bip->bli_item, XFS_LI_BUF, &xfs_buf_item_ops);	bip->bli_buf = bp;	xfs_buf_hold(bp);	/*	 * chunks is the number of XFS_BLF_CHUNK size pieces the buffer	 * can be divided into. Make sure not to truncate any pieces.	 * map_size is the size of the bitmap needed to describe the	 * chunks of the buffer.	 *	 * Discontiguous buffer support follows the layout of the underlying	 * buffer. This makes the implementation as simple as possible.	 */	error = xfs_buf_item_get_format(bip, bp->b_map_count);	ASSERT(error == 0);	for (i = 0; i < bip->bli_format_count; i++) {		chunks = DIV_ROUND_UP(BBTOB(bp->b_maps[i].bm_len),				      XFS_BLF_CHUNK);		map_size = DIV_ROUND_UP(chunks, NBWORD);		bip->bli_formats[i].blf_type = XFS_LI_BUF;		bip->bli_formats[i].blf_blkno = bp->b_maps[i].bm_bn;		bip->bli_formats[i].blf_len = bp->b_maps[i].bm_len;		bip->bli_formats[i].blf_map_size = map_size;	}#ifdef XFS_TRANS_DEBUG	/*	 * Allocate the arrays for tracking what needs to be logged	 * and what our callers request to be logged.  bli_orig	 * holds a copy of the original, clean buffer for comparison	 * against, and bli_logged keeps a 1 bit flag per byte in	 * the buffer to indicate which bytes the callers have asked	 * to have logged.	 */	bip->bli_orig = kmem_alloc(BBTOB(bp->b_length), KM_SLEEP);	memcpy(bip->bli_orig, bp->b_addr, BBTOB(bp->b_length));	bip->bli_logged = kmem_zalloc(BBTOB(bp->b_length) / NBBY, KM_SLEEP);#endif	/*	 * Put the buf item into the list of items attached to the	 * buffer at the front.	 */	if (bp->b_fspriv)		bip->bli_item.li_bio_list = bp->b_fspriv;	bp->b_fspriv = bip;}

static voidzero_log(xfs_mount_t *mp){	int error;	xlog_t	log;	xfs_daddr_t head_blk, tail_blk;	dev_t logdev = (mp->m_sb.sb_logstart == 0) ? x.logdev : x.ddev;	memset(&log, 0, sizeof(log));	if (!x.logdev)		x.logdev = x.ddev;	x.logBBsize = XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);	x.logBBstart = XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart);	log.l_dev = logdev;	log.l_logsize = BBTOB(x.logBBsize);	log.l_logBBsize = x.logBBsize;	log.l_logBBstart = x.logBBstart;	log.l_mp = mp;	if (xfs_sb_version_hassector(&mp->m_sb)) {		log.l_sectbb_log = mp->m_sb.sb_logsectlog - BBSHIFT;		ASSERT(log.l_sectbb_log <= mp->m_sectbb_log);		/* for larger sector sizes, must have v2 or external log */		ASSERT(log.l_sectbb_log == 0 ||			log.l_logBBstart == 0 ||			xfs_sb_version_haslogv2(&mp->m_sb));		ASSERT(mp->m_sb.sb_logsectlog >= BBSHIFT);	}	log.l_sectbb_mask = (1 << log.l_sectbb_log) - 1;	if ((error = xlog_find_tail(&log, &head_blk, &tail_blk))) {		do_warn(_("zero_log: cannot find log head/tail "			  "(xlog_find_tail=%d), zeroing it anyway/n"),			error);	} else {		if (verbose) {			do_warn(_("zero_log: head block %lld tail block %lld/n"),				head_blk, tail_blk);		}		if (head_blk != tail_blk) {			if (zap_log) {				do_warn(_("ALERT: The filesystem has valuable metadata changes in a log which is being/n""destroyed because the -L option was used./n"));			} else {				do_warn(_("ERROR: The filesystem has valuable metadata changes in a log which needs to/n""be replayed.  Mount the filesystem to replay the log, and unmount it before/n""re-running xfs_repair.  If you are unable to mount the filesystem, then use/n""the -L option to destroy the log and attempt a repair./n""Note that destroying the log may cause corruption -- please attempt a mount/n""of the filesystem before doing this./n"));				exit(2);			}		}	}	libxfs_log_clear(logdev,		XFS_FSB_TO_DADDR(mp, mp->m_sb.sb_logstart),		(xfs_extlen_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks),		&mp->m_sb.sb_uuid,		xfs_sb_version_haslogv2(&mp->m_sb) ? 2 : 1,		mp->m_sb.sb_logsunit, XLOG_FMT);}

/* * This initializes all the quota information that's kept in the * mount structure */STATIC intxfs_qm_init_quotainfo(	xfs_mount_t	*mp){	xfs_quotainfo_t *qinf;	int		error;	xfs_dquot_t	*dqp;	ASSERT(XFS_IS_QUOTA_RUNNING(mp));	qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);	/*	 * See if quotainodes are setup, and if not, allocate them,	 * and change the superblock accordingly.	 */	if ((error = xfs_qm_init_quotainos(mp))) {		kmem_free(qinf);		mp->m_quotainfo = NULL;		return error;	}	INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);	INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);	mutex_init(&qinf->qi_tree_lock);	INIT_LIST_HEAD(&qinf->qi_lru_list);	qinf->qi_lru_count = 0;	mutex_init(&qinf->qi_lru_lock);	/* mutex used to serialize quotaoffs */	mutex_init(&qinf->qi_quotaofflock);	/* Precalc some constants */	qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);	ASSERT(qinf->qi_dqchunklen);	qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);	do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));	mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);	/*	 * We try to get the limits from the superuser's limits fields.	 * This is quite hacky, but it is standard quota practice.	 *	 * We look at the USR dquot with id == 0 first, but if user quotas	 * are not enabled we goto the GRP dquot with id == 0.	 * We don't really care to keep separate default limits for user	 * and group quotas, at least not at this point.	 *	 * Since we may not have done a quotacheck by this point, just read	 * the dquot without attaching it to any hashtables or lists.	 */	error = xfs_qm_dqread(mp, 0,			XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :			 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :			  XFS_DQ_PROJ),			XFS_QMOPT_DOWARN, &dqp);	if (!error) {		xfs_disk_dquot_t	*ddqp = &dqp->q_core;		/*		 * The warnings and timers set the grace period given to		 * a user or group before he or she can not perform any		 * more writing. If it is zero, a default is used.		 */		qinf->qi_btimelimit = ddqp->d_btimer ?			be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;		qinf->qi_itimelimit = ddqp->d_itimer ?			be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;		qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?			be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;		qinf->qi_bwarnlimit = ddqp->d_bwarns ?			be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;		qinf->qi_iwarnlimit = ddqp->d_iwarns ?			be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;		qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?			be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;		qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);		qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);		qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);		qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);		qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);		qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit); 		xfs_qm_dqdestroy(dqp);	} else {		qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;		qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;		qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;		qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;		qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;		qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;	}	qinf->qi_shrinker.shrink = xfs_qm_shake;//.........这里部分代码省略.........