common/lvm/md_crc.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I% %E% SMI"

#include <sys/param.h>

static uint_t       *mddb_crctab = NULL;

#ifndef _KERNEL
#include <meta.h>
#include <assert.h>
#define MD_ZALLOC(x)    Zalloc(x)
#define MD_FREE(x, y)   Free(x)
#else   /* _KERNEL */
#define MD_ZALLOC(x)    kmem_zalloc(x, KM_SLEEP)
#define MD_FREE(x, y)   kmem_free(x, y)
#include <sys/thread.h>
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#endif  /* ! _KERNEL */
#include <sys/lvm/md_crc.h>

#define MDDB_CRCMAGIC 987654

static uint_t *
crcgentab(void)
{
    int b, i;
    uint_t      v;
    uint_t      *crctab;
    uint_t      poly = 0x04c11db7;

    crctab = (uint_t *)MD_ZALLOC(256 * sizeof (int));
    for (b = 0; b < 256; b++) {
        for (v = b << (24), i = 0; i < 8; i++) {
            if (v & ((unsigned int)1 << 31)) {
                v = (v << 1) ^ poly;
            } else {
                v = v << 1;
            }
        }
        crctab[b] = v;
    }
    return (crctab);
}

/*
 * crc function that allows  a number of areas to be skipped (ignored)
 * during the crc computation.  The result area of the record is also ignored
 * during the crc computation.  Ignored areas are used for data that may
 * be changed after record has been crcgen'd, but before the data has been
 * written to disk or for when a multi-owner diskset may have multiple
 * nodes writing the same record data with the exception of the timestamp field.
 * The list of skip areas must be in ascending order of offset and if any
 * areas overlap, the list will be modified.
 */
uint_t
crcfunc(
    uint_t  check,
    uchar_t *record,    /* record to be check-summed */
    uint_t  *result,    /* put check-sum here(really u_long) */
    size_t  size,       /* size of record in bytes */
    crc_skip_t *skip    /* list of areas to skip */
)
{
    uint_t      newcrc;
    uint_t      *crctab;
    uchar_t     *recaddr;
    crc_skip_t  *s, *p;

    /*
     * Check skip areas to see if they overlap (this should never happen,
     * but is handled just in case something changes in the future).
     * Also the skip list must be in ascending order of offset, assert
     * error if this is not the case.
     * If any 2 adjacent skip areas overlap, then the skip areas will
     * be merged into 1 skip area and the other skip area is freed.
     * If any 2 adjacent skip areas abut (border) each other, then skip
     * areas are not merged, but are left as 2 independent skip areas.
     * If the skip areas are identical, no change is made to either skip
     * area since this is handled later.
     */
    if (skip) {
        p = NULL;
        for (s = skip; s != NULL; s = s->skip_next) {
            if (p == NULL) {
                p = s;
                continue;
            }
#ifdef _KERNEL
            ASSERT(s->skip_offset > p->skip_offset);
#else
            assert(s->skip_offset > p->skip_offset);
#endif
            if ((p->skip_offset + p->skip_size) > s->skip_offset) {
                /*
                 * Current area overlaps previous, modify
                 * previous area and release current
                 */
                p->skip_size += s->skip_size - (p->skip_offset
                    + p->skip_size - s->skip_offset);
                p->skip_next = s->skip_next;
                MD_FREE(s, sizeof (crc_skip_t));
                s = p;
            }
            p = s;
        }
    }

    if (! mddb_crctab)
        mddb_crctab = crcgentab();

    crctab = mddb_crctab;
    newcrc = MDDB_CRCMAGIC;

    recaddr = record;
    s = skip;
    while (size--) {
        /* Skip the result pointer */
        if (record == (uchar_t *)result) {
            record += sizeof (uint_t);
            size -= (sizeof (uint_t) - 1);
            continue;
        }

        /*
         * Skip over next skip area if non-null
         */
        if ((s) && (record == (recaddr + (s->skip_offset)))) {
            record += s->skip_size;
            size -= (s->skip_size - 1);
            s = s->skip_next;
            continue;
        }

        newcrc = (newcrc << 8) ^ crctab[(newcrc >> 24) ^ *record++];
    }

    /* If we are checking, we either get a 0 - OK, or 1 - Not OK result */
    if (check) {
        if (*((uint_t *)result) == newcrc)
            return (0);
        return (1);
    }

    /*
     * If we are generating, we stuff the result, if we have a result
     * pointer, and return the value.
     */
    if (result != NULL)
        *((uint_t *)result) = newcrc;
    return (newcrc);
}

void
crcfreetab(void)
{
    if (mddb_crctab) {
        MD_FREE((caddr_t)mddb_crctab, 256 * sizeof (int));
        mddb_crctab = NULL;
    }
}