tools/diskomizer/checker.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	"@(#)checker.c	1.8	09/05/26 SMI"

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

#ifndef _LARGEFILE64_SOURCE
#define	_LARGEFILE64_SOURCE
#endif /* _LARGEFILE64_SOURCE */

#include <strings.h>
#include <string.h>
#include "diskomizer64mpism.h"
#include <diskomizer/daio.h>

/*
 * This converts from long long to check_t without just throwing away
 * the high order bits. If u_longlong_t is the same size as check_t
 * the optimizer can (and does) throw this away.
 */

static check_t
ll_to_check(u_longlong_t ll)
{
	union {
		u_longlong_t ll;
		check_t check[sizeof (u_longlong_t)/sizeof (check_t)];
	} u;
	check_t x = 0;
	int i;

	u.ll = ll;

	for (i = 0; i < (sizeof (u_longlong_t)/sizeof (check_t)); i++) {
		x ^= u.check[i];
	}

	return (x);
}

check_t
check_sum(uchar_t *buf, size_t len)
{
	int i;
	u_longlong_t total = 0;

#ifdef __sparc
	if (((ulong_t)buf % sizeof (check_t)) == 0) {
#endif
		check_t *ptr = (check_t *)buf;
		for (i = 0; i < len/sizeof (check_t); i++) {
			total += *(ptr + i);
		}
#ifdef __sparc
	} else {
		union {
			check_t check;
			uchar_t c[sizeof (check_t)];
		} u;
		int  j;

		for (i = 0; i < len/sizeof (check_t); i++) {
			for (j = 0; j < sizeof (check_t); j++) {
				u.c[j] = *(buf + (i * sizeof (check_t)) + j);
			}
			total += u.check;
		}
	}
#endif
	return (ll_to_check(total));
}


static int
do_memcmp(uchar_t *buf, size_t len, struct daio_id *id)
{
	if (id->hdr_len && memcmp(&buf[0], id->hdr, id->hdr_len) != 0) {
		return (-1);
	}
	if (memcmp(&buf[id->hdr_len], &id->buf[id->hdr_len],
	    len - (id->hdr_len + id->footer_len)) != 0) {
		return (-1);
	}
	if (id->footer_len && memcmp(&buf[id->hdr_len + len - id->footer_len],
	    id->footer, id->footer_len) != 0) {
		return (-1);
	}
	return (0);
}
static int
do_chksum(uchar_t *buf, size_t len, struct daio_id *id)
{
	if (id->hdr_len && memcmp(&buf[0], id->hdr, id->hdr_len) != 0) {
		return (-1);
	}
	if (check_sum(&buf[id->hdr_len],
	    len - (id->hdr_len + id->footer_len)) != id->chksum) {
		return (-1);
	}
	if (id->footer_len && memcmp(&buf[id->hdr_len + len - id->footer_len],
	    id->footer, id->footer_len) != 0) {
		return (-1);
	}
	return (0);
}
/*
 * Readonly check.
 *
 * Since we are readonly the hdr, footer and buf pointers can not point to
 * the data that was written so we use these for our own purpose.
 *
 * If buf is NULL it is assumed that this is the first read of this block
 * so no actual check is done, but the check sum just stored in the chksum.
 *
 * if it is not null then it this is a subsequent read.
 */
static int
do_readonly_check(uchar_t *buf, size_t len, struct daio_id *id)
{
	if (id->buf != NULL) {
		if (check_sum(&buf[0], len) != id->chksum) {
			return (-1);
		}
	} else {
		id->chksum = check_sum(&buf[0], len);
		id->buf = (uchar_t *)1;
	}
	return (0);
}
/*ARGSUSED*/
static int
do_none_ro(uchar_t *buf, size_t len, struct daio_id *id)
{
	id->buf = (uchar_t *)1;
	return (0);
}
static int
do_none(uchar_t *buf, size_t len, struct daio_id *id)
{
	return (0);
}
int
does_check(data_checker_t x)
{
	return (do_none != x || do_none_ro == x);
}
struct checker {
	char *name;
	char *desc;
	data_checker_t checker;
	data_checker_t readonly;
};

static struct checker checkers[] = {
	{"CHECKSUM", "Using check sums to check data", do_chksum,
		do_readonly_check},
	{"FULL", "Doing full comparison to check data", do_memcmp,
		do_readonly_check},
	{"READONLY", "Using check sums to check read only data",
		do_readonly_check, do_readonly_check},
	{"NONE", "Not checking data",  do_none, do_none_ro},
};
#define	N_CHECKERS (sizeof (checkers)/sizeof (struct checker))

data_checker_t
choose_data_checker(const char *checker)
{
	ulong_t i;

	for (i = 0; i < N_CHECKERS; i++) {
		if (strcasecmp(checker, checkers[i].name) == 0)
			return (is_readonly() ?
			    checkers[i].readonly : checkers[i].checker);
	}
	return (NULL);
}
static struct checker *
find_checker(data_checker_t checker)
{
	ulong_t i;

	for (i = 0; i < N_CHECKERS; i++) {
		if (checker == checkers[i].checker)
			return (&checkers[i]);
	}
	for (i = 0; i < N_CHECKERS; i++) {
		if (checker == checkers[i].readonly)
			return (&checkers[i]);
	}
	return (NULL);
}
char *
checker_name(data_checker_t checker)
{
	static char unknown[] = "UNKNOWN";
	struct checker *cp;

	if ((cp = find_checker(checker)) != NULL) {
		return (cp->name);
	}
	return (&unknown[0]);
}
char *
checker_string(data_checker_t checker)
{
	static char unknown[] = "Unknown checker";
	struct checker *cp;

	if ((cp = find_checker(checker)) != NULL) {
		return (cp->desc);
	}
	return (&unknown[0]);
}