xfs: clarify documentation for the function to reverify buffers

}

/*

 * Set buffer ops on an unchecked buffer and validate it, if possible.

 * Reverify a buffer found in cache without an attached ->b_ops.

 *

 * If the caller passed in an ops structure and the buffer doesn't have ops

 * assigned, set the ops and use them to verify the contents.  If the contents

 * cannot be verified, we'll clear XBF_DONE.  We assume the buffer has no

 * recorded errors and is already in XBF_DONE state.

 * If the caller passed an ops structure and the buffer doesn't have ops

 * assigned, set the ops and use it to verify the contents. If verification

 * fails, clear XBF_DONE. We assume the buffer has no recorded errors and is

 * already in XBF_DONE state on entry.

 *

 * Under normal operations, every in-core buffer must have buffer ops assigned

 * to them when the buffer is read in from disk so that we can validate the

 * metadata.

 *

 * However, there are two scenarios where one can encounter in-core buffers

 * that don't have buffer ops.  The first is during log recovery of buffers on

 * a V4 filesystem, though these buffers are purged at the end of recovery.

 *

 * The other is online repair, which tries to match arbitrary metadata blocks

 * with btree types in order to find the root.  If online repair doesn't match

 * the buffer with /any/ btree type, the buffer remains in memory in DONE state

 * with no ops, and a subsequent read_buf call from elsewhere will not set the

 * ops.  This function helps us fix this situation.

 * Under normal operations, every in-core buffer is verified on read I/O

 * completion. There are two scenarios that can lead to in-core buffers without

 * an assigned ->b_ops. The first is during log recovery of buffers on a V4

 * filesystem, though these buffers are purged at the end of recovery. The

 * other is online repair, which intentionally reads with a NULL buffer ops to

 * run several verifiers across an in-core buffer in order to establish buffer

 * type.  If repair can't establish that, the buffer will be left in memory

 * with NULL buffer ops.

 */

int

xfs_buf_ensure_ops(

xfs_buf_reverify(

	struct xfs_buf		*bp,

	const struct xfs_buf_ops *ops)

{

		return bp;

	}

	xfs_buf_ensure_ops(bp, ops);

	xfs_buf_reverify(bp, ops);

	if (flags & XBF_ASYNC) {

		/*

#define xfs_getsize_buftarg(buftarg)	block_size((buftarg)->bt_bdev)

#define xfs_readonly_buftarg(buftarg)	bdev_read_only((buftarg)->bt_bdev)

int xfs_buf_ensure_ops(struct xfs_buf *bp, const struct xfs_buf_ops *ops);

int xfs_buf_reverify(struct xfs_buf *bp, const struct xfs_buf_ops *ops);

#endif	/* __XFS_BUF_H__ */

		 * release this buffer when it kills the tranaction.

		 */

		ASSERT(bp->b_ops != NULL);

		error = xfs_buf_ensure_ops(bp, ops);

		error = xfs_buf_reverify(bp, ops);

		if (error) {

			xfs_buf_ioerror_alert(bp, __func__);