vnet/vnet/ip/ip_checksum.c

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 /*
  16  * ip4/ip_checksum.c: ip/tcp/udp checksums
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <vnet/ip/ip.h>
  41
  42 ip_csum_t
  43 ip_incremental_checksum (ip_csum_t sum, void * _data, uword n_bytes)
  44 {
  45   uword data = pointer_to_uword (_data);
  46   ip_csum_t sum0, sum1;
  47
  48   sum0 = 0;
  49   sum1 = sum;
  50
  51   /* Align data pointer to 64 bits. */
  52 #define _(t)                                    \
  53 do {                                            \
  54   if (n_bytes >= sizeof (t)                     \
  55       && sizeof (t) < sizeof (ip_csum_t)        \
  56       && (data % (2 * sizeof (t))) != 0)        \
  57     {                                           \
  58       sum0 += * uword_to_pointer (data, t *);   \
  59       data += sizeof (t);                       \
  60       n_bytes -= sizeof (t);                    \
  61     }                                           \
  62 } while (0)
  63
  64   _ (u8);
  65   _ (u16);
  66   if (BITS (ip_csum_t) > 32)
  67     _ (u32);
  68
  69 #undef _
  70
  71  {
  72    ip_csum_t * d = uword_to_pointer (data, ip_csum_t *);
  73
  74    while (n_bytes >= 2 * sizeof (d[0]))
  75      {
  76        sum0 = ip_csum_with_carry (sum0, d[0]);
  77        sum1 = ip_csum_with_carry (sum1, d[1]);
  78        d += 2;
  79        n_bytes -= 2 * sizeof (d[0]);
  80      }
  81
  82    data = pointer_to_uword (d);
  83  }
  84
  85 #define _(t)                                                            \
  86 do {                                                                    \
  87   if (n_bytes >= sizeof (t) && sizeof (t) <= sizeof (ip_csum_t))        \
  88     {                                                                   \
  89       sum0 = ip_csum_with_carry (sum0, * uword_to_pointer (data, t *)); \
  90       data += sizeof (t);                                               \
  91       n_bytes -= sizeof (t);                                            \
  92     }                                                                   \
  93 } while (0)
  94
  95  if (BITS (ip_csum_t) > 32)
  96    _ (u64);
  97  _ (u32);
  98  _ (u16);
  99  _ (u8);
 100
 101 #undef _
 102
 103  /* Combine even and odd sums. */
 104  sum0 = ip_csum_with_carry (sum0, sum1);
 105
 106  return sum0;
 107 }
 108
 109 ip_csum_t
 110 ip_csum_and_memcpy (ip_csum_t sum, void * dst, void * src, uword n_bytes)
 111 {
 112   uword n_left;
 113   ip_csum_t sum0 = sum, sum1;
 114   n_left = n_bytes;
 115
 116   if (n_left && (pointer_to_uword (dst) & sizeof(u8)))
 117     {
 118       u8 * d8, val;
 119
 120       d8 = dst;
 121       val = ((u8 *)src)[0];
 122       d8[0] = val;
 123       dst += 1;
 124       src += 1;
 125       n_left -= 1;
 126       sum0 = ip_csum_with_carry (sum0, val << (8 * CLIB_ARCH_IS_LITTLE_ENDIAN));
 127     }
 128
 129   while ((n_left >= sizeof (u16)) && (pointer_to_uword (dst) & (sizeof (sum) - sizeof (u16))))
 130     {
 131       u16 * d16, * s16;
 132
 133       d16 = dst;
 134       s16 = src;
 135
 136       d16[0] = clib_mem_unaligned (&s16[0], u16);
 137
 138       sum0 = ip_csum_with_carry (sum0, d16[0]);
 139       dst += sizeof (u16);
 140       src += sizeof (u16);
 141       n_left -= sizeof (u16);
 142     }
 143
 144   sum1 = 0;
 145   while (n_left >= 2 * sizeof (sum))
 146     {
 147       ip_csum_t dst0, dst1;
 148       ip_csum_t *dst_even, *src_even;
 149
 150       dst_even = dst;
 151       src_even = src;
 152       dst0 = clib_mem_unaligned (&src_even[0], ip_csum_t);
 153       dst1 = clib_mem_unaligned (&src_even[1], ip_csum_t);
 154
 155       dst_even[0] = dst0;
 156       dst_even[1] = dst1;
 157
 158       dst += 2 * sizeof(dst_even[0]);
 159       src += 2 * sizeof(dst_even[0]);
 160       n_left -= 2 * sizeof (dst_even[0]);
 161
 162       sum0 = ip_csum_with_carry (sum0, dst0);
 163       sum1 = ip_csum_with_carry (sum1, dst1);
 164     }
 165
 166   sum0 = ip_csum_with_carry (sum0, sum1);
 167   while (n_left >= 1 * sizeof (sum))
 168     {
 169       ip_csum_t dst0, *dst_even, *src_even;
 170
 171       dst_even = dst;
 172       src_even = src;
 173
 174       dst0 = clib_mem_unaligned (&src_even[0], ip_csum_t);
 175
 176       dst_even[0] = dst0;
 177
 178       dst += 1 * sizeof(sum);
 179       src += 1 * sizeof(sum);
 180       n_left -= 1 * sizeof (sum);
 181
 182       sum0 = ip_csum_with_carry (sum0, dst0);
 183     }
 184
 185   while (n_left >= sizeof (u16))
 186     {
 187       u16 dst0, *dst_short, *src_short;
 188
 189       dst_short = dst;
 190       src_short = src;
 191
 192       dst0 = clib_mem_unaligned (&src_short[0], u16);
 193
 194       dst_short[0] = dst0;
 195
 196       sum0 = ip_csum_with_carry (sum0, dst_short[0]);
 197       dst += 1 * sizeof (dst0);
 198       src += 1 * sizeof (dst0);
 199       n_left -= 1 * sizeof (dst0);
 200
 201     }
 202
 203   if (n_left == 1)
 204     {
 205       u8 * d8, * s8, val;
 206
 207       d8 = dst;
 208       s8 = src;
 209
 210       d8[0] = val = s8[0];
 211       d8 += 1;
 212       s8 += 1;
 213       n_left -= 1;
 214       sum0 = ip_csum_with_carry (sum0, val << (8 * CLIB_ARCH_IS_BIG_ENDIAN));
 215     }
 216
 217   return sum0;
 218 }