/*
* 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 (c) 1992,1997 by Sun Microsystems, Inc.
* All rights reserved.
*/
/* Copyright (c) 1990 Mentat Inc. */
#pragma ident "%Z%%M% %I% %E% SMI"
#include <sys/types.h>
#include <sys/stream.h>
#include <sys/ddi.h>
#include <sys/isa_defs.h>
#include <inet/common.h>
#define FOLD_SUM(sum) \
{ sum = (sum >> 16) + (sum & 0xFFFF); sum = (sum >> 16) + (sum & 0xFFFF); }
#define U16AM(p, i, m) ((((uint16_t *)(p))[i]) & (uint32_t)(m))
/*
* For maximum efficiency, these access macros should be redone for
* machines that can access unaligned data. NOTE: these assume
* ability to fetch from a zero extended 'uint8_t' and 'uint16_t'. Add explicit
* masks in the U8_FETCH, U16_FETCH, PREV_TWO and NEXT_TWO as needed.
*/
#ifdef _LITTLE_ENDIAN
#define U8_FETCH_FIRST(p) ((p)[0])
#define U8_FETCH_SECOND(p) (((uint32_t)(p)[0]) << 8)
#define PREV_ONE(p) U16AM(p, -1, 0xFF00)
#define NEXT_ONE(p) U16AM(p, 0, 0xFF)
#else
#define U8_FETCH_FIRST(p) ((uint32_t)((p)[0]) << 8)
#define U8_FETCH_SECOND(p) ((p)[0])
#define PREV_ONE(p) U16AM(p, -1, 0xFF)
#define NEXT_ONE(p) U16AM(p, 0, 0xFF00)
#endif
#define U16_FETCH(p) U8_FETCH_FIRST(p) + U8_FETCH_SECOND(p+1)
#define PREV_TWO(p) ((uint32_t)(((uint16_t *)(p))[-1]))
#define NEXT_TWO(p) ((uint32_t)(((uint16_t *)(p))[0]))
/*
* Return the ones complement checksum from the mblk chain at mp,
* after skipping offset bytes, and adding in the supplied partial
* sum. Note that a final complement of the return value is needed
* if no further contributions to the checksum are forthcoming.
*/
uint16_t
ip_csum(mp, offset, sum)
mblk_t *mp;
int offset;
uint32_t sum;
{
uint8_t *startp = mp->b_rptr + offset;
uint8_t *endp = mp->b_wptr;
/* >= 0x2 means flipped for memory align, 0x1 means last count was odd */
int odd_total = 0;
#ifdef TEST_COVERAGE
mblk_t *safe_mp;
#define INIT_COVERAGE() (safe_mp = mp, safe_mp->b_next = NULL)
#define MARK_COVERAGE(flag) (safe_mp->b_next = \
(mblk_t *)((uint32_t)safe_mp->b_next | flag))
#else
#define INIT_COVERAGE() /* */
#define MARK_COVERAGE(flag) /* */
#endif
for (;;) {
INIT_COVERAGE();
if ((endp - startp) < 10) {
MARK_COVERAGE(0x1);
while ((endp - startp) >= 2) {
MARK_COVERAGE(0x2);
sum += U16_FETCH(startp);
startp += 2;
}
if ((endp - startp) >= 1) {
MARK_COVERAGE(0x4);
odd_total = 1;
sum += U8_FETCH_FIRST(startp);
}
MARK_COVERAGE(0x8);
FOLD_SUM(sum);
goto next_frag;
}
if ((uint32_t)startp & 0x1) {
MARK_COVERAGE(0x10);
odd_total = 3;
startp++;
sum = (sum << 8) + PREV_ONE(startp);
}
if ((uint32_t)startp & 0x2) {
MARK_COVERAGE(0x20);
startp += 2;
sum += PREV_TWO(startp);
}
if ((uint32_t)endp & 0x1) {
MARK_COVERAGE(0x40);
odd_total ^= 0x1;
endp--;
sum += NEXT_ONE(endp);
}
if ((uint32_t)endp & 0x2) {
MARK_COVERAGE(0x80);
endp -= 2;
sum += NEXT_TWO(endp);
}
{
#ifdef NOT_ALL_PTRS_EQUAL
#define INC_PTR(cnt) ptr += cnt
#define INC_ENDPTR(cnt) endptr += cnt
uint32_t *ptr = (uint32_t *)startp;
uint32_t *endptr = (uint32_t *)endp;
#else
#define INC_PTR(cnt) startp += (cnt * sizeof (uint32_t))
#define INC_ENDPTR(cnt) endp += (cnt * sizeof (uint32_t))
#define ptr ((uint32_t *)startp)
#define endptr ((uint32_t *)endp)
#endif
#ifdef USE_FETCH_AND_SHIFT
uint32_t u1, u2;
uint32_t mask = 0xFFFF;
#define LOAD1(i) u1 = ptr[i]
#define LOAD2(i) u2 = ptr[i]
#define SUM1(i) sum += (u1 & mask) + (u1 >> 16)
#define SUM2(i) sum += (u2 & mask) + (u2 >> 16)
#endif
#ifdef USE_FETCH_AND_ADDC
uint32_t u1, u2;
#define LOAD1(i) u1 = ptr[i]
#define LOAD2(i) u2 = ptr[i]
#define SUM1(i) sum += u1
#define SUM2(i) sum += u2
#endif
#ifdef USE_ADDC
#define SUM1(i) sum += ptr[i]
#endif
#ifdef USE_POSTINC
#define SUM1(i) sum += *((uint16_t *)ptr)++; sum += *((uint16_t *)ptr)++
#undef INC_PTR
#define INC_PTR(i) /* */
#endif
#ifndef LOAD1
#define LOAD1(i) /* */
#endif
#ifndef LOAD2
#define LOAD2(i) /* */
#endif
#ifndef SUM2
#define SUM2(i) SUM1(i)
#endif
/* USE_INDEXING is the default */
#ifndef SUM1
#define SUM1(i)
sum += ((uint16_t *)ptr)[i * 2]; sum += ((uint16_t *)ptr)[(i * 2) + 1]
#endif
LOAD1(0);
INC_ENDPTR(-8);
if (ptr <= endptr) {
MARK_COVERAGE(0x100);
do {
LOAD2(1); SUM1(0);
LOAD1(2); SUM2(1);
LOAD2(3); SUM1(2);
LOAD1(4); SUM2(3);
LOAD2(5); SUM1(4);
LOAD1(6); SUM2(5);
LOAD2(7); SUM1(6);
LOAD1(8); SUM2(7);
INC_PTR(8);
} while (ptr <= endptr);
}
#ifdef USE_TAIL_SWITCH
switch ((endptr + 8) - ptr) {
case 7: LOAD2(6); SUM2(6);
case 6: LOAD2(5); SUM2(5);
case 5: LOAD2(4); SUM2(4);
case 4: LOAD2(3); SUM2(3);
case 3: LOAD2(2); SUM2(2);
case 2: LOAD2(1); SUM2(1);
case 1: SUM1(0);
case 0: break;
}
#else
INC_ENDPTR(4);
if (ptr <= endptr) {
MARK_COVERAGE(0x200);
LOAD2(1); SUM1(0);
LOAD1(2); SUM2(1);
LOAD2(3); SUM1(2);
LOAD1(4); SUM2(3);
INC_PTR(4);
}
INC_ENDPTR(4);
if (ptr < endptr) {
MARK_COVERAGE(0x400);
do {
SUM1(0); LOAD1(1);
INC_PTR(1);
} while (ptr < endptr);
}
#endif
}
FOLD_SUM(sum);
if (odd_total > 1) {
MARK_COVERAGE(0x800);
sum = ((sum << 8) | (sum >> 8)) & 0xFFFF;
odd_total -= 2;
}
next_frag:
mp = mp->b_cont;
if (!mp) {
MARK_COVERAGE(0x1000);
{
uint32_t u1 = sum;
return ((uint16_t)u1);
}
}
MARK_COVERAGE(0x4000);
startp = mp->b_rptr;
endp = mp->b_wptr;
if (odd_total && (endp > startp)) {
MARK_COVERAGE(0x8000);
odd_total = 0;
sum += U8_FETCH_SECOND(startp);
startp++;
}
}
}
#undef endptr
#undef INIT_COVERAGE
#undef INC_PTR
#undef INC_ENDPTR
#undef LOAD1
#undef LOAD2
#undef MARK_COVERAGE
#undef ptr
#undef SUM1
#undef SUM2
#undef FOLD_SUM
#undef NEXT_ONE
#undef NEXT_TWO
#undef PREV_ONE
#undef PREV_TWO
#undef U8_FETCH_FIRST
#undef U8_FETCH_SECOND
#undef U16AM
#undef U16_FETCH