/*
* 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
* 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 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1990 Mentat Inc. */
#include <sys/inttypes.h>
#include <inet/sctp_crc32.h>
#include <sys/multidata.h>
#include <sys/multidata_impl.h>
unsigned int sum);
/*
* Checksum routine for Internet Protocol family headers.
* This routine is very heavily used in the network
* code and should be modified for each CPU to be as fast as possible.
*/
/*
* used on integers as well. uintptr_t is long enough to hold both
* integer and pointer.
*/
#ifdef ZC_TEST
/*
* Disable the TCP s/w cksum.
* XXX - This is just a hack for testing purpose. Don't use it for
* anything else!
*/
int noswcksum = 0;
#endif
/*
* Note: this does not ones-complement the result since it is used
* when computing partial checksums.
* For nonSTRUIO_IP mblks, assumes mp->b_rptr+offset is 16 bit aligned.
* For STRUIO_IP mblks, assumes mp->b_datap->db_struiobase is 16 bit aligned.
*
* Note: for STRUIO_IP special mblks some data may have been previously
* checksumed, this routine will handle additional data prefixed within
* an mblk or b_cont (chained) mblk(s). This routine will also handle
* suffixed b_cont mblk(s) and data suffixed within an mblk.
*/
unsigned int
{
ushort_t *w;
int pmlen;
#ifdef ZC_TEST
if (noswcksum)
return (0xffff);
#endif
/*
* May be fast-path, only one mblk.
*/
/*
* Checksum any data not already done by
* the caller and add in any partial checksum.
*/
dp->db_cksumend)) {
/*
* Mblk data pointers aren't inclusive
* of uio data, so disregard checksum.
*
* not using all of data in dblk make sure
* not use to use the precalculated checksum
* in this case.
*/
goto norm;
}
mlen = 0;
goto slow;
/*
* There is prefix data to do and some uio
* data has already been checksumed and there
* is more uio data to do, so do the prefix
* data first, then do the remainder of the
* uio data.
*/
dp->db_cksumstuff);
if (is_odd(w)) {
goto slow1;
}
/*
* There may be uio data to do, if there is
* prefix data to do then add in all of the
* uio data (if any) to do, else just do any
* uio data.
*/
if (mlen)
- dp->db_cksumstuff;
else {
dp->db_cksumstuff);
if (is_odd(w))
goto slow;
- dp->db_cksumstuff;
}
} else if (mlen == 0)
return (psum);
goto slow;
} else {
/*
* Checksum all data not already done by the caller.
*/
norm:
goto slow;
}
}
slow:
pmp = 0;
mlen = 0;
pmlen = 0;
for (; ; ) {
/*
* Each trip around loop adds in word(s) from one mbuf segment
* (except for when pmp == mp, then its two partial trips).
*/
if (pmp) {
/*
* This is the second trip around for this mblk.
*/
pmp = 0;
mlen = 0;
goto douio;
/*
* Checksum any data not already done by the
* caller and add in any partial checksum.
*/
dp->db_cksumend)) {
/*
* Mblk data pointers aren't inclusive
* of uio data, so disregard checksum.
*
* not using all of data in dblk make sure
* not use to use the precalculated checksum
* in this case.
*/
goto snorm;
}
mlen = 0;
/*
* There is prefix data too do and some
* uio data has already been checksumed,
* so do the prefix data only this trip.
*/
} else {
/*
* Add in any partial cksum (if any) and
* do the remainder of the uio data.
*/
int odd;
dp->db_cksumstart);
if (pmlen == -1) {
/*
* Previous mlen was odd, so swap
* the partial checksum bytes.
*/
| (psum >> 8);
if (odd)
pmlen = 0;
} else {
if (odd)
pmlen = -1;
}
/*
* If prefix data to do and then all
* the uio data nees to be checksumed,
* else just do any uio data.
*/
if (mlen)
- dp->db_cksumstuff;
else {
dp->db_cksumstuff);
}
}
}
} else {
/*
* Checksum all of the mblk data.
*/
}
/*
* There is a byte left from the last
* segment; add it into the checksum.
* Don't have to worry about a carry-
* out here because we make sure that
* high part of (32 bit) sum is small
* below.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
w = (ushort_t *)((char *)w + 1);
mlen--;
pmlen = 0;
}
if (mlen > 0) {
if (is_even(w)) {
w += mlen>>1;
/*
* If we had an odd number of bytes,
* then the last byte goes in the high
* part of the sum, and we take the
* first byte to the low part of the sum
* the next time around the loop.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
pmlen = -1;
}
} else {
#ifdef _LITTLE_ENDIAN
#else
#endif
mlen--;
/* Do a separate checksum and copy operation */
w += mlen>>1;
/*
* If we had an even number of bytes,
* then the last byte goes in the low
* part of the sum. Otherwise we had an
* odd number of bytes and we take the first
* byte to the low part of the sum the
* next time around the loop.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
}
else
pmlen = -1;
}
}
/*
* Locate the next block with some data.
* If there is a word split across a boundary we
* will wrap to the top with mlen == -1 and
* then add it in shifted appropriately.
*/
offset = 0;
if (! pmp) {
for (; ; ) {
if (mp == 0) {
goto done;
}
break;
}
} else
}
done:
/*
* Add together high and low parts of sum
* and carry to get cksum.
* Have to be careful to not drop the last
* carry here.
*/
return (sum);
}
{
crc32 = 0xFFFFFFFF;
}
/* Complement the result */
return (crc32);
}
/*
* Routine to compute Internet checksum (16-bit 1's complement) of a given
* Multidata packet descriptor. As in the non-Multidata routine, this doesn't
* 1's complement the result, such that it may be used to compute partial
* checksums. Since it works on buffer spans rather than mblks, this routine
* does not handle existing partial checksum value as in the STRUIO_IP special
* mblk case (supporting this is rather trivial, but is perhaps of no use at
* the moment unless synchronous streams and delayed checksum calculation are
* revived.)
*
* Note also here that the given Multidata packet descriptor must refer to
* a header buffer, i.e. it must have a header fragment. In addition, the
* offset must lie within the boundary of the header fragment. For the
* outbound tcp (MDT) case, this will not be an issue because the stack
* ensures that such conditions are met, and that there is no need whatsoever
* to compute partial checksums on an arbitrary offset that is not part of
* the header fragment. We may need to revisit this routine to handle all
* cases of the inbound (MDR) case, especially when we need to perform partial
* checksum calculation due to padded bytes (non-zeroes) in the frame.
*/
{
ushort_t *w;
if (i == 0) {
} else {
offset = 0;
}
/*
* There is a byte left from the last
* segment; add it into the checksum.
* Don't have to worry about a carry-
* out here because we make sure that
* high part of (32 bit) sum is small
* below.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
w = (ushort_t *)((char *)w + 1);
mlen--;
}
if (mlen == 0)
continue;
if (is_even(w)) {
w += mlen >> 1;
/*
* If we had an odd number of bytes,
* then the last byte goes in the high
* part of the sum, and we take the
* first byte to the low part of the sum
* the next time around the loop.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
}
} else {
#ifdef _LITTLE_ENDIAN
#else
#endif
mlen--;
/* Do a separate checksum and copy operation */
w += mlen >> 1;
/*
* If we had an even number of bytes,
* then the last byte goes in the low
* part of the sum. Otherwise we had an
* odd number of bytes and we take the first
* byte to the low part of the sum the
* next time around the loop.
*/
#ifdef _LITTLE_ENDIAN
#else
#endif
} else {
}
}
}
/*
* Add together high and low parts of sum and carry to get cksum.
* Have to be careful to not drop the last carry here.
*/
return (sum);
}
/* Return the IP checksum for the IP header at "iph". */
{
int opt_len;
if (opt_len > 0) {
do {
uph += 2;
} while (--opt_len);
}
if (sum == 0xffff)
sum = 0;
}