tools/diskomizer/decode_errors.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

#pragma ident	"@(#)decode_errors.c	1.6	09/05/26 SMI"

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */


#include "diskomizer64mpism.h"
#include "args.h"
#include "bits.h"

static void
decode_matching(int pri, struct aio_str *aiop)
{
	struct fds *fd;

	fd = find_path(aiop->error.dev->fdhead, aiop->error.path_id);

	if (aiop->error.dev->fdhead->next != aiop->error.dev->fdhead) {
		plog(pri, "Buffer matches last write to block "
		    "byte offset 0t%lld (%#llx) on path %s (%s) to dev %s\n",
		    diskomizer_off2byteoff(aiop->error.doff),
		    diskomizer_off2byteoff(aiop->error.doff),
		    fd->longname, fd->shortname,
		    aiop->error.dev->logicalname);
	} else {
		plog(pri, "Buffer matches last write to block "
		    "byte offset 0t%lld (%#llx) on dev %s (%s)\n",
		    diskomizer_off2byteoff(aiop->error.doff),
		    diskomizer_off2byteoff(aiop->error.doff),
		    fd->shortname, aiop->error.dev->logicalname);
	}
	if (aiop->error.delta) {
		time_log(pri, aiop->error.last_requested,
		    "which was submitted to be written at");
		time_log(pri, aiop->error.last_requested +
		    aiop->error.delta,
		    "                     and returned at");
	} else {
		time_log(pri, aiop->error.last_requested,
		    "which was written at");
	}
}

static void
decode_length_mismatch(int pri, struct aio_str *aiop)
{
	plog(pri, "Wrong length in header, expected %#lx, got %#lx\n",
	    (long)INDEX_TO_DIOLEN(aiop->iolen), (long)aiop->error.len);
	if (aiop->error.desc.MATCHING_DEVICE) {
		time_log(pri, aiop->error.last_requested,
		    "The read header was submitted to byte offset"
		    " 0t%lld (%#llx) on path %s (%s) at",
		    diskomizer_off2byteoff(aiop->error.doff),
		    diskomizer_off2byteoff(aiop->error.doff),
		    aiop->error.fd->longname, aiop->error.fd->shortname);
	}
}

static void
decode_bits(int pri, struct diff_return *dr)
{
	union {
		uchar_t c[sizeof (dr->bits) / sizeof (uchar_t)];
		uint16_t s[sizeof (dr->bits) / sizeof (uint16_t)];
		uint32_t i[sizeof (dr->bits) / sizeof (uint32_t)];
		uint64_t l;
	} bits;
	uchar_t bc;
	uint64_t ans;
	char nbits;
	char nchars;
	char all_bits[64];

	if ((bc = count_uint64_bits(dr->bits)) == 64 || bc == 0) {
		return;
	}

	bits.l = dr->bits;

	if (bits.i[0] == bits.i[1]) {
		if (bits.s[0] == bits.s[1]) {
			if (bits.c[0] == bits.c[1]) {
				nchars = 2;
				nbits = 8;
				ans = bits.c[0];
				bc = count_uint8_bits(bits.c[0]);
				what_uint8_bits_set(ans, all_bits);
			} else {
				nchars = 4;
				nbits = 16;
				ans = bits.s[0];
				bc = count_uint16_bits(bits.s[0]);
				what_uint16_bits_set(ans, all_bits);
			}
		} else {
			nchars = 8;
			nbits = 32;
			ans = bits.i[0];
			bc = count_uint32_bits(bits.i[0]);
			what_uint32_bits_set(ans, all_bits);
		}
	} else {
		nchars = 16;
		nbits = 64;
		ans = bits.l;
		what_uint64_bits_set(ans, all_bits);
	}


	if (bc == 1 && !OPTION(obscure_raw_bits)) {
		plog(pri,
		    "bit flip%s seen in bit %d of a %d bit word\n",
		    dr->count == 1 ? " is" : "s are",
		    (int)all_bits[0], nbits);
	} else if (bc < nbits/2 && bc < 8 &&!OPTION(obscure_raw_bits)) {
		char str[25];
		int i;
		int j;

		str[0] = NULL;

		for (i = j = 0; i < bc; i++)  {
			int x = snprintf(&str[j], sizeof (str) - j, "%s%2.2d",
			    i > 0 ? "," : "", all_bits[i]);
			j += x;
		}
		plog(pri,
		    "bit flips are seen in bits %s of a %d bit word\n",
		    str, nbits);
	} else {
		plog(pri,
		    "bit flips are seen in these %d bit aligned bits "
		    "0x%*.*llx\n", nbits, nchars, nchars, ans);
	}
}

void
decode_errors(int pri, struct aio_str *aiop, int read_count)
{
	if (aiop->error.desc.LENGTH_MISMATCH) {
		decode_length_mismatch(pri, aiop);
	}
	if (aiop->error.desc.MATCHING_LAST) {
		decode_matching(pri, aiop);
	}
	if (aiop->error.diff_file != NULL) {
		plog(LOG_ERR, "Diffs file dumped to %s\n",
		    aiop->error.diff_file);
		aiop->error.diff_file = NULL;
	}
	if (read_count != 0) {
		plog(LOG_ERR, "Block has previously been read successfully "
		    "%d time%s and is now in error.\n", read_count,
		    read_count > 1 ? "s" : "");
	}
}

void
report_error_desc(int pri, struct aio_str *aiop, const char *str)
{
	if (aiop->error.desc.HEADER_CHECKSUM_ERR) {
		struct bufhdr_a hdr = get_bufhdr_a(aiop->buf);

		plog(pri, "bad header checksum, expected %#llx, got %#llx\n",
		    (long long)hdr.hdrchksum, aiop->error.bad_checksum);
	} else if (aiop->error.desc.BODY_CHECKSUM_ERR) {
		struct bufhdr_a hdr = get_bufhdr_a(aiop->buf);

		plog(pri,
		    "bad body checksum for %s, expected %#llx, got %#llx%s\n",
		    hdr.type.BUF_EXECUTABLE ? "func" : "data",
		    hdr.chksum, aiop->error.bad_checksum,
		    opts.fix_bad_checksums ? " (Fixed)" : "");
	}
	/*
	 * If less than 1% of the total bits transported are corrupt
	 * then consider this to be "bit" corruption and report it as such
	 */
	if (aiop->error.dr.count &&
	    (100 * (opts.obscure_bit_percentage * aiop->error.dr.count)) <
	    (INDEX_TO_DIOLEN(aiop->iolen) * CHAR_BIT)) {
		plog(pri, "%s%s bit corruption detected: %lld bit%s flipped\n",
		    str, aiop->retrycnt > 0 ? " retry" : "",
		    aiop->error.dr.count, aiop->error.dr.count == 1 ? "" : "s");
		decode_bits(pri, &aiop->error.dr);
	} else {
		plog(pri, "%s%s corruption detected\n",
		    str, aiop->retrycnt > 0 ? " retry" : "");
	}

}