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 * @gack_cnt: number of Gap ACK blocks in the record 164 * @gacks: array of Gap ACK blocks 165 */ 166 struct tipc_gap_ack_blks { 167 __be16 len; 168 u8 gack_cnt; 169 u8 reserved; 170 struct tipc_gap_ack gacks[]; 171 }; 172 173 #define tipc_gap_ack_blks_sz(n) (sizeof(struct tipc_gap_ack_blks) + \ 174 sizeof(struct tipc_gap_ack) * (n)) 175 176 #define MAX_GAP_ACK_BLKS 32 177 #define MAX_GAP_ACK_BLKS_SZ tipc_gap_ack_blks_sz(MAX_GAP_ACK_BLKS) 178 179 static inline struct tipc_msg *buf_msg(struct sk_buff *skb) 180 { 181 return (struct tipc_msg *)skb->data; 182 } 183 184 static inline u32 msg_word(struct tipc_msg *m, u32 pos) 185 { 186 return ntohl(m->hdr[pos]); 187 } 188 189 static inline void msg_set_word(struct tipc_msg *m, u32 w, u32 val) 190 { 191 m->hdr[w] = htonl(val); 192 } 193 194 static inline u32 msg_bits(struct tipc_msg *m, u32 w, u32 pos, u32 mask) 195 { 196 return (msg_word(m, w) >> pos) & mask; 197 } 198 199 static inline void msg_set_bits(struct tipc_msg *m, u32 w, 200 u32 pos, u32 mask, u32 val) 201 { 202 val = (val & mask) << pos; 203 mask = mask << pos; 204 m->hdr[w] &= ~htonl(mask); 205 m->hdr[w] |= htonl(val); 206 } 207 208 static inline void msg_swap_words(struct tipc_msg *msg, u32 a, u32 b) 209 { 210 u32 temp = msg->hdr[a]; 211 212 msg->hdr[a] = msg->hdr[b]; 213 msg->hdr[b] = temp; 214 } 215 216 /* 217 * Word 0 218 */ 219 static inline u32 msg_version(struct tipc_msg *m) 220 { 221 return msg_bits(m, 0, 29, 7); 222 } 223 224 static inline void msg_set_version(struct tipc_msg *m) 225 { 226 msg_set_bits(m, 0, 29, 7, TIPC_VERSION); 227 } 228 229 static inline u32 msg_user(struct tipc_msg *m) 230 { 231 return msg_bits(m, 0, 25, 0xf); 232 } 233 234 static inline u32 msg_isdata(struct tipc_msg *m) 235 { 236 return msg_user(m) <= TIPC_CRITICAL_IMPORTANCE; 237 } 238 239 static inline void msg_set_user(struct tipc_msg *m, u32 n) 240 { 241 msg_set_bits(m, 0, 25, 0xf, n); 242 } 243 244 static inline u32 msg_hdr_sz(struct tipc_msg *m) 245 { 246 return msg_bits(m, 0, 21, 0xf) << 2; 247 } 248 249 static inline void msg_set_hdr_sz(struct tipc_msg *m, u32 n) 250 { 251 msg_set_bits(m, 0, 21, 0xf, n>>2); 252 } 253 254 static inline u32 msg_size(struct tipc_msg *m) 255 { 256 return msg_bits(m, 0, 0, 0x1ffff); 257 } 258 259 static inline u32 msg_blocks(struct tipc_msg *m) 260 { 261 return (msg_size(m) / 1024) + 1; 262 } 263 264 static inline u32 msg_data_sz(struct tipc_msg *m) 265 { 266 return msg_size(m) - msg_hdr_sz(m); 267 } 268 269 static inline int msg_non_seq(struct tipc_msg *m) 270 { 271 return msg_bits(m, 0, 20, 1); 272 } 273 274 static inline void msg_set_non_seq(struct tipc_msg *m, u32 n) 275 { 276 msg_set_bits(m, 0, 20, 1, n); 277 } 278 279 static inline int msg_is_syn(struct tipc_msg *m) 280 { 281 return msg_bits(m, 0, 17, 1); 282 } 283 284 static inline void msg_set_syn(struct tipc_msg *m, u32 d) 285 { 286 msg_set_bits(m, 0, 17, 1, d); 287 } 288 289 static inline int msg_dest_droppable(struct tipc_msg *m) 290 { 291 return msg_bits(m, 0, 19, 1); 292 } 293 294 static inline void msg_set_dest_droppable(struct tipc_msg *m, u32 d) 295 { 296 msg_set_bits(m, 0, 19, 1, d); 297 } 298 299 static inline int msg_is_keepalive(struct tipc_msg *m) 300 { 301 return msg_bits(m, 0, 19, 1); 302 } 303 304 static inline void msg_set_is_keepalive(struct tipc_msg *m, u32 d) 305 { 306 msg_set_bits(m, 0, 19, 1, d); 307 } 308 309 static inline int msg_src_droppable(struct tipc_msg *m) 310 { 311 return msg_bits(m, 0, 18, 1); 312 } 313 314 static inline void msg_set_src_droppable(struct tipc_msg *m, u32 d) 315 { 316 msg_set_bits(m, 0, 18, 1, d); 317 } 318 319 static inline int msg_ack_required(struct tipc_msg *m) 320 { 321 return msg_bits(m, 0, 18, 1); 322 } 323 324 static inline void msg_set_ack_required(struct tipc_msg *m, u32 d) 325 { 326 msg_set_bits(m, 0, 18, 1, d); 327 } 328 329 static inline bool msg_is_rcast(struct tipc_msg *m) 330 { 331 return msg_bits(m, 0, 18, 0x1); 332 } 333 334 static inline void msg_set_is_rcast(struct tipc_msg *m, bool d) 335 { 336 msg_set_bits(m, 0, 18, 0x1, d); 337 } 338 339 static inline void msg_set_size(struct tipc_msg *m, u32 sz) 340 { 341 m->hdr[0] = htonl((msg_word(m, 0) & ~0x1ffff) | sz); 342 } 343 344 static inline unchar *msg_data(struct tipc_msg *m) 345 { 346 return ((unchar *)m) + msg_hdr_sz(m); 347 } 348 349 static inline struct tipc_msg *msg_inner_hdr(struct tipc_msg *m) 350 { 351 return (struct tipc_msg *)msg_data(m); 352 } 353 354 /* 355 * Word 1 356 */ 357 static inline u32 msg_type(struct tipc_msg *m) 358 { 359 return msg_bits(m, 1, 29, 0x7); 360 } 361 362 static inline void msg_set_type(struct tipc_msg *m, u32 n) 363 { 364 msg_set_bits(m, 1, 29, 0x7, n); 365 } 366 367 static inline int msg_in_group(struct tipc_msg *m) 368 { 369 int mtyp = msg_type(m); 370 371 return mtyp >= TIPC_GRP_MEMBER_EVT && mtyp <= TIPC_GRP_UCAST_MSG; 372 } 373 374 static inline bool msg_is_grp_evt(struct tipc_msg *m) 375 { 376 return msg_type(m) == TIPC_GRP_MEMBER_EVT; 377 } 378 379 static inline u32 msg_named(struct tipc_msg *m) 380 { 381 return msg_type(m) == TIPC_NAMED_MSG; 382 } 383 384 static inline u32 msg_mcast(struct tipc_msg *m) 385 { 386 int mtyp = msg_type(m); 387 388 return ((mtyp == TIPC_MCAST_MSG) || (mtyp == TIPC_GRP_BCAST_MSG) || 389 (mtyp == TIPC_GRP_MCAST_MSG)); 390 } 391 392 static inline u32 msg_connected(struct tipc_msg *m) 393 { 394 return msg_type(m) == TIPC_CONN_MSG; 395 } 396 397 static inline u32 msg_errcode(struct tipc_msg *m) 398 { 399 return msg_bits(m, 1, 25, 0xf); 400 } 401 402 static inline void msg_set_errcode(struct tipc_msg *m, u32 err) 403 { 404 msg_set_bits(m, 1, 25, 0xf, err); 405 } 406 407 static inline u32 msg_reroute_cnt(struct tipc_msg *m) 408 { 409 return msg_bits(m, 1, 21, 0xf); 410 } 411 412 static inline void msg_incr_reroute_cnt(struct tipc_msg *m) 413 { 414 msg_set_bits(m, 1, 21, 0xf, msg_reroute_cnt(m) + 1); 415 } 416 417 static inline void msg_reset_reroute_cnt(struct tipc_msg *m) 418 { 419 msg_set_bits(m, 1, 21, 0xf, 0); 420 } 421 422 static inline u32 msg_lookup_scope(struct tipc_msg *m) 423 { 424 return msg_bits(m, 1, 19, 0x3); 425 } 426 427 static inline void msg_set_lookup_scope(struct tipc_msg *m, u32 n) 428 { 429 msg_set_bits(m, 1, 19, 0x3, n); 430 } 431 432 static inline u16 msg_bcast_ack(struct tipc_msg *m) 433 { 434 return msg_bits(m, 1, 0, 0xffff); 435 } 436 437 static inline void msg_set_bcast_ack(struct tipc_msg *m, u16 n) 438 { 439 msg_set_bits(m, 1, 0, 0xffff, n); 440 } 441 442 /* Note: reusing bits in word 1 for ACTIVATE_MSG only, to re-synch 443 * link peer session number 444 */ 445 static inline bool msg_dest_session_valid(struct tipc_msg *m) 446 { 447 return msg_bits(m, 1, 16, 0x1); 448 } 449 450 static inline void msg_set_dest_session_valid(struct tipc_msg *m, bool valid) 451 { 452 msg_set_bits(m, 1, 16, 0x1, valid); 453 } 454 455 static inline u16 msg_dest_session(struct tipc_msg *m) 456 { 457 return msg_bits(m, 1, 0, 0xffff); 458 } 459 460 static inline void msg_set_dest_session(struct tipc_msg *m, u16 n) 461 { 462 msg_set_bits(m, 1, 0, 0xffff, n); 463 } 464 465 /* 466 * Word 2 467 */ 468 static inline u16 msg_ack(struct tipc_msg *m) 469 { 470 return msg_bits(m, 2, 16, 0xffff); 471 } 472 473 static inline void msg_set_ack(struct tipc_msg *m, u16 n) 474 { 475 msg_set_bits(m, 2, 16, 0xffff, n); 476 } 477 478 static inline u16 msg_seqno(struct tipc_msg *m) 479 { 480 return msg_bits(m, 2, 0, 0xffff); 481 } 482 483 static inline void msg_set_seqno(struct tipc_msg *m, u16 n) 484 { 485 msg_set_bits(m, 2, 0, 0xffff, n); 486 } 487 488 /* 489 * Words 3-10 490 */ 491 static inline u32 msg_importance(struct tipc_msg *m) 492 { 493 int usr = msg_user(m); 494 495 if (likely((usr <= TIPC_CRITICAL_IMPORTANCE) && !msg_errcode(m))) 496 return usr; 497 if ((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER)) 498 return msg_bits(m, 9, 0, 0x7); 499 return TIPC_SYSTEM_IMPORTANCE; 500 } 501 502 static inline void msg_set_importance(struct tipc_msg *m, u32 i) 503 { 504 int usr = msg_user(m); 505 506 if (likely((usr == MSG_FRAGMENTER) || (usr == MSG_BUNDLER))) 507 msg_set_bits(m, 9, 0, 0x7, i); 508 else if (i < TIPC_SYSTEM_IMPORTANCE) 509 msg_set_user(m, i); 510 else 511 pr_warn("Trying to set illegal importance in message\n"); 512 } 513 514 static inline u32 msg_prevnode(struct tipc_msg *m) 515 { 516 return msg_word(m, 3); 517 } 518 519 static inline void msg_set_prevnode(struct tipc_msg *m, u32 a) 520 { 521 msg_set_word(m, 3, a); 522 } 523 524 static inline u32 msg_origport(struct tipc_msg *m) 525 { 526 if (msg_user(m) == MSG_FRAGMENTER) 527 m = msg_inner_hdr(m); 528 return msg_word(m, 4); 529 } 530 531 static inline void msg_set_origport(struct tipc_msg *m, u32 p) 532 { 533 msg_set_word(m, 4, p); 534 } 535 536 static inline u32 msg_destport(struct tipc_msg *m) 537 { 538 return msg_word(m, 5); 539 } 540 541 static inline void msg_set_destport(struct tipc_msg *m, u32 p) 542 { 543 msg_set_word(m, 5, p); 544 } 545 546 static inline u32 msg_mc_netid(struct tipc_msg *m) 547 { 548 return msg_word(m, 5); 549 } 550 551 static inline void msg_set_mc_netid(struct tipc_msg *m, u32 p) 552 { 553 msg_set_word(m, 5, p); 554 } 555 556 static inline int msg_short(struct tipc_msg *m) 557 { 558 return msg_hdr_sz(m) == SHORT_H_SIZE; 559 } 560 561 static inline u32 msg_orignode(struct tipc_msg *m) 562 { 563 if (likely(msg_short(m))) 564 return msg_prevnode(m); 565 return msg_word(m, 6); 566 } 567 568 static inline void msg_set_orignode(struct tipc_msg *m, u32 a) 569 { 570 msg_set_word(m, 6, a); 571 } 572 573 static inline u32 msg_destnode(struct tipc_msg *m) 574 { 575 return msg_word(m, 7); 576 } 577 578 static inline void msg_set_destnode(struct tipc_msg *m, u32 a) 579 { 580 msg_set_word(m, 7, a); 581 } 582 583 static inline u32 msg_nametype(struct tipc_msg *m) 584 { 585 return msg_word(m, 8); 586 } 587 588 static inline void msg_set_nametype(struct tipc_msg *m, u32 n) 589 { 590 msg_set_word(m, 8, n); 591 } 592 593 static inline u32 msg_nameinst(struct tipc_msg *m) 594 { 595 return msg_word(m, 9); 596 } 597 598 static inline u32 msg_namelower(struct tipc_msg *m) 599 { 600 return msg_nameinst(m); 601 } 602 603 static inline void msg_set_namelower(struct tipc_msg *m, u32 n) 604 { 605 msg_set_word(m, 9, n); 606 } 607 608 static inline void msg_set_nameinst(struct tipc_msg *m, u32 n) 609 { 610 msg_set_namelower(m, n); 611 } 612 613 static inline u32 msg_nameupper(struct tipc_msg *m) 614 { 615 return msg_word(m, 10); 616 } 617 618 static inline void msg_set_nameupper(struct tipc_msg *m, u32 n) 619 { 620 msg_set_word(m, 10, n); 621 } 622 623 /* 624 * Constants and routines used to read and write TIPC internal message headers 625 */ 626 627 /* 628 * Connection management protocol message types 629 */ 630 #define CONN_PROBE 0 631 #define CONN_PROBE_REPLY 1 632 #define CONN_ACK 2 633 634 /* 635 * Name distributor message types 636 */ 637 #define PUBLICATION 0 638 #define WITHDRAWAL 1 639 640 /* 641 * Segmentation message types 642 */ 643 #define FIRST_FRAGMENT 0 644 #define FRAGMENT 1 645 #define LAST_FRAGMENT 2 646 647 /* 648 * Link management protocol message types 649 */ 650 #define STATE_MSG 0 651 #define RESET_MSG 1 652 #define ACTIVATE_MSG 2 653 654 /* 655 * Changeover tunnel message types 656 */ 657 #define SYNCH_MSG 0 658 #define FAILOVER_MSG 1 659 660 /* 661 * Config protocol message types 662 */ 663 #define DSC_REQ_MSG 0 664 #define DSC_RESP_MSG 1 665 #define DSC_TRIAL_MSG 2 666 #define DSC_TRIAL_FAIL_MSG 3 667 668 /* 669 * Group protocol message types 670 */ 671 #define GRP_JOIN_MSG 0 672 #define GRP_LEAVE_MSG 1 673 #define GRP_ADV_MSG 2 674 #define GRP_ACK_MSG 3 675 #define GRP_RECLAIM_MSG 4 676 #define GRP_REMIT_MSG 5 677 678 /* 679 * Word 1 680 */ 681 static inline u32 msg_seq_gap(struct tipc_msg *m) 682 { 683 return msg_bits(m, 1, 16, 0x1fff); 684 } 685 686 static inline void msg_set_seq_gap(struct tipc_msg *m, u32 n) 687 { 688 msg_set_bits(m, 1, 16, 0x1fff, n); 689 } 690 691 static inline u32 msg_node_sig(struct tipc_msg *m) 692 { 693 return msg_bits(m, 1, 0, 0xffff); 694 } 695 696 static inline void msg_set_node_sig(struct tipc_msg *m, u32 n) 697 { 698 msg_set_bits(m, 1, 0, 0xffff, n); 699 } 700 701 static inline u32 msg_node_capabilities(struct tipc_msg *m) 702 { 703 return msg_bits(m, 1, 15, 0x1fff); 704 } 705 706 static inline void msg_set_node_capabilities(struct tipc_msg *m, u32 n) 707 { 708 msg_set_bits(m, 1, 15, 0x1fff, n); 709 } 710 711 /* 712 * Word 2 713 */ 714 static inline u32 msg_dest_domain(struct tipc_msg *m) 715 { 716 return msg_word(m, 2); 717 } 718 719 static inline void msg_set_dest_domain(struct tipc_msg *m, u32 n) 720 { 721 msg_set_word(m, 2, n); 722 } 723 724 static inline u32 msg_bcgap_after(struct tipc_msg *m) 725 { 726 return msg_bits(m, 2, 16, 0xffff); 727 } 728 729 static inline void msg_set_bcgap_after(struct tipc_msg *m, u32 n) 730 { 731 msg_set_bits(m, 2, 16, 0xffff, n); 732 } 733 734 static inline u32 msg_bcgap_to(struct tipc_msg *m) 735 { 736 return msg_bits(m, 2, 0, 0xffff); 737 } 738 739 static inline void msg_set_bcgap_to(struct tipc_msg *m, u32 n) 740 { 741 msg_set_bits(m, 2, 0, 0xffff, n); 742 } 743 744 /* 745 * Word 4 746 */ 747 static inline u32 msg_last_bcast(struct tipc_msg *m) 748 { 749 return msg_bits(m, 4, 16, 0xffff); 750 } 751 752 static inline u32 msg_bc_snd_nxt(struct tipc_msg *m) 753 { 754 return msg_last_bcast(m) + 1; 755 } 756 757 static inline void msg_set_last_bcast(struct tipc_msg *m, u32 n) 758 { 759 msg_set_bits(m, 4, 16, 0xffff, n); 760 } 761 762 static inline u32 msg_nof_fragms(struct tipc_msg *m) 763 { 764 return msg_bits(m, 4, 0, 0xffff); 765 } 766 767 static inline void msg_set_nof_fragms(struct tipc_msg *m, u32 n) 768 { 769 msg_set_bits(m, 4, 0, 0xffff, n); 770 } 771 772 static inline u32 msg_fragm_no(struct tipc_msg *m) 773 { 774 return msg_bits(m, 4, 16, 0xffff); 775 } 776 777 static inline void msg_set_fragm_no(struct tipc_msg *m, u32 n) 778 { 779 msg_set_bits(m, 4, 16, 0xffff, n); 780 } 781 782 static inline u16 msg_next_sent(struct tipc_msg *m) 783 { 784 return msg_bits(m, 4, 0, 0xffff); 785 } 786 787 static inline void msg_set_next_sent(struct tipc_msg *m, u16 n) 788 { 789 msg_set_bits(m, 4, 0, 0xffff, n); 790 } 791 792 static inline void msg_set_long_msgno(struct tipc_msg *m, u32 n) 793 { 794 msg_set_bits(m, 4, 0, 0xffff, n); 795 } 796 797 static inline u32 msg_bc_netid(struct tipc_msg *m) 798 { 799 return msg_word(m, 4); 800 } 801 802 static inline void msg_set_bc_netid(struct tipc_msg *m, u32 id) 803 { 804 msg_set_word(m, 4, id); 805 } 806 807 static inline u32 msg_link_selector(struct tipc_msg *m) 808 { 809 if (msg_user(m) == MSG_FRAGMENTER) 810 m = (void *)msg_data(m); 811 return msg_bits(m, 4, 0, 1); 812 } 813 814 /* 815 * Word 5 816 */ 817 static inline u16 msg_session(struct tipc_msg *m) 818 { 819 return msg_bits(m, 5, 16, 0xffff); 820 } 821 822 static inline void msg_set_session(struct tipc_msg *m, u16 n) 823 { 824 msg_set_bits(m, 5, 16, 0xffff, n); 825 } 826 827 static inline u32 msg_probe(struct tipc_msg *m) 828 { 829 return msg_bits(m, 5, 0, 1); 830 } 831 832 static inline void msg_set_probe(struct tipc_msg *m, u32 val) 833 { 834 msg_set_bits(m, 5, 0, 1, val); 835 } 836 837 static inline char msg_net_plane(struct tipc_msg *m) 838 { 839 return msg_bits(m, 5, 1, 7) + 'A'; 840 } 841 842 static inline void msg_set_net_plane(struct tipc_msg *m, char n) 843 { 844 msg_set_bits(m, 5, 1, 7, (n - 'A')); 845 } 846 847 static inline u32 msg_linkprio(struct tipc_msg *m) 848 { 849 return msg_bits(m, 5, 4, 0x1f); 850 } 851 852 static inline void msg_set_linkprio(struct tipc_msg *m, u32 n) 853 { 854 msg_set_bits(m, 5, 4, 0x1f, n); 855 } 856 857 static inline u32 msg_bearer_id(struct tipc_msg *m) 858 { 859 return msg_bits(m, 5, 9, 0x7); 860 } 861 862 static inline void msg_set_bearer_id(struct tipc_msg *m, u32 n) 863 { 864 msg_set_bits(m, 5, 9, 0x7, n); 865 } 866 867 static inline u32 msg_redundant_link(struct tipc_msg *m) 868 { 869 return msg_bits(m, 5, 12, 0x1); 870 } 871 872 static inline void msg_set_redundant_link(struct tipc_msg *m, u32 r) 873 { 874 msg_set_bits(m, 5, 12, 0x1, r); 875 } 876 877 static inline u32 msg_peer_stopping(struct tipc_msg *m) 878 { 879 return msg_bits(m, 5, 13, 0x1); 880 } 881 882 static inline void msg_set_peer_stopping(struct tipc_msg *m, u32 s) 883 { 884 msg_set_bits(m, 5, 13, 0x1, s); 885 } 886 887 static inline bool msg_bc_ack_invalid(struct tipc_msg *m) 888 { 889 switch (msg_user(m)) { 890 case BCAST_PROTOCOL: 891 case NAME_DISTRIBUTOR: 892 case LINK_PROTOCOL: 893 return msg_bits(m, 5, 14, 0x1); 894 default: 895 return false; 896 } 897 } 898 899 static inline void msg_set_bc_ack_invalid(struct tipc_msg *m, bool invalid) 900 { 901 msg_set_bits(m, 5, 14, 0x1, invalid); 902 } 903 904 static inline char *msg_media_addr(struct tipc_msg *m) 905 { 906 return (char *)&m->hdr[TIPC_MEDIA_INFO_OFFSET]; 907 } 908 909 static inline u32 msg_bc_gap(struct tipc_msg *m) 910 { 911 return msg_bits(m, 8, 0, 0x3ff); 912 } 913 914 static inline void msg_set_bc_gap(struct tipc_msg *m, u32 n) 915 { 916 msg_set_bits(m, 8, 0, 0x3ff, n); 917 } 918 919 /* 920 * Word 9 921 */ 922 static inline u16 msg_msgcnt(struct tipc_msg *m) 923 { 924 return msg_bits(m, 9, 16, 0xffff); 925 } 926 927 static inline void msg_set_msgcnt(struct tipc_msg *m, u16 n) 928 { 929 msg_set_bits(m, 9, 16, 0xffff, n); 930 } 931 932 static inline u16 msg_syncpt(struct tipc_msg *m) 933 { 934 return msg_bits(m, 9, 16, 0xffff); 935 } 936 937 static inline void msg_set_syncpt(struct tipc_msg *m, u16 n) 938 { 939 msg_set_bits(m, 9, 16, 0xffff, n); 940 } 941 942 static inline u32 msg_conn_ack(struct tipc_msg *m) 943 { 944 return msg_bits(m, 9, 16, 0xffff); 945 } 946 947 static inline void msg_set_conn_ack(struct tipc_msg *m, u32 n) 948 { 949 msg_set_bits(m, 9, 16, 0xffff, n); 950 } 951 952 static inline u16 msg_adv_win(struct tipc_msg *m) 953 { 954 return msg_bits(m, 9, 0, 0xffff); 955 } 956 957 static inline void msg_set_adv_win(struct tipc_msg *m, u16 n) 958 { 959 msg_set_bits(m, 9, 0, 0xffff, n); 960 } 961 962 static inline u32 msg_max_pkt(struct tipc_msg *m) 963 { 964 return msg_bits(m, 9, 16, 0xffff) * 4; 965 } 966 967 static inline void msg_set_max_pkt(struct tipc_msg *m, u32 n) 968 { 969 msg_set_bits(m, 9, 16, 0xffff, (n / 4)); 970 } 971 972 static inline u32 msg_link_tolerance(struct tipc_msg *m) 973 { 974 return msg_bits(m, 9, 0, 0xffff); 975 } 976 977 static inline void msg_set_link_tolerance(struct tipc_msg *m, u32 n) 978 { 979 msg_set_bits(m, 9, 0, 0xffff, n); 980 } 981 982 static inline u16 msg_grp_bc_syncpt(struct tipc_msg *m) 983 { 984 return msg_bits(m, 9, 16, 0xffff); 985 } 986 987 static inline void msg_set_grp_bc_syncpt(struct tipc_msg *m, u16 n) 988 { 989 msg_set_bits(m, 9, 16, 0xffff, n); 990 } 991 992 static inline u16 msg_grp_bc_acked(struct tipc_msg *m) 993 { 994 return msg_bits(m, 9, 16, 0xffff); 995 } 996 997 static inline void msg_set_grp_bc_acked(struct tipc_msg *m, u16 n) 998 { 999 msg_set_bits(m, 9, 16, 0xffff, n); 1000 } 1001 1002 static inline u16 msg_grp_remitted(struct tipc_msg *m) 1003 { 1004 return msg_bits(m, 9, 16, 0xffff); 1005 } 1006 1007 static inline void msg_set_grp_remitted(struct tipc_msg *m, u16 n) 1008 { 1009 msg_set_bits(m, 9, 16, 0xffff, n); 1010 } 1011 1012 /* Word 10 1013 */ 1014 static inline u16 msg_grp_evt(struct tipc_msg *m) 1015 { 1016 return msg_bits(m, 10, 0, 0x3); 1017 } 1018 1019 static inline void msg_set_grp_evt(struct tipc_msg *m, int n) 1020 { 1021 msg_set_bits(m, 10, 0, 0x3, n); 1022 } 1023 1024 static inline u16 msg_grp_bc_ack_req(struct tipc_msg *m) 1025 { 1026 return msg_bits(m, 10, 0, 0x1); 1027 } 1028 1029 static inline void msg_set_grp_bc_ack_req(struct tipc_msg *m, bool n) 1030 { 1031 msg_set_bits(m, 10, 0, 0x1, n); 1032 } 1033 1034 static inline u16 msg_grp_bc_seqno(struct tipc_msg *m) 1035 { 1036 return msg_bits(m, 10, 16, 0xffff); 1037 } 1038 1039 static inline void msg_set_grp_bc_seqno(struct tipc_msg *m, u32 n) 1040 { 1041 msg_set_bits(m, 10, 16, 0xffff, n); 1042 } 1043 1044 static inline bool msg_peer_link_is_up(struct tipc_msg *m) 1045 { 1046 if (likely(msg_user(m) != LINK_PROTOCOL)) 1047 return true; 1048 if (msg_type(m) == STATE_MSG) 1049 return true; 1050 return false; 1051 } 1052 1053 static inline bool msg_peer_node_is_up(struct tipc_msg *m) 1054 { 1055 if (msg_peer_link_is_up(m)) 1056 return true; 1057 return msg_redundant_link(m); 1058 } 1059 1060 static inline bool msg_is_reset(struct tipc_msg *hdr) 1061 { 1062 return (msg_user(hdr) == LINK_PROTOCOL) && (msg_type(hdr) == RESET_MSG); 1063 } 1064 1065 /* Word 13 1066 */ 1067 static inline void msg_set_peer_net_hash(struct tipc_msg *m, u32 n) 1068 { 1069 msg_set_word(m, 13, n); 1070 } 1071 1072 static inline u32 msg_peer_net_hash(struct tipc_msg *m) 1073 { 1074 return msg_word(m, 13); 1075 } 1076 1077 /* Word 14 1078 */ 1079 static inline u32 msg_sugg_node_addr(struct tipc_msg *m) 1080 { 1081 return msg_word(m, 14); 1082 } 1083 1084 static inline void msg_set_sugg_node_addr(struct tipc_msg *m, u32 n) 1085 { 1086 msg_set_word(m, 14, n); 1087 } 1088 1089 static inline void msg_set_node_id(struct tipc_msg *hdr, u8 *id) 1090 { 1091 memcpy(msg_data(hdr), id, 16); 1092 } 1093 1094 static inline u8 *msg_node_id(struct tipc_msg *hdr) 1095 { 1096 return (u8 *)msg_data(hdr); 1097 } 1098 1099 struct sk_buff *tipc_buf_acquire(u32 size, gfp_t gfp); 1100 bool tipc_msg_validate(struct sk_buff **_skb); 1101 bool tipc_msg_reverse(u32 own_addr, struct sk_buff **skb, int err); 1102 void tipc_skb_reject(struct net *net, int err, struct sk_buff *skb, 1103 struct sk_buff_head *xmitq); 1104 void tipc_msg_init(u32 own_addr, struct tipc_msg *m, u32 user, u32 type, 1105 u32 hsize, u32 destnode); 1106 struct sk_buff *tipc_msg_create(uint user, uint type, uint hdr_sz, 1107 uint data_sz, u32 dnode, u32 onode, 1108 u32 dport, u32 oport, int errcode); 1109 int tipc_buf_append(struct sk_buff **headbuf, struct sk_buff **buf); 1110 bool tipc_msg_try_bundle(struct sk_buff *tskb, struct sk_buff **skb, u32 mss, 1111 u32 dnode, bool *new_bundle); 1112 bool tipc_msg_extract(struct sk_buff *skb, struct sk_buff **iskb, int *pos); 1113 int tipc_msg_fragment(struct sk_buff *skb, const struct tipc_msg *hdr, 1114 int pktmax, struct sk_buff_head *frags); 1115 int tipc_msg_build(struct tipc_msg *mhdr, struct msghdr *m, 1116 int offset, int dsz, int mtu, struct sk_buff_head *list); 1117 int tipc_msg_append(struct tipc_msg *hdr, struct msghdr *m, int dlen, 1118 int mss, struct sk_buff_head *txq); 1119 bool tipc_msg_lookup_dest(struct net *net, struct sk_buff *skb, int *err); 1120 bool tipc_msg_assemble(struct sk_buff_head *list); 1121 bool tipc_msg_reassemble(struct sk_buff_head *list, struct sk_buff_head *rcvq); 1122 bool tipc_msg_pskb_copy(u32 dst, struct sk_buff_head *msg, 1123 struct sk_buff_head *cpy); 1124 void __tipc_skb_queue_sorted(struct sk_buff_head *list, u16 seqno, 1125 struct sk_buff *skb); 1126 bool tipc_msg_skb_clone(struct sk_buff_head *msg, struct sk_buff_head *cpy); 1127 1128 static inline u16 buf_seqno(struct sk_buff *skb) 1129 { 1130 return msg_seqno(buf_msg(skb)); 1131 } 1132 1133 static inline int buf_roundup_len(struct sk_buff *skb) 1134 { 1135 return (skb->len / 1024 + 1) * 1024; 1136 } 1137 1138 /* tipc_skb_peek(): peek and reserve first buffer in list 1139 * @list: list to be peeked in 1140 * Returns pointer to first buffer in list, if any 1141 */ 1142 static inline struct sk_buff *tipc_skb_peek(struct sk_buff_head *list, 1143 spinlock_t *lock) 1144 { 1145 struct sk_buff *skb; 1146 1147 spin_lock_bh(lock); 1148 skb = skb_peek(list); 1149 if (skb) 1150 skb_get(skb); 1151 spin_unlock_bh(lock); 1152 return skb; 1153 } 1154 1155 /* tipc_skb_peek_port(): find a destination port, ignoring all destinations 1156 * up to and including 'filter'. 1157 * Note: ignoring previously tried destinations minimizes the risk of 1158 * contention on the socket lock 1159 * @list: list to be peeked in 1160 * @filter: last destination to be ignored from search 1161 * Returns a destination port number, of applicable. 1162 */ 1163 static inline u32 tipc_skb_peek_port(struct sk_buff_head *list, u32 filter) 1164 { 1165 struct sk_buff *skb; 1166 u32 dport = 0; 1167 bool ignore = true; 1168 1169 spin_lock_bh(&list->lock); 1170 skb_queue_walk(list, skb) { 1171 dport = msg_destport(buf_msg(skb)); 1172 if (!filter || skb_queue_is_last(list, skb)) 1173 break; 1174 if (dport == filter) 1175 ignore = false; 1176 else if (!ignore) 1177 break; 1178 } 1179 spin_unlock_bh(&list->lock); 1180 return dport; 1181 } 1182 1183 /* tipc_skb_dequeue(): unlink first buffer with dest 'dport' from list 1184 * @list: list to be unlinked from 1185 * @dport: selection criteria for buffer to unlink 1186 */ 1187 static inline struct sk_buff *tipc_skb_dequeue(struct sk_buff_head *list, 1188 u32 dport) 1189 { 1190 struct sk_buff *_skb, *tmp, *skb = NULL; 1191 1192 spin_lock_bh(&list->lock); 1193 skb_queue_walk_safe(list, _skb, tmp) { 1194 if (msg_destport(buf_msg(_skb)) == dport) { 1195 __skb_unlink(_skb, list); 1196 skb = _skb; 1197 break; 1198 } 1199 } 1200 spin_unlock_bh(&list->lock); 1201 return skb; 1202 } 1203 1204 /* tipc_skb_queue_splice_tail - append an skb list to lock protected list 1205 * @list: the new list to append. Not lock protected 1206 * @head: target list. Lock protected. 1207 */ 1208 static inline void tipc_skb_queue_splice_tail(struct sk_buff_head *list, 1209 struct sk_buff_head *head) 1210 { 1211 spin_lock_bh(&head->lock); 1212 skb_queue_splice_tail(list, head); 1213 spin_unlock_bh(&head->lock); 1214 } 1215 1216 /* tipc_skb_queue_splice_tail_init - merge two lock protected skb lists 1217 * @list: the new list to add. Lock protected. Will be reinitialized 1218 * @head: target list. Lock protected. 1219 */ 1220 static inline void tipc_skb_queue_splice_tail_init(struct sk_buff_head *list, 1221 struct sk_buff_head *head) 1222 { 1223 struct sk_buff_head tmp; 1224 1225 __skb_queue_head_init(&tmp); 1226 1227 spin_lock_bh(&list->lock); 1228 skb_queue_splice_tail_init(list, &tmp); 1229 spin_unlock_bh(&list->lock); 1230 tipc_skb_queue_splice_tail(&tmp, head); 1231 } 1232 1233 /* __tipc_skb_dequeue() - dequeue the head skb according to expected seqno 1234 * @list: list to be dequeued from 1235 * @seqno: seqno of the expected msg 1236 * 1237 * returns skb dequeued from the list if its seqno is less than or equal to 1238 * the expected one, otherwise the skb is still hold 1239 * 1240 * Note: must be used with appropriate locks held only 1241 */ 1242 static inline struct sk_buff *__tipc_skb_dequeue(struct sk_buff_head *list, 1243 u16 seqno) 1244 { 1245 struct sk_buff *skb = skb_peek(list); 1246 1247 if (skb && less_eq(buf_seqno(skb), seqno)) { 1248 __skb_unlink(skb, list); 1249 return skb; 1250 } 1251 return NULL; 1252 } 1253 1254 #endif 1255