FD.io VPP  v20.09-64-g4f7b92f0a
Vector Packet Processing
ip_checksum.c
Go to the documentation of this file.
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 static 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  /*
52  * Align pointer to 64 bits. The ip checksum is a 16-bit
53  * one's complememt sum. It's impractical to optimize
54  * the calculation if the incoming address is odd.
55  */
56 #define _(t) \
57 do { \
58  if (n_bytes >= sizeof (t) \
59  && sizeof (t) < sizeof (ip_csum_t) \
60  && (data % (2 * sizeof (t))) != 0) \
61  { \
62  sum0 += * uword_to_pointer (data, t *); \
63  data += sizeof (t); \
64  n_bytes -= sizeof (t); \
65  } \
66 } while (0)
67 
68  if (PREDICT_TRUE ((data & 1) == 0))
69  {
70  _(u16);
71  if (BITS (ip_csum_t) > 32)
72  _(u32);
73  }
74 #undef _
75 
76  {
77  ip_csum_t *d = uword_to_pointer (data, ip_csum_t *);
78 
79  while (n_bytes >= 2 * sizeof (d[0]))
80  {
81  sum0 = ip_csum_with_carry (sum0, d[0]);
82  sum1 = ip_csum_with_carry (sum1, d[1]);
83  d += 2;
84  n_bytes -= 2 * sizeof (d[0]);
85  }
86 
87  data = pointer_to_uword (d);
88  }
89 
90 #define _(t) \
91 do { \
92  if (n_bytes >= sizeof (t) && sizeof (t) <= sizeof (ip_csum_t)) \
93  { \
94  sum0 = ip_csum_with_carry (sum0, * uword_to_pointer (data, t *)); \
95  data += sizeof (t); \
96  n_bytes -= sizeof (t); \
97  } \
98 } while (0)
99 
100  if (BITS (ip_csum_t) > 32)
101  _(u64);
102  _(u32);
103  _(u16);
104  _(u8);
105 
106 #undef _
107 
108  /* Combine even and odd sums. */
109  sum0 = ip_csum_with_carry (sum0, sum1);
110 
111  return sum0;
112 }
113 
114 /*
115  * Note: the tcp / udp checksum calculation is performance critical
116  * [e.g. when NIC h/w offload is not available],
117  * so it's worth producing architecture-dependent code.
118  *
119  * ip_incremental_checksum() is an always-inlined static
120  * function which uses the function pointer we set up in
121  * ip_checksum_init().
122  */
123 
125 
126 static clib_error_t *
128 {
129  vnet_incremental_checksum_fp = _ip_incremental_checksum;
130  return 0;
131 }
132 
134 
135 #if CLIB_DEBUG > 0
136 
137 static const char test_pkt[] = {
138  0x45, 0x00, 0x00, 0x3c, 0x5d, 0x6f, 0x40, 0x00,
139  0x40, 0x06, 0x3f, 0x6b, 0x0a, 0x76, 0x72, 0x44,
140  0x0a, 0x56, 0x16, 0xd2,
141 };
142 
143 static clib_error_t *
145  unformat_input_t * input, vlib_cli_command_t * cmd)
146 {
147  u16 csum;
148  ip4_header_t *hp;
149  u8 *align_test = 0;
150  int offset;
151 
152  vec_validate (align_test, ARRAY_LEN (test_pkt) + 7);
153 
154  for (offset = 0; offset < 8; offset++)
155  {
156  memcpy (align_test + offset, test_pkt, ARRAY_LEN (test_pkt));
157 
158  hp = (ip4_header_t *) (align_test + offset);
159  csum = ip4_header_checksum (hp);
160 
161  vlib_cli_output (vm, "offset %d checksum %u expected result 27455",
162  offset, (u32) csum);
163  }
164 
165  return 0;
166 }
167 
168 /* *INDENT-OFF* */
169 VLIB_CLI_COMMAND (test_checksum, static) =
170 {
171  .path = "test ip checksum",
172  .short_help = "test ip checksum",
173  .function = test_ip_checksum_fn,
174 };
175 /* *INDENT-ON* */
176 
177 #endif /* CLIB_DEBUG */
178 
179 /*
180  * fd.io coding-style-patch-verification: ON
181  *
182  * Local Variables:
183  * eval: (c-set-style "gnu")
184  * End:
185  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:509
static clib_error_t * test_ip_checksum_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: ip_checksum.c:144
ip_csum_t(* vnet_incremental_checksum_fp)(ip_csum_t, void *, uword)
Definition: ip_checksum.c:124
#define PREDICT_TRUE(x)
Definition: clib.h:121
unsigned long u64
Definition: types.h:89
uword ip_csum_t
Definition: ip_packet.h:244
vlib_main_t * vm
Definition: in2out_ed.c:1582
static ip_csum_t ip_csum_with_carry(ip_csum_t sum, ip_csum_t x)
Definition: ip_packet.h:247
unsigned char u8
Definition: types.h:56
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
unsigned int u32
Definition: types.h:88
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
static clib_error_t * ip_checksum_init(vlib_main_t *vm)
Definition: ip_checksum.c:127
#define ARRAY_LEN(x)
Definition: clib.h:67
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:158
#define uword_to_pointer(u, type)
Definition: types.h:136
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:696
static uword pointer_to_uword(const void *p)
Definition: types.h:131
u64 uword
Definition: types.h:112
struct clib_bihash_value offset
template key/value backing page structure
#define BITS(x)
Definition: clib.h:66
static u16 ip4_header_checksum(ip4_header_t *i)
Definition: ip4_packet.h:314