1 /* 2 * net/tipc/msg.h: Include file for TIPC message header routines 3 * 4 * Copyright (c) 2000-2007, 2014-2017 Ericsson AB 5 * Copyright (c) 2005-2008, 2010-2011, Wind River Systems 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the names of the copyright holders nor the names of its 17 * contributors may be used to endorse or promote products derived from 18 * this software without specific prior written permission. 19 * 20 * Alternatively, this software may be distributed under the terms of the 21 * GNU General Public License ("GPL") version 2 as published by the Free 22 * Software Foundation. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 34 * POSSIBILITY OF SUCH DAMAGE. 35 */ 36 37 #ifndef _TIPC_MSG_H 38 #define _TIPC_MSG_H 39 40 #include <linux/tipc.h> 41 #include "core.h" 42 43 /* 44 * Constants and routines used to read and write TIPC payload message headers 45 * 46 * Note: Some items are also used with TIPC internal message headers 47 */ 48 #define TIPC_VERSION 2 49 struct plist; 50 51 /* 52 * Payload message users are defined in TIPC's public API: 53 * - TIPC_LOW_IMPORTANCE 54 * - TIPC_MEDIUM_IMPORTANCE 55 * - TIPC_HIGH_IMPORTANCE 56 * - TIPC_CRITICAL_IMPORTANCE 57 */ 58 #define TIPC_SYSTEM_IMPORTANCE 4 59 60 61 /* 62 * Payload message types 63 */ 64 #define TIPC_CONN_MSG 0 65 #define TIPC_MCAST_MSG 1 66 #define TIPC_NAMED_MSG 2 67 #define TIPC_DIRECT_MSG 3 68 #define TIPC_GRP_MEMBER_EVT 4 69 #define TIPC_GRP_BCAST_MSG 5 70 #define TIPC_GRP_MCAST_MSG 6 71 #define TIPC_GRP_UCAST_MSG 7 72 73 /* 74 * Internal message users 75 */ 76 #define BCAST_PROTOCOL 5 77 #define MSG_BUNDLER 6 78 #define LINK_PROTOCOL 7 79 #define CONN_MANAGER 8 80 #define GROUP_PROTOCOL 9 81 #define TUNNEL_PROTOCOL 10 82 #define NAME_DISTRIBUTOR 11 83 #define MSG_FRAGMENTER 12 84 #define LINK_CONFIG 13 85 #define SOCK_WAKEUP 14 /* pseudo user */ 86 #define TOP_SRV 15 /* pseudo user */ 87 88 /* 89 * Message header sizes 90 */ 91 #define SHORT_H_SIZE 24 /* In-cluster basic payload message */ 92 #define BASIC_H_SIZE 32 /* Basic payload message */ 93 #define NAMED_H_SIZE 40 /* Named payload message */ 94 #define MCAST_H_SIZE 44 /* Multicast payload message */ 95 #define GROUP_H_SIZE 44 /* Group payload message */ 96 #define INT_H_SIZE 40 /* Internal messages */ 97 #define MIN_H_SIZE 24 /* Smallest legal TIPC header size */ 98 #define MAX_H_SIZE 60 /* Largest possible TIPC header size */ 99 100 #define MAX_MSG_SIZE (MAX_H_SIZE + TIPC_MAX_USER_MSG_SIZE) 101 #define FB_MTU 3744 102 #define TIPC_MEDIA_INFO_OFFSET 5 103 104 struct tipc_skb_cb { 105 union { 106 struct { 107 struct sk_buff *tail; 108 unsigned long nxt_retr; 109 unsigned long retr_stamp; 110 u32 bytes_read; 111 u32 orig_member; 112 u16 chain_imp; 113 u16 ackers; 114 u16 retr_cnt; 115 } __packed; 116 #ifdef CONFIG_TIPC_CRYPTO 117 struct { 118 struct tipc_crypto *rx; 119 struct tipc_aead *last; 120 u8 recurs; 121 } tx_clone_ctx __packed; 122 #endif 123 } __packed; 124 union { 125 struct { 126 u8 validated:1; 127 #ifdef CONFIG_TIPC_CRYPTO 128 u8 encrypted:1; 129 u8 decrypted:1; 130 u8 probe:1; 131 u8 tx_clone_deferred:1; 132 #endif 133 }; 134 u8 flags; 135 }; 136 u8 reserved; 137 #ifdef CONFIG_TIPC_CRYPTO 138 void *crypto_ctx; 139 #endif 140 } __packed; 141 142 #define TIPC_SKB_CB(__skb) ((struct tipc_skb_cb *)&((__skb)->cb[0])) 143 144 struct tipc_msg { 145 __be32 hdr[15]; 146 }; 147 148 /* struct tipc_gap_ack - TIPC Gap ACK block 149 * @ack: seqno of the last consecutive packet in link deferdq 150 * @gap: number of gap packets since the last ack 151 * 152 * E.g: 153 * link deferdq: 1 2 3 4 10 11 13 14 15 20 154 * --> Gap ACK blocks: <4, 5>, <11, 1>, <15, 4>, <20, 0> 155 */ 156 struct tipc_gap_ack { 157 __be16 ack; 158 __be16 gap; 159 }; 160 161 /* struct tipc_gap_ack_blks 162 * @len: actual length of the record 163 * @ugack_cnt: number of Gap ACK blocks for unicast (following the broadcast 164 * ones) 165 * @start_index: starting index for "valid" broadcast Gap ACK blocks 166 * @bgack_cnt: number of Gap ACK blocks for broadcast in the record 167 * @gacks: array of Gap ACK blocks 168 * 169 * 31 16 15 0 170 * +-------------+-------------+-------------+-------------+ 171 * | bgack_cnt | ugack_cnt | len | 172 * +-------------+-------------+-------------+-------------+ - 173 * | gap | ack | | 174 * +-------------+-------------+-------------+-------------+ > bc gacks 175 * : : : | 176 * +-------------+-------------+-------------+-------------+ - 177 * | gap | ack | | 178 * +-------------+-------------+-------------+-------------+ > uc gacks 179 * : : : | 180 * +-------------+-------------+-------------+-------------+ - 181 */ 182 struct tipc_gap_ack_blks { 183 __be16 len; 184 union { 185 u8 ugack_cnt; 186 u8 start_index; 187 }; 188 u8 bgack_cnt; 189 struct tipc_gap_ack gacks[]; 190 }; 191 192 #define MAX_GAP_ACK_BLKS 128 193 #define MAX_GAP_ACK_BLKS_SZ (sizeof(struct tipc_gap_ack_blks) + \ 194 sizeof(struct tipc_gap_ack) * MAX_GAP_ACK_BLKS) 195 196 static inline struct tipc_msg *buf_msg(struct sk_buff *skb) 197 { 198 return (struct tipc_msg *)skb->data; 199 } 200 201 static inline u32 msg_word(struct tipc_msg *m, u32 pos) 202 { 203 return ntohl(m->hdr[pos]); 204 } 205 206 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val) 207 { 208 m->hdr[w] = htonl(val); 209 } 210 211 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask) 212 { 213 return (msg_word(m, w) >> pos) & mask; 214 } 215 216 static inline void msg_set_bits(struct tipc_msg *m, u32 w, 217 u32 pos, u32 mask, u32 val) 218 { 219 val = (val & mask) << pos; 220 mask = mask << pos; 221 m->hdr[w] &= ~htonl(mask); 222 m->hdr[w] |= htonl(val); 223 } 224 225 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b) 226 { 227 u32 temp = msg->hdr[a]; 228 229 msg->hdr[a] = msg->hdr[b]; 230 msg->hdr[b] = temp; 231 } 232 233 /* 234 * Word 0 235 */ 236 static inline u32 msg_version(struct tipc_msg *m) 237 { 238 return msg_bits(m, 0, 29, 7); 239 } 240 241 static inline void msg_set_version(struct tipc_msg *m) 242 { 243 msg_set_bits(m, 0, 29, 7, TIPC_VERSION); 244 } 245 246 static inline u32 msg_user(struct tipc_msg *m) 247 { 248 return msg_bits(m, 0, 25, 0xf); 249 } 250 251 static inline u32 msg_isdata(struct tipc_msg *m) 252 { 253 return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE; 254 } 255 256 static inline void msg_set_user(struct tipc_msg *m, u32 n) 257 { 258 msg_set_bits(m, 0, 25, 0xf, n); 259 } 260 261 static inline u32 msg_hdr_sz(struct tipc_msg *m) 262 { 263 return msg_bits(m, 0, 21, 0xf) << 2; 264 } 265 266 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n) 267 { 268 msg_set_bits(m, 0, 21, 0xf, n>>2); 269 } 270 271 static inline u32 msg_size(struct tipc_msg *m) 272 { 273 return msg_bits(m, 0, 0, 0x1ffff); 274 } 275 276 static inline u32 msg_blocks(struct tipc_msg *m) 277 { 278 return (msg_size(m) / 1024) + 1; 279 } 280 281 static inline u32 msg_data_sz(struct tipc_msg *m) 282 { 283 return msg_size(m) - msg_hdr_sz(m); 284 } 285 286 static inline int msg_non_seq(struct tipc_msg *m) 287 { 288 return msg_bits(m, 0, 20, 1); 289 } 290 291 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n) 292 { 293 msg_set_bits(m, 0, 20, 1, n); 294 } 295 296 static inline int msg_is_syn(struct tipc_msg *m) 297 { 298 return msg_bits(m, 0, 17, 1); 299 } 300 301 static inline void msg_set_syn(struct tipc_msg *m, u32 d) 302 { 303 msg_set_bits(m, 0, 17, 1, d); 304 } 305 306 static inline int msg_dest_droppable(struct tipc_msg *m) 307 { 308 return msg_bits(m, 0, 19, 1); 309 } 310 311 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d) 312 { 313 msg_set_bits(m, 0, 19, 1, d); 314 } 315 316 static inline int msg_is_keepalive(struct tipc_msg *m) 317 { 318 return msg_bits(m, 0, 19, 1); 319 } 320 321 static inline void msg_set_is_keepalive(struct tipc_msg *m, u32 d) 322 { 323 msg_set_bits(m, 0, 19, 1, d); 324 } 325 326 static inline int msg_src_droppable(struct tipc_msg *m) 327 { 328 return msg_bits(m, 0, 18, 1); 329 } 330 331 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d) 332 { 333 msg_set_bits(m, 0, 18, 1, d); 334 } 335 336 static inline int msg_ack_required(struct tipc_msg *m) 337 { 338 return msg_bits(m, 0, 18, 1); 339 } 340 341 static inline void msg_set_ack_required(struct tipc_msg *m) 342 { 343 msg_set_bits(m, 0, 18, 1, 1); 344 } 345 346 static inline int msg_nagle_ack(struct tipc_msg *m) 347 { 348 return msg_bits(m, 0, 18, 1); 349 } 350 351 static inline void msg_set_nagle_ack(struct tipc_msg *m) 352 { 353 msg_set_bits(m, 0, 18, 1, 1); 354 } 355 356 static inline bool msg_is_rcast(struct tipc_msg *m) 357 { 358 return msg_bits(m, 0, 18, 0x1); 359 } 360 361 static inline void msg_set_is_rcast(struct tipc_msg *m, bool d) 362 { 363 msg_set_bits(m, 0, 18, 0x1, d); 364 } 365 366 static inline void msg_set_size(struct tipc_msg *m, u32 sz) 367 { 368 m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz); 369 } 370 371 static inline unchar *msg_data(struct tipc_msg *m) 372 { 373 return ((unchar *)m) + msg_hdr_sz(m); 374 } 375 376 static inline struct tipc_msg *msg_inner_hdr(struct tipc_msg *m) 377 { 378 return (struct tipc_msg *)msg_data(m); 379 } 380 381 /* 382 * Word 1 383 */ 384 static inline u32 msg_type(struct tipc_msg *m) 385 { 386 return msg_bits(m, 1, 29, 0x7); 387 } 388 389 static inline void msg_set_type(struct tipc_msg *m, u32 n) 390 { 391 msg_set_bits(m, 1, 29, 0x7, n); 392 } 393 394 static inline int msg_in_group(struct tipc_msg *m) 395 { 396 int mtyp = msg_type(m); 397 398 return mtyp >= TIPC_GRP_MEMBER_EVT && mtyp <= TIPC_GRP_UCAST_MSG; 399 } 400 401 static inline bool msg_is_grp_evt(struct tipc_msg *m) 402 { 403 return msg_type(m) == TIPC_GRP_MEMBER_EVT; 404 } 405 406 static inline u32 msg_named(struct tipc_msg *m) 407 { 408 return msg_type(m) == TIPC_NAMED_MSG; 409 } 410 411 static inline u32 msg_mcast(struct tipc_msg *m) 412 { 413 int mtyp = msg_type(m); 414 415 return ((mtyp == TIPC_MCAST_MSG) || (mtyp == TIPC_GRP_BCAST_MSG) || 416 (mtyp == TIPC_GRP_MCAST_MSG)); 417 } 418 419 static inline u32 msg_connected(struct tipc_msg *m) 420 { 421 return msg_type(m) == TIPC_CONN_MSG; 422 } 423 424 static inline u32 msg_direct(struct tipc_msg *m) 425 { 426 return msg_type(m) == TIPC_DIRECT_MSG; 427 } 428 429 static inline u32 msg_errcode(struct tipc_msg *m) 430 { 431 return msg_bits(m, 1, 25, 0xf); 432 } 433 434 static inline void msg_set_errcode(struct tipc_msg *m, u32 err) 435 { 436 msg_set_bits(m, 1, 25, 0xf, err); 437 } 438 439 static inline void msg_set_bulk(struct tipc_msg *m) 440 { 441 msg_set_bits(m, 1, 28, 0x1, 1); 442 } 443 444 static inline u32 msg_is_bulk(struct tipc_msg *m) 445 { 446 return msg_bits(m, 1, 28, 0x1); 447 } 448 449 static inline void msg_set_last_bulk(struct tipc_msg *m) 450 { 451 msg_set_bits(m, 1, 27, 0x1, 1); 452 } 453 454 static inline u32 msg_is_last_bulk(struct tipc_msg *m) 455 { 456 return msg_bits(m, 1, 27, 0x1); 457 } 458 459 static inline void msg_set_non_legacy(struct tipc_msg *m) 460 { 461 msg_set_bits(m, 1, 26, 0x1, 1); 462 } 463 464 static inline u32 msg_is_legacy(struct tipc_msg *m) 465 { 466 return !msg_bits(m, 1, 26, 0x1); 467 } 468 469 static inline u32 msg_reroute_cnt(struct tipc_msg *m) 470 { 471 return msg_bits(m, 1, 21, 0xf); 472 } 473 474 static inline void msg_incr_reroute_cnt(struct tipc_msg *m) 475 { 476 msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1); 477 } 478 479 static inline void msg_reset_reroute_cnt(struct tipc_msg *m) 480 { 481 msg_set_bits(m, 1, 21, 0xf, 0); 482 } 483 484 static inline u32 msg_lookup_scope(struct tipc_msg *m) 485 { 486 return msg_bits(m, 1, 19, 0x3); 487 } 488 489 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n) 490 { 491 msg_set_bits(m, 1, 19, 0x3, n); 492 } 493 494 static inline u16 msg_bcast_ack(struct tipc_msg *m) 495 { 496 return msg_bits(m, 1, 0, 0xffff); 497 } 498 499 static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n) 500 { 501 msg_set_bits(m, 1, 0, 0xffff, n); 502 } 503 504 /* Note: reusing bits in word 1 for ACTIVATE_MSG only, to re-synch 505 * link peer session number 506 */ 507 static inline bool msg_dest_session_valid(struct tipc_msg *m) 508 { 509 return msg_bits(m, 1, 16, 0x1); 510 } 511 512 static inline void msg_set_dest_session_valid(struct tipc_msg *m, bool valid) 513 { 514 msg_set_bits(m, 1, 16, 0x1, valid); 515 } 516 517 static inline u16 msg_dest_session(struct tipc_msg *m) 518 { 519 return msg_bits(m, 1, 0, 0xffff); 520 } 521 522 static inline void msg_set_dest_session(struct tipc_msg *m, u16 n) 523 { 524 msg_set_bits(m, 1, 0, 0xffff, n); 525 } 526 527 /* 528 * Word 2 529 */ 530 static inline u16 msg_ack(struct tipc_msg *m) 531 { 532 return msg_bits(m, 2, 16, 0xffff); 533 } 534 535 static inline void msg_set_ack(struct tipc_msg *m, u16 n) 536 { 537 msg_set_bits(m, 2, 16, 0xffff, n); 538 } 539 540 static inline u16 msg_seqno(struct tipc_msg *m) 541 { 542 return msg_bits(m, 2, 0, 0xffff); 543 } 544 545 static inline void msg_set_seqno(struct tipc_msg *m, u16 n) 546 { 547 msg_set_bits(m, 2, 0, 0xffff, n); 548 } 549 550 /* 551 * Words 3-10 552 */ 553 static inline u32 msg_importance(struct tipc_msg *m) 554 { 555 int usr = msg_user(m); 556 557 if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m))) 558 return usr; 559 if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)) 560 return msg_bits(m, 9, 0, 0x7); 561 return TIPC_SYSTEM_IMPORTANCE; 562 } 563 564 static inline void msg_set_importance(struct tipc_msg *m, u32 i) 565 { 566 int usr = msg_user(m); 567 568 if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))) 569 msg_set_bits(m, 9, 0, 0x7, i); 570 else if (i < TIPC_SYSTEM_IMPORTANCE) 571 msg_set_user(m, i); 572 else 573 pr_warn("Trying to set illegal importance in message\n"); 574 } 575 576 static inline u32 msg_prevnode(struct tipc_msg *m) 577 { 578 return msg_word(m, 3); 579 } 580 581 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a) 582 { 583 msg_set_word(m, 3, a); 584 } 585 586 static inline u32 msg_origport(struct tipc_msg *m) 587 { 588 if (msg_user(m) == MSG_FRAGMENTER) 589 m = msg_inner_hdr(m); 590 return msg_word(m, 4); 591 } 592 593 static inline void msg_set_origport(struct tipc_msg *m, u32 p) 594 { 595 msg_set_word(m, 4, p); 596 } 597 598 static inline u16 msg_named_seqno(struct tipc_msg *m) 599 { 600 return msg_bits(m, 4, 0, 0xffff); 601 } 602 603 static inline void msg_set_named_seqno(struct tipc_msg *m, u16 n) 604 { 605 msg_set_bits(m, 4, 0, 0xffff, n); 606 } 607 608 static inline u32 msg_destport(struct tipc_msg *m) 609 { 610 return msg_word(m, 5); 611 } 612 613 static inline void msg_set_destport(struct tipc_msg *m, u32 p) 614 { 615 msg_set_word(m, 5, p); 616 } 617 618 static inline u32 msg_mc_netid(struct tipc_msg *m) 619 { 620 return msg_word(m, 5); 621 } 622 623 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p) 624 { 625 msg_set_word(m, 5, p); 626 } 627 628 static inline int msg_short(struct tipc_msg *m) 629 { 630 return msg_hdr_sz(m) == SHORT_H_SIZE; 631 } 632 633 static inline u32 msg_orignode(struct tipc_msg *m) 634 { 635 if (likely(msg_short(m))) 636 return msg_prevnode(m); 637 return msg_word(m, 6); 638 } 639 640 static inline void msg_set_orignode(struct tipc_msg *m, u32 a) 641 { 642 msg_set_word(m, 6, a); 643 } 644 645 static inline u32 msg_destnode(struct tipc_msg *m) 646 { 647 return msg_word(m, 7); 648 } 649 650 static inline void msg_set_destnode(struct tipc_msg *m, u32 a) 651 { 652 msg_set_word(m, 7, a); 653 } 654 655 static inline u32 msg_nametype(struct tipc_msg *m) 656 { 657 return msg_word(m, 8); 658 } 659 660 static inline void msg_set_nametype(struct tipc_msg *m, u32 n) 661 { 662 msg_set_word(m, 8, n); 663 } 664 665 static inline u32 msg_nameinst(struct tipc_msg *m) 666 { 667 return msg_word(m, 9); 668 } 669 670 static inline u32 msg_namelower(struct tipc_msg *m) 671 { 672 return msg_nameinst(m); 673 } 674 675 static inline void msg_set_namelower(struct tipc_msg *m, u32 n) 676 { 677 msg_set_word(m, 9, n); 678 } 679 680 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n) 681 { 682 msg_set_namelower(m, n); 683 } 684 685 static inline u32 msg_nameupper(struct tipc_msg *m) 686 { 687 return msg_word(m, 10); 688 } 689 690 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n) 691 { 692 msg_set_word(m, 10, n); 693 } 694 695 /* 696 * Constants and routines used to read and write TIPC internal message headers 697 */ 698 699 /* 700 * Connection management protocol message types 701 */ 702 #define CONN_PROBE 0 703 #define CONN_PROBE_REPLY 1 704 #define CONN_ACK 2 705 706 /* 707 * Name distributor message types 708 */ 709 #define PUBLICATION 0 710 #define WITHDRAWAL 1 711 712 /* 713 * Segmentation message types 714 */ 715 #define FIRST_FRAGMENT 0 716 #define FRAGMENT 1 717 #define LAST_FRAGMENT 2 718 719 /* 720 * Link management protocol message types 721 */ 722 #define STATE_MSG 0 723 #define RESET_MSG 1 724 #define ACTIVATE_MSG 2 725 726 /* 727 * Changeover tunnel message types 728 */ 729 #define SYNCH_MSG 0 730 #define FAILOVER_MSG 1 731 732 /* 733 * Config protocol message types 734 */ 735 #define DSC_REQ_MSG 0 736 #define DSC_RESP_MSG 1 737 #define DSC_TRIAL_MSG 2 738 #define DSC_TRIAL_FAIL_MSG 3 739 740 /* 741 * Group protocol message types 742 */ 743 #define GRP_JOIN_MSG 0 744 #define GRP_LEAVE_MSG 1 745 #define GRP_ADV_MSG 2 746 #define GRP_ACK_MSG 3 747 #define GRP_RECLAIM_MSG 4 748 #define GRP_REMIT_MSG 5 749 750 /* 751 * Word 1 752 */ 753 static inline u32 msg_seq_gap(struct tipc_msg *m) 754 { 755 return msg_bits(m, 1, 16, 0x1fff); 756 } 757 758 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n) 759 { 760 msg_set_bits(m, 1, 16, 0x1fff, n); 761 } 762 763 static inline u32 msg_node_sig(struct tipc_msg *m) 764 { 765 return msg_bits(m, 1, 0, 0xffff); 766 } 767 768 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n) 769 { 770 msg_set_bits(m, 1, 0, 0xffff, n); 771 } 772 773 static inline u32 msg_node_capabilities(struct tipc_msg *m) 774 { 775 return msg_bits(m, 1, 15, 0x1fff); 776 } 777 778 static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n) 779 { 780 msg_set_bits(m, 1, 15, 0x1fff, n); 781 } 782 783 /* 784 * Word 2 785 */ 786 static inline u32 msg_dest_domain(struct tipc_msg *m) 787 { 788 return msg_word(m, 2); 789 } 790 791 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n) 792 { 793 msg_set_word(m, 2, n); 794 } 795 796 static inline u32 msg_bcgap_after(struct tipc_msg *m) 797 { 798 return msg_bits(m, 2, 16, 0xffff); 799 } 800 801 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n) 802 { 803 msg_set_bits(m, 2, 16, 0xffff, n); 804 } 805 806 static inline u32 msg_bcgap_to(struct tipc_msg *m) 807 { 808 return msg_bits(m, 2, 0, 0xffff); 809 } 810 811 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n) 812 { 813 msg_set_bits(m, 2, 0, 0xffff, n); 814 } 815 816 /* 817 * Word 4 818 */ 819 static inline u32 msg_last_bcast(struct tipc_msg *m) 820 { 821 return msg_bits(m, 4, 16, 0xffff); 822 } 823 824 static inline u32 msg_bc_snd_nxt(struct tipc_msg *m) 825 { 826 return msg_last_bcast(m) + 1; 827 } 828 829 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n) 830 { 831 msg_set_bits(m, 4, 16, 0xffff, n); 832 } 833 834 static inline u32 msg_nof_fragms(struct tipc_msg *m) 835 { 836 return msg_bits(m, 4, 0, 0xffff); 837 } 838 839 static inline void msg_set_nof_fragms(struct tipc_msg *m, u32 n) 840 { 841 msg_set_bits(m, 4, 0, 0xffff, n); 842 } 843 844 static inline u32 msg_fragm_no(struct tipc_msg *m) 845 { 846 return msg_bits(m, 4, 16, 0xffff); 847 } 848 849 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n) 850 { 851 msg_set_bits(m, 4, 16, 0xffff, n); 852 } 853 854 static inline u16 msg_next_sent(struct tipc_msg *m) 855 { 856 return msg_bits(m, 4, 0, 0xffff); 857 } 858 859 static inline void msg_set_next_sent(struct tipc_msg *m, u16 n) 860 { 861 msg_set_bits(m, 4, 0, 0xffff, n); 862 } 863 864 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n) 865 { 866 msg_set_bits(m, 4, 0, 0xffff, n); 867 } 868 869 static inline u32 msg_bc_netid(struct tipc_msg *m) 870 { 871 return msg_word(m, 4); 872 } 873 874 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id) 875 { 876 msg_set_word(m, 4, id); 877 } 878 879 static inline u32 msg_link_selector(struct tipc_msg *m) 880 { 881 if (msg_user(m) == MSG_FRAGMENTER) 882 m = (void *)msg_data(m); 883 return msg_bits(m, 4, 0, 1); 884 } 885 886 /* 887 * Word 5 888 */ 889 static inline u16 msg_session(struct tipc_msg *m) 890 { 891 return msg_bits(m, 5, 16, 0xffff); 892 } 893 894 static inline void msg_set_session(struct tipc_msg *m, u16 n) 895 { 896 msg_set_bits(m, 5, 16, 0xffff, n); 897 } 898 899 static inline u32 msg_probe(struct tipc_msg *m) 900 { 901 return msg_bits(m, 5, 0, 1); 902 } 903 904 static inline void msg_set_probe(struct tipc_msg *m, u32 val) 905 { 906 msg_set_bits(m, 5, 0, 1, val); 907 } 908 909 static inline char msg_net_plane(struct tipc_msg *m) 910 { 911 return msg_bits(m, 5, 1, 7) + 'A'; 912 } 913 914 static inline void msg_set_net_plane(struct tipc_msg *m, char n) 915 { 916 msg_set_bits(m, 5, 1, 7, (n - 'A')); 917 } 918 919 static inline u32 msg_linkprio(struct tipc_msg *m) 920 { 921 return msg_bits(m, 5, 4, 0x1f); 922 } 923 924 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n) 925 { 926 msg_set_bits(m, 5, 4, 0x1f, n); 927 } 928 929 static inline u32 msg_bearer_id(struct tipc_msg *m) 930 { 931 return msg_bits(m, 5, 9, 0x7); 932 } 933 934 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n) 935 { 936 msg_set_bits(m, 5, 9, 0x7, n); 937 } 938 939 static inline u32 msg_redundant_link(struct tipc_msg *m) 940 { 941 return msg_bits(m, 5, 12, 0x1); 942 } 943 944 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r) 945 { 946 msg_set_bits(m, 5, 12, 0x1, r); 947 } 948 949 static inline u32 msg_peer_stopping(struct tipc_msg *m) 950 { 951 return msg_bits(m, 5, 13, 0x1); 952 } 953 954 static inline void msg_set_peer_stopping(struct tipc_msg *m, u32 s) 955 { 956 msg_set_bits(m, 5, 13, 0x1, s); 957 } 958 959 static inline bool msg_bc_ack_invalid(struct tipc_msg *m) 960 { 961 switch (msg_user(m)) { 962 case BCAST_PROTOCOL: 963 case NAME_DISTRIBUTOR: 964 case LINK_PROTOCOL: 965 return msg_bits(m, 5, 14, 0x1); 966 default: 967 return false; 968 } 969 } 970 971 static inline void msg_set_bc_ack_invalid(struct tipc_msg *m, bool invalid) 972 { 973 msg_set_bits(m, 5, 14, 0x1, invalid); 974 } 975 976 static inline char *msg_media_addr(struct tipc_msg *m) 977 { 978 return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET]; 979 } 980 981 static inline u32 msg_bc_gap(struct tipc_msg *m) 982 { 983 return msg_bits(m, 8, 0, 0x3ff); 984 } 985 986 static inline void msg_set_bc_gap(struct tipc_msg *m, u32 n) 987 { 988 msg_set_bits(m, 8, 0, 0x3ff, n); 989 } 990 991 /* 992 * Word 9 993 */ 994 static inline u16 msg_msgcnt(struct tipc_msg *m) 995 { 996 return msg_bits(m, 9, 16, 0xffff); 997 } 998 999 static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n) 1000 { 1001 msg_set_bits(m, 9, 16, 0xffff, n); 1002 } 1003 1004 static inline u16 msg_syncpt(struct tipc_msg *m) 1005 { 1006 return msg_bits(m, 9, 16, 0xffff); 1007 } 1008 1009 static inline void msg_set_syncpt(struct tipc_msg *m, u16 n) 1010 { 1011 msg_set_bits(m, 9, 16, 0xffff, n); 1012 } 1013 1014 static inline u32 msg_conn_ack(struct tipc_msg *m) 1015 { 1016 return msg_bits(m, 9, 16, 0xffff); 1017 } 1018 1019 static inline void msg_set_conn_ack(struct tipc_msg *m, u32 n) 1020 { 1021 msg_set_bits(m, 9, 16, 0xffff, n); 1022 } 1023 1024 static inline u16 msg_adv_win(struct tipc_msg *m) 1025 { 1026 return msg_bits(m, 9, 0, 0xffff); 1027 } 1028 1029 static inline void msg_set_adv_win(struct tipc_msg *m, u16 n) 1030 { 1031 msg_set_bits(m, 9, 0, 0xffff, n); 1032 } 1033 1034 static inline u32 msg_max_pkt(struct tipc_msg *m) 1035 { 1036 return msg_bits(m, 9, 16, 0xffff) * 4; 1037 } 1038 1039 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n) 1040 { 1041 msg_set_bits(m, 9, 16, 0xffff, (n / 4)); 1042 } 1043 1044 static inline u32 msg_link_tolerance(struct tipc_msg *m) 1045 { 1046 return msg_bits(m, 9, 0, 0xffff); 1047 } 1048 1049 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n) 1050 { 1051 msg_set_bits(m, 9, 0, 0xffff, n); 1052 } 1053 1054 static inline u16 msg_grp_bc_syncpt(struct tipc_msg *m) 1055 { 1056 return msg_bits(m, 9, 16, 0xffff); 1057 } 1058 1059 static inline void msg_set_grp_bc_syncpt(struct tipc_msg *m, u16 n) 1060 { 1061 msg_set_bits(m, 9, 16, 0xffff, n); 1062 } 1063 1064 static inline u16 msg_grp_bc_acked(struct tipc_msg *m) 1065 { 1066 return msg_bits(m, 9, 16, 0xffff); 1067 } 1068 1069 static inline void msg_set_grp_bc_acked(struct tipc_msg *m, u16 n) 1070 { 1071 msg_set_bits(m, 9, 16, 0xffff, n); 1072 } 1073 1074 static inline u16 msg_grp_remitted(struct tipc_msg *m) 1075 { 1076 return msg_bits(m, 9, 16, 0xffff); 1077 } 1078 1079 static inline void msg_set_grp_remitted(struct tipc_msg *m, u16 n) 1080 { 1081 msg_set_bits(m, 9, 16, 0xffff, n); 1082 } 1083 1084 /* Word 10 1085 */ 1086 static inline u16 msg_grp_evt(struct tipc_msg *m) 1087 { 1088 return msg_bits(m, 10, 0, 0x3); 1089 } 1090 1091 static inline void msg_set_grp_evt(struct tipc_msg *m, int n) 1092 { 1093 msg_set_bits(m, 10, 0, 0x3, n); 1094 } 1095 1096 static inline u16 msg_grp_bc_ack_req(struct tipc_msg *m) 1097 { 1098 return msg_bits(m, 10, 0, 0x1); 1099 } 1100 1101 static inline void msg_set_grp_bc_ack_req(struct tipc_msg *m, bool n) 1102 { 1103 msg_set_bits(m, 10, 0, 0x1, n); 1104 } 1105 1106 static inline u16 msg_grp_bc_seqno(struct tipc_msg *m) 1107 { 1108 return msg_bits(m, 10, 16, 0xffff); 1109 } 1110 1111 static inline void msg_set_grp_bc_seqno(struct tipc_msg *m, u32 n) 1112 { 1113 msg_set_bits(m, 10, 16, 0xffff, n); 1114 } 1115 1116 static inline bool msg_peer_link_is_up(struct tipc_msg *m) 1117 { 1118 if (likely(msg_user(m) != LINK_PROTOCOL)) 1119 return true; 1120 if (msg_type(m) == STATE_MSG) 1121 return true; 1122 return false; 1123 } 1124 1125 static inline bool msg_peer_node_is_up(struct tipc_msg *m) 1126 { 1127 if (msg_peer_link_is_up(m)) 1128 return true; 1129 return msg_redundant_link(m); 1130 } 1131 1132 static inline bool msg_is_reset(struct tipc_msg *hdr) 1133 { 1134 return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG); 1135 } 1136 1137 /* Word 13 1138 */ 1139 static inline void msg_set_peer_net_hash(struct tipc_msg *m, u32 n) 1140 { 1141 msg_set_word(m, 13, n); 1142 } 1143 1144 static inline u32 msg_peer_net_hash(struct tipc_msg *m) 1145 { 1146 return msg_word(m, 13); 1147 } 1148 1149 /* Word 14 1150 */ 1151 static inline u32 msg_sugg_node_addr(struct tipc_msg *m) 1152 { 1153 return msg_word(m, 14); 1154 } 1155 1156 static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n) 1157 { 1158 msg_set_word(m, 14, n); 1159 } 1160 1161 static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id) 1162 { 1163 memcpy(msg_data(hdr), id, 16); 1164 } 1165 1166 static inline u8 *msg_node_id(struct tipc_msg *hdr) 1167 { 1168 return (u8 *)msg_data(hdr); 1169 } 1170 1171 struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp); 1172 bool tipc_msg_validate(struct sk_buff **_skb); 1173 bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err); 1174 void tipc_skb_reject(struct net *net, int err, struct sk_buff *skb, 1175 struct sk_buff_head *xmitq); 1176 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type, 1177 u32 hsize, u32 destnode); 1178 struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz, 1179 uint data_sz, u32 dnode, u32 onode, 1180 u32 dport, u32 oport, int errcode); 1181 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf); 1182 bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss, 1183 u32 dnode, bool *new_bundle); 1184 bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos); 1185 int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr, 1186 int pktmax, struct sk_buff_head *frags); 1187 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, 1188 int offset, int dsz, int mtu, struct sk_buff_head *list); 1189 int tipc_msg_append(struct tipc_msg *hdr, struct msghdr *m, int dlen, 1190 int mss, struct sk_buff_head *txq); 1191 bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err); 1192 bool tipc_msg_assemble(struct sk_buff_head *list); 1193 bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq); 1194 bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg, 1195 struct sk_buff_head *cpy); 1196 bool __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno, 1197 struct sk_buff *skb); 1198 bool tipc_msg_skb_clone(struct sk_buff_head *msg, struct sk_buff_head *cpy); 1199 1200 static inline u16 buf_seqno(struct sk_buff *skb) 1201 { 1202 return msg_seqno(buf_msg(skb)); 1203 } 1204 1205 static inline int buf_roundup_len(struct sk_buff *skb) 1206 { 1207 return (skb->len / 1024 + 1) * 1024; 1208 } 1209 1210 /* tipc_skb_peek(): peek and reserve first buffer in list 1211 * @list: list to be peeked in 1212 * Returns pointer to first buffer in list, if any 1213 */ 1214 static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list, 1215 spinlock_t *lock) 1216 { 1217 struct sk_buff *skb; 1218 1219 spin_lock_bh(lock); 1220 skb = skb_peek(list); 1221 if (skb) 1222 skb_get(skb); 1223 spin_unlock_bh(lock); 1224 return skb; 1225 } 1226 1227 /* tipc_skb_peek_port(): find a destination port, ignoring all destinations 1228 * up to and including 'filter'. 1229 * Note: ignoring previously tried destinations minimizes the risk of 1230 * contention on the socket lock 1231 * @list: list to be peeked in 1232 * @filter: last destination to be ignored from search 1233 * Returns a destination port number, of applicable. 1234 */ 1235 static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter) 1236 { 1237 struct sk_buff *skb; 1238 u32 dport = 0; 1239 bool ignore = true; 1240 1241 spin_lock_bh(&list->lock); 1242 skb_queue_walk(list, skb) { 1243 dport = msg_destport(buf_msg(skb)); 1244 if (!filter || skb_queue_is_last(list, skb)) 1245 break; 1246 if (dport == filter) 1247 ignore = false; 1248 else if (!ignore) 1249 break; 1250 } 1251 spin_unlock_bh(&list->lock); 1252 return dport; 1253 } 1254 1255 /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list 1256 * @list: list to be unlinked from 1257 * @dport: selection criteria for buffer to unlink 1258 */ 1259 static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list, 1260 u32 dport) 1261 { 1262 struct sk_buff *_skb, *tmp, *skb = NULL; 1263 1264 spin_lock_bh(&list->lock); 1265 skb_queue_walk_safe(list, _skb, tmp) { 1266 if (msg_destport(buf_msg(_skb)) == dport) { 1267 __skb_unlink(_skb, list); 1268 skb = _skb; 1269 break; 1270 } 1271 } 1272 spin_unlock_bh(&list->lock); 1273 return skb; 1274 } 1275 1276 /* tipc_skb_queue_splice_tail - append an skb list to lock protected list 1277 * @list: the new list to append. Not lock protected 1278 * @head: target list. Lock protected. 1279 */ 1280 static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list, 1281 struct sk_buff_head *head) 1282 { 1283 spin_lock_bh(&head->lock); 1284 skb_queue_splice_tail(list, head); 1285 spin_unlock_bh(&head->lock); 1286 } 1287 1288 /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists 1289 * @list: the new list to add. Lock protected. Will be reinitialized 1290 * @head: target list. Lock protected. 1291 */ 1292 static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list, 1293 struct sk_buff_head *head) 1294 { 1295 struct sk_buff_head tmp; 1296 1297 __skb_queue_head_init(&tmp); 1298 1299 spin_lock_bh(&list->lock); 1300 skb_queue_splice_tail_init(list, &tmp); 1301 spin_unlock_bh(&list->lock); 1302 tipc_skb_queue_splice_tail(&tmp, head); 1303 } 1304 1305 /* __tipc_skb_dequeue() - dequeue the head skb according to expected seqno 1306 * @list: list to be dequeued from 1307 * @seqno: seqno of the expected msg 1308 * 1309 * returns skb dequeued from the list if its seqno is less than or equal to 1310 * the expected one, otherwise the skb is still hold 1311 * 1312 * Note: must be used with appropriate locks held only 1313 */ 1314 static inline struct sk_buff *__tipc_skb_dequeue(struct sk_buff_head *list, 1315 u16 seqno) 1316 { 1317 struct sk_buff *skb = skb_peek(list); 1318 1319 if (skb && less_eq(buf_seqno(skb), seqno)) { 1320 __skb_unlink(skb, list); 1321 return skb; 1322 } 1323 return NULL; 1324 } 1325 1326 #endif 1327