1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0 3 * 4 * Copyright (c) 2004 Topspin Corporation. All rights reserved. 5 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved. 6 * 7 * This software is available to you under a choice of one of two 8 * licenses. You may choose to be licensed under the terms of the GNU 9 * General Public License (GPL) Version 2, available from the file 10 * COPYING in the main directory of this source tree, or the 11 * OpenIB.org BSD license below: 12 * 13 * Redistribution and use in source and binary forms, with or 14 * without modification, are permitted provided that the following 15 * conditions are met: 16 * 17 * - Redistributions of source code must retain the above 18 * copyright notice, this list of conditions and the following 19 * disclaimer. 20 * 21 * - Redistributions in binary form must reproduce the above 22 * copyright notice, this list of conditions and the following 23 * disclaimer in the documentation and/or other materials 24 * provided with the distribution. 25 * 26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 33 * SOFTWARE. 34 */ 35 36 #include <sys/cdefs.h> 37 __FBSDID("$FreeBSD$"); 38 39 #include <linux/errno.h> 40 #include <linux/string.h> 41 #include <linux/if_ether.h> 42 43 #include <rdma/ib_pack.h> 44 45 #include <machine/in_cksum.h> 46 47 #define STRUCT_FIELD(header, field) \ 48 .struct_offset_bytes = offsetof(struct ib_unpacked_ ## header, field), \ 49 .struct_size_bytes = sizeof ((struct ib_unpacked_ ## header *) 0)->field, \ 50 .field_name = #header ":" #field 51 52 static const struct ib_field lrh_table[] = { 53 { STRUCT_FIELD(lrh, virtual_lane), 54 .offset_words = 0, 55 .offset_bits = 0, 56 .size_bits = 4 }, 57 { STRUCT_FIELD(lrh, link_version), 58 .offset_words = 0, 59 .offset_bits = 4, 60 .size_bits = 4 }, 61 { STRUCT_FIELD(lrh, service_level), 62 .offset_words = 0, 63 .offset_bits = 8, 64 .size_bits = 4 }, 65 { RESERVED, 66 .offset_words = 0, 67 .offset_bits = 12, 68 .size_bits = 2 }, 69 { STRUCT_FIELD(lrh, link_next_header), 70 .offset_words = 0, 71 .offset_bits = 14, 72 .size_bits = 2 }, 73 { STRUCT_FIELD(lrh, destination_lid), 74 .offset_words = 0, 75 .offset_bits = 16, 76 .size_bits = 16 }, 77 { RESERVED, 78 .offset_words = 1, 79 .offset_bits = 0, 80 .size_bits = 5 }, 81 { STRUCT_FIELD(lrh, packet_length), 82 .offset_words = 1, 83 .offset_bits = 5, 84 .size_bits = 11 }, 85 { STRUCT_FIELD(lrh, source_lid), 86 .offset_words = 1, 87 .offset_bits = 16, 88 .size_bits = 16 } 89 }; 90 91 static const struct ib_field eth_table[] = { 92 { STRUCT_FIELD(eth, dmac_h), 93 .offset_words = 0, 94 .offset_bits = 0, 95 .size_bits = 32 }, 96 { STRUCT_FIELD(eth, dmac_l), 97 .offset_words = 1, 98 .offset_bits = 0, 99 .size_bits = 16 }, 100 { STRUCT_FIELD(eth, smac_h), 101 .offset_words = 1, 102 .offset_bits = 16, 103 .size_bits = 16 }, 104 { STRUCT_FIELD(eth, smac_l), 105 .offset_words = 2, 106 .offset_bits = 0, 107 .size_bits = 32 }, 108 { STRUCT_FIELD(eth, type), 109 .offset_words = 3, 110 .offset_bits = 0, 111 .size_bits = 16 } 112 }; 113 114 static const struct ib_field vlan_table[] = { 115 { STRUCT_FIELD(vlan, tag), 116 .offset_words = 0, 117 .offset_bits = 0, 118 .size_bits = 16 }, 119 { STRUCT_FIELD(vlan, type), 120 .offset_words = 0, 121 .offset_bits = 16, 122 .size_bits = 16 } 123 }; 124 125 static const struct ib_field ip4_table[] = { 126 { STRUCT_FIELD(ip4, ver), 127 .offset_words = 0, 128 .offset_bits = 0, 129 .size_bits = 4 }, 130 { STRUCT_FIELD(ip4, hdr_len), 131 .offset_words = 0, 132 .offset_bits = 4, 133 .size_bits = 4 }, 134 { STRUCT_FIELD(ip4, tos), 135 .offset_words = 0, 136 .offset_bits = 8, 137 .size_bits = 8 }, 138 { STRUCT_FIELD(ip4, tot_len), 139 .offset_words = 0, 140 .offset_bits = 16, 141 .size_bits = 16 }, 142 { STRUCT_FIELD(ip4, id), 143 .offset_words = 1, 144 .offset_bits = 0, 145 .size_bits = 16 }, 146 { STRUCT_FIELD(ip4, frag_off), 147 .offset_words = 1, 148 .offset_bits = 16, 149 .size_bits = 16 }, 150 { STRUCT_FIELD(ip4, ttl), 151 .offset_words = 2, 152 .offset_bits = 0, 153 .size_bits = 8 }, 154 { STRUCT_FIELD(ip4, protocol), 155 .offset_words = 2, 156 .offset_bits = 8, 157 .size_bits = 8 }, 158 { STRUCT_FIELD(ip4, check), 159 .offset_words = 2, 160 .offset_bits = 16, 161 .size_bits = 16 }, 162 { STRUCT_FIELD(ip4, saddr), 163 .offset_words = 3, 164 .offset_bits = 0, 165 .size_bits = 32 }, 166 { STRUCT_FIELD(ip4, daddr), 167 .offset_words = 4, 168 .offset_bits = 0, 169 .size_bits = 32 } 170 }; 171 172 static const struct ib_field udp_table[] = { 173 { STRUCT_FIELD(udp, sport), 174 .offset_words = 0, 175 .offset_bits = 0, 176 .size_bits = 16 }, 177 { STRUCT_FIELD(udp, dport), 178 .offset_words = 0, 179 .offset_bits = 16, 180 .size_bits = 16 }, 181 { STRUCT_FIELD(udp, length), 182 .offset_words = 1, 183 .offset_bits = 0, 184 .size_bits = 16 }, 185 { STRUCT_FIELD(udp, csum), 186 .offset_words = 1, 187 .offset_bits = 16, 188 .size_bits = 16 } 189 }; 190 191 static const struct ib_field grh_table[] = { 192 { STRUCT_FIELD(grh, ip_version), 193 .offset_words = 0, 194 .offset_bits = 0, 195 .size_bits = 4 }, 196 { STRUCT_FIELD(grh, traffic_class), 197 .offset_words = 0, 198 .offset_bits = 4, 199 .size_bits = 8 }, 200 { STRUCT_FIELD(grh, flow_label), 201 .offset_words = 0, 202 .offset_bits = 12, 203 .size_bits = 20 }, 204 { STRUCT_FIELD(grh, payload_length), 205 .offset_words = 1, 206 .offset_bits = 0, 207 .size_bits = 16 }, 208 { STRUCT_FIELD(grh, next_header), 209 .offset_words = 1, 210 .offset_bits = 16, 211 .size_bits = 8 }, 212 { STRUCT_FIELD(grh, hop_limit), 213 .offset_words = 1, 214 .offset_bits = 24, 215 .size_bits = 8 }, 216 { STRUCT_FIELD(grh, source_gid), 217 .offset_words = 2, 218 .offset_bits = 0, 219 .size_bits = 128 }, 220 { STRUCT_FIELD(grh, destination_gid), 221 .offset_words = 6, 222 .offset_bits = 0, 223 .size_bits = 128 } 224 }; 225 226 static const struct ib_field bth_table[] = { 227 { STRUCT_FIELD(bth, opcode), 228 .offset_words = 0, 229 .offset_bits = 0, 230 .size_bits = 8 }, 231 { STRUCT_FIELD(bth, solicited_event), 232 .offset_words = 0, 233 .offset_bits = 8, 234 .size_bits = 1 }, 235 { STRUCT_FIELD(bth, mig_req), 236 .offset_words = 0, 237 .offset_bits = 9, 238 .size_bits = 1 }, 239 { STRUCT_FIELD(bth, pad_count), 240 .offset_words = 0, 241 .offset_bits = 10, 242 .size_bits = 2 }, 243 { STRUCT_FIELD(bth, transport_header_version), 244 .offset_words = 0, 245 .offset_bits = 12, 246 .size_bits = 4 }, 247 { STRUCT_FIELD(bth, pkey), 248 .offset_words = 0, 249 .offset_bits = 16, 250 .size_bits = 16 }, 251 { RESERVED, 252 .offset_words = 1, 253 .offset_bits = 0, 254 .size_bits = 8 }, 255 { STRUCT_FIELD(bth, destination_qpn), 256 .offset_words = 1, 257 .offset_bits = 8, 258 .size_bits = 24 }, 259 { STRUCT_FIELD(bth, ack_req), 260 .offset_words = 2, 261 .offset_bits = 0, 262 .size_bits = 1 }, 263 { RESERVED, 264 .offset_words = 2, 265 .offset_bits = 1, 266 .size_bits = 7 }, 267 { STRUCT_FIELD(bth, psn), 268 .offset_words = 2, 269 .offset_bits = 8, 270 .size_bits = 24 } 271 }; 272 273 static const struct ib_field deth_table[] = { 274 { STRUCT_FIELD(deth, qkey), 275 .offset_words = 0, 276 .offset_bits = 0, 277 .size_bits = 32 }, 278 { RESERVED, 279 .offset_words = 1, 280 .offset_bits = 0, 281 .size_bits = 8 }, 282 { STRUCT_FIELD(deth, source_qpn), 283 .offset_words = 1, 284 .offset_bits = 8, 285 .size_bits = 24 } 286 }; 287 288 __sum16 ib_ud_ip4_csum(struct ib_ud_header *header) 289 { 290 #if defined(INET) || defined(INET6) 291 struct ip iph; 292 293 iph.ip_hl = 5; 294 iph.ip_v = 4; 295 iph.ip_tos = header->ip4.tos; 296 iph.ip_len = header->ip4.tot_len; 297 iph.ip_id = header->ip4.id; 298 iph.ip_off = header->ip4.frag_off; 299 iph.ip_ttl = header->ip4.ttl; 300 iph.ip_p = header->ip4.protocol; 301 iph.ip_sum = 0; 302 iph.ip_src.s_addr = header->ip4.saddr; 303 iph.ip_dst.s_addr = header->ip4.daddr; 304 305 return in_cksum_hdr(&iph); 306 #else 307 return 0; 308 #endif 309 } 310 EXPORT_SYMBOL(ib_ud_ip4_csum); 311 312 /** 313 * ib_ud_header_init - Initialize UD header structure 314 * @payload_bytes:Length of packet payload 315 * @lrh_present: specify if LRH is present 316 * @eth_present: specify if Eth header is present 317 * @vlan_present: packet is tagged vlan 318 * @grh_present: GRH flag (if non-zero, GRH will be included) 319 * @ip_version: if non-zero, IP header, V4 or V6, will be included 320 * @udp_present :if non-zero, UDP header will be included 321 * @immediate_present: specify if immediate data is present 322 * @header:Structure to initialize 323 */ 324 int ib_ud_header_init(int payload_bytes, 325 int lrh_present, 326 int eth_present, 327 int vlan_present, 328 int grh_present, 329 int ip_version, 330 int udp_present, 331 int immediate_present, 332 struct ib_ud_header *header) 333 { 334 size_t udp_bytes = udp_present ? IB_UDP_BYTES : 0; 335 336 grh_present = grh_present && !ip_version; 337 memset(header, 0, sizeof *header); 338 339 /* 340 * UDP header without IP header doesn't make sense 341 */ 342 if (udp_present && ip_version != 4 && ip_version != 6) 343 return -EINVAL; 344 345 if (lrh_present) { 346 u16 packet_length; 347 348 header->lrh.link_version = 0; 349 header->lrh.link_next_header = 350 grh_present ? IB_LNH_IBA_GLOBAL : IB_LNH_IBA_LOCAL; 351 packet_length = (IB_LRH_BYTES + 352 IB_BTH_BYTES + 353 IB_DETH_BYTES + 354 (grh_present ? IB_GRH_BYTES : 0) + 355 payload_bytes + 356 4 + /* ICRC */ 357 3) / 4; /* round up */ 358 header->lrh.packet_length = cpu_to_be16(packet_length); 359 } 360 361 if (vlan_present) 362 header->eth.type = cpu_to_be16(ETH_P_8021Q); 363 364 if (ip_version == 6 || grh_present) { 365 header->grh.ip_version = 6; 366 header->grh.payload_length = 367 cpu_to_be16((udp_bytes + 368 IB_BTH_BYTES + 369 IB_DETH_BYTES + 370 payload_bytes + 371 4 + /* ICRC */ 372 3) & ~3); /* round up */ 373 header->grh.next_header = udp_present ? IPPROTO_UDP : 0x1b; 374 } 375 376 if (ip_version == 4) { 377 header->ip4.ver = 4; /* version 4 */ 378 header->ip4.hdr_len = 5; /* 5 words */ 379 header->ip4.tot_len = 380 cpu_to_be16(IB_IP4_BYTES + 381 udp_bytes + 382 IB_BTH_BYTES + 383 IB_DETH_BYTES + 384 payload_bytes + 385 4); /* ICRC */ 386 header->ip4.protocol = IPPROTO_UDP; 387 } 388 if (udp_present && ip_version) 389 header->udp.length = 390 cpu_to_be16(IB_UDP_BYTES + 391 IB_BTH_BYTES + 392 IB_DETH_BYTES + 393 payload_bytes + 394 4); /* ICRC */ 395 396 if (immediate_present) 397 header->bth.opcode = IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE; 398 else 399 header->bth.opcode = IB_OPCODE_UD_SEND_ONLY; 400 header->bth.pad_count = (4 - payload_bytes) & 3; 401 header->bth.transport_header_version = 0; 402 403 header->lrh_present = lrh_present; 404 header->eth_present = eth_present; 405 header->vlan_present = vlan_present; 406 header->grh_present = grh_present || (ip_version == 6); 407 header->ipv4_present = ip_version == 4; 408 header->udp_present = udp_present; 409 header->immediate_present = immediate_present; 410 return 0; 411 } 412 EXPORT_SYMBOL(ib_ud_header_init); 413 414 /** 415 * ib_ud_header_pack - Pack UD header struct into wire format 416 * @header:UD header struct 417 * @buf:Buffer to pack into 418 * 419 * ib_ud_header_pack() packs the UD header structure @header into wire 420 * format in the buffer @buf. 421 */ 422 int ib_ud_header_pack(struct ib_ud_header *header, 423 void *buf) 424 { 425 int len = 0; 426 427 if (header->lrh_present) { 428 ib_pack(lrh_table, ARRAY_SIZE(lrh_table), 429 &header->lrh, (char *)buf + len); 430 len += IB_LRH_BYTES; 431 } 432 if (header->eth_present) { 433 ib_pack(eth_table, ARRAY_SIZE(eth_table), 434 &header->eth, (char *)buf + len); 435 len += IB_ETH_BYTES; 436 } 437 if (header->vlan_present) { 438 ib_pack(vlan_table, ARRAY_SIZE(vlan_table), 439 &header->vlan, (char *)buf + len); 440 len += IB_VLAN_BYTES; 441 } 442 if (header->grh_present) { 443 ib_pack(grh_table, ARRAY_SIZE(grh_table), 444 &header->grh, (char *)buf + len); 445 len += IB_GRH_BYTES; 446 } 447 if (header->ipv4_present) { 448 ib_pack(ip4_table, ARRAY_SIZE(ip4_table), 449 &header->ip4, (char *)buf + len); 450 len += IB_IP4_BYTES; 451 } 452 if (header->udp_present) { 453 ib_pack(udp_table, ARRAY_SIZE(udp_table), 454 &header->udp, (char *)buf + len); 455 len += IB_UDP_BYTES; 456 } 457 458 ib_pack(bth_table, ARRAY_SIZE(bth_table), 459 &header->bth, (char *)buf + len); 460 len += IB_BTH_BYTES; 461 462 ib_pack(deth_table, ARRAY_SIZE(deth_table), 463 &header->deth, (char *)buf + len); 464 len += IB_DETH_BYTES; 465 466 if (header->immediate_present) { 467 memcpy((char *)buf + len, &header->immediate_data, sizeof header->immediate_data); 468 len += sizeof header->immediate_data; 469 } 470 471 return len; 472 } 473 EXPORT_SYMBOL(ib_ud_header_pack); 474 475 /** 476 * ib_ud_header_unpack - Unpack UD header struct from wire format 477 * @header:UD header struct 478 * @buf:Buffer to pack into 479 * 480 * ib_ud_header_pack() unpacks the UD header structure @header from wire 481 * format in the buffer @buf. 482 */ 483 int ib_ud_header_unpack(void *buf, 484 struct ib_ud_header *header) 485 { 486 ib_unpack(lrh_table, ARRAY_SIZE(lrh_table), 487 buf, &header->lrh); 488 buf = (char *)buf + IB_LRH_BYTES; 489 490 if (header->lrh.link_version != 0) { 491 pr_warn("Invalid LRH.link_version %d\n", 492 header->lrh.link_version); 493 return -EINVAL; 494 } 495 496 switch (header->lrh.link_next_header) { 497 case IB_LNH_IBA_LOCAL: 498 header->grh_present = 0; 499 break; 500 501 case IB_LNH_IBA_GLOBAL: 502 header->grh_present = 1; 503 ib_unpack(grh_table, ARRAY_SIZE(grh_table), 504 buf, &header->grh); 505 buf = (char *)buf + IB_GRH_BYTES; 506 507 if (header->grh.ip_version != 6) { 508 pr_warn("Invalid GRH.ip_version %d\n", 509 header->grh.ip_version); 510 return -EINVAL; 511 } 512 if (header->grh.next_header != 0x1b) { 513 pr_warn("Invalid GRH.next_header 0x%02x\n", 514 header->grh.next_header); 515 return -EINVAL; 516 } 517 break; 518 519 default: 520 pr_warn("Invalid LRH.link_next_header %d\n", 521 header->lrh.link_next_header); 522 return -EINVAL; 523 } 524 525 ib_unpack(bth_table, ARRAY_SIZE(bth_table), 526 buf, &header->bth); 527 buf = (char *)buf + IB_BTH_BYTES; 528 529 switch (header->bth.opcode) { 530 case IB_OPCODE_UD_SEND_ONLY: 531 header->immediate_present = 0; 532 break; 533 case IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE: 534 header->immediate_present = 1; 535 break; 536 default: 537 pr_warn("Invalid BTH.opcode 0x%02x\n", header->bth.opcode); 538 return -EINVAL; 539 } 540 541 if (header->bth.transport_header_version != 0) { 542 pr_warn("Invalid BTH.transport_header_version %d\n", 543 header->bth.transport_header_version); 544 return -EINVAL; 545 } 546 547 ib_unpack(deth_table, ARRAY_SIZE(deth_table), 548 buf, &header->deth); 549 buf = (char *)buf + IB_DETH_BYTES; 550 551 if (header->immediate_present) 552 memcpy(&header->immediate_data, buf, sizeof header->immediate_data); 553 554 return 0; 555 } 556 EXPORT_SYMBOL(ib_ud_header_unpack); 557